marsultor/email-tracker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

should be it

Browse Source
This commit is contained in:
Mars Ultor
2025-10-24 19:21:19 -05:00
parent a4b23fc57c
commit f09560c7b1
14047 changed files with 3161551 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

868
external/duckdb/extension/tpcds/dsdgen/dsdgen-c/r_params.cpp vendored Normal file
View File

@@ -0,0 +1,868 @@
/*
* Legal Notice
*
* This document and associated source code (the "Work") is a part of a
* benchmark specification maintained by the TPC.
*
* The TPC reserves all right, title, and interest to the Work as provided
* under U.S. and international laws, including without limitation all patent
* and trademark rights therein.
*
* No Warranty
*
* 1.1 TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THE INFORMATION
* CONTAINED HEREIN IS PROVIDED "AS IS" AND WITH ALL FAULTS, AND THE
* AUTHORS AND DEVELOPERS OF THE WORK HEREBY DISCLAIM ALL OTHER
* WARRANTIES AND CONDITIONS, EITHER EXPRESS, IMPLIED OR STATUTORY,
* INCLUDING, BUT NOT LIMITED TO, ANY (IF ANY) IMPLIED WARRANTIES,
* DUTIES OR CONDITIONS OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
* PURPOSE, OF ACCURACY OR COMPLETENESS OF RESPONSES, OF RESULTS, OF
* WORKMANLIKE EFFORT, OF LACK OF VIRUSES, AND OF LACK OF NEGLIGENCE.
* ALSO, THERE IS NO WARRANTY OR CONDITION OF TITLE, QUIET ENJOYMENT,
* QUIET POSSESSION, CORRESPONDENCE TO DESCRIPTION OR NON-INFRINGEMENT
* WITH REGARD TO THE WORK.
* 1.2 IN NO EVENT WILL ANY AUTHOR OR DEVELOPER OF THE WORK BE LIABLE TO
* ANY OTHER PARTY FOR ANY DAMAGES, INCLUDING BUT NOT LIMITED TO THE
* COST OF PROCURING SUBSTITUTE GOODS OR SERVICES, LOST PROFITS, LOSS
* OF USE, LOSS OF DATA, OR ANY INCIDENTAL, CONSEQUENTIAL, DIRECT,
* INDIRECT, OR SPECIAL DAMAGES WHETHER UNDER CONTRACT, TORT, WARRANTY,
* OR OTHERWISE, ARISING IN ANY WAY OUT OF THIS OR ANY OTHER AGREEMENT
* RELATING TO THE WORK, WHETHER OR NOT SUCH AUTHOR OR DEVELOPER HAD
* ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.
*
* Contributors:
* Gradient Systems
*/
/*
* parameter handling functions
*/
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "config.h"
#include "porting.h"
#include "r_params.h"
#include "tdefs.h"
#include "release.h"
#include <cassert>
#define PARAM_MAX_LEN 80
#ifndef TEST
extern option_t options[];
extern char *params[];
#else
option_t options[] = {{"PROG", OPT_STR | OPT_HIDE, 0, NULL, NULL, "tester"},
{"PARAMS", OPT_STR, 1, "read parameters from file <s>", read_file, ""},
{"DISTRIBUTIONS", OPT_STR, 2, "read distributions from file <s>", NULL, "tester_dist.idx"},
{"OUTDIR", OPT_STR, 3, "generate files in directory <s>", NULL, "./"},
{"VERBOSE", OPT_FLG, 4, "enable verbose output", NULL, "N"},
{"HELP", OPT_FLG, 5, "display this message", usage, "N"},
{"scale", OPT_INT, 6, "set scale to <i>", NULL, "1"},
NULL};
char *params[9];
#endif
#define MAX_LINE_LEN 120
#ifdef _WIN32
#define OPTION_START '/'
#else
#define OPTION_START '-'
#endif
int read_file(const char *param_name, const char *option);
int fnd_param(const char *name);
void print_params(void);
/*
* Routine: load_params()
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO:
* 20010621 JMS shared memory not yet implemented
*/
void load_params() {
/*
int i=0;
while (options[i].name != NULL)
{
load_param(i, GetSharedMemoryParam(options[i].index));
i++;
}
SetSharedMemoryStat(STAT_ROWCOUNT, get_int("STEP"), 0);
*/
return;
}
/*
* Routine: set_flag(int f)
* Purpose: set a toggle parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
void set_flg(const char *flag) {
int nParam;
init_params();
nParam = fnd_param(flag);
if (nParam >= 0)
strcpy(params[options[nParam].index], "Y");
return;
}
/*
* Routine: clr_flg(f)
* Purpose: clear a toggle parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
void clr_flg(const char *flag) {
int nParam;
init_params();
nParam = fnd_param(flag);
if (nParam >= 0)
strcpy(params[options[nParam].index], "N");
return;
}
/*
* Routine: is_set(int f)
* Purpose: return the state of a toggle parameter, or whether or not a string
* or int parameter has been set Algorithm: Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int is_set(const char *flag) {
int nParam, bIsSet = 0;
init_params();
nParam = fnd_param(flag);
if (nParam >= 0) {
if ((options[nParam].flags & TYPE_MASK) == OPT_FLG)
bIsSet = (params[options[nParam].index][0] == 'Y') ? 1 : 0;
else
bIsSet = (options[nParam].flags & OPT_SET) || (strlen(options[nParam].dflt) > 0);
}
return (bIsSet); /* better a false negative than a false positive ? */
}
/*
* Routine: set_int(int var, char *value)
* Purpose: set an integer parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
void set_int(const char *var, const char *val) {
int nParam;
init_params();
nParam = fnd_param(var);
if (nParam >= 0) {
strcpy(params[options[nParam].index], val);
options[nParam].flags |= OPT_SET;
}
return;
}
/*
* Routine: get_int(char *var)
* Purpose: return the value of an integer parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int get_int(const char *var) {
int nParam;
init_params();
nParam = fnd_param(var);
if (nParam >= 0)
return (atoi(params[options[nParam].index]));
else
return (0);
}
double get_dbl(const char *var) {
int nParam;
init_params();
nParam = fnd_param(var);
if (nParam >= 0)
return (atof(params[options[nParam].index]));
else
return (0);
}
/*
* Routine: set_str(int var, char *value)
* Purpose: set a character parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
void set_str(const char *var, const char *val) {
int nParam;
init_params();
nParam = fnd_param(var);
if (nParam >= 0) {
strcpy(params[options[nParam].index], val);
options[nParam].flags |= OPT_SET;
}
return;
}
/*
* Routine: get_str(char * var)
* Purpose: return the value of a character parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
char *get_str(const char *var) {
int nParam;
init_params();
nParam = fnd_param(var);
if (nParam >= 0)
return (params[options[nParam].index]);
else
return (NULL);
}
/*
* Routine: init_params(void)
* Purpose: initialize a parameter set, setting default values
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int init_params(void) {
int i;
if (InitConstants::init_params_init)
return (0);
for (i = 0; options[i].name != NULL; i++) {
params[options[i].index] = (char *)malloc(PARAM_MAX_LEN * sizeof(char));
MALLOC_CHECK(params[options[i].index]);
strncpy(params[options[i].index], options[i].dflt, 80);
if (*options[i].dflt)
options[i].flags |= OPT_DFLT;
}
InitConstants::init_params_init = 1;
return (0);
}
/*
* Routine: print_options(struct OPTION_T *o, int file, int depth)
* Purpose: print a summary of options
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
static void print_options(struct OPTION_T *o, int bShowOptional) {
int i, w_adjust, bShow = 0, nCount = 0;
for (i = 0; options[i].name != NULL; i++) {
/*
* options come in two groups, general and "hidden". Decide which group
* to show in this pass, and ignore others
*/
bShow = 0;
if (bShowOptional && (o[i].flags & OPT_ADV))
bShow = 1;
if (!bShowOptional && !(o[i].flags & OPT_ADV))
bShow = 1;
if (!bShow || (o[i].flags & OPT_HIDE))
continue;
nCount += 1;
printf("%s = ", o[i].name);
w_adjust = 15 - strlen(o[i].name);
if (o[i].flags & OPT_INT)
printf(" <n> ");
else if (o[i].flags & OPT_STR)
printf(" <s> ");
else if (o[i].flags & OPT_SUB)
printf(" <opt> ");
else if (o[i].flags & OPT_FLG)
printf(" [Y|N] ");
else
printf(" ");
printf("%*s-- %s", w_adjust, " ", o[i].usage);
if (o[i].flags & OPT_NOP)
printf(" NOT IMPLEMENTED");
printf("\n");
}
if (nCount == 0)
printf("None defined.\n");
return;
}
/*
* Routine: save_file(char *path)
* Purpose: print a summary of options
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int save_file(const char *path) {
int i, w_adjust;
FILE *ofp;
time_t timestamp;
init_params();
time(&timestamp);
if ((ofp = fopen(path, "w")) == NULL)
return (-1);
fprintf(ofp, "--\n-- %s Benchmark Parameter File\n-- Created: %s", get_str("PROG"), ctime(&timestamp));
fprintf(ofp, "--\n-- Each entry is of the form: '<parameter> = <value> -- "
"optional comment'\n");
fprintf(ofp, "-- Refer to benchmark documentation for more details\n--\n");
for (i = 0; options[i].name != NULL; i++) {
if (options[i].flags & OPT_HIDE) /* hidden option */
continue;
if (strlen(params[options[i].index]) == 0)
continue;
fprintf(ofp, "%s = ", options[i].name);
w_adjust = strlen(options[i].name) + 3;
if (options[i].flags & OPT_STR) {
fprintf(ofp, "\"%s\"", params[options[i].index]);
w_adjust += 2;
} else
fprintf(ofp, "%s", params[options[i].index]);
w_adjust += strlen(params[options[i].index]) + 3;
w_adjust = 60 - w_adjust;
fprintf(ofp, "%*s-- %s", w_adjust, " ", options[i].usage);
if (options[i].flags & OPT_NOP)
fprintf(ofp, " NOT IMPLEMENTED");
fprintf(ofp, "\n");
}
fclose(ofp);
return (0);
}
/*
* Routine: usage(char *param_name, char *msg)
* Purpose: display a usage message, with an optional error message
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int usage(const char *param_name, const char *msg) {
init_params();
fprintf(stderr, "%s Population Generator (Version %d.%d.%d%s)\n", get_str("PROG"), VERSION, RELEASE, MODIFICATION,
PATCH);
fprintf(stderr, "Copyright %s %s\n", COPYRIGHT, C_DATES);
if (msg != NULL)
printf("\nERROR: %s\n\n", msg);
printf("\n\nUSAGE: %s [options]\n", get_str("PROG"));
printf("\nNote: When defined in a parameter file (using -p), parmeters "
"should\n");
printf("use the form below. Each option can also be set from the command\n");
printf("line, using a form of '%cparam [optional argument]'\n", OPTION_START);
printf("Unique anchored substrings of options are also recognized, and \n");
printf("case is ignored, so '%csc' is equivalent to '%cSCALE'\n\n", OPTION_START, OPTION_START);
printf("General Options\n===============\n");
print_options(options, 0);
printf("\n");
printf("Advanced Options\n===============\n");
print_options(options, 1);
printf("\n");
exit((msg == NULL) ? 0 : 1);
}
/*
* Routine: set_option(int var, char *value)
* Purpose: set a particular parameter; main entry point for the module
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int set_option(const char *name, const char *param) {
printf("ERROR: set_option not supported");
assert(0);
exit(1);
// int res = 1;
// option_t *o;
// char parse_int[15];
// char *cp;
//
// init_params();
//
// res = fnd_param(name);
// if (res == -1)
// return (res);
//
// o = &options[res];
//
// if (o->flags & OPT_NOP) {
// printf("ERROR: Cannot accept %s.\tNot Implemented!\n", o->name);
// return (0);
// }
//
// /* option is already set from the command line or hard-coded */
// /* and doesn't allow multiple settings */
//
// switch (o->flags & TYPE_MASK) {
// case OPT_FLG:
// if ((param && (*param == 'Y' || *param == 'Y' || *param == OPTION_START)) || (param == NULL)) {
// if (o->action)
// if (o->action((char *)o->name, NULL) < 0)
// usage((char *)o->name, "Cannot process option");
// set_flg(name);
// } else
// clr_flg(name);
// res = 1;
// break;
// case OPT_INT:
// if (o->action) {
// if ((res = o->action((char *)o->name, param)) < 0)
// usage(NULL, "Bad parameter argument");
// else
// sprintf(parse_int, "%d", res);
// }
// set_int(name, (o->action) ? parse_int : param);
// res = 2;
// break;
// case OPT_STR:
// if (*param == '"') {
// cp = strchr((param + 1), '"');
// if (cp == NULL) /* non-terminated string literal */
// usage(NULL, "Non-terminated string");
// *cp = '\0';
// param += 1;
// } else {
// cp = strpbrk(param, " \t\n");
// if (cp != NULL)
// *cp = '\0';
// }
// if (o->action && strlen(param))
// if (o->action((char *)o->name, param) < 0)
// usage((char *)o->name, "Cannot process option");
// set_str(name, param);
// res = 2;
// break;
// default:
// fprintf(stderr, "Invalid option/type (%d/%s)\n", o->flags & TYPE_MASK, o->name);
// exit(0);
// break;
// }
//
// o->flags |= OPT_SET; /* marked as set */
//
// return (res);
}
/*
* Routine: process_options(int count, char **vector)
* Purpose: process a set of command line options
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: 20000309 need to return integer to allow processing of left-over args
*/
int process_options(int count, const char **vector) {
int option_num = 1, res = 1;
init_params();
while (option_num < count) {
if (*vector[option_num] == OPTION_START) {
if (option_num == (count - 1))
res = set_option(vector[option_num] + 1, NULL);
else
res = set_option(vector[option_num] + 1, vector[option_num + 1]);
}
if (res < 0) {
printf("ERROR: option '%s' or its argument unknown.\n", (vector[option_num] + 1));
usage(NULL, NULL);
exit(1);
} else
option_num += res;
}
#ifdef JMS
if (is_set("VERBOSE"))
print_params();
#endif
return (option_num);
}
/*
* Routine: read_file(char *param_name, char *fname)
* Purpose: process a parameter file
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int read_file(const char *param_name, const char *optarg) {
FILE *fp;
char *cp;
char line[MAX_LINE_LEN];
char name[100];
int index;
init_params();
if ((fp = fopen(optarg, "r")) == NULL)
return (-1);
while (fgets(line, MAX_LINE_LEN, fp) != NULL) {
if ((cp = strchr(line, '\n')) != NULL)
*cp = '\0';
if ((cp = strchr(line, '-')) != NULL)
if (*(cp + 1) == '-')
*cp = '\0';
if ((cp = strtok(line, " \t=\n")) != NULL) {
strcpy(name, cp);
index = fnd_param(name);
if (index == -1)
continue; /* JMS: errors are silently ignored */
cp += strlen(cp) + 1;
while (*cp && strchr(" \t =", *cp))
cp++;
/* command line options over-ride those in a file */
if (options[index].flags & OPT_SET)
continue;
if (*cp) {
switch (options[index].flags & TYPE_MASK) {
case OPT_INT:
if ((cp = strtok(cp, " \t\n")) != NULL)
set_option(name, cp);
break;
case OPT_STR:
case OPT_FLG:
set_option(name, cp);
break;
}
}
}
}
fclose(fp);
return (0);
}
/*
* Routine: print_params(void)
* Purpose: print a parameter summary to display current settings
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
void print_params(void) {
int i;
init_params();
for (i = 0; options[i].name != NULL; i++)
if (options[i].name != NULL) {
printf("%s = ", options[i].name);
switch (options[i].flags & TYPE_MASK) {
case OPT_INT:
printf("%d\n", get_int((char *)options[i].name));
break;
case OPT_STR:
printf("%s\n", get_str((char *)options[i].name));
break;
case OPT_FLG:
printf("%c\n", is_set((char *)options[i].name) ? 'Y' : 'N');
break;
}
}
return;
}
/*
* Routine: fnd_param(char *name, int *type, char *value)
* Purpose: traverse the defined parameters, looking for a match
* Algorithm:
* Data Structures:
*
* Params:
* Returns: index of option
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int fnd_param(const char *name) {
int i, res = -1;
for (i = 0; options[i].name != NULL; i++) {
if (strncasecmp(name, options[i].name, strlen(name)) == 0) {
if (res == -1)
res = i;
else
return (-1);
}
}
return (res);
}
/*
* Routine: GetParamName(int nParam)
* Purpose: Translate between a parameter index and its name
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
char *GetParamName(int nParam) {
init_params();
return (char *)(options[nParam].name);
}
/*
* Routine: GetParamValue(int nParam)
* Purpose: Retrieve a parameters string value based on an index
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
char *GetParamValue(int nParam) {
init_params();
return (params[options[nParam].index]);
}
/*
* Routine: load_param(char *szValue, int nParam)
* Purpose: Set a parameter based on an index
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int load_param(int nParam, const char *szValue) {
init_params();
if (options[nParam].flags & OPT_SET) /* already set from the command line */
return (0);
else
strcpy(params[options[nParam].index], szValue);
return (0);
}
/*
* Routine: IsIntParam(char *szValue, int nParam)
* Purpose: Boolean test for integer parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int IsIntParam(const char *szParam) {
int nParam;
if ((nParam = fnd_param(szParam)) == -1)
return (nParam);
return ((options[nParam].flags & OPT_INT) ? 1 : 0);
}
/*
* Routine: IsStrParam(char *szValue, int nParam)
* Purpose: Boolean test for string parameter
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int IsStrParam(const char *szParam) {
int nParam;
if ((nParam = fnd_param(szParam)) == -1)
return (nParam);
return ((options[nParam].flags & OPT_STR) ? 1 : 0);
}
#ifdef TEST
main() {
init_params();
set_int("SCALE", "7");
set_flg("VERBOSE");
set_str("DISTRIBUTIONS", "'some file name'");
print_params();
set_int("s", "8");
clr_flg("VERBOSE");
printf("DIST is %s\n", get_str("DISTRIBUTIONS"));
print_params();
usage(NULL, NULL);
}
#endif /* TEST_PARAMS */