| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2006 Sam Lantinga |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| 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 |
| Lesser General Public License for more details. |
| |
| 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 |
| slouken@libsdl.org |
| */ |
| |
| /* This file takes care of command line argument parsing, and stdio redirection |
| in the MacOS environment. (stdio/stderr is *not* directed for Mach-O builds) |
| */ |
| |
| #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 |
| |
| #if !(defined(__APPLE__) && defined(__MACH__)) |
| /* The standard output files */ |
| #define STDOUT_FILE "stdout.txt" |
| #define STDERR_FILE "stderr.txt" |
| #endif |
| |
| #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; |
| Boolean output_to_file; |
| } PrefsRecord; |
| |
| /* See if the command key is held down at startup */ |
| static Boolean CommandKeyIsDown(void) |
| { |
| KeyMap theKeyMap; |
| |
| GetKeys(theKeyMap); |
| |
| if (((unsigned char *) theKeyMap)[6] & 0x80) { |
| return(true); |
| } |
| return(false); |
| } |
| |
| #if !(defined(__APPLE__) && defined(__MACH__)) |
| |
| /* Parse a command line buffer into arguments */ |
| 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) { |
| |
| ProcessSerialNumber process; |
| ProcessInfoRec process_info; |
| FSSpec process_fsp; |
| |
| process.highLongOfPSN = 0; |
| process.lowLongOfPSN = kCurrentProcess; |
| process_info.processInfoLength = sizeof (process_info); |
| process_info.processName = NULL; |
| process_info.processAppSpec = &process_fsp; |
| |
| if ( noErr != GetProcessInformation (&process, &process_info) ) |
| return 0; |
| |
| SDL_memcpy(name, process_fsp.name, process_fsp.name[0] + 1); |
| 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; |
| |
| /* Get Preferences folder - works with Multiple Users */ |
| if ( noErr != FindFolder ( kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder, |
| &volume_ref_number, &directory_id) ) |
| exit (-1); |
| |
| if ( ! getCurrentAppName (app_name) ) |
| exit (-1); |
| |
| /* Truncate if name is too long */ |
| if (app_name[0] > MAX_NAME ) |
| app_name[0] = MAX_NAME; |
| |
| 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); |
| |
| /* Make the file spec for prefs file */ |
| if ( noErr != FSMakeFSSpec (volume_ref_number, directory_id, prefs_name, prefs_fsp) ) { |
| if ( !create ) |
| return 0; |
| else { |
| /* Create the prefs file */ |
| SDL_memcpy(prefs_fsp->name, prefs_name, prefs_name[0] + 1); |
| prefs_fsp->parID = directory_id; |
| prefs_fsp->vRefNum = volume_ref_number; |
| |
| FSpCreateResFile (prefs_fsp, 0x3f3f3f3f, 'pref', 0); // '????' parsed as trigraph |
| |
| if ( noErr != ResError () ) |
| return 0; |
| } |
| } |
| return 1; |
| } |
| |
| static int readPrefsResource (PrefsRecord *prefs) { |
| |
| Handle prefs_handle; |
| |
| 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 ); |
| if (prefs_handle != NULL) |
| RemoveResource (prefs_handle); |
| |
| prefs_handle = NewHandle ( prefs->command_line[0] + prefs->video_driver_name[0] + 4 ); |
| if (prefs_handle != NULL) { |
| |
| int offset; |
| |
| 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) { |
| |
| int no_error = 1; |
| 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... */ |
| return 0; |
| |
| 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; |
| FSSpec prefs_fsp; |
| |
| /* Get prefs file, create if it doesn't exist */ |
| 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[]) |
| { |
| |
| #if !(defined(__APPLE__) && defined(__MACH__)) |
| #pragma unused(argc, argv) |
| #endif |
| |
| #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 }; |
| |
| #if !(defined(__APPLE__) && defined(__MACH__)) |
| int nargs; |
| char **args; |
| char *commandLine; |
| |
| StrFileName appNameText; |
| #endif |
| int videodriver = VIDEO_ID_TOOLBOX; |
| int settingsChanged = 0; |
| |
| long i; |
| |
| /* Kyle's SDL command-line dialog code ... */ |
| #if !TARGET_API_MAC_CARBON |
| InitGraf (&qd.thePort); |
| InitFonts (); |
| InitWindows (); |
| InitMenus (); |
| InitDialogs (nil); |
| #endif |
| InitCursor (); |
| FlushEvents(everyEvent,0); |
| #if !TARGET_API_MAC_CARBON |
| MaxApplZone (); |
| #endif |
| MoreMasters (); |
| MoreMasters (); |
| #if 0 |
| /* 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"); |
| |
| #if TARGET_API_MAC_CARBON |
| SetPort (GetDialogPort(errorDialog)); |
| #else |
| SetPort (errorDialog); |
| #endif |
| 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 |
| SDL_InitQuickDraw(&qd); |
| #endif |
| |
| if ( readPreferences (&prefs) ) { |
| |
| if (SDL_memcmp(prefs.video_driver_name+1, "DSp", 3) == 0) |
| videodriver = 1; |
| else if (SDL_memcmp(prefs.video_driver_name+1, "toolbox", 7) == 0) |
| videodriver = 2; |
| } |
| |
| if ( CommandKeyIsDown() ) { |
| |
| #define kCL_OK 1 |
| #define kCL_Cancel 2 |
| #define kCL_Text 3 |
| #define kCL_File 4 |
| #define kCL_Video 6 |
| |
| DialogPtr commandDialog; |
| short dummyType; |
| Rect dummyRect; |
| Handle dummyHandle; |
| short itemHit; |
| #if TARGET_API_MAC_CARBON |
| ControlRef control; |
| #endif |
| |
| /* Assume that they will change settings, rather than do exhaustive check */ |
| settingsChanged = 1; |
| |
| /* Create dialog and display it */ |
| commandDialog = GetNewDialog (1000, nil, (WindowPtr)-1); |
| #if TARGET_API_MAC_CARBON |
| SetPort ( GetDialogPort(commandDialog) ); |
| #else |
| SetPort (commandDialog); |
| #endif |
| |
| /* Setup controls */ |
| #if TARGET_API_MAC_CARBON |
| GetDialogItemAsControl(commandDialog, kCL_File, &control); |
| 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); |
| |
| #if TARGET_API_MAC_CARBON |
| GetDialogItemAsControl(commandDialog, kCL_Video, &control); |
| 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); |
| |
| #if TARGET_API_MAC_CARBON |
| 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 |
| |
| #if TARGET_API_MAC_CARBON |
| GetDialogItemAsControl(commandDialog, kCL_Video, &control); |
| videodriver = GetControlValue(control); |
| #else |
| GetDialogItem (commandDialog, kCL_Video, &dummyType, &dummyHandle, &dummyRect); |
| videodriver = GetControlValue ((ControlRef)dummyHandle); |
| #endif |
| |
| DisposeDialog (commandDialog); |
| |
| if (itemHit == kCL_Cancel ) { |
| exit (0); |
| } |
| } |
| |
| /* Set pseudo-environment variables for video driver, update prefs */ |
| 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 !(defined(__APPLE__) && defined(__MACH__)) |
| /* Redirect standard I/O to files */ |
| if ( prefs.output_to_file ) { |
| freopen (STDOUT_FILE, "w", stdout); |
| freopen (STDERR_FILE, "w", stderr); |
| } else { |
| fclose (stdout); |
| fclose (stderr); |
| } |
| #endif |
| |
| 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; |
| getCurrentAppName (appNameText); /* check for error here ? */ |
| |
| 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] = '_'; |
| |
| /* Copy app name & full command text to command-line C-string */ |
| SDL_memcpy(commandLine, appNameText + 1, appNameText[0]); |
| commandLine[appNameText[0]] = ' '; |
| 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 (); |
| #else // defined(__APPLE__) && defined(__MACH__) |
| SDL_main(argc, argv); |
| #endif |
| |
| /* Exit cleanly, calling atexit() functions */ |
| exit (0); |
| |
| /* Never reached, but keeps the compiler quiet */ |
| return (0); |
| } |