int run_task(task_type_t type, metric_type_t metric, task_option_t *options, char *id) {
switch (type) {
case PROCESS:
return handle_process(metric, options, id);
case DIRECTORY:
return handle_directory(options, id);
case DISK:
return handle_disk(metric, options, id);
case SWAP:
return handle_swap(id);
case LOAD:
return handle_load(id);
case TOTAL:
return handle_total(id, metric);
default: {
// We've been passed an incorrectly initialized task. Shouldn't happen, but handle
// for debugging. Plus it gets GCC off my case.
task_report_t report;
init_task_report(&report, id, type, metric);
sprintf(report.message, "FATAL CAUSE INVALID_TASK");
lpush(&reports, &report);
return NOTGIOS_GENERIC_ERROR;
}
}
}
void main_loop(struct loaded_rom& rom, struct moviefile& initial, bool load_has_to_succeed) throw(std::bad_alloc,
std::runtime_error)
{
lsnes_instance.emu_thread = threads::id();
auto& core = CORE();
mywindowcallbacks mywcb(*core.dispatch, *core.runmode, *core.supdater);
core.iqueue->system_thread_available = true;
//Basic initialization.
core.commentary->init();
core.fbuf->init_special_screens();
core.jukebox->set_update([&core]() { core.supdater->update(); });
*core.rom = rom;
init_main_callbacks();
initialize_all_builtin_c_cores();
core_core::install_all_handlers();
//Load our given movie.
bool first_round = false;
bool just_did_loadstate = false;
bool used = false;
try {
do_load_state(initial, LOAD_STATE_INITIAL, used);
core.runmode->set_point(emulator_runmode::P_SAVE);
core.supdater->update();
first_round = core.mlogic->get_mfile().dyn.save_frame;
just_did_loadstate = first_round;
} catch(std::bad_alloc& e) {
OOM_panic();
} catch(std::exception& e) {
if(!used)
delete &initial;
platform::error_message(std::string("Can't load initial state: ") + e.what());
messages << "ERROR: Can't load initial state: " << e.what() << std::endl;
if(load_has_to_succeed) {
messages << "FATAL: Can't load movie" << std::endl;
throw;
}
core.runmode->set_corrupt();
core.fbuf->redraw_framebuffer(emu_framebuffer::screen_corrupt);
}
core.runmode->set_pause_cond(initial.start_paused);
platform::set_paused(core.runmode->is_paused());
stop_at_frame_active = false;
core.lua2->run_startup_scripts();
while(!core.runmode->is_quit() || !queued_saves.empty()) {
if(handle_corrupt()) {
first_round = *core.mlogic && core.mlogic->get_mfile().dyn.save_frame;
just_did_loadstate = first_round;
continue;
}
core.framerate->ack_frame_tick(framerate_regulator::get_utime());
core.runmode->decay_skiplag();
if(!first_round) {
core.controls->reset_framehold();
if(!macro_hold_1 && !macro_hold_2) {
core.controls->advance_macros();
}
macro_hold_2 = false;
core.mlogic->get_movie().get_pollcounters().set_framepflag(false);
core.mlogic->new_frame_starting(core.runmode->is_skiplag());
core.mlogic->get_movie().get_pollcounters().set_framepflag(true);
if(core.runmode->is_quit() && queued_saves.empty())
break;
handle_saves();
int r = 0;
if(queued_saves.empty())
r = handle_load();
if(r > 0 || core.runmode->is_corrupt()) {
core.mlogic->get_movie().get_pollcounters().set_framepflag(
core.mlogic->get_mfile().dyn.save_frame != 0);
first_round = core.mlogic->get_mfile().dyn.save_frame;
stop_at_frame_active = false;
just_did_loadstate = first_round;
core.controls->reset_framehold();
core.dbg->do_callback_frame(core.mlogic->get_movie().get_current_frame(), true);
continue;
} else if(r < 0) {
//Not exactly desriable, but this at least won't desync.
stop_at_frame_active = false;
if(core.runmode->is_quit())
goto out;
core.runmode->set_pause();
}
}
if(just_did_loadstate) {
//If we just loadstated, we are up to date.
if(core.runmode->is_quit())
break;
platform::set_paused(core.runmode->is_paused());
platform::flush_command_queue();
//We already have done the reset this frame if we are going to do one at all.
core.mlogic->get_movie().set_controls(core.mlogic->update_controls(true));
core.mlogic->get_movie().set_all_DRDY();
just_did_loadstate = false;
}
core.dbg->do_callback_frame(core.mlogic->get_movie().get_current_frame(), false);
core.rom->emulate();
random_mix_timing_entropy();
if(core.runmode->is_freerunning())
platform::wait(core.framerate->to_wait_frame(framerate_regulator::get_utime()));
first_round = false;
core.lua2->callback_do_frame();
}
out:
core.jukebox->unset_update();
core.mdumper->end_dumps();
core_core::uninstall_all_handlers();
core.commentary->kill();
core.iqueue->system_thread_available = false;
//Kill some things to avoid crashes.
core.dbg->core_change();
core.project->set(NULL, true);
core.mwatch->clear_multi(core.mwatch->enumerate());
//Close the ROM.
load_null_rom();
do_load_rom();
}
static int handle(char *buf)
{
TCSession *session = tc_get_session();
char *cmd, *params;
int len, retval;
len = strlen(buf);
if (len > 0 && buf[len-1] == '\n')
buf[--len] = 0;
if (len > 0 && buf[len-1] == '\r')
buf[--len] = 0;
//tc_log_msg(__FILE__, "read from socket: |%s|", buf);
cmd = buf + strspn(buf, " \t");
params = cmd + strcspn(cmd, " \t");
*params++ = 0;
params += strspn(params, " \t");
if (!*cmd) { // not strictly necessary, but lines up else if's nicely
retval = 0;
} else if (strncasecmp(cmd, "config", 2) == 0) {
retval = handle_config(params);
} else if (strncasecmp(cmd, "disable", 2) == 0) {
retval = handle_disable(params);
} else if (strncasecmp(cmd, "dump", 2) == 0) {
dump_vob(client_sock);
retval = 1;
} else if (strncasecmp(cmd, "enable", 2) == 0) {
retval = handle_enable(params);
} else if (strncasecmp(cmd, "help", 2) == 0) {
retval = handle_help(params);
} else if (strncasecmp(cmd, "list", 2) == 0) {
retval = handle_list(params);
} else if (strncasecmp(cmd, "load", 2) == 0) {
retval = handle_load(params);
} else if (strncasecmp(cmd, "parameters", 3) == 0) {
retval = handle_parameter(params);
} else if (strncasecmp(cmd, "pause", 3) == 0) {
tc_pause_request();
retval = 1;
} else if (strncasecmp(cmd, "preview", 3) == 0) {
retval = handle_preview(params);
} else if (strncasecmp(cmd, "progress", 5) == 0) {
session->progress_meter = !session->progress_meter;
retval = 1;
} else if (strncasecmp(cmd, "processing", 10) == 0) {
dump_processing(client_sock);
retval = 1;
} else if (strncasecmp(cmd, "quit", 2) == 0
|| strncasecmp(cmd, "exit", 2) == 0) {
return 0; // tell caller to close socket
} else if (strncasecmp(cmd, "unload", 2) == 0) {
retval = 0; // FIXME: not implemented
} else if (strncasecmp(cmd, "version", 2) == 0) {
sendstr(client_sock, PACKAGE_VERSION "\n");
retval = 1;
} else if (strncasecmp(cmd, "stop", 4)) {
tc_interrupt();
tc_framebuffer_interrupt();
retval = 1;
} else {
retval = 0;
}
sendstr(client_sock, retval ? "OK\n" : "FAILED\n");
return 1; // socket remains open
}
int command_handle(char *buf)
{
int cmd = command_interpret(buf); /* get the command index */
switch (cmd) {
case 0:
break;
case 6:
nand_query();
break;
case 7:
handle_nerase();
break;
case 8: /* nread */
nand_read(NAND_READ);
break;
case 9: /* nreadraw */
nand_read(NAND_READ_RAW);
break;
case 10: /* nreadoob */
nand_read(NAND_READ_OOB);
break;
case 11:
nand_prog();
break;
case 12:
handle_help();
break;
case 13:
handle_version();
break;
case 14:
debug_go();
break;
case 16: /* exit */
printf(" exiting usbboot software\n");
return -1; /* return -1 to break the main.c while
* then run usb_ingenic_cleanup*/
/*case 17:
nand_read(NAND_READ_TO_RAM); */
break;
case 18:
handle_gpio(2);
break;
case 19:
handle_gpio(3);
break;
case 20:
boot(STAGE1_FILE_PATH, STAGE2_FILE_PATH);
break;
case 26:
handle_nmark();
break;
case 28:
handle_load();
break;
case 29:
handle_memtest();
break;
default:
printf(" command not support or input error!\n");
break;
}
return 1;
}
