/* mp4.c */

/***************************************************
 * A stripped-down shell for Unix                  *
 *   reads shell scripts from standard input       *
 *                                                 *
 * Author:  Douglas W, Jones,     July 7, 2003     *
 ***************************************************/

/***************************************************
 * Grammar of scripting language:                  *
 *                                                 *
 *   <script> ::= { <line> } <EOF>                 *
 *                                                 *
 *   <line> ::= exit { <anything> } <EOL>          *
 *      the only built-in command                  *
 *                                                 *
 *   <line> ::= # { <anything> } <EOL>             *
 *      lines of this form are comments            *
 *                                                 *
 *   <line> ::= <progname> { <argument> } <EOL>    *
 *      lines of this form are executed            *
 *                                                 *
 *   <progname> ::= <nonblankstring>               *
 *      program names should be the names of       *
 *      executable files relative to one of these  *
 *      directories:                               *
 *         the current directory (.)               *
 *         /bin                                    *
 *         /usr/bin                                *
 *      Directories are searched in that order!    *
 *                                                 *
 *   <argument> ::= <nonblankstring>               *
 *                                                 *
 ***************************************************/

#include <stdio.h>
#include <strings.h>
#include <fcntl.h>

/* maximum number of allowed command line arguments */
#define MAXARGS 128
/* maximum length of an input line */
#define LINELEN 256

/*************************************************** 
 * I/O utilities                                   *
 *   formally speaking, this is something like a   *
 *   set of lexical scan support routines          *
 ***************************************************/

int getnonblank()
/* like getchar() but only terminates when it reached a nonblank character,
   or when it hits a newline or end of file.
 */
{
	int ch;
	for (;;) { 
		ch  = getchar();
		if (ch == '\n') break;
		if (ch == EOF) break;
		if (ch > ' ') break;
	}
	return ch;
}

/*************************************************** 
 * The main program                                *
 *   A completely awful single block of code       *
 ***************************************************/

extern char **environ; /* the environment passed to this program */

main(int argc, char * argv[])
/* the main program */
{
	/* there are many missing features here.  Among them, it would
	   be nice to reopen standard input as argv[1] if that argument
	   is present. */

	/* each iteration of the following loop reads one line */
	for (;;) {
		int ch; /* one character from the input file */
		char line[LINELEN]; /* one line of input */
		int len; /* position on this line */

		/* the command line arguments found on this line */
		char * argv[MAXARGS];
		int argc;

		/* setup to scan one line of input
		   note that current scanning is awful, with no
		   support for shell or environment variables */

		len = 0;
		argc = 0;
		for (;;) {
			/* find a nonblank character */
			ch = getnonblank();
			if (ch == '\n') break;
			if (ch == EOF) break;

			/* ch is a nonblank character, it starts an argument */
			argv[argc] = &line[len];
			if (argc >= (MAXARGS-1)) {
				fputs( "too many arguments", stdout );
			} else {
				argc++;
			}
			line[len] = ch;
			if (len >= (LINELEN-1)) {
				fputs( "line too long", stdout );
			} else {
				len++;
			}

			/* get remainder of argument (find next blank) */
			for (;;) { 
				ch  = getchar();
				if (ch == '\n') break;
				if (ch == EOF) break;
				if (ch <= ' ') break;

				line[len] = ch;
				if (len >= (LINELEN-1)) {
					fputs( "line too long", stdout );
				} else {
					len++;
				}
			}

			/* put null terminator on argument */
			line[len] = '\0';
			if (len >= (LINELEN-1)) {
				fputs( "line too long", stdout );
			} else {
				len++;
			}

			/* quit loop if end of line */
			if (ch == '\n') break;
			if (ch == EOF) break;
		}
		argv[argc] = NULL;

		/* argv array is now built, but it could be length zero! */

		/* try to execute this command */
		if ((argc > 0) && (argv[0][0] != '#')) {
			/* this line is nonblank and not a comment */

			/* first, try all built-in commands
			   currently, only one is supported */
			if (!strcmp( "exit", argv[0] )) {
				/* would be nice to allow exit argument to
				   be changed and to complain about excess
				   arguments, but that's not done yet */
				exit(0);

			} else {
				/* it must be the name of an executble */

				/* magic code to execute sub process */
				int pid;
				int status;
				if ((pid = fork()) == 0) {
					char name[LINELEN];

					/* this tries a fixed search path */
					strncpy( name, "", LINELEN);
					strncat( name, argv[0], LINELEN);
					execve( name, argv, environ );

					strncpy( name, "/bin/", LINELEN);
					strncat( name, argv[0], LINELEN);
					execve( name, argv, environ );

					strncpy( name, "/usr/bin/", LINELEN);
					strncat( name, argv[0], LINELEN);
					execve( name, argv, environ );

					fputs( argv[0], stderr );
					fputs( ": could not execute\n",
						stderr );
					exit(-1);
				} else {
					while(wait(&status) != pid);
					/* should capture the exit status
					   so it can be tested! */
				}
			}
		} /* if the line contained a command, we tried to execute it */

		/* if this was the last line of the file, normal termination */
		if (ch == EOF) break;

	} /* end of loop, one iteration per line */

	/* exit normally */
	exit(0);

} /* end of main program */