toys/pending/sh.c - platform/external/toybox - Git at Google

 /* sh.c - toybox shell
  *
  * Copyright 2006 Rob Landley <rob@landley.net>
  *
  * The POSIX-2008/SUSv4 spec for this is at:
  * http://opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html
  * and http://opengroup.org/onlinepubs/9699919799/utilities/sh.html
  *
  * The first link describes the following shell builtins:
  *
  *   break colon continue dot eval exec exit export readonly return set shift
  *   times trap unset
  *
  * The second link (the utilities directory) also contains specs for the
  * following shell builtins:
  *
  *   alias bg cd command fc fg getopts hash jobs kill read type ulimit
  *   umask unalias wait
  *
  * Things like the bash man page are good to read too.

 USE_SH(NEWTOY(cd, NULL, TOYFLAG_NOFORK))
 USE_SH(NEWTOY(exit, NULL, TOYFLAG_NOFORK))

 USE_SH(NEWTOY(sh, "c:i", TOYFLAG_BIN))
 USE_SH(OLDTOY(toysh, sh, TOYFLAG_BIN))
 // Login lies in argv[0], so add some aliases to catch that
 USE_SH(OLDTOY(-sh, sh, 0))
 USE_SH(OLDTOY(-toysh, sh, 0))

 config SH
   bool "sh (toysh)"
   default n
   help
     usage: sh [-c command] [script]

     Command shell.  Runs a shell script, or reads input interactively
     and responds to it.

     -c	command line to execute
     -i	interactive mode (default when STDIN is a tty)

 # These are here for the help text, they're not selectable and control nothing
 config CD
   bool
   default n
   depends on SH
   help
     usage: cd [-PL] [path]

     Change current directory.  With no arguments, go $HOME.

     -P	Physical path: resolve symlinks in path
     -L	Local path: .. trims directories off $PWD (default)

 config EXIT
   bool
   default n
   depends on SH
   help
     usage: exit [status]

     Exit shell.  If no return value supplied on command line, use value
     of most recent command, or 0 if none.
 */

 #define FOR_sh
 #include "toys.h"

 GLOBALS(
   char *command;

   long lineno;

   // parse scratch space
   struct double_list *parse;

   // Running jobs.
   struct sh_job {
     struct sh_job *next, *prev;
     unsigned jobno;

     // Every pipeline has at least one set of arguments or it's Not A Thing
     struct sh_arg {
       char **v;
       unsigned long c;
     } pipeline;

     // null terminated array of running processes in pipeline
     struct sh_process {
       struct string_list *delete; // expanded strings
       int pid, exit;   // status? Stopped? Exited?
       char *end;
       struct sh_arg arg;
     } *procs, *proc;
   } *jobs, *job;
   unsigned jobcnt;
 )

 void cd_main(void)
 {
   char *dest = *toys.optargs ? *toys.optargs : getenv("HOME");

   xchdir(dest ? dest : "/");
 }

 void exit_main(void)
 {
   exit(*toys.optargs ? atoi(*toys.optargs) : 0);
 }

 // Print prompt, parsing escapes
 static void do_prompt(char *prompt)
 {
   char *s, c, cc;

   if (!prompt) prompt = "\\$ ";
   while (*prompt) {
     c = *(prompt++);

     if (c=='!') {
       if (*prompt=='!') prompt++;
       else {
         printf("%ld", TT.lineno);
         continue;
       }
     } else if (c=='\\') {
       int i = 0;

       cc = *(prompt++);
       if (!cc) goto down;

       // \nnn \dD{}hHjlstT@AuvVwW!#$
       // Ignore bash's "nonprintable" hack; query our cursor position instead.
       if (cc=='[' || cc==']') continue;
       else if (cc=='$') putchar(getuid() ? '$' : '#');
       else if (cc=='h' || cc=='H') {
         *toybuf = 0;
         gethostname(toybuf, sizeof(toybuf)-1);
         if (cc=='h' && (s = strchr(toybuf, '.'))) *s = 0;
         fputs(toybuf, stdout);
       } else if (cc=='s') fputs(getbasename(*toys.argv), stdout);
       else {
         if (!(c = unescape(cc))) {
           c = '\\';
           prompt--;
         }
         i++;
       }
       if (!i) continue;
     }
 down:
     putchar(c);
   }
   fflush(stdout);
 }

 // Execute the commands in a pipeline
 static void run_command(struct sh_process *pp)
 {
   struct toy_list *tl = toy_find(*pp->arg.v);

   // Is this command a builtin that should run in this process?
   if (tl && (tl->flags & TOYFLAG_NOFORK)) {
     struct toy_context temp;
     sigjmp_buf rebound;

     // This fakes lots of what toybox_main() does.
     memcpy(&temp, &toys, sizeof(struct toy_context));
     memset(&toys, 0, sizeof(struct toy_context));

     if (!sigsetjmp(rebound, 1)) {
       toys.rebound = &rebound;
       toy_init(tl, pp->arg.v);
       tl->toy_main();
     }
     pp->exit = toys.exitval;
     if (toys.optargs != toys.argv+1) free(toys.optargs);
     if (toys.old_umask) umask(toys.old_umask);
     memcpy(&toys, &temp, sizeof(struct toy_context));
   } else {
     int pipe[2];

     pipe[0] = 0;
     pipe[1] = 1;
     if (-1 == (pp->pid = xpopen_both(pp->arg.v, pipe)))
       perror_msg("%s: vfork", *pp->arg.v);
     else pp->exit = xpclose_both(pp->pid, 0);
   }

   return;
 }

 // todo: ${name:?error} causes an error/abort here (syntax_err longjmp?)
 static void expand_arg(struct sh_arg *arg, char *new)
 {
   if (!(arg->c&32)) arg->v = xrealloc(arg->v, sizeof(void *)*(arg->c+33));

   arg->v[arg->c++] = new;
   arg->v[arg->c] = 0;
 }

 // like error_msg() but exit from shell scripts
 void syntax_err(char *msg, ...)
 {
   va_list va;

   va_start(va, msg);
   verror_msg(msg, 0, va);
   va_end(va);

   if (*toys.optargs) xexit();
 }


 // Parse one word from the command line, appending one or more argv[] entries
 // to struct command.  Handles environment variable substitution and
 // substrings.  Returns pointer to next used byte, or NULL if it
 // hit an ending token.

 // caller eats leading spaces

 // parse next word from command line. Returns end, or 0 if need continuation
 static char *parse_word(char *start)
 {
   int i, quote = 0;
   char *end = start, *s;

   // find end of string

   while (*end) {
     i = 0;

     // Handle quote contexts
     if (quote) {
       // end quote, skip quoted chars
       if (*end == toybuf[quote-1]) quote--, end++;
       else if (toybuf[quote-1] == '"' && *end == '`') toybuf[quote++] = *end++;
       else if (toybuf[quote-1] == '\'' || isspace(*end)) end++;
       else i++;
     } else {
       if (isspace(*end)) break;
       // start quote
       if (strchr("\"'`", *end)) toybuf[quote++] = *end++;
       else if (strstart(&end, "<(") || strstart(&end,">(")) toybuf[quote++]=')';
       else if (*end==')') return end+(end==start);
       else {
         // control chars
         for (s = end; strchr(";|&<>(", *s); s++);
         if (s != end) return (end == start) ? s : end;
         i++;
       }
     }

     // loop if we already handled a symbol
     if (!i) continue;

     // Things the same unquoted or in double quotes

     // backslash escapes
     if (*end == '\\') {
       if (!end[1]) return 0;
       end += 2;
     } else if (*end == '$') {
       // barf if we're near overloading quote stack (nesting ridiculously deep)
       if (quote>4000) {
         syntax_err("tilt");
         return (void *)1;
       }
       end++;
       if (strstart(&end, "((")) {
         // all we care about here are parentheses matching and then ending ))
         for (i = 0;;) {
           if (!*end) return 0;
           if (!i && strstart(&end, "))")) break;
           if (*end == '(') i++;
           else if (*end == ')') i--;
         }
       } else if (-1 != (i = stridx("({[", *end))) {
         toybuf[quote++] = ")}]"[i];
         end++;
       }
     } else end++;
   }

   return quote ? 0 : end;
 }

 // Consume a line of shell script and do what it says. Returns 0 if finished,
 // pointer to start of unused part of line if it needs another line of input.
 static char *parse_line(char *line, struct double_list **pipeline)
 {
   char *start = line, *end, *s, *ex, *add;
   struct sh_arg *arg = 0;
   struct double_list *pl, *expect = 0;
   unsigned i, paren = 0;

   // Resume appending to last pipeline's last argument list
   if (*pipeline) arg = (void *)(*pipeline)->prev->data;
   if (arg) for (i = 0; i<arg->c; i++) {
     if (!strcmp(arg->v[i], "(")) paren++;
     else if (!strcmp(arg->v[i], ")")) paren--;
   }

   // Loop handling each word
   for (;;) {
     // Skip leading whitespace/comment
     while (isspace(*start)) ++start;
     if (*start=='#') {
       while (*start && *start != '\n') start++;
       continue;
     }

     // Parse next word and detect continuation/overflow.
     if ((end = parse_word(start)) == (void *)1) return 0;
     if (!end) return start;

     // Extend pipeline and argv[], handle EOL
     if (!arg)
       dlist_add(pipeline, (void *)(arg = xzalloc(sizeof(struct sh_arg))));
     if (!(31&arg->c)) arg->v = xrealloc(arg->v, (32+arg->c)*sizeof(void *));
     if (end == start) {
       arg->v[arg->c] = 0;
       break;
     }

     // Save argument (strdup) and check if it's special
     s = arg->v[arg->c] = xstrndup(start, end-start);
     if (!strcmp(s, "(")) paren++;
     else if (!strcmp(s, ")") && !paren--) syntax_err("bad %s", s);
     if (paren || !strchr(";|&", *start)) arg->c++;
     else {
       if (!arg->c) {
         syntax_err("bad %s", arg->v[arg->c]);
         goto flush;
       }
       arg = 0;
     }
     start = end;
   }

   // We parsed to the end of the line, which ended a pipeline.
   // Now handle flow control commands, which can also need more lines.

   // array of command lines separated by | and such
   // Note: don't preparse past ; because environment variables differ

   // Check for flow control continuations
   end = 0;
   for (pl = *pipeline; pl ; pl = (pl->next == *pipeline) ? 0 : pl->next) {
     arg = (void *)pl->data;
     if (!arg->c) continue;
     add = 0;

     // parse flow control statements in this command line
     for (i = 0; ; i++) {
       ex = expect ? expect->prev->data : 0;
       s = arg->v[i];

       // push word to expect to end this block, and expect a command first
       if (add) {
         dlist_add(&expect, add);
         dlist_add(&expect, add = 0);
       }

       // end of statement?
       if (i == arg->c) break;

       // When waiting for { it must be next symbol, but can be on a new line.
       if (ex && !strcmp(ex, "{") && (strcmp(s, "{") || (!i && end))) {
         syntax_err("need {");
         goto flush;
       }

       if (!strcmp(s, "if")) add = "then";
       else if (!strcmp(s, "for") || !strcmp(s, "select")
           || !strcmp(s, "while") || !strcmp(s, "until")) add = "do";
       else if (!strcmp(s, "case")) add = "esac";
       else if (!strcmp(s, "{")) add = "}";
       else if (!strcmp(s, "[[")) add = "]]";

       // function NAME () [nl] { [nl] body ; }
       // Why can you to declare functions inside other functions?
       else if (arg->c>i+1 && !strcmp(arg->v[i+1], "(")) goto funky;
       else if (!strcmp(s, "function")) {
         i++;
 funky:
         // At this point we can only have a function: barf if it's invalid
         if (arg->c<i+3 || !strcmp(arg->v[i+1], "(")
             || !strcmp(arg->v[i+2], ")"))
         {
           syntax_err("bad function ()");
           goto flush;
         }
         dlist_add(&expect, "}");
         dlist_add(&expect, 0);
         dlist_add(&expect, "{");

       // Expecting NULL will take any otherwise unrecognized word
       } else if (expect && !ex) {
         free(dlist_pop(&expect));
         continue;

       // If we expect nothing and didn't just start a new flow control block,
       // rest of statement is a command and arguments, so stop now
       } else if (!ex) break;

       if (add) continue;

       // If we got here we expect a word to end this block: is this it?
       if (!strcmp(arg->v[i], ex)) {
         free(dlist_pop(&expect));

         // can't "if | then" or "while && do", only ; or newline works
         if (end && !strcmp(end, ";")) {
           syntax_err("bad %s", end);
           goto flush;
         }

         // if it's a multipart block, what comes next?
         if (!strcmp(s, "do")) ex = "done";
         else if (!strcmp(s, "then")) add = "fi\0A";
       // fi could have elif, which queues a then.
       } else if (!strcmp(ex, "fi")) {
         if (!strcmp(s, "elif")) {
           free(dlist_pop(&expect));
           add = "then";
         // catch duplicate else while we're here
         } else if (!strcmp(s, "else")) {
           if (ex[3] != 'A') {
             syntax_err("2 else");
             goto flush;
           }
           free(dlist_pop(&expect));
           add = "fi\0B";
         }
       }
     }
     // Record how the previous stanza ended: ; | & ;; || && ;& ;;& |& NULL
     end = arg->v[arg->c];
   }

   // Do we need more lines to finish a flow control statement?
   if (expect || paren) {
     llist_traverse(expect, free);
     return start;
   }

   // iterate through the commands running each one
   for (pl = *pipeline; pl ; pl = (pl->next == *pipeline) ? 0 : pl->next) {
     struct sh_process *pp = xzalloc(sizeof(struct sh_process));

     for (i = 0; i<((struct sh_arg *)pl->data)->c; i++)
       expand_arg(&pp->arg, ((struct sh_arg *)pl->data)->v[i]);
     run_command(pp);
   }

 flush:
   while ((pl = dlist_pop(pipeline))) {
     arg = (void *)pl->data;
     free(pl);
     for (i = 0; i<arg->c; i++) free(arg->v[i]);
     free(arg->v);
     free(arg);
   }
   *pipeline = 0;

   return 0;
 }

 void sh_main(void)
 {
   FILE *f = 0;
   char *command = 0, *old = 0;
   struct double_list *scratch = 0;

   // Set up signal handlers and grab control of this tty.
   if (isatty(0)) toys.optflags |= FLAG_i;

   if (*toys.optargs) f = xfopen(*toys.optargs, "r");
   if (TT.command) command = parse_line(TT.command, &scratch);
   else for (;;) {
     char *new = 0;
     size_t linelen = 0;

     // Prompt and read line
     if (!f) {
       char *s = getenv(command ? "PS2" : "PS1");

       if (!s) s = command ? "> " : (getpid() ? "\\$ " : "# ");
       do_prompt(s);
     }
     if (1 > getline(&new, &linelen, f ? f : stdin)) break;
     if (f) TT.lineno++;

     // Append to unused portion of previous line if any
     if (command) {
       command = xmprintf("%s%s", command, new);
       free(old);
       free(new);
       old = command;
     } else {
       free(old);
       old = new;
     }

     // returns 0 if line consumed, command if it needs more data
     command = parse_line(old, &scratch);
   }

   if (command) error_exit("unfinished line");
   toys.exitval = f && ferror(f);
 }
	/* sh.c - toybox shell
	*
	* Copyright 2006 Rob Landley <rob@landley.net>
	*
	* The POSIX-2008/SUSv4 spec for this is at:
	* http://opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html
	* and http://opengroup.org/onlinepubs/9699919799/utilities/sh.html
	*
	* The first link describes the following shell builtins:
	*
	* break colon continue dot eval exec exit export readonly return set shift
	* times trap unset
	*
	* The second link (the utilities directory) also contains specs for the
	* following shell builtins:
	*
	* alias bg cd command fc fg getopts hash jobs kill read type ulimit
	* umask unalias wait
	*
	* Things like the bash man page are good to read too.

	USE_SH(NEWTOY(cd, NULL, TOYFLAG_NOFORK))
	USE_SH(NEWTOY(exit, NULL, TOYFLAG_NOFORK))

	USE_SH(NEWTOY(sh, "c:i", TOYFLAG_BIN))
	USE_SH(OLDTOY(toysh, sh, TOYFLAG_BIN))
	// Login lies in argv[0], so add some aliases to catch that
	USE_SH(OLDTOY(-sh, sh, 0))
	USE_SH(OLDTOY(-toysh, sh, 0))

	config SH
	bool "sh (toysh)"
	default n
	help
	usage: sh [-c command] [script]

	Command shell. Runs a shell script, or reads input interactively
	and responds to it.

	-c command line to execute
	-i interactive mode (default when STDIN is a tty)

	# These are here for the help text, they're not selectable and control nothing
	config CD
	bool
	default n
	depends on SH
	help
	usage: cd [-PL] [path]

	Change current directory. With no arguments, go $HOME.

	-P Physical path: resolve symlinks in path
	-L Local path: .. trims directories off $PWD (default)

	config EXIT
	bool
	default n
	depends on SH
	help
	usage: exit [status]

	Exit shell. If no return value supplied on command line, use value
	of most recent command, or 0 if none.
	*/

	#define FOR_sh
	#include "toys.h"

	GLOBALS(
	char *command;

	long lineno;

	// parse scratch space
	struct double_list *parse;

	// Running jobs.
	struct sh_job {
	struct sh_job next, prev;
	unsigned jobno;

	// Every pipeline has at least one set of arguments or it's Not A Thing
	struct sh_arg {
	char **v;
	unsigned long c;
	} pipeline;

	// null terminated array of running processes in pipeline
	struct sh_process {
	struct string_list *delete; // expanded strings
	int pid, exit; // status? Stopped? Exited?
	char *end;
	struct sh_arg arg;
	} procs, proc;
	} jobs, job;
	unsigned jobcnt;
	)

	void cd_main(void)
	{
	char dest = toys.optargs ? *toys.optargs : getenv("HOME");

	xchdir(dest ? dest : "/");
	}

	void exit_main(void)
	{
	exit(toys.optargs ? atoi(toys.optargs) : 0);
	}

	// Print prompt, parsing escapes
	static void do_prompt(char *prompt)
	{
	char *s, c, cc;

	if (!prompt) prompt = "\\$ ";
	while (*prompt) {
	c = *(prompt++);

	if (c=='!') {
	if (*prompt=='!') prompt++;
	else {
	printf("%ld", TT.lineno);
	continue;
	}
	} else if (c=='\\') {
	int i = 0;

	cc = *(prompt++);
	if (!cc) goto down;

	// \nnn \dD{}hHjlstT@AuvVwW!#$
	// Ignore bash's "nonprintable" hack; query our cursor position instead.
	if (cc=='[' \|\| cc==']') continue;
	else if (cc=='$') putchar(getuid() ? '$' : '#');
	else if (cc=='h' \|\| cc=='H') {
	*toybuf = 0;
	gethostname(toybuf, sizeof(toybuf)-1);
	if (cc=='h' && (s = strchr(toybuf, '.'))) *s = 0;
	fputs(toybuf, stdout);
	} else if (cc=='s') fputs(getbasename(*toys.argv), stdout);
	else {
	if (!(c = unescape(cc))) {
	c = '\\';
	prompt--;
	}
	i++;
	}
	if (!i) continue;
	}
	down:
	putchar(c);
	}
	fflush(stdout);
	}

	// Execute the commands in a pipeline
	static void run_command(struct sh_process *pp)
	{
	struct toy_list tl = toy_find(pp->arg.v);

	// Is this command a builtin that should run in this process?
	if (tl && (tl->flags & TOYFLAG_NOFORK)) {
	struct toy_context temp;
	sigjmp_buf rebound;

	// This fakes lots of what toybox_main() does.
	memcpy(&temp, &toys, sizeof(struct toy_context));
	memset(&toys, 0, sizeof(struct toy_context));

	if (!sigsetjmp(rebound, 1)) {
	toys.rebound = &rebound;
	toy_init(tl, pp->arg.v);
	tl->toy_main();
	}
	pp->exit = toys.exitval;
	if (toys.optargs != toys.argv+1) free(toys.optargs);
	if (toys.old_umask) umask(toys.old_umask);
	memcpy(&toys, &temp, sizeof(struct toy_context));
	} else {
	int pipe[2];

	pipe[0] = 0;
	pipe[1] = 1;
	if (-1 == (pp->pid = xpopen_both(pp->arg.v, pipe)))
	perror_msg("%s: vfork", *pp->arg.v);
	else pp->exit = xpclose_both(pp->pid, 0);
	}

	return;
	}

	// todo: ${name:?error} causes an error/abort here (syntax_err longjmp?)
	static void expand_arg(struct sh_arg arg, char new)
	{
	if (!(arg->c&32)) arg->v = xrealloc(arg->v, sizeof(void )(arg->c+33));

	arg->v[arg->c++] = new;
	arg->v[arg->c] = 0;
	}

	// like error_msg() but exit from shell scripts
	void syntax_err(char *msg, ...)
	{
	va_list va;

	va_start(va, msg);
	verror_msg(msg, 0, va);
	va_end(va);

	if (*toys.optargs) xexit();
	}


	// Parse one word from the command line, appending one or more argv[] entries
	// to struct command. Handles environment variable substitution and
	// substrings. Returns pointer to next used byte, or NULL if it
	// hit an ending token.

	// caller eats leading spaces

	// parse next word from command line. Returns end, or 0 if need continuation
	static char parse_word(char start)
	{
	int i, quote = 0;
	char end = start, s;

	// find end of string

	while (*end) {
	i = 0;

	// Handle quote contexts
	if (quote) {
	// end quote, skip quoted chars
	if (*end == toybuf[quote-1]) quote--, end++;
	else if (toybuf[quote-1] == '"' && end == '`') toybuf[quote++] = end++;
	else if (toybuf[quote-1] == '\'' \|\| isspace(*end)) end++;
	else i++;
	} else {
	if (isspace(*end)) break;
	// start quote
	if (strchr("\"'`", end)) toybuf[quote++] = end++;
	else if (strstart(&end, "<(") \|\| strstart(&end,">(")) toybuf[quote++]=')';
	else if (*end==')') return end+(end==start);
	else {
	// control chars
	for (s = end; strchr(";\|&<>(", *s); s++);
	if (s != end) return (end == start) ? s : end;
	i++;
	}
	}

	// loop if we already handled a symbol
	if (!i) continue;

	// Things the same unquoted or in double quotes

	// backslash escapes
	if (*end == '\\') {
	if (!end[1]) return 0;
	end += 2;
	} else if (*end == '$') {
	// barf if we're near overloading quote stack (nesting ridiculously deep)
	if (quote>4000) {
	syntax_err("tilt");
	return (void *)1;
	}
	end++;
	if (strstart(&end, "((")) {
	// all we care about here are parentheses matching and then ending ))
	for (i = 0;;) {
	if (!*end) return 0;
	if (!i && strstart(&end, "))")) break;
	if (*end == '(') i++;
	else if (*end == ')') i--;
	}
	} else if (-1 != (i = stridx("({[", *end))) {
	toybuf[quote++] = ")}]"[i];
	end++;
	}
	} else end++;
	}

	return quote ? 0 : end;
	}

	// Consume a line of shell script and do what it says. Returns 0 if finished,
	// pointer to start of unused part of line if it needs another line of input.
	static char parse_line(char line, struct double_list **pipeline)
	{
	char start = line, end, s, ex, *add;
	struct sh_arg *arg = 0;
	struct double_list pl, expect = 0;
	unsigned i, paren = 0;

	// Resume appending to last pipeline's last argument list
	if (pipeline) arg = (void )(*pipeline)->prev->data;
	if (arg) for (i = 0; i<arg->c; i++) {
	if (!strcmp(arg->v[i], "(")) paren++;
	else if (!strcmp(arg->v[i], ")")) paren--;
	}

	// Loop handling each word
	for (;;) {
	// Skip leading whitespace/comment
	while (isspace(*start)) ++start;
	if (*start=='#') {
	while (start && start != '\n') start++;
	continue;
	}

	// Parse next word and detect continuation/overflow.
	if ((end = parse_word(start)) == (void *)1) return 0;
	if (!end) return start;

	// Extend pipeline and argv[], handle EOL
	if (!arg)
	dlist_add(pipeline, (void *)(arg = xzalloc(sizeof(struct sh_arg))));
	if (!(31&arg->c)) arg->v = xrealloc(arg->v, (32+arg->c)sizeof(void ));
	if (end == start) {
	arg->v[arg->c] = 0;
	break;
	}

	// Save argument (strdup) and check if it's special
	s = arg->v[arg->c] = xstrndup(start, end-start);
	if (!strcmp(s, "(")) paren++;
	else if (!strcmp(s, ")") && !paren--) syntax_err("bad %s", s);
	if (paren \|\| !strchr(";\|&", *start)) arg->c++;
	else {
	if (!arg->c) {
	syntax_err("bad %s", arg->v[arg->c]);
	goto flush;
	}
	arg = 0;
	}
	start = end;
	}

	// We parsed to the end of the line, which ended a pipeline.
	// Now handle flow control commands, which can also need more lines.

	// array of command lines separated by \| and such
	// Note: don't preparse past ; because environment variables differ

	// Check for flow control continuations
	end = 0;
	for (pl = pipeline; pl ; pl = (pl->next == pipeline) ? 0 : pl->next) {
	arg = (void *)pl->data;
	if (!arg->c) continue;
	add = 0;

	// parse flow control statements in this command line
	for (i = 0; ; i++) {
	ex = expect ? expect->prev->data : 0;
	s = arg->v[i];

	// push word to expect to end this block, and expect a command first
	if (add) {
	dlist_add(&expect, add);
	dlist_add(&expect, add = 0);
	}

	// end of statement?
	if (i == arg->c) break;

	// When waiting for { it must be next symbol, but can be on a new line.
	if (ex && !strcmp(ex, "{") && (strcmp(s, "{") \|\| (!i && end))) {
	syntax_err("need {");
	goto flush;
	}

	if (!strcmp(s, "if")) add = "then";
	else if (!strcmp(s, "for") \|\| !strcmp(s, "select")
	\|\| !strcmp(s, "while") \|\| !strcmp(s, "until")) add = "do";
	else if (!strcmp(s, "case")) add = "esac";
	else if (!strcmp(s, "{")) add = "}";
	else if (!strcmp(s, "[[")) add = "]]";

	// function NAME () [nl] { [nl] body ; }
	// Why can you to declare functions inside other functions?
	else if (arg->c>i+1 && !strcmp(arg->v[i+1], "(")) goto funky;
	else if (!strcmp(s, "function")) {
	i++;
	funky:
	// At this point we can only have a function: barf if it's invalid
	if (arg->c<i+3 \|\| !strcmp(arg->v[i+1], "(")
	\|\| !strcmp(arg->v[i+2], ")"))
	{
	syntax_err("bad function ()");
	goto flush;
	}
	dlist_add(&expect, "}");
	dlist_add(&expect, 0);
	dlist_add(&expect, "{");

	// Expecting NULL will take any otherwise unrecognized word
	} else if (expect && !ex) {
	free(dlist_pop(&expect));
	continue;

	// If we expect nothing and didn't just start a new flow control block,
	// rest of statement is a command and arguments, so stop now
	} else if (!ex) break;

	if (add) continue;

	// If we got here we expect a word to end this block: is this it?
	if (!strcmp(arg->v[i], ex)) {
	free(dlist_pop(&expect));

	// can't "if \| then" or "while && do", only ; or newline works
	if (end && !strcmp(end, ";")) {
	syntax_err("bad %s", end);
	goto flush;
	}

	// if it's a multipart block, what comes next?
	if (!strcmp(s, "do")) ex = "done";
	else if (!strcmp(s, "then")) add = "fi\0A";
	// fi could have elif, which queues a then.
	} else if (!strcmp(ex, "fi")) {
	if (!strcmp(s, "elif")) {
	free(dlist_pop(&expect));
	add = "then";
	// catch duplicate else while we're here
	} else if (!strcmp(s, "else")) {
	if (ex[3] != 'A') {
	syntax_err("2 else");
	goto flush;
	}
	free(dlist_pop(&expect));
	add = "fi\0B";
	}
	}
	}
	// Record how the previous stanza ended: ; \| & ;; \|\| && ;& ;;& \|& NULL
	end = arg->v[arg->c];
	}

	// Do we need more lines to finish a flow control statement?
	if (expect \|\| paren) {
	llist_traverse(expect, free);
	return start;
	}

	// iterate through the commands running each one
	for (pl = pipeline; pl ; pl = (pl->next == pipeline) ? 0 : pl->next) {
	struct sh_process *pp = xzalloc(sizeof(struct sh_process));

	for (i = 0; i<((struct sh_arg *)pl->data)->c; i++)
	expand_arg(&pp->arg, ((struct sh_arg *)pl->data)->v[i]);
	run_command(pp);
	}

	flush:
	while ((pl = dlist_pop(pipeline))) {
	arg = (void *)pl->data;
	free(pl);
	for (i = 0; i<arg->c; i++) free(arg->v[i]);
	free(arg->v);
	free(arg);
	}
	*pipeline = 0;

	return 0;
	}

	void sh_main(void)
	{
	FILE *f = 0;
	char command = 0, old = 0;
	struct double_list *scratch = 0;

	// Set up signal handlers and grab control of this tty.
	if (isatty(0)) toys.optflags \|= FLAG_i;

	if (toys.optargs) f = xfopen(toys.optargs, "r");
	if (TT.command) command = parse_line(TT.command, &scratch);
	else for (;;) {
	char *new = 0;
	size_t linelen = 0;

	// Prompt and read line
	if (!f) {
	char *s = getenv(command ? "PS2" : "PS1");

	if (!s) s = command ? "> " : (getpid() ? "\\$ " : "# ");
	do_prompt(s);
	}
	if (1 > getline(&new, &linelen, f ? f : stdin)) break;
	if (f) TT.lineno++;

	// Append to unused portion of previous line if any
	if (command) {
	command = xmprintf("%s%s", command, new);
	free(old);
	free(new);
	old = command;
	} else {
	free(old);
	old = new;
	}

	// returns 0 if line consumed, command if it needs more data
	command = parse_line(old, &scratch);
	}

	if (command) error_exit("unfinished line");
	toys.exitval = f && ferror(f);
	}