/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

*/

/* This file takes care of command line argument parsing, and stdio redirection

*/

#if defined(__APPLE__) && defined(__MACH__)

#include <Carbon/Carbon.h>

#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)

#include <Carbon.h>

#else

#include <Dialogs.h>

#include <Fonts.h>

#include <Events.h>

#include <Resources.h>

#include <Folders.h>

#endif

/* Include the SDL main definition header */

#include "SDL.h"

#include "SDL_main.h"

#ifdef main

#undef main

#endif

/* The standard output files */

#define STDOUT_FILE "stdout.txt"

#define STDERR_FILE "stderr.txt"

#if !defined(__MWERKS__) && !TARGET_API_MAC_CARBON

/* In MPW, the qd global has been removed from the libraries */

QDGlobals qd;

#endif

/* Structure for keeping prefs in 1 variable */

typedef struct

{

Str255 command_line;

Str255 video_driver_name;

/* See if the command key is held down at startup */

static Boolean

CommandKeyIsDown(void)

if (((unsigned char *) theKeyMap)[6] & 0x80) {

return (true);

}

return (false);

}

#if !(defined(__APPLE__) && defined(__MACH__))

static int

ParseCommandLine(char *cmdline, char **argv)

char *bufp;

int argc;

argc = 0;

for (bufp = cmdline; *bufp;) {

/* Skip leading whitespace */

while (SDL_isspace(*bufp)) {

++bufp;

}

/* Skip over argument */

if (*bufp == '"') {

++bufp;

if (*bufp) {

if (argv) {

argv[argc] = bufp;

}

++argc;

}

/* Skip over word */

while (*bufp && (*bufp != '"')) {

++bufp;

}

} else {

if (*bufp) {

if (argv) {

argv[argc] = bufp;

}

++argc;

}

/* Skip over word */

while (*bufp && !SDL_isspace(*bufp)) {

++bufp;

}

}

if (*bufp) {

if (argv) {

*bufp = '\0';

}

++bufp;

}

}

if (argv) {

argv[argc] = NULL;

}

return (argc);

}

/* Remove the output files if there was no output written */

static void

cleanup_output(void)

FILE *file;

int empty;

/* Flush the output in case anything is queued */

fclose(stdout);

fclose(stderr);

/* See if the files have any output in them */

file = fopen(STDOUT_FILE, "rb");

if (file) {

empty = (fgetc(file) == EOF) ? 1 : 0;

fclose(file);

if (empty) {

remove(STDOUT_FILE);

}

}

file = fopen(STDERR_FILE, "rb");

if (file) {

empty = (fgetc(file) == EOF) ? 1 : 0;

fclose(file);

if (empty) {

remove(STDERR_FILE);

}

}

}

#endif //!(defined(__APPLE__) && defined(__MACH__))

static int

getCurrentAppName(StrFileName name)

{

ProcessInfoRec process_info;

FSSpec process_fsp;

process.lowLongOfPSN = kCurrentProcess;

process_info.processInfoLength = sizeof(process_info);

process_info.processName = NULL;

if (noErr != GetProcessInformation(&process, &process_info))

return 0;

return 1;

}

static int

getPrefsFile(FSSpec * prefs_fsp, int create)

{

/* The prefs file name is the application name, possibly truncated, */

/* plus " Preferences */

#define SUFFIX " Preferences"

#define MAX_NAME 19 /* 31 - strlen (SUFFIX) */

short volume_ref_number;

long directory_id;

StrFileName prefs_name;

StrFileName app_name;

if (noErr !=

FindFolder(kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder,

&volume_ref_number, &directory_id))

exit(-1);

if (!getCurrentAppName(app_name))

exit(-1);

SDL_memcpy(prefs_name + 1, app_name + 1, app_name[0]);

SDL_memcpy(prefs_name + app_name[0] + 1, SUFFIX, strlen(SUFFIX));

prefs_name[0] = app_name[0] + strlen(SUFFIX);

if (noErr !=

FSMakeFSSpec(volume_ref_number, directory_id, prefs_name, prefs_fsp))

{

if (!create)

return 0;

else {

/* Create the prefs file */

FSpCreateResFile(prefs_fsp, 0x3f3f3f3f, 'pref', 0); // '????' parsed as trigraph

if (noErr != ResError())

return 0;

}

return 1;

}

static int

readPrefsResource(PrefsRecord * prefs)

{

prefs_handle = Get1Resource('CLne', 128);

if (prefs_handle != NULL) {

int offset = 0;

// int j = 0;

HLock(prefs_handle);

/* Get command line string */

SDL_memcpy(prefs->command_line, *prefs_handle,

(*prefs_handle)[0] + 1);

/* Get video driver name */

offset += (*prefs_handle)[0] + 1;

SDL_memcpy(prefs->video_driver_name, *prefs_handle + offset,

(*prefs_handle)[offset] + 1);

/* Get save-to-file option (1 or 0) */

offset += (*prefs_handle)[offset] + 1;

prefs->output_to_file = (*prefs_handle)[offset];

ReleaseResource(prefs_handle);

return ResError() == noErr;

}

return 0;

}

static int

writePrefsResource(PrefsRecord * prefs, short resource_file)

{

Handle prefs_handle;

UseResFile(resource_file);

prefs_handle = Get1Resource('CLne', 128);

RemoveResource(prefs_handle);

prefs_handle =

NewHandle(prefs->command_line[0] + prefs->video_driver_name[0] + 4);

HLock(prefs_handle);

/* Command line text */

offset = 0;

SDL_memcpy(*prefs_handle, prefs->command_line,

prefs->command_line[0] + 1);

/* Video driver name */

offset += prefs->command_line[0] + 1;

SDL_memcpy(*prefs_handle + offset, prefs->video_driver_name,

prefs->video_driver_name[0] + 1);

/* Output-to-file option */

offset += prefs->video_driver_name[0] + 1;

*(*((char **) prefs_handle) + offset) = (char) prefs->output_to_file;

*(*((char **) prefs_handle) + offset + 1) = 0;

AddResource(prefs_handle, 'CLne', 128, "\pCommand Line");

WriteResource(prefs_handle);

UpdateResFile(resource_file);

DisposeHandle(prefs_handle);

return ResError() == noErr;

}

return 0;

}

