hush: preparatory patch for removing extra empty pipes generation

in parse stage. No real code change here.

1 files changed, 90 insertions, 80 deletions

diff --git a/shell/hush.c b/shell/hush.c
index 78531e864..eb6f37f15 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -125,10 +125,10 @@ static const char *indenter(int i)
 #define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
 #endif
 
-#define SPECIAL_VAR_SYMBOL 03
-#define FLAG_EXIT_FROM_LOOP 1
+#define SPECIAL_VAR_SYMBOL   3
+#define FLAG_EXIT_FROM_LOOP  1
 #define FLAG_PARSE_SEMICOLON (1 << 1)           /* symbol ';' is special for parser */
-#define FLAG_REPARSING       (1 << 2)           /* >=2nd pass */
+#define FLAG_REPARSING       (1 << 2)           /* >= 2nd pass */
 
 typedef enum {
         REDIRECT_INPUT     = 1,
@@ -199,10 +199,10 @@ struct p_context {
         struct pipe *list_head;
         struct pipe *pipe;
         struct redir_struct *pending_redirect;
-        reserved_style w;
-        int old_flag;               /* for figuring out valid reserved words */
+        reserved_style res_w;
+        int old_flag;           /* for figuring out valid reserved words */
         struct p_context *stack;
-        int type;           /* define type of parser : ";$" common or special symbol */
+        int parse_type;         /* define type of parser : ";$" common or special symbol */
         /* How about quoting status? */
 };
 
@@ -410,8 +410,8 @@ static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *i
 static int parse_string(o_string *dest, struct p_context *ctx, const char *src);
 static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, const char *end_trigger);
 /*   setup: */
-static int parse_stream_outer(struct in_str *inp, int flag);
-static int parse_string_outer(const char *s, int flag);
+static int parse_stream_outer(struct in_str *inp, int parse_flag);
+static int parse_string_outer(const char *s, int parse_flag);
 static int parse_file_outer(FILE *f);
 /*   job management: */
 static int checkjobs(struct pipe* fg_pipe);
@@ -1854,23 +1854,24 @@ static void debug_print_tree(struct pipe *pi, int lvl)
         };
 
         int pin, prn;
