hush: use G.xxx instead of #define xxx G.xxx. We have too many globals

 there and #defines get messy. Remove one write-only G.variable.

1 files changed, 198 insertions, 234 deletions

diff --git a/shell/hush.c b/shell/hush.c
index f65405563..b471bd845 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -427,9 +427,10 @@ struct globals {
         line_input_t *line_input_state;
 #endif
         pid_t root_pid;
+        pid_t last_bg_pid;
 #if ENABLE_HUSH_JOB
         int run_list_level;
-        pid_t saved_task_pgrp;
+//      pid_t saved_task_pgrp;
         pid_t saved_tty_pgrp;
         int last_jobid;
         struct pipe *job_list;
@@ -448,10 +449,9 @@ struct globals {
         unsigned depth_break_continue;
         unsigned depth_of_loop;
 #endif
-        pid_t last_bg_pid;
         const char *ifs;
         const char *cwd;
-        struct variable *top_var; /* = &shell_ver (set in main()) */
+        struct variable *top_var; /* = &G.shell_ver (set in main()) */
         struct variable shell_ver;
 #if ENABLE_FEATURE_SH_STANDALONE
         struct nofork_save_area nofork_save;
@@ -464,53 +464,9 @@ struct globals {
 };
 
 #define G (*ptr_to_globals)
-
-#if !ENABLE_HUSH_INTERACTIVE
-enum { interactive_fd = 0 };
-#endif
-#if !ENABLE_HUSH_JOB
-enum { run_list_level = 0 };
-#endif
-
-#if ENABLE_HUSH_INTERACTIVE
-#define interactive_fd   (G.interactive_fd  )
-#define PS1              (G.PS1             )
-#define PS2              (G.PS2             )
-#endif
-#if ENABLE_FEATURE_EDITING
-#define line_input_state (G.line_input_state)
-#endif
-#define root_pid         (G.root_pid        )
-#if ENABLE_HUSH_JOB
-#define run_list_level   (G.run_list_level  )
-#define saved_task_pgrp  (G.saved_task_pgrp )
-#define saved_tty_pgrp   (G.saved_tty_pgrp  )
-#define last_jobid       (G.last_jobid      )
-#define job_list         (G.job_list        )
-#define toplevel_list    (G.toplevel_list   )
-#define toplevel_jb      (G.toplevel_jb     )
-#define ctrl_z_flag      (G.ctrl_z_flag     )
-#endif /* JOB */
-#define global_argv      (G.global_argv     )
-#define global_argc      (G.global_argc     )
-#define last_return_code (G.last_return_code)
-#define ifs              (G.ifs             )
-#define flag_break_continue  (G.flag_break_continue )
-#define depth_break_continue (G.depth_break_continue)
-#define depth_of_loop    (G.depth_of_loop   )
-#define fake_mode        (G.fake_mode       )
-#define cwd              (G.cwd             )
-#define last_bg_pid      (G.last_bg_pid     )
-#define top_var          (G.top_var         )
-#define shell_ver        (G.shell_ver       )
-#if ENABLE_FEATURE_SH_STANDALONE
-#define nofork_save      (G.nofork_save     )
-#endif
-#if ENABLE_HUSH_JOB
-#define toplevel_jb      (G.toplevel_jb     )
-#endif
-#define charmap          (G.charmap         )
-#define user_input_buf   (G.user_input_buf  )
+/* Not #defining name to G.name - this quickly gets unwieldy
+ * (too many defines). Also, I actually prefer to see when a variable
+ * is global, thus "G." prefix is a useful hint */
 #define INIT_G() do { \
         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 } while (0)
@@ -522,23 +478,29 @@ enum { run_list_level = 0 };
 /* Normal */
 static void syntax(const char *msg)
 {
+#if ENABLE_HUSH_INTERACTIVE
         /* Was using fancy stuff:
-         * (interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
+         * (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
          * but it SEGVs. ?! Oh well... explicit temp ptr works around that */
         void FAST_FUNC (*fp)(const char *s, ...);
-
-        fp = (interactive_fd ? bb_error_msg : bb_error_msg_and_die);
+        fp = (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die);
         fp(msg ? "%s: %s" : "syntax error", "syntax error", msg);
+#else
+        bb_error_msg_and_die(msg ? "%s: %s" : "syntax error", "syntax error", msg);
+#endif
 }
 
 #else
 /* Debug */
 static void syntax_lineno(int line)
 {
+#if ENABLE_HUSH_INTERACTIVE
         void FAST_FUNC (*fp)(const char *s, ...);
-
-        fp = (interactive_fd ? bb_error_msg : bb_error_msg_and_die);
+        fp = (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die);
         fp("syntax error hush.c:%d", line);
+#else
+        bb_error_msg_and_die("syntax error hush.c:%d", line);
+#endif
 }
 #define syntax(str) syntax_lineno(__LINE__)
 #endif
@@ -844,7 +806,7 @@ static void handler_ctrl_c(int sig UNUSED_PARAM)
 {
         debug_printf_jobs("got sig %d\n", sig);
 // as usual we can have all kinds of nasty problems with leaked malloc data here
-        siglongjmp(toplevel_jb, 1);
+        siglongjmp(G.toplevel_jb, 1);
 }
 
 static void handler_ctrl_z(int sig UNUSED_PARAM)
@@ -855,7 +817,7 @@ static void handler_ctrl_z(int sig UNUSED_PARAM)
         pid = fork();
         if (pid < 0) /* can't fork. Pretend there was no ctrl-Z */
                 return;
-        ctrl_z_flag = 1;
+        G.ctrl_z_flag = 1;
         if (!pid) { /* child */
                 if (ENABLE_HUSH_JOB)
                         die_sleep = 0; /* let nofork's xfuncs die */
@@ -870,13 +832,13 @@ static void handler_ctrl_z(int sig UNUSED_PARAM)
         }
         /* parent */
         /* finish filling up pipe info */
-        toplevel_list->pgrp = pid; /* child is in its own pgrp */
-        toplevel_list->progs[0].pid = pid;
+        G.toplevel_list->pgrp = pid; /* child is in its own pgrp */
+        G.toplevel_list->progs[0].pid = pid;
         /* parent needs to longjmp out of running nofork.
          * we will "return" exitcode 0, with child put in background */
 // as usual we can have all kinds of nasty problems with leaked malloc data here
         debug_printf_jobs("siglongjmp in parent\n");
-        siglongjmp(toplevel_jb, 1);
+        siglongjmp(G.toplevel_jb, 1);
 }
 
 /* Restores tty foreground process group, and exits.
@@ -890,8 +852,10 @@ static void sigexit(int sig)
         /* Disable all signals: job control, SIGPIPE, etc. */
         sigprocmask_allsigs(SIG_BLOCK);
 
