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