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);
}