-        if (interactive_fd)
-                tcsetpgrp(interactive_fd, saved_tty_pgrp);
+#if ENABLE_HUSH_INTERACTIVE
+        if (G.interactive_fd)
+                tcsetpgrp(G.interactive_fd, G.saved_tty_pgrp);
+#endif
 
         /* Not a signal, just exit */
         if (sig <= 0)
@@ -919,12 +883,12 @@ static void hush_exit(int exitcode)
 
 static const char *set_cwd(void)
 {
-        if (cwd == bb_msg_unknown)
-                cwd = NULL;     /* xrealloc_getcwd_or_warn(arg) calls free(arg)! */
-        cwd = xrealloc_getcwd_or_warn((char *)cwd);
-        if (!cwd)
-                cwd = bb_msg_unknown;
-        return cwd;
+        if (G.cwd == bb_msg_unknown)
+                G.cwd = NULL;     /* xrealloc_getcwd_or_warn(arg) calls free(arg)! */
+        G.cwd = xrealloc_getcwd_or_warn((char *)G.cwd);
+        if (!G.cwd)
+                G.cwd = bb_msg_unknown;
+        return G.cwd;
 }
 
 
@@ -1224,11 +1188,11 @@ static int static_peek(struct in_str *i)
 static void cmdedit_set_initial_prompt(void)
 {
 #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
-        PS1 = NULL;
+        G.PS1 = NULL;
 #else
-        PS1 = getenv("PS1");
-        if (PS1 == NULL)
-                PS1 = "\\w \\$ ";
+        G.PS1 = getenv("PS1");
+        if (G.PS1 == NULL)
+                G.PS1 = "\\w \\$ ";
 #endif
 }
 #endif /* EDITING */
@@ -1240,14 +1204,14 @@ static const char* setup_prompt_string(int promptmode)
 #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
         /* Set up the prompt */
         if (promptmode == 0) { /* PS1 */
-                free((char*)PS1);
-                PS1 = xasprintf("%s %c ", cwd, (geteuid() != 0) ? '$' : '#');
-                prompt_str = PS1;
+                free((char*)G.PS1);
+                G.PS1 = xasprintf("%s %c ", G.cwd, (geteuid() != 0) ? '$' : '#');
+                prompt_str = G.PS1;
         } else {
-                prompt_str = PS2;
+                prompt_str = G.PS2;
         }
 #else
-        prompt_str = (promptmode == 0) ? PS1 : PS2;
+        prompt_str = (promptmode == 0) ? G.PS1 : G.PS2;
 #endif
         debug_printf("result '%s'\n", prompt_str);
         return prompt_str;
@@ -1263,21 +1227,21 @@ static void get_user_input(struct in_str *i)
         /* Enable command line editing only while a command line
          * is actually being read */
         do {
-                r = read_line_input(prompt_str, user_input_buf, BUFSIZ-1, line_input_state);
+                r = read_line_input(prompt_str, G.user_input_buf, BUFSIZ-1, G.line_input_state);
         } while (r == 0); /* repeat if Ctrl-C */
         i->eof_flag = (r < 0);
         if (i->eof_flag) { /* EOF/error detected */
-                user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
-                user_input_buf[1] = '\0';
+                G.user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
+                G.user_input_buf[1] = '\0';
         }
 #else
         fputs(prompt_str, stdout);
         fflush(stdout);
-        user_input_buf[0] = r = fgetc(i->file);
-        /*user_input_buf[1] = '\0'; - already is and never changed */
+        G.user_input_buf[0] = r = fgetc(i->file);
+        /*G.user_input_buf[1] = '\0'; - already is and never changed */
         i->eof_flag = (r == EOF);
 #endif
-        i->p = user_input_buf;
+        i->p = G.user_input_buf;
 }
 
 #endif  /* INTERACTIVE */
@@ -1300,7 +1264,7 @@ static int file_get(struct in_str *i)
                 /* need to double check i->file because we might be doing something
                  * more complicated by now, like sourcing or substituting. */
 #if ENABLE_HUSH_INTERACTIVE
