Subversion Repositories or1k_old

/*

 * winMain.c --

 *

 *      Main entry point for wish and other Tk-based applications.

 *

 * Copyright (c) 1995 Sun Microsystems, Inc.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * SCCS: @(#) winMain.c 1.33 96/12/17 12:56:14

 */

#include <tk.h>

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#undef WIN32_LEAN_AND_MEAN

#include <malloc.h>

#include <locale.h>

#include "itk.h"

/* include tclInt.h for access to namespace API */

#include "tclInt.h"

/*

 * The following declarations refer to internal Tk routines.  These

 * interfaces are available for use, but are not supported.

 */

EXTERN void             TkConsoleCreate(void);

EXTERN int              TkConsoleInit(Tcl_Interp *interp);

/*

 * Forward declarations for procedures defined later in this file:

 */

static void             setargv _ANSI_ARGS_((int *argcPtr, char ***argvPtr));

static void             WishPanic _ANSI_ARGS_(TCL_VARARGS(char *,format));

#ifdef TK_TEST

EXTERN int              Tktest_Init(Tcl_Interp *interp);

#endif /* TK_TEST */

/*

 *----------------------------------------------------------------------

 *

 * WinMain --

 *

 *      Main entry point from Windows.

 *

 * Results:

 *      Returns false if initialization fails, otherwise it never

 *      returns.

 *

 * Side effects:

 *      Just about anything, since from here we call arbitrary Tcl code.

 *

 *----------------------------------------------------------------------

 */

int APIENTRY

WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow)

    HINSTANCE hInstance;

    HINSTANCE hPrevInstance;

    LPSTR lpszCmdLine;

    int nCmdShow;

