void initSetValue(const char* varName, const char* value,
const char* moduleName,
int32_t lineno, int32_t filename) {
configVarType* configVar;
if (*varName == '\0') {
const char* message = "No variable name given";
chpl_error(message, lineno, filename);
}
configVar = lookupConfigVar(moduleName, varName);
if (configVar == NULL) {
const char* configName = ((moduleName == NULL || !strcmp(moduleName, ""))
? varName
: chpl_glom_strings(3,
moduleName, ".", varName));
const char* message = chpl_glom_strings(3, "attempt to set config named '",
configName,
"', but there is no such config");
chpl_error(message, lineno, filename);
} else if (configVar == ambiguousConfigVar) {
const char* message = chpl_glom_strings(5,
"Multiple modules define a config "
"named '", varName,
"'. Use '--help' for a list and "
"disambiguate using '<moduleName>.",
varName, "'.");
chpl_error(message, lineno, filename);
}
if (strcmp(varName, "numLocales") == 0) {
parseNumLocales(value, lineno, filename);
}
configVar->setValue = chpl_glom_strings(1, value);
}
// TODO: Change all the 0 linenos below into real line numbers
void parseConfigFile(const char* configFilename,
int32_t lineno, int32_t filename) {
FILE* argFile = fopen(configFilename, "r");
if (!argFile) {
char* message = chpl_glom_strings(2, "Unable to open ", configFilename);
chpl_error(message, lineno, filename);
}
chpl_saveFilename(configFilename); // CHPL_FILE_IDX_SAVED_FILENAME will now
// give us configFilename
while (!feof(argFile)) {
int numScans = 0;
char setConfigBuffer[_default_string_length];
numScans = fscanf(argFile, _default_format_read_string, setConfigBuffer);
if (numScans == 1) {
if (*setConfigBuffer == '#') {
if (!feof(argFile)) {
do {
char ch = fgetc(argFile);
if (ch == '\n')
break;
} while (!feof(argFile));
}
} else if (!aParsedString(argFile, setConfigBuffer, 0,
CHPL_FILE_IDX_SAVED_FILENAME)) {
char* equalsSign;
const char* moduleName;
char* varName;
configVarType *configVar =
breakIntoPiecesAndLookup(setConfigBuffer, &equalsSign, &moduleName,
&varName, 0, CHPL_FILE_IDX_SAVED_FILENAME);
if (configVar == NULL) {
handleUnexpectedConfigVar(moduleName, varName, 0,
CHPL_FILE_IDX_SAVED_FILENAME);
} else {
char* value = equalsSign + 1;
if (equalsSign && *value) {
initSetValue(varName, value, moduleName, 0,
CHPL_FILE_IDX_SAVED_FILENAME);
} else {
char configValBuffer[_default_string_length];
numScans =
fscanf(argFile, _default_format_read_string, configValBuffer);
if (numScans != 1) {
char *message =
chpl_glom_strings(3, "Configuration variable '", varName,
"' is missing its initialization value");
chpl_error(message, 0, CHPL_FILE_IDX_SAVED_FILENAME);
} else {
initSetValue(varName, configValBuffer, moduleName, 0,
CHPL_FILE_IDX_SAVED_FILENAME);
}
}
}
}
}
}
fclose(argFile);
}
int chpl_comm_run_in_gdb(int argc, char* argv[], int gdbArgnum, int* status) {
int i;
char* command = chpl_glom_strings(2, "gdb -q -ex 'break gdbShouldBreakHere' --args ",
argv[0]);
for (i=1; i<argc; i++) {
if (i != gdbArgnum) {
command = chpl_glom_strings(3, command, " ", argv[i]);
}
}
*status = mysystem(command, "running gdb", 0);
return 1;
}
static void handleUnexpectedConfigVar(const char* moduleName, char* varName,
int32_t lineno, int32_t filename) {
const char* message;
if (moduleName[0]) {
message = chpl_glom_strings(5, "Module '", moduleName,
"' has no configuration variable named '",
varName, "'");
} else if (varName[0]) {
message = chpl_glom_strings(3, "Unrecognized configuration variable '",
varName, "'");
} else {
message = "No configuration variable name specified";
}
chpl_error(message, lineno, filename);
}
static configVarType* breakIntoPiecesAndLookup(char* str, char** equalsSign,
const char** moduleName,
char** varName,
int32_t lineno,
int32_t filename) {
configVarType* configVar;
*equalsSign = strchr(str, '=');
if (*equalsSign) {
**equalsSign = '\0';
}
parseModVarName(str, moduleName, varName);
configVar = lookupConfigVar(*moduleName, *varName);
if (configVar == ambiguousConfigVar) {
const char* message = chpl_glom_strings(5, "Configuration variable '",
*varName,
"' is defined in more than one "
"module. Use '--help' for a list "
"of configuration variables and "
"'-s<module>.",
*varName, "' to disambiguate.");
chpl_error(message, lineno, filename);
}
return configVar;
}
static sbatchVersion determineQsubVersion(void) {
char version[versionBuffLen+1] = "";
char* versionPtr = version;
FILE* sysFile;
int i;
char* command = chpl_glom_strings(3, "sbatch --version > ", sysFilename, " 2>&1");
system(command);
sysFile = fopen(sysFilename, "r");
for (i=0; i<versionBuffLen; i++) {
char tmp;
fscanf(sysFile, "%c", &tmp);
if (tmp == '\n') {
*versionPtr++ = '\0';
break;
} else {
*versionPtr++ = tmp;
}
}
fclose(sysFile);
if (strstr(version, "NCCS")) {
return nccs;
} else if (strstr(version, "SBATCHPro")) {
return slurmpro;
} else if (strstr(version, "wrapper sbatch SBATCH UMA 1.0")) {
return uma;
} else if (strstr(version, "slurm")) {
return slurm;
} else if (strstr(version, "version: ")) {
return torque;
} else {
return unknown;
}
}
// TODO: Change all the 0 linenos below into real line numbers
void parseConfigFile(const char* configFilename,
int32_t lineno, chpl_string filename) {
FILE* argFile = fopen(configFilename, "r");
if (!argFile) {
char* message = chpl_glom_strings(2, "Unable to open ", configFilename);
chpl_error(message, lineno, filename);
}
while (!feof(argFile)) {
int numScans = 0;
char setConfigBuffer[_default_string_length];
numScans = fscanf(argFile, _default_format_read_string, setConfigBuffer);
if (numScans == 1) {
if (!aParsedString(argFile, setConfigBuffer, 0, configFilename)) {
char* equalsSign;
const char* moduleName;
char* varName;
configVarType* configVar = breakIntoPiecesAndLookup(setConfigBuffer,
&equalsSign,
&moduleName,
&varName,
0, configFilename);
if (configVar == NULL) {
handleUnexpectedConfigVar(moduleName, varName, 0, configFilename);
} else {
char* value = equalsSign + 1;
checkDeprecatedConfig(varName, equalsSign ? value : equalsSign);
if (equalsSign && *value) {
initSetValue(varName, value, moduleName, 0, configFilename);
} else {
char configValBuffer[_default_string_length];
numScans = fscanf(argFile, _default_format_read_string, configValBuffer);
if (numScans != 1) {
char* message = chpl_glom_strings(3, "Configuration variable '", varName,
"' is missing its initialization value");
chpl_error(message, 0, configFilename);
} else {
initSetValue(varName, configValBuffer, moduleName, 0, configFilename);
}
}
}
}
}
}
fclose(argFile);
}
void installConfigVar(const char* varName, const char* value,
const char* moduleName) {
unsigned hashValue;
configVarType* configVar = (configVarType*)
chpl_mem_allocMany(1, sizeof(configVarType), CHPL_RT_MD_CF_TABLE_DATA, 0, 0);
hashValue = hash(varName);
configVar->nextInBucket = configVarTable[hashValue];
configVar->nextInstalled = NULL;
configVarTable[hashValue] = configVar;
if (firstInTable == NULL) {
firstInTable = configVar;
} else {
lastInTable->nextInstalled = configVar;
}
lastInTable = configVar;
configVar->varName = chpl_glom_strings(1, varName);
configVar->moduleName = chpl_glom_strings(1, moduleName);
configVar->defaultValue = chpl_glom_strings(1, value);
configVar->setValue = NULL;
}
chpl_bool c_string_to_chpl_bool(c_string str, int lineno, c_string filename) {
if (string_compare(str, "true") == 0) {
return true;
} else if (string_compare(str, "false") == 0) {
return false;
} else {
const char* message =
chpl_glom_strings(3, "Unexpected value when converting from string to bool: '",
str, "'");
chpl_error(message, lineno, filename);
return false;
}
}
void parseNumLocales(const char* numPtr, int32_t lineno, c_string filename) {
int invalid;
char invalidChars[2] = "\0\0";
_argNumLocales = c_string_to_int32_t_precise(numPtr, &invalid, invalidChars);
if (invalid) {
char* message = chpl_glom_strings(3, "\"", numPtr,
"\" is not a valid number of locales");
chpl_error(message, lineno, filename);
}
if (_argNumLocales < 1) {
chpl_error("Number of locales must be greater than 0", lineno, filename);
}
}
int handleNonstandardArg(int* argc, char* argv[], int argNum,
int32_t lineno, int32_t filename) {
if (mainHasArgs) {
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = argv[argNum];
chpl_gen_main_arg.argc++;
} else {
char* message = chpl_glom_strings(3, "Unexpected flag: \"", argv[argNum], "\"");
chpl_error(message, lineno, filename);
}
return 0;
}
void initSetValue(const char* varName, const char* value,
const char* moduleName,
int32_t lineno, chpl_string filename) {
configVarType* configVar;
if (*varName == '\0') {
const char* message = "No variable name given";
chpl_error(message, lineno, filename);
}
configVar = lookupConfigVar(moduleName, varName);
if (configVar == NULL || configVar == ambiguousConfigVar) {
chpl_internal_error("unknown config var case not handled appropriately");
}
if (strcmp(varName, "numLocales") == 0) {
parseNumLocales(value, lineno, filename);
}
configVar->setValue = chpl_glom_strings(1, value);
}
int handlePossibleConfigVar(int* argc, char* argv[], int argnum,
int32_t lineno, chpl_string filename) {
int retval = 0;
int arglen = strlen(argv[argnum]+2)+1;
char* argCopy = chpl_mem_allocMany(arglen, sizeof(char),
CHPL_RT_MD_CONFIG_ARG_COPY_DATA, argnum,
"<command-line>");
char* equalsSign;
const char* moduleName;
char* varName;
configVarType* configVar;
strcpy(argCopy, argv[argnum]+2);
configVar = breakIntoPiecesAndLookup(argCopy, &equalsSign, &moduleName,
&varName, lineno, filename);
if (configVar == NULL) {
if (argv[argnum][1] == '-') { // this is a -- argument
retval = handleNonstandardArg(argc, argv, argnum, lineno, filename);
} else { // this is a -s argument
handleUnexpectedConfigVar(moduleName, varName, lineno, filename);
}
} else {
char* value = equalsSign + 1;
checkDeprecatedConfig(varName, equalsSign ? value : equalsSign);
if (equalsSign && *value) {
initSetValue(varName, value, moduleName, lineno, filename);
} else if (!strcmp(configVar->defaultValue, "bool")) {
initSetValue(varName, "true", moduleName, lineno, filename);
} else {
if (argnum + 1 >= *argc) {
char* message = chpl_glom_strings(3, "Configuration variable '", varName,
"' is missing its initialization value");
chpl_error(message, lineno, filename);
} else {
initSetValue(varName, argv[argnum+1], moduleName, lineno, filename);
retval = 1;
}
}
}
chpl_mem_free(argCopy, argnum, "<command-line>");
return retval;
}
int handleNonstandardArg(int* argc, char* argv[], int argNum,
int32_t lineno, int32_t filename) {
int numHandled = chpl_launch_handle_arg(*argc, argv, argNum,
lineno, filename);
if (numHandled == 0) {
if (mainHasArgs) {
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = argv[argNum];
chpl_gen_main_arg.argc++;
} else {
char* message;
message = chpl_glom_strings(3,"Unexpected flag: \"",argv[argNum],"\"");
chpl_error(message, lineno, filename);
}
return 0;
} else {
int i;
for (i=argNum+numHandled; i<*argc; i++) {
argv[i-numHandled] = argv[i];
}
*argc -= numHandled;
return -1; // back the cursor up in order to re-parse this arg
}
}
void parseArgs(chpl_bool isLauncher, chpl_parseArgsMode_t mode,
int* argc, char* argv[]) {
int i;
int printHelp = 0;
int printAbout = 0;
int origargc = *argc;
int stop_parsing = 0;
//
// Handle the pre-parse for '-E' arguments separately.
//
if (mode == parse_dash_E) {
assert(!isLauncher);
parseDashEArgs(argc, argv);
return;
}
for (i = 1; i < *argc; i++) {
const char* filename = "<command-line arg>";
int lineno = i + (origargc - *argc);
int argLength = 0;
const char* currentArg = argv[i];
argLength = strlen(currentArg);
if (mainHasArgs && (stop_parsing || argLength < 2)) {
/* update the argv structure passed to a Chapel program, but don't parse
* the arguments
*/
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = argv[i];
chpl_gen_main_arg.argc++;
continue;
}
/* if the Chapel main takes arguments, then "--" is a magic argument that
* will prevent parsing of any additional arguments
*/
if (mainHasArgs && strcmp(currentArg, "--") == 0) {
stop_parsing = 1;
continue;
}
if (argLength < 2) {
const char* message = chpl_glom_strings(3, "\"", currentArg,
"\" is not a valid argument");
chpl_error(message, lineno, filename);
}
switch (currentArg[0]) {
case '-':
switch (currentArg[1]) {
case '-':
{
const char* flag = currentArg + 2;
if (strcmp(flag, "gdb") == 0) {
gdbFlag = i;
break;
}
if (strcmp(flag, "help") == 0) {
printHelp = 1;
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = "--help";
chpl_gen_main_arg.argc++;
break;
}
if (strcmp(flag, "about") == 0) {
printAbout = 1;
break;
}
if (strcmp(flag, "verbose") == 0) {
verbosity=2;
break;
}
if (strcmp(flag, "blockreport") == 0) {
blockreport = 1;
break;
}
if (strcmp(flag, "taskreport") == 0) {
taskreport = 1;
break;
}
if (strcmp(flag, "quiet") == 0) {
verbosity = 0;
break;
}
if (argLength < 3) {
char* message = chpl_glom_strings(3, "\"", currentArg,
"\" is not a valid argument");
chpl_error(message, lineno, filename);
}
i += handlePossibleConfigVar(argc, argv, i, lineno, filename);
break;
}
case 'a':
if (currentArg[2] == '\0') {
printAbout = 1;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'b':
if (currentArg[2] == '\0') {
blockreport = 1;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'E':
if (isLauncher) {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
} else {
//
// We parse -E only in parse_dash_E mode, which is handled above.
//
if (currentArg[2] == '\0') {
i++;
}
}
break;
case 'f':
if (currentArg[2] == '\0') {
i++;
if (i >= *argc) {
chpl_error("-f flag is missing <filename> argument",
lineno, filename);
}
currentArg = argv[i];
parseConfigFile(currentArg, lineno, filename);
} else {
parseConfigFile(currentArg + 2, lineno, filename);
}
break;
case 'h':
if (currentArg[2] == '\0') {
printHelp = 1;
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = "-h";
chpl_gen_main_arg.argc++;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'n':
if (currentArg[2] == 'l') {
const char* numPtr;
if (currentArg[3] == '\0') {
i++;
if (i >= *argc) {
chpl_error("-nl flag is missing <numLocales> argument",
lineno, filename);
}
currentArg = argv[i];
numPtr = currentArg;
} else {
numPtr = &(currentArg[3]);
}
initSetValue("numLocales", numPtr, "Built-in", lineno, filename);
break;
}
i += handleNonstandardArg(argc, argv, i, lineno, filename);
break;
case 'q':
if (currentArg[2] == '\0') {
verbosity = 0;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 's':
{
if (argLength < 3) {
char* message = chpl_glom_strings(3, "\"", currentArg,
"\" is not a valid argument");
chpl_error(message, lineno, filename);
}
i += handlePossibleConfigVar(argc, argv, i, lineno, filename);
break;
}
case 't':
if (currentArg[2] == '\0') {
taskreport = 1;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'v':
if (currentArg[2] == '\0') {
verbosity = 2;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
default:
i += handleNonstandardArg(argc, argv, i, lineno, filename);
break;
}
break;
default:
i += handleNonstandardArg(argc, argv, i, lineno, filename);
break;
}
}
if (printAbout) {
chpl_program_about();
chpl_exit_any(0);
}
if (printHelp) {
if (!mainHasArgs) {
printHelpTable();
printConfigVarTable();
chpl_exit_any(0);
}
}
}
/* This function parses a config var of type string, and sets its value in
the hash table.
*/
static int aParsedString(FILE* argFile, char* setConfigBuffer,
int32_t lineno, int32_t filename) {
char* equalsSign = strchr(setConfigBuffer, '=');
int stringLength = strlen(setConfigBuffer);
char firstChar;
char* value;
char lastChar;
const char* moduleName;
char* varName;
if (!equalsSign || !(equalsSign + 1)) {
return 0;
}
firstChar = equalsSign[1];
if ((firstChar != '"') && (firstChar != '\'')) {
return 0;
}
value = equalsSign + 2;
*equalsSign = '\0';
lastChar = setConfigBuffer[stringLength - 1];
parseModVarName(setConfigBuffer, &moduleName, &varName);
if ((firstChar != lastChar) || (strlen(value) == 0)) {
int nextChar = fgetc(argFile);
do {
switch (nextChar) {
case EOF:
{
char* message;
setConfigBuffer[stringLength] = '\0';
message = chpl_glom_strings(2, "Found end of file while reading string: ",
equalsSign + 1);
chpl_error(message, lineno, filename);
break;
}
case '\n':
{
char* message;
setConfigBuffer[stringLength] = '\0';
message = chpl_glom_strings(2, "Found newline while reading string: ",
equalsSign + 1);
chpl_error(message, lineno, filename);
break;
}
default:
{
if (stringLength >= _default_string_length - 1) {
char dsl[1024];
char* message;
sprintf(dsl, "%d", _default_string_length);
message = chpl_glom_strings(2, "String exceeds the maximum string length of ",
dsl);
chpl_error(message, lineno, filename);
}
setConfigBuffer[stringLength] = nextChar;
stringLength++;
nextChar = fgetc(argFile);
}
}
} while (nextChar != firstChar);
} else {
stringLength--;
}
setConfigBuffer[stringLength] = '\0';
initSetValue(varName, value, moduleName, lineno, filename);
return 1;
}
