int
states_main( int argc, char ** argv )
{
struct args args;
int fd;
if ( parse_args( argc, argv, &args ) < 0 )
{
fprintf( stderr, "usage:\n"
"stategen file.st -b -h file.H -c file.C [-s file2.C]\n"
" file.st : input file\n"
" -b : emit base class\n"
" file.H : header file\n"
" file.C : implementation\n"
" file2.C : skeleton implementation\n" );
return( 1 );
}
close( 0 );
close( 1 );
if ( open( args.inputfile, O_RDONLY ) < 0 )
{
fprintf( stderr, "unable to open input file: %s\n",
strerror( errno ));
exit( 1 );
}
init_machine( &args );
yyparse();
fprintf( stderr,
"*** used %d bytes of memory in %d parse entries\n",
machine.bytes_allocated, machine.entries );
if ( args.headerfile )
{
fprintf( stderr, "*** producing header file %s\n", args.headerfile );
unlink( args.headerfile );
open( args.headerfile, O_CREAT | O_WRONLY, 0644 );
dump_machine( DUMP_HEADER );
fflush( stdout );
close( 1 );
}
if ( args.implfile )
{
fprintf( stderr, "*** producing implementation file %s\n",
args.implfile );
unlink( args.implfile );
open( args.implfile, O_CREAT | O_WRONLY, 0644 );
dump_machine( DUMP_CODE );
fflush( stdout );
close( 1 );
}
if ( args.skelfile )
{
fprintf( stderr, "*** producing skeleton file %s\n", args.skelfile );
unlink( args.skelfile );
open( args.skelfile, O_CREAT | O_WRONLY, 0644 );
dump_machine( DUMP_SKELETON );
fflush( stdout );
close( 1 );
}
destroy_machine();
if ( args.emit_base_class )
{
fprintf( stderr, "*** producing state machine base header\n" );
unlink( "pk_state_machine_base.H" );
fd = open( "pk_state_machine_base.H", O_CREAT | O_WRONLY, 0644 );
if (write( fd, baseclassH, strlen( baseclassH )) < 0)
fprintf(stderr, "write base class H failed\n");
close( fd );
fprintf( stderr, "*** producing state machine base impl\n" );
unlink( "pk_state_machine_base.C" );
fd = open( "pk_state_machine_base.C", O_CREAT | O_WRONLY, 0644 );
if (write( fd, baseclassC, strlen( baseclassC )) < 0)
fprintf(stderr, "write base class C failed\n");
close( fd );
}
return 0;
}
int run_game(int game)
{
running_machine *machine;
int error = MAMERR_NONE;
mame_private *mame;
callback_item *cb;
/* create the machine structure and driver */
machine = create_machine(game);
mame = machine->mame_data;
/* looooong term: remove this */
Machine = machine;
/* start in the "pre-init phase" */
mame->current_phase = MAME_PHASE_PREINIT;
/* perform validity checks before anything else */
if (mame_validitychecks(game) != 0)
return MAMERR_FAILED_VALIDITY;
/* loop across multiple hard resets */
mame->exit_pending = FALSE;
while (error == 0 && !mame->exit_pending)
{
init_resource_tracking();
add_free_resources_callback(timer_free);
add_free_resources_callback(state_save_free);
/* use setjmp/longjmp for deep error recovery */
mame->fatal_error_jmpbuf_valid = TRUE;
error = setjmp(mame->fatal_error_jmpbuf);
if (error == 0)
{
int settingsloaded;
/* move to the init phase */
mame->current_phase = MAME_PHASE_INIT;
/* start tracking resources for real */
begin_resource_tracking();
/* if we have a logfile, set up the callback */
mame->logerror_callback_list = NULL;
if (options.logfile)
add_logerror_callback(machine, logfile_callback);
/* then finish setting up our local machine */
init_machine(machine);
/* load the configuration settings and NVRAM */
settingsloaded = config_load_settings();
nvram_load();
/* display the startup screens */
ui_display_startup_screens(!settingsloaded && !options.skip_disclaimer, !options.skip_warnings, !options.skip_gameinfo);
/* ensure we don't show the opening screens on a reset */
options.skip_disclaimer = options.skip_warnings = options.skip_gameinfo = TRUE;
/* start resource tracking; note that soft_reset assumes it can */
/* call end_resource_tracking followed by begin_resource_tracking */
/* to clear out resources allocated between resets */
begin_resource_tracking();
/* perform a soft reset -- this takes us to the running phase */
soft_reset(0);
/* run the CPUs until a reset or exit */
mame->hard_reset_pending = FALSE;
while ((!mame->hard_reset_pending && !mame->exit_pending) || mame->saveload_pending_file != NULL)
{
profiler_mark(PROFILER_EXTRA);
/* execute CPUs if not paused */
if (!mame->paused)
cpuexec_timeslice();
/* otherwise, just pump video updates through */
else
video_frame_update();
/* handle save/load */
if (mame->saveload_schedule_callback)
(*mame->saveload_schedule_callback)(machine);
profiler_mark(PROFILER_END);
}
/* and out via the exit phase */
mame->current_phase = MAME_PHASE_EXIT;
/* stop tracking resources at this level */
end_resource_tracking();
/* save the NVRAM and configuration */
nvram_save();
config_save_settings();
}
mame->fatal_error_jmpbuf_valid = FALSE;
/* call all exit callbacks registered */
for (cb = mame->exit_callback_list; cb; cb = cb->next)
(*cb->func.exit)(machine);
/* close all inner resource tracking */
exit_resource_tracking();
/* free our callback lists */
free_callback_list(&mame->exit_callback_list);
free_callback_list(&mame->reset_callback_list);
free_callback_list(&mame->pause_callback_list);
}
/* destroy the machine */
destroy_machine(machine);
/* return an error */
return error;
}
