Subversion Repositories DevTools

/*

 * MS-DOS SHELL - Main program, memory and variable management

 *

 * MS-DOS SHELL - Copyright (c) 1990,4 Data Logic Limited and Charles Forsyth

 *

 * This code is based on (in part) the shell program written by Charles

 * Forsyth and is subject to the following copyright restrictions:

 *

 * 1.  Redistribution and use in source and binary forms are permitted

 *     provided that the above copyright notice is duplicated in the

 *     source form and the copyright notice in file sh6.c is displayed

 *     on entry to the program.

 *

 * 2.  The sources (or parts thereof) or objects generated from the sources

 *     (or parts of sources) cannot be sold under any circumstances.

 *

 * When parts of the original 2.1 shell were replaced by the Lexical

 * Analsyer written by Simon J. Gerraty (for his Public Domain Korn Shell,

 * which is also based on Charles Forsyth original idea), a number of changes

 * were made to reflect the changes Simon made to the Parse output tree.  Some

 * parts of this code in this module are based on the algorithms/ideas that

 * he incorporated into his shell, in particular interfaces to the new Lexical

 * Scanner.

 *

 *    $Header: /cvsroot/device/DEVL/UTILS/SH/Sh1.c,v 1.3 2004/11/04 02:47:59 ayoung Exp $

 *

 *    $Log: Sh1.c,v $

 *    Revision 1.3  2004/11/04 02:47:59  ayoung

 *    handle upto 8 PATH definitions

 *

 *    Revision 1.2  2004/05/10 09:30:06  ayoung

 *    improved Path/PATH handling

 *    Quote CreateProcess arg0 if embedded spaces are  encountered

 *    Native NT exec dont need to check command line length

 *    Warning when '@' within redirect list

 *    DEBUG_EXEC option, split from PRINT_EXEC option and improved

 *

 *    Revision 1.1  2002/08/02 06:49:33  adamy

 *    imported (reference only)

 *

 *    Revision 1.1  2001/07/20 05:55:43  ayoung

 *    WIN32 support

 *

 *    Revision 1.1.1.1  1999/12/02 01:11:12  gordonh

 *    UTIL

 *

 *	Revision 2.19  1994/08/25  20:49:11  istewart

 *	MS Shell 2.3 Release

 *

 *	Revision 2.18  1994/02/23  09:23:38  istewart

 *	Beta 233 updates

 *

 *	Revision 2.17  1994/02/01  10:25:20  istewart

 *	Release 2.3 Beta 2, including first NT port

 *

 *	Revision 2.16  1994/01/20  14:51:43  istewart

 *	Release 2.3 Beta 1

 *

 *	Revision 2.15  1994/01/11  17:55:25  istewart

 *	Release 2.3 Beta 0 patches

 *

 *	Revision 2.14  1993/12/01  11:58:34  istewart

 *	Release 226 beta

 *

 *	Revision 2.13  1993/11/09  10:39:49  istewart

 *	Beta 226 checking

 *

 *	Revision 2.12  1993/08/25  16:03:57  istewart

 *	Beta 225 - see Notes file

 *

 *	Revision 2.11  1993/07/02  10:21:35  istewart

 *	224 Beta fixes

 *

 *	Revision 2.10  1993/06/16  12:55:49  istewart

 *	Fix the -s and -t options so they work

 *

 *	Revision 2.9  1993/06/14  11:00:12  istewart

 *	More changes for 223 beta

 *

 *	Revision 2.8  1993/06/02  09:52:35  istewart

 *	Beta 223 Updates - see Notes file

 *

 *	Revision 2.7  1993/02/16  16:03:15  istewart

 *	Beta 2.22 Release

 *

 *	Revision 2.6  1993/01/26  18:35:09  istewart

 *	Release 2.2 beta 0

 *

 *	Revision 2.5  1992/12/14  10:54:56  istewart

 *	BETA 215 Fixes and 2.1 Release

 *

 *	Revision 2.4  1992/11/06  10:03:44  istewart

 *	214 Beta test updates

 *

 *	Revision 2.3  1992/09/03  18:54:45  istewart

 *	Beta 213 Updates

 *

 *	Revision 2.2  1992/07/16  14:33:34  istewart

 *	Beta 212 Baseline

 *

 *	Revision 2.1  1992/07/10  10:52:48  istewart

 *	211 Beta updates

 *

 *	Revision 2.0  1992/04/13  17:39:09  Ian_Stewartson

 *     MS-Shell 2.0 Baseline release

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <stdlib.h>

#include <signal.h>

#include <errno.h>

#include <setjmp.h>

#include <stdarg.h>

#include <string.h>

#include <unistd.h>

#include <ctype.h>

#include <fcntl.h>

#include <limits.h>

#include <dirent.h>

#include <time.h>

#include "sh.h"

/* OS2 or DOS, DEBUG MEMORY or normal malloc */