-        char **argv;
         pin = 0;
         while (pi) {
                 fprintf(stderr, "%*spipe %d r_mode=%s followup=%d %s\n", lvl*2, "",
                                 pin, RES[pi->r_mode], pi->followup, PIPE[pi->followup]);
                 prn = 0;
                 while (prn < pi->num_progs) {
+                        struct child_prog *child = &pi->progs[prn];
+                        char **argv = child->argv;
+
                         fprintf(stderr, "%*s prog %d", lvl*2, "", prn);
-                        if (pi->progs[prn].group) {
+                        if (child->group) {
                                 fprintf(stderr, " group %s: (argv=%p)\n",
-                                                (pi->subshell ? "()" : "{}"),
-                                                pi->progs[prn].argv);
-                                debug_print_tree(pi->progs[prn].group, lvl+1);
+                                                (child->subshell ? "()" : "{}"),
+                                                argv);
+                                debug_print_tree(child->group, lvl+1);
                                 prn++;
                                 continue;
                         }
-                        argv = pi->progs[prn].argv;
                         if (argv) while (*argv) {
                                 fprintf(stderr, " '%s'", *argv);
                                 argv++;
@@ -1901,7 +1902,7 @@ static int run_list_real(struct pipe *pi)
         int flag_rep = 0;
         int save_num_progs;
         int flag_skip = 1;
-        int rcode = 0; /* probaly for gcc only */
+        int rcode = 0; /* probably for gcc only */
         int flag_restore = 0;
         int if_code = 0, next_if_code = 0;  /* need double-buffer to handle elif */
         reserved_style rmode, skip_more_in_this_rmode = RES_XXXX;
@@ -1968,17 +1969,15 @@ static int run_list_real(struct pipe *pi)
         }
 #endif
 
-        for (; pi; pi = (flag_restore != 0) ? rpipe : pi->next) {
-                if (pi->r_mode == RES_WHILE || pi->r_mode == RES_UNTIL
-                 || pi->r_mode == RES_FOR
-                ) {
+        for (; pi; pi = flag_restore ? rpipe : pi->next) {
+                rmode = pi->r_mode;
+                if (rmode == RES_WHILE || rmode == RES_UNTIL || rmode == RES_FOR) {
                         flag_restore = 0;
                         if (!rpipe) {
                                 flag_rep = 0;
                                 rpipe = pi;
                         }
                 }
-                rmode = pi->r_mode;
                 debug_printf_exec(": rmode=%d if_code=%d next_if_code=%d skip_more=%d\n",
                                 rmode, if_code, next_if_code, skip_more_in_this_rmode);
                 if (rmode == skip_more_in_this_rmode && flag_skip) {
@@ -2535,7 +2534,7 @@ static void initialize_context(struct p_context *ctx)
         ctx->child = NULL;
         ctx->list_head = new_pipe();
         ctx->pipe = ctx->list_head;
-        ctx->w = RES_NONE;
+        ctx->res_w = RES_NONE;
         ctx->stack = NULL;
         ctx->old_flag = 0;
         done_command(ctx);   /* creates the memory for working child */
@@ -2574,29 +2573,29 @@ static int reserved_word(o_string *dest, struct p_context *ctx)
         enum { NRES = sizeof(reserved_list)/sizeof(reserved_list[0]) };
         const struct reserved_combo *r;
 
-        for (r = reserved_list; r < reserved_list+NRES; r++) {
+        for (r = reserved_list; r < reserved_list + NRES; r++) {
                 if (strcmp(dest->data, r->literal) == 0) {
                         debug_printf("found reserved word %s, code %d\n", r->literal, r->code);
                         if (r->flag & FLAG_START) {
                                 struct p_context *new = xmalloc(sizeof(struct p_context));
                                 debug_printf("push stack\n");
-                                if (ctx->w == RES_IN || ctx->w == RES_FOR) {
+                                if (ctx->res_w == RES_IN || ctx->res_w == RES_FOR) {
                                         syntax();
                                         free(new);
-                                        ctx->w = RES_SNTX;
+                                        ctx->res_w = RES_SNTX;
                                         b_reset(dest);
                                         return 1;
                                 }
                                 *new = *ctx;   /* physical copy */
                                 initialize_context(ctx);
                                 ctx->stack = new;
-                        } else if (ctx->w == RES_NONE || !(ctx->old_flag & (1 << r->code))) {
+                        } else if (ctx->res_w == RES_NONE || !(ctx->old_flag & (1 << r->code))) {
                                 syntax();
-                                ctx->w = RES_SNTX;
+                                ctx->res_w = RES_SNTX;
                                 b_reset(dest);
                                 return 1;
                         }
-                        ctx->w = r->code;
+                        ctx->res_w = r->code;
                         ctx->old_flag = r->flag;
                         if (ctx->old_flag & FLAG_END) {
                                 struct p_context *old;
@@ -2623,7 +2622,7 @@ static int done_word(o_string *dest, struct p_context *ctx)
         glob_t *glob_target;
         int gr, flags = 0;
 
-        debug_printf_parse("done_word: '%s' %p\n", dest->data, child);
+        debug_printf_parse("done_word entered: '%s' %p\n", dest->data, child);
         if (dest->length == 0 && !dest->nonnull) {
                 debug_printf_parse("done_word return 0: true null, ignored\n");
                 return 0;
@@ -2636,15 +2635,16 @@ static int done_word(o_string *dest, struct p_context *ctx)
                         debug_printf_parse("done_word return 1: syntax error, groups and arglists don't mix\n");
                         return 1;
                 }
-                if (!child->argv && (ctx->type & FLAG_PARSE_SEMICOLON)) {
-                        debug_printf_parse(": checking %s for reserved-ness\n", dest->data);
+                if (!child->argv && (ctx->parse_type & FLAG_PARSE_SEMICOLON)) {
+                        debug_printf_parse(": checking '%s' for reserved-ness\n", dest->data);
                         if (reserved_word(dest, ctx)) {
-                                debug_printf_parse("done_word return %d\n", (ctx->w == RES_SNTX));
-                                return (ctx->w == RES_SNTX);
+                                debug_printf_parse("done_word return %d\n", (ctx->res_w == RES_SNTX));
+                                return (ctx->res_w == RES_SNTX);
                         }
                 }
                 glob_target = &child->glob_result;
-                if (child->argv) flags |= GLOB_APPEND;
+                if (child->argv)
+                        flags |= GLOB_APPEND;
         }
         gr = xglob(dest, flags, glob_target);
         if (gr != 0) {
@@ -2663,7 +2663,7 @@ static int done_word(o_string *dest, struct p_context *ctx)
         } else {
                 child->argv = glob_target->gl_pathv;
         }
-        if (ctx->w == RES_FOR) {
+        if (ctx->res_w == RES_FOR) {
                 done_word(dest, ctx);
                 done_pipe(ctx, PIPE_SEQ);
         }
@@ -2676,56 +2676,63 @@ static int done_word(o_string *dest, struct p_context *ctx)
 static int done_command(struct p_context *ctx)
 {
         /* The child is really already in the pipe structure, so
-         * advance the pipe counter and make a new, null child.
-         * Only real trickiness here is that the uncommitted
-         * child structure, to which ctx->child points, is not
-         * counted in pi->num_progs. */
+         * advance the pipe counter and make a new, null child. */
         struct pipe *pi = ctx->pipe;
-        struct child_prog *prog = ctx->child;
+        struct child_prog *child = ctx->child;
 
-        if (prog && prog->group == NULL
-         && prog->argv == NULL
-         && prog->redirects == NULL
-        ) {
-                debug_printf("done_command: skipping null command\n");
-                return 0;
-        }
-        if (prog) {
+        if (child) {
+                if (child->group == NULL
+                 && child->argv == NULL
+                 && child->redirects == NULL
+                ) {
+                        debug_printf_parse("done_command: skipping null command\n");
+                        return 0;
+                }
                 pi->num_progs++;
-                debug_printf("done_command: num_progs incremented to %d\n", pi->num_progs);
+                debug_printf_parse("done_command: ++num_progs=%d\n", pi->num_progs);
         } else {
-                debug_printf("done_command: initializing\n");
+                debug_printf_parse("done_command: initializing, num_progs=%d\n", pi->num_progs);
         }
-        pi->progs = xrealloc(pi->progs, sizeof(*pi->progs) * (pi->num_progs+1));
-
-        prog = pi->progs + pi->num_progs;
-        memset(prog, 0, sizeof(*prog));
-        /*prog->redirects = NULL;*/
-        /*prog->argv = NULL; */
-        /*prog->is_stopped = 0;*/
-        /*prog->group = NULL;*/
-        /*prog->glob_result.gl_pathv = NULL;*/
-        prog->family = pi;
-        /*prog->sp = 0;*/
-        ctx->child = prog;
-        prog->type = ctx->type;
 
+        /* Only real trickiness here is that the uncommitted
+         * child structure is not counted in pi->num_progs. */
+        pi->progs = xrealloc(pi->progs, sizeof(*pi->progs) * (pi->num_progs+1));
+        child = &pi->progs[pi->num_progs];
+
+        memset(child, 0, sizeof(*child));
+        /*child->redirects = NULL;*/
+        /*child->argv = NULL;*/
+        /*child->is_stopped = 0;*/
+        /*child->group = NULL;*/
+        /*child->glob_result.gl_pathv = NULL;*/
+        child->family = pi;
+        /*child->sp = 0;*/
+        child->type = ctx->parse_type;
+
+        ctx->child = child;
         /* but ctx->pipe and ctx->list_head remain unchanged */
+
         return 0;
 }
 
 static int done_pipe(struct p_context *ctx, pipe_style type)
 {
         struct pipe *new_p;
+
+        debug_printf_parse("done_pipe entered, followup %d\n", type);
         done_command(ctx);  /* implicit closure of previous command */
-        debug_printf_parse("done_pipe, type %d\n", type);
         ctx->pipe->followup = type;
-        ctx->pipe->r_mode = ctx->w;
+        ctx->pipe->r_mode = ctx->res_w;
         new_p = new_pipe();
         ctx->pipe->next = new_p;
         ctx->pipe = new_p;
         ctx->child = NULL;
+// TODO: even just <enter> on command line basically generates
+// tree of three NOPs (!).
+// Can we detect that previous done_command have seen "skipping null command"
+// condition and NOT create new pipe here?
         done_command(ctx);  /* set up new pipe to accept commands */
+        debug_printf_parse("done_pipe return 0\n");
         return 0;
 }
 
@@ -3055,7 +3062,7 @@ static int parse_stream(o_string *dest, struct p_context *ctx,
                 }
                 if (m == MAP_IFS_IF_UNQUOTED) {
                         if (done_word(dest, ctx)) {
-                                debug_printf_parse("parse_stream return 1\n");
+                                debug_printf_parse("parse_stream return 1: done_word!=0\n");
                                 return 1;
                         }
                         /* If we aren't performing a substitution, treat
@@ -3066,9 +3073,9 @@ static int parse_stream(o_string *dest, struct p_context *ctx,
                         }
                 }
                 if ((end_trigger && strchr(end_trigger, ch))
-                 && !dest->quote && ctx->w == RES_NONE
+                 && !dest->quote && ctx->res_w == RES_NONE
                 ) {
-                        debug_printf_parse("parse_stream return 0\n");
+                        debug_printf_parse("parse_stream return 0: end_trigger char found\n");
                         return 0;
                 }
                 if (m == MAP_IFS_IF_UNQUOTED)
@@ -3089,7 +3096,7 @@ static int parse_stream(o_string *dest, struct p_context *ctx,
                 case '\\':
                         if (next == EOF) {
                                 syntax();
-                                debug_printf_parse("parse_stream return 1\n");
+                                debug_printf_parse("parse_stream return 1: \\<eof>\n");
                                 return 1;
                         }
                         b_addqchr(dest, '\\', dest->quote);
@@ -3111,7 +3118,7 @@ static int parse_stream(o_string *dest, struct p_context *ctx,
                         }
                         if (ch == EOF) {
                                 syntax();
-                                debug_printf_parse("parse_stream return 1\n");
+                                debug_printf_parse("parse_stream return 1: unterminated '\n");
                                 return 1;
                         }
                         break;
@@ -3204,7 +3211,7 @@ static int parse_stream(o_string *dest, struct p_context *ctx,
          * that is, we were really supposed to get end_trigger, and never got
          * one before the EOF.  Can't use the standard "syntax error" return code,
          * so that parse_stream_outer can distinguish the EOF and exit smoothly. */
-        debug_printf_parse("parse_stream return -%d\n", end_trigger != NULL);
+        debug_printf_parse("parse_stream return %d\n", -(end_trigger != NULL));
         if (end_trigger)
                 return -1;
         return 0;
@@ -3220,7 +3227,8 @@ static void update_ifs_map(void)
 {
         /* char *ifs and char map[256] are both globals. */
         ifs = getenv("IFS");
-        if (ifs == NULL) ifs = " \t\n";
+        if (ifs == NULL)
+                ifs = " \t\n";
         /* Precompute a list of 'flow through' behavior so it can be treated
          * quickly up front.  Computation is necessary because of IFS.
          * Special case handling of IFS == " \t\n" is not implemented.
@@ -3235,24 +3243,26 @@ static void update_ifs_map(void)
 
 /* most recursion does not come through here, the exception is
  * from builtin_source() */
-static int parse_stream_outer(struct in_str *inp, int flag)
+static int parse_stream_outer(struct in_str *inp, int parse_flag)
 {
 // FIXME: '{ true | exit 3; echo $? }' is parsed as a whole,
 // as a result $? is replaced by 0, not 3!
-// Need to stop & execute stuff at ';', not parse till EOL!
 
         struct p_context ctx;
         o_string temp = NULL_O_STRING;
         int rcode;
         do {
-                ctx.type = flag;
+                ctx.parse_type = parse_flag;
                 initialize_context(&ctx);
                 update_ifs_map();
-                if (!(flag & FLAG_PARSE_SEMICOLON) || (flag & FLAG_REPARSING))
+                if (!(parse_flag & FLAG_PARSE_SEMICOLON) || (parse_flag & FLAG_REPARSING))
                         mapset(";$&|", MAP_ORDINARY);
 #if ENABLE_HUSH_INTERACTIVE
                 inp->promptmode = 1;
 #endif
+                /* We will stop & execute after each ';' or '\n'.
+                 * Example: "sleep 9999; echo TEST" + ctrl-C:
+                 * TEST should be printed */
                 rcode = parse_stream(&temp, &ctx, inp, ";\n");
                 if (rcode != 1 && ctx.old_flag != 0) {
                         syntax();
@@ -3274,15 +3284,15 @@ static int parse_stream_outer(struct in_str *inp, int flag)
                         free_pipe_list(ctx.list_head, 0);
                 }
                 b_free(&temp);
-        } while (rcode != -1 && !(flag & FLAG_EXIT_FROM_LOOP));   /* loop on syntax errors, return on EOF */
+        } while (rcode != -1 && !(parse_flag & FLAG_EXIT_FROM_LOOP));   /* loop on syntax errors, return on EOF */
         return 0;
 }
 
-static int parse_string_outer(const char *s, int flag)
+static int parse_string_outer(const char *s, int parse_flag)
 {
         struct in_str input;
         setup_string_in_str(&input, s);
-        return parse_stream_outer(&input, flag);
+        return parse_stream_outer(&input, parse_flag);
 }
 
 static int parse_file_outer(FILE *f)
@@ -3303,7 +3313,7 @@ static void setup_job_control(void)
         pid_t shell_pgrp;
 
         saved_task_pgrp = shell_pgrp = getpgrp();
-        debug_printf("saved_task_pgrp=%d\n", saved_task_pgrp);
+        debug_printf_jobs("saved_task_pgrp=%d\n", saved_task_pgrp);
         fcntl(interactive_fd, F_SETFD, FD_CLOEXEC);
 
         /* If we were ran as 'hush &',
@@ -3319,7 +3329,7 @@ static void setup_job_control(void)
         set_misc_sighandler(SIG_IGN);
 //huh?  signal(SIGCHLD, SIG_IGN);
 
-        /* We _must_ restore tty pgrp fatal signals */
+        /* We _must_ restore tty pgrp on fatal signals */
         set_fatal_sighandler(sigexit);
 
         /* Put ourselves in our own process group.  */