Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume10/sh_dos/part03

Text File | 1990-02-13 | 81KB | 3,988 lines

Newsgroups: comp.sources.misc
organization: ITM Sector, Data Logic Ltd. (A Raytheon Company)
From: [e-mail] (Ian Stewartson)
subject: v10i055: MSDOS Shell (sh) Implementation - Part 02 of 05
Sender: [e-mail] (Brandon S. Allbery - comp.sources.misc)

Posting-number: Volume 10, Issue 55
Submitted-by: [e-mail] (Ian Stewartson)
Archive-name: sh_dos/part03

#!/bin/sh
# this is part 2 of a multipart archive
# do not concatenate these parts, unpack them in order with /bin/sh
# file lib/ms_dio.c continued
#
CurArch=2
if test ! -r s2_seq_.tmp
then echo "Please unpack part 1 first!"
     exit 1; fi
( read Scheck
  if test "$Scheck" != $CurArch
  then echo "Please unpack part $Scheck next!"
       exit 1;
  else exit 0; fi
) < s2_seq_.tmp || exit 1
echo "x - Continuing file lib/ms_dio.c"
sed 's/^X//' << 'SHAR_EOF' >> lib/ms_dio.c
X
X    if (FP->drive & HD_FLAG)
X    {
X        struct partition    *pp, tp;
X
X/* System call failed - no device */
X
X        if ((iregs.x.cflag) || (ndrive >= iregs.h.dl))
X        {
X        free (FP);
X        errno = ENOENT;
X        return -1;
X        }
X
X/* OK - save the parameters */
X
X        FP->m_cyl    = (iregs.h.ch | ((iregs.h.cl & 0x0c0) << 2)) + 2;
X        FP->m_head   = iregs.h.dh + 1;
X        FP->m_sector = iregs.h.cl & 0x03f;
X        FP->m_scount = FP->m_cyl * FP->m_head * FP->m_sector;
X
X/* If this is not partition 0 - read the partition table */
X
X        if (FP->partition)
X        {
X        if (dio_do (BIOS_READ, FP, buf, 0L, 1) == -1)
X        {
X            free (FP);
X            return -1;
X        }
X
X        if (*(int *)&buf[510] != 0xaa55)
X        {
X            errno = ENOENT;
X            return -1;
X        }
X
X/* Sort the partition table */
X
X        pp = (struct partition *)&buf[0x1be];
X
X        for (i = 0; i < 4; i++)
X        {
X            for (j = 0; j < 3; j++)
X            {
X            if (((!pp[j].offset) && pp[j + 1].offset) ||
X                ((pp[j].offset > pp[j + 1].offset) &&
X                  pp[j + 1].offset))
X            {
X                tp        = pp[j];
X                pp[j]     = pp[j + 1];
X                pp[j + 1] = tp;
X            }
X            }
X        }
X
X        if (pp[FP->partition - 1].offset == 0L)
X        {
X            errno = ENOENT;
X            return -1;
X        }
X
X        FP->m_start = pp[FP->partition - 1].offset;
X        FP->m_scount = pp[FP->partition - 1].size;
X        }
X    }
X
X/* Floppy disk - get parameters.  We try our best here, but DOS 3.3 allows
X * you to format any number of sectors per track and tracks per disk
X */
X
X    else
X    {
X
X/* System call failed - think this means we're on an XT.  So set up the
X * XT parameters
X */
X
X        if ((iregs.x.cflag) && (ndrive < 2))
X        {
X        iregs.h.bl   = 0x01;
X        FP->m_cyl    = 40;
X        FP->m_head   = 2;
X        FP->m_sector = 9;
X        }
X
X/* No Drive */
X
X        else if ((iregs.x.cflag) || (ndrive >= iregs.h.dl))
X        {
X        free (FP);
X        errno = ENOENT;
X        return -1;
X        }
X
X/* OK - save the parameters */
X
X        else
X        {
X        FP->m_cyl    = iregs.h.ch;
X        FP->m_head   = iregs.h.dh + 1;
X        FP->m_sector = iregs.h.cl;
X        }
X
X        FP->m_scount = FP->m_cyl * FP->m_head * FP->m_sector;
X
X/* High capacity drive ? */
X
X        if ((iregs.h.bl == 0x02) || (iregs.h.bl == 0x03))
X        {
X
X/* Try reading sector 0 */
X
X        FP->m_sector = (iregs.h.bl == 0x02) ? 9 : 15;
X
X/* If it failed - switch to the other type */
X
X        if (dio_do (BIOS_READ, FP, buf, 0L, 1) == -1)
X        {
X            FP->m_sector = (iregs.h.bl == 0x02) ? 15 : 9;
X
X            iregs.h.ah   = 0x17;
X            iregs.h.dl   = (unsigned char)FP->drive;
X            iregs.h.al   = (unsigned char)(5 - iregs.h.bl);
X            int86 (0x13, &iregs, &iregs);
X        }
X        }
X
X/* 8 or 9 Sectors, 1 or 2 heads */
X
X        if (((iregs.h.bl > 0x00) || (iregs.h.bl < 0x04)) &&
X        (FP->m_sector == 9))
X        {
X        FP->m_scount = FP->m_cyl * FP->m_head * FP->m_sector;
X
X/* Check to see if sector 8 exists */
X
X        if (dio_do (BIOS_READ, FP, buf, 8L, 1) == -1)
X            FP->m_sector = 8;
X
X/* Check to see if sector 380 exists */
X
X        if (dio_do (BIOS_READ, FP, buf, 380L, 1) == -1)
X            FP->m_head = 1;
X        }
X
X/* 720K drive - read sector 15 to see if 1.4M */
X
X        else if (iregs.h.bl == 0x04)
X        {
X        FP->m_scount = FP->m_cyl * FP->m_head * FP->m_sector;
X
X        if (dio_do (BIOS_READ, FP, buf, 17L, 1) == -1)
X            FP->m_sector = 9;
X        }
X
X        FP->m_scount = FP->m_cyl * FP->m_head * FP->m_sector;
X    }
X
X/* Set up the file descriptor entry and return the number */
X
X    MS_io_fs[fp] = FP;
X    return fp + MS_MODIFIER;
X    }
X
X    else
X    return open (name, mode, permissions);
X}
X
X/* fstat function */
X
Xint        dio_fstat (fp, St)
Xint        fp;
Xstruct stat    *St;
X{
X    struct fs        *FP;
X
X    if (fp < MS_MODIFIER)
X    return fstat (fp, St);
X
X    if ((FP = dio_fpcheck (fp)) == (struct fs *)NULL)
X    return -1;
X
X/* Dummy values */
X
X    memset (St, 0, sizeof (struct stat));
X    St->st_mode = 0x61b6;
X    St->st_nlink = 1;
X
X    if (FP->drive == DRIVE_RAM)
X    {
X    St->st_size = MEGABYTE;
X    St->st_rdev = 0x0300;
X    }
X
X    else
X    {
X    St->st_rdev = ((FP->drive & (~HD_FLAG)) * 10 + FP->partition) |
X              ((FP->drive & HD_FLAG) ? 0x0200 : 0x0100);
X    St->st_dev = FP->drive;
X    }
X
X    St->st_atime = time ((time_t *)NULL);
X    St->st_ctime = St->st_ctime;
X    St->st_mtime = St->st_atime;
X    return 0;
X}
X
X/*
X * Close function
X */
X
Xint    dio_close (fp)
Xint    fp;
X{
X    struct fs        *FP;
X
X    if (fp < MS_MODIFIER)
X    return close (fp);
X
X    if ((FP = dio_fpcheck (fp)) == (struct fs *)NULL)
X    return -1;
X
X    free (FP);
X    MS_io_fs[fp - MS_MODIFIER] = (struct fs *)NULL;
X    return 0;
X}
X
X/*
X * Seek function
X */
X
Xlong    dio_lseek (fp, off, type)
Xint    fp;
Xoff_t    off;
Xint    type;
X{
X    off_t        check;
X    struct fs        *FP;
X
X    if (fp < MS_MODIFIER)
X    return lseek (fp, off, type);
X
X    if ((FP = dio_fpcheck (fp)) == (struct fs *)NULL)
X    return -1L;
X
X    switch (type)
X    {
X    case SEEK_SET:
X        check = off;
X        break;
X
X    case SEEK_CUR:
X        check = off + FP->location;
X        break;
X
X    case SEEK_END:
X    default:
X        errno = EINVAL;
X        return -1L;
X    }
X
X    if (check < 0L)
X    {
X    errno = EINVAL;
X    return -1L;
X    }
X
X    return (FP->location = check);
X}
X
X/* Check for a valid file pointer */
X
Xstatic struct fs    *dio_fpcheck (fp)
Xint            fp;
X{
X    struct fs    *FP;
X
X    if (((FP = MS_io_fs[fp - MS_MODIFIER]) == (struct fs *)NULL) ||
X    (fp - MS_MODIFIER >= _NFILE) || (fp - MS_MODIFIER < 0))
X    {
X    errno = EBADF;
X    return (struct fs *)NULL;
X    }
X
X    return FP;
X}
X
X/* Check for a valid file name */
X
Xstatic int    dio_fncheck (name)
Xchar        *name;
X{
X
X/* Check for hard disk */
X
X    if (isdigit(name[7]) && isdigit(name[8]) && (strlen (name) == 9) &&
X    (!strnicmp (name, "/dev/hd", 6)))
X    {
X    int    i = atoi (&name[7]);
X
X    return ((i % 10) > 4) ? -1 : i | HD_FLAG;
X    }
X
X/* Check for floppy disk */
X
X    else if (isdigit(name[7]) && (strlen (name) == 8) &&
X    (!strnicmp (name, "/dev/fd", 6)))
X    return name[7] - '0';
X
X    else if (!stricmp (name, "/dev/kmem"))
X    return DRIVE_RAM;
X
X    return -1;
X}
X
X/* Get file status */
X
Xint        dio_stat (name, St)
Xchar        *name;
Xstruct stat    *St;
X{
X    int        drive;
X
X    if ((drive = dio_fncheck (name)) == -1)
X    return stat (name, St);
X
X    memset (St, 0, sizeof (struct stat));
X    St->st_mode = 0x61b6;
X    St->st_nlink = 1;
X    St->st_atime = time ((time_t *)NULL);
X    St->st_ctime = St->st_ctime;
X    St->st_mtime = St->st_atime;
X
X    if (drive == DRIVE_RAM)
X    {
X    St->st_size = MEGABYTE;
X    St->st_rdev = 0x0300;
X    }
X
X    else
X    {
X    St->st_rdev = (drive & (~HD_FLAG)) | ((drive & HD_FLAG) ? 0x0200
X                                : 0x0100);
X    St->st_dev = drive;
X    }
X
X    return 0;
X}
X
X/* Check file access */
X
Xint    dio_access (name, mode)
Xchar    *name;
Xint    mode;
X{
X    if (dio_fncheck (name) == -1)
X    return access (name, mode);
X
X    else if (mode & 1)
X    {
X    errno = EACCES;
X    return -1;
X    }
X
X    return 0;
X}
X
X/* Change file permissions */
X
Xint    dio_chmod (name, mode)
Xchar    *name;
Xint    mode;
X{
X    return (dio_fncheck (name) == -1) ? chmod (name, mode) : 0;
X}
X
X/* Create file */
X
Xint    dio_creat (name, mode)
Xchar    *name;
Xint    mode;
X{
X    return (dio_fncheck (name) == -1) ? creat (name, mode)
X                      : dio_open (name, O_WRONLY, mode);
X}
X
X/* Duplicate handler */
X
Xint    dio_dup (fp)
Xint    fp;
X{
X    struct fs    *FP;        /* New pointer            */
X    struct fs    *FP1;        /* Old pointer            */
X
X    if (fp < MS_MODIFIER)
X    return dup (fp);
X
X    if ((FP1 = dio_fpcheck (fp)) == (struct fs *)NULL)
X    return -1;
X
X    for (fp = 0; (fp < _NFILE) && (MS_io_fs[fp] != (struct fs *)NULL); fp++)
X    ;
X
X    if ((fp == _NFILE) ||
X    ((FP = (struct fs *)malloc (sizeof (struct fs))) == (struct fs *)NULL))
X    {
X    errno = EMFILE;
X    return -1;
X    }
X
X    MS_io_fs[fp] = FP;
X    *FP = *FP1;
X    return fp;
X}
X
X/* Check if tty */
X
Xint    dio_isatty (fp)
Xint    fp;
X{
X    if (fp < MS_MODIFIER)
X    return isatty (fp);
X
X    return 0;
X}
X
X/* Tell location */
X
Xlong    dio_tell (fp)
Xint    fp;
X{
X    struct fs    *FP;
X
X    if (fp < MS_MODIFIER)
X    return tell (fp);
X
X    return ((FP = dio_fpcheck (fp)) == (struct fs *)NULL) ? -1L : FP->location;
X}
SHAR_EOF
echo "File lib/ms_dio.c is complete"
chmod 0644 lib/ms_dio.c || echo "restore of lib/ms_dio.c fails"
set `wc -c lib/ms_dio.c`;Sum=$1
if test "$Sum" != "17329"
then echo original size 17329, current size $Sum;fi
echo "x - extracting lib/director.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lib/director.c &&
X/*
X * @(#)msd_dir.c 1.4 87/11/06    Public Domain.
X *
X *  A public domain implementation of BSD directory routines for
X *  MS-DOS.  Written by Michael Rendell ({uunet,utai}michael@garfield),
X *  August 1897
X */
X
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <stdio.h>
X#include <stdlib.h>
X#include <malloc.h>
X#include <string.h>
X#include <limits.h>
X#include <errno.h>
X#include <dirent.h>
X#include <dos.h>
X
X#define    ATTRIBUTES        (_A_SUBDIR | _A_HIDDEN | _A_SYSTEM | \
X                 _A_NORMAL | _A_RDONLY | _A_ARCH | _A_VOLID)
X
Xstatic void    free_dircontents (struct _dircontents *);
X
XDIR    *opendir(name)
Xchar    *name;
X{
X    struct stat        statb;
X    DIR            *dirp;
X    char        c;
X    struct _dircontents    *dp;
X    char        nbuf[PATH_MAX + NAME_MAX + 2];
X    struct find_t    dtabuf;
X
X    if (stat (name, &statb) < 0)
X    return (DIR *) NULL;
X
X    if (!S_ISDIR(statb.st_mode))
X    {
X    errno = ENOTDIR;
X    return (DIR *)NULL;
X    }
X
X    if ((dirp = (DIR *) malloc (sizeof (DIR))) == (DIR *) NULL)
X    return (DIR *) NULL;
X
X    if (*name && (c = name[strlen (name) - 1]) != '\\' && c != '/')
X    (void) strcat (strcpy (nbuf, name), "\\*.*");
X
X    else
X    (void) strcat (strcpy (nbuf, name), "*.*");
X
X    dirp->dd_loc      = 0;
X    dirp->dd_cp       = (struct _dircontents *) NULL;
X    dirp->dd_contents = (struct _dircontents *) NULL;
X
X    if (_dos_findfirst (nbuf, ATTRIBUTES, &dtabuf) != 0)
X    return dirp;
X
X    do
X    {
X    if (((dp = (struct _dircontents *) malloc(sizeof(struct _dircontents))) == (struct _dircontents *) NULL) ||
X        ((dp->_d_entry = strdup (dtabuf.name)) == (char *) NULL))
X    {
X        if (dp != (char *)NULL)
X        free ((char *) dp);
X
X        free_dircontents (dirp->dd_contents);
X        return (DIR *) NULL;
X    }
X
X    if (dirp->dd_contents)
X        dirp->dd_cp = dirp->dd_cp->_d_next = dp;
X
X    else
X        dirp->dd_contents = dirp->dd_cp = dp;
X
X    dp->_d_next = (struct _dircontents *) NULL;
X
X    } while (_dos_findnext (&dtabuf) == 0);
X
X    dirp->dd_cp = dirp->dd_contents;
X
X    return dirp;
X}
X
Xint    closedir(dirp)
XDIR    *dirp;
X{
X    free_dircontents (dirp->dd_contents);
X    free ((char *) dirp);
X    return 0;
X}
X
Xstruct dirent    *readdir(dirp)
XDIR        *dirp;
X{
X    static struct dirent    dp;
X
X    if (dirp->dd_cp == (struct _dircontents *) NULL)
X    return (struct dirent *) NULL;
X
X    dp.d_reclen = strlen (strcpy (dp.d_name, dirp->dd_cp->_d_entry));
X    dp.d_off    = dirp->dd_loc * 32;
X    dp.d_ino    = (ino_t)++dirp->dd_loc;
X    dirp->dd_cp = dirp->dd_cp->_d_next;
X    strlwr (dp.d_name);
X
X    return &dp;
X}
X
Xvoid    rewinddir (dirp)
XDIR    *dirp;
X{
X    seekdir (dirp, (off_t)0);
X}
X
Xvoid    seekdir (dirp, off)
XDIR    *dirp;
Xoff_t    off;
X{
X    long        i = off;
X    struct _dircontents    *dp;
X
X    if (off < 0L)
X    return;
X
X    for (dp = dirp->dd_contents ; --i >= 0 && dp ; dp = dp->_d_next)
X    ;
X
X    dirp->dd_loc = off - (i + 1);
X    dirp->dd_cp = dp;
X}
X
Xoff_t    telldir(dirp)
XDIR    *dirp;
X{
X    return dirp->dd_loc;
X}
X
Xstatic void        free_dircontents(dp)
Xstruct _dircontents    *dp;
X{
X    struct _dircontents    *odp;
X
X    while (dp)
X    {
X    if (dp->_d_entry)
X        free(dp->_d_entry);
X
X    dp = (odp = dp)->_d_next;
X    free((char *) odp);
X    }
X}
SHAR_EOF
chmod 0644 lib/director.c || echo "restore of lib/director.c fails"
set `wc -c lib/director.c`;Sum=$1
if test "$Sum" != "3067"
then echo original size 3067, current size $Sum;fi
echo "x - extracting lib/popen.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lib/popen.c &&
X/*
X * popen/pclose: simple MS-DOS piping scheme to imitate UNIX pipes
X */
X
X#include <sys/types.h>
X#include <stdio.h>
X#include <string.h>
X#include <errno.h>
X#include <process.h>
X#include <limits.h>
X#include <stdlib.h>
X#include <unistd.h>
X
Xtypedef struct    pipes {
X    FILE    *p_fp;            /* File id            */
X    char    *p_process;        /* Program name            */
X    char    *p_file;        /* Pipe file name        */
X    int        p_status;        /* Status for close to return    */
X                    /* Read pipes only        */
X    bool    p_write;        /* Read or write        */
X} PIPE;
X
Xstatic PIPE    P_list[_NFILE];        /* The pipe structures        */
Xstatic int    Pipes_Inited = 0;    /* Initialised ?        */
Xstatic int    Unique_Pipe  = 0;
X
Xstatic PIPE    *_p_save_entry (char *, bool);
Xstatic int    _p_run (char *);
Xstatic int    _p_reset_entry (PIPE *, int);
Xstatic PIPE    *_p_get_entry (FILE *);
X
X/* Set up a pipe structure */
X
Xstatic PIPE    *_p_save_entry (prog, mode)
Xchar        *prog;
Xbool        mode;
X{
X    FILE    *fp;        /* File handler                */
X    PIPE    *pp;        /* Pipe handler structure        */
X    char    tmpfile[NAME_MAX + PATH_MAX + 2];
X    char    *tmpdir;    /* Points to directory prefix of pipe    */
X
X/* Find out where we should put temporary files */
X
X    if ((tmpdir = getenv ("TMPDIR")) == (char *) NULL)
X    tmpdir = getenv ("TMP");
X
X/* Use temporary directory if available */
X
X    if (tmpdir == (char *)NULL)
X    tmpdir = ".";
X
X/* Get a unique pipe file name */
X
X    sprintf (tmpfile, "%s/pipe%05d.tmp", tmpdir, Unique_Pipe++);
X    unlink (tmpfile);
X
X/* Create the pipe */
X
X    if ((fp = fopen (tmpfile, "w")) == (FILE *) NULL)
X    return (PIPE *)NULL;
X
X/* Create the PIPE entry */
X
X    if ((pp = _p_get_entry ((FILE *)NULL)) == (PIPE *)NULL)
X    {
X    fclose (fp);
X    unlink (tmpfile);
X    errno = EMFILE;
X    return (PIPE *)NULL;
X    }
X
X/* Set up the entry */
X
X    pp->p_fp      = fp;
X    pp->p_write   = mode;
X    pp->p_process = strdup (prog);
X    pp->p_file    = strdup (tmpfile);
X
X/* Check for errors */
X
X    if ((pp->p_process == (char *)NULL) || (pp->p_file == (char *)NULL))
X    {
X    _p_reset_entry (pp, 1);
X    errno = ENOMEM;
X    return (FILE *)NULL;
X    }
X
X    return pp;
X}
X
X/* Execute command via SHELL or COMSPEC */
X
Xstatic int    _p_run (command)
Xchar        *command;
X{
X    char    *shell;            /* Command processor        */
X    char    *shellpath;        /* Full command processor path    */
X    char    *bp;            /* Generic string pointer    */
X    char    *dash = "/c";
X
X/* Determine the command processor */
X
X    if (((shell = getenv ("SHELL")) == (char *) NULL) &&
X    ((shell = getenv ("COMSPEC")) == (char *) NULL))
X    shell = "command.com";
X
X    shellpath = strlwr (shell);
X
X/* Strip off any leading backslash directories */
X
X    if ((shell = strrchr (shellpath, '\\')) != (char *)NULL)
X    ++shell;
X
X    else
X    shell = shellpath;
X
X/* Strip off any leading slash directories */
X
X    if ((bp = strrchr (shell, '/')) != (char *)NULL)
X    shell = ++bp;
X
X    if (strcmp (shell, "command.com"))
X    *dash = '-';
X
X/* Run the program */
X
X    return spawnl (P_WAIT, shellpath, shell, dash, command, (char *) NULL);
X}
X
X/* resetpipe: Private routine to cancel a pipe */
X
Xstatic int    _p_reset_entry (pp, mode)
XPIPE        *pp;
Xint        mode;
X{
X    int        result = (!mode) ? 0 : -1;
X    int        serrno = errno;
X
X/* Close the pipe */
X
X    fclose (pp->p_fp);
X
X/* Free up memory */
X
X    if (pp->p_file != (char *)NULL)
X    {
X    result = unlink (pp->p_file);
X
X    if (!mode)
X        serrno = errno;
X
X    else
X        result = -1;
X
X    free (pp->p_file);
X    }
X
X    if (pp->p_process != (char *)NULL)
X    free (pp->p_process);
X
X    memset (pp, 0, sizeof (PIPE));
X
X/* Return error code */
X
X    errno = serrno;
X    return result;
X}
X
X/* Find a free entry */
X
Xstatic PIPE    *_p_get_entry (fp)
XFILE        *fp;
X{
X    int        i;
X
X    for (i = 0; i < _NFILE; i++)
X    {
X    if (P_list[i].p_fp == fp)
X        return &P_list[i];
X    }
X
X    return (PIPE *)NULL;
X}
X
X
X/* popen: open a pipe */
X
XFILE    *popen (command, type)
Xchar    *command;        /* The command to be run        */
Xchar    *type;            /* "w" or "r"                */
X{
X    int        old_stdout;
X    PIPE    *pp;
X
X/* Initialise the pipe structure */
X
X    if (!Pipes_Inited)
X    {
X    memset (&P_list[0], 0, sizeof (P_list));
X    Pipes_Inited = 1;
X    }
X
X/* For write style pipe, pclose handles program execution */
X
X    if (strcmp (type, "w") == 0)
X    return ((pp = _p_save_entry (command, TRUE)) == (PIPE *)NULL)
X           ? (FILE *)NULL : pp->p_fp;
X
X/* read pipe must create tmp file, set up stdout to point to the temp
X * file, and run the program.  note that if the pipe file cannot be
X * opened, it'll return a condition indicating pipe failure, which is
X * fine.
X */
X
X    else if (strcmp (type, "r") == 0)
X    {
X    if ((pp = _p_save_entry (command, FALSE)) == (PIPE *)NULL)
X       return (FILE *)NULL;
X
X/* Save the stdout file descriptor, dup the pipe onto standard out,
X * execute the command, close the pipe and re-open it
X */
X
X    if ((old_stdout = dup (fileno(stdout)) < 0)        ||
X        (dup2 (fileno (pp->p_fp), fileno(stdout)) < 0)    ||
X        ((pp->p_status = _p_run (command)) < 0)        ||
X        (fclose (pp->p_fp) < 0)                ||
X        (dup2 (old_stdout, fileno (stdout)) < 0)        ||
X        ((pp->p_fp = fopen (pp->p_file, "r")) == (FILE *)NULL))
X    {
X        _p_reset_entry (pp, 1);
X        return (FILE *)NULL;
X    }
X
X    else
X        return pp->p_fp;
X    }
X
X/* screwy call or unsupported type */
X
X    errno = EINVAL;
X    return (FILE *)NULL;
X}
X
X/* close a pipe */
X
Xint    pclose (fp)
XFILE    *fp;
X{
X    PIPE    *pp;            /* Current pipe structure    */
X    int        old_stdin;        /* Where our stdin points now    */
X
X    if ((pp = _p_get_entry (fp)) == (PIPE *)NULL)
X    {
X    errno = EBADF;
X    return -1;
X    }
X
X    if (fclose (pp->p_fp) < 0)
X    return _p_reset_entry (pp, 1);
X
X/* Open the pipe in read mode, Save stdin file descriptor, copy pipe file
X * descriptor to stdin, execute the command, and then restore stdin
X */
X
X    if (pp->p_write &&
X    (    ((pp->p_fp = fopen (pp->p_file, "r")) == (FILE *)NULL)    ||
X        ((old_stdin = dup (fileno (stdin))) < 0)        ||
X        (dup2 (fileno (pp->p_fp), fileno (stdin)) < 0)        ||
X        ((pp->p_status = _p_run (pp->p_process)) < 0)        ||
X        (fclose (pp->p_fp) < 0)                    ||
X        (dup2 (old_stdin, fileno (stdin)) < 0)
X    ))
X    return _p_reset_entry (pp, 1);
X
X/* Close the temp file and remove it */
X
X    return _p_reset_entry (pp, 0);
X}
SHAR_EOF
chmod 0644 lib/popen.c || echo "restore of lib/popen.c fails"
set `wc -c lib/popen.c`;Sum=$1
if test "$Sum" != "6060"
then echo original size 6060, current size $Sum;fi
echo "x - extracting lib/syserr.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lib/syserr.c &&
X/* perror(s) print the current error message. */
X
Xchar    *sys_errlist[] = {
X    "Error 0 ",
X    "Operation not permitted",
X    "No such file or directory",
X    "No such process",
X    "Interrupted system call",
X    "I/O error",
X    "No such device or address",
X    "Arg list too long",
X    "Exec format error",
X    "Bad file number",
X    "No children",
X    "No more processes",
X    "Not enough core",
X    "Permission denied",
X    "Bad address",
X    "Block device required",
X    "Mount device busy",
X    "File exists",
X    "Cross-device link",
X    "No such device",
X    "Not a directory",
X    "Is a directory",
X    "Invalid argument",
X    "File table overflow",
X    "Too many open files",
X    "Not a typewriter",
X    "Text file busy",
X    "File too large",
X    "No space left on device",
X#define  ESPIPE    29
X    "Illegal seek",
X    "Read-only file system",
X    "Too many links",
X
X    "Broken pipe",
X    "Math argument",
X    "Result too large",
X    "EUCLEAN",
X    "No message of desired type",
X    "Resource deadlock would occur"
X    "Unknown error"
X};
X
Xint    sys_nerr = sizeof(sys_errlist)/sizeof(char *) - 1;
SHAR_EOF
chmod 0644 lib/syserr.c || echo "restore of lib/syserr.c fails"
set `wc -c lib/syserr.c`;Sum=$1
if test "$Sum" != "1106"
then echo original size 1106, current size $Sum;fi
echo "x - extracting lib/stdargv.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lib/stdargv.c &&
X/*
X *  MODULE NAME:     expand.c                        Revision: 1.0
X *
X *  AUTHOR:         Ian Stewartson
X *
X *  LOCATION:         Data Logic,
X *             Greenford,
X *             Middlesex,
X *             England.
X *
X#include <logo.h>
X *  MODULE DEFINITION:    This function expandes the command line parameters
X *            in a UNIX like manner.    Wild character *?[] are
X *            allowed in file names. @filename causes command lines
X *            to be read from filename.  Strings between " or ' are
X *            not expanded.  All entries in the array are malloced.
X *
X *            This function replaces the standard MS-DOS command
X *            line processing function (_setargv in stdargv.obj).
X *
X *  CALLING SEQUENCE:    The following calling sequences are used:
X *
X *            void    _setargv ();
X *
X *  ERROR MESSAGES:    Out of memory
X *
X *  INCLUDE FILES:
X */
X
X#include <sys/types.h>            /* MS-DOS type definitions          */
X#include <sys/stat.h>            /* File status definitions        */
X#include <stdio.h>            /* Standard I/O delarations         */
X#include <stdlib.h>            /* Standard library functions       */
X#include <errno.h>            /* Error number declarations        */
X#include <dos.h>            /* DOS functions declarations       */
X#include <bios.h>            /* BIOS functions declarations      */
X#include <ctype.h>            /* Character type declarations      */
X#include <string.h>            /* String library functions         */
X#include <limits.h>            /* String library functions         */
X#include <fcntl.h>            /* File Control Declarations        */
X#include <io.h>                /* Input/Output Declarations        */
X#include <dirent.h>            /* Direction I/O functions        */
X
X/*
X *  DATA DEFINITIONS:
X */
X
X#define MAX_LINE    160        /* Max line length        */
X#define S_ENTRY        sizeof (char *)
X
X/*
X *  DATA DECLARATIONS:
X */
X#ifdef MSDOS
X
Xextern void    _setargv (void);
Xstatic void    exp_line (char *);        /* Expand file        */
Xstatic int    ex_pfield (char    *, char *);    /* Expand field        */
Xstatic void    ex_pfile (char *);
Xstatic char    *ex_gspace (int, char *);    /* Get space        */
Xstatic void    ex_add_arg (char *);    /* Add argument            */
Xstatic char    *ex_skip_sp (char *);    /* Skip spaces            */
Xstatic char    *ex_tounix (char *);    /* Convert name to Unix format    */
Xstatic int    ex_find (char*, int);    /* Split file name        */
Xstatic void    ex_fatal (int, char *, char *);    /* Fatal error processing*/
Xstatic char    *ex_environment (char *);    /* Process environment    */
Xstatic char    *_ex_multi_drive (char *);    /* Check for multidrive    */
Xstatic char    *ex_nomem = "%s: %s\n";
X
Xextern char far    *_pgmptr;         /* Program name            */
Xextern char    **__argv;         /* Current argument address    */
Xextern int    __argc;         /* Current argument count    */
X
X/*
X *  MODULE ABSTRACT: _setargv
X *
X *  UNIX like command line expansion
X */
X
Xvoid    _setargv ()
X{
X                    /* Set up pointer to command line */
X    char far        *argvp = (char far *)((((long)_psp) << 16) + 0x081L);
X    unsigned int    envs = *(int far *)((((long)_psp) << 16) + 0x02cL);
X    char far        *s;         /* Temporary string pointer        */
X#ifndef M_I86LM
X    char        buf[MAX_LINE];    /* Temporary space        */
X    char        *cp;
X#endif
X
X/* Command line can be null or 0x0d terminated - convert to null */
X
X    s = argvp;
X
X    while (*s && (*s != 0x0d))
X    ++s;
X
X    if (*s == 0x0d)
X    *s = 0;
X
X/* Set up global parameters and expand */
X
X    __argc = 0;
X
X/* Get the program name */
X
X    if (_osmajor <= 2)
X    s = "unknown";
X
X/* In the case of DOS 3+, we look in the environment space */
X
X    else
X    {
X    s = (char far *)(((long)envs) << 16);
X
X    while (*s)
X    {
X        while (*(s++) != 0);
X    }
X
X    s += 3;
X    }
X
X    _pgmptr = s;
X
X#ifndef M_I86LM
X    cp = buf;
X    while (*(cp++) = *(s++));
X
X    ex_add_arg (ex_tounix (buf));    /* Add the program name        */
X
X    s  = argvp;
X    cp = buf;
X    while (*(cp++) = *(s++));
X
X    exp_line (buf);
X#else
X    ex_add_arg (ex_tounix (s));        /* Add the program name        */
X    exp_line (argvp);
X#endif
X
X    ex_add_arg ((char *)NULL);
X    --__argc;
X}
X
X/*
X * Expand a line
X */
X
Xstatic void    exp_line (argvp)
Xchar        *argvp;            /* Line to expand            */
X{
X    char    *spos;            /* End of string pointer    */
X    char    *cpos;            /* Start of string pointer    */
X    char    *fn;            /* Extracted file name string    */
X
X/* Search for next separator */
X
X    spos = argvp;
X
X    while (*(cpos = ex_skip_sp (spos)))
X    {
X
X/* Extract string argument */
X
X    if ((*cpos == '"') || (*cpos == '\''))
X    {
X        spos = cpos + 1;
X
X        do
X        {
X        if ((spos = strchr (spos, *cpos)) != NULL)
X        {
X            spos++;
X            if (spos[-2] != '\\')
X            break;
X        }
X
X        else
X            spos = &spos[strlen (cpos)];
X
X        }
X        while (*spos);
X
X        fn    = ex_gspace (spos - cpos - 2, cpos + 1);
X    }
X
X/* Extract normal argument */
X
X    else
X    {
X        spos = cpos;
X        while (!isspace(*spos) && *spos)
X        spos++;
X
X        fn = ex_gspace (spos - cpos, cpos);
X    }
X
X/* Process argument */
X
X    if (*cpos != '"')
X        fn = ex_environment (fn);
X
X    switch (*cpos)
X    {
X        case '@':        /* Expand file                    */
X        ex_pfile (fn);
X        break;
X
X        case '"':        /* Expand string                */
X        case '\'':
X        ex_add_arg (fn);
X        break;
X
X        default:        /* Expand field                    */
X        if (!ex_find (fn, 0))
X            ex_add_arg (fn);
X    }
X
X    free (fn);
X    }
X}
X
X/* Expand a field if it has metacharacters in it */
X
Xstatic int    ex_pfield (prefix, postfix)
Xchar        *prefix;        /* Prefix field                */
Xchar        *postfix;        /* Postfix field            */
X{
X    int          count;        /* File path length        */
X    int         f_count = 0;    /* Number of files generated    */
X    int            slash_flag = 0;    /* slash required        */
X    char        fn[PATH_MAX + NAME_MAX + 2];/* Search file name */
X    char        *name;        /* Match string            */
X    char        *p, *p1;
X    DIR            *dp;
X    struct dirent    *c_de;
X    unsigned int    c_drive;    /* Current drive        */
X    unsigned int    m_drive;    /* Max drive            */
X    unsigned int    s_drive;    /* Selected drive        */
X    unsigned int    x_drive, y_drive;    /* Dummies        */
X    char        *multi;        /* Multi-drive flag        */
X    char        t_drive[2];
X
X/* Convert file name to lower case */
X
X    strlwr (prefix);
X
X/* Search all drives ? */
X
X    if ((multi = _ex_multi_drive (prefix)) != (char *)NULL)
X    {
X    _dos_getdrive (&c_drive);    /* Get number of drives        */
X    _dos_setdrive (c_drive, &m_drive);
X    t_drive[1] = 0;
X
X    for (s_drive = 1; s_drive <= m_drive; ++s_drive)
X    {
X        _dos_setdrive (s_drive, &x_drive);
X        _dos_getdrive (&y_drive);
X        _dos_setdrive (c_drive, &x_drive);
X
X/* Check to see if the second diskette drive is really there */
X
X        if (((_bios_equiplist () & 0x00c0) == 0x0000) && (s_drive == 2))
X        continue;
X
X/* If the drive exists and is in our list - process it */
X
X        *multi = 0;
X        *t_drive = (char)(s_drive + 'a' - 1);
X
X        if ((y_drive == s_drive) && pnmatch (t_drive, prefix, 0))
X        {
X        *multi = ':';
X        *fn = *t_drive;
X        strcpy (fn + 1, multi);
X        f_count += ex_pfield (fn, postfix);
X        }
X
X        *multi = ':';
X    }
X
X    return f_count;
X    }
X
X/* Get the path length */
X
X    p = strrchr (prefix, '/');
X    p1 = strchr (prefix, ':');
X
X    if ((p1 == (char *)NULL) || (p1 < p))
X    {
X    if (p == (char *)NULL)
X    {
X        count = 0;
X        name = prefix;
X    }
X
X    else
X    {
X        count = p - prefix;
X        name = p + 1;
X    }
X    }
X
X    else if ((p == (char *)NULL) || (p < p1))
X    {
X    count = p1 - prefix;
X    name = p1 + 1;
X    }
X
X/* Set up file name for search */
X
X    if (((count == 2) && (strncmp (prefix + 1, ":/", 2) == 0)) ||
X    ((count == 0) && (*prefix == '/')))
X    {
X    strncpy (fn, prefix, ++count);
X    fn[count] = 0;
X    strcat (fn, ".");
X    }
X
X    else
X    {
X    if ((count == 1) && (*(prefix + 1) == ':'))
X        count++;
X
X    strncpy (fn, prefix, count);
X    fn[count] = 0;
X
X    if (((count == 2) && (*(prefix + 1) == ':')) || (count == 0))
X        strcat (fn, ".");
X
X    else
X        slash_flag = 1;
X    }
X
X/* Search for file names */
X
X    if ((dp = opendir (fn)) == (DIR *)NULL)
X    return 0;
X
X/* Are there any matches */
X
X    while ((c_de = readdir (dp)) != (struct dirent *)NULL)
X    {
X    if ((*c_de->d_name == '.') && (*name != '.'))
X        continue;
X
X/* Check for match */
X
X    if (pnmatch (c_de->d_name, name, 0))
X    {
X        fn[count] = 0;
X
X        if (slash_flag)
X        strcat (fn, "/");
X
X        strcat (fn, c_de->d_name);
X
X/* If the postfix is not null, this must be a directory */
X
X        if (postfix != (char *)NULL)
X        {
X        struct stat        statb;
X
X        if (stat (fn, &statb) < 0 ||
X            (statb.st_mode & S_IFMT) != S_IFDIR)
X            continue;
X
X        strcat (fn, "/");
X        strcat (fn, postfix);
X        }
X
X        f_count += ex_find (fn, 1);
X    }
X    }
X
X    closedir (dp);
X    return f_count;
X}
X
X/* Expand file name */
X
Xstatic void    ex_pfile (file)
Xchar        *file;        /* Expand file name                */
X{
X    FILE        *fp;        /* File descriptor                */
X    char    *p;        /* Pointer                */
X    int        c_maxlen = MAX_LINE;
X    char    *line;        /* Line buffer                    */
X
X/* Grab some memory for the line */
X
X    if ((line = malloc (c_maxlen)) == (char *)NULL)
X    ex_fatal (ENOMEM, ex_nomem, (char *)NULL);
X
X/* If file open fails, expand as a field */
X
X    if ((fp = fopen (file + 1, "rt")) == NULL)
X    {
X    if (!ex_find (file, 0))
X        ex_add_arg (file);
X
X    return;
X    }
X
X/* For each line in the file, remove EOF characters and add argument */
X
X    while (fgets (line, c_maxlen, fp) != (char *)NULL)
X    {
X    while ((p = strchr (line, '\n')) == (char *)NULL)
X    {
X        if ((p = strchr (line, 0x1a)) != (char *)NULL)
X        break;
X
X        if ((line = realloc (line, c_maxlen + MAX_LINE)) == (char *)NULL)
X        ex_fatal (ENOMEM, ex_nomem, (char *)NULL);
X
X        if (fgets (&line[c_maxlen - 1], MAX_LINE, fp) == (char *)NULL)
X        break;
X
X        c_maxlen += MAX_LINE - 1;
X    }
X
X    if (p != (char *)NULL)
X        *p = 0;
X
X    ex_add_arg (line);
X    }
X
X    if (ferror(fp))
X    ex_fatal (errno, "%s: %s (%s)\n", file + 1);
X
X    free (line);
X    fclose (fp);
X}
X
X/* Get space for name */
X
Xstatic char    *ex_gspace (l, in_s)
Xint        l;            /* String length                */
Xchar        *in_s;                  /* String address        */
X{
X    char    *out_s;            /* Malloced space address       */
X
X    if ((out_s = malloc (l + 1)) == (char *)NULL)
X    ex_fatal (ENOMEM, ex_nomem, (char *)NULL);
X
X/* Copy string for specified length */
X
X    strncpy (out_s, in_s, l);
X    out_s[l] = 0;
X
X    return (out_s);
X}
X
X/* Append an argument to the string */
X
Xstatic void    ex_add_arg (fn)
Xchar        *fn;            /* Argument to add        */
X{
X    if (__argc == 0)
X    __argv = (char **)malloc (50 * S_ENTRY);
X
X    else if ((__argc % 50) == 0)
X    __argv = (char **)realloc (__argv, (__argc + 50) * S_ENTRY);
X
X    if (__argv == (char **)NULL)
X    ex_fatal (ENOMEM, ex_nomem, (char *)NULL);
X
X    __argv[__argc++] = (fn == (char *)NULL) ? fn : ex_gspace (strlen (fn), fn);
X}
X
X/*  Skip over spaces */
X
Xstatic char    *ex_skip_sp (a)
Xchar        *a;            /* String start address        */
X{
X    while (isspace(*a))
X        a++;
X
X    return (a);
X}
X
X/* Convert name to Unix format */
X
Xstatic char    *ex_tounix (a)
Xchar        *a;
X{
X    char    *sp = a;
X
X    while ((a = strchr (a, '\\')) != (char *)NULL)
X    *(a++) = '/';
X
X    return strlwr (sp);
X}
X
X/* Find the location of meta-characters.  If no meta, add the argument and
X * return NULL.  If meta characters, return position of end of directory
X * name.  If not multiple directories, return -1
X */
X
Xstatic int    ex_find (file, must_exist)
Xchar        *file;
Xint        must_exist;        /* FIle must exist flag        */
X{
X    char    *p;
X    int        i;
X    static char    ex_meta[] = "?*[]\\";    /* Metacharacters        */
X
X    if ((p = strpbrk (file, ex_meta)) == (char *)NULL)
X    {
X    if (must_exist && (access (file, 0) < 0))
X        return 0;
X
X    ex_add_arg (file);
X    return 1;
X    }
X
X    else if ((p = strchr (p, '/')) != (char *)NULL)
X    *(p++) = 0;
X
X    i = ex_pfield (file, p);
X
X    if (p != (char *)NULL)
X       *(--p) = '/';
X
X    return i;
X}
X
X/* Fatal errors */
X
Xstatic void    ex_fatal (ecode, format, para)
Xint        ecode;
Xchar        *format;
Xchar        *para;
X{
X    fprintf (stderr, format, "stdargv", strerror (ecode), para);
X    exit (1);
X}
X
X/* Process Environment - note that field is a malloc'ed field */
X
Xstatic char    *ex_environment (field)
Xchar        *field;
X{
X    char    *sp, *cp, *np, *ep;
X    char    save;
X    int        b_flag;
X
X    sp = field;
X
X/* Replace any $ strings */
X
X    while ((sp = strchr (sp, '$')) != (char *)NULL)
X    {
X    if (*(cp = ++sp) == '{')
X    {
X        b_flag = 1;
X        ++cp;
X
X        while (*cp && (*cp != '}'))
X        cp++;
X    }
X
X    else
X    {
X        b_flag;
X
X        while (isalnum(*cp))
X        cp++;
X    }
X
X/* Grab the environment variable */
X
X    if (cp == sp)
X        continue;
X
X    save = *cp;
X    *cp = 0;
X    ep = getenv (sp + b_flag);
X    *cp = save;
X
X    if (ep != (char *)NULL)
X    {
X        np = ex_gspace (strlen(field) - (cp - sp) + strlen (ep) - 1, field);
X        strcpy (&np[sp - field - 1], ep);
X        ex_tounix (&np[sp - field - 1]);
X        free (field);
X        strcpy ((sp = &np[strlen(np)]), cp + b_flag);
X        field = np;
X    }
X    }
X
X    return field;
X}
X
X/* Check for multi_drive prefix */
X
Xstatic char    *_ex_multi_drive (prefix)
Xchar        *prefix;
X{
X    if (strlen (prefix) < 2)
X    return (char *)NULL;
X
X    if (((*prefix == '*') || (*prefix == '?')) && (prefix[1] == ':'))
X    return prefix + 1;
X
X    if (*prefix != '[')
X    return (char *)NULL;
X
X    while (*prefix && (*prefix != ']'))
X    {
X    if ((*prefix == '\\') && (*(prefix + 1)))
X        ++prefix;
X
X    ++prefix;
X    }
X
X    return (*prefix && (*(prefix + 1) == ':')) ? prefix + 1 : (char *)NULL;
X}
X#endif
SHAR_EOF
chmod 0644 lib/stdargv.c || echo "restore of lib/stdargv.c fails"
set `wc -c lib/stdargv.c`;Sum=$1
if test "$Sum" != "12922"
then echo original size 12922, current size $Sum;fi
echo "x - extracting lib/pnmatch.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lib/pnmatch.c &&
X#include <stdlib.h>
X
X/* File name pattern matching function */
X
Xint    pnmatch (string, pattern, flag)
Xchar    *string;            /* String to match                  */
Xchar    *pattern;            /* Pattern to match against         */
Xint    flag;                /* Match using '$' & '^'            */
X{
X    register int    cur_s;        /* Current string character         */
X    register int    cur_p;        /* Current pattern character        */
X
X/* Match $ and ^ ? */
X
X    if (flag == 1)
X    {
X    while (*string)
X    {
X        if (pnmatch (string++, pattern, ++flag))
X        return 1;
X    }
X
X    return 0;
X    }
X
X/* Match string */
X
X    while (cur_p = *(pattern++))
X    {
X    cur_s = *(string++);        /* Load current string character    */
X
X        switch (cur_p)            /* Switch on pattern character      */
X        {
X            case '^':            /* Match start of string            */
X            {
X                if (flag == 2)
X                    string--;
X
X                else if ((flag) || (cur_p != cur_s))
X            return 0;
X
X                break;
X            }
X
X            case '$':            /* Match end of string              */
X            {
X                if (!flag)
X                {
X                    if (cur_p != cur_s)
X            return 0;
X
X                    break;
X                }
X
X                else
X            return ((cur_s) ? 0 : 1);
X            }
X
X            case '[':            /* Match class of characters        */
X            {
X                while(1)
X                {
X                    if (!(cur_p = *(pattern++)))
X            return 0;
X
X                    if (cur_p == ']')
X            return 0;
X
X                    if (cur_s != cur_p)
X                    {
X                        if (*pattern == '-')
X                        {
X                            if(cur_p > cur_s)
X                                continue;
X
X                            if (cur_s > *(++pattern))
X                                continue;
X                        }
X                        else
X                            continue;
X                    }
X
X                    break;
X                }
X
X                while (*pattern)
X                {
X                    if (*(pattern++) == ']')
X                        break;
X                }
X            }
X
X            case '?':            /* Match any character              */
X            {
X                if (!cur_s)
X            return 0;
X
X                break;
X            }
X
X            case '*':            /* Match any number of any character*/
X            {
X                string--;
X
X                do
X                {
X                    if (pnmatch (string, pattern, 0))
X            return 1;
X                }
X                while (*(string++));
X
X        return 0;
X            }
X
X            case '\\':            /* Next character is non-meta       */
X            {
X                if (!(cur_p = *(pattern++)))
X            return 0;
X            }
X
X            default:            /* Match against current pattern    */
X            {
X                if (cur_p != cur_s)
X            return 0;
X
X                break;
X            }
X        }
X    }
X
X    return ((flag || (!(*string))) ? 1 : 0);
X}
SHAR_EOF
chmod 0644 lib/pnmatch.c || echo "restore of lib/pnmatch.c fails"
set `wc -c lib/pnmatch.c`;Sum=$1
if test "$Sum" != "2985"
then echo original size 2985, current size $Sum;fi
echo "x - extracting lib/getopt.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lib/getopt.c &&
X/*
X *  MODULE NAME:   getopt.c                Revision 1.0
X *
X *  AUTHOR:        I. Stewartson
X *                 Data Logic Ltd.,
X *                 Queens House,
X *                 Greenhill Way,
X *                 Harrow,
X *                 Middlesex HA1 1YR.
X *                 Telephone: London [phone]
X *
X#include <logo.h>
X *  MODULE DESCRIPTION: This function is based on the UNIX library function.
X *            getopt return the next option letter in argv that
X *            matches a letter in opstring.  optstring is a string
X *            of recognised option letters; if a letter is followed
X *            by a colon, the option is expected to have an argument
X *            that may or may not be separated from it by white
X *            space.  optarg is set to point to the start of the
X *            option argument on return from getopt.
X *
X *            getopt places in optind the argv index of the next
X *            argument to be processed.  Because optind is external,
X *            it is normally initialised to zero automatically before
X *            the first call to getopt.
X *
X *            When all options have been processed (i.e. up to the
X *            first non-option argument), getopt returns EOF.  The
X *            special option -- may be used to delimit the end of
X *            the options; EOF will be returned, and -- will be
X *            skipped.
X *
X *            getopt prints an error message on stderr and returns a
X *            question mark (?) when it encounters an option letter
X *            not included in optstring.  This error message may be
X *            disabled by setting opterr to a non-zero value.
X *
X *  CALLING SEQUENCE:    The following calling sequences are used:
X *
X *            int    getopt(argc, argv, optstring)
X *            int    argc;
X *            char    **argv;
X *            char    *optstring;
X *
X *  ERROR MESSAGES:
X *            %s: illegal option -- %c
X *            %s: option requires an argument -- %c
X *
X *  INCLUDE FILES:
X */
X
X#include <stdio.h>            /* Standard Input/Output    */
X#include <string.h>            /* String function declarations    */
X#include <stdlib.h>            /* Standard library declarations*/
X
X/*
X *  DATA DECLARATIONS:
X */
X
Xint        opterr = 0;
Xint        optind = 1;
Xint        optopt;
Xint        optvar = 0;
Xchar        *optarg;
X
Xstatic char    *errmes1 = "%s: illegal option -- %c\n";
Xstatic char    *errmes2 = "%s: option requires an argument -- %c\n";
X
X/*
X *  MODULE ABSTRACT:
X *
X *  EXECUTABLE CODE:
X */
X
Xint    getopt(argc, argv, optstring)
Xint    argc;                /* Argument count        */
Xchar    **argv;                /* Argument string vector    */
Xchar    *optstring;            /* Valid options        */
X{
X    static int    string_off = 1;        /* Current position        */
X    int        cur_option;        /* Current option        */
X    char    *cp;            /* Character pointer        */
X
X    if (string_off == 1)
X    {
X    if ((optind >= argc) || (argv[optind][0] != '-') || (!argv[optind][1]))
X        return (EOF);
X
X    else if (!strcmp(argv[optind], "--"))
X    {
X        optind++;
X        return (EOF);
X    }
X    }
X
X/* Get the current character from the current argument vector */
X
X    optopt = cur_option = argv[optind][string_off];
X
X/* Validate it */
X
X    if ((cur_option == ':') || ((cur_option == '*') && optvar) ||
X    ((cp = strchr(optstring, cur_option)) == (char *)NULL))
X    {
X    if (opterr)
X        fprintf(stderr, errmes1, cur_option, argv[0]);
X
X    if (!argv[optind][++string_off])
X    {
X        optind++;
X        string_off = 1;
X    }
X
X    return ('?');
X    }
X
X/* Parameters following ? */
X
X    if (*(++cp) == ':')
X    {
X    if (argv[optind][string_off + 1])
X        optarg = &argv[optind++][string_off + 1];
X
X    else if (++optind >= argc)
X    {
X        if (opterr)
X        fprintf(stderr, errmes2, cur_option, argv[0]);
X
X        string_off = 1;
X        return ('?');
X    }
X
X    else
X        optarg = argv[optind++];
X
X    string_off = 1;
X    }
X
X    else if ((*cp == '*') && optvar)
X    {
X    if (argv[optind][string_off + 1] != 0)
X        optarg = &argv[optind++][string_off + 1];
X    else
X    {
X        optarg = "";
X        optind++;
X        string_off = 1;
X    }
X    }
X
X    else
X    {
X    if (!argv[optind][++string_off])
X    {
X        string_off = 1;
X        optind++;
X    }
X
X    optarg = (char *)NULL;
X    }
X
X    return (cur_option);
X}
SHAR_EOF
chmod 0644 lib/getopt.c || echo "restore of lib/getopt.c fails"
set `wc -c lib/getopt.c`;Sum=$1
if test "$Sum" != "3853"
then echo original size 3853, current size $Sum;fi
echo "x - extracting scripts/l (Text)"
sed 's/^X//' << 'SHAR_EOF' > scripts/l &&
X#!sh
Xls -C $*
SHAR_EOF
chmod 0644 scripts/l || echo "restore of scripts/l fails"
set `wc -c scripts/l`;Sum=$1
if test "$Sum" != "14"
then echo original size 14, current size $Sum;fi
echo "x - extracting scripts/extend.lst (Text)"
sed 's/^X//' << 'SHAR_EOF' > scripts/extend.lst &&
XLIB.EXE
XLINK.EXE
Xsh.exe
SHAR_EOF
chmod 0644 scripts/extend.lst || echo "restore of scripts/extend.lst fails"
set `wc -c scripts/extend.lst`;Sum=$1
if test "$Sum" != "24"
then echo original size 24, current size $Sum;fi
echo "x - extracting scripts/profile.sh (Text)"
sed 's/^X//' << 'SHAR_EOF' > scripts/profile.sh &&
X#!sh
XPATH=".;..;c:/oracle5/bin;c:/bin;c:/dos;c:/scm;c:/windows"
XCDPATH=".;..;/;c:/;c:/windows;c:/scm;c:/ian"
XINCLUDE=c:/include
XLIB=c:/lib
XTMP=c:/tmp
XTZ=GMT0BST
XEDITOR=vi
XPS1="s0H[%p] %d %tu%n %e> "
XHOME=c:/
XTERM=ibmpc-mono
XCL="-AL -Zid -W3"
XINIT=c:/bin/me_ini
XEXTENDED_LINE=c:/bin/extend.lst
XEXINIT="set aw ai sm dm sw=4 wm=5"
X
Xmsdos LIB TMP
SHAR_EOF
chmod 0644 scripts/profile.sh || echo "restore of scripts/profile.sh fails"
set `wc -c scripts/profile.sh`;Sum=$1
if test "$Sum" != "366"
then echo original size 366, current size $Sum;fi
echo "x - extracting shell/Makefile (Text)"
sed 's/^X//' << 'SHAR_EOF' > shell/Makefile &&
X#
X# MS-DOS SHELL - Makefile
X#
X# MS-DOS SHELL - Copyright (c) 1989 Data Logic Limited.
X#
X# Redistribution and use in source and binary forms are permitted
X# provided that the above copyright notice is duplicated in the
X# source form.
X#
X#
X#    $Header$
X#
X#    $Log$
X#
X
XOBJS=sh0.obj sh1.obj sh2.obj sh3.obj sh4.obj sh5.obj sh6.obj    \
X     sh7.obj sh8.obj sh9.obj sh10.obj
XASFLAGS= /Ml /Zi /Zd
X
Xsh.exe:    $(OBJS)
X    link sh0+sh1+sh2+sh3+sh4+sh5+sh6+sh7+sh8+sh9+sh10/noi, sh.exe;
SHAR_EOF
chmod 0644 shell/Makefile || echo "restore of shell/Makefile fails"
set `wc -c shell/Makefile`;Sum=$1
if test "$Sum" != "470"
then echo original size 470, current size $Sum;fi
echo "x - extracting shell/sh1.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > shell/sh1.c &&
X/* MS-DOS SHELL - Main program, memory and variable management
X *
X * MS-DOS SHELL - Copyright (c) 1990 Data Logic Limited and Charles Forsyth
X *
X * This code is based on (in part) the shell program written by Charles
X * Forsyth and is subject to the following copyright restrictions:
X *
X * 1.  Redistribution and use in source and binary forms are permitted
X *     provided that the above copyright notice is duplicated in the
X *     source form and the copyright notice in file sh6.c is displayed
X *     on entry to the program.
X *
X * 2.  The sources (or parts thereof) or objects generated from the sources
X *     (or parts of sources) cannot be sold under any circumstances.
X *
X *    $Header: sh1.c 1.1 90/01/25 13:40:39 MS_user Exp $
X *
X *    $Log:    sh1.c $
X * Revision 1.1  90/01/25  13:40:39  MS_user
X * Initial revision
X *
X */
X
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <stdio.h>
X#include <stdlib.h>
X#include <signal.h>
X#include <errno.h>
X#include <setjmp.h>
X#include <stdarg.h>
X#include <string.h>
X#include <unistd.h>
X#include <ctype.h>
X#include <fcntl.h>
X#include <limits.h>
X#include <dos.h>
X#include <time.h>
X#include "sh.h"
X
X/*
X * Structure of Malloced space to allow release of space nolonger required
X * without having to know about it.
X */
X
Xtypedef struct region {
X    struct region    *next;
X    int            area;
X} s_region;
X
Xstatic struct region    *areastart = (s_region *)NULL;
X
X/*
X * default shell, search rules
X */
X
Xstatic char    *shellname = "c:/bin/sh";
Xstatic char    *search    = ";c:/bin;c:/usr/bin";
Xstatic char    *ymail     = "You have mail\n";
Xstatic char    *Path       = "PATH";
X#ifdef SIGQUIT
Xstatic void    (*qflag)() = SIG_IGN;
X#endif
X
X/* Functions */
X
Xstatic char    *cclass (char *, int, bool);
Xstatic char    *copy_to_equals (char *, char *);
Xstatic void    nameval (Var_List *, char *, char *, bool);
Xstatic void    patch_up (void);
Xstatic void    onecommand (void);
Xstatic void    Check_Mail (void);
Xstatic void    Pre_Process_Argv (char **);
Xstatic void    Load_G_VL (void);
X
X/*
X * The main program starts here
X */
X
Xvoid        main (argc, argv)
Xint        argc;
Xregister char    **argv;
X{
X    register int    f;
X    register char    *s, *s1;
X    int            cflag = 0;
X    int            sc;
X    char        *name, **ap;
X    int            (*iof)(IO_State *) = filechar;
X    Var_List        *lset;
X    bool        l_rflag = FALSE;
X
X/* Patch up various parts of the system */
X
X    patch_up ();
X
X/* Load the environment into our structures */
X
X    if ((ap = environ) != (char **)NULL)
X    {
X    while (*ap)
X        assign (*ap++, !COPYV);
X
X    for (ap = environ; *ap;)
X        s_vstatus (lookup (*ap++, TRUE), EXPORT);
X    }
X
X/* Zap all files */
X
X    closeall ();
X    areanum = 1;
X
X/* Get the current directory */
X
X    Getcwd ();
X
X/* Set up some stardard variables if their not set */
X
X    if ((lset = lookup (shell, TRUE))->value == null)
X    setval (lset, shellname);
X
X    s_vstatus (lset, EXPORT);
X
X/* Check for restricted shell */
X
X    if ((s = strrchr (lset->value, '/')) == (char *)NULL)
X    s = lset->value;
X
X    else
X    s++;
X
X    if (*s == 'r')
X    l_rflag = TRUE;
X
X/* Set up home directory */
X
X    if ((lset = lookup (home, TRUE))->value == null)
X    setval (lset, "c:/");
X
X    s_vstatus (lset, EXPORT);
X
X/* Set up history file location */
X
X    setval (lookup ("$", TRUE), putn (getpid ()));
X
X    Load_G_VL ();
X    path->status |= (EXPORT | PONLY);
X    ifs->status  |= (EXPORT | PONLY);
X    ps1->status  |= (EXPORT | PONLY);
X    ps2->status  |= (EXPORT | PONLY);
X
X    if (path->value == null)
X    setval (path, search);
X
X    if (ifs->value == null)
X    setval (ifs, " \t\n");
X
X    if (ps1->value == null)
X    setval (ps1, "$ ");
X
X    if (ps2->value == null)
X    setval (ps2, "> ");
X
X/* Check the restricted shell */
X
X    if ((s = strrchr ((name = *argv), '/')) == (char *)NULL)
X    s = name;
X
X    if ((s1 = strchr (s, '.')) != (char *)NULL)
X    *s1 = 0;
X
X    if (strcmp (s, "rsh") == 0)
X    l_rflag = TRUE;
X
X    if (s1 != (char *)NULL)
X    *s1 = '.';
X
X/* Preprocess options to convert two character options of the form /x to
X * -x.  Some programs!!
X */
X
X     Pre_Process_Argv (argv);
X
X/* Process the options */
X
X    while ((sc = getopt (argc, argv, "abc:defghijklmnopqrtsuvwxyz0")) != EOF)
X    {
X    switch (sc)
X    {
X        case '0':                /* Level 0 flag for DOS    */
X        level0 = TRUE;
X        break;
X
X        case 'r':                /* Restricted        */
X        l_rflag = TRUE;
X        break;
X
X        case 'c':                /* Command on line    */
X        ps1->status &= ~EXPORT;
X        ps2->status &= ~EXPORT;
X        setval (ps1, null);
X        setval (ps2, null);
X        cflag = 1;
X
X        PUSHIO (aword, optarg, iof = nlchar);
X        break;
X
X        case 'q':                /* No quit ints        */
X#ifdef SIGQUIT
X        qflag = SIG_DFL;
X#endif
X        break;
X
X        case 's':                /* standard input    */
X        break;
X
X        case 't':                /* One command        */
X        ps1->status &= ~EXPORT;
X        setval (ps1, null);
X        iof = linechar;
X        break;
X
X        case 'i':                /* Set interactive    */
X        talking++;
X
X        default:
X        if (islower (sc))
X            FL_SET (sc);
X    }
X    }
X
X    argv += optind;
X    argc -= optind;
X
X/* Execute one off command - disable prompts */
X
X    if ((iof == filechar) && (argc > 0))
X    {
X    setval (ps1, null);
X    setval (ps2, null);
X    ps1->status &= ~EXPORT;
X    ps2->status &= ~EXPORT;
X
X    f = 0;
X
X/* Open the file if necessary */
X
X    if (strcmp ((name = *argv), "-") != 0)
X    {
X        if ((f = O_for_execute (name)) < 0)
X        {
X        print_error ("%s: cannot open\n", name);
X        exit (1);
X        }
X    }
X
X    next (remap (f));        /* Load into I/O stack    */
X    }
X
X/* Set up the $- variable */
X
X    setdash ();
X
X/* Load terminal I/O structure if necessary and load the history file */
X
X    if (e.iop < iostack)
X    {
X    PUSHIO (afile, 0, iof);
X
X    if (isatty (0) && isatty (1) && !cflag)
X    {
X        fprintf (stderr, Copy_Right1, _osmajor, _osminor);
X        fputs (Copy_Right2, stderr);
X
X        talking++;
X        History_Enabled = TRUE;
X        Load_History ();
X    }
X    }
X
X#ifdef SIGQUIT
X    signal (SIGQUIT, qflag);
X#endif
X
X/* Read profile ? */
X
X    if (((name != (char *)NULL) && (*name == '-')) || level0)
X    {
X    talking++;
X
X    if ((f = O_for_execute ("/etc/profile")) >= 0)
X        next (remap(f));
X
X    if ((f = O_for_execute ("profile")) >= 0)
X        next (remap(f));
X    }
X
X/* Set up signals */
X
X    if (talking)
X    signal (SIGTERM, sig);
X
X    if (signal (SIGINT, SIG_IGN) != SIG_IGN)
X    signal (SIGINT, onintr);
X
X/* Load any parameters */
X
X    dolv = argv;
X    dolc = argc;
X    dolv[0] = name;
X
X    if (dolc > 1)
X    {
X    for (ap = ++argv; --argc > 0;)
X    {
X        if (assign (*ap = *argv++, !COPYV))
X        dolc--;                    /* keyword */
X
X        else
X        ap++;
X    }
X    }
X
X    setval (lookup ("#", TRUE), putn ((--dolc < 0) ? (dolc = 0) : dolc));
X
X/* Execute the command loop */
X
X    while (1)
X    {
X    if (talking && e.iop <= iostack)
X    {
X        Check_Mail ();
X        put_prompt (ps1->value);
X        r_flag = l_rflag;
X    }
X
X    onecommand ();
X    }
X}
X
X/*
X * Set up the value of $-
X */
X
Xvoid    setdash ()
X{
X    register char    *cp, c;
X    char        m['z' - 'a' + 1];
X
X    for (cp = m, c = 'a'; c <= 'z'; ++c)
X    {
X    if (FL_TEST (c))
X        *(cp++) = c;
X    }
X
X    *cp = 0;
X    setval (lookup ("-", TRUE), m);
X}
X
X/* Execute a command */
X
Xstatic void    onecommand ()
X{
X    register int    i;
X    jmp_buf        m1;
X    C_Op        *outtree;
X
X
X/* Exit any previous environments */
X
X    while (e.oenv)
X    quitenv ();
X
X/* initialise space */
X
X    areanum = 1;
X    freehere (areanum);
X    freearea (areanum);
X    wdlist = (Word_B *)NULL;
X    iolist = (Word_B *)NULL;
X    e.errpt = (int *)NULL;
X    e.cline = space (LINE_MAX);
X    e.eline = e.cline + LINE_MAX - 5;
X    e.linep = e.cline;
X    yynerrs = 0;
X    multiline = 0;
X    inparse = 1;
X    SW_intr = 0;
X    execflg = 0;
X
X/* Get the line and process it */
X
X    if (setjmp (failpt = m1) || ((outtree = yyparse ()) == (C_Op *)NULL) ||
X    SW_intr)
X    {
X
X/* Failed - clean up */
X
X    while (e.oenv)
X        quitenv ();
X
X    scraphere ();
X
X    if (!talking && SW_intr)
X        leave ();
X
X/* Exit */
X
X    inparse = 0;
X    SW_intr = 0;
X    return;
X    }
X
X/* Ok - reset some variables and then execute the command tree */
X
X    inparse = 0;
X    Break_List = (Break_C *)NULL;
X    Return_List = (Break_C *)NULL;
X    SShell_List = (Break_C *)NULL;
X    SW_intr = 0;
X    execflg = 0;
X
X/* Set execute function recursive level and the SubShell count to zero */
X
X    Execute_stack_depth = 0;
X
X/* Set up Redirection IO (Saved) array and SubShell Environment information */
X
X    NSave_IO_E = 0;        /* Number of entries        */
X    MSave_IO_E = 0;        /* Max Number of entries    */
X    NSubShells = 0;        /* Number of entries        */
X    MSubShells = 0;        /* Max Number of entries    */
X
X/* Save the environment information */
X
X    if (talking && e.iop <= iostack)
X    Add_History (FALSE);
X
X    if (!FL_TEST ('n'))
X    execute (outtree, NOPIPE, NOPIPE, 0);
X
X/* Make sure the I/O and environment are back at level 0 and then clear them */
X
X    Execute_stack_depth = 0;
X
X    if (NSubShells != 0)
X    Delete_G_VL ();
X
X    if (NSave_IO_E)
X    restore_std (0);
X
X    if (MSubShells)
X    DELETE (SubShells);
X
X    if (MSave_IO_E)
X    DELETE (SSave_IO);
X
X/* Check for interrupts */
X
X    if (!talking && SW_intr)
X    {
X    execflg = 0;
X    leave ();
X    }
X
X/* Run any traps that are required */
X
X    if ((i = trapset) != 0)
X    {
X    trapset = 0;
X    runtrap (i);
X    }
X}
X
X/*
X * Terminate current environment with an error
X */
X
Xvoid    fail ()
X{
X    longjmp (failpt, 1);
X
X    /* NOTREACHED */
X}
X
X/*
X * Exit the shell
X */
X
Xvoid    leave ()
X{
X    if (execflg)
X    fail ();
X
X/* Clean up */
X
X    scraphere ();
X    freehere (1);
X
X/* Trap zero on exit */
X
X    runtrap (0);
X
X/* Dump history on exit */
X
X    if (talking && isatty(0))
X    Dump_History ();
X
X    closeall ();
X    exit (exstat);
X
X/* NOTREACHED */
X}
X
X/*
X * Output warning message
X */
X
Xvoid    print_warn (fmt)
Xchar    *fmt;
X{
X    va_list    ap;
X    char    x[100];
X
X    va_start (ap, fmt);
X    vsprintf (x, fmt, ap);
X    S_puts (x);
X    exstat = -1;
X
X/* If leave on error - exit */
X
X    if (FL_TEST ('e'))
X    leave ();
X
X    va_end (ap);
X}
X
X/*
X * Output error message
X */
X
Xvoid    print_error (fmt)
Xchar    *fmt;
X{
X    va_list    ap;
X    char    x[100];
X
X/* Error message processing */
X
X    va_start (ap, fmt);
X    vsprintf (x, fmt, ap);
X    S_puts (x);
X    exstat = -1;
X
X    if (FL_TEST ('e'))
X    leave ();
X
X    va_end (ap);
X
X/* Error processing */
X
X    if (FL_TEST ('n'))
X    return;
X
X/* If not interactive - exit */
X
X    if (!talking)
X    leave ();
X
X    if (e.errpt)
X    longjmp (e.errpt, 1);
X
X/* closeall (); Removed - caused problems.  There may be problems
X * remaining with files left open?
X */
X
X    e.iop = e.iobase = iostack;
X}
X
X/*
X * Create or delete a new environment.  If f is set, delete the environment
X */
X
Xbool    newenv (f)
Xint    f;
X{
X    register Environ    *ep;
X
X/* Delete environment? */
X
X    if (f)
X    {
X    quitenv ();
X    return TRUE;
X    }
X
X/* Create a new environment */
X
X    if ((ep = (Environ *) space (sizeof (Environ))) == (Environ *)NULL)
X    {
X    while (e.oenv)
X        quitenv ();
X
X    fail ();
X    }
X
X    *ep = e;
X    e.oenv = ep;
X    e.errpt = errpt;
X    return FALSE;
X}
X
X/*
X * Exit the current environment successfully
X */
X
Xvoid    quitenv ()
X{
X    register Environ    *ep;
X    register int    fd;
X
X/* Restore old environment, delete the space and close any files opened in
X * this environment
X */
X
X    if ((ep = e.oenv) != (Environ *)NULL)
X    {
X    fd = e.iofd;
X    e = *ep;
X
X    DELETE (ep);
X
X    while (--fd >= e.iofd)
X        S_close (fd, TRUE);
X    }
X}
X
X/*
X * Is character c in s?
X */
X
Xbool        any (c, s)
Xregister char    c;
Xregister char    *s;
X{
X    while (*s)
X    {
X    if (*(s++) == c)
X        return TRUE;
X    }
X
X    return FALSE;
X}
X
X/*
X * Convert binary to ascii
X */
X
Xchar        *putn (n)
Xregister int    n;
X{
X    static char        nt[10];
X
X    sprintf (nt, "%u", n);
X    return nt;
X}
X
X/*
X * Add a file to the input stack
X */
X
Xvoid    next (f)
Xint    f;
X{
X    PUSHIO (afile, f, filechar);
X}
X
X/*
X * SIGINT interrupt processing
X */
X
Xvoid    onintr (signo)
Xint    signo;
X{
X
X/* Restore signal processing and set SIGINT detected flag */
X
X    signal (SIGINT, onintr);
X    SW_intr = 1;
X
X/* Are we talking to the user?  Yes - check in parser */
X
X    if (talking)
X    {
X    if (inparse)
X    {
X        S_putc (NL);
X        fail ();
X    }
X    }
X
X/* No - exit */
X
X    else
X    {
X    execflg = 0;
X    leave ();
X    }
X}
X
X/*
X * Grap some space and check for an error
X */
X
Xchar    *space (n)
Xint    n;
X{
X    register char *cp;
X
X    if ((cp = getcell (n)) == (char *)NULL)
X    print_error ("sh: out of string space\n");
X
X    return cp;
X}
X
X/*
X * Save a string in a given area
X */
X
Xchar        *strsave (s, a)
Xregister char    *s;
X{
X    register char    *cp;
X
X    if ((cp = space (strlen (s) + 1)) != (char *)NULL)
X    {
X    setarea ((char *)cp, a);
X    return strcpy (cp, s);
X    }
X
X    return null;
X}
X
X/*
X * trap handling - Save signal number and restore signal processing
X */
X
Xvoid        sig (i)
Xregister int    i;
X{
X    trapset = i;
X    signal (i, sig);
X}
X
X/*
X * Execute a trap command
X */
X
Xvoid    runtrap (i)
Xint    i;
X{
X    char    *trapstr;
X    char    tval[10];
X
X    sprintf (tval, "~%d", i);
X
X    if (((trapstr = lookup (tval, FALSE)->value)) == null)
X    return;
X
X/* If signal zero, save a copy of the trap value and then delete the trap */
X
X    if (i == 0)
X    {
X    trapstr = strsave (trapstr, areanum);
X    unset (tval, TRUE);
X    }
X
X    RUN (aword, trapstr, nlchar);
X}
X
X/*
X * Find the given name in the dictionary and return its value.  If the name was
X * not previously there, enter it now and return a null value.
X */
X
XVar_List    *lookup (n, cflag)
Xregister char    *n;
Xbool        cflag;
X{
X    register Var_List    *vp;
X    register char    *cp;
X    register int    c;
X    static Var_List    dummy;
X
X/* Set up the dummy variable */
X
X    dummy.name = n;
X    dummy.status = RONLY;
X    dummy.value = null;
X
X/* If digit string - use the dummy to return the value */
X
X    if (isdigit (*n))
X    {
X    for (c = 0; isdigit (*n) && (c < 1000); n++)
X        c = c * 10 + *n - '0';
X
X    dummy.value = (c <= dolc) ? dolv[c] : null;
X    return &dummy;
X    }
X
X/* Look up in list */
X
X    for (vp = vlist; vp != (Var_List *)NULL; vp = vp->next)
X    {
X    if (eqname (vp->name, n))
X        return vp;
X    }
X
X/* If we don't want to create it, return a dummy */
X
X    if (!cflag)
X    return &dummy;
X
X/* Create a new variable */
X
X    cp = findeq (n);
X
X    if (((vp = (Var_List *)space (sizeof (Var_List))) == (Var_List *)NULL)
X    || (vp->name = space ((int)(cp - n) + 2)) == (char *)NULL)
X    {
X    dummy.name = null;
X    return &dummy;
X    }
X
X/* Set area for space to zero - no auto-delete */
X
X    setarea ((char *)vp, 0);
X    setarea ((char *)vp->name, 0);
X
X/* Just the name upto the equals sign, no more */
X
X    copy_to_equals (vp->name, n);
X
X/* Link into list */
X
X    vp->value = null;
X    vp->next = vlist;
X    vp->status = GETCELL;
X    vlist = vp;
X    return vp;
X}
X
X/*
X * give variable at `vp' the value `val'.
X */
X
Xvoid        setval(vp, val)
XVar_List    *vp;
Xchar        *val;
X{
X    nameval (vp, val, (char *)NULL, FALSE);
X}
X
X/*
X * Copy and check that it terminates in an equals sign
X */
X
Xstatic char    *copy_to_equals (d, s)
Xchar        *d, *s;
X{
X    int        n = (int) (findeq (s) - s);
X
X    strncpy (d, s, n);
X    *(d += n) = '=';
X    *(++d) = 0;
X    return d;
X}
X
X/*
X * Set up new value for name
X *
X * If name is not NULL, it must be a prefix of the space `val', and end with
X * `='.  This is all so that exporting values is reasonably painless.
X */
X
Xstatic void        nameval (vp, val, name, disable)
Xregister Var_List    *vp;
Xchar            *val;
Xchar            *name;
Xbool            disable;
X{
X    register char    *xp;
X    int            fl = 0;
X
X/* Check if variable is read only */
X
X    if (vp->status & RONLY)
X    {
X    char    c = *(xp = findeq (vp->name));
X
X    *xp = 0;
X    S_puts (xp);
X    *xp = c;
X    print_error (" is read-only\n");
X    return;
X    }
X
X/* Check for $PATH reset in restricted shell */
X
X    if (!disable && (strcmp (vp->name, Path) == 0) && check_rsh (Path))
X    return;
X
X/* Get space for string ? */
X
X    if (name == (char *)NULL)
X    {
X    if ((xp = space (strlen (vp->name) + strlen (val) + 2)) == (char *)NULL)
X        return;
X
X/* make string:  name=value */
X
X    setarea ((char *)xp, 0);
X    name = xp;
X
X    xp = copy_to_equals (xp, vp->name);
X    strcpy (xp, val);
X    val = xp;
X    fl = GETCELL;
X    }
X
X    if (vp->status & GETCELL)
X    DELETE (vp->name);    /* form new string `name=value' */
X
X    vp->name = name;
X    vp->value = val;
X    vp->status |= fl;
X
X    if (FL_TEST ('a'))
X    s_vstatus (vp, EXPORT);
X}
X
X/*
X * Set the status of an environment variable
X */
X
Xvoid        s_vstatus (vp, flag)
XVar_List    *vp;
Xint        flag;            /* Addition status flags    */
X{
X    if (isalpha (*vp->name))        /* not an internal symbol ($# etc) */
X    vp->status |= flag;
X}
X
X/*
X * Check for assignment X=Y
X */
X
Xbool        isassign (s)
Xregister char    *s;
X{
X    if (!isalpha (*s))
X    return FALSE;
X
X    for (; *s != '='; s++)
X    {
X    if (!*s || !isalnum (*s))
X        return FALSE;
X    }
X
X    return TRUE;
X}
X
X/*
X * Execute an assignment.  If a valid assignment, load it into the variable
X * list.
X */
X
Xbool        assign (s, cf)
Xregister char    *s;
Xint        cf;
X{
X    register char    *cp;
X    Var_List        *vp;
X
X    if (!isalpha (*s))
X    return FALSE;
X
X    for (cp = s; *cp != '='; cp++)
X    {
X    if (!*cp || !isalnum (*cp))
X        return FALSE;
X    }
X
X    nameval ((vp = lookup (s, TRUE)), ++cp, (cf == COPYV ? (char *)NULL : s),
X         FALSE);
X
X    if (cf != COPYV)
X    vp->status &= ~GETCELL;
X
X    return TRUE;
X}
X
X/*
X * Compare two environment strings
X */
X
Xbool            eqname(n1, n2)
Xregister char        *n1, *n2;
X{
X    for (; *n1 != '=' && *n1 != 0; n1++)
X    {
X    if (*n2++ != *n1)
X        return FALSE;
X    }
X
X    return (!*n2 || (*n2 == '=')) ? TRUE : FALSE;
X}
X
X/*
X * Find the equals sign in a string
X */
X
Xchar        *findeq (cp)
Xregister char    *cp;
X{
X    while (*cp && (*cp != '='))
X    cp++;
X
X    return cp;
X}
X
X/*
X * Duplicate the Variable List for a Subshell
X *
X * Create a new Var_list environment for a Sub Shell
X */
X
Xint    Create_NG_VL ()
X{
X    int            i;
X    S_SubShell        *sp;
X    Var_List        *vp, *vp1;
X
X    for (sp = SubShells, i = 0; (i < NSubShells) &&
X                   (SubShells[i].depth < Execute_stack_depth);
X     i++);
X
X/* If depth is greater or equal to the Execute_stack_depth - we should panic
X * as this should not happen.  However, for the moment, I'll ignore it
X */
X
X    if (NSubShells == MSubShells)
X    {
X    sp = (S_SubShell *)space ((MSubShells + SSAVE_IO_SIZE) * sizeof (S_SubShell));
X
X/* Check for error */
X
X    if (sp == (S_SubShell *)NULL)
X    {
X        errno = ENOMEM;
X        return -1;
X    }
X
X/* Save original data */
X
X    if (MSubShells != 0)
X    {
X        memcpy (sp, SubShells, sizeof (S_SubShell) * MSubShells);
X        DELETE (SubShells);
X    }
X
X    setarea ((char *)sp, 0);
X    SubShells = sp;
X    MSubShells += SSAVE_IO_SIZE;
X    }
X
X/* Save the depth and the old vlist value */
X
X    sp = &SubShells[NSubShells++];
X    sp->depth  = Execute_stack_depth;
X    sp->header = vlist;
X    vlist = (Var_List *)NULL;
X
X/* Duplicate the old Variable list */
X
X    for (vp = sp->header; vp != (Var_List *)NULL; vp = vp->next)
X    {
X    nameval ((vp1 = lookup (vp->name, TRUE)), findeq (vp->name) + 1,
X         (char *)NULL, TRUE);
X
X    vp1->status |= (vp->status & (C_MSDOS | PONLY | EXPORT | RONLY));
X    }
X
X/* Reset global values */
X
X    Load_G_VL ();
X    return 0;
X}
X
X/*
X * Delete a SubShell environment and restore the original
X */
X
Xvoid    Delete_G_VL ()
X{
X    int        j;
X    S_SubShell    *sp;
X    Var_List    *vp;
X
X    for (j = NSubShells; j > 0; j--)
X    {
X       sp = &SubShells[j - 1];
X
X       if (sp->depth < Execute_stack_depth)
X       break;
X
X/* Reduce number of entries */
X
X    --NSubShells;
X
X/* Release the space */
X
X    for (vp = vlist; vp != (Var_List *)NULL; vp = vp->next)
X    {
X        if (vp->status & GETCELL)
X        DELETE (vp->name);
X
X        DELETE (vp);
X    }
X
X/* Restore vlist information */
X
X    vlist = sp->header;
X    Load_G_VL ();
X    }
X}
X
X/*
X * Load GLobal Var List values
X */
X
Xstatic void    Load_G_VL ()
X{
X    path  = lookup (Path, TRUE);
X    ifs   = lookup ("IFS", TRUE);
X    ps1   = lookup ("PS1", TRUE);
X    ps2   = lookup ("PS2", TRUE);
X    C_dir = lookup ("~", TRUE);
X    Restore_Dir ();
X}
X
X/*
X * Match a pattern as in sh(1).
X */
X
Xbool        gmatch (s, p, IgnoreCase)
Xregister char    *s, *p;
Xbool        IgnoreCase;
X{
X    register int    sc, pc;
X
X    if ((s == (char *)NULL) || (p == (char *)NULL))
X    return FALSE;
X
X    while ((pc = *(p++) & CMASK) != '\0')
X    {
X    sc = *(s++) & QMASK;
X
X    switch (pc)
X    {
X        case '[':            /* Class expression        */
X        if ((p = cclass (p, sc, IgnoreCase)) == (char *)NULL)
X            return FALSE;
X
X        break;
X
X        case '?':            /* Match any character        */
X        if (sc == 0)
X            return FALSE;
X
X        break;
X
X        case '*':            /* Match as many as possible    */
X        s--;
X        do
X        {
X            if (!*p || gmatch (s, p, IgnoreCase))
X            return TRUE;
X
X        } while (*(s++));
X
X        return FALSE;
X
X        default:
X        if (IgnoreCase)
X        {
X            sc = tolower (sc);
X            pc = tolower ((pc & ~QUOTE));
X        }
X
X        if (sc != (pc & ~QUOTE))
X            return FALSE;
X    }
X    }
X
X    return (*s == 0) ? TRUE : FALSE;
X}
X
X/*
X * Process a class expression - []
X */
X
Xstatic char    *cclass (p, sub, IgnoreCase)
Xregister char    *p;
Xregister int    sub;
Xbool        IgnoreCase;
X{
X    register int    c, d, not, found;
X
X/* Exclusive or inclusive class */
X
X    if ((not = *p == NOT) != 0)
X    p++;
X
X    found = not;
X
X    do
X    {
X    if (!*p)
X        return (char *)NULL;
X
X/* Get the next character in class, converting to lower case if necessary */
X
X    c = IgnoreCase ? tolower ((*p & CMASK)) : (*p & CMASK);
X
X/* If this is a range, get the end of range character */
X
X    if ((*(p + 1) == '-') && (*(p + 2) != ']'))
X    {
X        d = IgnoreCase ? tolower ((*(p + 2) & CMASK)) : (*(p + 2) & CMASK);
X        p++;
X    }
X
X    else
X        d = c;
X
X/* Is the current character in the class? */
X
X    if ((c <= sub) && (sub <= d))
X        found = !not;
X
X    } while (*(++p) != ']');
X
X    return found ? p + 1 : (char *)NULL;
X}
X
X/*
X * Get a string in a malloced area
X */
X
Xchar        *getcell(nbytes)
Xunsigned int    nbytes;
X{
X    s_region        *np;
X
X    if (nbytes == 0)
X    abort ();    /* silly and defeats the algorithm */
X
X/* Grab some space */
X
X    if ((np = (s_region *)calloc (nbytes + sizeof (s_region), 1)) == (s_region *)NULL)
X        return (char *)NULL;
X
X/* Link into chain */
X
X    np->next = areastart;
X    np->area = areanum;
X    areastart = np;
X
X    return ((char *)np) + sizeof (s_region);
X}
X
X/*
X * Free a string in a malloced area
X */
X
Xvoid    freecell (s)
Xchar    *s;
X{
X    register s_region    *cp = areastart;
X    s_region        *lp = (s_region *)NULL;
X    s_region        *sp = (s_region *)(s - sizeof (s_region));
X
X/* Find the string in the chain */
X
X    if (s != (char *)NULL)
X    {
X    while (cp != (s_region *)NULL)
X    {
X        if (cp != sp)
X        {
X        lp = cp;
X        cp = cp->next;
X        continue;
X        }
X
X/* First in chain ? */
X
X        else if (lp == (s_region *)NULL)
X        areastart = cp->next;
X
X/* Delete the current entry and relink */
X
X        else
X        lp->next = cp->next;
X
X        free (cp);
X        break;
X    }
X    }
X}
X
X/*
X * Autodelete space nolonger required.  Ie. Free all the strings in a malloced
X * area
X */
X
Xvoid        freearea (a)
Xregister int    a;
X{
X    register s_region    *cp = areastart;
X    s_region        *lp = (s_region *)NULL;
X
X    while (cp != (s_region *)NULL)
X    {
X
X/* Is the area number less than that specified - yes, continue */
X    if (cp->area < a)
X    {
X        lp = cp;
X        cp = cp->next;
X    }
X
X/* OK - delete the area.  Is it the first in chain ?  Yes, delete, relink
X * and update start location
X */
X
X    else if (lp == (s_region *)NULL)
X    {
X        lp = cp;
X        cp = cp->next;
X        areastart = cp;
X
X        free (lp);
X        lp = (char *)NULL;
X    }
X
X/* Not first, delete the current entry and relink */
X
X    else
X    {
X        lp->next = cp->next;
X        free (cp);
X        cp = lp->next;
X    }
X    }
X}
X
X/*
X * Set the area number for a malloced string.  This allows autodeletion of
X * space that is nolonger required.
X */
X
Xvoid    setarea (cp,a)
Xchar    *cp;
Xint    a;
X{
X    s_region    *sp = (s_region *)(cp - sizeof (s_region));
X
X    if (cp != (char *)NULL)
X    sp->area = a;
X}
X
X/*
X * Get the area number for a malloced string
X */
X
Xint    getarea (cp)
Xchar    *cp;
X{
X    s_region    *sp = (s_region *)(cp - sizeof (s_region));
X
X    return sp->area;
X}
X
X/* Output one of the Prompt.  We save the prompt for the history part of
X * the program
X */
X
Xvoid    put_prompt (s)
Xchar    *s;
X{
X    struct dosdate_t     d_date;
X    struct dostime_t    d_time;
X    int            i;
X    char        buf[PATH_MAX + 4];
X
X    last_prompt = s;        /* Save the Last prompt output        */
X
X    _dos_gettime (&d_time);    /* Get the date and time in case    */
X    _dos_getdate (&d_date);
X
X    while (*s)
X    {
X
X/* If a format character, process it */
X
X    if (*s == '%')
X    {
X        s++;
X        *s = tolower(*s);
X
X        if (*s == '%')
X        S_putc ('%');
X
X        else
X        {
X        *buf = 0;
X
X        switch (*s)
X        {
X            case 'e':            /* Current event number */
X            if (History_Enabled)
X                sprintf (buf, "%d", Current_Event + 1);
X
X            break;
X
X            case 't':            /* time        */
X            sprintf (buf,"%.2d:%.2d", d_time.hour, d_time.minute);
X            break;
X
X            case 'd':            /* date        */
X            sprintf (buf, "%.3s %.2d-%.2d-%.2d",
X                 &"SunMonTueWedThuFriSat"[d_date.dayofweek * 3],
X                 d_date.day, d_date.month, d_date.year % 100);
X            break;
X
X            case 'p':            /* directory    */
X            case 'n':            /* default drive */
X            strcpy (buf, C_dir->value);
X
X            if (*s == 'n')
X                buf[1] = 0;
X
X            break;
X
X            case 'v':            /* version        */
X            sprintf (buf, "MS-DOS %.2d:%.2d", _osmajor, _osminor);
X            break;
X        }
X
X/* Output the string */
X
X        S_puts (buf);
X        }
X    }
X
X/* Escaped character ? */
X
X    else if (*s == '\\')
X    {
X        if ((i = Process_Escape (&s)) == -1)
X        i = 0;
X
X        S_putc (i);
X    }
X
X    else
X        S_putc (*s);
X
X/* Go to the next character */
X
X    s++;
X    }
X}
X
X/*
X * Get the current path in UNIX format and save it in the environment
X * variable $~
X */
X
Xvoid    Getcwd ()
X{
X    char    ldir[PATH_MAX + 6];
X    char    *cp = getcwd (ldir, PATH_MAX + 4);
X
X    strlwr (cp);
X
X/* Convert to Unix format */
X
X    while (*cp)
X    {
X    if (*cp == '\\')
X        *cp = '/';
X
X    ++cp;
X    }
X
X/* Save in environment */
X
X    setval ((C_dir = lookup ("~", TRUE)), ldir);
X}
X
X/*
X * Patch up various parts of the system for the shell.  At the moment, we
X * modify the ctype table so that _ is an upper case character.
X */
X
Xstatic void    patch_up ()
X{
X/* Patch the ctype table as a cheat */
X
X    (_ctype+1)['_'] |= _UPPER;
X}
X
X/*
X * Mail Check processing.  Every $MAILCHECK seconds, we check either $MAIL
X * or $MAILPATH to see if any file has changed its modification time since
X * we last looked.  In $MAILCHECK, the files are separated by colons (:).
X * If the filename contains a %, the string following the % is the message
X * to display if the file has changed.
X */
X
Xstatic void    Check_Mail ()
X{
X    int            delay = atoi (lookup ("MAILCHECK", FALSE)->value);
X    Var_List        *mail = lookup ("MAIL", FALSE);
X    Var_List        *mailp = lookup ("MAILPATH", FALSE);
X    static time_t    last = 0L;
X    time_t        current = time ((time_t *)NULL);
X    struct stat        st;
X    char        *cp, *sp, *ap;
X
X/* Have we waited long enough */
X
X    if ((current - last) < delay)
X    return;
X
X/* Yes - Check $MAILPATH.  If it is defined, process it.  Otherwise, use
X * $MAIL
X */
X
X    if (mailp->value != null)
X    {
X
X/* Check MAILPATH */
X
X    sp = mailp->value;
X
X/* Look for the next separator */
X
X    while ((cp = strchr (sp, ':')) != (char *)NULL)
X    {
X        *cp = 0;
X
X/* % in string ? */
X
X        if ((ap = strchr (ap, '%')) != (char *)NULL)
X        *ap = 0;
X
X/* Check the file name */
X
X        if ((stat (sp, &st) != -1) && (st.st_mtime > last))
X        {
X        if (ap != (char *)NULL)
X        {
X            S_puts (ap + 1);
X            S_putc (NL);
X        }
X
X        else
X            S_puts (ymail);
X        }
X
X/* Restore the % */
X
X        if (ap != (char *)NULL)
X        *ap = '%';
X
X/* Restore the colon and find the next one */
X
X        *cp = ':';
X        sp = cp + 1;
X    }
X    }
X
X/* Just check MAIL */
X
X    else if ((mail->value != null) && (stat (mail->value, &st) != -1) &&
X         (st.st_mtime > last))
X    S_puts (ymail);
X
X/* Save the last check time */
X
X    last = current;
X}
X
X/*
X * Preprocess Argv to get handle of options in the format /x
X *
X * Some programs invoke the shell using / instead of - to mark the options.
X * We need to convert to -.  Also /c is a special case.  The rest of the
X * command line is the command to execute.  So, we get the command line
X * from the original buffer instead of argv array.
X */
X
Xstatic void    Pre_Process_Argv (argv)
Xchar        **argv;
X{
X    char    *ocl = (char far *)((((long)_psp) << 16) + 0x081L);
X
X
X/* Check for these options */
X
X    while ((*++argv != (char *)NULL) && (strlen (*argv) == 2) &&
X       (**argv == '/'))
X    {
X       *strlwr (*argv) = '-';
X
X/* Get the original information from the command line */
X
X       if ((*argv)[1] == 'c')
X       {
X        while ((*ocl != '/') && (*(ocl + 1) != 'c') && (*ocl) &&
X           (*ocl != '\r'))
X        ++ocl;
X
X        if (*ocl != '/')
X        continue;
X
X/* Find the start of the string */
X
X        ocl += 2;
X
X        while (isspace (*ocl) && (*ocl != '\r'))
X        ++ocl;
X
X        if (*ocl == '\r')
X        continue;
X
X/* Found the start.  Set up next parameter and ignore the rest */
X
X        if (*(argv + 1) == (char *)NULL)
X        continue;
X
X        *(argv + 1) = ocl;
X        *(argv + 2) = (char *)NULL;
X
X        if ((ocl = strchr (ocl, '\r')) != (char *)NULL)
X        *ocl = 0;
X
X        return;
X       }
X    }
X}
SHAR_EOF
chmod 0644 shell/sh1.c || echo "restore of shell/sh1.c fails"
set `wc -c shell/sh1.c`;Sum=$1
if test "$Sum" != "28366"
then echo original size 28366, current size $Sum;fi
echo "x - extracting shell/sh2.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > shell/sh2.c &&
X/* MS-DOS SHELL - Parser
X *
X * MS-DOS SHELL - Copyright (c) 1990 Data Logic Limited and Charles Forsyth
X *
X * This code is based on (in part) the shell program written by Charles
X * Forsyth and is subject to the following copyright restrictions:
X *
X * 1.  Redistribution and use in source and binary forms are permitted
X *     provided that the above copyright notice is duplicated in the
X *     source form and the copyright notice in file sh6.c is displayed
X *     on entry to the program.
X *
X * 2.  The sources (or parts thereof) or objects generated from the sources
X *     (or parts of sources) cannot be sold under any circumstances.
X *
X *    $Header: sh2.c 1.1 90/01/25 13:41:12 MS_user Exp $
X *
X *    $Log:    sh2.c $
X * Revision 1.1  90/01/25  13:41:12  MS_user
X * Initial revision
X *
X */
X
X#include <sys/types.h>
X#include <stddef.h>
X#include <signal.h>
X#include <errno.h>
X#include <setjmp.h>
X#include <string.h>
X#include <ctype.h>
X#include <unistd.h>
X#include "sh.h"
X
X/*
X * shell: syntax (C version)
X */
X
Xtypedef union {
X    char    *cp;
X    char    **wp;
X    int        i;
X    C_Op    *o;
X} YYSTYPE;
X
X#define    WORD    256
X#define    LOGAND    257
X#define    LOGOR    258
X#define    BREAK    259
X#define    IF    260
X#define    THEN    261
X#define    ELSE    262
X#define    ELIF    263
X#define    FI    264
X#define    CASE    265
X#define    ESAC    266
X#define    FOR    267
X#define    WHILE    268
X#define    UNTIL    269
X#define    DO    270
X#define    DONE    271
X#define    IN    272
X#define    YYERRCODE 300
X
X/* flags to yylex */
X
X#define    CONTIN    01    /* skip new lines to complete command */
X
Xstatic bool        startl;
Xstatic int        peeksym;
Xstatic bool        Allow_funcs;
Xstatic int        iounit = IODEFAULT;
Xstatic C_Op        *tp;
Xstatic YYSTYPE        yylval;
Xstatic char        *syntax_err = "sh: syntax error\n";
X
Xstatic C_Op        *pipeline (int);
Xstatic C_Op        *andor (void);
Xstatic C_Op        *c_list (bool);
Xstatic bool        synio (int);
Xstatic void        musthave (int, int);
Xstatic C_Op        *simple (void);
Xstatic C_Op        *nested (int, int);
Xstatic C_Op        *command (int);
Xstatic C_Op        *dogroup (int);
Xstatic C_Op        *thenpart (void);
Xstatic C_Op        *elsepart (void);
Xstatic C_Op        *caselist (void);
Xstatic C_Op        *casepart (void);
Xstatic char        **pattern (void);
Xstatic char        **wordlist (void);
Xstatic C_Op        *list (C_Op *, C_Op *);
Xstatic C_Op        *block (int, C_Op *, C_Op *, char **);
Xstatic int        rlookup (char *);
Xstatic C_Op        *namelist (C_Op *);
Xstatic char        **copyw (void);
Xstatic void        word (char *);
Xstatic IO_Actions    **copyio (void);
Xstatic IO_Actions    *io (int, int, char *);
Xstatic void        yyerror (char *);
Xstatic int        yylex (int);
Xstatic int        collect (int, int);
Xstatic int        dual (int);
Xstatic void        diag (int);
Xstatic char        *tree (unsigned int);
X
XC_Op    *yyparse ()
X{
X    C_Op    *outtree;
X
X    startl  = TRUE;
X    peeksym = 0;
X    yynerrs = 0;
X    outtree = c_list (TRUE);
X    musthave (NL, 0);
X
X    return (yynerrs != 0) ? (C_Op *)NULL : outtree;
X}
X
Xstatic C_Op    *pipeline (cf)
Xint        cf;
X{
X    register C_Op    *t, *p;
X    register int    c;
X
X    if ((t = command (cf)) != (C_Op *)NULL)
X    {
X    Allow_funcs = FALSE;
X    while ((c = yylex (0)) == '|')
X    {
X        if ((p = command (CONTIN)) == (C_Op *)NULL)
X        yyerror (syntax_err);
X
X/* shell statement */
X
X        if ((t->type != TPAREN) && (t->type != TCOM))
X        t = block (TPAREN, t, NOBLOCK, NOWORDS);
X
X        t = block (TPIPE, t, p, NOWORDS);
X    }
X
X    peeksym = c;
X    }
X
X    return t;
X}
X
Xstatic C_Op    *andor ()
X{
X    register C_Op    *t, *p;
X    register int    c;
X
X    if ((t = pipeline (0)) != (C_Op *)NULL)
X    {
X    Allow_funcs = FALSE;
X    while (((c = yylex (0)) == LOGAND) || (c == LOGOR))
X    {
X        if ((p = pipeline (CONTIN)) == (C_Op *)NULL)
X        yyerror (syntax_err);
X
X        t = block ((c == LOGAND) ? TAND : TOR, t, p, NOWORDS);
X    }
X
X    peeksym = c;
X    }
X
X    return t;
X}
X
Xstatic C_Op    *c_list (allow)
Xbool        allow;
X{
X    register C_Op    *t, *p;
X    register int    c;
X
X/* Functions are only allowed at the start of a line */
X
X    Allow_funcs = allow;
X
X    if ((t = andor ()) != (C_Op *)NULL)
X    {
X    Allow_funcs = FALSE;
X
X    if ((peeksym = yylex (0)) == '&')
X        t = block (TASYNC, t, NOBLOCK, NOWORDS);
X
X    while ((c = yylex(0)) == ';' || c == '&' || multiline && c == NL)
X    {
X        if ((p = andor ()) == (C_Op *)NULL)
X        return t;
X
X        if ((peeksym = yylex (0)) == '&')
X        p = block (TASYNC, p, NOBLOCK, NOWORDS);
X
X        t = list (t, p);
X    }
X    peeksym = c;
X    }
X
X    return t;
X}
X
X
Xstatic bool    synio (cf)
Xint        cf;
X{
X    register IO_Actions    *iop;
X    register int    i;
X    register int    c;
X
X    if (((c = yylex (cf)) != '<') && (c != '>'))
X    {
X    peeksym = c;
X    return FALSE;
X    }
X
X    i = yylval.i;
X    musthave (WORD, 0);
X    iop = io (iounit, i, yylval.cp);
X    iounit = IODEFAULT;
X
X    if (i & IOHERE)
X    markhere (yylval.cp, iop);
X
X    return TRUE;
X}
X
Xstatic void    musthave (c, cf)
Xint        c, cf;
X{
X    if ((peeksym = yylex (cf)) != c)
X    yyerror (syntax_err);
X
X    peeksym = 0;
X}
X
Xstatic C_Op    *simple ()
X{
X    register C_Op    *t = (C_Op *)NULL;
X
X    while (1)
X    {
X    switch (peeksym = yylex (0))
X    {
X        case '<':
X        case '>':
X        synio (0);
X        break;
X
X        case WORD:
X        if (t == (C_Op *)NULL)
X            (t = (C_Op *)tree (sizeof (C_Op)))->type = TCOM;
X
X        peeksym = 0;
X        word (yylval.cp);
X        break;
X
X/* Check for function - name () { word; } */
X
X        case '(':
X        if ((t != (C_Op *)NULL) && (Allow_funcs == TRUE) &&
X            (wdlist != (Word_B *)NULL) && (wdlist->w_nword == 1))
X        {
X            Word_B    *save;
X
X            peeksym = 0;
X            musthave (')', 0);
X            musthave ('{', 0);
X            save = wdlist;
X            wdlist = (Word_B *)NULL;
X            t->type = TFUNC;
X            t->left = nested (TBRACE, '}');
X            wdlist = save;
X            Allow_funcs = FALSE;
X            musthave (NL, 0);
X            peeksym = NL;
X        }
X
X        default:
X        return t;
X    }
X    }
X}
X
Xstatic C_Op    *nested (type, mark)
Xint        type, mark;
X{
X    register C_Op    *t;
X
X    multiline++;
X    t = c_list (FALSE);
X    musthave (mark, 0);
X    multiline--;
X    return block (type, t, NOBLOCK, NOWORDS);
X}
X
Xstatic C_Op    *command (cf)
Xint        cf;
X{
X    register C_Op    *t;
X    Word_B        *iosave = iolist;
X    register int    c;
X
X    iolist = (Word_B *)NULL;
X
X    if (multiline)
X    cf |= CONTIN;
X
X    while (synio (cf))
X    cf = 0;
X
X    switch (c = yylex (cf))
X    {
X    default:
X        peeksym = c;
X
X        if ((t = simple ()) == (C_Op *)NULL)
SHAR_EOF
echo "End of part 2"
echo "File shell/sh2.c is continued in part 3"
echo "3" > s2_seq_.tmp
exit 0

--
Regards,

Ian Stewartson
Data Logic Ltd.