#ifdef OS2_DOSALLOC

#  ifdef DEBUG_MEMORY

#    define RELEASE_MEMORY(x)	if (DosFreeSeg (SELECTOROF ((x))))	\

				    fprintf(stderr, "Memory Release error\n");

#  else

#    define RELEASE_MEMORY(x)	DosFreeSeg (SELECTOROF ((x)))

#  endif

#else

#  define RELEASE_MEMORY(x)     free ((x))

#endif

/*

 * Structure of Malloced space to allow release of space nolonger required

 * without having to know about it.

 */

typedef struct region {

    struct region	*next;

    size_t		nbytes;

    int			area;

} s_region;

static struct region	*MemoryAreaHeader = (s_region *)NULL;

/*

 * default shell, search rules

 */

#if (OS_TYPE == OS_UNIX)

static char		*shellname = "/bin/pksh";

static char		search[] = ":/bin:/usr/bin";

extern char		**environ;

#else

static char		*shellname = "c:/bin/sh.exe";

static char		search[] = ";c:/bin;c:/usr/bin";

#endif

static char		*ymail = "You have mail";

static char		*ShellNameLiteral = "sh";

static char		*ShellOptions = "D:MPRX:abc:defghijklmnopqrtsuvwxyz0";

#if (OS_TYPE != OS_DOS)

static char		DefaultWinTitle[] = "MS Shell";

#endif

#if (OS_TYPE == OS_OS2)

#  if (OS_SIZE == OS_32)

static HEV		SessionQueueSema = 0;

static HQUEUE		SessionQueueHandler = 0;

#  else

static HSEM		SessionQueueSema = 0;

static HQUEUE		SessionQueueHandler = 0;

#  endif

#endif

static char		*tilde = "~";

static char		LIT_OSmode[] = "OSMODE";

static char		LIT_SHmode[] = "SHMODE";

static char		LIT_Dollar[] = "$";

#if (OS_TYPE == OS_DOS)

static char            *NOExit = "sh: ignoring attempt to leave lowest level shell";

#endif

static bool		ProcessingDEBUGTrap = FALSE;

static bool		ProcessingERRORTrap = FALSE;

static unsigned int	ATOE_GFlags;	/* Twalk GLOBAL flags		*/

static unsigned int	ATNE_Function;	/* Twalk GLOBAL flags		*/

/*

 * Count value for counting the number entries in an array

 */

static int		Count_Array;	/* Array size			*/

static char		*Count_Name;	/* Array name			*/

/* Integer Variables */

static struct ShellVariablesInit {

    char       *Name;                   /* Name of variable             */

    int		Status;			/* Initial status		*/

    char       *CValue;

} InitialiseShellVariables[] = {

    { LIT_COLUMNS,		STATUS_INTEGER,		"80"		},

    { HistorySizeVariable,	STATUS_INTEGER,		"100"		},

    { LineCountVariable,	STATUS_INTEGER,		"1"		},

    { LIT_LINES,		STATUS_INTEGER,		"25"		},

    { OptIndVariable,		STATUS_INTEGER,		"1"		},

    { StatusVariable,		STATUS_INTEGER,		"0"		},

    { RandomVariable,		(STATUS_EXPORT | STATUS_INTEGER),

							null		},

    { SecondsVariable,		(STATUS_EXPORT | STATUS_INTEGER),

							null		},

    { LIT_OSmode,		(STATUS_EXPORT | STATUS_CANNOT_UNSET |

				 STATUS_INTEGER),	null		},

    { LIT_SHmode,		(STATUS_EXPORT | STATUS_CANNOT_UNSET |

				 STATUS_INTEGER),	null		},

    { LIT_Dollar,		(STATUS_CANNOT_UNSET | STATUS_INTEGER),

							null		},

    { LastWordVariable,		STATUS_EXPORT,		null		},

    { PathLiteral,		(STATUS_EXPORT | STATUS_CANNOT_UNSET),

							search		},

    { IFS,			(STATUS_EXPORT | STATUS_CANNOT_UNSET),

							" \t\n"		},

    { PS1,			(STATUS_EXPORT | STATUS_CANNOT_UNSET),

							"%e$ "		},

    { PS2,			(STATUS_EXPORT | STATUS_CANNOT_UNSET),

							"> "		},

    { PS3,			STATUS_EXPORT,		"#? "		},

    { PS4,			STATUS_EXPORT,		"+ "		},

    { HomeVariableName,		STATUS_EXPORT,		null		},

    { ShellVariableName,	STATUS_EXPORT,		null		},

#if (OS_TYPE != OS_DOS)

    { WinTitleVariable, 	0,			DefaultWinTitle	},

#endif

    { (char *)NULL,		0 }

};

