int CLIB_DECL main(int argc, char *argv[]) { int result = -1; clock_t begin_time; double elapsed_time; core_options *messtest_options = NULL; test_count = 0; failure_count = 0; messtest_options = NULL; /* register options */ messtest_options = options_create(messtest_fail); options_add_entries(messtest_options, messtest_option_entries); options_set_option_callback(messtest_options, OPTION_GAMENAME, handle_arg); /* run MAME's validity checks; if these fail cop out now */ /* NPW 16-Sep-2006 - commenting this out because this cannot be run outside of MAME */ //if (mame_validitychecks(-1)) // goto done; /* run Imgtool's validity checks; if these fail cop out now */ if (imgtool_validitychecks()) goto done; begin_time = clock(); /* parse the commandline */ if (options_parse_command_line(messtest_options, argc, argv, OPTION_PRIORITY_CMDLINE,TRUE)) { fprintf(stderr, "Error while parsing cmdline\n"); goto done; } if (test_count > 0) { elapsed_time = ((double) (clock() - begin_time)) / CLOCKS_PER_SEC; fprintf(stderr, "Tests complete; %i test(s), %i failure(s), elapsed time %.2f\n", test_count, failure_count, elapsed_time); } else { fprintf(stderr, "Usage: %s [test1] [test2]...\n", argv[0]); } result = failure_count; done: if (messtest_options) options_free(messtest_options); return result; }
int cli_execute(int argc, char **argv, const options_entry *osd_options) { core_options *options; astring *gamename = astring_alloc(); astring *exename = astring_alloc(); const char *gamename_option; const game_driver *driver; int result; /* initialize the options manager and add the CLI-specific options */ options = mame_options_init(osd_options); options_add_entries(options, cli_options); /* parse the command line first; if we fail here, we're screwed */ if (options_parse_command_line(options, argc, argv, OPTION_PRIORITY_CMDLINE)) { result = MAMERR_INVALID_CONFIG; goto error; } /* parse the simple commmands before we go any further */ core_filename_extract_base(exename, argv[0], TRUE); result = execute_simple_commands(options, astring_c(exename)); if (result != -1) { goto error; } /* find out what game we might be referring to */ gamename_option = options_get_string(options, OPTION_GAMENAME); core_filename_extract_base(gamename, gamename_option, TRUE); driver = driver_get_name(astring_c(gamename)); /* execute any commands specified */ result = execute_commands(options, astring_c(exename), driver); if (result != -1) { goto error; } /* if we don't have a valid driver selected, offer some suggestions */ if (strlen(gamename_option) > 0 && driver == NULL) { const game_driver *matches[10]; int drvnum; /* get the top 10 approximate matches */ driver_list_get_approx_matches(drivers, gamename_option, ARRAY_LENGTH(matches), matches); /* print them out */ fprintf(stderr, "\n\"%s\" approximately matches the following\n" "supported " GAMESNOUN " (best match first):\n\n", gamename_option); for (drvnum = 0; drvnum < ARRAY_LENGTH(matches); drvnum++) if (matches[drvnum] != NULL) fprintf(stderr, "%-10s%s\n", matches[drvnum]->name, matches[drvnum]->description); /* exit with an error */ result = MAMERR_NO_SUCH_GAME; goto error; } /* run the game */ result = mame_execute(options); error: /* free our options and exit */ options_free(options); astring_free(gamename); astring_free(exename); return result; }
static messtest_result_t run_test(int flags, messtest_results *results) { const game_driver *driver; messtest_result_t rc; clock_t begin_time; double real_run_time; astring *fullpath = NULL; const char *device_opt; const char *fake_argv[2]; core_options *opts; /* lookup driver */ driver = driver_get_name(current_testcase.driver); /* cannot find driver? */ if (driver == NULL) { report_message(MSG_FAILURE, "Cannot find driver '%s'", current_testcase.driver); return MESSTEST_RESULT_STARTFAILURE; } /* prepare testing state */ current_command = current_testcase.commands; state = STATE_READY; test_flags = flags; screenshot_num = 0; runtime_hash = 0; had_failure = FALSE; //videoram = NULL; //videoram_size = 0; /* set up options */ opts = mame_options_init(win_mess_opts); options_set_string(opts, OPTION_GAMENAME, driver->name, OPTION_PRIORITY_CMDLINE); if( current_testcase.bios ) options_set_string(opts, OPTION_BIOS, current_testcase.bios, OPTION_PRIORITY_CMDLINE); options_set_bool(opts, OPTION_SKIP_GAMEINFO, TRUE, OPTION_PRIORITY_CMDLINE); options_set_bool(opts, OPTION_THROTTLE, FALSE, OPTION_PRIORITY_CMDLINE); options_set_bool(opts, OPTION_DEBUG, FALSE, OPTION_PRIORITY_CMDLINE); options_set_bool(opts, OPTION_DEBUG_INTERNAL, FALSE, OPTION_PRIORITY_CMDLINE); options_set_bool(opts, OPTION_WRITECONFIG, FALSE, OPTION_PRIORITY_CMDLINE); if (current_testcase.ram != 0) { options_set_int(opts, OPTION_RAMSIZE, current_testcase.ram, OPTION_PRIORITY_CMDLINE); } /* ugh... hideous ugly fake arguments */ fake_argv[0] = "MESSTEST"; fake_argv[1] = driver->name; options_parse_command_line(opts, ARRAY_LENGTH(fake_argv), (char **) fake_argv, OPTION_PRIORITY_CMDLINE,TRUE); /* preload any needed images */ while(current_command->command_type == MESSTEST_COMMAND_IMAGE_PRELOAD) { /* get the path */ fullpath = assemble_software_path(astring_alloc(), driver, current_command->u.image_args.filename); /* get the option name */ device_opt = device_config_image_interface::device_typename(current_command->u.image_args.device_ident.type); /* set the option */ options_set_string(opts, device_opt, astring_c(fullpath), OPTION_PRIORITY_CMDLINE); /* cleanup */ astring_free(fullpath); fullpath = NULL; /* next command */ current_command++; } /* perform the test */ report_message(MSG_INFO, "Beginning test (driver '%s')", current_testcase.driver); begin_time = clock(); mame_set_output_channel(OUTPUT_CHANNEL_ERROR, messtest_output_error, NULL, NULL, NULL); mame_set_output_channel(OUTPUT_CHANNEL_WARNING, mame_null_output_callback, NULL, NULL, NULL); mame_set_output_channel(OUTPUT_CHANNEL_INFO, mame_null_output_callback, NULL, NULL, NULL); mame_set_output_channel(OUTPUT_CHANNEL_DEBUG, mame_null_output_callback, NULL, NULL, NULL); mame_set_output_channel(OUTPUT_CHANNEL_LOG, mame_null_output_callback, NULL, NULL, NULL); test_osd_interface osd; mame_execute(osd, opts); real_run_time = ((double) (clock() - begin_time)) / CLOCKS_PER_SEC; /* what happened? */ switch(state) { case STATE_ABORTED: report_message(MSG_FAILURE, "Test aborted"); rc = MESSTEST_RESULT_RUNTIMEFAILURE; break; case STATE_DONE: if (had_failure) { report_message(MSG_FAILURE, "Test failed (real time %.2f; emu time %.2f [%i%%])", real_run_time, final_time.as_double(), (int) ((final_time.as_double() / real_run_time) * 100)); rc = MESSTEST_RESULT_RUNTIMEFAILURE; } else { report_message(MSG_INFO, "Test succeeded (real time %.2f; emu time %.2f [%i%%])", real_run_time, final_time.as_double(), (int) ((final_time.as_double() / real_run_time) * 100)); rc = MESSTEST_RESULT_SUCCESS; } break; default: state = STATE_ABORTED; report_message(MSG_FAILURE, "Abnormal termination"); rc = MESSTEST_RESULT_STARTFAILURE; break; } if (results) { results->rc = rc; results->runtime_hash = runtime_hash; } options_free(opts); return rc; }
int main(int argc, char *argv[]) { ERR_VALUE ret = ERR_INTERNAL_ERROR; utils_allocator_init(omp_get_num_procs()); omp_init_lock(&_readCoverageLock); #ifdef _MSC_VER uint64_t startTime = GetTickCount64(); #endif ret = options_module_init(37); if (ret == ERR_SUCCESS) { ret = _init_default_values(); if (ret == ERR_SUCCESS) { ret = options_parse_command_line(argc - 2, argv + 2); if (ret == ERR_SUCCESS) { PROGRAM_OPTIONS po; PROGRAM_STATISTICS st; memset(&st, 0, sizeof(st)); ret = _capture_program_options(&po); if (ret == ERR_SUCCESS) { omp_set_num_threads(po.OMPThreads); const char *cmd = argv[1]; if (strncmp(cmd, "help", sizeof("help")) == 0) { options_print_help(); } else if (strncmp(cmd, "repair", sizeof("repair")) == 0) { size_t refSeqLen = 0; FASTA_FILE seqFile; char *rsFasta = NULL; ret = fasta_load(po.RefSeqFile, &seqFile); if (ret == ERR_SUCCESS) { ret = fasta_read_seq(&seqFile, &rsFasta, &refSeqLen); po.ReferenceSequence = rsFasta; if (ret != ERR_SUCCESS) fasta_free(&seqFile); } if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_vertexLAs); if (ret == ERR_SUCCESS) ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_edgeLAs); if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_ONE_READ), &po.ReadSubArrays); if (ret == ERR_SUCCESS) { const size_t numThreads = omp_get_num_procs(); for (size_t i = 0; i < numThreads; ++i) { dym_array_init_ONE_READ(po.ReadSubArrays + i, 140); _vertexLAs[i] = NULL; _edgeLAs[i] = NULL; } size_t regionCount = 0; PACTIVE_REGION regions = NULL; ret = input_refseq_to_regions(po.ReferenceSequence, refSeqLen, ®ions, ®ionCount); if (ret == ERR_SUCCESS) { const ACTIVE_REGION *pa = NULL; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) _activeRegionCount += (pa->Length / po.TestStep); ++pa; } _activeRegionProcessed = 0; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) repair_reads_in_parallel(pa, &po); ++pa; } input_free_regions(regions, regionCount); } PONE_READ r = po.Reads; for (size_t i = 0; i < po.ReadCount; ++i) { if (r->NumberOfFixes * 100 / r->ReadSequenceLen <= po.ParseOptions.ReadMaxErrorRate) { read_quality_encode(r); read_write_sam(stdout, r); read_quality_decode(r); } ++r; } utils_free(rsFasta); int i = 0; #pragma omp parallel for shared (po) for (i = 0; i < numThreads; ++i) dym_array_finit_ONE_READ(po.ReadSubArrays + i); utils_free(po.ReadSubArrays); } } utils_free(_edgeLAs); utils_free(_vertexLAs); fasta_free(&seqFile); } } else if (strncmp(cmd, "rfreq", sizeof("rfreq")) == 0) { kmer_freq_distribution(&po, po.KMerSize, po.Reads, po.ReadCount); } else if (strncmp(cmd, "call", sizeof("call")) == 0) { fprintf(stderr, "K-mer size: %u\n", po.KMerSize); fprintf(stderr, "Active region length: %u\n", po.RegionLength); fprintf(stderr, "Reference: %s\n", po.RefSeqFile); fprintf(stderr, "Reads: %u\n", po.ReadCount); fprintf(stderr, "Read coverage threshold: %u\n", po.Threshold); fprintf(stderr, "Min. read position quality: %u\n", po.ReadPosQuality); fprintf(stderr, "OpenMP thread count: %i\n", po.OMPThreads); fprintf(stderr, "Output VCF file: %s\n", po.VCFFile); ret = paired_reads_init(); if (ret == ERR_SUCCESS) { if (ret == ERR_SUCCESS) { size_t refSeqLen = 0; FASTA_FILE seqFile; char *rsFasta = NULL; ret = fasta_load(po.RefSeqFile, &seqFile); if (ret == ERR_SUCCESS) { ret = fasta_read_seq(&seqFile, &rsFasta, &refSeqLen); po.ReferenceSequence = rsFasta; if (ret != ERR_SUCCESS) fasta_free(&seqFile); } if (ret == ERR_SUCCESS) { po.VCFFileHandle = NULL; if (*po.VCFFile != '\0') { ret = utils_fopen(po.VCFFile, FOPEN_MODE_WRITE, &po.VCFFileHandle); if (ret == ERR_SUCCESS) dym_array_init_VARIANT_CALL(&po.VCArray, 140); } if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_vertexLAs); if (ret == ERR_SUCCESS) ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_edgeLAs); ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_VARIANT_CALL), &po.VCSubArrays); if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_ONE_READ), &po.ReadSubArrays); if (ret == ERR_SUCCESS) { const size_t numThreads = omp_get_num_procs(); for (size_t i = 0; i < numThreads; ++i) { dym_array_init_VARIANT_CALL(po.VCSubArrays + i, 140); dym_array_init_ONE_READ(po.ReadSubArrays + i, 140); _vertexLAs[i] = NULL; _edgeLAs[i] = NULL; } size_t regionCount = 0; PACTIVE_REGION regions = NULL; ret = input_refseq_to_regions(po.ReferenceSequence, refSeqLen, ®ions, ®ionCount); if (ret == ERR_SUCCESS) { const ACTIVE_REGION *pa = NULL; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) _activeRegionCount += (pa->Length / po.TestStep); ++pa; } _activeRegionProcessed = 0; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) process_active_region_in_parallel(pa, &po); ++pa; } input_free_regions(regions, regionCount); } utils_free(rsFasta); ret = vc_array_merge(&po.VCArray, po.VCSubArrays, numThreads); int i = 0; #pragma omp parallel for shared(po) for (i = 0; i <(int) numThreads; ++i) { dym_array_finit_ONE_READ(po.ReadSubArrays + i); vc_array_finit(po.VCSubArrays + i); } utils_free(po.ReadSubArrays); } utils_free(po.VCSubArrays); } utils_free(_edgeLAs); utils_free(_vertexLAs); if (po.VCFFileHandle != NULL) { if (ret == ERR_SUCCESS) vc_array_print(po.VCFFileHandle, &po.VCArray); vc_array_finit(&po.VCArray); utils_fclose(po.VCFFileHandle); } } fasta_free(&seqFile); } } else printf("fix_reads(): %u\n", ret); printf("Read coverage: %lf\n", _readBaseCount / _totalRegionLength ); paired_reads_finit(); } } } } } options_module_finit(); } #ifdef _MSC_VER uint64_t endTime = GetTickCount64(); fprintf(stderr, "Time: %I64u s\n", (endTime - startTime) / 1000); #endif omp_destroy_lock(&_readCoverageLock); return ret; }
int cli_execute(int argc, char **argv, const options_entry *osd_options) { core_options *options = NULL; const char *gamename_option; const game_driver *driver; int result = MAMERR_FATALERROR; astring gamename; astring exename; try { /* initialize the options manager and add the CLI-specific options */ options = mame_options_init(osd_options); options_add_entries(options, cli_options); /* parse the command line first; if we fail here, we're screwed */ if (options_parse_command_line(options, argc, argv, OPTION_PRIORITY_CMDLINE)) { result = MAMERR_INVALID_CONFIG; goto error; } /* parse the simple commmands before we go any further */ core_filename_extract_base(&exename, argv[0], TRUE); result = execute_simple_commands(options, exename); if (result != -1) goto error; /* find out what game we might be referring to */ gamename_option = options_get_string(options, OPTION_GAMENAME); core_filename_extract_base(&gamename, gamename_option, TRUE); driver = driver_get_name(gamename); /* execute any commands specified */ result = execute_commands(options, exename, driver); if (result != -1) goto error; /* if we don't have a valid driver selected, offer some suggestions */ if (strlen(gamename_option) > 0 && driver == NULL) { const game_driver *matches[10]; int drvnum; /* get the top 10 approximate matches */ driver_list_get_approx_matches(drivers, gamename_option, ARRAY_LENGTH(matches), matches); /* print them out */ fprintf(stderr, "\n\"%s\" approximately matches the following\n" "supported " GAMESNOUN " (best match first):\n\n", gamename_option); for (drvnum = 0; drvnum < ARRAY_LENGTH(matches); drvnum++) if (matches[drvnum] != NULL) fprintf(stderr, "%-18s%s\n", matches[drvnum]->name, matches[drvnum]->description); /* exit with an error */ result = MAMERR_NO_SUCH_GAME; goto error; } /* run the game */ result = mame_execute(options); } catch (emu_fatalerror &fatal) { fprintf(stderr, "%s\n", fatal.string()); if (fatal.exitcode() != 0) result = fatal.exitcode(); } catch (emu_exception &) { fprintf(stderr, "Caught unhandled emulator exception\n"); } catch (std::bad_alloc &) { fprintf(stderr, "Out of memory!\n"); } catch (...) { fprintf(stderr, "Caught unhandled exception\n"); } error: /* free our options and exit */ if (options != NULL) options_free(options); /* report any unfreed memory */ dump_unfreed_mem(); return result; }