generic/interface/main.c

#include <utilities/ascConfig.h>

ASC_IMPORT(int) AscDriver(int, CONST char * argv[]);

#ifdef __WIN32__
static void setargv(int*, char ***);
#endif /* __WIN32__ */

/*
 *  main or WinMain
 *
 *  The main entry point for a Unix or Windows application.
 *
 *  Each just calls AscDriver().
 *  These are based on functions from the Tk 8.0 distribution.
 *  See unix/tkAppInit.c and win/winMain.c in their sources.
 */
#ifndef __WIN32__

int main(int argc, CONST char *argv[])
{
  AscDriver(argc, argv);
  return 0;
}

#else /* __WIN32__ */

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
{
  int argc;
  char **argv;
  char *p;
  char buffer[MAX_PATH];

  UNUSED_PARAMETER(hInstance);
  UNUSED_PARAMETER(hPrevInstance);
  UNUSED_PARAMETER(lpszCmdLine);
  UNUSED_PARAMETER(nCmdShow);

  /*
   * 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.
   */

  /*
   *  Windows expects us to parse our arguments ourselves.
   */
  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 = '/';
    }
  }

  AscDriver(argc, argv);
  return 1;
}
#endif /* __WIN32__ */

#ifdef __WIN32__
/*
 *-------------------------------------------------------------------------
 *
 * 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.
 *
 * Parameters:
 *    argcptr  Filled with number of argument strings.
 *    argvptr  Filled with argument strings (malloc'd).
 *
 * This function is from the Tk 8.0 distribution.  See win/winMain.c in
 * their sources.
 *
 *--------------------------------------------------------------------------
 */
static void
setargv(int *argcPtr, char ***argvPtr)
{
    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;
}

#endif /* __WIN32__ */
1	johnpye	521	#include <utilities/ascConfig.h>
2
3			ASC_IMPORT(int) AscDriver(int, CONST char * argv[]);
4
5			#ifdef __WIN32__
6			static void setargv(int, char **);
7			#endif /* __WIN32__ */
8
9			/*
10			* main or WinMain
11			*
12			* The main entry point for a Unix or Windows application.
13			*
14			* Each just calls AscDriver().
15			* These are based on functions from the Tk 8.0 distribution.
16			* See unix/tkAppInit.c and win/winMain.c in their sources.
17			*/
18			#ifndef __WIN32__
19
20			int main(int argc, CONST char *argv[])
21			{
22			AscDriver(argc, argv);
23			return 0;
24			}
25
26			#else /* __WIN32__ */
27
28			int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
29			LPSTR lpszCmdLine, int nCmdShow)
30			{
31			int argc;
32			char **argv;
33			char *p;
34			char buffer[MAX_PATH];
35
36			UNUSED_PARAMETER(hInstance);
37			UNUSED_PARAMETER(hPrevInstance);
38			UNUSED_PARAMETER(lpszCmdLine);
39			UNUSED_PARAMETER(nCmdShow);
40
41			/*
42			* Set up the default locale to be standard "C" locale so parsing
43			* is performed correctly.
44			*/
45			setlocale(LC_ALL, "C");
46
47			/*
48			* Increase the application queue size from default value of 8.
49			* At the default value, cross application SendMessage of WM_KILLFOCUS
50			* will fail because the handler will not be able to do a PostMessage!
51			* This is only needed for Windows 3.x, since NT dynamically expands
52			* the queue.
53			*/
54			SetMessageQueue(64);
55
56			/*
57			* Create the console channels and install them as the standard
58			* channels. All I/O will be discarded until TkConsoleInit is
59			* called to attach the console to a text widget.
60			*/
61
62			/*
63			* Windows expects us to parse our arguments ourselves.
64			*/
65			setargv(&argc, &argv);
66
67			/*
68			* Replace argv[0] with full pathname of executable, and forward
69			* slashes substituted for backslashes.
70			*/
71			GetModuleFileName(NULL, buffer, sizeof(buffer));
72			argv[0] = buffer;
73			for (p = buffer; *p != '\0'; p++) {
74			if (*p == '\\') {
75			*p = '/';
76			}
77			}
78
79			AscDriver(argc, argv);
80			return 1;
81			}
82			#endif /* __WIN32__ */
83
84			#ifdef __WIN32__
85			/*
86			*-------------------------------------------------------------------------
87			*
88			* setargv --
89			*
90			* Parse the Windows command line string into argc/argv. Done here
91			* because we don't trust the builtin argument parser in crt0.
92			* Windows applications are responsible for breaking their command
93			* line into arguments.
94			*
95			* 2N backslashes + quote -> N backslashes + begin quoted string
96			* 2N + 1 backslashes + quote -> literal
97			* N backslashes + non-quote -> literal
98			* quote + quote in a quoted string -> single quote
99			* quote + quote not in quoted string -> empty string
100			* quote -> begin quoted string
101			*
102			* Results:
103			* Fills argcPtr with the number of arguments and argvPtr with the
104			* array of arguments.
105			*
106			* Side effects:
107			* Memory allocated.
108			*
109			* Parameters:
110			* argcptr Filled with number of argument strings.
111			* argvptr Filled with argument strings (malloc'd).
112			*
113			* This function is from the Tk 8.0 distribution. See win/winMain.c in
114			* their sources.
115			*
116			*--------------------------------------------------------------------------
117			*/
118			static void
119			setargv(int argcPtr, char **argvPtr)
120			{
121			char cmdLine, p, arg, argSpace;
122			char **argv;
123			int argc, size, inquote, copy, slashes;
124
125			cmdLine = GetCommandLine();
126
127			/*
128			* Precompute an overly pessimistic guess at the number of arguments
129			* in the command line by counting non-space spans.
130			*/
131
132			size = 2;
133			for (p = cmdLine; *p != '\0'; p++) {
134			if (isspace(*p)) {
135			size++;
136			while (isspace(*p)) {
137			p++;
138			}
139			if (*p == '\0') {
140			break;
141			}
142			}
143			}
144			argSpace = (char ) ckalloc((unsigned) (size sizeof(char *)
145			+ strlen(cmdLine) + 1));
146			argv = (char **) argSpace;
147			argSpace += size * sizeof(char *);
148			size--;
149
150			p = cmdLine;
151			for (argc = 0; argc < size; argc++) {
152			argv[argc] = arg = argSpace;
153			while (isspace(*p)) {
154			p++;
155			}
156			if (*p == '\0') {
157			break;
158			}
159
160			inquote = 0;
161			slashes = 0;
162			while (1) {
163			copy = 1;
164			while (*p == '\\') {
165			slashes++;
166			p++;
167			}
168			if (*p == '"') {
169			if ((slashes & 1) == 0) {
170			copy = 0;
171			if ((inquote) && (p[1] == '"')) {
172			p++;
173			copy = 1;
174			} else {
175			inquote = !inquote;
176			}
177			}
178			slashes >>= 1;
179			}
180
181			while (slashes) {
182			*arg = '\\';
183			arg++;
184			slashes--;
185			}
186
187			if ((p == '\0') \|\| (!inquote && isspace(p))) {
188			break;
189			}
190			if (copy != 0) {
191			arg = p;
192			arg++;
193			}
194			p++;
195			}
196			*arg = '\0';
197			argSpace = arg + 1;
198			}
199			argv[argc] = NULL;
200
201			*argcPtr = argc;
202			*argvPtr = argv;
203			}
204
205			#endif /* __WIN32__ */