/*

 * List of Editor variables

 */

#if defined (FLAGS_EMACS) || defined (FLAGS_VI) || defined (FLAGS_GMACS)

static char		*EditorVariables[] = {

    FCEditVariable, EditorVariable, VisualVariable, (char *)NULL

};

#endif

					/* Entry directory		*/

static char	Start_directory[PATH_MAX + 6] = { 0 };

static time_t	ShellStartTime = 0;	/* Load time of shell		*/

					/* Original Interrupt 24 address */

#if (OS_TYPE == OS_DOS) && !defined (__EMX__)

#if defined (__WATCOMC__)

#    define INTERRUPT_TYPE		__interrupt __far

#  else

#    define INTERRUPT_TYPE		interrupt far

#  endif

static void	(INTERRUPT_TYPE *Orig_I24_V) (void);

#endif

#ifdef SIGQUIT

static void     (_SIGDECL *qflag)(int) = SIG_IGN;

#endif

/* Functions */

static int F_LOCAL	RunCommands (Source *);

static unsigned char * F_LOCAL  CheckClassExpression (unsigned char *, int, bool);

static bool F_LOCAL	Initialise (int, char **);

static void F_LOCAL	CheckForMailArriving (void);

static void F_LOCAL	LoadGlobalVariableList (void);

static void F_LOCAL	LoadTheProfileFiles (void);

static void F_LOCAL	ConvertUnixPathToMSDOS (char *);

static void F_LOCAL	ClearUserPrompts (void);

static void F_LOCAL	SecondAndRandomEV (char *, long);

static void F_LOCAL	SetUpParameterEV (int, char **, char *);

static bool F_LOCAL	AllowedToSetVariable (VariableList *);

static void F_LOCAL	SetUpANumericValue (VariableList *, long, int);

static void F_LOCAL	ProcessErrorExit (char *, va_list);

static char * F_LOCAL	SuppressSpacesZeros (VariableList *, char *);

static void		AddToNewEnvironment (const void *, VISIT, int);

static void		AddToOldEnvironment (const void *, VISIT, int);

static void		DeleteEnvironment (const void *, VISIT, int);

static void F_LOCAL	CheckOPTIND (char *, long);

static void F_LOCAL	CreateIntegerVariables (void);

static bool F_LOCAL	ExecuteShellScript (char *);

static void 		CountEnvironment (const void *, VISIT, int);

/*

 * Process termination

 */

#if (OS_TYPE != OS_DOS)

static void F_LOCAL	CheckForTerminatedProcess (void);

#  if (OS_TYPE == OS_NT)

static void		LookUpJobs (const void *, VISIT, int);

#  endif

#else

#  define CheckForTerminatedProcess()

#endif

/*

 * No real argv interface

 */

#if (OS_TYPE == OS_UNIX)

#define Pre_Process_Argv(a,b)

#else

static void F_LOCAL	Pre_Process_Argv (char **, int *);

#endif

/*

 * OS/2 Session Queues

 */

#if (OS_TYPE == OS_OS2)

static void F_LOCAL	CheckForSessionEnd (void);

static void F_LOCAL	CreateTerminationQueues (void);

#else

#  define CheckForSessionEnd()

#  define CreateTerminationQueues()

#endif

#if defined (FLAGS_EMACS) || defined (FLAGS_VI) || defined (FLAGS_GMACS)