static int

readPreferences(PrefsRecord * prefs)

{

FSSpec prefs_fsp;

/* Check for prefs file first */

if (getPrefsFile(&prefs_fsp, 0)) {

short prefs_resource;

prefs_resource = FSpOpenResFile(&prefs_fsp, fsRdPerm);

if (prefs_resource == -1) /* this shouldn't happen, but... */

UseResFile(prefs_resource);

no_error = readPrefsResource(prefs);

CloseResFile(prefs_resource);

/* Fall back to application's resource fork (reading only, so this is safe) */

else {

no_error = readPrefsResource(prefs);

}

return no_error;

}

static int

writePreferences(PrefsRecord * prefs)

{

int no_error = 1;

if (getPrefsFile(&prefs_fsp, 1)) {

short prefs_resource;

prefs_resource = FSpOpenResFile(&prefs_fsp, fsRdWrPerm);

if (prefs_resource == -1)

return 0;

no_error = writePrefsResource(prefs, prefs_resource);

CloseResFile(prefs_resource);

return no_error;

}

/* This is where execution begins */

int

main(int argc, char *argv[])

{

#define DEFAULT_ARGS "\p" /* pascal string for default args */

#define DEFAULT_VIDEO_DRIVER "\ptoolbox" /* pascal string for default video driver name */

#define DEFAULT_OUTPUT_TO_FILE 1 /* 1 == output to file, 0 == no output */

#define VIDEO_ID_DRAWSPROCKET 1 /* these correspond to popup menu choices */

#define VIDEO_ID_TOOLBOX 2

PrefsRecord prefs =

{ DEFAULT_ARGS, DEFAULT_VIDEO_DRIVER, DEFAULT_OUTPUT_TO_FILE };

int nargs;

char **args;

char *commandLine;

StrFileName appNameText;

int videodriver = VIDEO_ID_TOOLBOX;

int settingsChanged = 0;

long i;

/* Kyle's SDL command-line dialog code ... */

InitGraf(&qd.thePort);

InitFonts();

InitWindows();

InitMenus();

InitDialogs(nil);

InitCursor();

FlushEvents(everyEvent, 0);

MoreMasters();

MoreMasters();

/* Intialize SDL, and put up a dialog if we fail */

if (SDL_Init(0) < 0) {

#define kErr_OK 1

#define kErr_Text 2

DialogPtr errorDialog;

short dummyType;

Rect dummyRect;

Handle dummyHandle;

short itemHit;

errorDialog = GetNewDialog(1001, nil, (WindowPtr) - 1);

if (errorDialog == NULL)

return -1;

DrawDialog(errorDialog);

GetDialogItem(errorDialog, kErr_Text, &dummyType, &dummyHandle,

&dummyRect);

SetDialogItemText(dummyHandle, "\pError Initializing SDL");

do {

ModalDialog(nil, &itemHit);

}

while (itemHit != kErr_OK);

DisposeDialog(errorDialog);

exit(-1);

}

atexit(cleanup_output);

atexit(SDL_Quit);

#endif

/* Set up SDL's QuickDraw environment */

#if !TARGET_API_MAC_CARBON

#endif

if (readPreferences(&prefs)) {

if (SDL_memcmp(prefs.video_driver_name + 1, "DSp", 3) == 0)

}

if (CommandKeyIsDown()) {

#define kCL_OK 1

#define kCL_Cancel 2

#define kCL_Text 3

#define kCL_File 4

#define kCL_Video 6

short dummyType;

Rect dummyRect;

Handle dummyHandle;

short itemHit;

#if TARGET_API_MAC_CARBON

#endif

/* Assume that they will change settings, rather than do exhaustive check */

settingsChanged = 1;

commandDialog = GetNewDialog(1000, nil, (WindowPtr) - 1);

#if TARGET_API_MAC_CARBON

SetPort(GetDialogPort(commandDialog));

#else

SetPort(commandDialog);

#endif

SetControlValue(control, prefs.output_to_file);

#else

GetDialogItem(commandDialog, kCL_File, &dummyType, &dummyHandle, &dummyRect); /* MJS */

SetControlValue((ControlHandle) dummyHandle, prefs.output_to_file);

#endif

GetDialogItem(commandDialog, kCL_Text, &dummyType, &dummyHandle,

&dummyRect);

SetDialogItemText(dummyHandle, prefs.command_line);

SetControlValue(control, videodriver);

#else

GetDialogItem(commandDialog, kCL_Video, &dummyType, &dummyHandle,

&dummyRect);

SetControlValue((ControlRef) dummyHandle, videodriver);

#endif

SetDialogDefaultItem(commandDialog, kCL_OK);

SetDialogCancelItem(commandDialog, kCL_Cancel);

do {

ModalDialog(nil, &itemHit); /* wait for user response */

/* Toggle command-line output checkbox */

if (itemHit == kCL_File) {

#if TARGET_API_MAC_CARBON

GetDialogItemAsControl(commandDialog, kCL_File, &control);

SetControlValue(control, !GetControlValue(control));

#else

GetDialogItem(commandDialog, kCL_File, &dummyType, &dummyHandle, &dummyRect); /* MJS */

SetControlValue((ControlHandle) dummyHandle,

!GetControlValue((ControlHandle)

dummyHandle));

#endif

}

}

while (itemHit != kCL_OK && itemHit != kCL_Cancel);

/* Get control values, even if they did not change */

GetDialogItem(commandDialog, kCL_Text, &dummyType, &dummyHandle, &dummyRect); /* MJS */

GetDialogItemText(dummyHandle, prefs.command_line);

GetDialogItemAsControl(commandDialog, kCL_File, &control);

prefs.output_to_file = GetControlValue(control);

#else

GetDialogItem(commandDialog, kCL_File, &dummyType, &dummyHandle, &dummyRect); /* MJS */

prefs.output_to_file = GetControlValue((ControlHandle) dummyHandle);

#endif

GetDialogItemAsControl(commandDialog, kCL_Video, &control);

videodriver = GetControlValue(control);

#else

GetDialogItem(commandDialog, kCL_Video, &dummyType, &dummyHandle,

&dummyRect);

videodriver = GetControlValue((ControlRef) dummyHandle);

#endif

if (itemHit == kCL_Cancel) {

exit(0);

}

switch (videodriver) {

case VIDEO_ID_DRAWSPROCKET:

SDL_putenv("SDL_VIDEODRIVER=DSp");

SDL_memcpy(prefs.video_driver_name, "\pDSp", 4);

break;

case VIDEO_ID_TOOLBOX:

SDL_putenv("SDL_VIDEODRIVER=toolbox");

SDL_memcpy(prefs.video_driver_name, "\ptoolbox", 8);

break;

}

if (prefs.output_to_file) {

freopen(STDOUT_FILE, "w", stdout);

freopen(STDERR_FILE, "w", stderr);

} else {

fclose(stdout);

fclose(stderr);

}

if (settingsChanged) {

/* Save the prefs, even if they might not have changed (but probably did) */

if (!writePreferences(&prefs))

fprintf(stderr, "WARNING: Could not save preferences!\n");

#if !(defined(__APPLE__) && defined(__MACH__))

appNameText[0] = 0;

commandLine = (char *) malloc(appNameText[0] + prefs.command_line[0] + 2);

if (commandLine == NULL) {

exit(-1);

}

/* Rather than rewrite ParseCommandLine method, let's replace */

/* any spaces in application name with underscores, */

/* so that the app name is only 1 argument */

for (i = 1; i < 1 + appNameText[0]; i++)

if (appNameText[i] == ' ')

appNameText[i] = '_';

SDL_memcpy(commandLine + appNameText[0] + 1, prefs.command_line + 1,

prefs.command_line[0]);

commandLine[appNameText[0] + 1 + prefs.command_line[0]] = '\0';

/* Parse C-string into argv and argc */

nargs = ParseCommandLine(commandLine, NULL);

args = (char **) malloc((nargs + 1) * (sizeof *args));

if (args == NULL) {

exit(-1);

}

ParseCommandLine(commandLine, args);

/* Run the main application code */

SDL_main(nargs, args);

free(args);

free(commandLine);

/* Remove useless stdout.txt and stderr.txt */

cleanup_output();

/* Exit cleanly, calling atexit() functions */

exit(0);

/* Never reached, but keeps the compiler quiet */

return (0);

/* vi: set ts=4 sw=4 expandtab: */