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