static void F_LOCAL	SetEditorMode (char *);

#endif

/*

 * The Program Name and Command Line, set up by stdargv.c

 */

#if (OS_TYPE != OS_UNIX)

extern char 		*_APgmName;

extern char		*_ACmdLine;

#endif

/*

 * The main program starts here

 */

#if defined(WIN32)

void __cdecl main(int argc, char **argv, char **envp)

#else

void main(int argc, char **argv)

#endif

{

    int			cflag = 0;

    int			sc;

    char                *name;

					/* Load up various parts of the	*/

					/* system			*/

    bool                OptionsRflag;

    bool		OptionsXflag = FALSE;	/* -x option from	*/

						/* command line		*/

    bool		Level0Shell = FALSE;	/* Level 0 (read profile)*/

    jmp_buf		ReturnPoint;

    char		*cp;

    Source		*s;

    int			fid;

    bool		TTYInput;

    bool		PIPEInput;

    bool		RootShell = FALSE;

    (void) envp;

    name = *argv;

    OptionsRflag = Initialise(argc, argv);

    SetWindowName ((char *)NULL);

/* Create Parse input */

    s = pushs (SFILE);

    s->u.file = stdin;

/* Set up start time */

    ShellStartTime = time ((time_t *)NULL);

/* Preprocess options to convert two character options of the form /x to

 * -x.  Some programs!!

 */

    if (argc > 1)

        Pre_Process_Argv (argv, &argc);

/* Save the start directory for when we exit */

    S_getcwd (Start_directory, 0);

/* Process the options */

    while ((sc = GetOptions (argc, argv, ShellOptions, GETOPT_MESSAGE)) != EOF)

    {

	switch (sc)

	{

	    case '?':

		FinalExitCleanUp (1);

	    case '0':				/* Level 0 flag for DOS	*/

		Level0Shell = TRUE;

		break;

	    case 'r':				/* Restricted		*/

		OptionsRflag = TRUE;

		break;

	    case 'c':				/* Command on line	*/

		ClearUserPrompts ();

		cflag = 1;

		s->type = SSTRING;

		s->str = OptionArgument;

		SetVariableFromString ("_cString", OptionArgument);

		break;

	    case 'q':				/* No quit ints		*/

#ifdef SIGQUIT

		qflag = SIG_DFL;

#endif

		break;

	    case 'X':

		if (!GotoDirectory (OptionArgument, GetCurrentDrive ()))

		{

		    PrintErrorMessage ("%s: bad directory", OptionArgument);

		    FinalExitCleanUp (1);

		}

		break;

	    case 'x':

		OptionsXflag = TRUE;

		break;

	    case 'M':

		ShellGlobalFlags |= FLAGS_MSDOS_FORMAT;

	        break;

	    case 'D':

		AssignVariableFromString (OptionArgument, (int *)NULL);

	        break;

	    case 'R':

		RootShell = TRUE;

		ChangeInitLoad = TRUE;	/* Change load .ini pt.		*/

		break;

#if (OS_TYPE != OS_DOS)

	    case 'P':				/* Use real pipes	*/

    		ShellGlobalFlags |= FLAGS_REALPIPES;

    		break;

#endif

	    case 's':				/* standard input	*/

	    	if (cflag)

		    PrintErrorMessage ("cannot use -s and -c together");

	    case 'i':				/* Set interactive	*/

		InteractiveFlag = TRUE;

	    default:

		if (islower (sc))

		    FL_SET (sc);

	}

/* If -s, set the argv to point to -s so that the rest of the parameters

 * get used as parameters ($digit) values.

 */

        if (FL_TEST (FLAG_POSITION))

	{

	    OptionIndex--;

	    break;

	}

    }

/* Under UNIX, check for login shell */

#if (OS_TYPE == OS_UNIX)

    if (*argv[0] == '-')

	Level0Shell = TRUE;

#endif

    argv += OptionIndex;

    argc -= OptionIndex;

/* Get configuration info */

    Configure_Keys ();

/*

 * Check for terminal input.  A special case for OS/2.  If pipe input and

 * output and no arguments, set interactive flag.

 *

 * Unset the variable after!

 */

    TTYInput  = C2bool ((IS_TTY (0) && IS_TTY (1)));

    PIPEInput = C2bool ((IS_Pipe (0) && IS_Pipe (1) &&

                         (GetVariableAsString (LIT_AllowTTY, FALSE) != null)));

    UnSetVariable (LIT_AllowTTY, -1, TRUE);

    if ((s->type == SFILE) &&

        ((FL_TEST (FLAG_INTERACTIVE)) || TTYInput || PIPEInput) &&

        !cflag &&

        ((argc == 0) || FL_TEST (FLAG_POSITION)))

    {

        s->type = STTY;

        FL_SET (FLAG_POSITION);

        FL_SET (FLAG_INTERACTIVE);

        InteractiveFlag = TRUE;

        if  (TTYInput)

            PrintVersionNumber (stderr);

    }

/* Root shell - check only tty devices */

    if (RootShell)

    {

       if ((s->type != STTY) || !TTYInput)

            PrintErrorMessage ("-R not valid on non-interactive shells");

#if (OS_TYPE == OS_DOS) && !defined (__EMX__)

        Orig_I24_V = (void (INTERRUPT_TYPE *)())NULL;

#endif

    }

/*

 * Execute commands from a file? - disable prompts

 */

    if ((s->type == SFILE) && (argc > 0) && !InteractiveFlag)

    {

        ClearUserPrompts ();

	name = *argv;

	if (((fid = S_open (FALSE, s->file = name, O_RMASK)) < 0) ||

	    ((s->u.file = ReOpenFile (ReMapIOHandler (fid), sOpenReadMode))

	                == (FILE *)NULL))

	{

	    PrintErrorMessage (LIT_Emsg, "cannot open script", name,

			       strerror (errno));

	    FinalExitCleanUp (1);

	}

/* Un-map this file descriptor from the current environment so it does not

 * get closed at the wrong times

 */

        ChangeFileDescriptorStatus (fileno (s->u.file), FALSE);

#if (OS_TYPE != OS_DOS)

        SetVariableFromString (WinTitleVariable, name);

#endif

    }

/* Setup stderr, stdout buffering */

    setvbuf (stderr, (char *)NULL, _IONBF, 0);

    if (InteractiveFlag && !IS_TTY (1))

        setvbuf (stdout, (char *)NULL, _IOLBF, BUFSIZ);

/* Set up the $- variable */

    SetShellSwitches ();

#ifdef SIGQUIT

    signal (SIGQUIT, qflag);

#endif

/* Set up signals */

    if (InteractiveFlag)

        signal (SIGTERM, TerminateSignalled);

/* Load any parameters */

   SetUpParameterEV (argc, argv, name);

/* Return point */

    if (SetErrorPoint (ReturnPoint))

        ExitTheShell (FALSE);

    signal (SIGINT, InterruptSignalled);

/* Read profile ?.  Init EMAC first for binding keys */

    if (((name != (char *)NULL) && (*name == CHAR_HYPHEN)) || Level0Shell)

    {

#if defined (FLAGS_EMACS) || defined (FLAGS_GMACS)

        EMACS_Initialisation ();

#endif

        LoadTheProfileFiles ();

    }

/*

 * Load history and configure

 */

    if (s->type == STTY)

    {

        HistoryEnabled = TRUE;

        LoadHistory ();

    }

/*

 * If the x or r flag was set on the command line, set it now after the

 * profiles have been executed.

 */

    if (GetVariableAsString("SHDEBUGEXEC", FALSE) != null)

    {

	FL_SET (FLAG_DEBUG_EXECUTE);

     	FL_CLEAR (FLAG_WARNING);

    }

    if (OptionsXflag)

    {

        FL_SET (FLAG_PRINT_EXECUTE);

    }

    if (OptionsRflag)

    {

	FL_SET (FLAG_READONLY_SHELL);

	RestrictedShellFlag = TRUE;

    }

/*

 * Execute $ENV

 *

 * TOCHECK - substitute (cp, DOTILDE);

 */

    if ((cp = GetVariableAsString (ENVVariable, FALSE)) != null)

        ExecuteShellScript (cp);

/* If interactive, set up Editor modes */

#if defined (FLAGS_EMACS) || defined (FLAGS_VI) || defined (FLAGS_GMACS)

    if (InteractiveFlag)

    {

        char    **rep = EditorVariables;

	while (*rep != (char *)NULL)

	{

	    if ((cp = GetVariableAsString (*(rep++), FALSE)) != null)

	    {

                SetEditorMode (cp);

		break;

	    }

	}

    }

#endif

/*

 * Execute what ever we have to do!!

 */

//  while (TRUE)

    for (;;)

    {

	switch (SetErrorPoint (ReturnPoint))

	{

	    case TERMINATE_POINT_SET:

		RunCommands (s);		/* Drop to exit		*/

	    case TERMINATE_COMMAND:

	    default:

		ExitTheShell (FALSE);

/* Re-set TTY input.  If we reach this point, the shell is a root shell and

 * the no exit message has been displayed.  Reset the shell for input from the

 * TTY.

 */

	    case TERMINATE_SHELL:

		s->type = STTY;

		break;

	}

    }

}

