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 | STATUS_CONVERT_MSDOS),

                                                        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

/*

**  Debug level

*/

int debug_level = 0;

/*

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

/* Force Shell Globals as DOS */

#if (OS_TYPE == OS_NT) ||(OS_TYPE == OS_DOS)

        ShellGlobalFlags |= FLAGS_MSDOS_FORMAT;

#endif

/* 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 ( debug_level & DEBUG_EXEC_ALL )

    {

        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;