void test_argstr_basic_003(CuTest* tc) { struct arg_str* a = arg_str0(NULL, "hello,world", "STRVAL", "either --hello or --world or none"); struct arg_str* b = arg_str0("bB", NULL, "STRVAL", "either -b or -B or none"); struct arg_str* c = arg_str1("cC", NULL, "STRVAL", "either -c or -C"); struct arg_str* d = arg_strn("dD", "delta", "STRVAL", 2, 4, "-d|-D|--delta 2..4 occurences"); struct arg_end* end = arg_end(20); void* argtable[] = {a, b, c, d, end}; int nerrors; char* argv[] = {"program", "-Cstring1", "--delta=string2", "--delta=string3", NULL}; int argc = sizeof(argv) / sizeof(char*) - 1; CuAssertTrue(tc, arg_nullcheck(argtable) == 0); nerrors = arg_parse(argc, argv, argtable); if (nerrors > 0) arg_print_errors(stdout, end, argv[0]); CuAssertTrue(tc, nerrors == 0); CuAssertTrue(tc, a->count == 0); CuAssertTrue(tc, b->count == 0); CuAssertTrue(tc, c->count == 1); CuAssertStrEquals(tc, c->sval[0], "string1"); CuAssertTrue(tc, d->count == 2); CuAssertStrEquals(tc, d->sval[0], "string2"); CuAssertStrEquals(tc, d->sval[1], "string3"); arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0])); }
static int dslink_parse_opts(int argc, char **argv, DSLinkConfig *config) { int ret = 0; struct arg_lit *help; struct arg_str *broker, *log; struct arg_end *end; void *argTable[] = { help = arg_lit0("h", "help", "Displays this help menu"), broker = arg_str1("b", "broker", "url", "Sets the broker URL to connect to"), log = arg_str0("l", "log", "log type", "Sets the logging level"), end = arg_end(5) }; if (arg_nullcheck(argTable) != 0) { return DSLINK_ALLOC_ERR; } int errs = arg_parse(argc, argv, argTable); if (help->count > 0) { printf("Usage: <opts>\n"); arg_print_glossary(stdout, argTable, " %-25s %s\n"); ret = 1; goto exit; } if (errs > 0) { dslink_print_help(); arg_print_errors(stdout, end, ":"); ret = 1; goto exit; } config->broker_url = broker->sval[0]; if (log->count > 0) { char lvl[8]; const char *src = log->sval[0]; size_t len = strlen(src); if (len > sizeof(lvl)) { len = sizeof(lvl); } memcpy(lvl, src, len); if (dslink_log_set_lvl(lvl, len) != 0) { printf("Invalid log level: %s\n", lvl); dslink_print_help(); ret = 1; goto exit; } } exit: arg_freetable(argTable, sizeof(argTable) / sizeof(argTable[0])); return ret; }
merge_options_t *new_merge_cli_options() { merge_options_t *options = (merge_options_t*) malloc (sizeof(merge_options_t)); options->num_options = NUM_MERGE_OPTIONS; options->input_files = arg_str1(NULL, "vcf-list", NULL, "List of comma-separated input VCF files"); options->missing_mode = arg_str0(NULL, "missing-mode", NULL, "How to fill missing genotypes (missing = ./., reference = 0/0)"); options->info_fields = arg_str0(NULL, "info-fields", NULL, "Information to generate in the new INFO column"); options->copy_filter = arg_lit0(NULL, "copy-filter", "Whether to copy the FILTER column from the original files into the samples"); options->copy_info = arg_lit0(NULL, "copy-info", "Whether to copy the INFO column from the original files into the samples"); return options; }
void register_ethernet() { eth_event_group = xEventGroupCreate(); tcpip_adapter_init(); ESP_ERROR_CHECK(esp_event_loop_init(eth_event_handler, NULL)); eth_config_t config = DEFAULT_ETHERNET_PHY_CONFIG; config.phy_addr = CONFIG_PHY_ADDRESS; config.gpio_config = eth_gpio_config_rmii; config.tcpip_input = tcpip_adapter_eth_input; config.clock_mode = CONFIG_PHY_CLOCK_MODE; #ifdef CONFIG_PHY_USE_POWER_PIN /* Replace the default 'power enable' function with an example-specific one that toggles a power GPIO. */ config.phy_power_enable = phy_device_power_enable_via_gpio; #endif ESP_ERROR_CHECK(esp_eth_init(&config)); eth_control_args.control = arg_str1(NULL, NULL, "<start|stop|info>", "Start/Stop Ethernet or Get info of Ethernet"); eth_control_args.end = arg_end(1); const esp_console_cmd_t cmd = { .command = "ethernet", .help = "Control Ethernet interface", .hint = NULL, .func = eth_cmd_control, .argtable = ð_control_args }; ESP_ERROR_CHECK(esp_console_cmd_register(&cmd)); iperf_args.ip = arg_str0("c", "client", "<ip>", "run in client mode, connecting to <host>"); iperf_args.server = arg_lit0("s", "server", "run in server mode"); iperf_args.udp = arg_lit0("u", "udp", "use UDP rather than TCP"); iperf_args.port = arg_int0("p", "port", "<port>", "server port to listen on/connect to"); iperf_args.interval = arg_int0("i", "interval", "<interval>", "seconds between periodic bandwidth reports"); iperf_args.time = arg_int0("t", "time", "<time>", "time in seconds to transmit for (default 10 secs)"); iperf_args.abort = arg_lit0("a", "abort", "abort running iperf"); iperf_args.end = arg_end(1); const esp_console_cmd_t iperf_cmd = { .command = "iperf", .help = "iperf command", .hint = NULL, .func = ð_cmd_iperf, .argtable = &iperf_args }; ESP_ERROR_CHECK(esp_console_cmd_register(&iperf_cmd)); }
int main(int argc, char *argv[]) { struct arg_str *cblOpt = arg_str1("c", "cable", "nero:<VID>:<PID> | xil3 | dusb", "cable driver to use"); struct arg_lit *scanOpt = arg_lit0("s", "scan", " scan the JTAG chain"); struct arg_file *bitOpt = arg_file0("b", "bitfile", "<fileName>", " bit file to load"); struct arg_uint *devOpt = arg_uint0("d", "device", "<device>", " target device (default \"1\")"); struct arg_lit *helpOpt = arg_lit0("h", "help", " print this help and exit\n"); struct arg_end *endOpt = arg_end(20); void* argTable[] = {cblOpt, scanOpt, bitOpt, devOpt, helpOpt, endOpt}; const char *progName = "xilprg"; uint32 exitCode = 0; int numErrors; const char *cable, *bitFile; uint32 devNum; char line[1024]; char configFileName[4097]; // TODO: Fix, somehow. if ( arg_nullcheck(argTable) != 0 ) { fprintf(stderr, "%s: insufficient memory\n", progName); fail(1); } numErrors = arg_parse(argc, argv, argTable); if ( helpOpt->count > 0 ) { printf("Xilinx Programmer 0.6 Copyright (C) 2006-2011 Zoltan Csizmadia & Chris McClelland\n\nUsage: %s", progName); arg_print_syntax(stdout, argTable, "\n"); printf("\nProgram a Xilinx FPGA.\n\n"); arg_print_glossary(stdout, argTable," %-10s %s\n"); fail(0); } if ( numErrors > 0 ) { arg_print_errors(stdout, endOpt, progName); fprintf(stderr, "Try '%s --help' for more information.\n", progName); fail(2); } if ( (scanOpt->count == 0 && bitOpt->count == 0) || (scanOpt->count != 0 && bitOpt->count != 0) ) { fprintf(stderr, "%s: you must specify either -s|--scan or -b|--bitfile, but not both\n", progName); fprintf(stderr, "Try '%s --help' for more information.\n", progName); fail(3); } cable = cblOpt->sval[0]; bitFile = bitOpt->count ? bitOpt->filename[0] : NULL; devNum = devOpt->count ? devOpt->ival[0] : 1; if ( initialize() ) { fprintf(stderr, "%s failed to initialize!\n", progName); fail(4); } if ( getConfigFullPath("xilprg.conf", configFileName, sizeof(configFileName)) ) { fprintf(stderr, "%s failed to determine the location of its config file!\n", progName); fail(5); } if ( load_config_file(configFileName) ) { fprintf(stderr, "%s failed to load its config file from %s!\n", progName, configFileName); fail(6); } try { sprintf(line, "cable %s", cable); process_command_line(line); if ( scanOpt->count ) { process_command_line("detect"); } else { sprintf(line, "program %lu \"%s\"", devNum, bitFile); process_command_line(line); } } catch ( const std::exception &ex ) { fprintf(stderr, "%s failed: %s!\n", progName, ex.what()); fail(7); } cleanup: uninitialize(); arg_freetable(argTable, sizeof(argTable)/sizeof(argTable[0])); return exitCode; }
int main(int argc, char **argv) { int exitcode = 0; int nerrors = 0; /* Prepare command line arguments */ struct arg_str *latero_ip = arg_str1(NULL,"latero_ip","IP", "Latero server IP address"); struct arg_lit *print_resp= arg_lit0("p", "print", "print response packet"); struct arg_int *numpkt = arg_int0("n", "numpkt","<n>", "How many packets (default is 1)"); struct arg_int *dacval = arg_intn(NULL,"dac","<int>",0,4,"dac values (up to 4 values)"); struct arg_lit *rd = arg_lit0("r", "read", "read"); struct arg_lit *wr = arg_lit0("w", "write", "write"); struct arg_int *addr = arg_int0("a", "addr",NULL, "address"); struct arg_int *value = arg_int0("v", "value",NULL, "value"); struct arg_lit *mainctrl = arg_lit0(NULL,"mainctrl", "Raw commands are for the main controller"); struct arg_int *tpat = arg_int0("t","testpat","<n>", "Run Test Pattern:1=Split, 2=AllPin, 3=RowCol"); struct arg_lit *latio = arg_lit0(NULL,"lateroio", "Raw commands are for the Latero IO card"); struct arg_lit *help = arg_lit0(NULL,"help", "print this help and exit"); struct arg_end *end = arg_end(10); void* argtable[] = {latero_ip,print_resp,numpkt,dacval, rd, wr, addr, value, mainctrl, tpat, latio, help,end}; //latero_ip->sval[0] = "192.168.1.108"; /* verify the argtable[] entries were allocated sucessfully */ if (arg_nullcheck(argtable) != 0) { /* NULL entries were detected, some allocations must have failed */ printf("Insufficient memory (argtable)\n"); exitcode = 1; goto exit; } numpkt->ival[0] = 1; tpat->ival[0] = 0; nerrors = arg_parse(argc,argv,argtable); /* special case: '--help' takes precedence over error reporting */ if (help->count > 0) { printf("Usage: %s", argv[0]); arg_print_syntax(stdout,argtable,"\n"); printf("Latero client demonstration program version 1, revision 1\n"); arg_print_glossary(stdout,argtable," %-25s %s\n"); exitcode=0; goto exit; } if (nerrors > 0) { /* Display the error details contained in the arg_end struct.*/ arg_print_errors(stdout,end,argv[0]); printf("Try '%s --help' for more information.\n",argv[0]); exitcode = 0; goto exit; } if( wr->count > 0 ) { if( addr->count != 1 || value->count != 1 ) { printf("Write requires an address and a value\n"); exitcode = 1; goto exit; } if( mainctrl->count + latio->count == 0 ) { printf("Write requires a destination (--mainctrl or --lateroio)\n"); exitcode = 1; goto exit; } } if( rd->count > 0 ) { if( addr->count != 1 ) { printf("Read requires an address\n"); exitcode = 1; goto exit; } if( mainctrl->count + latio->count == 0 ) { printf("Read requires a destination (--mainctrl or --lateroio)\n"); exitcode = 1; goto exit; } } return( my_main( latero_ip->sval[0], print_resp->count, numpkt->ival[0], dacval->ival, dacval->count, rd->count, wr->count, addr->ival[0], value->ival[0], mainctrl->count, latio->count, tpat->ival[0]) ); exit: printf("Program Ended\n"); arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0])); return(exitcode); }
int main(int argc, char* argv[]) { // commandline argument parser options struct arg_lit *help = arg_lit0("h", "help", "print this help and exit"); struct arg_lit *vers = arg_lit0("v", "version", "print version information and exit"); struct arg_str *astr = arg_str1("s", "str", "<str>", "Animation string"); struct arg_end *end = arg_end(20); void* argtable[] = {help,vers,astr,end}; const char* progname = "omf_parse"; int from_stdin = 0; // Make sure everything got allocated if(arg_nullcheck(argtable) != 0) { printf("%s: insufficient memory\n", progname); goto exit_0; } // Parse arguments int nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { arg_print_errors(stdout, end, progname); printf("Try '%s --help' for more information.\n", progname); goto exit_0; } // Handle version if(vers->count > 0) { printf("%s v0.1\n", progname); printf("Command line One Must Fall 2097 Animation string parser\n"); printf("Source code is available at https://github.com/omf2097 under MIT license.\n"); printf("(C) 2014 Tuomas Virtanen\n"); goto exit_0; } // Handle help if(help->count > 0) { printf("Usage: %s", progname); arg_print_syntax(stdout, argtable, "\n"); printf("\nArguments:\n"); arg_print_glossary(stdout, argtable, "%-25s %s\n"); goto exit_0; } const char *str = *astr->sval; if (strcmp("-", *astr->sval) == 0) { from_stdin = 1; char *tmp_str = malloc(512); fgets(tmp_str, 512, stdin); // throttle the newline tmp_str[strlen(tmp_str)-1] = '\0'; str = tmp_str; } // Print some data printf("Parsing \"%s\".\n\n", str); int err_pos; sd_script script; sd_script_create(&script); int ret = sd_script_decode(&script, str, &err_pos); if(ret != SD_SUCCESS) { if(ret == SD_INVALID_TAG) { printf("Bad input string! Error at position %d.\n", err_pos); } if(ret == SD_ANIM_INVALID_STRING) { printf("Bad input string!\n"); } goto exit_1; } for(int frame_id = 0; frame_id < script.frame_count; frame_id++) { sd_script_frame *frame = &script.frames[frame_id]; printf("%d. Frame %d: '%c%d'\n", frame_id, frame->sprite, (char)(frame->sprite+65), frame->tick_len); for(int tag_id = 0; tag_id < frame->tag_count; tag_id++) { sd_script_tag *tag = &frame->tags[tag_id]; if(tag->desc == NULL) { tag->desc = ""; } if(tag->has_param) { printf(" %-4s %-4d %s\n", tag->key, tag->value, tag->desc); } else { printf(" %-4s %s\n", tag->key, tag->desc); } } } exit_1: sd_script_free(&script); exit_0: if (from_stdin) { free((char*)str); } arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0])); return 0; }
split_options_t *new_split_cli_options() { split_options_t *options = (split_options_t*) malloc (sizeof(split_options_t)); options->criterion = arg_str1(NULL, "criterion", NULL, "Criterion for splitting the file"); options->intervals = arg_str0(NULL, "intervals", NULL, "Values of intervals for splitting the file"); return options; }
struct Args parse_arguments(int argc, char *argv[]) { struct Args args; args.mass = 0.0; args.diam = 0.0; args.cd = 0.0; args.wind = 0.0; args.run_simulation = 0; // Simulation options struct arg_dbl *mass = arg_dbl1("m", "mass", "<float>", "Mass of rocket without motor (g)"); struct arg_dbl *diam = arg_dbl1("d", "diam", "<float>", "Diameter of rocket (mm)"); struct arg_dbl *cd = arg_dbl1("c", "cd", "<float>", "Drag coefficient of rocket"); struct arg_dbl *wind = arg_dbl1("w", "wind", "<float>", "Wind speed (km/h)"); struct arg_str *motor = arg_str1("M", "motor", "<string>", "Motor (use '-l' or '--list_motors' to see list"); // Help options struct arg_lit *help = arg_lit0("h", "help", "Printing help"); struct arg_lit *list_motors = arg_lit0("l", "list_motors", "List motors"); struct arg_end *end = arg_end(20); // Prepare argtable void *argtable[] = {mass, diam, cd, wind, motor, help, list_motors, end}; const char *progname = "lawn_dart"; int nerrors; // Verify the argtable[] entries were allocated sucessfully if (arg_nullcheck(argtable) != 0) { // NULL entries were detected, some allocations must have failed printf("%s: insufficient memory\n",progname); } // Parse the command line as defined by argtable[] nerrors = arg_parse(argc, argv, argtable); // Check for --help if (help->count > 0 || argc == 1) { printf("Lawn Dart: A Model Rocket Flight Simulator\n\n"); printf("%s", progname); arg_print_syntax(stdout, argtable,"\n"); puts(""); arg_print_glossary(stdout, argtable," %-25s %s\n"); puts(""); print_help(); } else if (list_motors->count > 0) { print_motor_list(); } else { // If all required options have been specified if (!nerrors) { // Get options from params args.mass = mass->dval[0] / 1000.0; args.diam = diam->dval[0] / 1000.0; args.cd = cd->dval[0]; args.wind = wind->dval[0] / 3.6; // Assert proper values int all_params_ok = 1; if (args.mass < 0.001 || args.mass > 1000.0) all_params_ok = 0; if (args.diam < 0.001 || args.diam > 1.0) all_params_ok = 0; if (args.cd < 0.0 || args.cd > 1.0) all_params_ok = 0; if (args.wind < 0.0 || args.wind > 100.0) all_params_ok = 0; // Confirm to run simulation if (all_params_ok) { args.run_simulation = 1; } } else { puts("--- Missing required parameters ---\n"); printf("%s", progname); arg_print_syntax(stdout, argtable,"\n"); puts(""); arg_print_glossary(stdout, argtable," %-25s %s\n"); puts(""); print_help(); } } return args; }
int main(int argc, char** argv) { int ret, i; int nerrors[NUMBER_OF_DIFFERENT_SYNTAXES + 1]; /* argtable setup */ /* SYNTAX 1: [--info] */ info1 = arg_lit1(NULL, "info", "Show information about the FLI camera"); end1 = arg_end(20); void * argtable1[] = {info1, end1}; argtable[1] = argtable1; /* SYNTAX 2: [--get-temperature] */ gettemp2 = arg_lit1(NULL, "get-temperature", "Print the temperature of the CCD, base and cooling power"); end2 = arg_end(20); void * argtable2[] = {gettemp2, end2}; argtable[2] = argtable2; /* SYNTAX 3: [--set-temperature] */ settemp3 = arg_int1(NULL, "set-temperature", "N", "Set the temperature of the CCD (in Celsius)"); end3 = arg_end(20); void * argtable3[] = {settemp3, end3}; argtable[3] = argtable3; /* SYNTAX 4: [--fan] */ fan4 = arg_str1(NULL, "fan", "(on|off)", "Turn on or off the fan"); end4 = arg_end(20); void * argtable4[] = {fan4, end4}; argtable[4] = argtable4; /* SYNTAX 5: [--shutter] */ shutter5 = arg_str1(NULL, "shutter", "(open|close)", "Open or close the shutter"); end5 = arg_end(20); void * argtable5[] = {shutter5, end5}; argtable[5] = argtable5; /* SYNTAX 6: --acquire <time/sec> --shutter {open|close} --output xyz.fits [--bin <bx>,<by>] [--offset <x0>,<y0>] [--size <sx>,<sy>] [--mode <mode>...] [--verbose] */ acquire6 = arg_str1(NULL, "acquire", "<time>", "Exposure time in sec"); shutter6 = arg_str1(NULL, "shutter", "(open|close)", "Whether to open or close the shutter"); output6 = arg_file1(NULL, "output", "xyz.fits", "Output filename for the FITS file"); bin6 = arg_str0(NULL, "bin", "<bx,by>", "Binning options in X,Y format"); offset6 = arg_str0(NULL, "offset", "<x0,y0>", "Offset options in X,Y format"); size6 = arg_str0(NULL, "size", "<sx,sy>", "Sizes in X,Y format"); mode6 = arg_str0(NULL, "mode", "(1mhz|8mhz)", "Download speed"); verbose6 = arg_lit0(NULL, "verbose", "Show verbose output"); end6 = arg_end(20); void * argtable6[] = {acquire6, shutter6, output6, bin6, offset6, size6, mode6, verbose6, end6}; argtable[6] = argtable6; /* SYNTAX 7: [--help]*/ help7 = arg_lit1(NULL, "help", "Print this help"); end7 = arg_end(20); void * argtable7[] = {help7, end7}; argtable[7] = argtable7; /* verify all argtable[] entries were allocated successfully */ for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) { if (arg_nullcheck(argtable[i]) != 0) { printf("%s: insufficient memory\n", progname); return EXIT_FAILURE; } } /* set defaults for the optional arguments */ bin6->sval[0] = "1,1"; offset6->sval[0] = "0,0"; size6->sval[0] = "4096,4096"; mode6->sval[0] = "8mhz"; /* parse all argument possibilities */ for (i = 1; i <= NUMBER_OF_DIFFERENT_SYNTAXES; i++) { nerrors[i] = arg_parse(argc, argv, argtable[i]); } /* select the right command */ /* --info */ if (nerrors[1] == 0) { if (info1->count > 0) { ret = camera_info(); if (ret) return ret; return 0; } /* --get-temperature */ } else if (nerrors[2] == 0) { if (gettemp2->count > 0) { ret = camera_get_temp(); if (ret) return ret; return 0; } /* --set-temperature */ } else if (nerrors[3] == 0) { if (settemp3->count > 0) { ret = camera_set_temp(settemp3->ival[0]); if (ret) return ret; return 0; } /* --fan */ } else if (nerrors[4] == 0) { int fan; if (strcmp("on", fan4->sval[0]) == 0) { fan = 1; } else if (strcmp("off", fan4->sval[0]) == 0) { fan = 0; } else { fprintf(stderr, "Cannot parse the option for --fan, see --help.\n"); return -1; } ret = camera_set_fan(fan); if (ret) return ret; return 0; /* --shutter */ } else if (nerrors[5] == 0) { int open_shutter; if (strcmp("open", shutter5->sval[0]) == 0) { open_shutter = 1; } else if (strcmp("close", shutter5->sval[0]) == 0) { open_shutter = 0; } else { fprintf(stderr, "Cannot parse the option for --shutter, see --help.\n"); return -1; } ret = camera_control_shutter(open_shutter); if (ret) return ret; return 0; /* --acquire */ } else if (nerrors[6] == 0) { if (acquire6->count > 0) { /* local variables to store the arguments */ float exposure_time; int is_dark; char * output_filename; char * bin_options; char * offset_options; char * size_options; int bx, by; int x0, y0; int sx, sy; int one_mhz_speed; int is_verbose = 0; /* copy const char arrays to char arrays to suppress warnings */ output_filename = (char*) malloc((strlen(output6->filename[0])) * sizeof (char)); bin_options = (char*) malloc((strlen(bin6->sval[0])) * sizeof (char)); offset_options = (char*) malloc((strlen(offset6->sval[0])) * sizeof (char)); size_options = (char*) malloc((strlen(size6->sval[0])) * sizeof (char)); strcpy(output_filename, output6->filename[0]); strcpy(bin_options, bin6->sval[0]); strcpy(offset_options, offset6->sval[0]); strcpy(size_options, size6->sval[0]); /* process arguments */ /* exposure time */ exposure_time = atof(acquire6->sval[0]); if (exposure_time < 0) { fprintf(stderr, "Exposure time cannot be below zero (given %f).\n", exposure_time); return -1; } /* shutter */ if (strcmp("open", shutter6->sval[0]) == 0) { is_dark = 0; } else if (strcmp("close", shutter6->sval[0]) == 0) { is_dark = 1; } else { fprintf(stderr, "Cannot parse the option for --shutter, see --help.\n"); return -1; } /* bin, size and offset */ ret = parse_comma_separated_values(bin_options, &bx, &by, "bin"); if (ret) return ret; ret = parse_comma_separated_values(offset_options, &x0, &y0, "offset"); if (ret) return ret; ret = parse_comma_separated_values(size_options, &sx, &sy, "size"); if (ret) return ret; /* mode */ if (strcmp("1mhz", mode6->sval[0]) == 0) { one_mhz_speed = 1; } else if (strcmp("8mhz", mode6->sval[0]) == 0) { one_mhz_speed = 0; } else { fprintf(stderr, "Cannot parse the option for --mode, see --help.\n"); return -1; } /* verbose */ if (verbose6->count > 0) is_verbose = 1; ret = camera_acquire(exposure_time, is_dark, output_filename, bx, by, x0, y0, sx, sy, one_mhz_speed, is_verbose); if (ret) return ret; return 0; } /* --help */ } else if (nerrors[7] == 0) { if (help7) { ret = camera_help(); if (ret) return ret; return 0; } /* incorrect or partially incorrect argument syntaxes */ } else { if (settemp3->count > 0) { arg_print_errors(stdout, end3, progname); printf("usage: %s ", progname); arg_print_syntax(stdout, argtable3, "\n"); } else if (fan4->count > 0) { arg_print_errors(stdout, end4, progname); printf("usage: %s ", progname); arg_print_syntax(stdout, argtable4, "\n"); } else if (acquire6->count > 0) { arg_print_errors(stdout, end5, progname); printf("usage: %s ", progname); arg_print_syntax(stdout, argtable5, "\n"); } else { printf("%s: unable to parse arguments, see syntax below:\n", progname); ret = 0; ret = camera_help(); return ret; } return EXIT_FAILURE; } /* no command line options at all */ printf("Try '%s --help' for more information.\n", progname); return (EXIT_SUCCESS); }
int main(int argc, char* argv[]) { struct arg_lit *help; struct arg_file *input, *output; struct arg_str *rotation; struct arg_end *end; /* command line parsing through argtable package */ void* argtable[] = { help = arg_lit0("h", "help", "display this help and exit"), input = arg_file0("i", "input", "input", "name of the input file (default stdin"), output = arg_file0("o", "output", "file", "name of the output file (default stdout)"), rotation = arg_str1(NULL, NULL, "\"x y z w\"", "rotate w degrees around axis x y z"), end = arg_end(20) }; const char* progname = "xyztk-rotate"; int rc = 0; int nerrors; /* verify the argtable[] entries were allocated sucessfully */ if (arg_nullcheck(argtable) != 0) { /* NULL entries were detected, some allocations must have failed */ printf("%s: insufficient memory\n", progname); rc=1; goto exit; } /* set default values */ /* parse the command line flags, overriding default values */ nerrors = arg_parse(argc,argv,argtable); /* special case: '--help' takes precedence over error reporting */ if (help->count > 0) { printf("Usage: %s", progname); arg_print_syntax(stdout,argtable,"\n"); printf("\n"); arg_print_glossary(stdout,argtable," %-40s %s\n"); printf("\n"); rc=0; goto exit; } /* special case: no command line options induces brief help */ if (argc==1) { printf("Try '%s --help' for more information.\n",progname); rc=0; goto exit; } /* If the parser returned any errors then display them and exit */ if (nerrors > 0) { /* Display the error details contained in the arg_end struct.*/ arg_print_errors(stdout,end,progname); printf("Try '%s --help' for more information.\n",progname); rc=1; goto exit; } /* set global structures */ /* initialize I/O pointers */ FILE* in; if (input->count) { in = fopen(input->filename[0], "r"); } else { in = stdin; } FILE* out; if (output->count) { out = fopen(output->filename[0], "w"); } else { out = stdout; } /* initialize molecule structure */ xyztk_molecule_t molecule; xyztk_molecule_load (&molecule, in); /* read rotation from string */ xyztk_quat_t r; sscanf (rotation->sval[0], "%lf%lf%lf%lf", &r.x, &r.y, &r.z, &r.w); xyztk_molecule_rotate (&molecule, &r); /* print output */ int i; fprintf(out, "%d\n", molecule.n_atoms); fprintf(out, "%s", molecule.name); for (i = 0; i < molecule.n_atoms; ++i) { fprintf(out, "%-8s %20.14lf %20.14lf %20.14lf \n", molecule.label[i].s, molecule.coord[i].x, molecule.coord[i].y, molecule.coord[i].z); } exit: /* deallocate each non-null entry in argtable[] */ arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0])); return rc; }
int genkmarkers(int argc, char* argv[]) { // determine my process name _splitpath(argv[0],NULL,NULL,gszProcName,NULL); #else int genkmarkers(int argc, char** argv) { // determine my process name CUtility::splitpath((char *)argv[0],NULL,gszProcName); #endif int iScreenLogLevel; // level of screen diagnostics int iFileLogLevel; // level of file diagnostics char szLogFile[_MAX_PATH]; // write diagnostics to this file int Rslt = 0; // function result code >= 0 represents success, < 0 on failure int NumberOfProcessors; // number of installed CPUs int NumThreads; // number of threads (0 defaults to number of CPUs) int PMode; // processing mode int KMerLen; // this length K-mers int PrefixLen; // inter-cultivar shared prefix length int SuffixLen; // cultivar specific suffix length int MinWithPrefix; // minimum number of cultivars required to have the shared prefix int MinHamming; // must be at least this Hamming away from any other K-mer in other species char szCultivarName[cMaxDatasetSpeciesChrom+1]; // cultivar name char szPartialCultivarsList[(cMaxDatasetSpeciesChrom + 10) * cMaxTargCultivarChroms]; // individual species parsed from this comma/tab/space separated list int NumPartialCultivars; // there are this many pseudo chromosomes for targeted cultivar for which K-mer markers are required char *pszPartialCultivars[cMaxTargCultivarChroms+1]; // pseudo chromosome names which identify targeted cultivar char szSfxPseudoGenome[_MAX_PATH]; // contains assembly + suffix array over all psuedo-chromosomes for all cultivars char szMarkerFile[_MAX_PATH]; // output potential markers to this file char szMarkerReadsFile[_MAX_PATH]; // output reads containing potential markers to this file char szSQLiteDatabase[_MAX_PATH]; // results summaries to this SQLite file char szExperimentName[cMaxDatasetSpeciesChrom+1]; // experiment name char szExperimentDescr[1000]; // describes experiment // command line args struct arg_lit *help = arg_lit0("h","help", "Print this help and exit"); struct arg_lit *version = arg_lit0("v","version,ver", "Print version information and exit"); struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to screen and logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug"); struct arg_file *LogFile = arg_file0("F","log","<file>", "Diagnostics log file"); struct arg_int *pmode = arg_int0("m","mode","<int>", "Processing mode : 0 - default with K-mer extension, 1 - no K-mer extension, 2 - inter-cultivar shared prefix sequences "); struct arg_int *kmerlen = arg_int0("k","kmer","<int>", "Cultivar specific K-mers of this length (default 50, range 25..100)"); struct arg_int *prefixlen = arg_int0("p","prefixlen","<int>", "Cultivar specific K-mers to contain inter-cultivar shared prefix sequences of this length (Mode 2 only"); struct arg_int *minwithprefix = arg_int0("s","minshared","<int>","Inter-cultivar shared prefix sequences must be present in this many cultivars (Mode 2 only, default all)"); struct arg_int *minhamming = arg_int0("K","minhamming","<int>", "Minimum Hamming separation distance in other non-target cultivars (default 2, range 1..5)"); struct arg_str *cultivar = arg_str1("c","cultivar","<str>", "Cultivar name to associate with identified marker K-mers"); struct arg_str *chromnames = arg_str1("C","chromnames","<str>", "Comma/space separated list of pseudo-chrom names specific to cultivar for which markers are required"); struct arg_file *infile = arg_file1("i","in","<file>", "Use this suffix indexed pseudo-chromosomes file"); struct arg_file *outfile = arg_file1("o","markers","<file>", "Output accepted marker K-mer sequences to this multifasta file"); struct arg_file *outreadsfile = arg_file0("O","markerreads","<file>", "Output reads containing accepted marker K-mers to this multifasta file"); struct arg_int *numthreads = arg_int0("T","threads","<int>", "number of processing threads 0..128 (defaults to 0 which sets threads to number of CPU cores)"); struct arg_file *summrslts = arg_file0("q","sumrslts","<file>", "Output results summary to this SQLite3 database file"); struct arg_str *experimentname = arg_str0("w","experimentname","<str>", "experiment name SQLite3 database file"); struct arg_str *experimentdescr = arg_str0("W","experimentdescr","<str>", "experiment description SQLite3 database file"); struct arg_end *end = arg_end(200); void *argtable[] = {help,version,FileLogLevel,LogFile, summrslts,experimentname,experimentdescr, pmode,kmerlen,prefixlen,minwithprefix,minhamming,cultivar,chromnames,infile,outfile,outreadsfile, numthreads, end}; char **pAllArgs; int argerrors; argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs); if(argerrors >= 0) argerrors = arg_parse(argerrors,pAllArgs,argtable); /* special case: '--help' takes precedence over error reporting */ if (help->count > 0) { printf("\n%s %s %s, Version %s\nOptions ---\n", gszProcName,gpszSubProcess->pszName,gpszSubProcess->pszFullDescr,cpszProgVer); arg_print_syntax(stdout,argtable,"\n"); arg_print_glossary(stdout,argtable," %-25s %s\n"); printf("\nNote: Parameters can be entered into a parameter file, one parameter per line."); printf("\n To invoke this parameter file then precede its name with '@'"); printf("\n e.g. %s %s @myparams.txt\n",gszProcName,gpszSubProcess->pszName); printf("\nPlease report any issues regarding usage of %s at https://github.com/csiro-crop-informatics/biokanga/issues\n\n",gszProcName); return(1); } /* special case: '--version' takes precedence error reporting */ if (version->count > 0) { printf("\n%s %s Version %s\n",gszProcName,gpszSubProcess->pszName,cpszProgVer); return(1); } if (!argerrors) { if(FileLogLevel->count && !LogFile->count) { printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>\n'",FileLogLevel->ival[0]); return(1); } iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo; if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug) { printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d\n",iFileLogLevel,eDLNone,eDLDebug); return(1); } if(LogFile->count) { strncpy(szLogFile,LogFile->filename[0],_MAX_PATH); szLogFile[_MAX_PATH-1] = '\0'; } else { iFileLogLevel = eDLNone; szLogFile[0] = '\0'; } // now that log parameters have been parsed then initialise diagnostics log system if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true)) { printf("\nError: Unable to start diagnostics subsystem\n"); if(szLogFile[0] != '\0') printf(" Most likely cause is that logfile '%s' can't be opened/created\n",szLogFile); return(1); } gDiagnostics.DiagOut(eDLInfo,gszProcName,"Subprocess %s Version %s starting",gpszSubProcess->pszName,cpszProgVer); gExperimentID = 0; gProcessID = 0; gProcessingID = 0; szSQLiteDatabase[0] = '\0'; szExperimentName[0] = '\0'; szExperimentDescr[0] = '\0'; if(experimentname->count) { strncpy(szExperimentName,experimentname->sval[0],sizeof(szExperimentName)); szExperimentName[sizeof(szExperimentName)-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(szExperimentName); CUtility::ReduceWhitespace(szExperimentName); } else szExperimentName[0] = '\0'; gExperimentID = 0; gProcessID = 0; gProcessingID = 0; szSQLiteDatabase[0] = '\0'; szExperimentDescr[0] = '\0'; if(summrslts->count) { strncpy(szSQLiteDatabase,summrslts->filename[0],sizeof(szSQLiteDatabase)-1); szSQLiteDatabase[sizeof(szSQLiteDatabase)-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(szSQLiteDatabase); if(strlen(szSQLiteDatabase) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite database specified with '-q<filespec>' option"); return(1); } if(strlen(szExperimentName) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite experiment name specified with '-w<str>' option"); return(1); } if(experimentdescr->count) { strncpy(szExperimentDescr,experimentdescr->sval[0],sizeof(szExperimentDescr)-1); szExperimentDescr[sizeof(szExperimentDescr)-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(szExperimentDescr); } if(strlen(szExperimentDescr) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite experiment description specified with '-W<str>' option"); return(1); } gExperimentID = gSQLiteSummaries.StartExperiment(szSQLiteDatabase,false,true,szExperimentName,szExperimentName,szExperimentDescr); if(gExperimentID < 1) return(1); gProcessID = gSQLiteSummaries.AddProcess((char *)gpszSubProcess->pszName,(char *)gpszSubProcess->pszName,(char *)gpszSubProcess->pszFullDescr); if(gProcessID < 1) return(1); gProcessingID = gSQLiteSummaries.StartProcessing(gExperimentID,gProcessID,(char *)cpszProgVer); if(gProcessingID < 1) return(1); gDiagnostics.DiagOut(eDLInfo,gszProcName,"Initialised SQLite database '%s' for results summary collection",szSQLiteDatabase); gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database experiment identifier for '%s' is %d",szExperimentName,gExperimentID); gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database process identifier for '%s' is %d",(char *)gpszSubProcess->pszName,gProcessID); gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database processing instance identifier is %d",gProcessingID); } else { szSQLiteDatabase[0] = '\0'; szExperimentDescr[0] = '\0'; } // show user current resource limits #ifndef _WIN32 gDiagnostics.DiagOut(eDLInfo, gszProcName, "Resources: %s",CUtility::ReportResourceLimits()); #endif #ifdef _WIN32 SYSTEM_INFO SystemInfo; GetSystemInfo(&SystemInfo); NumberOfProcessors = SystemInfo.dwNumberOfProcessors; #else NumberOfProcessors = sysconf(_SC_NPROCESSORS_CONF); #endif int MaxAllowedThreads = min(cMaxWorkerThreads,NumberOfProcessors); // limit to be at most cMaxWorkerThreads if((NumThreads = numthreads->count ? numthreads->ival[0] : MaxAllowedThreads)==0) NumThreads = MaxAllowedThreads; if(NumThreads < 0 || NumThreads > MaxAllowedThreads) { gDiagnostics.DiagOut(eDLWarn,gszProcName,"Warning: Number of threads '-T%d' specified was outside of range %d..%d",NumThreads,1,MaxAllowedThreads); gDiagnostics.DiagOut(eDLWarn,gszProcName,"Warning: Defaulting number of threads to %d",MaxAllowedThreads); NumThreads = MaxAllowedThreads; } PMode = (etPMode)(pmode->count ? pmode->ival[0] : ePMExtdKMers); if(PMode < ePMExtdKMers || PMode >= ePMplaceholder) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Processing mode '-m%d' specified outside of range %d..%d\n",PMode,ePMExtdKMers,(int)ePMplaceholder-1); exit(1); } KMerLen = kmerlen->count ? kmerlen->ival[0] : cDfltKMerLen; if(KMerLen < cMinKMerLen || KMerLen > cMaxKMerLen) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: K-mer core length '-k%d' must be in range %d..%d",KMerLen,cMinKMerLen,cMaxKMerLen); return(1); } if(PMode == 2) { PrefixLen = prefixlen->count ? prefixlen->ival[0] : KMerLen/2; if(PrefixLen < cMinKMerLen/2 || PrefixLen > KMerLen-(cMinKMerLen/2)) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Prefix length '-p%d' must be in range %d..%d",KMerLen,cMinKMerLen/2,KMerLen-(cMinKMerLen/2)); return(1); } SuffixLen = KMerLen - PrefixLen; MinWithPrefix = minwithprefix->count ? minwithprefix->ival[0] : 0; if(MinWithPrefix != 0 && MinWithPrefix < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Minimum cultivars sharing prefix sequence '-s%d' must be either 0 (all) or at least 1",MinWithPrefix); return(1); } } MinHamming = minhamming->count ? minhamming->ival[0] : cDfltHamming; if(MinHamming < cMinHamming || MinHamming > cMaxHamming) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Minimum Hamming separation '-K%d' must be in range %d..%d",MinHamming,cMinHamming,cMaxHamming); return(1); } strncpy(szCultivarName,cultivar->sval[0],cMaxDatasetSpeciesChrom); szCultivarName[cMaxDatasetSpeciesChrom]= '\0'; CUtility::TrimQuotedWhitespcExtd(szCultivarName); if(strlen(szCultivarName) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected cultivar name '-c<name>' is empty"); return(1); } strncpy(szPartialCultivarsList,chromnames->sval[0],sizeof(szPartialCultivarsList)); szPartialCultivarsList[sizeof(szPartialCultivarsList)-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(szPartialCultivarsList); CUtility::ReduceWhitespace(szPartialCultivarsList); char *pChr = szPartialCultivarsList; char *pStartChr; char Chr; int CurSpeciesLen; NumPartialCultivars=0; CurSpeciesLen = 0; pStartChr = pChr; while((Chr = *pChr++) != '\0') { if(Chr == ' ' || Chr == '\t' || Chr == ',') // treat any of these as delimiters { pChr[-1] = '\0'; if(CurSpeciesLen != 0) { pszPartialCultivars[NumPartialCultivars++] = pStartChr; CurSpeciesLen = 0; } pStartChr = pChr; continue; } CurSpeciesLen += 1; } if(CurSpeciesLen) pszPartialCultivars[NumPartialCultivars++] = pStartChr; if(!NumPartialCultivars) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected at least one ('-C<names>') targeted cultivar chromosme name"); return(1); } strcpy(szSfxPseudoGenome,infile->filename[0]); CUtility::TrimQuotedWhitespcExtd(szSfxPseudoGenome); if(strlen(szSfxPseudoGenome) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected input pseudo-genome suffix array filename '-i<name>' is empty"); return(1); } strcpy(szMarkerFile,outfile->filename[0]); CUtility::TrimQuotedWhitespcExtd(szMarkerFile); if(strlen(szMarkerFile) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected marker file to generate filename '-o<name>' is empty"); return(1); } if(outreadsfile->count) { strcpy(szMarkerReadsFile,outreadsfile->filename[0]); CUtility::TrimQuotedWhitespcExtd(szMarkerReadsFile); if(strlen(szMarkerReadsFile) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Reads containing markers filename '-O<name>' is empty"); return(1); } } else szMarkerReadsFile[0] = '\0'; gDiagnostics.DiagOut(eDLInfo,gszProcName,"Processing parameters:"); const char *pszDescr; switch(PMode) { case ePMExtdKMers: pszDescr = "Extended K-mer markers"; break; case ePMNoExtdKMers: pszDescr = "Non-extended K-mer markers"; break; case ePMPrefixKMers: pszDescr = "K-mers to share prefix sequence with other cultivars"; break; } gDiagnostics.DiagOutMsgOnly(eDLInfo,"Processing mode is : '%s'",pszDescr); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Targeted cultivar name : '%s'",szCultivarName); for(int Idx = 0; Idx < NumPartialCultivars; Idx++) gDiagnostics.DiagOutMsgOnly(eDLInfo,"Targeted cultivar chromosome name (%d) : '%s'", Idx + 1,pszPartialCultivars[Idx]); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Core K-mer length : %d",KMerLen); if(PMode == ePMPrefixKMers) { gDiagnostics.DiagOutMsgOnly(eDLInfo,"Inter-cultivar shared prefix sequence length : %d",PrefixLen); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Cultivar specific suffix sequence length : %d",SuffixLen); if(MinWithPrefix) gDiagnostics.DiagOutMsgOnly(eDLInfo,"Min number cultivars sharing prefix : %d",MinWithPrefix); else gDiagnostics.DiagOutMsgOnly(eDLInfo,"Min number cultivars sharing prefix : 'All'"); } gDiagnostics.DiagOutMsgOnly(eDLInfo,"Minimum Hamming separation : %d",MinHamming); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Input indexed pseudo-genome file: '%s'",szSfxPseudoGenome); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Write marker K-mers to file: '%s'",szMarkerFile); if(szMarkerReadsFile[0] != '\0') gDiagnostics.DiagOutMsgOnly(eDLInfo,"Write marker containing reads to file: '%s'",szMarkerReadsFile); if(szExperimentName[0] != '\0') gDiagnostics.DiagOutMsgOnly(eDLInfo,"This processing reference: %s",szExperimentName); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Number of processing threads: %d",NumThreads); if(gExperimentID > 0) { int ParamID; ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szLogFile),"log",szLogFile); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(PMode),"mode",&PMode); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(KMerLen),"kmer",&KMerLen); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(PrefixLen),"prefixlen",&PrefixLen); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(SuffixLen),"suffixlen",&SuffixLen); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(MinWithPrefix),"minwithprefix",&MinWithPrefix); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(MinHamming),"minhamming",&MinHamming); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(NumThreads),"threads",&NumThreads); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(NumberOfProcessors),"cpus",&NumberOfProcessors); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szCultivarName),"cultivar",szCultivarName); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(NumPartialCultivars),"NumPartialCultivars",&NumPartialCultivars); for(int Idx = 0; Idx < NumPartialCultivars; Idx++) ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(pszPartialCultivars[Idx]),"chromnames",pszPartialCultivars[Idx]); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szSfxPseudoGenome),"in",szSfxPseudoGenome); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szMarkerFile),"markers",szMarkerFile); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szMarkerReadsFile),"markerreads",szMarkerReadsFile); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szSQLiteDatabase),"sumrslts",szSQLiteDatabase); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szExperimentName),"experimentname",szExperimentName); ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szExperimentDescr),"experimentdescr",szExperimentDescr); } #ifdef _WIN32 SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS); #endif gStopWatch.Start(); Rslt = LocMarkers((etPMode)PMode,KMerLen,PrefixLen,SuffixLen,MinWithPrefix,MinHamming,szCultivarName,NumPartialCultivars,pszPartialCultivars,szSfxPseudoGenome,szMarkerFile,szMarkerReadsFile,NumThreads); Rslt = Rslt >=0 ? 0 : 1; if(gExperimentID > 0) { if(gProcessingID) gSQLiteSummaries.EndProcessing(gProcessingID,Rslt); gSQLiteSummaries.EndExperiment(gExperimentID); } gStopWatch.Stop(); gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read()); return(Rslt); } else { printf("\n%s %s %s, Version %s\n", gszProcName,gpszSubProcess->pszName,gpszSubProcess->pszFullDescr,cpszProgVer); arg_print_errors(stdout,end,gszProcName); arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n"); return(1); } return 0; }
int kangax(int argc, char* argv[]) { // determine my process name _splitpath(argv[0],NULL,NULL,gszProcName,NULL); #else int kangax(int argc, char** argv) { // determine my process name CUtility::splitpath((char *)argv[0],NULL,gszProcName); #endif int iScreenLogLevel; // level of screen diagnostics int iFileLogLevel; // level of file diagnostics char szLogFile[_MAX_PATH]; // write diagnostics to this file int Rslt; char szOutputFileSpec[_MAX_PATH]; int MinSeqLen; // only accept for indexing sequences which are at least this length int SimGenomeSize; // if 1..1000 then simulating indexing of a genome of this size in Gbp. int NumInputFileSpecs; // number of input file specs char *pszInputFileSpecs[cMaxInFileSpecs]; // input files char szDescription[cMBSFFileDescrLen]; char szTitle[cMBSFShortFileDescrLen]; char szRefSpecies[cMaxDatasetSpeciesChrom]; int iMode; // processing mode bool bSOLiD; // colorspace (SOLiD) generation int NumberOfProcessors; // number of installed CPUs int NumThreads; // number of threads (0 defaults to number of CPUs) char szSQLiteDatabase[_MAX_PATH]; // results summaries to this SQLite file char szExperimentName[cMaxDatasetSpeciesChrom+1]; // experiment name char szExperimentDescr[1000]; // describes experiment // command line args struct arg_lit *help = arg_lit0("hH","help", "print this help and exit"); struct arg_lit *version = arg_lit0("v","version,ver", "print version information and exit"); struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug"); struct arg_file *LogFile = arg_file0("F","log","<file>", "diagnostics log file"); struct arg_int *Mode=arg_int0("m", "mode", "<int>", "Processing mode, 0=standard, 1=bisulphite index, 2=simulated genome (default 0)"); struct arg_lit *solid = arg_lit0("C","colorspace", "Generate for colorspace (SOLiD)"); struct arg_int *simgenomesize=arg_int0("s", "simgenomesize", "<int>","Simulated genome size in Gbp (default 5, range 1..1000"); struct arg_int *minseqlen=arg_int0("l", "minseqlen", "<int>","Do not accept for indexing sequences less than this length (default 50, range 1..1000000)"); struct arg_file *infiles = arg_filen("i",NULL,"<file>",0,cMaxInFileSpecs, "input from wildcarded kangas or fasta files"); struct arg_file *OutFile = arg_file0("o",NULL,"<file>", "output suffix array file"); struct arg_str *Descr = arg_str0("d","descr","<string>", "full description"); struct arg_str *Title = arg_str0("t","title","<string>", "short title"); struct arg_str *RefSpecies = arg_str1("r","ref","<string>", "reference species"); struct arg_int *threads = arg_int0("T","threads","<int>", "number of processing threads 0..128 (defaults to 0 which sets threads to number of CPU cores)"); struct arg_file *summrslts = arg_file0("q","sumrslts","<file>", "Output results summary to this SQLite3 database file"); struct arg_str *experimentname = arg_str0("w","experimentname","<str>", "experiment name SQLite3 database file"); struct arg_str *experimentdescr = arg_str0("W","experimentdescr","<str>", "experiment description SQLite3 database file"); struct arg_end *end = arg_end(200); void *argtable[] = {help,version,FileLogLevel,LogFile, summrslts,experimentname,experimentdescr, Mode,minseqlen,simgenomesize,solid,infiles,OutFile,RefSpecies,Descr,Title, threads,end}; char **pAllArgs; int argerrors; argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs); if(argerrors >= 0) argerrors = arg_parse(argerrors,pAllArgs,argtable); /* special case: '--help' takes precedence over error reporting */ if (help->count > 0) { printf("\n%s %s %s, Version %s\nOptions ---\n", gszProcName,gpszSubProcess->pszName,gpszSubProcess->pszFullDescr,cpszProgVer); arg_print_syntax(stdout,argtable,"\n"); arg_print_glossary(stdout,argtable," %-25s %s\n"); printf("\nNote: Parameters can be entered into a parameter file, one parameter per line."); printf("\n To invoke this parameter file then precede its name with '@'"); printf("\n e.g. %s %s @myparams.txt\n",gszProcName,gpszSubProcess->pszName); printf("\nPlease report any issues regarding usage of %s at https://github.com/csiro-crop-informatics/biokanga/issues\n\n",gszProcName); return(1); } /* special case: '--version' takes precedence error reporting */ if (version->count > 0) { printf("\n%s %s Version %s\n",gszProcName,gpszSubProcess->pszName,cpszProgVer); return(1); } if (!argerrors) { if(FileLogLevel->count && !LogFile->count) { printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>'",FileLogLevel->ival[0]); exit(1); } iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo; if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug) { printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d",iFileLogLevel,eDLNone,eDLDebug); exit(1); } if(LogFile->count) { strncpy(szLogFile,LogFile->filename[0],_MAX_PATH); szLogFile[_MAX_PATH-1] = '\0'; } else { iFileLogLevel = eDLNone; szLogFile[0] = '\0'; } // now that log parameters have been parsed then initialise diagnostics log system if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true)) { printf("\nError: Unable to start diagnostics subsystem\n"); if(szLogFile[0] != '\0') printf(" Most likely cause is that logfile '%s' can't be opened/created\n",szLogFile); exit(1); } gDiagnostics.DiagOut(eDLInfo,gszProcName,"Subprocess %s Version %s starting",gpszSubProcess->pszName,cpszProgVer); gExperimentID = 0; gProcessID = 0; gProcessingID = 0; szSQLiteDatabase[0] = '\0'; szExperimentName[0] = '\0'; szExperimentDescr[0] = '\0'; if(experimentname->count) { strncpy(szExperimentName,experimentname->sval[0],sizeof(szExperimentName)); szExperimentName[sizeof(szExperimentName)-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(szExperimentName); CUtility::ReduceWhitespace(szExperimentName); } else szExperimentName[0] = '\0'; MinSeqLen = 0; gExperimentID = 0; gProcessID = 0; gProcessingID = 0; szSQLiteDatabase[0] = '\0'; szExperimentDescr[0] = '\0'; if(summrslts->count) { strncpy(szSQLiteDatabase,summrslts->filename[0],sizeof(szSQLiteDatabase)-1); szSQLiteDatabase[sizeof(szSQLiteDatabase)-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(szSQLiteDatabase); if(strlen(szSQLiteDatabase) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite database specified with '-q<filespec>' option"); return(1); } if(strlen(szExperimentName) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite experiment name specified with '-w<str>' option"); return(1); } if(experimentdescr->count) { strncpy(szExperimentDescr,experimentdescr->sval[0],sizeof(szExperimentDescr)-1); szExperimentDescr[sizeof(szExperimentDescr)-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(szExperimentDescr); } if(strlen(szExperimentDescr) < 1) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite experiment description specified with '-W<str>' option"); return(1); } gExperimentID = gSQLiteSummaries.StartExperiment(szSQLiteDatabase,false,true,szExperimentName,szExperimentName,szExperimentDescr); if(gExperimentID < 1) return(1); gProcessID = gSQLiteSummaries.AddProcess((char *)gpszSubProcess->pszName,(char *)gpszSubProcess->pszName,(char *)gpszSubProcess->pszFullDescr); if(gProcessID < 1) return(1); gProcessingID = gSQLiteSummaries.StartProcessing(gExperimentID,gProcessID,(char *)cpszProgVer); if(gProcessingID < 1) return(1); gDiagnostics.DiagOut(eDLInfo,gszProcName,"Initialised SQLite database '%s' for results summary collection",szSQLiteDatabase); gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database experiment identifier for '%s' is %d",szExperimentName,gExperimentID); gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database process identifier for '%s' is %d",(char *)gpszSubProcess->pszName,gProcessID); gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database processing instance identifier is %d",gProcessingID); } else { szSQLiteDatabase[0] = '\0'; szExperimentDescr[0] = '\0'; } iMode = Mode->count ? Mode->ival[0] : 0; if(iMode < 0 || iMode > 2) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: processing mode '-m%d' must be specified in range %d..%d",iMode,0,1); exit(1); } if(iMode == 2) { SimGenomeSize = simgenomesize->count ? simgenomesize->ival[0] : 5; if(SimGenomeSize < 1 || iMode > cMaxSimGenomeGbp) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: simulated genome size in Gbp '-s%d' must be specified in range 1..%d",SimGenomeSize,cMaxSimGenomeGbp); exit(1); } } else SimGenomeSize = 0; bSOLiD = solid->count ? true : false; int Idx; if(iMode != 2) { MinSeqLen = minseqlen->count ? minseqlen->ival[0] : 50; if(MinSeqLen < 1) MinSeqLen = 1; else if(MinSeqLen > 1000000) MinSeqLen = 1000000; for(NumInputFileSpecs=Idx=0;NumInputFileSpecs < cMaxInFileSpecs && Idx < infiles->count; Idx++) { pszInputFileSpecs[Idx] = NULL; if(pszInputFileSpecs[NumInputFileSpecs] == NULL) pszInputFileSpecs[NumInputFileSpecs] = new char [_MAX_PATH]; strncpy(pszInputFileSpecs[NumInputFileSpecs],infiles->filename[Idx],_MAX_PATH); pszInputFileSpecs[NumInputFileSpecs][_MAX_PATH-1] = '\0'; CUtility::TrimQuotedWhitespcExtd(pszInputFileSpecs[NumInputFileSpecs]); if(pszInputFileSpecs[NumInputFileSpecs][0] != '\0') NumInputFileSpecs++; } if(!NumInputFileSpecs) { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no input file(s) specified with '-i<filespec>' option)\n"); exit(1); } } else { NumInputFileSpecs = 0; pszInputFileSpecs[0] = NULL; } if(OutFile->count) { strcpy(szOutputFileSpec,OutFile->filename[0]); CUtility::TrimQuotedWhitespcExtd(szOutputFileSpec); } else szOutputFileSpec[0] = '\0'; if(iMode != 2 && szOutputFileSpec[0] == '\0') { gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: no output file(s) specified with '-o<filespec>' option)\n"); exit(1); } strncpy(szRefSpecies,RefSpecies->sval[0],cMaxDatasetSpeciesChrom); szRefSpecies[cMaxDatasetSpeciesChrom-1] = '\0'; if(!Title->count) strcpy(szTitle,szRefSpecies); else { strncpy(szTitle,Title->sval[0],cMBSFShortFileDescrLen); szTitle[cMBSFShortFileDescrLen-1] = '\0'; } if(!Descr->count) strcpy(szDescription,szRefSpecies); else { strncpy(szDescription,Descr->sval[0],cMBSFFileDescrLen); szDescription[cMBSFFileDescrLen-1] = '\0'; } // show user current resource limits #ifndef _WIN32 gDiagnostics.DiagOut(eDLInfo, gszProcName, "Resources: %s",CUtility::ReportResourceLimits()); #endif int AvailGBMemory; #ifdef _WIN32 SYSTEM_INFO SystemInfo; GetSystemInfo(&SystemInfo); NumberOfProcessors = SystemInfo.dwNumberOfProcessors; MEMORYSTATUSEX status; status.dwLength = sizeof(status); GlobalMemoryStatusEx(&status); AvailGBMemory = (int)(status.ullTotalPhys / 0x040000000); // set to be gigabytes #else NumberOfProcessors = sysconf(_SC_NPROCESSORS_CONF); long pages = sysconf(_SC_PHYS_PAGES); long page_size = sysconf(_SC_PAGE_SIZE); AvailGBMemory = (int)(((INT64)pages * (INT64)page_size)/0x040000000); #endif int MaxAllowedThreads = min(cMaxWorkerThreads,NumberOfProcessors); // limit to be at most cMaxWorkerThreads if((NumThreads = threads->count ? threads->ival[0] : MaxAllowedThreads)==0) NumThreads = MaxAllowedThreads; if(NumThreads < 0 || NumThreads > MaxAllowedThreads) { gDiagnostics.DiagOut(eDLWarn,gszProcName,"Warning: Number of threads '-T%d' specified was outside of range %d..%d",NumThreads,1,MaxAllowedThreads); gDiagnostics.DiagOut(eDLWarn,gszProcName,"Warning: Defaulting number of threads to %d",MaxAllowedThreads); NumThreads = MaxAllowedThreads; } gDiagnostics.DiagOut(eDLInfo,gszProcName,"Processing parameters:"); if(iMode == 2) { gDiagnostics.DiagOutMsgOnly(eDLInfo,"Simulating indexing of a genome of size: %dGbp",SimGenomeSize); if(AvailGBMemory < (SimGenomeSize * 7)) // allowing for 6 bytes per base plus overheads gDiagnostics.DiagOutMsgOnly(eDLWarn,"May be memory allocation problems when loading or indexing this simulated genome, available memory: %dGB",AvailGBMemory); } if(bSOLiD) gDiagnostics.DiagOutMsgOnly(eDLInfo,"Process for colorspace (SOLiD)"); if(iMode != 2) { gDiagnostics.DiagOutMsgOnly(eDLInfo,"Accepting for indexing sequences of length at least: %dbp",MinSeqLen); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Process input files as: '%s'",iMode == 0 ? "standard" : "bisulphite"); for(Idx=0; Idx < NumInputFileSpecs; Idx++) gDiagnostics.DiagOutMsgOnly(eDLInfo,"Input source file spec: '%s'",pszInputFileSpecs[Idx]); } if(szOutputFileSpec[0] != '\0') gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output to suffix array file: '%s'",szOutputFileSpec); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Reference species: '%s'",szRefSpecies); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Title text: '%s'",szTitle); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Descriptive text: '%s'",szDescription); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Number of threads : %d",NumThreads); if(szExperimentName[0] != '\0') gDiagnostics.DiagOutMsgOnly(eDLInfo,"This processing reference: %s",szExperimentName); #ifdef _WIN32 SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS); #endif gStopWatch.Start(); Rslt = CreateBioseqSuffixFile(iMode,MinSeqLen,SimGenomeSize,NumThreads,bSOLiD,NumInputFileSpecs,pszInputFileSpecs,szOutputFileSpec,szRefSpecies,szDescription,szTitle); Rslt = Rslt >=0 ? 0 : 1; if(gExperimentID > 0) { if(gProcessingID) gSQLiteSummaries.EndProcessing(gProcessingID,Rslt); gSQLiteSummaries.EndExperiment(gExperimentID); } gStopWatch.Stop(); gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read()); exit(Rslt); } else { printf("\n%s %s %s, Version %s\n", gszProcName,gpszSubProcess->pszName,gpszSubProcess->pszFullDescr,cpszProgVer); arg_print_errors(stdout,end,gszProcName); arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n"); exit(1); } }
int main(int argc, char *argv[]) { struct arg_str *vpOpt = arg_str1("v", "vidpid", "<VID:PID>", " vendor ID and product ID (e.g 04B4:8613)"); struct arg_uint *toOpt = arg_uint0("t", "timeout", "<millis>", " timeout in milliseconds"); struct arg_int *epOpt = arg_int0("e", "endpoint", "<epNum>", " endpoint to write to"); struct arg_lit *benOpt = arg_lit0("b", "benchmark", " benchmark the operation"); struct arg_lit *chkOpt = arg_lit0("c", "checksum", " print 16-bit checksum"); struct arg_lit *helpOpt = arg_lit0("h", "help", " print this help and exit\n"); struct arg_file *fileOpt = arg_file1(NULL, NULL, "<fileName>", " the data to send"); struct arg_end *endOpt = arg_end(20); void* argTable[] = {vpOpt, toOpt, epOpt, benOpt, chkOpt, helpOpt, fileOpt, endOpt}; const char *progName = "bulk"; int numErrors; uint8 epNum = 0x06; FILE *inFile = NULL; uint8 *buffer = NULL; uint32 fileLen; struct USBDevice *deviceHandle = NULL; USBStatus uStatus; int retVal = 0; const char *error = NULL; double totalTime, speed; uint16 checksum = 0x0000; uint32 timeout = 5000; uint32 i; #ifdef WIN32 LARGE_INTEGER tvStart, tvEnd, freq; DWORD_PTR mask = 1; SetThreadAffinityMask(GetCurrentThread(), mask); QueryPerformanceFrequency(&freq); #else struct timeval tvStart, tvEnd; long long startTime, endTime; #endif if ( arg_nullcheck(argTable) != 0 ) { printf("%s: insufficient memory\n", progName); FAIL(1, cleanup); } numErrors = arg_parse(argc, argv, argTable); if ( helpOpt->count > 0 ) { printf("Bulk Write Tool Copyright (C) 2009-2011 Chris McClelland\n\nUsage: %s", progName); arg_print_syntax(stdout, argTable, "\n"); printf("\nWrite data to a bulk endpoint.\n\n"); arg_print_glossary(stdout, argTable," %-10s %s\n"); FAIL(0, cleanup); } if ( numErrors > 0 ) { arg_print_errors(stdout, endOpt, progName); printf("Try '%s --help' for more information.\n", progName); FAIL(2, cleanup); } if ( toOpt->count ) { timeout = toOpt->ival[0]; } inFile = fopen(fileOpt->filename[0], "rb"); if ( !inFile ) { fprintf(stderr, "Unable to open file %s\n", fileOpt->filename[0]); FAIL(3, cleanup); } fseek(inFile, 0, SEEK_END); fileLen = (uint32)ftell(inFile); fseek(inFile, 0, SEEK_SET); buffer = (uint8 *)malloc(fileLen); if ( !buffer ) { fprintf(stderr, "Unable to allocate memory for file %s\n", fileOpt->filename[0]); FAIL(4, cleanup); } if ( fread(buffer, 1, fileLen, inFile) != fileLen ) { fprintf(stderr, "Unable to read file %s\n", fileOpt->filename[0]); FAIL(5, cleanup); } if ( chkOpt->count ) { for ( i = 0; i < fileLen; i++ ) { checksum = (uint16)(checksum + buffer[i]); } printf("Checksum: 0x%04X\n", checksum); } if ( epOpt->count ) { epNum = (uint8)epOpt->ival[0]; } uStatus = usbInitialise(0, &error); CHECK_STATUS(uStatus, 6, cleanup); uStatus = usbOpenDevice(vpOpt->sval[0], 1, 0, 0, &deviceHandle, &error); CHECK_STATUS(uStatus, 7, cleanup); #ifdef WIN32 QueryPerformanceCounter(&tvStart); uStatus = usbBulkWrite(deviceHandle, epNum, buffer, fileLen, timeout, &error); QueryPerformanceCounter(&tvEnd); CHECK_STATUS(uStatus, 8, cleanup); totalTime = (double)(tvEnd.QuadPart - tvStart.QuadPart); totalTime /= freq.QuadPart; printf("Time: %fms\n", totalTime/1000.0); speed = (double)fileLen / (1024*1024*totalTime); #else gettimeofday(&tvStart, NULL); uStatus = usbBulkWrite(deviceHandle, epNum, buffer, fileLen, timeout, &error); gettimeofday(&tvEnd, NULL); CHECK_STATUS(uStatus, 8, cleanup); startTime = tvStart.tv_sec; startTime *= 1000000; startTime += tvStart.tv_usec; endTime = tvEnd.tv_sec; endTime *= 1000000; endTime += tvEnd.tv_usec; totalTime = (double)(endTime - startTime); totalTime /= 1000000; // convert from uS to S. speed = (double)fileLen / (1024*1024*totalTime); #endif if ( benOpt->count ) { printf("Speed: %f MB/s\n", speed); } cleanup: if ( buffer ) { free(buffer); } if ( inFile ) { fclose(inFile); } if ( deviceHandle ) { usbCloseDevice(deviceHandle, 0); } if ( error ) { fprintf(stderr, "%s\n", error); usbFreeError(error); } arg_freetable(argTable, sizeof(argTable)/sizeof(argTable[0])); return retVal; }
void processArgs(int argc, char **argv) { int nerrors, i; char *savptr, str[1024], *str1, machName[1024], sessIDstr[1024]; struct arg_str *arg_sessionID = arg_str1( "S", "sessionID", "<mach.sessionID>", "session ID of run to be processed\n"); struct arg_str *arg_propIDs = arg_str0( "P", "proposals", "<int [,int [,int]]>", "quoted string of proposal numbers to use\n"); struct arg_str *arg_skipDays = arg_str0( "D", "days", "<skip [,length]>", "skip days at start, do length days after\n"); struct arg_lit *arg_Check = arg_lit0( NULL, "checkobs", "check observations for basic errors\n"); struct arg_lit *arg_TimeSummary = arg_lit0( NULL, "timesummary", "time summary"); struct arg_lit *arg_PeriodSearch = arg_lit0( NULL, "periodsearch", "make periodogram plots\n"); struct arg_lit *arg_Hourglass = arg_lit0( "H", "hourglass", "make hourglass plot\n"); struct arg_lit *arg_Opposition = arg_lit0( NULL, "opposition", "make solar angle (opposition) plot\n"); struct arg_str *arg_Airmass = arg_str0( NULL, "airmass", "<int>", "make per-field airmass plot (0 is max, 1 is median)\n"); struct arg_lit *arg_SixVisits = arg_lit0( "V", "sixvisitnum", "make all-filter visit numbers plot\n"); struct arg_lit *arg_5sigma = arg_lit0( "V", "5sigma", "make aitoff plot for median 5sigma also per proposal\n"); struct arg_lit *arg_skyb = arg_lit0( "V", "skyb", "make aitoff plot for median skyb also per proposal\n"); struct arg_lit *arg_seeing = arg_lit0( "V", "seeing", "make aitoff plot for median seeing also per proposal\n"); struct arg_lit *arg_Visits = arg_lit0( "v", "visitnum", "make visit numbers plot for specified filters\n \ (requires -f|--filters)\n"); struct arg_str *arg_reqFilters = arg_str0( "f", "filters", "<f [,f [,f]]>", "which filters to use; f in {ugrizy}\n"); struct arg_lit *arg_NEOrevisits = arg_lit0( "R", "revisits", "make NEO revisit numbers plot\n"); struct arg_lit *arg_Slew = arg_lit0( NULL, "slew", "make slew time histogram\n"); struct arg_lit *arg_SNtiming = arg_lit0( NULL, "sntiming", "make SN Ia cadence plots\n"); struct arg_file *arg_plotfileRoot = arg_file0(NULL, "plotfile", "harcopy file", "root name of plotfile for hardcopy\n"); struct arg_file *arg_plotTitle = arg_file0(NULL, "plottitle", "<string>", "title for plots\n"); struct arg_lit *arg_help = arg_lit0( "h", "help", "show usage\n"); struct arg_lit *arg_debug = arg_lit0( "d", "debug", "debugging output\n"); struct arg_str *arg_hostname = arg_str1( "N", "hostname", "<string>", "if you know hostname \n"); struct arg_str *arg_databasename = arg_str1( "DB", "database", "<string>", "if you know the db name \n"); struct arg_str *arg_designstretch = arg_str1( NULL, "designstretch", "<int>", "design or stretch value\n"); struct arg_end *arg_endp = arg_end(20); void *argtable[] = {arg_sessionID, arg_propIDs, arg_skipDays, arg_TimeSummary, arg_Check, arg_PeriodSearch, arg_Hourglass, arg_Opposition, arg_Airmass, arg_SixVisits, arg_5sigma, arg_skyb, arg_seeing, arg_Slew, arg_Visits, arg_reqFilters, arg_NEOrevisits, arg_SNtiming, arg_plotfileRoot, arg_plotTitle, arg_debug, arg_help, arg_hostname, arg_designstretch, arg_databasename, arg_endp}; if (arg_nullcheck(argtable) != 0) fprintf(stderr, "error: insufficient memory\n"); nerrors = arg_parse(argc,argv,argtable); // process arguments // render assistance when asked if(arg_help->count>0) { fprintf(stderr,"Usage: %s [options]\n where [options] are:\n\n",argv[0]); arg_print_glossary(stderr, argtable, "%-45s %s"); // arg_print_syntaxv(stderr, argtable, "\n"); exit(1); } // list errors if (nerrors > 0) { arg_print_errors(stdout,arg_endp,argv[0]); fprintf(stderr,"\nUsage: %s [options]\n where [options] are:\n\n",argv[0]); arg_print_glossary(stderr, argtable, "%-45s %s"); // arg_print_syntaxv(stderr, argtable, "\n"); exit(1); } // set database tableName and sessionID from sessionID argument //strcpy(str, *arg_sessionID->sval); //strcpy(machName, strtok_r(str,".",&savptr)); //strcpy(sessIDstr, strtok_r(NULL,".",&savptr)); strcpy(sessIDstr, *arg_sessionID->sval); sessionID = atoi(sessIDstr); if ( *arg_databasename->sval == NULL ) { sprintf(database, "%s", "OpsimDB"); } else { sprintf(database, "%s", *arg_databasename->sval); } if ( *arg_hostname->sval == NULL ) { if ( gethostname(identifier, identifier_length) == 0 ) { sprintf(hostname, "%s", identifier); } else { printf( "Hostname : %s\n", strerror(errno)); exit(1); } } else { sprintf (hostname, "%s", *arg_hostname->sval); } sprintf(tableName, "output_%s_%d", hostname, sessionID); // set action flags if(arg_5sigma->count>0) do5sigma=1; if(arg_skyb->count>0) doskyb=1; if(arg_seeing->count>0) doSeeing=1; if(arg_TimeSummary->count>0) doTimeSummary=1; if(arg_Check->count>0) doCheck=1; if(arg_PeriodSearch->count>0) doPeriodSearch=1; if(arg_Hourglass->count>0) doHourglass=1; if(arg_Opposition->count>0) doOpposition=1; if(arg_designstretch->count>0) { if ( strcmp(*arg_designstretch->sval, "0") == 0) { useDesignStretch = 0; } else { useDesignStretch = 1; } } if(arg_Airmass->count>0) { doAirmass=1; if(strcmp(*arg_Airmass->sval, "0") != 0) { useMaxAirmass=0; } else { useMaxAirmass=1; } } if(arg_SixVisits->count>0) doSixVisits=1; if(arg_Visits->count>0) { doVisits=1; if(arg_reqFilters->count==0) { fprintf(stderr,"Error: with -v|--visitsnum must give -f|--filters\n"); exit(1); } strcpy(str, *arg_reqFilters->sval); i = 0; strcpy(desiredFilters[i],strtok_r(str," ,",&savptr)); i++; while((str1=strtok_r(NULL," ,",&savptr))!= NULL) { strcpy(desiredFilters[i],str1); i++; } ndesiredFilters = i; } if(arg_NEOrevisits->count>0) doNEOrevisits=1; if(arg_SNtiming->count>0) doSNtiming=1; if(arg_Slew->count>0) doSlew=1; if(arg_propIDs->count>0) { strcpy(str, *arg_propIDs->sval); i = 0; propIDs[i] = atoi(strtok_r(str," ,",&savptr)); i++; while((str1=strtok_r(NULL," ,",&savptr))!= NULL) { propIDs[i] = atoi(str1); i++; } nIDs = i; } if(arg_plotfileRoot->count>0) { strcpy(plotfileRoot,arg_plotfileRoot->filename[0]); doHardcopy = 1; } if(arg_plotTitle->count>0) { strcpy(plotTitle,arg_plotTitle->filename[0]); } if(arg_skipDays->count>0) { strcpy(str, *arg_skipDays->sval); skipDays = atoi(strtok_r(str," ,",&savptr)); str1 = strtok_r(NULL," ,",&savptr); if(str1 != (char *) NULL) lengthDays = atoi(str1); } if(arg_debug->count>0) { debug = 1; } #if 0 printf(" sessionID: %d\n", sessionID); printf(" skipDays: %d\n", skipDays); printf(" lengthDays: %d\n", lengthDays); printf(" nIDs: %d\n", nIDs); if(nIDs>0) { printf(" using IDs: "); for(i=0; i<nIDs; i++) printf(" %d",propIDs[i]); printf("\n"); } printf(" doCheck: %d\n", doCheck); printf("doPeriodSearch: %d\n", doPeriodSearch); printf(" doHourglass: %d\n", doHourglass); printf(" doOpposition: %d\n", doOpposition); printf(" doSixVisits: %d\n", doSixVisits); printf(" doVisits: %d\n", doVisits); if(doVisits) { printf(" using filters: "); for(i=0; i<ndesiredFilters; i++) printf(" %s",desiredFilters[i]); printf("\n"); } printf(" doNEOrevisits: %d\n", doNEOrevisits); printf(" doSNtiming: %d\n", doSNtiming); if(strlen(plotfileRoot)>0) printf(" hardcopy file: \"%s\"\n", plotfileRoot); if(strlen(plotTitle)>0) printf(" plot title: \"%s\"\n", plotTitle); printf(" debug: %d\n", debug); #endif arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0])); }
int main(int argc, char* argv[]) { double discountFactor = 0.9; FILE* initFileFd = NULL; double* setPoints = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int nbSetPoints = 0; unsigned int* ns = NULL; unsigned int nbN = 0; unsigned int* hs = NULL; unsigned int nbH = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the set points"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of ressources"); struct arg_str* z = arg_str1("h", NULL, "<s>", "List of length for the sequences"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(6); int nerrors = 0; void* argtable[6]; argtable[0] = initFile; argtable[1] = r; argtable[2] = s; argtable[3] = z; argtable[4] = where; argtable[5] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 6); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 6); return EXIT_FAILURE; } initGenerativeModelParameters(); initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &nbSetPoints); setPoints = (double*)malloc(sizeof(double) * nbSetPoints); for(; i < nbSetPoints; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); setPoints[i] = strtod(str, NULL); } fclose(initFileFd); nbSteps = s->ival[0]; hs = parseUnsignedIntList((char*)z->sval[0], &nbH); ns = parseUnsignedIntList((char*)r->sval[0], &nbN); sprintf(str, "%s/%u_results_%s_%s.csv", where->filename[0], timestamp, z->sval[0], r->sval[0]); results = fopen(str, "w"); for(i = 0; i < nbN; i++) { /* Loop on the computational ressources */ printf("Starting with %u computational ressources\n", ns[i]); fprintf(results, "%u", ns[i]); fflush(NULL); unsigned int j = 0; for(; j < nbH; j++) { /* Loop on the length of the sequences */ unsigned int k = 0; state* crt1 = initState(); state* crt2 = copyState(crt1); double averages[2] = {0.0,0.0}; for(; k < nbSetPoints; k++) { /* Loop on the initial states */ unsigned int l = 0; parameters[10] = setPoints[k]; for(; l < nbSteps; l++) { /* Loop on the step */ char isTerminal = 0; double reward = 0.0; state* nextState = NULL; sequential_direct_instance* sequential_direct = sequential_direct_initInstance(crt1, discountFactor, hs[j],1); double* optimalAction = sequential_direct_planning(sequential_direct, ns[i]); isTerminal = nextStateReward(crt1, optimalAction, &nextState, &reward) < 0 ? 1 : 0; freeState(crt1); crt1 = nextState; averages[0] += reward; sequential_direct_uninitInstance(&sequential_direct); if(isTerminal) break; } printf("direct: %u set point done for h=%u\n", k, hs[j]); fflush(NULL); for(l = 0; l < nbSteps; l++) { /* Loop on the step */ char isTerminal = 0; double reward = 0.0; state* nextState = NULL; sequential_soo_instance* sequential_soo = sequential_soo_initInstance(crt2, discountFactor, hs[j],1); double* optimalAction = sequential_soo_planning(sequential_soo, ns[i]); isTerminal = nextStateReward(crt2, optimalAction, &nextState, &reward); freeState(crt2); crt2 = nextState; averages[1] += reward; sequential_soo_uninitInstance(&sequential_soo); if(isTerminal) break; } printf("soo: %u set point done for h=%u\n", k, hs[j]); fflush(NULL); } freeState(crt1); freeState(crt2); averages[0] = averages[0] /(double)nbSetPoints; averages[1] = averages[1] /(double)nbSetPoints; printf("Computation with h=%u and n=%u done\n", hs[j], ns[i]); fprintf(results, ",%.15f,%.15f", averages[0],averages[1]); fflush(NULL); } printf("Computation with %u computational ressources done\n\n", ns[i]); fprintf(results, "\n"); fflush(NULL); } fclose(results); arg_freetable(argtable, 6); free(setPoints); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
int main(int argc, char **argv) { const char* progname = "z-connector"; struct arg_file *device = arg_file1("dD", "device", NULL, "path to the serial port of Z-Wave dongle"); struct arg_str *server = arg_str1("sS", "server", NULL, "IP address or host name to connect to"); struct arg_int *port = arg_int0("pP", "port", NULL, "port number (defaults to 9087)"); struct arg_file *cert = arg_file0(NULL, "cert", NULL, "personal certificate"); struct arg_file *key = arg_file0(NULL, "key", NULL, "personal certificate key"); struct arg_file *cacert = arg_file0(NULL, "cacert", NULL, "CA certificate"); struct arg_file *log = arg_file0("lL", "log", NULL, "file to write log to (defaults to stdout)"); struct arg_lit *debug = arg_lit0(NULL, "debug", "log debugging information"); struct arg_lit *help = arg_lit0("h", "help", "print this help and exit"); struct arg_end *end = arg_end(20); void* argTable[] = {device, server, port, cert, key, cacert, log, debug, help, end}; #ifdef WIN32 WSADATA wsa; WORD wsaVersion = MAKEWORD(2, 2); int wsaError; DWORD win32err; #endif int retCode, nErrors; if (arg_nullcheck(argTable) != 0) { printf("%s: insufficient memory\n", progname); CLEAN_RETURN(1); } nErrors = arg_parse(argc, argv, argTable); if (IS_ARG_SET(help)) { printf("Usage: %s", progname); arg_print_syntax(stdout, argTable, "\n"); //printf("Print certain system information. With no options, same as -s.\n\n"); arg_print_glossary(stdout, argTable," %-25s %s\n"); printf("\nReport bugs to <*****@*****.**>.\n"); CLEAN_RETURN(0); } LogLevel = (IS_ARG_SET(debug)) ? 3 : 2; if (nErrors > 0) { arg_print_errors(stdout, end, progname); printf("Try '%s --help' for more information.\n", progname); CLEAN_RETURN(2); } #ifdef WIN32 hStoppingEvent = CreateEvent(NULL, TRUE, FALSE, "Local\\Z-Agent-Stop"); if (hStoppingEvent == NULL) { win32err = GetLastError(); if (win32err == ERROR_INVALID_HANDLE) { printf("Another instance is already running\n"); CLEAN_RETURN(0); } else { printf("Failed to create synchronization event: %d\n", win32err); CLEAN_RETURN(3); } } wsaError = WSAStartup(wsaVersion, &wsa); if (wsaError != 0) { printf("WSA Startup failed with code %d\n", wsaError); CloseHandle(hStoppingEvent); CLEAN_RETURN(3); } if (wsa.wVersion != wsaVersion) { printf("Required WSA version not found\n"); CloseHandle(hStoppingEvent); CLEAN_RETURN(3); } #endif retCode = main_impl(device->filename[0], server->sval[0], SAFE_INT(port, 9087), SAFE_FILE(cert, ""), SAFE_FILE(key, ""), SAFE_FILE(cacert, ""), SAFE_FILE(log, "-")); #ifdef WIN32 WSACleanup(); CloseHandle(hStoppingEvent); #endif CLEAN_RETURN(retCode); }
int main(int argc, char* argv[]) { int nerrors, w; bstring temp = NULL; const char* warnprefix = "no-"; bool expect_failure; // Define arguments. struct arg_lit* show_help = arg_lit0("h", "help", "Show this help."); struct arg_lit* expect_failure_lit = arg_lit0("f", "fail", "Expect failure during preprocessing."); struct arg_str* input_lang = arg_str1(NULL, NULL, "<lang>", "The input language."); struct arg_file* input_file = arg_file1(NULL, NULL, "<file>", "The input preprocessor file."); struct arg_lit* verbose = arg_litn("v", NULL, 0, LEVEL_EVERYTHING - LEVEL_DEFAULT, "Increase verbosity."); struct arg_lit* quiet = arg_litn("q", NULL, 0, LEVEL_DEFAULT - LEVEL_SILENT, "Decrease verbosity."); struct arg_end* end = arg_end(20); void* argtable[] = { show_help, verbose, quiet, expect_failure_lit, input_lang, input_file, end }; // Parse arguments. nerrors = arg_parse(argc, argv, argtable); if (nerrors != 0 || show_help->count != 0) { if (nerrors != 0) arg_print_errors(stdout, end, "libdcpu-pp test suite"); printd(LEVEL_DEFAULT, "syntax:\n dtasm"); arg_print_syntax(stderr, argtable, "\n"); printd(LEVEL_DEFAULT, "options:\n"); arg_print_glossary(stderr, argtable, " %-25s %s\n"); if (show_help->count == 2) { printd(LEVEL_DEFAULT, "defined warnings:\n"); for (w = 0; w < _WARN_COUNT; w++) printd(LEVEL_DEFAULT, " %s\n", dwarnpolicy[w].name); } arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0])); return 1; } // Set failure expectation variable. expect_failure = (expect_failure_lit->count > 0); // Set verbosity level. debug_setlevel(LEVEL_DEFAULT + verbose->count - quiet->count); // Set global path variable. osutil_setarg0(bautofree(bfromcstr(argv[0]))); // Set up error handling. if (dsethalt()) { // Handle the error. dautohandle(); printd(LEVEL_ERROR, "libdcpu-pp test suite: error occurred.\n"); if (temp != NULL) pp_cleanup(bautofree(temp)); arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0])); if (expect_failure) return 0; else return 1; } // Perform preprocessing. ppfind_add_autopath(bautofree(bfromcstr(input_file->filename[0]))); temp = pp_do( bautofree(bfromcstr(input_lang->sval[0])), bautofree(bfromcstr(input_file->filename[0])) ); // Perform parsing. test_success = true; yyin = fopen(temp->data, "r"); yyout = NULL; yyparse(); fclose(yyin); // Cleanup. pp_cleanup(bautofree(temp)); if (test_success && expect_failure) return 1; else if (test_success && !expect_failure) return 0; else if (!test_success && expect_failure) return 0; else return 1; }
int main(int argc, char* argv[]) { CURL* curl; bstring command; bstring name; bstring modpath; int all; // Define arguments. struct arg_lit* show_help = arg_lit0("h", "help", "Show this help."); struct arg_str* cmdopt = arg_str1(NULL, NULL, "<command>", "The command; either 'search', 'install', 'uninstall', 'enable' or 'disable'."); struct arg_str* nameopt = arg_str0(NULL, NULL, "<name>", "The name of the module to search for, install, uninstall, enable or disable."); struct arg_lit* all_flag = arg_lit0("a", "all", "Apply this command to all available / installed modules."); struct arg_lit* verbose = arg_litn("v", NULL, 0, LEVEL_EVERYTHING - LEVEL_DEFAULT, "Increase verbosity."); struct arg_lit* quiet = arg_litn("q", NULL, 0, LEVEL_DEFAULT - LEVEL_SILENT, "Decrease verbosity."); struct arg_end* end = arg_end(20); void* argtable[] = { show_help, cmdopt, all_flag, nameopt, verbose, quiet, end }; // Parse arguments. int nerrors = arg_parse(argc, argv, argtable); if (nerrors != 0 || show_help->count != 0 || (all_flag->count == 0 && nameopt->count == 0)) { if (all_flag->count == 0 && nameopt->count == 0) printd(LEVEL_ERROR, "error: must have either module name or -a."); if (show_help->count != 0) arg_print_errors(stderr, end, "mm"); fprintf(stderr, "syntax:\n dtmm"); arg_print_syntax(stderr, argtable, "\n"); fprintf(stderr, "options:\n"); arg_print_glossary(stderr, argtable, " %-25s %s\n"); arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0])); return 1; } // Set verbosity level. debug_setlevel(LEVEL_DEFAULT + verbose->count - quiet->count); // Show version information. version_print(bautofree(bfromcstr("Module Manager"))); // Set argument 0 and convert parameters. osutil_setarg0(bautofree(bfromcstr(argv[0]))); command = bfromcstr(cmdopt->sval[0]); name = bfromcstr(nameopt->sval[0]); // Initialize curl or exit. curl = curl_easy_init(); if (!curl) { printd(LEVEL_ERROR, "unable to initialize curl.\n"); return 1; } // Ensure module path exists. modpath = osutil_getmodulepath(); if (modpath == NULL) { printd(LEVEL_ERROR, "module path does not exist (searched TOOLCHAIN_MODULES and modules/).\n"); return 1; } bdestroy(modpath); // Convert all flag. all = (all_flag->count > 0); // If all is set, set the name back to "". if (all) bassigncstr(name, ""); // If the name is "all" or "*", handle this as the all // boolean flag. if (biseqcstr(name, "all") || biseqcstr(name, "*")) { bassigncstr(name, ""); all = 1; printd(LEVEL_WARNING, "treating name as -a (all) flag"); } if (biseqcstrcaseless(command, "search") || biseqcstrcaseless(command, "se")) return do_search(curl, name, all); else if (biseqcstrcaseless(command, "install") || biseqcstrcaseless(command, "in")) { if (all) return do_install_all(curl); else return do_install(curl, name); } else if (biseqcstrcaseless(command, "uninstall") || biseqcstrcaseless(command, "rm")) { if (all) return do_uninstall_all(curl); else return do_uninstall(curl, name); } else if (biseqcstrcaseless(command, "enable") || biseqcstrcaseless(command, "en")) { if (all) return do_enable_all(curl); else return do_enable(curl, name); } else if (biseqcstrcaseless(command, "disable") || biseqcstrcaseless(command, "di") || biseqcstrcaseless(command, "dis")) { if (all) return do_disable_all(curl); else return do_disable(curl, name); } else { printd(LEVEL_ERROR, "unknown command (must be search, install, uninstall, enable or disable)."); return 1; } return 0; }
int main(int argc, char *argv[]) { struct arg_int *lport = arg_int0("p", "port", "<localport>", "listening port (default is 8888)"); struct arg_int *debug = arg_int0("d", "debug", "<level>", "debug output level (default is 4)"); #ifdef PUBKEY_DATA_ struct arg_str *key = arg_str0("k", "key", "<keyfile>", "public key file (default is built-in)"); #else struct arg_str *key = arg_str0("k", "key", "<keyfile>", "public key file (default is pubkey)"); #endif #ifdef ROOTPEM_DATA_ struct arg_str *certdb= arg_str0(NULL, "certdb", "<certfile>", "trusted CA database (default is built-in)"); #else struct arg_str *certdb= arg_str0(NULL, "certdb", "<certfile>", "trusted CA database (default is root.pem)"); #endif struct arg_lit *help = arg_lit0(NULL,"help", "print this help and exit"); struct arg_str *host = arg_str1(NULL, NULL, "<host>[:port]", "non-blocked TLS server"); struct arg_end *end = arg_end(20); void *argtable[] = {lport, debug, key, certdb, help, host, end}; const char* progname = "telex-client"; int nerrors; int ret=0; assert(!arg_nullcheck(argtable)); // defaults: lport->ival[0] = 8888; debug->ival[0] = 3; #ifdef PUBKEY_DATA_ key->sval[0] = NULL; #else key->sval[0] = "pubkey"; #endif #ifdef ROOTPEM_DATA_ certdb->sval[0] = NULL; #else certdb->sval[0] = "root.pem"; #endif nerrors = arg_parse(argc,argv,argtable); if (help->count > 0) { printf("Usage: %s", progname); arg_print_syntax(stdout,argtable,"\n"); printf("\nEstablishes covert, encrypted tunnels, disguised as connections to <host>.\n\n"); arg_print_glossary(stdout,argtable," %-25s %s\n"); printf("\n"); ret = 0; } else if (nerrors > 0) { arg_print_errors(stdout,end,progname); printf("Try '%s --help' for more information.\n", progname); ret = 1; } else if (argc == 1) { printf("Try '%s --help' for more information.\n", progname); ret = 0; } else { int port = 443; char hstr[255]; assert(host->sval[0]); strncpy(hstr, host->sval[0], sizeof(hstr)-1); char *pstr=0; strtok(hstr, ":"); pstr = strtok(NULL, ":"); if (pstr) { port = strtol(pstr, NULL, 10); if (port < 1 || port > 65535) { fprintf(stderr, "Invalid remote port: %d", port); return 1; } } printf("WARNING: This software is an experimental prototype intended for\n"); printf(" researchers. It does not provide strong security and is\n"); printf(" UNSAFE FOR REAL-WORLD USE. For details of current limitations\n"); printf(" of our proof-of-concept, please see telex-client/ISSUES.\n"); ret = telex_client(lport->ival[0], port, debug->ival[0], hstr, key->sval[0], certdb->sval[0]); } arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0])); return ret; }
int main(int argc, char **argv) { /* SYNTAX 1: insert [-nvR] <file> [file]... -o <file> */ struct arg_rex *cmd1 = arg_rex1(NULL, NULL, "insert", NULL, REG_ICASE, NULL); struct arg_lit *noact1 = arg_lit0("n", NULL, "take no action"); struct arg_lit *verbose1 = arg_lit0("v", "verbose", "verbose messages"); struct arg_lit *recurse1 = arg_lit0("R", NULL, "recurse through subdirectories"); struct arg_file *infiles1 = arg_filen(NULL, NULL, NULL, 1,argc+2, "input file(s)"); struct arg_file *outfile1 = arg_file0("o", NULL, "<output>", "output file (default is \"-\")"); struct arg_end *end1 = arg_end(20); void* argtable1[] = {cmd1,noact1,verbose1,recurse1,infiles1,outfile1,end1}; int nerrors1; /* SYNTAX 2: remove [-nv] <file> */ struct arg_rex *cmd2 = arg_rex1(NULL, NULL, "remove", NULL, REG_ICASE, NULL); struct arg_lit *noact2 = arg_lit0("n", NULL, NULL); struct arg_lit *verbose2 = arg_lit0("v", "verbose", NULL); struct arg_file *infiles2 = arg_file1(NULL, NULL, NULL, NULL); struct arg_end *end2 = arg_end(20); void* argtable2[] = {cmd2,noact2,verbose2,infiles2,end2}; int nerrors2; /* SYNTAX 3: search [-v] <pattern> [-o <file>] [--help] [--version] */ struct arg_rex *cmd3 = arg_rex1(NULL, NULL, "search", NULL, REG_ICASE, NULL); struct arg_lit *verbose3 = arg_lit0("v", "verbose", NULL); struct arg_str *pattern3 = arg_str1(NULL, NULL, "<pattern>", "search string"); struct arg_file *outfile3 = arg_file0("o", NULL, "<output>", NULL); struct arg_end *end3 = arg_end(20); void* argtable3[] = {cmd3,verbose3,pattern3,outfile3,end3}; int nerrors3; /* SYNTAX 4: [-help] [-version] */ struct arg_lit *help4 = arg_lit0(NULL,"help", "print this help and exit"); struct arg_lit *version4 = arg_lit0(NULL,"version", "print version information and exit"); struct arg_end *end4 = arg_end(20); void* argtable4[] = {help4,version4,end4}; int nerrors4; const char* progname = "multisyntax"; int exitcode=0; /* verify all argtable[] entries were allocated sucessfully */ if (arg_nullcheck(argtable1)!=0 || arg_nullcheck(argtable2)!=0 || arg_nullcheck(argtable3)!=0 || arg_nullcheck(argtable4)!=0 ) { /* NULL entries were detected, some allocations must have failed */ printf("%s: insufficient memory\n",progname); exitcode=1; goto exit; } /* set any command line default values prior to parsing */ outfile1->filename[0]="-"; outfile3->filename[0]="-"; /* Above we defined a separate argtable for each possible command line syntax */ /* and here we parse each one in turn to see if any of them are successful */ nerrors1 = arg_parse(argc,argv,argtable1); nerrors2 = arg_parse(argc,argv,argtable2); nerrors3 = arg_parse(argc,argv,argtable3); nerrors4 = arg_parse(argc,argv,argtable4); /* Execute the appropriate main<n> routine for the matching command line syntax */ /* In this example program our alternate command line syntaxes are mutually */ /* exclusive, so we know in advance that only one of them can be successful. */ if (nerrors1==0) exitcode = mymain1(noact1->count, verbose1->count, recurse1->count, outfile1->filename[0], infiles1->filename, infiles1->count); else if (nerrors2==0) exitcode = mymain2(noact2->count, verbose2->count, infiles2->filename[0]); else if (nerrors3==0) exitcode = mymain3(verbose3->count, pattern3->sval[0], outfile3->filename[0]); else if (nerrors4==0) exitcode = mymain4(help4->count, version4->count, progname, argtable1, argtable2, argtable3, argtable4); else { /* We get here if the command line matched none of the possible syntaxes */ if (cmd1->count > 0) { /* here the cmd1 argument was correct, so presume syntax 1 was intended target */ arg_print_errors(stdout,end1,progname); printf("usage: %s ", progname); arg_print_syntax(stdout,argtable1,"\n"); } else if (cmd2->count > 0) { /* here the cmd2 argument was correct, so presume syntax 2 was intended target */ arg_print_errors(stdout,end2,progname); printf("usage: %s ", progname); arg_print_syntax(stdout,argtable2,"\n"); } else if (cmd3->count > 0) { /* here the cmd3 argument was correct, so presume syntax 3 was intended target */ arg_print_errors(stdout,end3,progname); printf("usage: %s ", progname); arg_print_syntax(stdout,argtable3,"\n"); } else { /* no correct cmd literals were given, so we cant presume which syntax was intended */ printf("%s: missing <insert|remove|search> command.\n",progname); printf("usage 1: %s ", progname); arg_print_syntax(stdout,argtable1,"\n"); printf("usage 2: %s ", progname); arg_print_syntax(stdout,argtable2,"\n"); printf("usage 3: %s ", progname); arg_print_syntax(stdout,argtable3,"\n"); printf("usage 4: %s", progname); arg_print_syntax(stdout,argtable4,"\n"); } } exit: /* deallocate each non-null entry in each argtable */ arg_freetable(argtable1,sizeof(argtable1)/sizeof(argtable1[0])); arg_freetable(argtable2,sizeof(argtable2)/sizeof(argtable2[0])); arg_freetable(argtable3,sizeof(argtable3)/sizeof(argtable3[0])); arg_freetable(argtable4,sizeof(argtable4)/sizeof(argtable4[0])); return exitcode; }
void conf_configure_app(configuration_ctx_t* ctx) { struct arg_lit* help = arg_lit0(OPT_HELP_SHORT, OPT_HELP_LONG, OPT_HELP_DESCR); struct arg_lit* helpF = arg_lit0(OPT_HELP_SHORT, OPT_HELP_LONG, OPT_HELP_DESCR); struct arg_lit* helpS = arg_lit0(OPT_HELP_SHORT, OPT_HELP_LONG, OPT_HELP_DESCR); struct arg_lit* grep = arg_lit0(OPT_GREP_SHORT, OPT_GREP_LONG, OPT_GREP_DESCR); struct arg_lit* grepF = arg_lit0(OPT_GREP_SHORT, OPT_GREP_LONG, OPT_GREP_DESCR); struct arg_lit* grepS = arg_lit0(OPT_GREP_SHORT, OPT_GREP_LONG, OPT_GREP_DESCR); struct arg_str* string = arg_str1(OPT_STR_SHORT, OPT_STR_LONG, NULL, OPT_STR_DESCR); struct arg_str* stringG = arg_str0(OPT_STR_SHORT, OPT_STR_LONG, NULL, OPT_STR_DESCR); struct arg_file* file = arg_file1(OPT_FILE_SHORT, OPT_FILE_LONG, NULL, OPT_FILE_DESCR); struct arg_file* fileG = arg_file0(OPT_FILE_SHORT, OPT_FILE_LONG, NULL, OPT_FILE_DESCR); struct arg_str* macro = arg_str1(OPT_MACRO_SHORT, OPT_MACRO_LONG, NULL, OPT_MACRO_DESCR); struct arg_str* macroS = arg_str1(OPT_MACRO_SHORT, OPT_MACRO_LONG, NULL, OPT_MACRO_DESCR); struct arg_str* macroF = arg_str1(OPT_MACRO_SHORT, OPT_MACRO_LONG, NULL, OPT_MACRO_DESCR); struct arg_file* files = arg_filen(OPT_F_SHORT, OPT_F_LONG, NULL, 1, ctx->argc + 2, OPT_F_DESCR); struct arg_file* filesS = arg_filen(OPT_F_SHORT, OPT_F_LONG, NULL, 1, ctx->argc + 2, OPT_F_DESCR); struct arg_file* filesF = arg_filen(OPT_F_SHORT, OPT_F_LONG, NULL, 1, ctx->argc + 2, OPT_F_DESCR); struct arg_end* end = arg_end(10); struct arg_end* endF = arg_end(10); struct arg_end* endS = arg_end(10); void* argtable[] = {help, grep, stringG, fileG, macro, files, end}; void* argtableF[] = {helpF, grepF, file, macroF, filesF, endF}; void* argtableS[] = {helpS, grepS, string, macroS, filesS, endS}; if(arg_nullcheck(argtable) != 0 || arg_nullcheck(argtableF) != 0 || arg_nullcheck(argtableS) != 0) { prconf_print_syntax(argtable, argtableS, argtableF); goto cleanup; } int nerrors = arg_parse(ctx->argc, ctx->argv, argtable); int nerrorsF = arg_parse(ctx->argc, ctx->argv, argtableF); int nerrorsS = arg_parse(ctx->argc, ctx->argv, argtableS); if(nerrors > 0 || help->count > 0) { prconf_print_syntax(argtable, argtableS, argtableF); if(help->count == 0 && ctx->argc > 1) { arg_print_errors(stdout, end, PROGRAM_NAME); } goto cleanup; } if(nerrorsS == 0) { ctx->on_string(filesS, macroS->sval[0], string->sval[0], grepS->count > 0); } else if(nerrorsF == 0) { ctx->on_file(filesS, macroF->sval[0], file->filename[0], grepF->count > 0); } else { prconf_print_syntax(argtable, argtableS, argtableF); arg_print_errors(stdout, endF, PROGRAM_NAME); arg_print_errors(stdout, endS, PROGRAM_NAME); } cleanup: arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0])); arg_freetable(argtableS, sizeof(argtableS) / sizeof(argtableS[0])); arg_freetable(argtableF, sizeof(argtableF) / sizeof(argtableF[0])); }
int GRTCLCrackCommandLineData::ParseCommandLine(int argc, char *argv[]) { int deviceCount, i; std::vector<std::string> webTableFilenames; // Command line argument parsing with argtable struct arg_lit *verbose = arg_lit0("v", "verbose", "verbose output"); struct arg_lit *silent = arg_lit0(NULL, "silent", "silence all output"); // Table related options struct arg_file *table_file = arg_filen(NULL,NULL,"<file>", 0, 10000, "GRT Tables to use"); struct arg_file *hash_file = arg_file0("f","hashfile","<file>", "Hashfile to use"); struct arg_str *hash_value = arg_str0("s", "hashstring", "hashstring", "The hash string"); struct arg_str *hash_type = arg_str1("h", "hashtype", "{NTLM, MD4, MD5, SHA1}", "hash type to crack"); // CUDA related params struct arg_int *device = arg_int0("d", "device", "<n>", "OpenCL device to use"); struct arg_int *platform = arg_int0("p", "platform", "<n>", "OpenCL platform to use"); struct arg_int *m = arg_int0("m", "ms", "<n>", "target step time in ms"); struct arg_int *blocks = arg_int0("b", "blocks", "<n>", "number of thread blocks to run"); struct arg_int *threads = arg_int0("t", "threads", "<n>", "number of threads per block"); struct arg_lit *zerocopy = arg_lit0("z", "zerocopy", "use zerocopy memory"); struct arg_file *o = arg_file0("o", "outputfile", "outputfile", "output file for results"); // hexoutput: Adds hex output to all password outputs. struct arg_lit *hex_output = arg_lit0(NULL, "hexoutput", "Adds hex output to all hash outputs"); struct arg_lit *amd_kernels = arg_lit0(NULL, "amd", "use AMD vector kernels"); struct arg_int *vector_width = arg_int0(NULL, "vectorwidth", "<n>", "vector width"); struct arg_lit *debug = arg_lit0(NULL, "debug", "Use debug display class"); struct arg_lit *devdebug = arg_lit0(NULL, "devdebug", "Developer debugging output"); struct arg_str *debugfiles = arg_str0(NULL, "debugdumpfiles", "<filename>", "Filename base to dump candidates and chains to"); struct arg_int *prefetch_count = arg_int0(NULL, "prefetch", "<n>", "number of prefetch threads"); struct arg_int *candidates_to_skip = arg_int0(NULL, "skip", "<n>", "number of candidate hashes to skip"); struct arg_str *table_url = arg_str0(NULL, "tableurl", "<URL>", "URL of the web table script"); struct arg_str *table_username = arg_str0(NULL, "tableusername", "<username>", "Username, if required, for the web table script"); struct arg_str *table_password = arg_str0(NULL, "tablepassword", "<password>", "Password, if required, for the web table script"); struct arg_end *end = arg_end(20); void *argtable[] = {verbose,silent,table_file,hash_value,hash_file,hash_type, device,platform,m,blocks,threads,zerocopy,o,amd_kernels,vector_width, debug, devdebug, prefetch_count,table_url,table_username,table_password, candidates_to_skip,debugfiles,hex_output,end}; // Get arguments, collect data, check for basic errors. if (arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); } // Look for errors int nerrors = arg_parse(argc,argv,argtable); if (nerrors > 0) { // Print errors, exit. arg_print_errors(stdout,end,argv[0]); //arg_print_syntax(stdout,argtable,"\n\n"); printf("\n\nOptions: \n"); arg_print_glossary(stdout,argtable," %-20s %s\n"); exit(1); } // Verbose & silent if (verbose->count) { this->Verbose = 1; } if (silent->count) { this->Silent = 1; } if (zerocopy->count) { this->CUDAUseZeroCopy = 1; } if (debug->count) { this->Debug = 1; } if (devdebug->count) { this->Debug = 1; this->DeveloperDebug = 1; } if (debugfiles->count) { this->DebugDump = 1; this->DebugDumpFilenameBase = *debugfiles->sval; } if (prefetch_count->count) { this->NumberPrefetchThreads = *prefetch_count->ival; } if (candidates_to_skip->count) { this->CandidateHashesToSkip = *candidates_to_skip->ival; } // Web table stuff if (table_url->count) { this->useWebTable = 1; this->tableURL = *table_url->sval; // If someone has NOT specified the candidates to skip, set to default. if (!candidates_to_skip->count) { this->CandidateHashesToSkip = DEFAULT_CANDIDATES_TO_SKIP; } } if (table_username->count) { this->tableUsername = *table_username->sval; } if (table_password->count) { this->tablePassword = *table_password->sval; } this->HashType = this->GRTHashTypes->GetHashIdFromString(*hash_type->sval); if (this->HashType == -1) { printf("Unknown hash type %s: Exiting.\n\n", *hash_type->sval); exit(1); } int correct_length = this->GRTHashTypes->GetHashLengthFromId(this->HashType); // if we know the correct length, we make sure the hash is the correct length if (correct_length != 0) { if ((hash_value->count) && (strlen(*hash_value->sval) != correct_length)) { printf("Hash string is not %d hex characters. Exiting.\n\n", correct_length); exit(1); } } if (hash_value->count) { convertAsciiToBinary(*hash_value->sval, this->Hash, 16); } else if (hash_file->count) { this->hashFileName = hash_file->filename[0]; this->useHashFile = 1; } else { printf("Must provide a hash value or a hash file!\n"); exit(1); } if (o->count) { this->outputHashFileName = o->filename[0]; this->useOutputHashFile = 1; } // Desired kernel time if (m->count) { this->KernelTimeMs = *m->ival; } // Do this to emulate CUDA behavior for now... // Threads - if not set, leave at default 0 if (threads->count) { this->OpenCLWorkitems = *threads->ival; } // Blocks - if not set, leave at default 0 if (blocks->count) { this->OpenCLWorkgroups = *blocks->ival * this->OpenCLWorkitems; } if (hex_output->count) { this->AddHexOutput = 1; } // Allocate space for the list of pointers // Create the table header type if (this->useWebTable) { this->TableHeader = new GRTTableHeaderVWeb(); this->TableHeader->setWebURL(this->tableURL); this->TableHeader->setWebUsername(this->tableUsername); this->TableHeader->setWebPassword(this->tablePassword); GRTTableHeaderVWeb *WebTableHeader = (GRTTableHeaderVWeb *)this->TableHeader; webTableFilenames = WebTableHeader->getHashesFromServerByType(this->HashType); } else { // V1 will work for both V1 & V2 types this->TableHeader = new GRTTableHeaderV1(); } // If we don't have any table filenames, get the ones from the web. // Note: The script ONLY reutrns valid tables. if ((table_file->count == 0) && this->useWebTable) { this->Table_File_Count = webTableFilenames.size(); this->Table_Filenames = (char **)malloc(this->Table_File_Count * sizeof(char *)); for (i = 0; i < this->Table_File_Count; i++) { // Increment size by 1 for null termination this->Table_Filenames[i] = (char *)malloc((webTableFilenames.at(i).size() + 1) * sizeof(char)); strcpy(this->Table_Filenames[i], webTableFilenames.at(i).c_str()); } } else { this->Table_File_Count = table_file->count; this->Table_Filenames = (char **)malloc(this->Table_File_Count * sizeof(char *)); // Handle the file list sanely for (i = 0; i < table_file->count; i++) { // Check to ensure the file is valid if (!this->TableHeader->isValidTable(table_file->filename[i], -1)) { printf("%s is not a valid GRT table! Exiting.\n", table_file->filename[i]); exit(1); } // Check to ensure the file is of the right type if (!this->TableHeader->isValidTable(table_file->filename[i], this->HashType)) { printf("%s is not a valid %s GRT table!\n", table_file->filename[i], this->GRTHashTypes->GetHashStringFromId(this->HashType)); exit(1); } // Increment size by 1 for null termination this->Table_Filenames[i] = (char *)malloc((strlen(table_file->filename[i]) + 1) * sizeof(char)); strcpy(this->Table_Filenames[i], table_file->filename[i]); } } // Finally, set the CUDA device and look for errors. if (device->count) { this->OpenCLDevice = *device->ival; } if (platform->count) { this->OpenCLPlatform = *platform->ival; } if (amd_kernels->count) { this->useAmdKernels = 1; this->vectorWidth = 4; } if (vector_width->count) { this->vectorWidth = *vector_width->ival; } }
int _tmain(int argc, char* argv[]) { // determine my process name _splitpath(argv[0],NULL,NULL,gszProcName,NULL); #else int main(int argc, const char** argv) { // determine my process name CUtility::splitpath((char *)argv[0],NULL,gszProcName); #endif int iScreenLogLevel; // level of screen diagnostics int iFileLogLevel; // level of file diagnostics char szLogFile[_MAX_PATH]; // write diagnostics to this file int Rslt; int iProcMode; int iMinLength; int iMaxLength; int iMinMergeLength; int iMaxMergeLength; char szRefFile[_MAX_PATH]; // process ref hypers from this file char szRelFile[_MAX_PATH]; // process rel hypers from this file char szOutLociFile[_MAX_PATH]; // write loci to this file char szRefSpecies[cMaxDatasetSpeciesChrom]; // use this species as the ref species in generated szOutLociFile char szRelSpecies[cMaxDatasetSpeciesChrom]; // use this species/list as the rel species in generated szOutLociFile char szElType[cMaxDatasetSpeciesChrom]; // use this as the element type in generated szOutLociFile int iRefExtend; // extend ref element lengths left+right by this many bases int iRelExtend; // extend rel element lengths left+right by this many bases int iJoinDistance; // if > 0 then join elements which only differ by at most this distance beween end of element i and start of element i+1 // command line args struct arg_lit *help = arg_lit0("h","help", "print this help and exit"); struct arg_lit *version = arg_lit0("v","version,ver", "print version information and exit"); struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to screen and logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug"); struct arg_file *LogFile = arg_file0("F","log","<file>", "diagnostics log file"); struct arg_file *RefFile = arg_file1("i","reffile","<file>", "reference hyper element CSV file"); struct arg_file *RelFile = arg_file0("I","relfile","<file>", "relative hyper element CSV file"); struct arg_file *OutLociFile = arg_file1("o",NULL,"<file>", "output loci to file as CSV"); struct arg_str *RefSpecies = arg_str1("r","refspecies","<string>","output loci file ref species"); struct arg_str *RelSpecies = arg_str1("R","relspecies","<string>","output loci file rel species"); struct arg_str *ElType = arg_str0("t","eltype","<string>","output loci file element type"); struct arg_int *ProcMode = arg_int0("p","mode","<int>", "processing mode: 0:Intersect (Ref & Rel)\n\t\t1:Ref exclusive (Ref & !Rel)\n\t\t2:Rel exclusive (!Ref & Rel)\n\t\t3:Union (Ref | Rel)\n\t\t4:Neither (!(Ref | Rel))"); struct arg_int *MinLength = arg_int0("l","minlength","<int>", "minimum input ref/rel element length (default 4)"); struct arg_int *MaxLength = arg_int0("L","maxlength","<int>", "maximum input ref/rel element length (default 1000000)"); struct arg_int *MinMergeLength = arg_int0("m","minmergelength","<int>","minimum merged output element length (default 4)"); struct arg_int *MaxMergeLength = arg_int0("M","maxmergelength","<int>","maximum merged output element length (default 1000000)"); struct arg_int *RefExtend = arg_int0("e","refextend","<int>", "extend ref element flanks left+right by this many bases (default 0)"); struct arg_int *RelExtend = arg_int0("E","relextend","<int>", "extend rel element flanks left+right by this many bases (default 0)"); struct arg_int *JoinDistance = arg_int0("j","join","<int>", "merge output elements which are only separated by this number of bases (default 0)"); struct arg_end *end = arg_end(20); void *argtable[] = {help,version,FileLogLevel,LogFile, ProcMode, RefFile,RelFile,OutLociFile, MinLength,MaxLength,RefExtend,RelExtend,JoinDistance,MinMergeLength,MaxMergeLength, RefSpecies,RelSpecies,ElType, end}; char **pAllArgs; int argerrors; argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs); if(argerrors >= 0) argerrors = arg_parse(argerrors,pAllArgs,argtable); /* special case: '--help' takes precedence over error reporting */ if (help->count > 0) { printf("\n%s CSV Merge Elements, Version %s\nOptions ---\n", gszProcName,cpszProgVer); arg_print_syntax(stdout,argtable,"\n"); arg_print_glossary(stdout,argtable," %-25s %s\n"); printf("\nNote: Parameters can be entered into a parameter file, one parameter per line."); printf("\n To invoke this parameter file then precede its name with '@'"); printf("\n e.g. %s @myparams.txt\n",gszProcName); printf("\nPlease report any issues regarding usage of %s at https://github.com/csiro-crop-informatics/biokanga/issues\n\n",gszProcName); exit(1); } /* special case: '--version' takes precedence error reporting */ if (version->count > 0) { printf("\n%s Version %s\n",gszProcName,cpszProgVer); exit(1); } if (!argerrors) { if(FileLogLevel->count && !LogFile->count) { printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>'",FileLogLevel->ival[0]); exit(1); } iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo; if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug) { printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d",iFileLogLevel,eDLNone,eDLDebug); exit(1); } if(LogFile->count) { strncpy(szLogFile,LogFile->filename[0],_MAX_PATH); szLogFile[_MAX_PATH-1] = '\0'; } else { iFileLogLevel = eDLNone; szLogFile[0] = '\0'; } iProcMode = ProcMode->count ? ProcMode->ival[0] : ePMElIntersect; if(iProcMode < ePMElIntersect || iProcMode > ePMElRefNotRefRel) { printf("Error: Processing mode '-p%d' is not in range 0..4",iProcMode); exit(1); } strncpy(szOutLociFile,OutLociFile->filename[0],_MAX_PATH); szOutLociFile[_MAX_PATH-1] = '\0'; strncpy(szRefSpecies,RefSpecies->sval[0],sizeof(szRefSpecies)); szRefSpecies[sizeof(szRefSpecies)-1] = '\0'; strncpy(szRelSpecies,RelSpecies->sval[0],sizeof(szRelSpecies)); szRelSpecies[sizeof(szRelSpecies)-1] = '\0'; if(ElType->count) { strncpy(szElType,ElType->sval[0],sizeof(szElType)); szElType[sizeof(szElType)-1] = '\0'; } else strcpy(szElType,"merged"); iMinLength = MinLength->count ? MinLength->ival[0] : cDfltMinLength; if(iMinLength < 0 || iMinLength > cMaxLengthRange) { printf("Error: Minimum element length '-l%d' is not in range 0..%d",iMinLength,cMaxLengthRange); exit(1); } iMaxLength = MaxLength->count ? MaxLength->ival[0] : cDfltMaxLength; if(iMaxLength < iMinLength || iMaxLength > cMaxLengthRange) { printf("Error: Maximum element length '-L%d' is not in range %d..%d",iMaxLength,iMinLength,cMaxLengthRange); exit(1); } iMinMergeLength = MinMergeLength->count ? MinMergeLength->ival[0] : cDfltMinLength; if(iMinMergeLength < 0 || iMinMergeLength > cMaxLengthRange) { printf("Error: Minimum output merged element length '-m%d' is not in range 0..%d",iMinMergeLength,cMaxLengthRange); exit(1); } iMaxMergeLength = MaxMergeLength->count ? MaxMergeLength->ival[0] : cDfltMaxLength; if(iMaxMergeLength < iMinMergeLength || iMaxMergeLength > cMaxLengthRange) { printf("Error: Maximum element length '-M%d' is not in range %d..%d",iMaxMergeLength,iMinMergeLength,cMaxLengthRange); exit(1); } iJoinDistance = JoinDistance->count ? JoinDistance->ival[0] : cDfltJoinOverlap; if(iJoinDistance < 0 || iJoinDistance > cMaxJoinOverlap) { printf("Error: Join separation length '-j%d' is not in range %d..%d",iJoinDistance,0,cMaxJoinOverlap); exit(1); } iRefExtend = RefExtend->count ? RefExtend->ival[0] : 0; if(iRefExtend < (-1 * cMaxExtendLength) || iRefExtend > cMaxExtendLength) { printf("Error: Ref Extension length '-e%d' is not in range %d..%d",iRefExtend,(-1 * cMaxExtendLength),cMaxExtendLength); exit(1); } iRelExtend = RelExtend->count ? RelExtend->ival[0] : 0; if(iRelExtend < (-1 * cMaxExtendLength) || iRelExtend > cMaxExtendLength) { printf("Error: Rel Extension length '-E%d' is not in range %d..%d",iRelExtend,(-1 * cMaxExtendLength),cMaxExtendLength); exit(1); } strncpy(szRefFile,RefFile->filename[0],_MAX_PATH); szRefFile[_MAX_PATH-1] = '\0'; if(RelFile->count) { strncpy(szRelFile,RelFile->filename[0],_MAX_PATH); szRelFile[_MAX_PATH-1] = '\0'; } else { if(iProcMode == ePMElRefExclusive || iProcMode == ePMElRefRelUnion) szRelFile[0] = '\0'; else { printf("Error: Rel loci file must be specified in processing mode '-p%d' (%s)",iProcMode,ProcMode2Txt((etProcMode)iProcMode)); exit(1); } } // now that command parameters have been parsed then initialise diagnostics log system if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true)) { printf("\nError: Unable to start diagnostics subsystem."); if(szLogFile[0] != '\0') printf(" Most likely cause is that logfile '%s' can't be opened/created",szLogFile); exit(1); } gDiagnostics.DiagOut(eDLInfo,gszProcName,"Version: %s Processing parameters:",cpszProgVer); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Processing Mode: %d (%s)",iProcMode,ProcMode2Txt((etProcMode)iProcMode)); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Reference CSV file: '%s'",szRefFile); if(szRelFile[0] != '\0') gDiagnostics.DiagOutMsgOnly(eDLInfo,"Relative CSV file: '%s'",szRelFile); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output processed loci into CSV file: '%s'",szOutLociFile); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output loci file ref species: '%s'",szRefSpecies); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output loci file rel species: '%s'",szRelSpecies); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output loci file element type: '%s'",szElType); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Minimum input element length: %d",iMinLength); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Maximum input element length: %d",iMaxLength); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Ref element flank extension length: %d",iRefExtend); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Rel element flank extension length: %d",iRelExtend); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Merge output elements separated by at most this many bases: %d",iJoinDistance); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Minimum output merged element length: %d",iMinMergeLength); gDiagnostics.DiagOutMsgOnly(eDLInfo,"Maximum output merged element length: %d",iMaxMergeLength); // processing here... gStopWatch.Start(); #ifdef _WIN32 SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS); #endif Rslt = Process((etProcMode)iProcMode,iMinLength,iMaxLength,iRefExtend,iRelExtend,iJoinDistance,iMinMergeLength,iMaxMergeLength,szRefFile,szRelFile,szOutLociFile, szRefSpecies,szRelSpecies,szElType); gStopWatch.Stop(); Rslt = Rslt >=0 ? 0 : 1; gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read()); exit(Rslt); } else { printf("\n%s CSV Merge Elements, Version %s\n",gszProcName,cpszProgVer); arg_print_errors(stdout,end,gszProcName); arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n"); exit(1); } }
int main(int argc, char* argv[]) { #ifdef BALL double discountFactor = 0.9; #else #ifdef CART_POLE double discountFactor = 0.95; #else #ifdef DOUBLE_CART_POLE double discountFactor = 0.95; #else #ifdef MOUNTAIN_CAR double discountFactor = 0.99; #else #ifdef ACROBOT double discountFactor = 0.95; #else #ifdef BOAT double discountFactor = 0.95; #else #ifdef CART_POLE_BINARY double discountFactor = 0.95; #else #ifdef SWIMMER double discountFactor = 0.95; #endif #endif #endif #endif #endif #endif #endif #endif FILE* initFileFd = NULL; state** initialStates = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int h = 0; unsigned int* ns = NULL; unsigned int nbN = 0; unsigned int n = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; optimistic_instance* optimistic = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of maximum numbers of evaluations"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(6); int nerrors = 0; void* argtable[6]; argtable[0] = initFile; argtable[1] = r; argtable[2] = s; argtable[3] = k; argtable[4] = where; argtable[5] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 6); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 6); return EXIT_FAILURE; } initGenerativeModelParameters(); K = k->ival[0]; initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &n); initialStates = (state**)malloc(sizeof(state*) * n); for(; i < n; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); initialStates[i] = makeState(str); } fclose(initFileFd); nbSteps = s->ival[0]; ns = parseUnsignedIntList((char*)r->sval[0], &nbN); optimistic = optimistic_initInstance(NULL, discountFactor); sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps); results = fopen(str, "w"); for(h = 0; h < nbN; h++) { double sumRewards = 0.0; for(i = 0; i < n; i++) { unsigned int j = 0; state* crt = copyState(initialStates[i]); optimistic_resetInstance(optimistic, crt); for(; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; optimistic_keepSubtree(optimistic); action* optimalAction = optimistic_planning(optimistic, ns[h]); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0; freeState(crt); crt = nextState; sumRewards += reward; if(isTerminal) break; } optimistic_resetInstance(optimistic, crt); freeState(crt); printf(">>>>>>>>>>>>>> %uth initial state processed\n", i + 1); fflush(NULL); } fprintf(results, "%u,%.15f\n", ns[h], sumRewards / (double)n); printf(">>>>>>>>>>>>>> n = %u done\n\n", ns[h]); fflush(NULL); } fclose(results); arg_freetable(argtable, 6); for(i = 0; i < n; i++) freeState(initialStates[i]); free(initialStates); optimistic_uninitInstance(&optimistic); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
int main(int argc, char** argv) { struct arg_int *numVerticesArg = arg_int0("v","vertices",NULL, "num vertices (default is 20)"); struct arg_int *numObjectsArg = arg_int0("o","objects",NULL, "num objects (default is 20)"); struct arg_lit *help = arg_lit0(NULL,"help", "print this help and exit"); struct arg_str *rendererArg = arg_str1(NULL,NULL,"RENDERER",NULL); struct arg_end *end = arg_end(20); void* argtable[] = {numVerticesArg, numObjectsArg, help, rendererArg, end}; const char* progname = "gl-instancing"; int exitcode=0; int nerrors; renderer *renderer; int numVertices = 20; int numObjects = 20; /* verify the argtable[] entries were allocated sucessfully */ if (arg_nullcheck(argtable) != 0) { /* NULL entries were detected, some allocations must have failed */ printf("%s: insufficient memory\n",progname); exitcode=1; goto exit; } /* Parse the command line as defined by argtable[] */ nerrors = arg_parse(argc,argv,argtable); /* special case: '--help' takes precedence over error reporting */ if (help->count > 0) { printUsage(stderr, progname, argtable); goto exit; } if (numVerticesArg->count > 0) { numVertices = numVerticesArg->ival[0]; } if (numObjectsArg->count > 0) { numObjects = numObjectsArg->ival[0]; } if (rendererArg->count == 0) { fprintf(stderr, "Provide a renderer!\n"); printUsage(stderr, progname, argtable); goto exit; } if (rendererArg->count > 0) { if (strcmp(rendererArg->sval[0], "standard") == 0) { renderer = getStandardRenderer(numVertices, numObjects); } else if (strcmp(rendererArg->sval[0], "instanced") == 0) { renderer = getInstancedRenderer(numVertices, numObjects); } else { fprintf(stderr, "Renderer %s is unknown. Supported renderers: instanced, standard\n", rendererArg->sval[0]); printUsage(stderr, progname, argtable); goto exit; } } exitcode = glMain(renderer); exit: /* deallocate each non-null entry in argtable[] */ arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0])); return exitcode; }
split_options_t *new_split_cli_options() { split_options_t *options = (split_options_t*) malloc (sizeof(split_options_t)); options->num_options = NUM_SPLIT_OPTIONS; options->criterion = arg_str1(NULL, "criterion", NULL, "Criterion for splitting the file"); return options; }
int main(int argc, char* argv[]) { #ifdef BALL double discountFactor = 0.9; #else #ifdef CART_POLE double discountFactor = 0.95; #else #ifdef DOUBLE_CART_POLE double discountFactor = 0.95; #else #ifdef MOUNTAIN_CAR double discountFactor = 0.99; #else #ifdef ACROBOT double discountFactor = 0.95; #else #ifdef BOAT double discountFactor = 0.95; #else #ifdef SWIMMER double discountFactor = 0.95; #endif #endif #endif #endif #endif #endif #endif FILE* initFileFd = NULL; state** initialStates = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int* ns = NULL; unsigned int nbN = 0; unsigned int* hs = NULL; unsigned int nbH = 0; unsigned int n = 0; unsigned int nbSteps = 0; unsigned int nbIterations = 1; unsigned int timestamp = time(NULL); int readFscanf = -1; random_search_instance* random_search = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of maximum numbers of evaluations"); struct arg_str* d = arg_str1("h", NULL, "<s>", "List of depth"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_int* it = arg_int1("i", NULL, "<n>", "Number of iteration"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(7); int nerrors = 0; void* argtable[7]; argtable[0] = initFile; argtable[1] = r; argtable[2] = d; argtable[3] = s; argtable[4] = it; argtable[5] = where; argtable[6] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 7); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 7); return EXIT_FAILURE; } initGenerativeModelParameters(); initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &n); initialStates = (state**)malloc(sizeof(state*) * n); for(; i < n; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); initialStates[i] = makeState(str); } fclose(initFileFd); nbSteps = s->ival[0]; nbIterations = it->ival[0]; ns = parseUnsignedIntList((char*)r->sval[0], &nbN); hs = parseUnsignedIntList((char*)d->sval[0], &nbH); random_search = random_search_initInstance(NULL, discountFactor); h_max = h_max_crt_depth; sprintf(str, "%s/%u_results_random_search_%s.csv", where->filename[0], timestamp,(char*)r->sval[0]); results = fopen(str, "w"); for(i = 0; i < nbIterations; i++) { unsigned int j = 0; for(;j < nbH; j++) { unsigned int k = 0; crtDepth = hs[j]; for(; k < nbN; k++) { unsigned int l = 0; double sumRewards = 0.0; for(; l < n; l++) { unsigned int m = 0; state* crt = copyState(initialStates[l]); for(; m < nbSteps; m++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; double* optimalAction = NULL; random_search_resetInstance(random_search, crt); optimalAction = random_search_planning(random_search, ns[k]); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0; freeState(crt); free(optimalAction); crt = nextState; sumRewards += reward; if(isTerminal) break; } random_search_resetInstance(random_search, crt); freeState(crt); printf(">>>>>>>>>>>>>> %uth initial state processed with h=%u and n=%u of iteration %u\n", l + 1, hs[j], ns[k], i+1); fflush(NULL); } fprintf(results, "%u,%u,%.15f\n", hs[j],ns[k], sumRewards / (double)n); printf(">>>>>>>>>>>>>> n = %u done\n\n", ns[k]); fflush(NULL); } printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> h = %u done \n\n", hs[j]); fflush(NULL); } fprintf(results,"\n"); printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ITERATION %u DONE <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\n\n", i+1); fflush(NULL); } fclose(results); arg_freetable(argtable, 7); for(i = 0; i < n; i++) freeState(initialStates[i]); free(initialStates); random_search_uninitInstance(&random_search); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { #ifdef BALL double discountFactor = 0.9; #else #ifdef CART_POLE double discountFactor = 0.95; #else #ifdef DOUBLE_CART_POLE double discountFactor = 0.95; #else #ifdef MOUNTAIN_CAR double discountFactor = 0.99; #else #ifdef ACROBOT double discountFactor = 0.95; #else #ifdef BOAT double discountFactor = 0.95; #else #ifdef SWIMMER double discountFactor = 0.95; #endif #endif #endif #endif #endif #endif #endif FILE* initFileFd = NULL; state** initialStates = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int nbInitialStates = 0; unsigned int* ns = NULL; unsigned int nbN = 0; double* Ls = NULL; unsigned int nbL = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; lipschitzian_instance* lipschitzian = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of ressources"); struct arg_str* z = arg_str1("L", NULL, "<s>", "List of Lipschitz coefficients to try"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(6); int nerrors = 0; void* argtable[6]; argtable[0] = initFile; argtable[1] = r; argtable[2] = s; argtable[3] = z; argtable[4] = where; argtable[5] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 6); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 6); return EXIT_FAILURE; } initGenerativeModelParameters(); initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &nbInitialStates); initialStates = (state**)malloc(sizeof(state*) * nbInitialStates); for(; i < nbInitialStates; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); initialStates[i] = makeState(str); } fclose(initFileFd); nbSteps = s->ival[0]; Ls = parseDoubleList((char*)z->sval[0], &nbL); ns = parseUnsignedIntList((char*)r->sval[0], &nbN); sprintf(str, "%s/%u_results_%s_%s.csv", where->filename[0], timestamp, z->sval[0], r->sval[0]); results = fopen(str, "w"); lipschitzian = lipschitzian_initInstance(NULL, discountFactor, 0.0); for(i = 0; i < nbN; i++) { /* Loop on the computational ressources */ fprintf(results, "%u", ns[i]); printf("Starting with %u computational ressources\n", ns[i]); fflush(NULL); unsigned int j = 0; for(; j < nbL; j++) { /* Loop on the Lispchitz constant */ unsigned int k = 0; double average = 0.0; lipschitzian->L = Ls[j]; for(; k < nbInitialStates; k++) { /* Loop on the initial states */ unsigned int l = 0; double sumRewards = 0.0; state* crt = copyState(initialStates[k]); lipschitzian_resetInstance(lipschitzian, crt); for(; l < nbSteps; l++) { /* Loop on the step */ char isTerminal = 0; double reward = 0.0; state* nextState = NULL; double* optimalAction = lipschitzian_planning(lipschitzian, ns[i]); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0; free(optimalAction); freeState(crt); crt = nextState; sumRewards += reward; lipschitzian_resetInstance(lipschitzian,crt); if(isTerminal) break; } average += sumRewards; freeState(crt); printf("Computation of the %u initial state done with L=%f\n", k, Ls[j]); fflush(NULL); } average = average /(double)nbInitialStates; fprintf(results, ",%.15f", average); printf("Computation with L=%f and n=%u done\n", Ls[j], ns[i]); fflush(NULL); } fprintf(results,"\n"); printf("Computation with %u computational ressources done\n\n", ns[i]); fflush(NULL); } fclose(results); arg_freetable(argtable, 6); for(i = 0; i < nbInitialStates; i++) freeState(initialStates[i]); free(initialStates); lipschitzian_uninitInstance(&lipschitzian); free(ns); free(Ls); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { unsigned int i = 0; unsigned int nbIntervals = 0; double* intervals = NULL; FILE* outputFileFd = NULL; gsl_rng* rng = NULL; unsigned int nbStates = 0; struct arg_file* outputFile = arg_file1("o", NULL, "<file>", "The output file for the generated initial state"); struct arg_int* n = arg_int1("n", NULL, "<n>", "The number of initial states to generate"); struct arg_str* s = arg_str1(NULL, "intervals", "<s>", "The intervals for the initial states generation"); struct arg_end* end = arg_end(4); void* argtable[4]; int nerrors = 0; argtable[0] = outputFile; argtable[1] = n; argtable[2] = s; argtable[3] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 4); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 4); return EXIT_FAILURE; } nbStates = n->ival[0]; intervals = parseIntervals(s->sval[0], &nbIntervals); rng = gsl_rng_alloc(gsl_rng_mt19937); gsl_rng_set(rng, time(NULL)); outputFileFd = fopen(outputFile->filename[0], "w"); fprintf(outputFileFd, "%u\n", n->ival[0]); for(; i < nbStates; i++) { unsigned int j = 0; for(; j < (nbIntervals - 1); j++) fprintf(outputFileFd, "%.15f,", (fabs(intervals[(j * 2) + 1] - intervals[j * 2]) * gsl_rng_uniform(rng)) + intervals[j * 2]); fprintf(outputFileFd, "%.15f\n", (fabs(intervals[(j * 2) + 1] - intervals[j * 2]) * gsl_rng_uniform(rng)) + intervals[j * 2]); } fclose(outputFileFd); gsl_rng_free(rng); free(intervals); arg_freetable(argtable, 4); return EXIT_SUCCESS; }