/*

 * Process a script file

 */

static bool F_LOCAL ExecuteShellScript (char *name)

{

    FILE	*f = stdin;

    int		fp;

    Source	*s;

    if (strcmp (name, "-") != 0)

    {

	if ((fp = OpenForExecution (name, (char **)NULL, (int *)NULL)) < 0)

	    return FALSE;

	if ((f = ReOpenFile (fp = ReMapIOHandler (fp),

			     sOpenReadMode)) == (FILE *)NULL)

	    return FALSE;

    }

    (s = pushs (SFILE))->u.file = f;

    s->file = name;

    RunCommands (s);

    if (f != stdin)

	CloseFile (f);

    return TRUE;

}

/*

 * run the commands from the input source, returning status.

 */

static int F_LOCAL RunCommands (Source *src)

{

    int		i;

    jmp_buf	ReturnPoint;

    C_Op	*t = (C_Op *)NULL;

    bool	wastty;

    int		EntryMemoryLevel = MemoryAreaLevel + 1;

    CreateNewEnvironment ();

    e.ErrorReturnPoint = (ErrorPoint)NULL;

    e.line = GetAllocatedSpace (LINE_MAX);

/*

 * Run until the end

 */

//  while (TRUE)

    for (;;)

    {

/* Initialise space */

	MemoryAreaLevel = EntryMemoryLevel;

	ReleaseMemoryArea (MemoryAreaLevel);

	SW_intr = 0;

	ProcessingEXECCommand = FALSE;

	if (src->next == NULL)

	    src->echo = C2bool (FL_TEST (FLAG_ECHO_INPUT));

/*

 * Set up a few things for console input - cursor, mail prompt etc

 */

	if ((wastty = C2bool (src->type == STTY)) != FALSE)

	{

	    PositionCursorInColumnZero ();

	    CheckForMailArriving ();

	    CheckForTerminatedProcess ();

	    CloseAllHandlers ();	/* Clean up any open shell files */

	}

	LastUserPrompt = PS1;

	FlushStreams ();			/* Clear output */

/* Set execute function recursive level and the SubShell count to zero */

	Execute_stack_depth = 0;

/* Set up Redirection IO (Saved) array and SubShell Environment information */

	NSave_IO_E = 0;		/* Number of entries		*/

	MSave_IO_E = 0;		/* Max Number of entries	*/

	NSubShells = 0;		/* Number of entries		*/

	MSubShells = 0;		/* Max Number of entries	*/

	CurrentFunction = (FunctionList *)NULL;

	CurrentFunction = (FunctionList *)NULL;

	ProcessingDEBUGTrap = FALSE;

	ProcessingERRORTrap = FALSE;

	Break_List = (Break_C *)NULL;

	Return_List = (Break_C *)NULL;

	SShell_List = (Break_C *)NULL;

	ProcessingEXECCommand = FALSE;

/* Get the line and process it */

	if (SetErrorPoint (ReturnPoint) ||

	    ((t = BuildParseTree (src)) == (C_Op *)NULL) || SW_intr)

	{

	    ScrapHereList ();

	    if ((!InteractiveFlag && SW_intr) || FL_TEST (FLAG_ONE_COMMAND))

		ExitTheShell (FALSE);

/* Go round again */

	    src->str = null;

	    SW_intr = 0;

	    continue;

	}

/* Ok - reset some variables and then execute the command tree */

	SW_intr = 0;

	ProcessingEXECCommand = FALSE;

	FlushHistoryBuffer ();		/* Save history			*/

/* Check for exit */

	if ((t != NULL) && (t->type == TEOF))

	{

	    if (wastty && (ShellGlobalFlags & FLAGS_IGNOREEOF))

	    {

		PrintWarningMessage ("Use `exit'");

		src->type = STTY;

		continue;

	    }

	    else

		break;

	}

/* Execute the parse tree */

	if ((SetErrorPoint (ReturnPoint) == 0) &&

	    ((!FL_TEST (FLAG_NO_EXECUTE)) || (src->type == STTY)))

	    ExecuteParseTree (t, NOPIPE, NOPIPE, 0);

/* Make sure the I/O and environment are back at level 0 and then clear them */

	e.ErrorReturnPoint = (ErrorPoint)NULL;

	Execute_stack_depth = 0;

	ClearExtendedLineFile ();

	if (NSubShells != 0)

	    DeleteGlobalVariableList ();

	if (NSave_IO_E)

	    RestoreStandardIO (0, TRUE);

	if (MSubShells)

	    ReleaseMemoryCell ((void *)SubShells);

	if (MSave_IO_E)

	    ReleaseMemoryCell ((void *)SSave_IO);

    /* Check for interrupts */

	if ((!InteractiveFlag && SW_intr) || FL_TEST (FLAG_ONE_COMMAND))

	{

	    ProcessingEXECCommand = FALSE;

	    ExitTheShell (FALSE);

	}

/* Run any traps that are required */

	if ((i = InterruptTrapPending) != 0)

	{

	    InterruptTrapPending = 0;

	    RunTrapCommand (i);

	}

    }

/*

 * Terminate the current environment

 */

    QuitCurrentEnvironment ();

    return ExitStatus;

}

