shared_source/c_tcl_base_7_5_w_mods/tclmain.c

/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclmain.c,v 1.2 2001/10/07 01:32:29 dtashley Exp $ */

/* IJS_SM_FILE_PUBLIC */

/* 
 * tclMain.c --
 *
 *      Main program for Tcl shells and other Tcl-based applications.
 *
 * Copyright (c) 1988-1994 The Regents of the University of California.
 * Copyright (c) 1994-1997 Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tclmain.c,v 1.2 2001/10/07 01:32:29 dtashley Exp $
 */

#define MODULE_TCLMAIN

#include "tclmain.h"

#include "tcl.h"
#include "tclInt.h"

#include "build_config.h"
#include "extninit.h"
#include "msgstrs.h"


# undef TCL_STORAGE_CLASS
# define TCL_STORAGE_CLASS DLLEXPORT

/*
 * The following code ensures that tclLink.c is linked whenever
 * Tcl is linked.  Without this code there's no reference to the
 * code in that file from anywhere in Tcl, so it may not be
 * linked into the application.
 */

EXTERN int Tcl_LinkVar();
int (*tclDummyLinkVarPtr)() = Tcl_LinkVar;

/*
 * Declarations for various library procedures and variables (don't want
 * to include tclPort.h here, because people might copy this file out of
 * the Tcl source directory to make their own modified versions).
 * Note:  "exit" should really be declared here, but there's no way to
 * declare it without causing conflicts with other definitions elsewher
 * on some systems, so it's better just to leave it out.
 */

extern int              isatty _ANSI_ARGS_((int fd));
extern char *           strcpy _ANSI_ARGS_((char *dst, CONST char *src));

static char *tclStartupScriptFileName = NULL;


/*
 *----------------------------------------------------------------------
 *
 * TclSetStartupScriptFileName --
 *
 *      Primes the startup script file name, used to override the
 *      command line processing.
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      This procedure initializes the file name of the Tcl script to
 *      run at startup.
 *
 *----------------------------------------------------------------------
 */
void TclSetStartupScriptFileName(fileName)
    char *fileName;
{
    tclStartupScriptFileName = fileName;
}


/*
 *----------------------------------------------------------------------
 *
 * TclGetStartupScriptFileName --
 *
 *      Gets the startup script file name, used to override the
 *      command line processing.
 *
 * Results:
 *      The startup script file name, NULL if none has been set.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */
