src/main/macos/SDL_main.c

/*
    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);
}

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