int main(int argc, char** argv) { #ifdef _3DS UNUSED(_mPerfShutdown); gfxInitDefault(); osSetSpeedupEnable(true); consoleInit(GFX_BOTTOM, NULL); if (!allocateRomBuffer()) { return 1; } #elif defined(__SWITCH__) UNUSED(_mPerfShutdown); gfxInitDefault(); consoleInit(NULL); #else signal(SIGINT, _mPerfShutdown); #endif int didFail = 0; struct mLogger logger = { .log = _log }; mLogSetDefaultLogger(&logger); struct PerfOpts perfOpts = { false, false, false, 0, 0, 0, false }; struct mSubParser subparser = { .usage = PERF_USAGE, .parse = _parsePerfOpts, .extraOptions = PERF_OPTIONS, .opts = &perfOpts }; struct mArguments args = {}; bool parsed = parseArguments(&args, argc, argv, &subparser); if (!args.fname) { parsed = false; } if (!parsed || args.showHelp) { usage(argv[0], PERF_USAGE); didFail = !parsed; goto cleanup; } if (args.showVersion) { version(argv[0]); goto cleanup; } if (perfOpts.savestate) { _savestate = VFileOpen(perfOpts.savestate, O_RDONLY); free(perfOpts.savestate); } _outputBuffer = malloc(256 * 256 * 4); if (perfOpts.csv) { puts("game_code,frames,duration,renderer"); } if (perfOpts.server) { didFail = !_mPerfRunServer(args.fname, &args, &perfOpts); } else { didFail = !_mPerfRunCore(args.fname, &args, &perfOpts); } free(_outputBuffer); if (_savestate) { _savestate->close(_savestate); } cleanup: freeArguments(&args); #ifdef _3DS gfxExit(); acExit(); #elif defined(__SWITCH__) gfxExit(); #endif return didFail; }
int main(int argc, char** argv) { struct mSDLRenderer renderer = {}; struct mCoreOptions opts = { .useBios = true, .rewindEnable = true, .audioBuffers = 512, .videoSync = false, .audioSync = true, .volume = 0x100, }; struct mArguments args; struct mGraphicsOpts graphicsOpts; struct mSubParser subparser; initParserForGraphics(&subparser, &graphicsOpts); bool parsed = parseArguments(&args, argc, argv, &subparser); if (!parsed || args.showHelp) { usage(argv[0], subparser.usage); freeArguments(&args); return !parsed; } if (args.showVersion) { version(argv[0]); freeArguments(&args); return 0; } renderer.core = mCoreFind(args.fname); if (!renderer.core) { printf("Could not run game. Are you sure the file exists and is a compatible game?\n"); freeArguments(&args); return 1; } renderer.core->desiredVideoDimensions(renderer.core, &renderer.width, &renderer.height); #ifdef BUILD_GL mSDLGLCreate(&renderer); #elif defined(BUILD_GLES2) || defined(USE_EPOXY) mSDLGLES2Create(&renderer); #else mSDLSWCreate(&renderer); #endif renderer.ratio = graphicsOpts.multiplier; if (renderer.ratio == 0) { renderer.ratio = 1; } opts.width = renderer.width * renderer.ratio; opts.height = renderer.height * renderer.ratio; if (!renderer.core->init(renderer.core)) { freeArguments(&args); return 1; } mInputMapInit(&renderer.core->inputMap, &GBAInputInfo); mCoreInitConfig(renderer.core, PORT); applyArguments(&args, &subparser, &renderer.core->config); mCoreConfigLoadDefaults(&renderer.core->config, &opts); mCoreLoadConfig(renderer.core); renderer.viewportWidth = renderer.core->opts.width; renderer.viewportHeight = renderer.core->opts.height; #if SDL_VERSION_ATLEAST(2, 0, 0) renderer.player.fullscreen = renderer.core->opts.fullscreen; renderer.player.windowUpdated = 0; #else renderer.fullscreen = renderer.core->opts.fullscreen; #endif renderer.lockAspectRatio = renderer.core->opts.lockAspectRatio; renderer.filter = renderer.core->opts.resampleVideo; if (!mSDLInit(&renderer)) { freeArguments(&args); renderer.core->deinit(renderer.core); return 1; } renderer.player.bindings = &renderer.core->inputMap; mSDLInitBindingsGBA(&renderer.core->inputMap); mSDLInitEvents(&renderer.events); mSDLEventsLoadConfig(&renderer.events, mCoreConfigGetInput(&renderer.core->config)); mSDLAttachPlayer(&renderer.events, &renderer.player); mSDLPlayerLoadConfig(&renderer.player, mCoreConfigGetInput(&renderer.core->config)); int ret; // TODO: Use opts and config ret = mSDLRun(&renderer, &args); mSDLDetachPlayer(&renderer.events, &renderer.player); mInputMapDeinit(&renderer.core->inputMap); mSDLDeinit(&renderer); freeArguments(&args); mCoreConfigFreeOpts(&opts); mCoreConfigDeinit(&renderer.core->config); renderer.core->deinit(renderer.core); return ret; } int mSDLRun(struct mSDLRenderer* renderer, struct mArguments* args) { struct mCoreThread thread = { .core = renderer->core }; if (!mCoreLoadFile(renderer->core, args->fname)) { return 1; } mCoreAutoloadSave(renderer->core); struct mDebugger* debugger = mDebuggerCreate(args->debuggerType, renderer->core); if (debugger) { mDebuggerAttach(debugger, renderer->core); mDebuggerEnter(debugger, DEBUGGER_ENTER_MANUAL, NULL); } if (args->patch) { struct VFile* patch = VFileOpen(args->patch, O_RDONLY); if (patch) { renderer->core->loadPatch(renderer->core, patch); } } else { mCoreAutoloadPatch(renderer->core); } renderer->audio.samples = renderer->core->opts.audioBuffers; renderer->audio.sampleRate = 44100; bool didFail = !mSDLInitAudio(&renderer->audio, &thread); if (!didFail) { #if SDL_VERSION_ATLEAST(2, 0, 0) mSDLSetScreensaverSuspendable(&renderer->events, renderer->core->opts.suspendScreensaver); mSDLSuspendScreensaver(&renderer->events); #endif if (mCoreThreadStart(&thread)) { renderer->runloop(renderer, &thread); mSDLPauseAudio(&renderer->audio); mCoreThreadJoin(&thread); } else { didFail = true; printf("Could not run game. Are you sure the file exists and is a compatible game?\n"); } #if SDL_VERSION_ATLEAST(2, 0, 0) mSDLResumeScreensaver(&renderer->events); mSDLSetScreensaverSuspendable(&renderer->events, false); #endif if (mCoreThreadHasCrashed(&thread)) { didFail = true; printf("The game crashed!\n"); } } renderer->core->unloadROM(renderer->core); return didFail; } static bool mSDLInit(struct mSDLRenderer* renderer) { if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("Could not initialize video: %s\n", SDL_GetError()); return false; } return renderer->init(renderer); } static void mSDLDeinit(struct mSDLRenderer* renderer) { mSDLDeinitEvents(&renderer->events); mSDLDeinitAudio(&renderer->audio); #if SDL_VERSION_ATLEAST(2, 0, 0) SDL_DestroyWindow(renderer->window); #endif renderer->deinit(renderer); SDL_Quit(); }
int main(int argc, char **argv) { if(isArgumentForShowingVersion(argv)) showVersionAndExit(); char *buf; char *bufCopy; pid_t pid = getpid(); pid_t backgroundJob; int status = 0; char *prompt = getPrompt(); int bg; int jobNumber = 1; int counts; int jumpSet = 0; char *arguments[2048]; initialize(); printf("\n"); setPrompt(prompt); while ((buf = readline(prompt))) { if(strlen(buf) != 0) { bufCopy = buddy_malloc((strlen(buf)+1)*sizeof(char)); strcpy(bufCopy, buf); add_history(bufCopy); } else { printFinishedJobs(jobList); free(buf); continue; } free(buf); if(isCommandNotEmpty(bufCopy)) bg = isBackgroundCommand(bufCopy); getArgument(arguments, bufCopy, &counts); if(isExitCommand(bufCopy)){ buddy_free(bufCopy); freeList(jobList); if(arguments != NULL){ freeArguments(counts, arguments, NULL); } exit(0); } if(isCdCommand(bufCopy, arguments)){ changeDir(arguments); freeArguments(counts, arguments, bufCopy); } else if(isJobsCommand(bufCopy)) { printList(jobList); freeArguments(counts, arguments, bufCopy); } else if(isFgCommand(bufCopy, arguments)){ fg(arguments, jobList, counts, bufCopy); } else if(isBgCommand(bufCopy, arguments)){ bgS(arguments, jobList, counts, bufCopy); } else if (isCommandNotEmpty(bufCopy)) { if(bg == 1) { backgroundJob = fork(); if(backgroundJob == 0) { ignoreSignals(); runCommand(arguments, bufCopy); } else{ NodePtr n = createAndSetNode(&jobNumber, backgroundJob, bufCopy, bg); recordCommand(n, jobNumber, bg); freeArguments(counts, arguments, bufCopy); } } else { pid = fork(); if(pid == 0){ runCommand(arguments, bufCopy); } else { NodePtr n = createAndSetNode(&jobNumber, pid, bufCopy, bg); ignoreSignals(); if((waitpid(pid,&status,WUNTRACED))<0) err_sys("waitpid error"); freeArguments(counts, arguments, bufCopy); restoreSignalsAndDetermineStatus(status, jobList, n); } } } else { freeArguments(counts, arguments, bufCopy); } if(jumpSet == 0){ sigsetjmp(env, 1); jumpSet = 1; } continue; } if(buf == NULL) printf("\n"); exit(0); }
// // MAIN program // int __cdecl main(int argc, char *argv[]) { short rexxrc = 0; /* return code from rexx */ int i; /* loop counter */ int rc; /* actually running program RC */ const char *program_name; /* name to run */ char arg_buffer[8192]; /* starting argument buffer */ char *cp; /* option character pointer */ CONSTRXSTRING arguments; /* rexxstart argument */ size_t argcount; RXSTRING rxretbuf; // program return buffer BOOL from_string = FALSE; /* running from command line string? */ BOOL real_argument = TRUE; /* running from command line string? */ RXSTRING instore[2]; RexxInstance *pgmInst; RexxThreadContext *pgmThrdInst; RexxArrayObject rxargs, rxcargs; RexxDirectoryObject dir; RexxObjectPtr result; rc = 0; /* set default return */ /* * Convert the input array into a single string for the Object REXX * argument string. Initialize the RXSTRING variable to point to this * string. Keep the string null terminated so we can print it for debug. * First argument is name of the REXX program * Next argument(s) are parameters to be passed */ arg_buffer[0] = '\0'; /* default to no argument string */ program_name = NULL; /* no program to run yet */ for (i = 1; i < argc; i++) /* loop through the arguments */ { /* is this an option switch? */ if ((*(cp=*(argv+i)) == '-' || *cp == '/')) { switch (*++cp) { case 'e': case 'E': /* execute from string */ if (from_string == FALSE) { /* only treat 1st -e differently */ from_string = TRUE; if ( argc == i+1 ) { break; } program_name = "INSTORE"; instore[0].strptr = argv[i+1]; instore[0].strlength = strlen(instore[0].strptr); instore[1].strptr = NULL; instore[1].strlength = 0; real_argument = FALSE; } break; case 'v': case 'V': { /* version display */ char *ptr = RexxGetVersionInformation(); if (ptr) { fprintf(stdout, ptr); fprintf(stdout, "\n"); RexxFreeMemory(ptr); } return 0; } default: /* ignore other switches */ break; } } else /* convert into an argument string */ { if (program_name == NULL) { /* no name yet? */ program_name = argv[i]; /* program is first non-option */ break; /* end parsing after program_name has been resolved */ } else if ( real_argument ) { /* part of the argument string */ if (arg_buffer[0] != '\0') { /* not the first one? */ strcat(arg_buffer, " "); /* add an blank */ } strcat(arg_buffer, argv[i]); /* add this to the argument string */ } real_argument = TRUE; } } if (program_name == NULL) { /* give a simple error message */ #undef printf printf("\n"); fprintf(stderr,"Syntax is \"rexx filename [arguments]\"\n"); fprintf(stderr,"or \"rexx -e program_string [arguments]\"\n"); fprintf(stderr,"or \"rexx -v\".\n"); return -1; } else { /* real program execution */ getArguments(NULL, GetCommandLine(), &argcount, &arguments); rxretbuf.strlength = 0L; /* initialize return to empty */ #ifdef REXXC_DEBUG printf("program_name = %s\n", program_name); printf("argv 0 = %s\n", argv[0]); printf("argv 1 = %s\n", argv[1]); printf("argv 2 = %s\n", argv[2]); printf("argument.strptr = %s\n", argument.strptr); printf("argument.strlenth = %lu\n", argument.strlength); #endif if (from_string) { /* Here we call the interpreter. We don't really need to use */ /* all the casts in this call; they just help illustrate */ /* the data types used. */ rc=REXXSTART(argcount, /* number of arguments */ &arguments, /* array of arguments */ program_name, /* name of REXX file */ instore, /* rexx code from command line */ "CMD", /* Command env. name */ RXCOMMAND, /* Code for how invoked */ NULL, &rexxrc, /* Rexx program output */ &rxretbuf ); /* Rexx program output */ /* rexx procedure executed*/ if ((rc==0) && rxretbuf.strptr) { RexxFreeMemory(rxretbuf.strptr); /* Release storage only if */ } freeArguments(NULL, &arguments); } else { RexxCreateInterpreter(&pgmInst, &pgmThrdInst, NULL); // configure the traditional single argument string if ( arguments.strptr != NULL ) { rxargs = pgmThrdInst->NewArray(1); pgmThrdInst->ArrayPut(rxargs, pgmThrdInst->String(arguments.strptr), 1); } else { rxargs = pgmThrdInst->NewArray(0); } // set up the C args into the .local environment dir = (RexxDirectoryObject)pgmThrdInst->GetLocalEnvironment(); if ( argc > 2 ) { rxcargs = pgmThrdInst->NewArray(argc - 2); } else { rxcargs = pgmThrdInst->NewArray(0); } for (i = 2; i < argc; i++) { pgmThrdInst->ArrayPut(rxcargs, pgmThrdInst->NewStringFromAsciiz(argv[i]), i - 1); } pgmThrdInst->DirectoryPut(dir, rxcargs, "SYSCARGS"); // call the interpreter result = pgmThrdInst->CallProgram(program_name, rxargs); // display any error message if there is a condition. // if there was an error, then that will be our return code. // Although the return is a wholenumber_t we know there is no error // code too big to fit in an int. rc = (int)pgmThrdInst->DisplayCondition(); if (rc != 0) { pgmInst->Terminate(); return -rc; // well, the negation of the error number is the return code } // now handle any potential return value if (result != NULL) { pgmThrdInst->ObjectToInt32(result, &rc); } pgmInst->Terminate(); return rc; } } return rc ? rc : rexxrc; // rexx program return cd }
int main(int argc, char** argv) { struct SDLSoftwareRenderer renderer; GBAVideoSoftwareRendererCreate(&renderer.d); struct GBAInputMap inputMap; GBAInputMapInit(&inputMap); struct GBAConfig config; GBAConfigInit(&config, PORT); GBAConfigLoad(&config); struct GBAOptions opts = { .width = VIDEO_HORIZONTAL_PIXELS, .height = VIDEO_VERTICAL_PIXELS, .useBios = true, .rewindEnable = true, .audioBuffers = 512, .videoSync = false, .audioSync = true, }; GBAConfigLoadDefaults(&config, &opts); struct GBAArguments args; struct GraphicsOpts graphicsOpts; struct SubParser subparser; initParserForGraphics(&subparser, &graphicsOpts); bool parsed = parseArguments(&args, &config, argc, argv, &subparser); if (!parsed || args.showHelp) { usage(argv[0], subparser.usage); freeArguments(&args); GBAConfigFreeOpts(&opts); GBAConfigDeinit(&config); return !parsed; } GBAConfigMap(&config, &opts); renderer.viewportWidth = opts.width; renderer.viewportHeight = opts.height; #if SDL_VERSION_ATLEAST(2, 0, 0) renderer.player.fullscreen = opts.fullscreen; renderer.player.windowUpdated = 0; #else renderer.fullscreen = opts.fullscreen; #endif renderer.ratio = graphicsOpts.multiplier; if (renderer.ratio == 0) { renderer.ratio = 1; } renderer.lockAspectRatio = opts.lockAspectRatio; renderer.filter = opts.resampleVideo; #ifdef BUILD_GL GBASDLGLCreate(&renderer); #elif defined(BUILD_GLES2) GBASDLGLES2Create(&renderer); #else GBASDLSWCreate(&renderer); #endif if (!GBASDLInit(&renderer)) { freeArguments(&args); GBAConfigFreeOpts(&opts); GBAConfigDeinit(&config); return 1; } struct GBAThread context = { .renderer = &renderer.d.d, .userData = &renderer }; context.debugger = createDebugger(&args, &context); GBAMapOptionsToContext(&opts, &context); GBAMapArgumentsToContext(&args, &context); bool didFail = false; renderer.audio.samples = context.audioBuffers; renderer.audio.sampleRate = 44100; if (opts.sampleRate) { renderer.audio.sampleRate = opts.sampleRate; } if (!GBASDLInitAudio(&renderer.audio, &context)) { didFail = true; } renderer.player.bindings = &inputMap; GBASDLInitBindings(&inputMap); GBASDLInitEvents(&renderer.events); GBASDLEventsLoadConfig(&renderer.events, GBAConfigGetInput(&config)); GBASDLAttachPlayer(&renderer.events, &renderer.player); GBASDLPlayerLoadConfig(&renderer.player, GBAConfigGetInput(&config)); context.overrides = GBAConfigGetOverrides(&config); if (!didFail) { #if SDL_VERSION_ATLEAST(2, 0, 0) GBASDLSetScreensaverSuspendable(&renderer.events, opts.suspendScreensaver); GBASDLSuspendScreensaver(&renderer.events); #endif if (GBAThreadStart(&context)) { renderer.runloop(&context, &renderer); GBAThreadJoin(&context); } else { didFail = true; printf("Could not run game. Are you sure the file exists and is a Game Boy Advance game?\n"); } #if SDL_VERSION_ATLEAST(2, 0, 0) GBASDLResumeScreensaver(&renderer.events); GBASDLSetScreensaverSuspendable(&renderer.events, false); #endif if (GBAThreadHasCrashed(&context)) { didFail = true; printf("The game crashed!\n"); } } freeArguments(&args); GBAConfigFreeOpts(&opts); GBAConfigDeinit(&config); free(context.debugger); GBASDLDetachPlayer(&renderer.events, &renderer.player); GBAInputMapDeinit(&inputMap); GBASDLDeinit(&renderer); return didFail; } static bool GBASDLInit(struct SDLSoftwareRenderer* renderer) { if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("Could not initialize video: %s\n", SDL_GetError()); return false; } return renderer->init(renderer); } static void GBASDLDeinit(struct SDLSoftwareRenderer* renderer) { GBASDLDeinitEvents(&renderer->events); GBASDLDeinitAudio(&renderer->audio); #if SDL_VERSION_ATLEAST(2, 0, 0) SDL_DestroyWindow(renderer->window); #endif renderer->deinit(renderer); SDL_Quit(); }