-                if (interactive_fd && i->promptme && i->file == stdin) {
+                if (G.interactive_fd && i->promptme && i->file == stdin) {
                         do {
                                 get_user_input(i);
                         } while (!*i->p); /* need non-empty line */
@@ -1561,15 +1525,15 @@ static void insert_bg_job(struct pipe *pi)
 
         /* Linear search for the ID of the job to use */
         pi->jobid = 1;
-        for (thejob = job_list; thejob; thejob = thejob->next)
+        for (thejob = G.job_list; thejob; thejob = thejob->next)
                 if (thejob->jobid >= pi->jobid)
                         pi->jobid = thejob->jobid + 1;
 
         /* Add thejob to the list of running jobs */
-        if (!job_list) {
-                thejob = job_list = xmalloc(sizeof(*thejob));
+        if (!G.job_list) {
+                thejob = G.job_list = xmalloc(sizeof(*thejob));
         } else {
-                for (thejob = job_list; thejob->next; thejob = thejob->next)
+                for (thejob = G.job_list; thejob->next; thejob = thejob->next)
                         continue;
                 thejob->next = xmalloc(sizeof(*thejob));
                 thejob = thejob->next;
@@ -1591,26 +1555,26 @@ static void insert_bg_job(struct pipe *pi)
         /* We don't wait for background thejobs to return -- append it
            to the list of backgrounded thejobs and leave it alone */
         printf("[%d] %d %s\n", thejob->jobid, thejob->progs[0].pid, thejob->cmdtext);
-        last_bg_pid = thejob->progs[0].pid;
-        last_jobid = thejob->jobid;
+        G.last_bg_pid = thejob->progs[0].pid;
+        G.last_jobid = thejob->jobid;
 }
 
 static void remove_bg_job(struct pipe *pi)
 {
         struct pipe *prev_pipe;
 
-        if (pi == job_list) {
-                job_list = pi->next;
+        if (pi == G.job_list) {
+                G.job_list = pi->next;
         } else {
-                prev_pipe = job_list;
+                prev_pipe = G.job_list;
                 while (prev_pipe->next != pi)
                         prev_pipe = prev_pipe->next;
                 prev_pipe->next = pi->next;
         }
-        if (job_list)
-                last_jobid = job_list->jobid;
+        if (G.job_list)
+                G.last_jobid = G.job_list->jobid;
         else
-                last_jobid = 0;
+                G.last_jobid = 0;
 }
 
 /* Remove a backgrounded job */
@@ -1705,7 +1669,7 @@ static int checkjobs(struct pipe* fg_pipe)
 #if ENABLE_HUSH_JOB
                 /* We asked to wait for bg or orphaned children */
                 /* No need to remember exitcode in this case */
-                for (pi = job_list; pi; pi = pi->next) {
+                for (pi = G.job_list; pi; pi = pi->next) {
                         for (i = 0; i < pi->num_progs; i++) {
                                 if (pi->progs[i].pid == childpid)
                                         goto found_pi_and_prognum;
@@ -1748,8 +1712,8 @@ static int checkjobs_and_fg_shell(struct pipe* fg_pipe)
         /* Job finished, move the shell to the foreground */
         p = getpgid(0); /* pgid of our process */
         debug_printf_jobs("fg'ing ourself: getpgid(0)=%d\n", (int)p);
-        tcsetpgrp(interactive_fd, p);
-//      if (tcsetpgrp(interactive_fd, p) && errno != ENOTTY)
+        tcsetpgrp(G.interactive_fd, p);
+//      if (tcsetpgrp(G.interactive_fd, p) && errno != ENOTTY)
 //              bb_perror_msg("tcsetpgrp-4a");
         return rcode;
 }
@@ -1865,9 +1829,9 @@ static int run_pipe(struct pipe *pi)
                         int a = find_applet_by_name(argv_expanded[0]);
                         if (a >= 0 && APPLET_IS_NOFORK(a)) {
                                 setup_redirects(child, squirrel);
-                                save_nofork_data(&nofork_save);
+                                save_nofork_data(&G.nofork_save);
                                 debug_printf_exec(": run_nofork_applet '%s' '%s'...\n", argv_expanded[0], argv_expanded[1]);
-                                rcode = run_nofork_applet_prime(&nofork_save, a, argv_expanded);
+                                rcode = run_nofork_applet_prime(&G.nofork_save, a, argv_expanded);
                                 free(argv_expanded);
                                 restore_redirects(squirrel);
                                 debug_printf_exec("run_pipe return %d\n", rcode);
@@ -1916,7 +1880,7 @@ static int run_pipe(struct pipe *pi)
 #if ENABLE_HUSH_JOB
                         /* Every child adds itself to new process group
                          * with pgid == pid_of_first_child_in_pipe */
-                        if (run_list_level == 1 && interactive_fd) {
+                        if (G.run_list_level == 1 && G.interactive_fd) {
                                 pid_t pgrp;
                                 /* Don't do pgrp restore anymore on fatal signals */
                                 set_fatal_sighandler(SIG_DFL);
@@ -1926,7 +1890,7 @@ static int run_pipe(struct pipe *pi)
                                 if (setpgid(0, pgrp) == 0 && pi->followup != PIPE_BG) {
                                         /* We do it in *every* child, not just first,
                                          * to avoid races */
-                                        tcsetpgrp(interactive_fd, pgrp);
+                                        tcsetpgrp(G.interactive_fd, pgrp);
                                 }
                         }
 #endif
@@ -2072,7 +2036,7 @@ static int run_list(struct pipe *pi)
         /*enum reserved_style*/ smallint rword = RES_NONE;
         /*enum reserved_style*/ smallint skip_more_for_this_rword = RES_XXXX;
 
-        debug_printf_exec("run_list start lvl %d\n", run_list_level + 1);
+        debug_printf_exec("run_list start lvl %d\n", G.run_list_level + 1);
 
 #if ENABLE_HUSH_LOOPS
         /* Check syntax for "for" */
@@ -2082,7 +2046,7 @@ static int run_list(struct pipe *pi)
                 /* current word is FOR or IN (BOLD in comments below) */
                 if (cpipe->next == NULL) {
                         syntax("malformed for");
-                        debug_printf_exec("run_list lvl %d return 1\n", run_list_level);
+                        debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
                         return 1;
                 }
                 /* "FOR v; do ..." and "for v IN a b; do..." are ok */
@@ -2093,7 +2057,7 @@ static int run_list(struct pipe *pi)
                  || cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
                 ) {
                         syntax("malformed for");
-                        debug_printf_exec("run_list lvl %d return 1\n", run_list_level);
+                        debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
                         return 1;
                 }
         }
@@ -2108,22 +2072,22 @@ static int run_list(struct pipe *pi)
          * We are saving state before entering outermost list ("while...done")
          * so that ctrl-Z will correctly background _entire_ outermost list,
          * not just a part of it (like "sleep 1 | exit 2") */
-        if (++run_list_level == 1 && interactive_fd) {
-                if (sigsetjmp(toplevel_jb, 1)) {
+        if (++G.run_list_level == 1 && G.interactive_fd) {
+                if (sigsetjmp(G.toplevel_jb, 1)) {
                         /* ctrl-Z forked and we are parent; or ctrl-C.
                          * Sighandler has longjmped us here */
                         signal(SIGINT, SIG_IGN);
                         signal(SIGTSTP, SIG_IGN);
                         /* Restore level (we can be coming from deep inside
                          * nested levels) */
-                        run_list_level = 1;
+                        G.run_list_level = 1;
 #if ENABLE_FEATURE_SH_STANDALONE
-                        if (nofork_save.saved) { /* if save area is valid */
+                        if (G.nofork_save.saved) { /* if save area is valid */
                                 debug_printf_jobs("exiting nofork early\n");
-                                restore_nofork_data(&nofork_save);
+                                restore_nofork_data(&G.nofork_save);
                         }
 #endif
-                        if (ctrl_z_flag) {
+                        if (G.ctrl_z_flag) {
                                 /* ctrl-Z has forked and stored pid of the child in pi->pid.
                                  * Remember this child as background job */
                                 insert_bg_job(pi);
@@ -2132,15 +2096,15 @@ static int run_list(struct pipe *pi)
                                 bb_putchar('\n');
                         }
                         USE_HUSH_LOOPS(loop_top = NULL;)
-                        USE_HUSH_LOOPS(depth_of_loop = 0;)
+                        USE_HUSH_LOOPS(G.depth_of_loop = 0;)
                         rcode = 0;
                         goto ret;
                 }
                 /* ctrl-Z handler will store pid etc in pi */
-                toplevel_list = pi;
-                ctrl_z_flag = 0;
+                G.toplevel_list = pi;
+                G.ctrl_z_flag = 0;
 #if ENABLE_FEATURE_SH_STANDALONE
-                nofork_save.saved = 0; /* in case we will run a nofork later */
+                G.nofork_save.saved = 0; /* in case we will run a nofork later */
 #endif
                 signal_SA_RESTART_empty_mask(SIGTSTP, handler_ctrl_z);
                 signal(SIGINT, handler_ctrl_c);
@@ -2155,11 +2119,11 @@ static int run_list(struct pipe *pi)
                                 rword, cond_code, skip_more_for_this_rword);
 #if ENABLE_HUSH_LOOPS
                 if ((rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR)
-                 && loop_top == NULL /* avoid bumping depth_of_loop twice */
+                 && loop_top == NULL /* avoid bumping G.depth_of_loop twice */
                 ) {
                         /* start of a loop: remember where loop starts */
                         loop_top = pi;
-                        depth_of_loop++;
+                        G.depth_of_loop++;
                 }
 #endif
                 if (rword == skip_more_for_this_rword && flag_skip) {
@@ -2268,7 +2232,7 @@ static int run_list(struct pipe *pi)
                 {
                         int r;
 #if ENABLE_HUSH_LOOPS
-                        flag_break_continue = 0;
+                        G.flag_break_continue = 0;
 #endif
                         rcode = r = run_pipe(pi); /* NB: rcode is a smallint */
                         if (r != -1) {
@@ -2276,17 +2240,17 @@ static int run_list(struct pipe *pi)
                                  * and we don't need to wait for anything. */
 #if ENABLE_HUSH_LOOPS
                                 /* was it "break" or "continue"? */
-                                if (flag_break_continue) {
-                                        smallint fbc = flag_break_continue;
+                                if (G.flag_break_continue) {
+                                        smallint fbc = G.flag_break_continue;
                                         /* we might fall into outer *loop*,
                                          * don't want to break it too */
                                         if (loop_top) {
-                                                depth_break_continue--;
-                                                if (depth_break_continue == 0)
-                                                        flag_break_continue = 0;
+                                                G.depth_break_continue--;
+                                                if (G.depth_break_continue == 0)
+                                                        G.flag_break_continue = 0;
                                                 /* else: e.g. "continue 2" should *break* once, *then* continue */
                                         } /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
-                                        if (depth_break_continue != 0 || fbc == BC_BREAK)
+                                        if (G.depth_break_continue != 0 || fbc == BC_BREAK)
                                                 goto check_jobs_and_break;
                                         /* "continue": simulate end of loop */
                                         rword = RES_DONE;
@@ -2299,13 +2263,13 @@ static int run_list(struct pipe *pi)
                                  * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
                                  * I'm NOT treating inner &'s as jobs */
 #if ENABLE_HUSH_JOB
-                                if (run_list_level == 1)
+                                if (G.run_list_level == 1)
                                         insert_bg_job(pi);
 #endif
                                 rcode = 0; /* EXIT_SUCCESS */
                         } else {
 #if ENABLE_HUSH_JOB
-                                if (run_list_level == 1 && interactive_fd) {
+                                if (G.run_list_level == 1 && G.interactive_fd) {
                                         /* waits for completion, then fg's main shell */
                                         rcode = checkjobs_and_fg_shell(pi);
                                         debug_printf_exec(": checkjobs_and_fg_shell returned %d\n", rcode);
@@ -2318,7 +2282,7 @@ static int run_list(struct pipe *pi)
                         }
                 }
                 debug_printf_exec(": setting last_return_code=%d\n", rcode);
-                last_return_code = rcode;
+                G.last_return_code = rcode;
 
                 /* Analyze how result affects subsequent commands */
 #if ENABLE_HUSH_IF
@@ -2349,22 +2313,22 @@ static int run_list(struct pipe *pi)
         } /* for (pi) */
 
 #if ENABLE_HUSH_JOB
-        if (ctrl_z_flag) {
+        if (G.ctrl_z_flag) {
                 /* ctrl-Z forked somewhere in the past, we are the child,
                  * and now we completed running the list. Exit. */
 //TODO: _exit?
                 exit(rcode);
         }
  ret:
-        if (!--run_list_level && interactive_fd) {
+        if (!--G.run_list_level && G.interactive_fd) {
                 signal(SIGTSTP, SIG_IGN);
                 signal(SIGINT, SIG_IGN);
         }
 #endif
-        debug_printf_exec("run_list lvl %d return %d\n", run_list_level + 1, rcode);
+        debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
 #if ENABLE_HUSH_LOOPS
         if (loop_top)
-                depth_of_loop--;
+                G.depth_of_loop--;
         free(for_list);
 #endif
 #if ENABLE_HUSH_CASE
@@ -2449,7 +2413,7 @@ static int run_and_free_list(struct pipe *pi)
 {
         int rcode = 0;
         debug_printf_exec("run_and_free_list entered\n");
-        if (!fake_mode) {
+        if (!G.fake_mode) {
                 debug_printf_exec(": run_list with %d members\n", pi->num_progs);
                 rcode = run_list(pi);
         }
@@ -2472,12 +2436,12 @@ static int run_and_free_list(struct pipe *pi)
  * Caller can deallocate entire list by single free(list). */
 
 /* Store given string, finalizing the word and starting new one whenever
- * we encounter ifs char(s). This is used for expanding variable values.
+ * we encounter IFS char(s). This is used for expanding variable values.
  * End-of-string does NOT finalize word: think about 'echo -$VAR-' */
 static int expand_on_ifs(o_string *output, int n, const char *str)
 {
         while (1) {
-                int word_len = strcspn(str, ifs);
+                int word_len = strcspn(str, G.ifs);
                 if (word_len) {
                         if (output->o_quote || !output->o_glob)
                                 o_addQstr(output, str, word_len);
@@ -2490,7 +2454,7 @@ static int expand_on_ifs(o_string *output, int n, const char *str)
                 o_addchr(output, '\0');
                 debug_print_list("expand_on_ifs", output, n);
                 n = o_save_ptr(output, n);
-                str += strspn(str, ifs); /* skip ifs chars */
+                str += strspn(str, G.ifs); /* skip ifs chars */
         }
         debug_print_list("expand_on_ifs[1]", output, n);
         return n;
@@ -2540,31 +2504,31 @@ static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
                 switch (first_ch & 0x7f) {
                 /* Highest bit in first_ch indicates that var is double-quoted */
                 case '$': /* pid */
-                        val = utoa(root_pid);
+                        val = utoa(G.root_pid);
                         break;
                 case '!': /* bg pid */
-                        val = last_bg_pid ? utoa(last_bg_pid) : (char*)"";
+                        val = G.last_bg_pid ? utoa(G.last_bg_pid) : (char*)"";
                         break;
                 case '?': /* exitcode */
-                        val = utoa(last_return_code);
+                        val = utoa(G.last_return_code);
                         break;
                 case '#': /* argc */
-                        val = utoa(global_argc ? global_argc-1 : 0);
+                        val = utoa(G.global_argc ? G.global_argc-1 : 0);
                         break;
                 case '*':
                 case '@':
                         i = 1;
-                        if (!global_argv[i])
+                        if (!G.global_argv[i])
                                 break;
                         ored_ch |= first_ch; /* do it for "$@" _now_, when we know it's not empty */
                         if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
                                 smallint sv = output->o_quote;
                                 /* unquoted var's contents should be globbed, so don't quote */
                                 output->o_quote = 0;
-                                while (global_argv[i]) {
-                                        n = expand_on_ifs(output, n, global_argv[i]);
-                                        debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, global_argc-1);
-                                        if (global_argv[i++][0] && global_argv[i]) {
+                                while (G.global_argv[i]) {
+                                        n = expand_on_ifs(output, n, G.global_argv[i]);
+                                        debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, G.global_argc - 1);
+                                        if (G.global_argv[i++][0] && G.global_argv[i]) {
                                                 /* this argv[] is not empty and not last:
                                                  * put terminating NUL, start new word */
                                                 o_addchr(output, '\0');
@@ -2579,8 +2543,8 @@ static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
                          * and in this case should treat it like '$*' - see 'else...' below */
                         if (first_ch == ('@'|0x80) && !or_mask) { /* quoted $@ */
                                 while (1) {
-                                        o_addQstr(output, global_argv[i], strlen(global_argv[i]));
-                                        if (++i >= global_argc)
+                                        o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
+                                        if (++i >= G.global_argc)
                                                 break;
                                         o_addchr(output, '\0');
                                         debug_print_list("expand_vars_to_list[4]", output, n);
@@ -2588,11 +2552,11 @@ static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
                                 }
                         } else { /* quoted $*: add as one word */
                                 while (1) {
-                                        o_addQstr(output, global_argv[i], strlen(global_argv[i]));
-                                        if (!global_argv[++i])
+                                        o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
+                                        if (!G.global_argv[++i])
                                                 break;
-                                        if (ifs[0])
-                                                o_addchr(output, ifs[0]);
+                                        if (G.ifs[0])
+                                                o_addchr(output, G.ifs[0]);
                                 }
                         }
                         break;
@@ -2620,8 +2584,8 @@ static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
                         arg[0] = first_ch & 0x7f;
                         if (isdigit(arg[0])) {
                                 i = xatoi_u(arg);
-                                if (i < global_argc)
-                                        val = global_argv[i];
+                                if (i < G.global_argc)
+                                        val = G.global_argv[i];
                                 /* else val remains NULL: $N with too big N */
                         } else
                                 val = lookup_param(arg);
@@ -2736,7 +2700,7 @@ static char* expand_strvec_to_string(char **argv)
                         if (HUSH_DEBUG)
                                 if (list[n-1] + strlen(list[n-1]) + 1 != list[n])
                                         bb_error_msg_and_die("BUG in varexp3");
-                        list[n][-1] = ' '; /* TODO: or to ifs[0]? */
+                        list[n][-1] = ' '; /* TODO: or to G.ifs[0]? */
                         n++;
                 }
         }
@@ -2755,7 +2719,7 @@ static struct variable *get_local_var(const char *name)
         if (!name)
                 return NULL;
         len = strlen(name);
-        for (cur = top_var; cur; cur = cur->next) {
+        for (cur = G.top_var; cur; cur = cur->next) {
                 if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=')
                         return cur;
         }
@@ -2777,7 +2741,7 @@ static int set_local_var(char *str, int flg_export)
         }
 
         name_len = value - str + 1; /* including '=' */
-        cur = top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
+        cur = G.top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
         while (1) {
                 if (strncmp(cur->varstr, str, name_len) != 0) {
                         if (!cur->next) {
@@ -2838,7 +2802,7 @@ static void unset_local_var(const char *name)
         if (!name)
                 return;
         name_len = strlen(name);
-        cur = top_var;
+        cur = G.top_var;
         while (cur) {
                 if (strncmp(cur->varstr, name, name_len) == 0 && cur->varstr[name_len] == '=') {
                         if (cur->flg_read_only) {
@@ -3319,7 +3283,7 @@ static FILE *generate_stream_from_list(struct pipe *head)
                 xmove_fd(channel[1], 1);
                 /* Prevent it from trying to handle ctrl-z etc */
 #if ENABLE_HUSH_JOB
-                run_list_level = 1;
+                G.run_list_level = 1;
 #endif
                 /* Process substitution is not considered to be usual
                  * 'command execution'.
@@ -3654,7 +3618,7 @@ static int parse_stream(o_string *dest, struct p_context *ctx,
                 next = '\0';
                 ch = i_getch(input);
                 if (ch != EOF) {
-                        m = charmap[ch];
+                        m = G.charmap[ch];
                         if (ch != '\n') {
                                 next = i_peek(input);
                         }
@@ -3915,29 +3879,28 @@ static int parse_stream(o_string *dest, struct p_context *ctx,
 static void set_in_charmap(const char *set, int code)
 {
         while (*set)
-                charmap[(unsigned char)*set++] = code;
+                G.charmap[(unsigned char)*set++] = code;
 }
 
 static void update_charmap(void)
 {
-        /* char *ifs and char charmap[256] are both globals. */
-        ifs = getenv("IFS");
-        if (ifs == NULL)
-                ifs = " \t\n";
+        G.ifs = getenv("IFS");
+        if (G.ifs == NULL)
+                G.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.
          * The charmap[] array only really needs two bits each,
          * and on most machines that would be faster (reduced L1 cache use).
          */
-        memset(charmap, CHAR_ORDINARY, sizeof(charmap));
+        memset(G.charmap, CHAR_ORDINARY, sizeof(G.charmap));
 #if ENABLE_HUSH_TICK
         set_in_charmap("\\$\"`", CHAR_SPECIAL);
 #else
         set_in_charmap("\\$\"", CHAR_SPECIAL);
 #endif
         set_in_charmap("<>;&|(){}#'", CHAR_ORDINARY_IF_QUOTED);
-        set_in_charmap(ifs, CHAR_IFS);  /* are ordinary if quoted */
+        set_in_charmap(G.ifs, CHAR_IFS);  /* are ordinary if quoted */
 }
 
 /* Most recursion does not come through here, the exception is
@@ -4016,13 +3979,14 @@ static void setup_job_control(void)
 {
         pid_t shell_pgrp;
 
-        saved_task_pgrp = shell_pgrp = getpgrp();
-        debug_printf_jobs("saved_task_pgrp=%d\n", saved_task_pgrp);
-        close_on_exec_on(interactive_fd);
+//      G.saved_task_pgrp =
+        shell_pgrp = getpgrp();
+//      debug_printf_jobs("saved_task_pgrp=%d\n", G.saved_task_pgrp);
+        close_on_exec_on(G.interactive_fd);
 
         /* If we were ran as 'hush &',
          * sleep until we are in the foreground.  */
-        while (tcgetpgrp(interactive_fd) != shell_pgrp) {
+        while (tcgetpgrp(G.interactive_fd) != shell_pgrp) {
                 /* Send TTIN to ourself (should stop us) */
                 kill(- shell_pgrp, SIGTTIN);
                 shell_pgrp = getpgrp();
@@ -4039,7 +4003,7 @@ static void setup_job_control(void)
         /* Put ourselves in our own process group.  */
         setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
         /* Grab control of the terminal.  */
-        tcsetpgrp(interactive_fd, getpid());
+        tcsetpgrp(G.interactive_fd, getpid());
 }
 #endif
 
@@ -4063,15 +4027,15 @@ int hush_main(int argc, char **argv)
 
         INIT_G();
 
-        root_pid = getpid();
+        G.root_pid = getpid();
 
         /* Deal with HUSH_VERSION */
-        shell_ver = const_shell_ver; /* copying struct here */
-        top_var = &shell_ver;
+        G.shell_ver = const_shell_ver; /* copying struct here */
+        G.top_var = &G.shell_ver;
         unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
         /* Initialize our shell local variables with the values
          * currently living in the environment */
-        cur_var = top_var;
+        cur_var = G.top_var;
         e = environ;
         if (e) while (*e) {
                 char *value = strchr(*e, '=');
@@ -4087,22 +4051,22 @@ int hush_main(int argc, char **argv)
         putenv((char *)version_str); /* reinstate HUSH_VERSION */
 
 #if ENABLE_FEATURE_EDITING
-        line_input_state = new_line_input_t(FOR_SHELL);
+        G.line_input_state = new_line_input_t(FOR_SHELL);
 #endif
         /* XXX what should these be while sourcing /etc/profile? */
-        global_argc = argc;
-        global_argv = argv;
+        G.global_argc = argc;
+        G.global_argv = argv;
         /* Initialize some more globals to non-zero values */
         set_cwd();
 #if ENABLE_HUSH_INTERACTIVE
 #if ENABLE_FEATURE_EDITING
         cmdedit_set_initial_prompt();
 #endif
-        PS2 = "> ";
+        G.PS2 = "> ";
 #endif
 
         if (EXIT_SUCCESS) /* otherwise is already done */
-                last_return_code = EXIT_SUCCESS;
+                G.last_return_code = EXIT_SUCCESS;
 
         if (argv[0] && argv[0][0] == '-') {
                 debug_printf("sourcing /etc/profile\n");
@@ -4118,17 +4082,17 @@ int hush_main(int argc, char **argv)
         while ((opt = getopt(argc, argv, "c:xif")) > 0) {
                 switch (opt) {
                 case 'c':
-                        global_argv = argv + optind;
-                        global_argc = argc - optind;
+                        G.global_argv = argv + optind;
+                        G.global_argc = argc - optind;
                         opt = parse_and_run_string(optarg, 0 /* parse_flag */);
                         goto final_return;
                 case 'i':
                         /* Well, we cannot just declare interactiveness,
                          * we have to have some stuff (ctty, etc) */
-                        /* interactive_fd++; */
+                        /* G.interactive_fd++; */
                         break;
                 case 'f':
-                        fake_mode = 1;
+                        G.fake_mode = 1;
                         break;
                 default:
 #ifndef BB_VER
@@ -4151,25 +4115,25 @@ int hush_main(int argc, char **argv)
         if (argv[optind] == NULL && input == stdin
          && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
         ) {
-                saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
-                debug_printf("saved_tty_pgrp=%d\n", saved_tty_pgrp);
-                if (saved_tty_pgrp >= 0) {
+                G.saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
+                debug_printf("saved_tty_pgrp=%d\n", G.saved_tty_pgrp);
+                if (G.saved_tty_pgrp >= 0) {
                         /* try to dup to high fd#, >= 255 */
-                        interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
-                        if (interactive_fd < 0) {
+                        G.interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
+                        if (G.interactive_fd < 0) {
                                 /* try to dup to any fd */
-                                interactive_fd = dup(STDIN_FILENO);
-                                if (interactive_fd < 0)
+                                G.interactive_fd = dup(STDIN_FILENO);
+                                if (G.interactive_fd < 0)
                                         /* give up */
-                                        interactive_fd = 0;
+                                        G.interactive_fd = 0;
                         }
                         // TODO: track & disallow any attempts of user
                         // to (inadvertently) close/redirect it
                 }
         }
-        debug_printf("interactive_fd=%d\n", interactive_fd);
-        if (interactive_fd) {
-                fcntl(interactive_fd, F_SETFD, FD_CLOEXEC);
+        debug_printf("G.interactive_fd=%d\n", G.interactive_fd);
+        if (G.interactive_fd) {
+                fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
                 /* Looks like they want an interactive shell */
                 setup_job_control();
                 /* -1 is special - makes xfuncs longjmp, not exit
@@ -4189,16 +4153,16 @@ int hush_main(int argc, char **argv)
         if (argv[optind] == NULL && input == stdin
          && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
         ) {
-                interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
-                if (interactive_fd < 0) {
+                G.interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
+                if (G.interactive_fd < 0) {
                         /* try to dup to any fd */
-                        interactive_fd = dup(STDIN_FILENO);
-                        if (interactive_fd < 0)
+                        G.interactive_fd = dup(STDIN_FILENO);
+                        if (G.interactive_fd < 0)
                                 /* give up */
-                                interactive_fd = 0;
+                                G.interactive_fd = 0;
                 }
-                if (interactive_fd) {
-                        fcntl(interactive_fd, F_SETFD, FD_CLOEXEC);
+                if (G.interactive_fd) {
+                        fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
                         set_misc_sighandler(SIG_IGN);
                 }
         }
@@ -4208,8 +4172,8 @@ int hush_main(int argc, char **argv)
                 opt = parse_and_run_file(stdin);
         } else {
                 debug_printf("\nrunning script '%s'\n", argv[optind]);
-                global_argv = argv + optind;
-                global_argc = argc - optind;
+                G.global_argv = argv + optind;
+                G.global_argc = argc - optind;
                 input = xfopen_for_read(argv[optind]);
                 fcntl(fileno(input), F_SETFD, FD_CLOEXEC);
                 opt = parse_and_run_file(input);
@@ -4219,9 +4183,9 @@ int hush_main(int argc, char **argv)
 
 #if ENABLE_FEATURE_CLEAN_UP
         fclose(input);
-        if (cwd != bb_msg_unknown)
-                free((char*)cwd);
-        cur_var = top_var->next;
+        if (G.cwd != bb_msg_unknown)
+                free((char*)G.cwd);
+        cur_var = G.top_var->next;
         while (cur_var) {
                 struct variable *tmp = cur_var;
                 if (!cur_var->max_len)
@@ -4230,7 +4194,7 @@ int hush_main(int argc, char **argv)
                 free(tmp);
         }
 #endif
-        hush_exit(opt ? opt : last_return_code);
+        hush_exit(opt ? opt : G.last_return_code);
 }
 
 
@@ -4280,7 +4244,7 @@ static int builtin_eval(char **argv)
                 char *str = expand_strvec_to_string(argv + 1);
                 parse_and_run_string(str, PARSEFLAG_EXIT_FROM_LOOP);
                 free(str);
-                rcode = last_return_code;
+                rcode = G.last_return_code;
         }
         return rcode;
 }
@@ -4323,7 +4287,7 @@ static int builtin_exit(char **argv)
 // TODO: warn if we have background jobs: "There are stopped jobs"
 // On second consecutive 'exit', exit anyway.
         if (argv[1] == NULL)
-                hush_exit(last_return_code);
+                hush_exit(G.last_return_code);
         /* mimic bash: exit 123abc == exit 255 + error msg */
         xfunc_error_retval = 255;
         /* bash: exit -2 == exit 254, no error msg */
@@ -4373,12 +4337,12 @@ static int builtin_fg_bg(char **argv)
         int i, jobnum;
         struct pipe *pi;
 
-        if (!interactive_fd)
+        if (!G.interactive_fd)
                 return EXIT_FAILURE;
         /* If they gave us no args, assume they want the last backgrounded task */
         if (!argv[1]) {
-                for (pi = job_list; pi; pi = pi->next) {
-                        if (pi->jobid == last_jobid) {
+                for (pi = G.job_list; pi; pi = pi->next) {
+                        if (pi->jobid == G.last_jobid) {
                                 goto found;
                         }
                 }
@@ -4389,7 +4353,7 @@ static int builtin_fg_bg(char **argv)
                 bb_error_msg("%s: bad argument '%s'", argv[0], argv[1]);
                 return EXIT_FAILURE;
         }
-        for (pi = job_list; pi; pi = pi->next) {
+        for (pi = G.job_list; pi; pi = pi->next) {
                 if (pi->jobid == jobnum) {
                         goto found;
                 }
@@ -4401,7 +4365,7 @@ static int builtin_fg_bg(char **argv)
         // of job being foregrounded (like "sleep 1 | cat")
         if (*argv[0] == 'f') {
                 /* Put the job into the foreground.  */
-                tcsetpgrp(interactive_fd, pi->pgrp);
+                tcsetpgrp(G.interactive_fd, pi->pgrp);
         }
 
         /* Restart the processes in the job */
@@ -4451,7 +4415,7 @@ static int builtin_jobs(char **argv UNUSED_PARAM)
         struct pipe *job;
         const char *status_string;
 
-        for (job = job_list; job; job = job->next) {
+        for (job = G.job_list; job; job = job->next) {
                 if (job->alive_progs == job->stopped_progs)
                         status_string = "Stopped";
                 else
@@ -4485,7 +4449,7 @@ static int builtin_set(char **argv)
         struct variable *e;
 
         if (temp == NULL)
-                for (e = top_var; e; e = e->next)
+                for (e = G.top_var; e; e = e->next)
                         puts(e->varstr);
         else
                 set_local_var(xstrdup(temp), 0);
@@ -4499,10 +4463,10 @@ static int builtin_shift(char **argv)
         if (argv[1]) {
                 n = atoi(argv[1]);
         }
-        if (n >= 0 && n < global_argc) {
-                global_argv[n] = global_argv[0];
-                global_argc -= n;
-                global_argv += n;
+        if (n >= 0 && n < G.global_argc) {
+                G.global_argv[n] = G.global_argv[0];
+                G.global_argc -= n;
+                G.global_argv += n;
                 return EXIT_SUCCESS;
         }
         return EXIT_FAILURE;
@@ -4525,9 +4489,9 @@ static int builtin_source(char **argv)
         close_on_exec_on(fileno(input));
 
         /* Now run the file */
-        /* XXX argv and argc are broken; need to save old global_argv
+        /* XXX argv and argc are broken; need to save old G.global_argv
          * (pointer only is OK!) on this stack frame,
-         * set global_argv=argv+1, recurse, and restore. */
+         * set G.global_argv=argv+1, recurse, and restore. */
         status = parse_and_run_file(input);
         fclose(input);
         return status;
@@ -4561,29 +4525,29 @@ static int builtin_unset(char **argv)
 #if ENABLE_HUSH_LOOPS
 static int builtin_break(char **argv)
 {
-        if (depth_of_loop == 0) {
+        if (G.depth_of_loop == 0) {
                 bb_error_msg("%s: only meaningful in a loop", "break");
                 return EXIT_SUCCESS; /* bash compat */
         }
-        flag_break_continue++; /* BC_BREAK = 1 */
-        depth_break_continue = 1;
+        G.flag_break_continue++; /* BC_BREAK = 1 */
+        G.depth_break_continue = 1;
         if (argv[1]) {
-                depth_break_continue = bb_strtou(argv[1], NULL, 10);
-                if (errno || !depth_break_continue || argv[2]) {
+                G.depth_break_continue = bb_strtou(argv[1], NULL, 10);
+                if (errno || !G.depth_break_continue || argv[2]) {
                         bb_error_msg("bad arguments");
-                        flag_break_continue = BC_BREAK;
-                        depth_break_continue = UINT_MAX;
+                        G.flag_break_continue = BC_BREAK;
+                        G.depth_break_continue = UINT_MAX;
                 }
         }
-        if (depth_of_loop < depth_break_continue)
-                depth_break_continue = depth_of_loop;
+        if (G.depth_of_loop < G.depth_break_continue)
+                G.depth_break_continue = G.depth_of_loop;
         return EXIT_SUCCESS;
 }
 
 static int builtin_continue(char **argv)
 {
-        if (depth_of_loop) {
-                flag_break_continue++; /* BC_CONTINUE = 2 = 1+1 */
+        if (G.depth_of_loop) {
+                G.flag_break_continue = 1; /* BC_CONTINUE = 2 = 1+1 */
                 return builtin_break(argv);
         }
         bb_error_msg("%s: only meaningful in a loop", "continue");