char *TclGetStartupScriptFileName()
{
    return tclStartupScriptFileName;
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_Main --
 *
 *      Main program for tclsh and most other Tcl-based applications.
 *
 * Results:
 *      None. This procedure never returns (it exits the process when
 *      it's done.
 *
 * Side effects:
 *      This procedure initializes the Tcl world and then starts
 *      interpreting commands;  almost anything could happen, depending
 *      on the script being interpreted.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_Main(argc, argv, appInitProc)
    int argc;                   /* Number of arguments. */
    char **argv;                /* Array of argument strings. */
    Tcl_AppInitProc *appInitProc;
                                /* Application-specific initialization
                                 * procedure to call after most
                                 * initialization but before starting to
                                 * execute commands. */
{
    Tcl_Obj *resultPtr;
    Tcl_Obj *commandPtr = NULL;
    char buffer[1000], *args;
    int code, gotPartial, tty, length;
    int exitCode = 0;
    Tcl_Channel inChannel, outChannel, errChannel;
    Tcl_Interp *interp;
    Tcl_DString argString;

    Tcl_FindExecutable(argv[0]);
    interp = Tcl_CreateInterp();
#ifdef TCL_MEM_DEBUG
    Tcl_InitMemory(interp);
#endif

    /*
     * Make command-line arguments available in the Tcl variables "argc"
     * and "argv".  If the first argument doesn't start with a "-" then
     * strip it off and use it as the name of a script file to process.
     */

    if (tclStartupScriptFileName == NULL) {
        if ((argc > 1) && (argv[1][0] != '-')) {
            tclStartupScriptFileName = argv[1];
            argc--;
            argv++;
        }
    }
    args = Tcl_Merge(argc-1, argv+1);
    Tcl_ExternalToUtfDString(NULL, args, -1, &argString);
    Tcl_SetVar(interp, "argv", Tcl_DStringValue(&argString), TCL_GLOBAL_ONLY);
    Tcl_DStringFree(&argString);
    ckfree(args);

    if (tclStartupScriptFileName == NULL) {
        Tcl_ExternalToUtfDString(NULL, argv[0], -1, &argString);
    } else {
        tclStartupScriptFileName = Tcl_ExternalToUtfDString(NULL,
                tclStartupScriptFileName, -1, &argString);
    }

    TclFormatInt(buffer, argc-1);
    Tcl_SetVar(interp, "argc", buffer, TCL_GLOBAL_ONLY);
    Tcl_SetVar(interp, "argv0", Tcl_DStringValue(&argString), TCL_GLOBAL_ONLY);

    /*
     * Set the "tcl_interactive" variable.
     */

    tty = isatty(0);
    Tcl_SetVar(interp, "tcl_interactive",
            ((tclStartupScriptFileName == NULL) && tty) ? "1" : "0",
            TCL_GLOBAL_ONLY);
    
    /*
     * Invoke application-specific initialization.
     */

     /* Register any extensions that should be registered for the
     ** executable currently being built.
     */
   ExtninitInit(interp);

   /* Set a Tcl variable to indicate the particular product
   ** we are building.  This is used in the startup message script
   ** to announce product version, and may be used other
   ** places, as well.
   */
   Tcl_SetVar(interp,
              BUILD_CONFIG_PRODUCT_NAME_VARIABLE,
              BUILD_CONFIG_STATIC_TCLSH_ALIAS,
              TCL_GLOBAL_ONLY);

   /* Set  Tcl variable to indicate the relese version of the
   ** product we are building.  This is used in the startup message script
   ** to announce product version, and may be used other
   ** places, as well.
   */
   Tcl_SetVar(interp,
              BUILD_CONFIG_PRODUCT_VERSION_VARIABLE,
              BUILD_CONFIG_RELEASE_VERSION,
              TCL_GLOBAL_ONLY);

   /* Output the introductory message to the console.
   ** The script called is generic and applies to both
   ** IjuScripter and IjuConsole.
   */
   Tcl_GlobalEval(interp, BUILD_CONFIG_StartupMessageScript);

    /*
     * If a script file was specified then just source that file
     * and quit.
     */

    if (tclStartupScriptFileName != NULL) {
        code = Tcl_EvalFile(interp, tclStartupScriptFileName);
        if (code != TCL_OK) {
            errChannel = Tcl_GetStdChannel(TCL_STDERR);
            if (errChannel) {
                /*
                 * The following statement guarantees that the errorInfo
                 * variable is set properly.
                 */

                Tcl_AddErrorInfo(interp, "");
                Tcl_WriteObj(errChannel, Tcl_GetVar2Ex(interp, "errorInfo",
                        NULL, TCL_GLOBAL_ONLY));
                Tcl_WriteChars(errChannel, "\n", 1);
            }
            exitCode = 1;
        }
        goto done;
    }
    Tcl_DStringFree(&argString);

    /*
     * We're running interactively.  Source a user-specific startup
     * file if the application specified one and if the file exists.
     */

    Tcl_SourceRCFile(interp);

    /*
     * Process commands from stdin until there's an end-of-file.  Note
     * that we need to fetch the standard channels again after every
     * eval, since they may have been changed.
     */

    commandPtr = Tcl_NewObj();
    Tcl_IncrRefCount(commandPtr);

    inChannel = Tcl_GetStdChannel(TCL_STDIN);
    outChannel = Tcl_GetStdChannel(TCL_STDOUT);
    gotPartial = 0;
    while (1) {
        if (tty) {
            Tcl_Obj *promptCmdPtr;

            promptCmdPtr = Tcl_GetVar2Ex(interp,
                    (gotPartial ? "tcl_prompt2" : "tcl_prompt1"),
                    NULL, TCL_GLOBAL_ONLY);
            if (promptCmdPtr == NULL) {
                defaultPrompt:
                if (!gotPartial && outChannel) {
                    Tcl_WriteChars(outChannel, "% ", 2);
                }
            } else {
                code = Tcl_EvalObjEx(interp, promptCmdPtr, 0);
                inChannel = Tcl_GetStdChannel(TCL_STDIN);
                outChannel = Tcl_GetStdChannel(TCL_STDOUT);
                errChannel = Tcl_GetStdChannel(TCL_STDERR);
                if (code != TCL_OK) {
                    if (errChannel) {
                        Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
                        Tcl_WriteChars(errChannel, "\n", 1);
                    }
                    Tcl_AddErrorInfo(interp,
                            "\n    (script that generates prompt)");
                    goto defaultPrompt;
                }
            }
            if (outChannel) {
                Tcl_Flush(outChannel);
            }
        }
        if (!inChannel) {
            goto done;
        }
        length = Tcl_GetsObj(inChannel, commandPtr);
        if (length < 0) {
            goto done;
        }
        if ((length == 0) && Tcl_Eof(inChannel) && (!gotPartial)) {
            goto done;
        }

        /*
         * Add the newline removed by Tcl_GetsObj back to the string.
         */

        Tcl_AppendToObj(commandPtr, "\n", 1);
        if (!TclObjCommandComplete(commandPtr)) {
            gotPartial = 1;
            continue;
        }

        gotPartial = 0;
        code = Tcl_RecordAndEvalObj(interp, commandPtr, 0);
        inChannel = Tcl_GetStdChannel(TCL_STDIN);
        outChannel = Tcl_GetStdChannel(TCL_STDOUT);
        errChannel = Tcl_GetStdChannel(TCL_STDERR);
        Tcl_DecrRefCount(commandPtr);
        commandPtr = Tcl_NewObj();
        Tcl_IncrRefCount(commandPtr);
        if (code != TCL_OK) {
            if (errChannel) {
                Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
                Tcl_WriteChars(errChannel, "\n", 1);
            }
        } else if (tty) {
            resultPtr = Tcl_GetObjResult(interp);
            Tcl_GetStringFromObj(resultPtr, &length);
            if ((length > 0) && outChannel) {
                Tcl_WriteObj(outChannel, resultPtr);
                Tcl_WriteChars(outChannel, "\n", 1);
            }
        }
#ifdef TCL_MEM_DEBUG
        if (tclMemDumpFileName != NULL) {
            Tcl_DecrRefCount(commandPtr);
            Tcl_DeleteInterp(interp);
            Tcl_Exit(0);
        }
#endif
    }

    /*
     * Rather than calling exit, invoke the "exit" command so that
     * users can replace "exit" with some other command to do additional
     * cleanup on exit.  The Tcl_Eval call should never return.
     */

    done:
    if (commandPtr != NULL) {
        Tcl_DecrRefCount(commandPtr);
    }
    sprintf(buffer, "exit %d", exitCode);
    Tcl_Eval(interp, buffer);
}


const char *TclMainCversion(void)
{   
    return ("$Revision: 1.2 $ $Modtime: 1/02/01 1:25a $ $Author: dtashley $");
}


const char *TclMainHversion(void)
{   
    return (TCLMAIN_H_VERSION);
}


/******************************************************************************
** $Log: tclmain.c,v $
** Revision 1.2  2001/10/07 01:32:29  dtashley
** Log information refined.
**
******************************************************************************/

/* End of TCLMAIN.C */
1	dashley	25	/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclmain.c,v 1.2 2001/10/07 01:32:29 dtashley Exp $ */
2
3			/* IJS_SM_FILE_PUBLIC */
4
5			/*
6			* tclMain.c --
7			*
8			* Main program for Tcl shells and other Tcl-based applications.
9			*
10			* Copyright (c) 1988-1994 The Regents of the University of California.
11			* Copyright (c) 1994-1997 Sun Microsystems, Inc.
12			*
13			* See the file "license.terms" for information on usage and redistribution
14			* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
15			*
16			* RCS: @(#) $Id: tclmain.c,v 1.2 2001/10/07 01:32:29 dtashley Exp $
17			*/
18
19			#define MODULE_TCLMAIN
20
21			#include "tclmain.h"
22
23			#include "tcl.h"
24			#include "tclInt.h"
25
26			#include "build_config.h"
27			#include "extninit.h"
28			#include "msgstrs.h"
29
30
31			# undef TCL_STORAGE_CLASS
32			# define TCL_STORAGE_CLASS DLLEXPORT
33
34			/*
35			* The following code ensures that tclLink.c is linked whenever
36			* Tcl is linked. Without this code there's no reference to the
37			* code in that file from anywhere in Tcl, so it may not be
38			* linked into the application.
39			*/
40
41			EXTERN int Tcl_LinkVar();
42			int (*tclDummyLinkVarPtr)() = Tcl_LinkVar;
43
44			/*
45			* Declarations for various library procedures and variables (don't want
46			* to include tclPort.h here, because people might copy this file out of
47			* the Tcl source directory to make their own modified versions).
48			* Note: "exit" should really be declared here, but there's no way to
49			* declare it without causing conflicts with other definitions elsewher
50			* on some systems, so it's better just to leave it out.
51			*/
52
53			extern int isatty _ANSI_ARGS_((int fd));
54			extern char * strcpy _ANSI_ARGS_((char dst, CONST char src));
55
56			static char *tclStartupScriptFileName = NULL;
57
58
59
60
61			/*
62			*----------------------------------------------------------------------
63			*
64			* TclSetStartupScriptFileName --
65			*
66			* Primes the startup script file name, used to override the
67			* command line processing.
68			*
69			* Results:
70			* None.
71			*
72			* Side effects:
73			* This procedure initializes the file name of the Tcl script to
74			* run at startup.
75			*
76			*----------------------------------------------------------------------
77			*/
78			void TclSetStartupScriptFileName(fileName)
79			char *fileName;
80			{
81			tclStartupScriptFileName = fileName;
82			}
83
84
85			/*
86			*----------------------------------------------------------------------
87			*
88			* TclGetStartupScriptFileName --
89			*
90			* Gets the startup script file name, used to override the
91			* command line processing.
92			*
93			* Results:
94			* The startup script file name, NULL if none has been set.
95			*
96			* Side effects:
97			* None.
98			*
99			*----------------------------------------------------------------------
100			*/
101			char *TclGetStartupScriptFileName()
102			{
103			return tclStartupScriptFileName;
104			}
105
106
107
108			/*
109			*----------------------------------------------------------------------
110			*
111			* Tcl_Main --
112			*
113			* Main program for tclsh and most other Tcl-based applications.
114			*
115			* Results:
116			* None. This procedure never returns (it exits the process when
117			* it's done.
118			*
119			* Side effects:
120			* This procedure initializes the Tcl world and then starts
121			* interpreting commands; almost anything could happen, depending
122			* on the script being interpreted.
123			*
124			*----------------------------------------------------------------------
125			*/
126
127			void
128			Tcl_Main(argc, argv, appInitProc)
129			int argc; /* Number of arguments. */
130			char *argv; / Array of argument strings. */
131			Tcl_AppInitProc *appInitProc;
132			/* Application-specific initialization
133			* procedure to call after most
134			* initialization but before starting to
135			* execute commands. */
136			{
137			Tcl_Obj *resultPtr;
138			Tcl_Obj *commandPtr = NULL;
139			char buffer[1000], *args;
140			int code, gotPartial, tty, length;
141			int exitCode = 0;
142			Tcl_Channel inChannel, outChannel, errChannel;
143			Tcl_Interp *interp;
144			Tcl_DString argString;
145
146			Tcl_FindExecutable(argv[0]);
147			interp = Tcl_CreateInterp();
148			#ifdef TCL_MEM_DEBUG
149			Tcl_InitMemory(interp);
150			#endif
151
152			/*
153			* Make command-line arguments available in the Tcl variables "argc"
154			* and "argv". If the first argument doesn't start with a "-" then
155			* strip it off and use it as the name of a script file to process.
156			*/
157
158			if (tclStartupScriptFileName == NULL) {
159			if ((argc > 1) && (argv[1][0] != '-')) {
160			tclStartupScriptFileName = argv[1];
161			argc--;
162			argv++;
163			}
164			}
165			args = Tcl_Merge(argc-1, argv+1);
166			Tcl_ExternalToUtfDString(NULL, args, -1, &argString);
167			Tcl_SetVar(interp, "argv", Tcl_DStringValue(&argString), TCL_GLOBAL_ONLY);
168			Tcl_DStringFree(&argString);
169			ckfree(args);
170
171			if (tclStartupScriptFileName == NULL) {
172			Tcl_ExternalToUtfDString(NULL, argv[0], -1, &argString);
173			} else {
174			tclStartupScriptFileName = Tcl_ExternalToUtfDString(NULL,
175			tclStartupScriptFileName, -1, &argString);
176			}
177
178			TclFormatInt(buffer, argc-1);
179			Tcl_SetVar(interp, "argc", buffer, TCL_GLOBAL_ONLY);
180			Tcl_SetVar(interp, "argv0", Tcl_DStringValue(&argString), TCL_GLOBAL_ONLY);
181
182			/*
183			* Set the "tcl_interactive" variable.
184			*/
185
186			tty = isatty(0);
187			Tcl_SetVar(interp, "tcl_interactive",
188			((tclStartupScriptFileName == NULL) && tty) ? "1" : "0",
189			TCL_GLOBAL_ONLY);
190
191			/*
192			* Invoke application-specific initialization.
193			*/
194
195			/* Register any extensions that should be registered for the
196			** executable currently being built.
197			*/
198			ExtninitInit(interp);
199
200			/* Set a Tcl variable to indicate the particular product
201			** we are building. This is used in the startup message script
202			** to announce product version, and may be used other
203			** places, as well.
204			*/
205			Tcl_SetVar(interp,
206			BUILD_CONFIG_PRODUCT_NAME_VARIABLE,
207			BUILD_CONFIG_STATIC_TCLSH_ALIAS,
208			TCL_GLOBAL_ONLY);
209
210			/* Set Tcl variable to indicate the relese version of the
211			** product we are building. This is used in the startup message script
212			** to announce product version, and may be used other
213			** places, as well.
214			*/
215			Tcl_SetVar(interp,
216			BUILD_CONFIG_PRODUCT_VERSION_VARIABLE,
217			BUILD_CONFIG_RELEASE_VERSION,
218			TCL_GLOBAL_ONLY);
219
220			/* Output the introductory message to the console.
221			** The script called is generic and applies to both
222			** IjuScripter and IjuConsole.
223			*/
224			Tcl_GlobalEval(interp, BUILD_CONFIG_StartupMessageScript);
225
226			/*
227			* If a script file was specified then just source that file
228			* and quit.
229			*/
230
231			if (tclStartupScriptFileName != NULL) {
232			code = Tcl_EvalFile(interp, tclStartupScriptFileName);
233			if (code != TCL_OK) {
234			errChannel = Tcl_GetStdChannel(TCL_STDERR);
235			if (errChannel) {
236			/*
237			* The following statement guarantees that the errorInfo
238			* variable is set properly.
239			*/
240
241			Tcl_AddErrorInfo(interp, "");
242			Tcl_WriteObj(errChannel, Tcl_GetVar2Ex(interp, "errorInfo",
243			NULL, TCL_GLOBAL_ONLY));
244			Tcl_WriteChars(errChannel, "\n", 1);
245			}
246			exitCode = 1;
247			}
248			goto done;
249			}
250			Tcl_DStringFree(&argString);
251
252			/*
253			* We're running interactively. Source a user-specific startup
254			* file if the application specified one and if the file exists.
255			*/
256
257			Tcl_SourceRCFile(interp);
258
259			/*
260			* Process commands from stdin until there's an end-of-file. Note
261			* that we need to fetch the standard channels again after every
262			* eval, since they may have been changed.
263			*/
264
265			commandPtr = Tcl_NewObj();
266			Tcl_IncrRefCount(commandPtr);
267
268			inChannel = Tcl_GetStdChannel(TCL_STDIN);
269			outChannel = Tcl_GetStdChannel(TCL_STDOUT);
270			gotPartial = 0;
271			while (1) {
272			if (tty) {
273			Tcl_Obj *promptCmdPtr;
274
275			promptCmdPtr = Tcl_GetVar2Ex(interp,
276			(gotPartial ? "tcl_prompt2" : "tcl_prompt1"),
277			NULL, TCL_GLOBAL_ONLY);
278			if (promptCmdPtr == NULL) {
279			defaultPrompt:
280			if (!gotPartial && outChannel) {
281			Tcl_WriteChars(outChannel, "% ", 2);
282			}
283			} else {
284			code = Tcl_EvalObjEx(interp, promptCmdPtr, 0);
285			inChannel = Tcl_GetStdChannel(TCL_STDIN);
286			outChannel = Tcl_GetStdChannel(TCL_STDOUT);
287			errChannel = Tcl_GetStdChannel(TCL_STDERR);
288			if (code != TCL_OK) {
289			if (errChannel) {
290			Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
291			Tcl_WriteChars(errChannel, "\n", 1);
292			}
293			Tcl_AddErrorInfo(interp,
294			"\n (script that generates prompt)");
295			goto defaultPrompt;
296			}
297			}
298			if (outChannel) {
299			Tcl_Flush(outChannel);
300			}
301			}
302			if (!inChannel) {
303			goto done;
304			}
305			length = Tcl_GetsObj(inChannel, commandPtr);
306			if (length < 0) {
307			goto done;
308			}
309			if ((length == 0) && Tcl_Eof(inChannel) && (!gotPartial)) {
310			goto done;
311			}
312
313			/*
314			* Add the newline removed by Tcl_GetsObj back to the string.
315			*/
316
317			Tcl_AppendToObj(commandPtr, "\n", 1);
318			if (!TclObjCommandComplete(commandPtr)) {
319			gotPartial = 1;
320			continue;
321			}
322
323			gotPartial = 0;
324			code = Tcl_RecordAndEvalObj(interp, commandPtr, 0);
325			inChannel = Tcl_GetStdChannel(TCL_STDIN);
326			outChannel = Tcl_GetStdChannel(TCL_STDOUT);
327			errChannel = Tcl_GetStdChannel(TCL_STDERR);
328			Tcl_DecrRefCount(commandPtr);
329			commandPtr = Tcl_NewObj();
330			Tcl_IncrRefCount(commandPtr);
331			if (code != TCL_OK) {
332			if (errChannel) {
333			Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
334			Tcl_WriteChars(errChannel, "\n", 1);
335			}
336			} else if (tty) {
337			resultPtr = Tcl_GetObjResult(interp);
338			Tcl_GetStringFromObj(resultPtr, &length);
339			if ((length > 0) && outChannel) {
340			Tcl_WriteObj(outChannel, resultPtr);
341			Tcl_WriteChars(outChannel, "\n", 1);
342			}
343			}
344			#ifdef TCL_MEM_DEBUG
345			if (tclMemDumpFileName != NULL) {
346			Tcl_DecrRefCount(commandPtr);
347			Tcl_DeleteInterp(interp);
348			Tcl_Exit(0);
349			}
350			#endif
351			}
352
353			/*
354			* Rather than calling exit, invoke the "exit" command so that
355			* users can replace "exit" with some other command to do additional
356			* cleanup on exit. The Tcl_Eval call should never return.
357			*/
358
359			done:
360			if (commandPtr != NULL) {
361			Tcl_DecrRefCount(commandPtr);
362			}
363			sprintf(buffer, "exit %d", exitCode);
364			Tcl_Eval(interp, buffer);
365			}
366
367
368			const char *TclMainCversion(void)
369			{
370			return ("$Revision: 1.2 $ $Modtime: 1/02/01 1:25a $ $Author: dtashley $");
371			}
372
373
374			const char *TclMainHversion(void)
375			{
376			return (TCLMAIN_H_VERSION);
377			}
378
379
380			/******************************************************************************
381			** $Log: tclmain.c,v $
382			** Revision 1.2 2001/10/07 01:32:29 dtashley
383			** Log information refined.
384			**
385			******************************************************************************/
386
387			/* End of TCLMAIN.C */