Subversion Repositories or1k

/*

 * tclAppInit.c --

 *

 *      Provides a default version of the main program and Tcl_AppInit

 *      procedure for Tcl applications (without Tk).  Note that this

 *      program must be built in Win32 console mode to work properly.

 *

 * Copyright (c) 1996 by 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: @(#) tclAppInit.c 1.12 97/04/30 11:04:50

 */

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

#include "tclInt.h"

#include "itcl.h"

#include <windows.h>

#include <locale.h>

#ifdef TCL_TEST

EXTERN int              Tcltest_Init _ANSI_ARGS_((Tcl_Interp *interp));

EXTERN int              TclObjTest_Init _ANSI_ARGS_((Tcl_Interp *interp));

#endif /* TCL_TEST */

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

/*

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

 *

 * main --

 *

 *      This is the main program for the application.

 *

 * Results:

 *      None: Tcl_Main never returns here, so this procedure never

 *      returns either.

 *

 * Side effects:

 *      Whatever the application does.

 *

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

 */

int

main(argc, argv)

    int argc;                   /* Number of command-line arguments. */

    char **argv;                /* Values of command-line arguments. */

{

    char *p;

    char buffer[MAX_PATH];

    /*

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

     * is performed correctly.

     */

    setlocale(LC_ALL, "C");

    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 = '/';

        }

    }

    Tcl_Main(argc, argv, Tcl_AppInit);

    return 0;                    /* Needed only to prevent compiler warning. */

}

/*

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

 *

 * 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) {

        return TCL_ERROR;

    }

#ifdef TCL_TEST

    if (Tcltest_Init(interp) == TCL_ERROR) {

        return TCL_ERROR;

    }

    Tcl_StaticPackage(interp, "Tcltest", Tcltest_Init,

            (Tcl_PackageInitProc *) NULL);

    if (TclObjTest_Init(interp) == TCL_ERROR) {

        return TCL_ERROR;

    }

#endif /* TCL_TEST */

    /*

     * Call the init procedures for included packages.  Each call should

     * look like this:

     *

     * if (Mod_Init(interp) == TCL_ERROR) {

     *     return TCL_ERROR;

     * }

     *

     * where "Mod" is the name of the module.

     */

    if (Itcl_Init(interp) == TCL_ERROR) {

        return TCL_ERROR;

    }

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

    /*

     *  This is itclsh, 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),

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

        return TCL_ERROR;

    }

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

        return TCL_ERROR;

    }

    /*

     * Call Tcl_CreateCommand for application-specific commands, if

     * they weren't already created by the init procedures called above.

     */

    /*

     * Specify a user-specific startup file to invoke if the application

     * is run interactively.  Typically the startup file is "~/.apprc"

     * where "app" is the name of the application.  If this line is deleted

     * then no user-specific startup file will be run under any conditions.

     */

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

    return TCL_OK;

}

/*

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

 *

 * 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;

}