main(int argc, char* argv[]) { process_argument(argc-1, &argv[1]); if(exe_filename==0) display_help(); else execute(exe_filename, input_filename, output_filename, time_limit); }
bool console_argument_parser_c::parse(abstract_settings_parser_c &parser_object) { console_argument_parser_c::parser_object = &parser_object; last_state = argument_error_state; if (process_argument(parser_object.get_next_argument()) == argument_error_state) { return false; } while (last_state == argument_started_state) { process_value(parser_object.get_next_argument()); } return last_state == argument_ok_state; }
/** * Parse commandline options. This is similar to getopt_long, but with some modifications. * It WILL modify the argv by cleaning the arguments. This makes it easier to process. */ void saffire_parse_options(int argc, char **argv, struct saffire_option *options[]) { int found; // Iterate all arguments for (int idx=0; idx != argc; idx++) { found = 0; struct saffire_option *opt = options[0]; while (opt && opt->longname != NULL) { if (argv[idx] && argv[idx][0] == '-' && argv[idx][1] == '-') { // Long option found (--option) if (! strcasecmp(argv[idx]+2, opt->longname)) { process_argument(idx, argc, argv, opt); found = 1; } } else if (argv[idx] && argv[idx][0] == '-' && argv[idx][1] != '-' && argv[idx][2] == '\0') { // Short option found (-o) if (! strcasecmp(argv[idx]+1, opt->shortname)) { process_argument(idx, argc, argv, opt); found = 1; } } else { // Open argument. Just skip this argument found = 1; } opt++; } // Unknown option found if (! found) { printf("saffire: invalid option '%s'\n" "Try 'saffire help config' for more information\n", argv[idx]); exit(1); } } }
void process_block_decl(char **decl, int nlines) { char *name,*cur,*region_name,operand_name[40]; struct memory_region *bytes, *operands; initialize(); sprintf(operand_name,"ops%i",operand_region_counter++); cur = decl[0]+1; eat_whitespace(&cur); name=grab_identifier(&cur); region_name = bytecode_malloc(strlen(name)+2); strcpy(region_name,"#"); strcat(region_name,name); bytes = mr_new(region_name,3 + (nlines+17)/8); operands = mr_new(operand_name,nlines*2); mr_mark_ptr(bytes,1,operands); bytes->data[0] = 0; int current_operand = 0; int current_byte = 0; int current_word = 2; int i; uint64_t word = 0; char *byte = (char *)&word; for(i=1;i<nlines;i++) { char *cur_line = decl[i]; *byte++ = get_bytecode(&cur_line); cur_line++; eat_whitespace(&cur_line); while(*cur_line != '\0') { process_argument(operands,¤t_operand,&cur_line); eat_whitespace(&cur_line); } if(++current_byte==8) { current_byte = 0; bytes->data[current_word] = word; byte = (char *)&word; current_word++; word = 0; } } bytes->data[current_word] = word; bytes->data[current_word+1] = 0; *byte = 0; }
int main(int argc, char **argv) { int opt; if ((uid = getuid()) == 0) { fprintf(stderr, "don't run %s as root, use:\n echo", argv[0]); for (optind = 0; optind < argc; optind++) { fprintf(stderr, " %s", argv[optind]); } fprintf(stderr, " | nice -5 su -m man\n"); exit(1); } while ((opt = getopt(argc, argv, "vnfLrh")) != -1) { switch (opt) { case 'f': force++; break; case 'L': determine_locale(); break; case 'n': pretend++; break; case 'r': rm_junk++; break; case 'v': verbose++; break; default: usage(); /* NOTREACHED */ } } if ((starting_dir = open(".", 0)) < 0) { err(1, "."); } umask(022); signal(SIGINT, trap_signal); signal(SIGHUP, trap_signal); signal(SIGQUIT, trap_signal); signal(SIGTERM, trap_signal); if ((machine = getenv("MACHINE")) == NULL) { static struct utsname utsname; if (uname(&utsname) == -1) err(1, "uname"); machine = utsname.machine; } if ((machine_arch = getenv("MACHINE_ARCH")) == NULL) machine_arch = MACHINE_ARCH; if (optind == argc) { const char *manpath = getenv("MANPATH"); if (manpath == NULL) manpath = DEFAULT_MANPATH; process_argument(manpath); } else { while (optind < argc) process_argument(argv[optind++]); } exit(exit_code); }
/* The argument has been expressed in a long-form, i.e. prefixed * by -- * Decode and act on the argument. * The associated_value will only be required by some arguments. * Return whether one or both were required. */ int process_long_form_argument(const char *argument, const char *associated_value) { if(stringcompare(argument, "addhashcode") == 0) { GlobalState.add_hashcode_tag = TRUE; return 1; } else if(stringcompare(argument, "append") == 0) { process_argument(APPEND_TO_OUTPUT_FILE_ARGUMENT, associated_value); return 2; } else if(stringcompare(argument, "checkfile") == 0) { process_argument(CHECK_FILE_ARGUMENT, associated_value); return 2; } else if(stringcompare(argument, "checkmate") == 0) { process_argument(MATCH_CHECKMATE_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "duplicates") == 0) { process_argument(DUPLICATES_FILE_ARGUMENT, associated_value); return 2; } else if(stringcompare(argument, "evaluation") == 0) { /* Output an evaluation is required with each move. */ GlobalState.output_evaluation = TRUE; return 1; } else if(stringcompare(argument, "fencomments") == 0) { /* Output an evaluation is required with each move. */ GlobalState.add_FEN_comments = TRUE; /* Turn off any separate setting of output_FEN_comment. */ GlobalState.output_FEN_string = FALSE; return 1; } else if(stringcompare(argument, "fuzzydepth") == 0) { /* Extract the depth. */ int depth = 0; if(sscanf(associated_value, "%d",&depth) == 1){ if(depth >= 0) { GlobalState.fuzzy_match_duplicates = TRUE; GlobalState.fuzzy_match_depth = depth; } else { fprintf(GlobalState.logfile, "--%s requires a number greater than or equal to zero.\n", argument); exit(1); } } else { fprintf(GlobalState.logfile, "--%s requires a number following it.\n", argument); exit(1); } return 2; } else if(stringcompare(argument, "help") == 0) { process_argument(HELP_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "keepbroken") == 0) { GlobalState.keep_broken_games = TRUE; return 1; } else if(stringcompare(argument, "linelength") == 0) { process_argument(LINE_WIDTH_ARGUMENT, associated_value); return 2; } else if(stringcompare(argument, "markmatches") == 0) { if(*associated_value != '\0') { GlobalState.add_position_match_comments = TRUE; GlobalState.position_match_comment = copy_string(associated_value); } else { fprintf(GlobalState.logfile, "--markmatches requires a comment string following it.\n"); exit(1); } return 2; } else if(stringcompare(argument, "nochecks") == 0) { GlobalState.keep_checks = FALSE; return 1; } else if(stringcompare(argument, "nocomments") == 0) { process_argument(DONT_KEEP_COMMENTS_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "noduplicates") == 0) { process_argument(DONT_KEEP_DUPLICATES_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "nofauxep") == 0) { GlobalState.suppress_redundant_ep_info = TRUE; return 1; } else if(stringcompare(argument, "nomovenumbers") == 0) { GlobalState.keep_move_numbers = FALSE; return 1; } else if(stringcompare(argument, "nonags") == 0) { process_argument(DONT_KEEP_NAGS_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "noresults") == 0) { GlobalState.keep_results = FALSE; return 1; } else if(stringcompare(argument, "notags") == 0) { if(GlobalState.tag_output_format == ALL_TAGS || GlobalState.tag_output_format == NO_TAGS) { GlobalState.tag_output_format = NO_TAGS; } else { fprintf(GlobalState.logfile, "--notags clashes with another argument.\n"); exit(1); } return 1; } else if(stringcompare(argument, "nounique") == 0) { process_argument(SUPPRESS_ORIGINALS_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "novars") == 0) { process_argument(DONT_KEEP_VARIATIONS_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "selectonly") == 0) { unsigned long selection = 0; /* Extract the selected match number. */ if(sscanf(associated_value, "%lu",&selection) == 1){ if(selection > 0) { GlobalState.matching_game_number = selection; } else { fprintf(GlobalState.logfile, "--%s requires a number greater than zero.\n", argument); exit(1); } } else { fprintf(GlobalState.logfile, "--%s requires a number greater than zero following it.\n", argument); exit(1); } return 2; } else if(stringcompare(argument, "output") == 0) { process_argument(WRITE_TO_OUTPUT_FILE_ARGUMENT, associated_value); return 2; } else if(stringcompare(argument, "plylimit") == 0) { int limit = 0; /* Extract the limit. */ if(sscanf(associated_value, "%d",&limit) == 1){ if(limit >= 0) { GlobalState.output_ply_limit = limit; } else { fprintf(GlobalState.logfile, "--%s requires a number greater than or equal to zero.\n", argument); exit(1); } } else { fprintf(GlobalState.logfile, "--%s requires a number following it.\n", argument); exit(1); } return 2; } else if(stringcompare(argument, "seven") == 0) { process_argument(SEVEN_TAG_ROSTER_ARGUMENT, ""); return 1; } else if(stringcompare(argument, "stalemate") == 0) { GlobalState.match_only_stalemate = TRUE; return 1; } else if(stringcompare(argument, "totalplycount") == 0) { GlobalState.output_total_plycount = TRUE; return 1; } else if(stringcompare(argument, "version") == 0) { fprintf(GlobalState.logfile, "pgn-extract %s\n", CURRENT_VERSION); exit(0); return 1; } else { fprintf(GlobalState.logfile, "Unrecognised long-form argument: --%s\n", argument); exit(1); return 1; } }
void read_args_file(const char *infile) { char *line; FILE *fp = fopen(infile,"r"); if(fp == NULL){ fprintf(GlobalState.logfile,"Cannot open %s for reading.\n",infile); exit(1); } else{ ArgType linetype = NO_ARGUMENT_MATCH; ArgType nexttype; while((line = read_line(fp)) != NULL){ if(blank_line(line)){ (void) free(line); continue; } nexttype = classify_arg(line); if(nexttype == NO_ARGUMENT_MATCH){ if(*line == argument_prefix[0]){ /* Treat the line as a source file name. */ add_filename_to_source_list(&line[1],NORMALFILE); } else if(linetype != NO_ARGUMENT_MATCH){ /* Handle the line. */ switch(linetype){ case MOVES_ARGUMENT: add_textual_variation_from_line(line); break; case POSITIONS_ARGUMENT: add_positional_variation_from_line(line); break; case TAGS_ARGUMENT: process_tag_line(infile,line); break; case TAG_ROSTER_ARGUMENT: process_roster_line(line); break; case ENDINGS_ARGUMENT: process_ending_line(line); (void) free(line); break; default: fprintf(GlobalState.logfile, "Internal error: unknown linetype %d in read_args_file\n", linetype); (void) free(line); exit(-1); } } else{ /* It should have been a line applying to the * current linetype. */ fprintf(GlobalState.logfile, "Missing argument type for line %s in the argument file.\n", line); exit(1); } } else{ switch(nexttype){ /* Arguments with a possible additional * argument value. * All of these apply only to the current * line in the argument file. */ case WRITE_TO_OUTPUT_FILE_ARGUMENT: case APPEND_TO_OUTPUT_FILE_ARGUMENT: case WRITE_TO_LOG_FILE_ARGUMENT: case APPEND_TO_LOG_FILE_ARGUMENT: case DUPLICATES_FILE_ARGUMENT: case USE_ECO_FILE_ARGUMENT: case CHECK_FILE_ARGUMENT: case FILE_OF_FILES_ARGUMENT: case BOUNDS_ARGUMENT: case GAMES_PER_FILE_ARGUMENT: case ECO_OUTPUT_LEVEL_ARGUMENT: case FILE_OF_ARGUMENTS_ARGUMENT: case NON_MATCHING_GAMES_ARGUMENT: case TAG_EXTRACTION_ARGUMENT: case LINE_WIDTH_ARGUMENT: case OUTPUT_FORMAT_ARGUMENT: process_argument(line[argument_prefix_len], &line[argument_prefix_len+1]); linetype = NO_ARGUMENT_MATCH; break; case LONG_FORM_ARGUMENT: { char *arg = &line[argument_prefix_len+1]; char *space = strchr(arg, ' '); if(space != NULL) { /* We need to drop an associated value from arg. */ int arglen = space - arg; char *just_arg = (char *) MallocOrDie(arglen + 1); strncpy(just_arg, arg, arglen); just_arg[arglen] = '\0'; process_long_form_argument(just_arg, skip_leading_spaces(space)); } else { process_long_form_argument(arg, ""); linetype = NO_ARGUMENT_MATCH; } } break; /* Arguments with no additional * argument value. * All of these apply only to the current * line in the argument file. */ case SEVEN_TAG_ROSTER_ARGUMENT: case HELP_ARGUMENT: case ALTERNATIVE_HELP_ARGUMENT: case DONT_KEEP_COMMENTS_ARGUMENT: case DONT_KEEP_DUPLICATES_ARGUMENT: case DONT_MATCH_PERMUTATIONS_ARGUMENT: case DONT_KEEP_NAGS_ARGUMENT: case OUTPUT_FEN_STRING_ARGUMENT: case CHECK_ONLY_ARGUMENT: case KEEP_SILENT_ARGUMENT: case USE_SOUNDEX_ARGUMENT: case MATCH_CHECKMATE_ARGUMENT: case SUPPRESS_ORIGINALS_ARGUMENT: case DONT_KEEP_VARIATIONS_ARGUMENT: case USE_VIRTUAL_HASH_TABLE_ARGUMENT: process_argument(line[argument_prefix_len],""); linetype = NO_ARGUMENT_MATCH; break; /* Arguments whose values persist beyond * the current line. */ case MOVES_ARGUMENT: case POSITIONS_ARGUMENT: case ENDINGS_ARGUMENT: case TAGS_ARGUMENT: case TAG_ROSTER_ARGUMENT: process_argument(line[argument_prefix_len], &line[argument_prefix_len+1]); /* Apply this type to subsequent lines. */ linetype = nexttype; break; default: linetype = nexttype; break; } (void) free(line); } } (void) fclose(fp); } }
int main(int argc, char* argv[]) { int return_val = 0, err; // // Install signal handler to perform cleanup before exit. // signal(SIGINT, (sig_fn_ptr) sigcleanup); signal(SIGHUP, (sig_fn_ptr) sigcleanup); signal(SIGTERM, (sig_fn_ptr) sigcleanup); if (argc < 2) { printf("\n%s\nNo parameters supplied. Entering interactive mode.\n" "For help on command line params, use --help switch.\n" "Hit Control-C at any time to exit program.\n", copyright_banner); read_arguments(); } else { for (int i = 1; i < argc; ) { i += process_argument(argv[i], argv[i+1]); } } if (display_help) { print_usage(); return 0; } if (testcount < 0 || testcount > 10000) { fatal("\nError: Test count value %d is out of range (0 - 10000)\n\n", testcount); } if (verifypasses < 1 || verifypasses > 100) { fatal("\nError: Verification passes value %d is out of range (1 - 100)\n\n", verifypasses); } if (filesize_MB < 1 || filesize_MB > 16777216) { fatal("\nError: Test file size %d is out of range (1 - 16777216)\n\n", filesize_MB); } // // In many operating systems it is advantageous to do file I/O in units of pages, // using buffers which start on page boundaries. Therefore we shall make the buffer // size a multiple of the page size and a multiple of the unit of work (uint32_t), // while trying to keep it at least as large as the bufsize_Mbytes constant. // pagesize = getpagesize(); uint32_t base_size = pagesize * sizeof(uint32_t); bufsize = ((0x100000 * bufsize_Mbytes) / base_size) + 1; bufsize = bufsize * base_size; // // For the purposes of the rest of the program, the buffer size is the number of uint32_ts // in a buffer, not the number of bytes. // bufsize /= sizeof(uint32_t); // // Translate the file size from megabytes to uint32_ts. // filesize = (off_t) filesize_MB * (1048576 / sizeof(uint32_t)); // // Create the log file. // logfile = fopen(logfilename, "a"); if (logfile == NULL) { fatal("Error: Couldn't open log file (%s).\n", logfilename); } time_t t = time(NULL); fprintf(logfile, "\n============================================================\n" "%s\n" "Start time: %s\n", copyright_banner, ctime(&t)); fprintf(logfile, "Test parameters:\n\t" "Test file size is %d megabytes\n\t", filesize_MB); fprintf(logfile, "%d%s test iteration%s\n\t", testcount, (testcount == 0) ? (" (infinite loop)") : (""), (testcount == 1) ? ("") : ("s") ); fprintf(logfile, "%d verification pass%s per test iteration\n", verifypasses, (verifypasses == 1) ? ("") : ("es") ); // // Test loop. // for (uint32_t testnum = 1; (testnum <= testcount) || (testcount == 0); testnum++) { print_and_log("\nBeginning test iteration #%d; creating test file...", testnum); putchar('\n'); process_testfile(CREATE, testfilename, filesize, testnum); fprintf(logfile, " (done)\n"); for (uint32_t pass = 1; pass <= verifypasses; pass++) { printf("Verifying integrity of test file, pass #%d\n", pass); err = process_testfile(VERIFY, testfilename, filesize, testnum); fprintf(logfile, "Completed test #%d verification pass #%d (%s)\n", testnum, pass, (err) ? "FAIL" : "OK"); if (err) { printf("Warning, corruption detected! Check logfile for details.\n"); return_val = 1; if (halt_on_error) { print_and_log("\nHalting test.\n"); fclose(logfile); logfile = NULL; return 1; } } } } print_and_log("\nFinished testing.\n\n"); // if (remove(testfilename)) { // print_and_log("Warning: test file could not be deleted!\n\n"); // } fclose(logfile); return return_val; }
int main(int argc, char** argv) { SETTINGS settings; int option_index = 1, ret, i, bits; #ifdef _WIN32 char CmdDir[MAX_PATH]; char *p; #endif memset(&settings, 0, sizeof(settings)); settings.first_file = 1; settings.radio = 1; settings.clip_prev = 1; settings.outbitwidth = 16; settings.format = WAV_NO_FMT; #ifdef _WIN32 /* Is this good enough? Or do we need to consider multi-byte codepages as * well? */ SetConsoleOutputCP(GetACP()); GetModuleFileName(NULL, CmdDir, MAX_PATH); p = strrchr(CmdDir, '\\') + 1; p[0] = '\0'; #endif while ((ret = getopt_long(argc, argv, ARG_STRING, long_options, &option_index)) != -1) { switch(ret) { case 0: if (!strcmp(long_options[option_index].name, "force")) { settings.force = 1; } else if (!strcmp(long_options[option_index].name, "undo-gain")) { settings.undo = 1; } else { fprintf(stderr, "Internal error parsing command line options\n"); exit(1); } break; case 'h': usage(); exit(0); break; case 'a': settings.audiophile = 1; break; case 'r': settings.radio = 1; break; case 'q': settings.adc = 1; break; case 'p': settings.no_offset = 1; break; case 'c': settings.apply_gain = 0; break; case 'x': settings.scale = 1; break; case 'y': settings.apply_gain = 1; settings.scale = 0; break; case 'w': settings.write_chunk = 1; break; case 's': settings.fast = 1; break; case 'o': settings.std_out = 1; break; #ifdef ENABLE_RECURSIVE case 'z': settings.recursive = 1; break; #endif case 'l': write_to_log = 1; #ifdef _WIN32 strcpy(log_file_name, CmdDir); strcat(log_file_name, LOG_NAME); #else strcpy(log_file_name, LOG_NAME); #endif break; case 'f': write_to_log = 1; strcpy(log_file_name, optarg); break; case 'n': settings.clip_prev = 0; break; case 'd': settings.need_to_process = 1; settings.dithering = 1; if(sscanf(optarg, "%d", &settings.shapingtype) != 1) { fprintf(stderr, "Warning: dither type %s not recognised, using default\n", optarg); break; } if (settings.shapingtype == 0) settings.dithering = 0; else if (settings.shapingtype == 1) settings.shapingtype = 0; else if (settings.shapingtype == 2) settings.shapingtype = 1; else if (settings.shapingtype == 3) settings.shapingtype = 2; else if (settings.shapingtype == 4) settings.shapingtype = 3; break; case 't': settings.limiter = 1; break; case 'g': if(sscanf(optarg, "%lf", &settings.man_gain) != 1) { fprintf(stderr, "Warning: manual gain %s not recognised, ignoring\n", optarg); break; } if(settings.man_gain < -20.0) { fprintf(stderr, "Warning: manual gain %s is out of range, " "applying gain of -20.0dB\n", optarg); settings.man_gain = -20.0; } else if(settings.man_gain > 12.0) { fprintf(stderr, "Warning: manual gain %s is out of range, " "applying gain of +12.0dB\n", optarg); settings.man_gain = 12.0; } break; case 'b': settings.need_to_process = 1; if(sscanf(optarg, "%d", &bits) != 1) { fprintf(stderr, "Warning: output format %s not recognised, using default\n", optarg); break; } if (bits == 1) { settings.outbitwidth = 8; settings.format = WAV_FMT_8BIT; break; } else if (bits == 2) { settings.outbitwidth = 16; settings.format = WAV_FMT_16BIT; break; } else if (bits == 3) { settings.outbitwidth = 24; settings.format = WAV_FMT_24BIT; break; } else if (bits == 4) { settings.outbitwidth = 32; settings.format = WAV_FMT_32BIT; break; } else if (bits == 5) { settings.outbitwidth = 32; settings.format = WAV_FMT_FLOAT; break; } else if (bits == 6) { settings.outbitwidth = 16; settings.format = WAV_FMT_AIFF; break; } else { fprintf(stderr, "Warning: output format %s not recognised, using default\n", optarg); break; } break; #ifdef _WIN32 case 'e': { char *p; int k; char * lpPart[MAX_PATH]={NULL}; settings.cmd = (char *) malloc(1024*8); /* 8Kb is XP's limit */ if (settings.cmd == NULL) { fprintf(stderr, "Failed to allocate memory for cmd...\n"); return 1; } p = settings.cmd; k = GetFullPathName(argv[optind - 1], 1024*8, p, lpPart); k = GetShortPathName(p, p, MAX_PATH); if (k == 0) { p += sprintf (p, "%s", argv[optind - 1]); } else { p += k; } for (k = optind; k < argc; ++k) { p += sprintf(p, " \"%s\"", argv[k]); } argc = optind; break; } #endif } } if (settings.undo == 1) { settings.write_chunk = 0; settings.no_offset = 1; } if (optind >= argc) { fprintf(stderr, _("No files specified.\n")); usage(); return EXIT_SUCCESS; } if (write_to_log) { write_log("Command line:\n\t"); for(i = 0; i < argc; i++) write_log("%s ", argv[i]); write_log("\n"); } if (!strcmp(argv[optind], "-")) { double track_peak, track_gain; double dc_offset; double offset; if (!get_gain("-", &track_peak, &track_gain, &dc_offset, &offset, &settings)) return -1; } else { for (i = optind; i < argc; ++i) { #ifdef ENABLE_RECURSIVE if (process_argument(argv[i], &settings) < 0) { free_list(settings.file_list); return EXIT_FAILURE; } #else if (add_to_list(&settings.file_list, argv[i]) < 0) return EXIT_FAILURE; #endif } /* Process files (perhaps remaining) in list */ ret = process_files(settings.file_list, &settings, "."); free_list(settings.file_list); settings.file_list = NULL; if (settings.cmd) free(settings.cmd); settings.cmd = NULL; } return (ret < 0) ? EXIT_FAILURE : EXIT_SUCCESS; }
int main(int argc, char *argv[]) { static const struct option long_opts[] = { /* commands */ {"inject", required_argument, NULL, c_INJECT}, {"remove", required_argument, NULL, c_REMOVE}, {"hexdump", required_argument, NULL, c_HEXDUMP}, /* options */ {"output", required_argument, NULL, o_OUTPUT}, /* flags */ {"force", no_argument, NULL, f_FORCE}, {"p8", no_argument, NULL, f_P8}, {"verbose", no_argument, NULL, f_VERBOSE}, {"help", no_argument, NULL, f_HELP}, {0, 0, 0, 0} }; static const char *short_opts = "I:R:H:o:fpvh"; int rc = EXIT_FAILURE; if (argc == 1) usage(args.short_name, false), exit(rc); int opt = 0, idx = 0; while ((opt = getopt_long(argc, argv, short_opts, long_opts, &idx)) != -1) if (process_argument(&args, opt, optarg) < 0) goto error; /* getopt_long doesn't know what to do with orphans, */ /* so we'll scoop them up here, and deal with them later */ while (optind < argc) if (process_option(&args, argv[optind++]) < 0) goto error; if (args.verbose == f_VERBOSE) args_dump(&args); if (validate_args(&args) < 0) goto error; if (process_args(&args) < 0) goto error; rc = EXIT_SUCCESS; if (false) { err_t *err; error: err = err_get(); assert(err != NULL); fprintf(stderr, "%s: %s : %s(%d) : (code=%d) %.*s\n", program_invocation_short_name, err_type_name(err), err_file(err), err_line(err), err_code(err), err_size(err), (char *)err_data(err)); } return rc; }
void _nasm_interface::parse_arguments(void) { std::string arg_str; size_t arg_count = 0, flag_iter; nasm_arguments::iterator arg_iter; TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_interface_lock); for(arg_iter = m_arguments.begin(); arg_iter != m_arguments.end(); ++arg_iter, ++arg_count) { if(arg_iter->empty()) { THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_UNEXPECTED_EMPTY_ARGUMENT, "%lu", arg_count); } arg_str = *arg_iter; if(arg_str.at(0) == FLAG_PREFIX) { arg_str.erase(arg_str.begin()); if(arg_str.empty()) { THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_INVALID_FLAG, "%s", (*arg_iter).c_str()); } if(arg_str.at(0) == FLAG_PREFIX) { arg_str.erase(arg_str.begin()); if(arg_str.empty()) { THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_INVALID_FLAG, "%s", (*arg_iter).c_str()); } TRANSFORM(tolower, arg_str); for(flag_iter = 0; flag_iter <= MAX_FLAG; ++flag_iter) { if(arg_str == FLAG_LONG_STRING(flag_iter)) { break; } } } else { TRANSFORM(tolower, arg_str); for(flag_iter = 0; flag_iter <= MAX_FLAG; ++flag_iter) { if(arg_str == FLAG_STRING(flag_iter)) { break; } } if(flag_iter > MAX_FLAG) { THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_UNKNOWN_FLAG, "%s", (*arg_iter).c_str()); } } process_argument(arg_iter, flag_iter); } else { if(!m_input_path.empty()) { THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_INPUT_PATH_REDEFINITION, "%s", (*arg_iter).c_str()); } m_input_path = arg_str; } } if(m_output_path.empty() && !m_input_path.empty() && !determine_base_path(m_output_path, m_input_path)) { THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_BASE_PATH_FAILURE, "%s", m_input_path.c_str()); } TRACE_EXIT("Return Value: 0x%x", NULL); }