/*

 * Set up the value of $-

 */

void SetShellSwitches (void)

{

    char	*cp, c;

    char	m['z' - 'a' + 2];

    for (cp = m, c = 'a'; c <= 'z'; ++c)

    {

	if (FL_TEST (c))

	    *(cp++) = c;

    }

    if (ShellGlobalFlags & FLAGS_MSDOS_FORMAT)

	*(cp++) = 'M';

    *cp = 0;

    SetVariableFromString (ShellOptionsVariable, m);

}

/*

 * Terminate current environment with an error

 */

void TerminateCurrentEnvironment (int TValue)

{

    FlushStreams ();			/* Clear output */

    if (e.ErrorReturnPoint != (ErrorPoint)NULL)

	ExitErrorPoint (TValue);

    /* NOTREACHED */

}

/*

 * Exit the shell

 */

void ExitTheShell (bool ReturnRequired)

{

    FlushStreams ();			/* Clear output */

    if (ProcessingEXECCommand)

	TerminateCurrentEnvironment (TERMINATE_COMMAND);

#if (OS_TYPE == OS_DOS) && !defined (__EMX__)

    if (Orig_I24_V == (void (INTERRUPT_TYPE *)())NULL)

    {

	feputs (NOExit);

	if (!ReturnRequired)

	    TerminateCurrentEnvironment (TERMINATE_SHELL);

    }

#else

    (void) ReturnRequired;

#endif

/* Clean up */

    ScrapHereList ();

    FreeAllHereDocuments (1);

/* Trap zero on exit */

    RunTrapCommand (0);

/* Dump history on exit */

    DumpHistory ();

    CloseAllHandlers ();

/* If this is a command only - restore the directory because DOS doesn't

 * and the user might expect it

 */

    if (*Start_directory)

	RestoreCurrentDirectory (Start_directory);

/* If this happens during startup - we restart */

#if (OS_TYPE == OS_DOS) && !defined (__EMX__)

    if (Orig_I24_V == (void (INTERRUPT_TYPE *)())NULL)

	return;

#endif

/*

 * Clean up any Here Document files left in the function tree

 */

    DeleteAllFunctions ();

/* Exit - hurray */

    FinalExitCleanUp (ExitStatus);

/* NOTREACHED */

}

/*

 * Output warning message

 */

int PrintWarningMessage (char *fmt, ...)

{

    va_list	ap;

    va_start (ap, fmt);

    vfprintf (stderr, fmt, ap);

    feputc (CHAR_NEW_LINE);

    ExitStatus = -1;

/* If leave on error - exit */

    if (FL_TEST (FLAG_EXIT_ON_ERROR))

	ExitTheShell (FALSE);

    va_end (ap);

    return 1;

}

/*

 * Shell error message