{

    char **argv, *p;

    int argc;

    char buffer[MAX_PATH];

    Tcl_SetPanicProc(WishPanic);

    /*

     * Set up the default locale to be standard "C" locale so parsing

     * is performed correctly.

     */

    setlocale(LC_ALL, "C");

    /*

     * Increase the application queue size from default value of 8.

     * At the default value, cross application SendMessage of WM_KILLFOCUS

     * will fail because the handler will not be able to do a PostMessage!

     * This is only needed for Windows 3.x, since NT dynamically expands

     * the queue.

     */

    SetMessageQueue(64);

    /*

     * Create the console channels and install them as the standard

     * channels.  All I/O will be discarded until TkConsoleInit is

     * called to attach the console to a text widget.

     */

    TkConsoleCreate();

    setargv(&argc, &argv);

    /*

     * Replace argv[0] with full pathname of executable, and forward

     * slashes substituted for backslashes.

     */

    GetModuleFileName(NULL, buffer, sizeof(buffer));

    argv[0] = buffer;

    for (p = buffer; *p != '\0'; p++) {

        if (*p == '\\') {

            *p = '/';

        }

    }

    Tk_Main(argc, argv, Tcl_AppInit);

    return 1;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_AppInit --

 *

 *      This procedure performs application-specific initialization.

 *      Most applications, especially those that incorporate additional

 *      packages, will have their own version of this procedure.

 *

 * Results:

 *      Returns a standard Tcl completion code, and leaves an error

 *      message in interp->result if an error occurs.

 *

 * Side effects:

 *      Depends on the startup script.

 *

 *----------------------------------------------------------------------

 */

int

Tcl_AppInit(interp)

    Tcl_Interp *interp;         /* Interpreter for application. */

{

    if (Tcl_Init(interp) == TCL_ERROR) {

        goto error;

    }

    if (Tk_Init(interp) == TCL_ERROR) {

        goto error;

    }

    Tcl_StaticPackage(interp, "Tk", Tk_Init, Tk_SafeInit);

    if (Itcl_Init(interp) == TCL_ERROR) {

        return TCL_ERROR;

    }

    if (Itk_Init(interp) == TCL_ERROR) {

        return TCL_ERROR;

    }

    Tcl_StaticPackage(interp, "Itcl", Itcl_Init, Itcl_SafeInit);

    Tcl_StaticPackage(interp, "Itk", Itk_Init, (Tcl_PackageInitProc *) NULL);

    /*

     *  This is itkwish, so import all [incr Tcl] commands by

     *  default into the global namespace.  Fix up the autoloader

     *  to do the same.

     */

    if (Tcl_Import(interp, Tcl_GetGlobalNamespace(interp),

            "::itk::*", /* allowOverwrite */ 1) != TCL_OK) {

        return TCL_ERROR;

    }

    if (Tcl_Import(interp, Tcl_GetGlobalNamespace(interp),

            "::itcl::*", /* allowOverwrite */ 1) != TCL_OK) {

        return TCL_ERROR;

    }

    if (Tcl_Eval(interp, "auto_mkindex_parser::slavehook { _%@namespace import -force ::itcl::* ::itk::* }") != TCL_OK) {

        return TCL_ERROR;

    }

    /*

     * Initialize the console only if we are running as an interactive

     * application.

     */

    if (TkConsoleInit(interp) == TCL_ERROR) {

        goto error;

    }

#ifdef TK_TEST

    if (Tktest_Init(interp) == TCL_ERROR) {

        goto error;

    }

    Tcl_StaticPackage(interp, "Tktest", Tktest_Init,

            (Tcl_PackageInitProc *) NULL);

#endif /* TK_TEST */

    Tcl_SetVar(interp, "tcl_rcFileName", "~/itkwishrc.tcl", TCL_GLOBAL_ONLY);

    return TCL_OK;

error:

    WishPanic(interp->result);

    return TCL_ERROR;

}

/*

 *----------------------------------------------------------------------

 *

 * WishPanic --

 *

 *      Display a message and exit.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      Exits the program.

 *

 *----------------------------------------------------------------------

 */

void

WishPanic TCL_VARARGS_DEF(char *,arg1)

{

    va_list argList;

    char buf[1024];

    char *format;

    format = TCL_VARARGS_START(char *,arg1,argList);

    vsprintf(buf, format, argList);

    MessageBeep(MB_ICONEXCLAMATION);

    MessageBox(NULL, buf, "Fatal Error in Wish",

            MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);

#ifdef _MSC_VER

    DebugBreak();

#endif

    ExitProcess(1);

}

/*

 *-------------------------------------------------------------------------

 *

 * setargv --

 *

 *      Parse the Windows command line string into argc/argv.  Done here

 *      because we don't trust the builtin argument parser in crt0.

 *      Windows applications are responsible for breaking their command

 *      line into arguments.

 *

 *      2N backslashes + quote -> N backslashes + begin quoted string

 *      2N + 1 backslashes + quote -> literal

 *      N backslashes + non-quote -> literal

 *      quote + quote in a quoted string -> single quote

 *      quote + quote not in quoted string -> empty string

 *      quote -> begin quoted string

 *

 * Results:

 *      Fills argcPtr with the number of arguments and argvPtr with the

 *      array of arguments.

 *

 * Side effects:

 *      Memory allocated.

 *

 *--------------------------------------------------------------------------

 */

static void

setargv(argcPtr, argvPtr)

    int *argcPtr;               /* Filled with number of argument strings. */

    char ***argvPtr;            /* Filled with argument strings (malloc'd). */

{

    char *cmdLine, *p, *arg, *argSpace;

    char **argv;

    int argc, size, inquote, copy, slashes;

    cmdLine = GetCommandLine();

    /*

     * Precompute an overly pessimistic guess at the number of arguments

     * in the command line by counting non-space spans.

     */

    size = 2;

    for (p = cmdLine; *p != '\0'; p++) {

        if (isspace(*p)) {

            size++;

            while (isspace(*p)) {

                p++;

            }

            if (*p == '\0') {

                break;

            }

        }

    }

    argSpace = (char *) ckalloc((unsigned) (size * sizeof(char *)

            + strlen(cmdLine) + 1));

    argv = (char **) argSpace;

    argSpace += size * sizeof(char *);

    size--;

    p = cmdLine;

    for (argc = 0; argc < size; argc++) {

        argv[argc] = arg = argSpace;

        while (isspace(*p)) {

            p++;

        }

        if (*p == '\0') {

            break;

        }

        inquote = 0;

        slashes = 0;

        while (1) {

            copy = 1;

            while (*p == '\\') {

                slashes++;

                p++;

            }

            if (*p == '"') {

                if ((slashes & 1) == 0) {

                    copy = 0;

                    if ((inquote) && (p[1] == '"')) {

                        p++;

                        copy = 1;

                    } else {

                        inquote = !inquote;

                    }

                }

                slashes >>= 1;

            }

            while (slashes) {

                *arg = '\\';

                arg++;

                slashes--;

            }

            if ((*p == '\0') || (!inquote && isspace(*p))) {

                break;

            }

            if (copy != 0) {

                *arg = *p;

                arg++;

            }

            p++;

        }

        *arg = '\0';

        argSpace = arg + 1;

    }

    argv[argc] = NULL;

    *argcPtr = argc;

    *argvPtr = argv;

}