# This is a shell archive.  Save it in a file, remove anything before
# this line, and then unpack it by entering "sh file".  Note, it may
# create directories; files and directories will be owned by you and
# have default permissions.
#
# This archive contains:
#
#	README
#	Makefile
#	command.c
#	main.c
#	mp4.c
#	boolean.h
#	command.h
#
echo x - README
sed 's/^X//' >README << 'END-of-README'
XREADME
X
X------------------------------------------------------------------------
XGeneral information about ESH, the Example Shell interpreter.
X
XAuthor:   Douglas W. Jones, July  7, 2003   Version 4.0
XRevised:  Douglas W. Jones, July 14, 2003   Version 4.1
X
XCopyright:  This work is intended as a pedagogical example; as such, no
X	    restrictions are placed on the reader's rights to derive
X	    useful products from it, so long as any copyright claimed on
X	    the results gives appropriate credit for this work.
X
XWarantee:   This work, as distributed, is intended as a pedagogical
X	    example; as such, it deliberately contains undocumented
X	    design errors and deficiencies that are left to the student
X	    to uncover!  Furthermore, as distributed, it is not intended
X	    to be of any particular use for any purpose other than
X	    teaching.
X------------------------------------------------------------------------
X
XThis directory contains all the tools needed to build the ESH assembler.
X
XTo compile ESH, simply run make.  Before running make, read the
Xinstructions at the head of the makefile.
X
XThis file contains the following components:
X
X	Makefile	-- the input to make, for making the ESH shell
X
X	README		-- this file
X
X	command.c	-- command execution mechanism
X	command.h
X
X	main.c		-- the main program
X
X------------------------------------------------------------------------
X   Grammar of scripting language:
X
X     <script> ::= { <line> } <EOF>
X
X     <line> ::= exit { <anything> } <EOL>
X        the only built-in command
X
X     <line> ::= # { <anything> } <EOL>
X        lines of this form are comments
X
X     <line> ::= <progname> { <argument> } <EOL>
X        lines of this form are executed
X
X     <progname> ::= <nonblankstring>
X        program names should be the names of
X        executable files relative to one of these
X        directories:
X           the current directory (.)
X           /bin
X           /usr/bin
X        Directories are searched in that order!
X
X     <argument> ::= <nonblankstring>
END-of-README
echo x - Makefile
sed 's/^X//' >Makefile << 'END-of-Makefile'
X# Makefile
X
X#################################################################
X# File dependencies and instructions for building ESH shell     #
X# Authorship and Revision History:                              #
X#   V4.1:  Douglas W. Jones, July  22, 2003                     #
X#                                                               #
X# Instructions:                                                 #
X#          make       -- builds esh, the assembler              #
X#          make esh   -- builds esh explicitly                  #
X#          make clean -- deletes esh and all intermediate files #
X#          make shar  -- builds esh.shar, for archive or export #
X#                                                               #
X#################################################################
X
XVERSION = "\"V4.1\""
XAUTHOR  = "\"Douglas W. Jones\""
X
X#################################################################
X# Configuration constants                                       #
X#   you may need to change some of these!                       #
X#################################################################
X
X# what C compiler to use (HP-UX choices are c89, gcc, CC, g++, cc -Aa)
XCC = cc
X
X# maximum length of an input line
XLINELEN = 256
X
X# maximum number of arguments on an input line
XMAXARGS = 128
X
X#################################################################
X# File dependencies                                             #
X#################################################################
X
XOBJECTS = main.o command.o
Xesh: $(OBJECTS)
X	$(CC) -o esh $(OBJECTS)
X
XMAINDEF1 = -DVERSION=$(VERSION) -DAUTHOR=$(AUTHOR)
XMAINDEF2 = -DLINELEN=$(LINELEN) -DMAXARGS=$(MAXARGS)
Xmain.o: main.c Makefile
Xmain.o: command.h
X	$(CC) -c $(MAINDEF1) $(MAINDEF2) main.c
X
XCOMDEF   = -DLINELEN=$(LINELEN)
Xcommand.o: command.c
X	$(CC) -c $(COMDEF) command.c
X
Xclean:
X	rm -f *.o esh
X
Xshar:
X	shar README Makefile *.c *.h > esh.shar
END-of-Makefile
echo x - command.c
sed 's/^X//' >command.c << 'END-of-command.c'
X/* command.c */
X
X/***************************************************
X * shell command execution subsystem               *
X * Author:  Douglas W. Jones, July 14, 2003        *
X * Revised: Douglas W. Jones, July 22, 2003   *V4.1*
X ***************************************************/
X
X/*************************************************** 
X * Prerequisites for use                           *
X ***************************************************/
X
X/* maximum length of a file name */
X/* LINELEN defined by Makefile */
X
X#include <sys/types.h>
X#include <unistd.h>
X#include <stdlib.h>
X#include <string.h>
X#include <stdio.h>
X
X#include "boolean.h"
X
X#define EXTERN
X#include "command.h"
X
X/* Note on usage of <string.h>:
X	Some systems have routines in <string.h> that are handy but are
X	missing from other systems.  This code makes an effort to avoid
X	these in favor of routines that seem to be more widely available.
X	Comments on the code in question say "could use" and give the
X	name of the <string.h> routine that is not as widely available.
X */
X/*************************************************** 
X * Private data                                    *
X ***************************************************/
X
Xextern char **environ;          /* the shell's environment */
X
Xstatic char *path;              /* the value of PATH in the environment */
Xstatic char *pathcopy = NULL;   /* a copy of the value of PATH to work with */
Xstatic char *pathpart[LINELEN]; /* pointers to path parts in pathcopy */
Xstatic int pathpartcount;       /* how many path parts were found? */
X
X/*************************************************** 
X * Private support functions                       *
X ***************************************************/
X
Xstatic getpath()
X/* extract the current value of PATH from the environment */
X{
X	char * p; /* temporary, used in parsing strings */
X
X	/* first, we get a copy of the path to work with */
X	path = getenv( "PATH" );
X	if (pathcopy != NULL) free( pathcopy );
X	pathcopy = strdup( path );
X
X	/* second, we parse the copy of the path into path components */
X	p = pathcopy;
X	pathpartcount = 0;
X	if ((p != NULL) && (*p != '\0')) {
X		for (;;) {
X			/* record one path component */
X			pathpart[pathpartcount] = p;
X			pathpartcount++;
X
X			/* find the end of the component, if needed, mark it */
X			/* could use strtok() or strsep() */
X			p = strpbrk( p, ":" );
X			if (p == NULL) break; /* we found the end of the path */
X			*p = '\0';           /* mark the end */
X
X			/* prepare to look at the next component */
X			p++;
X			if (pathpartcount >= LINELEN) break;
X		}
X	}
X
X	/* now, the first pathpartcount elements of
X	   pathpart[] point to copies of components of path */
X}
X
Xstatic launch( int argc, char * argv[] )
X/* execute the command given by argv[0], not a built-in command, using
X   argc -- the number of textual arguments to the command
X   argv -- the array of textual arguments argv[0] through argv[argc]
X */
X{
X	/* we assume that argc > 0 and this line is not a comment */
X
X	/* magic code to execute a subprocess */
X	int pid;
X	int status;
X	if ((pid = fork()) == 0) {
X		if (*argv[0] == '/') {
X			/* directly named file */
X			execve( argv[0], argv, environ );
X		} else {
X			/* use the search path to find the file */
X			int i; /* index into pathpart[] */
X			for (i = 0; i < pathpartcount; i++) {
X				char name[LINELEN];
X
X				/* build the filename in the array name */
X				strncpy( name, pathpart[i], LINELEN);
X				strncat( name, "/", LINELEN);
X				strncat( name, argv[0], LINELEN);
X
X				/* try launching it */
X				execve( name, argv, environ );
X			}
X		}
X
X		/* attempted execution failed */
X		fputs( argv[0], stderr );
X		fputs( ": could not execute\n", stderr );
X		exit( EXIT_FAILURE );
X	} else {
X		while(wait(&status) != pid);
X		/* should capture the exit status
X		   so it can be tested! */
X	}
X}
X
XBOOLEAN argcheck( int argc, int min, int max, char * arg0 )
X/* check that argc is between min and max;
X   if not, bomb out with an appropriate complaint.
X */
X{
X	if (argc < min) {
X		fputs( arg0, stderr );
X		fputs( ": missing arguments\n", stderr );
X		return FALSE;
X	} else if (argc > max) {
X		fputs( arg0, stderr );
X		fputs( ": unexpected extra arguments\n", stderr );
X		return FALSE;
X	}
X	return TRUE;
X}
X
X/*************************************************** 
X * Implementation of the Interface                 *
X ***************************************************/
X
Xvoid com_init()
X/* initialize for command execution */
X{
X	getpath(); /* get and parse the search path */
X}
X
Xvoid com_exec( int argc, char * argv[] )
X/* execute the command given by argv[0] using
X   argc -- the number of textual arguments to the command
X   argv -- the array of textual arguments argv[0] through argv[argc]
X */
X{
X	/* we assume that argc > 0 and this line is not a comment */
X
X	/* first, try all built-in commands */
X	if (!strcmp( "exit", argv[0] )) {
X		if (argcheck( argc, 1, 1, argv[0] )) {
X			exit( EXIT_SUCCESS );
X		}
X		exit( EXIT_FAILURE );
X
X	} else if (!strcmp( "setenv", argv[0] )) {
X		if (argcheck( argc, 3, 3, argv[0] )) {
X			/* substitute for setenv( argv[1], argv[2], 1 ) */
X			char * s = malloc(
X				strlen( argv[1] ) + strlen( argv[2] ) + 2 );
X			strcpy( s, argv[1] );
X			strcat( s, "=" );
X			strcat( s, argv[2] );
X			putenv( s );
X
X			/* this could have changed PATH */
X			if (!strcmp( "PATH", argv[1] )) {
X				getpath(); /* reparse PATH */
X			}
X
X		}
X	} else {
X		/* it must be the name of an executble */
X		launch( argc, argv );
X	}
X}
END-of-command.c
echo x - main.c
sed 's/^X//' >main.c << 'END-of-main.c'
X/* main.c */
X
X/*****************************************************
X * A stripped-down shell for Unix                    *
X *   reads shell scripts from standard input         *
X *                                                   *
X * Author:  Douglas W, Jones,     July 7,  2003      *
X * Revised: Douglas W, Jones,     July 16, 2003 *V4.0*
X *****************************************************/
X
X/* version number and authorship */
X/* VERSION defined by Makefile */
X/* AUTHOR  defined by Makefile */
X
X/* maximum length of the argument list and of any one input line */
X/* MAXARGS defined by Makefile */
X/* LINELEN defined by Makefile */
X
X#include "command.h"
X
X/***************************************************
X * Private main program data                       *
X ***************************************************/
X
X#include <stdio.h>
X
Xextern char **environ; /* the environment passed to this program */
X
X/*************************************************** 
X * I/O utilities                                   *
X *   formally speaking, this is something like a   *
X *   set of lexical scan support routines          *
X ***************************************************/
X
Xint getnonblank()
X/* like getchar() but only terminates when it reached a nonblank character,
X   or when it hits a newline or end of file.
X */
X{
X	int ch;
X	for (;;) { 
X		ch  = getchar();
X		if (ch == '\n') break;
X		if (ch == EOF) break;
X		if (ch > ' ') break;
X	}
X	return ch;
X}
X
X/*************************************************** 
X * The main program                                *
X *   Mixes parsing and several other functions     *
X ***************************************************/
X
Xmain(int argc, char * argv[])
X/* the main program */
X{
X	com_init(); /* initialize the command processor */
X
X	/* there are many missing features here.  Among them, it would
X	   be nice to reopen standard input as argv[1] if that argument
X	   is present. */
X
X	/* each iteration of the following loop reads one line */
X	for (;;) {
X		int ch; /* one character from the input file */
X		char line[LINELEN]; /* one line of input */
X		int len; /* position on this line */
X
X		/* the command line arguments found on this line */
X		char * argv[MAXARGS];
X		int argc;
X
X		/* setup to scan one line of input
X		   note that current scanning is awful, with no
X		   support for shell or environment variables */
X
X		len = 0;
X		argc = 0;
X		for (;;) {
X			/* find a nonblank character */
X			ch = getnonblank();
X			if (ch == '\n') break;
X			if (ch == EOF) break;
X
X			/* ch is a nonblank character, it starts an argument */
X			argv[argc] = &line[len];
X			if (argc >= (MAXARGS-1)) {
X				fputs( "too many arguments", stdout );
X			} else {
X				argc++;
X			}
X			line[len] = ch;
X			if (len >= (LINELEN-1)) {
X				fputs( "line too long", stdout );
X			} else {
X				len++;
X			}
X
X			/* get remainder of argument (find next blank) */
X			for (;;) { 
X				ch  = getchar();
X				if (ch == '\n') break;
X				if (ch == EOF) break;
X				if (ch <= ' ') break;
X
X				line[len] = ch;
X				if (len >= (LINELEN-1)) {
X					fputs( "line too long", stdout );
X				} else {
X					len++;
X				}
X			}
X
X			/* put null terminator on argument */
X			line[len] = '\0';
X			if (len >= (LINELEN-1)) {
X				fputs( "line too long", stdout );
X			} else {
X				len++;
X			}
X
X			/* quit loop if end of line */
X			if (ch == '\n') break;
X			if (ch == EOF) break;
X		}
X		argv[argc] = NULL;
X
X		/* argv array is now built, but it could be length zero! */
X
X		/* try to execute this command */
X		if ((argc > 0) && (argv[0][0] != '#')) {
X			com_exec( argc, argv );
X		}
X
X		/* if this was the last line of the file, normal termination */
X		if (ch == EOF) break;
X
X	} /* end of loop, one iteration per line */
X
X	/* exit normally */
X	exit(0);
X
X} /* end of main program */
END-of-main.c
echo x - mp4.c
sed 's/^X//' >mp4.c << 'END-of-mp4.c'
X/* mp4.c */
X
X/***************************************************
X * A stripped-down shell for Unix                  *
X *   reads shell scripts from standard input       *
X *                                                 *
X * Author:  Douglas W, Jones,     July 7, 2003     *
X ***************************************************/
X
X/***************************************************
X * Grammar of scripting language:                  *
X *                                                 *
X *   <script> ::= { <line> } <EOF>                 *
X *                                                 *
X *   <line> ::= exit { <anything> } <EOL>          *
X *      the only built-in command                  *
X *                                                 *
X *   <line> ::= # { <anything> } <EOL>             *
X *      lines of this form are comments            *
X *                                                 *
X *   <line> ::= <progname> { <argument> } <EOL>    *
X *      lines of this form are executed            *
X *                                                 *
X *   <progname> ::= <nonblankstring>               *
X *      program names should be the names of       *
X *      executable files relative to one of these  *
X *      directories:                               *
X *         the current directory (.)               *
X *         /bin                                    *
X *         /usr/bin                                *
X *      Directories are searched in that order!    *
X *                                                 *
X *   <argument> ::= <nonblankstring>               *
X *                                                 *
X ***************************************************/
X
X#include <stdio.h>
X#include <strings.h>
X#include <fcntl.h>
X
X/* maximum number of allowed command line arguments */
X#define MAXARGS 128
X/* maximum length of an input line */
X#define LINELEN 256
X
X/*************************************************** 
X * I/O utilities                                   *
X *   formally speaking, this is something like a   *
X *   set of lexical scan support routines          *
X ***************************************************/
X
Xint getnonblank()
X/* like getchar() but only terminates when it reached a nonblank character,
X   or when it hits a newline or end of file.
X */
X{
X	int ch;
X	for (;;) { 
X		ch  = getchar();
X		if (ch == '\n') break;
X		if (ch == EOF) break;
X		if (ch > ' ') break;
X	}
X	return ch;
X}
X
X/*************************************************** 
X * The main program                                *
X *   A completely awful single block of code       *
X ***************************************************/
X
Xextern char **environ; /* the environment passed to this program */
X
Xmain(int argc, char * argv[])
X/* the main program */
X{
X	/* there are many missing features here.  Among them, it would
X	   be nice to reopen standard input as argv[1] if that argument
X	   is present. */
X
X	/* each iteration of the following loop reads one line */
X	for (;;) {
X		int ch; /* one character from the input file */
X		char line[LINELEN]; /* one line of input */
X		int len; /* position on this line */
X
X		/* the command line arguments found on this line */
X		char * argv[MAXARGS];
X		int argc;
X
X		/* setup to scan one line of input
X		   note that current scanning is awful, with no
X		   support for shell or environment variables */
X
X		len = 0;
X		argc = 0;
X		for (;;) {
X			/* find a nonblank character */
X			ch = getnonblank();
X			if (ch == '\n') break;
X			if (ch == EOF) break;
X
X			/* ch is a nonblank character, it starts an argument */
X			argv[argc] = &line[len];
X			if (argc >= (MAXARGS-1)) {
X				fputs( "too many arguments", stdout );
X			} else {
X				argc++;
X			}
X			line[len] = ch;
X			if (len >= (LINELEN-1)) {
X				fputs( "line too long", stdout );
X			} else {
X				len++;
X			}
X
X			/* get remainder of argument (find next blank) */
X			for (;;) { 
X				ch  = getchar();
X				if (ch == '\n') break;
X				if (ch == EOF) break;
X				if (ch <= ' ') break;
X
X				line[len] = ch;
X				if (len >= (LINELEN-1)) {
X					fputs( "line too long", stdout );
X				} else {
X					len++;
X				}
X			}
X
X			/* put null terminator on argument */
X			line[len] = '\0';
X			if (len >= (LINELEN-1)) {
X				fputs( "line too long", stdout );
X			} else {
X				len++;
X			}
X
X			/* quit loop if end of line */
X			if (ch == '\n') break;
X			if (ch == EOF) break;
X		}
X		argv[argc] = NULL;
X
X		/* argv array is now built, but it could be length zero! */
X
X		/* try to execute this command */
X		if ((argc > 0) && (argv[0][0] != '#')) {
X			/* this line is nonblank and not a comment */
X
X			/* first, try all built-in commands
X			   currently, only one is supported */
X			if (!strcmp( "exit", argv[0] )) {
X				/* would be nice to allow exit argument to
X				   be changed and to complain about excess
X				   arguments, but that's not done yet */
X				exit(0);
X
X			} else {
X				/* it must be the name of an executble */
X
X				/* magic code to execute sub process */
X				int pid;
X				int status;
X				if ((pid = fork()) == 0) {
X					char name[LINELEN];
X
X					/* this tries a fixed search path */
X					strncpy( name, "", LINELEN);
X					strncat( name, argv[0], LINELEN);
X					execve( name, argv, environ );
X
X					strncpy( name, "/bin/", LINELEN);
X					strncat( name, argv[0], LINELEN);
X					execve( name, argv, environ );
X
X					strncpy( name, "/usr/bin/", LINELEN);
X					strncat( name, argv[0], LINELEN);
X					execve( name, argv, environ );
X
X					fputs( argv[0], stderr );
X					fputs( ": could not execute\n",
X						stderr );
X					exit(-1);
X				} else {
X					while(wait(&status) != pid);
X					/* should capture the exit status
X					   so it can be tested! */
X				}
X			}
X		} /* if the line contained a command, we tried to execute it */
X
X		/* if this was the last line of the file, normal termination */
X		if (ch == EOF) break;
X
X	} /* end of loop, one iteration per line */
X
X	/* exit normally */
X	exit(0);
X
X} /* end of main program */
END-of-mp4.c
echo x - boolean.h
sed 's/^X//' >boolean.h << 'END-of-boolean.h'
X/* boolean.h */
X
X/***************************************
X * The boolean type that we wish C had *
X ***************************************/
X
X#define TRUE    (1)
X#define FALSE   (0)
X#define BOOLEAN int
END-of-boolean.h
echo x - command.h
sed 's/^X//' >command.h << 'END-of-command.h'
X/* command.h */
X
X/***************************************************
X * shell command execution subsystem interface     *
X * Author:  Douglas W. Jones, July 14, 2003        *
X ***************************************************/
X
X/*************************************************** 
X * Prerequisites for use                           *
X *   None                                          *
X ***************************************************/
X
X/*************************************************** 
X * The Interface                                   *
X ***************************************************/
X
Xvoid com_init();
X/* initialize for command execution */
X
Xvoid com_exec( int argc, char * argv[] );
X/* execute the command given by argv[0] using
X   argc -- the number of textual arguments to the command
X   argv -- the array of textual arguments argv[0] through argv[argc]
X */
END-of-command.h
exit