From 7fceed5f75c9c082b2bc5f47be816e69524f63af Mon Sep 17 00:00:00 2001
From: Rob Landley <rob@landley.net>
Date: Tue, 25 Jun 2019 14:32:36 -0500
Subject: Start over on toysh.

Basic line continuation logic (to prompt with $PS2). Doesn't use result yet.
---
 toys/pending/sh.c | 484 ++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 309 insertions(+), 175 deletions(-)

(limited to 'toys/pending/sh.c')

diff --git a/toys/pending/sh.c b/toys/pending/sh.c
index 8a9e93b6..8c898cd5 100644
--- a/toys/pending/sh.c
+++ b/toys/pending/sh.c
@@ -18,24 +18,6 @@
  *   umask unalias wait
  *
  * Things like the bash man page are good to read too.
- *
- * TODO: "make sh" doesn't work (nofork builtins need to be included)
- * TODO: test that $PS1 color changes work without stupid \[ \] hack
- * TODO: make fake pty wrapper for test infrastructure
- * TODO: // Handle embedded NUL bytes in the command line.
- * TODO: var=val command
- * existing but considered builtins: false kill pwd true
- * buitins: alias bg command fc fg getopts jobs newgrp read umask unalias wait
- * "special" builtins: break continue : . eval exec export readonly return set
- *   shift times trap unset
- * | & ; < > ( ) $ ` \ " ' <space> <tab> <newline>
- * * ? [ # ~ = %
- * ! { } case do done elif else esac fi for if in then until while
- * [[ ]] function select
- * $@ $* $# $? $- $$ $! $0
- * ENV HOME IFS LANG LC_ALL LINENO PATH PPID PS1 PS2 PS4 PWD
- * label:
- * TODO: test exit from "trap EXIT" doesn't recurse
 
 USE_SH(NEWTOY(cd, NULL, TOYFLAG_NOFORK))
 USE_SH(NEWTOY(exit, NULL, TOYFLAG_NOFORK))
@@ -58,6 +40,7 @@ config SH
     -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
@@ -88,25 +71,31 @@ GLOBALS(
   char *command;
 
   long lineno;
-)
 
-// What we know about a single process.
-struct command {
-  struct command *next;
-  int flags;              // exit, suspend, && ||
-  int pid;                // pid (or exit code)
-  int argc;
-  char *argv[0];
-};
-
-// A collection of processes piped into/waiting on each other.
-struct pipeline {
-  struct pipeline *next;
-  int job_id;
-  struct command *cmd;
-  char *cmdline;         // Unparsed line for display purposes
-  int cmdlinelen;        // How long is cmdline?
-};
+  // 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)
 {
@@ -120,87 +109,56 @@ void exit_main(void)
   exit(*toys.optargs ? atoi(*toys.optargs) : 0);
 }
 
-// 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.
-static char *parse_word(char *start, struct command **cmd)
-{
-  char *end;
-
-  // Detect end of line (and truncate line at comment)
-  if (strchr("><&|(;", *start)) return 0;
-
-  // Grab next word.  (Add dequote and envvar logic here)
-  end = start;
-  while (*end && !isspace(*end)) end++;
-  (*cmd)->argv[(*cmd)->argc++] = xstrndup(start, end-start);
-
-  // Allocate more space if there's no room for NULL terminator.
-
-  if (!((*cmd)->argc & 7))
-    *cmd=xrealloc(*cmd,
-        sizeof(struct command) + ((*cmd)->argc+8)*sizeof(char *));
-  (*cmd)->argv[(*cmd)->argc] = 0;
-  return end;
-}
-
-// Parse a line of text into a pipeline.
-// Returns a pointer to the next line.
-
-static char *parse_pipeline(char *cmdline, struct pipeline *line)
+// Print prompt, parsing escapes
+static void do_prompt(char *prompt)
 {
-  struct command **cmd = &(line->cmd);
-  char *start = line->cmdline = cmdline;
-
-  if (!cmdline) return 0;
+  char *s, c, cc;
 
-  line->cmdline = cmdline;
-
-  // Parse command into argv[]
-  for (;;) {
-    char *end;
-
-    // Skip leading whitespace and detect end of line.
-    while (isspace(*start)) start++;
-    if (!*start || *start=='#') {
-      line->cmdlinelen = start-cmdline;
-      return 0;
-    }
+  if (!prompt) prompt = "\\$ ";
+  while (*prompt) {
+    c = *(prompt++);
 
-    // Allocate next command structure if necessary
-    if (!*cmd) *cmd = xzalloc(sizeof(struct command)+8*sizeof(char *));
+    if (c=='!') {
+      if (*prompt=='!') prompt++;
+      else {
+        printf("%ld", TT.lineno);
+        continue;
+      }
+    } else if (c=='\\') {
+      int i = 0;
 
-    // Parse next argument and add the results to argv[]
-    end = parse_word(start, cmd);
+      cc = *(prompt++);
+      if (!cc) goto down;
 
-    // If we hit the end of this command, how did it end?
-    if (!end) {
-      if (*start) {
-        if (*start==';') {
-          start++;
-          break;
+      // \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--;
         }
-        // handle | & < > >> << || &&
+        i++;
       }
-      break;
+      if (!i) continue;
     }
-    start = end;
+down:
+    putchar(c);
   }
-
-  line->cmdlinelen = start-cmdline;
-
-  return start;
+  fflush(stdout);
 }
 
 // Execute the commands in a pipeline
-static void run_pipeline(struct pipeline *line)
+static void run_command(struct sh_process *pp)
 {
-  struct toy_list *tl;
-  struct command *cmd = line->cmd;
-  if (!cmd || !cmd->argc) return;
-
-  tl = toy_find(cmd->argv[0]);
+  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)) {
@@ -213,123 +171,299 @@ static void run_pipeline(struct pipeline *line)
 
     if (!sigsetjmp(rebound, 1)) {
       toys.rebound = &rebound;
-      toy_init(tl, cmd->argv);
+      toy_init(tl, pp->arg.v);
       tl->toy_main();
     }
-    cmd->pid = toys.exitval;
+    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 status;
+    int pipe[2];
 
-    cmd->pid = vfork();
-    if (!cmd->pid) xexec(cmd->argv);
-    else waitpid(cmd->pid, &status, 0);
-
-    if (WIFEXITED(status)) cmd->pid = WEXITSTATUS(status);
-    if (WIFSIGNALED(status)) cmd->pid = WTERMSIG(status);
+    pipe[0] = 0;
+    pipe[1] = 1;
+    if (-1 == (pp->pid = xpopen_both(pp->arg.v, pipe)))
+      perror_msg("%s: not found", *pp->arg.v);
+    else pp->exit = xpclose_both(pp->pid, 0);
   }
 
   return;
 }
 
-// Free the contents of a command structure
-static void free_cmd(void *data)
+// todo: ${name:?error} causes an error/abort here (syntax_err longjmp?)
+static void expand_arg(struct sh_arg *arg, char *new)
 {
-  struct command *cmd=(struct command *)data;
+  if (!(arg->c&32)) arg->v = xrealloc(arg->v, sizeof(void *)*(arg->c+33));
 
-  while(cmd->argc) free(cmd->argv[--cmd->argc]);
+  arg->v[arg->c++] = new;
+  arg->v[arg->c] = 0;
 }
 
-
-// Parse a command line and do what it says to do.
-static void handle(char *command)
+// like error_msg() but exit from shell scripts
+void syntax_err(char *msg, ...)
 {
-  struct pipeline line;
-  char *start = command;
+  va_list va;
 
-  // Loop through commands in this line
+  va_start(va, msg);
+  verror_msg(msg, 0, va);
+  va_end(va);
 
-  for (;;) {
+  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 a group of connected commands
+// 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++;
+      }
+    }
 
-    memset(&line,0,sizeof(struct pipeline));
-    start = parse_pipeline(start, &line);
-    if (!line.cmd) break;
+    // loop if we already handled a symbol
+    if (!i) continue;
 
-    // Run those commands
+    // Things the same unquoted or in double quotes
 
-    run_pipeline(&line);
-    llist_traverse(line.cmd, free_cmd);
+    // 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;
 }
 
-static void do_prompt(void)
+// 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 *prompt = getenv("PS1"), *s, c, cc;
+  char *start = line, *end, *s;
+  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--;
+  }
 
-  if (!prompt) prompt = "\\$ ";
-  while (*prompt) {
-    c = *(prompt++);
+  // Loop handling each word
+  for (;;) {
+    // Skip leading whitespace/comment
+    while (isspace(*start)) ++start;
+    if (*start=='#') {
+      while (*start && *start != '\n') start++;
+      continue;
+    }
 
-    if (c=='!') {
-      if (*prompt=='!') prompt++;
-      else {
-        printf("%ld", TT.lineno);
-        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;
       }
-    } else if (c=='\\') {
-      cc = *(prompt++);
-      if (!cc) goto down;
+      arg = 0;
+    }
+    start = end;
+  }
 
-      // \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--;
+  // 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;
+
+    // parse flow control statements in this command line
+    for (i = 0; i<arg->c; i++) {
+      char *ex = expect ? expect->prev->data : 0;
+
+      s = arg->v[i];
+      if (!strcmp(s, "if")) ex = "then";
+      else if (!strcmp(s, "for") || !strcmp(s, "select")
+          || !strcmp(s, "while") || !strcmp(s, "until")) ex = "do";
+      else if (!strcmp(s, "case")) ex = "esac";
+      else if (!strcmp(s, "{")) ex = "}";
+      else if (!strcmp(s, "[[")) ex = "]]";
+
+      // If we expect a non-flow-control command, eat rest of line
+      else if (expect && !ex) {
+        free(dlist_pop(&expect));
+        continue;
+
+      // Did we find a specific word we were waiting for?
+      } else if (ex && !strcmp(arg->v[i], ex)) {
+        free(dlist_pop(&expect));
+        if (end && !strcmp(end, ";")) {
+          // can't if | then or while && do, only ; or newline counts
+          syntax_err("bad %s", end);
+          goto flush;
+        }
+        if (!strcmp(s, "do")) dlist_add(&expect, "done");
+        else if (!strcmp(s, "then")) dlist_add(&expect, "fi\0A");
+        break;
+      // fi could have elif, which queues a then.
+      } else if (ex && !strcmp(ex, "fi")) {
+        if (!strcmp(s, "elif")) {
+          free(dlist_pop(&expect));
+          dlist_add(&expect, "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));
+          dlist_add(&expect, "fi\0B");
         }
+      } else break;
 
-        goto down;
-      }
-      continue;
+      dlist_add(&expect, ex);
     }
-down:
-    putchar(c);
+    // Record how the previous stanza ended
+    end = arg->v[arg->c];
+  }
+
+  // If we need more lines to finish flow control...
+  // TODO: functions
+  if (expect) {
+    llist_traverse(expect, free);
+    return start;
   }
+
+  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) handle(xstrdup(TT.command));
-  else {
-    size_t cmdlen = 0;
-    for (;;) {
-      char *command = 0;
-
-      // TODO: parse escapes in prompt
-      if (!f) do_prompt();
-      if (1 > getline(&command, &cmdlen, f ? f : stdin)) break;
-      handle(command);
-      free(command);
+  if (TT.command) command = parse_line(TT.command, &scratch);
+  else for (;;) {
+    char *new = 0;
+    size_t linelen = 0;
+
+    // Prompt and read line
+    if (!f) do_prompt(getenv(command ? "PS2" : "PS1"));
+    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);
   }
 
-  toys.exitval = 1;
+  if (command) error_exit("unfinished line");
+  toys.exitval = f && ferror(f);
 }
-- 
cgit v1.2.3