hush: style fixes

1 files changed, 332 insertions, 314 deletions

diff --git a/shell/hush.c b/shell/hush.c
index 1540327f1..1ff9b7fd5 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -79,21 +79,11 @@
  */
 
 #include "busybox.h"
-#include <ctype.h>     /* isalpha, isdigit */
-#include <unistd.h>    /* getpid */
-#include <stdlib.h>    /* getenv, atoi */
-#include <string.h>    /* strchr */
-#include <stdio.h>     /* popen etc. */
 #include <glob.h>      /* glob, of course */
-#include <stdarg.h>    /* va_list */
-#include <errno.h>
-#include <fcntl.h>
 #include <getopt.h>    /* should be pretty obvious */
 
-#include <sys/stat.h>  /* ulimit */
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <signal.h>
+//#include <sys/wait.h>
+//#include <signal.h>
 
 /* #include <dmalloc.h> */
 /* #define DEBUG_SHELL */
@@ -168,46 +158,46 @@ struct p_context {
         struct pipe *pipe;
         struct redir_struct *pending_redirect;
         reserved_style w;
-        int old_flag;                           /* for figuring out valid reserved words */
+        int old_flag;               /* for figuring out valid reserved words */
         struct p_context *stack;
-        int type;                       /* define type of parser : ";$" common or special symbol */
+        int type;           /* define type of parser : ";$" common or special symbol */
         /* How about quoting status? */
 };
 
 struct redir_struct {
-        redir_type type;                        /* type of redirection */
-        int fd;                                         /* file descriptor being redirected */
-        int dup;                                        /* -1, or file descriptor being duplicated */
-        struct redir_struct *next;      /* pointer to the next redirect in the list */
-        glob_t word;                            /* *word.gl_pathv is the filename */
+        redir_type type;            /* type of redirection */
+        int fd;                     /* file descriptor being redirected */
+        int dup;                    /* -1, or file descriptor being duplicated */
+        struct redir_struct *next;  /* pointer to the next redirect in the list */
+        glob_t word;                /* *word.gl_pathv is the filename */
 };
 
 struct child_prog {
-        pid_t pid;                                      /* 0 if exited */
-        char **argv;                            /* program name and arguments */
-        struct pipe *group;                     /* if non-NULL, first in group or subshell */
-        int subshell;                           /* flag, non-zero if group must be forked */
-        struct redir_struct *redirects; /* I/O redirections */
-        glob_t glob_result;                     /* result of parameter globbing */
-        int is_stopped;                         /* is the program currently running? */
-        struct pipe *family;            /* pointer back to the child's parent pipe */
-        int sp;                         /* number of SPECIAL_VAR_SYMBOL */
+        pid_t pid;                  /* 0 if exited */
+        char **argv;                /* program name and arguments */
+        struct pipe *group;         /* if non-NULL, first in group or subshell */
+        int subshell;               /* flag, non-zero if group must be forked */
+        struct redir_struct *redirects; /* I/O redirections */
+        glob_t glob_result;         /* result of parameter globbing */
+        int is_stopped;             /* is the program currently running? */
+        struct pipe *family;        /* pointer back to the child's parent pipe */
+        int sp;                     /* number of SPECIAL_VAR_SYMBOL */
         int type;
 };
 
 struct pipe {
-        int jobid;                                      /* job number */
-        int num_progs;                          /* total number of programs in job */
-        int running_progs;                      /* number of programs running */
-        char *text;                                     /* name of job */
-        char *cmdbuf;                           /* buffer various argv's point into */
-        pid_t pgrp;                                     /* process group ID for the job */
-        struct child_prog *progs;       /* array of commands in pipe */
-        struct pipe *next;                      /* to track background commands */
-        int stopped_progs;                      /* number of programs alive, but stopped */
-        int job_context;                        /* bitmask defining current context */
-        pipe_style followup;            /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
-        reserved_style r_mode;          /* supports if, for, while, until */
+        int jobid;                  /* job number */
+        int num_progs;              /* total number of programs in job */
+        int running_progs;          /* number of programs running */
+        char *text;                 /* name of job */
+        char *cmdbuf;               /* buffer various argv's point into */
+        pid_t pgrp;                 /* process group ID for the job */
+        struct child_prog *progs;   /* array of commands in pipe */
+        struct pipe *next;          /* to track background commands */
+        int stopped_progs;          /* number of programs alive, but stopped */
+        int job_context;            /* bitmask defining current context */
+        pipe_style followup;        /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
+        reserved_style r_mode;      /* supports if, for, while, until */
 };
 
 struct close_me {
@@ -238,9 +228,9 @@ static int interactive;
 static struct close_me *close_me_head;
 static const char *cwd;
 static struct pipe *job_list;
-static unsigned int last_bg_pid;
+static unsigned last_bg_pid;
 static int last_jobid;
-static unsigned int shell_terminal;
+static unsigned shell_terminal;
 static char *PS1;
 static char *PS2;
 static struct variables shell_ver = { "HUSH_VERSION", "0.01", 1, 1, 0 };
@@ -301,11 +291,11 @@ static void debug_printf(const char *format, ...)
 /* broken, of course, but OK for testing */
 static char *indenter(int i)
 {
-        static char blanks[]="                                    ";
+        static char blanks[] = "                                    ";
         return &blanks[sizeof(blanks)-i-1];
 }
 #else
-#define debug_printf(...) do {;} while(0);
+#define debug_printf(...) do {;} while (0);
 #endif
 #define final_printf debug_printf
 
@@ -340,7 +330,7 @@ static int b_check_space(o_string *o, int len);
 static int b_addchr(o_string *o, int ch);
 static void b_reset(o_string *o);
 static int b_addqchr(o_string *o, int ch, int quote);
-static int b_adduint(o_string *o, unsigned int i);
+static int b_adduint(o_string *o, unsigned i);
 /*  in_str manipulations: */
 static int static_get(struct in_str *i);
 static int static_peek(struct in_str *i);
@@ -404,35 +394,35 @@ static int set_local_var(const char *s, int flg_export);
  * For example, 'unset foo | whatever' will parse and run, but foo will
  * still be set at the end. */
 static const struct built_in_command bltins[] = {
-        {"bg", "Resume a job in the background", builtin_fg_bg},
-        {"break", "Exit for, while or until loop", builtin_not_written},
-        {"cd", "Change working directory", builtin_cd},
-        {"continue", "Continue for, while or until loop", builtin_not_written},
-        {"env", "Print all environment variables", builtin_env},
-        {"eval", "Construct and run shell command", builtin_eval},
-        {"exec", "Exec command, replacing this shell with the exec'd process",
-                builtin_exec},
-        {"exit", "Exit from shell()", builtin_exit},
-        {"export", "Set environment variable", builtin_export},
-        {"fg", "Bring job into the foreground", builtin_fg_bg},
-        {"jobs", "Lists the active jobs", builtin_jobs},
-        {"pwd", "Print current directory", builtin_pwd},
-        {"read", "Input environment variable", builtin_read},
-        {"return", "Return from a function", builtin_not_written},
-        {"set", "Set/unset shell local variables", builtin_set},
-        {"shift", "Shift positional parameters", builtin_shift},
-        {"trap", "Trap signals", builtin_not_written},
-        {"ulimit","Controls resource limits", builtin_not_written},
-        {"umask","Sets file creation mask", builtin_umask},
-        {"unset", "Unset environment variable", builtin_unset},
-        {".", "Source-in and run commands in a file", builtin_source},
-        {"help", "List shell built-in commands", builtin_help},
-        {NULL, NULL, NULL}
+        { "bg", "Resume a job in the background", builtin_fg_bg },
+        { "break", "Exit for, while or until loop", builtin_not_written },
+        { "cd", "Change working directory", builtin_cd },
+        { "continue", "Continue for, while or until loop", builtin_not_written },
+        { "env", "Print all environment variables", builtin_env },
+        { "eval", "Construct and run shell command", builtin_eval },
+        { "exec", "Exec command, replacing this shell with the exec'd process",
+                builtin_exec },
+        { "exit", "Exit from shell()", builtin_exit },
+        { "export", "Set environment variable", builtin_export },
+        { "fg", "Bring job into the foreground", builtin_fg_bg },
+        { "jobs", "Lists the active jobs", builtin_jobs },
+        { "pwd", "Print current directory", builtin_pwd },
+        { "read", "Input environment variable", builtin_read },
+        { "return", "Return from a function", builtin_not_written },
+        { "set", "Set/unset shell local variables", builtin_set },
+        { "shift", "Shift positional parameters", builtin_shift },
+        { "trap", "Trap signals", builtin_not_written },
+        { "ulimit","Controls resource limits", builtin_not_written },
+        { "umask","Sets file creation mask", builtin_umask },
+        { "unset", "Unset environment variable", builtin_unset },
+        { ".", "Source-in and run commands in a file", builtin_source },
+        { "help", "List shell built-in commands", builtin_help },
+        { NULL, NULL, NULL }
 };
 
 static const char *set_cwd(void)
 {
-        if(cwd==bb_msg_unknown)
+        if (cwd == bb_msg_unknown)
                 cwd = NULL;     /* xgetcwd(arg) called free(arg) */
         cwd = xgetcwd((char *)cwd);
         if (!cwd)
@@ -477,8 +467,8 @@ static int builtin_env(struct child_prog *dummy ATTRIBUTE_UNUSED)
 {
         char **e = environ;
         if (e == NULL) return EXIT_FAILURE;
-        for (; *e; e++) {
-                puts(*e);
+        for (*e) {
+                puts(*e++);
         }
         return EXIT_SUCCESS;
 }
@@ -513,7 +503,7 @@ static int builtin_export(struct child_prog *child)
 
         name = strdup(name);
 
-        if(name) {
+        if (name) {
                 const char *value = strchr(name, '=');
 
                 if (!value) {
@@ -525,7 +515,7 @@ static int builtin_export(struct child_prog *child)
                                 size_t ln = strlen(name);
 
                                 tmp = realloc(name, ln+strlen(value)+2);
-                                if(tmp==NULL)
+                                if (tmp == NULL)
                                         res = -1;
                                 else {
                                         sprintf(tmp+ln, "=%s", value);
@@ -538,9 +528,9 @@ static int builtin_export(struct child_prog *child)
                         }
                 }
         }
-        if (res<0)
+        if (res < 0)
                 bb_perror_msg("export");
-        else if(res==0)
+        else if (res == 0)
                 res = set_local_var(name, 1);
         else
                 res = 0;
@@ -552,7 +542,7 @@ static int builtin_export(struct child_prog *child)
 static int builtin_fg_bg(struct child_prog *child)
 {
         int i, jobnum;
-        struct pipe *pi=NULL;
+        struct pipe *pi = NULL;
 
         if (!interactive)
                 return EXIT_FAILURE;
@@ -612,7 +602,7 @@ static int builtin_help(struct child_prog *dummy ATTRIBUTE_UNUSED)
         printf("\nBuilt-in commands:\n");
         printf("-------------------\n");
         for (x = bltins; x->cmd; x++) {
-                if (x->descr==NULL)
+                if (x->descr == NULL)
                         continue;
                 printf("%s\t%s\n", x->cmd, x->descr);
         }
@@ -624,7 +614,7 @@ static int builtin_help(struct child_prog *dummy ATTRIBUTE_UNUSED)
 static int builtin_jobs(struct child_prog *child ATTRIBUTE_UNUSED)
 {
         struct pipe *job;
-        char *status_string;
+        const char *status_string;
 
         for (job = job_list; job; job = job->next) {
                 if (job->running_progs == job->stopped_progs)
@@ -652,14 +642,14 @@ static int builtin_read(struct child_prog *child)
 
         if (child->argv[1]) {
                 char string[BUFSIZ];
-                char *var = 0;
+                char *var = NULL;
 
-                string[0] = 0;  /* In case stdin has only EOF */
+                string[0] = '\0';  /* In case stdin has only EOF */
                 /* read string */
                 fgets(string, sizeof(string), stdin);
                 chomp(string);
-                var = malloc(strlen(child->argv[1])+strlen(string)+2);
-                if(var) {
+                var = malloc(strlen(child->argv[1]) + strlen(string) + 2);
+                if (var) {
                         sprintf(var, "%s=%s", child->argv[1], string);
                         res = set_local_var(var, 0);
                 } else
@@ -668,10 +658,9 @@ static int builtin_read(struct child_prog *child)
                         bb_perror_msg("read");
                 free(var);      /* So not move up to avoid breaking errno */
                 return res;
-        } else {
-                do res=getchar(); while(res!='\n' && res!=EOF);
-                return 0;
         }
+        do res = getchar(); while (res != '\n' && res != EOF);
+        return 0;
 }
 
 /* built-in 'set VAR=value' handler */
@@ -681,23 +670,23 @@ static int builtin_set(struct child_prog *child)
         struct variables *e;
 
         if (temp == NULL)
-                for(e = top_vars; e; e=e->next)
+                for (e = top_vars; e; e = e->next)
                         printf("%s=%s\n", e->name, e->value);
         else
                 set_local_var(temp, 0);
 
-                return EXIT_SUCCESS;
+        return EXIT_SUCCESS;
 }
 
 
 /* Built-in 'shift' handler */
 static int builtin_shift(struct child_prog *child)
 {
-        int n=1;
+        int n = 1;
         if (child->argv[1]) {
-                n=atoi(child->argv[1]);
+                n = atoi(child->argv[1]);
         }
-        if (n>=0 && n<global_argc) {
+        if (n >= 0 && n < global_argc) {
                 /* XXX This probably breaks $0 */
                 global_argc -= n;
                 global_argv += n;
@@ -740,12 +729,13 @@ static int builtin_umask(struct child_prog *child)
         const char *arg = child->argv[1];
         char *end;
         if (arg) {
-                new_umask=strtoul(arg, &end, 8);
-                if (*end!='\0' || end == arg) {
+                new_umask = strtoul(arg, &end, 8);
+                if (*end != '\0' || end == arg) {
                         return EXIT_FAILURE;
                 }
         } else {
-                printf("%.3o\n", (unsigned int) (new_umask=umask(0)));
+                new_umask = umask(0);
+                printf("%.3o\n", (unsigned) new_umask);
         }
         umask(new_umask);
         return EXIT_SUCCESS;
@@ -761,7 +751,7 @@ static int builtin_unset(struct child_prog *child)
 
 static int builtin_not_written(struct child_prog *child)
 {
-        printf("builtin_%s not written\n",child->argv[0]);
+        printf("builtin_%s not written\n", child->argv[0]);
         return EXIT_FAILURE;
 }
 
@@ -784,7 +774,8 @@ static int b_check_space(o_string *o, int len)
 static int b_addchr(o_string *o, int ch)
 {
         debug_printf("b_addchr: %c %d %p\n", ch, o->length, o);
-        if (b_check_space(o, 1)) return B_NOSPAC;
+        if (b_check_space(o, 1))
+                return B_NOSPAC;
         o->data[o->length] = ch;
         o->length++;
         o->data[o->length] = '\0';
@@ -795,7 +786,8 @@ static void b_reset(o_string *o)
 {
         o->length = 0;
         o->nonnull = 0;
-        if (o->data != NULL) *o->data = '\0';
+        if (o->data != NULL)
+                *o->data = '\0';
 }
 
 static void b_free(o_string *o)
@@ -814,17 +806,17 @@ static int b_addqchr(o_string *o, int ch, int quote)
         if (quote && strchr("*?[\\",ch)) {
                 int rc;
                 rc = b_addchr(o, '\\');
-                if (rc) return rc;
+                if (rc)
+                        return rc;
         }
         return b_addchr(o, ch);
 }
 
 /* belongs in utility.c */
-static char *simple_itoa(unsigned int i)
+static char *simple_itoa(unsigned i)
 {
-        /* 21 digits plus null terminator, good for 64-bit or smaller ints */
-        static char local[22];
-        char *p = &local[21];
+        static char local[sizeof(int)*3 + 2];
+        char *p = &local[sizeof(int)*3 + 2 - 1];
         *p-- = '\0';
         do {
                 *p-- = '0' + i % 10;
@@ -833,19 +825,19 @@ static char *simple_itoa(unsigned int i)
         return p + 1;
 }
 
-static int b_adduint(o_string *o, unsigned int i)
+static int b_adduint(o_string *o, unsigned i)
 {
         int r;
         char *p = simple_itoa(i);
         /* no escape checking necessary */
-        do r=b_addchr(o, *p++); while (r==0 && *p);
+        do r = b_addchr(o, *p++); while (r==0 && *p);
         return r;
 }
 
 static int static_get(struct in_str *i)
 {
-        int ch=*i->p++;
-        if (ch=='\0') return EOF;
+        int ch = *i->p++;
+        if (ch == '\0') return EOF;
         return ch;
 }
 
@@ -860,7 +852,7 @@ static void cmdedit_set_initial_prompt(void)
         PS1 = NULL;
 #else
         PS1 = getenv("PS1");
-        if(PS1==0)
+        if (PS1 == NULL)
                 PS1 = "\\w \\$ ";
 #endif
 }
@@ -872,16 +864,16 @@ static void setup_prompt_string(int promptmode, char **prompt_str)
         /* Set up the prompt */
         if (promptmode == 1) {
                 free(PS1);
-                PS1=xmalloc(strlen(cwd)+4);
-                sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ?  "$ ":"# ");
+                PS1 = xmalloc(strlen(cwd)+4);
+                sprintf(PS1, "%s %s", cwd, (geteuid() != 0) ? "$ " : "# ");
                 *prompt_str = PS1;
         } else {
                 *prompt_str = PS2;
         }
 #else
-        *prompt_str = (promptmode==1)? PS1 : PS2;
+        *prompt_str = (promptmode == 1) ? PS1 : PS2;
 #endif
-        debug_printf("result %s\n",*prompt_str);
+        debug_printf("result %s\n", *prompt_str);
 }
 
 #if ENABLE_FEATURE_EDITING
@@ -905,8 +897,8 @@ static void get_user_input(struct in_str *i)
 #else
         fputs(prompt_str, stdout);
         fflush(stdout);
-        the_command[0]=fgetc(i->file);
-        the_command[1]='\0';
+        the_command[0] = fgetc(i->file);
+        the_command[1] = '\0';
 #endif
         fflush(stdout);
         i->p = the_command;
@@ -921,18 +913,18 @@ static int file_get(struct in_str *i)
         ch = 0;
         /* If there is data waiting, eat it up */
         if (i->p && *i->p) {
-                ch=*i->p++;
+                ch = *i->p++;
         } else {
                 /* need to double check i->file because we might be doing something
                  * more complicated by now, like sourcing or substituting. */
                 if (i->__promptme && interactive && i->file == stdin) {
-                        while(! i->p || (interactive && strlen(i->p)==0) ) {
+                        while (!i->p || !(interactive && strlen(i->p))) {
                                 get_user_input(i);
                         }
-                        i->promptmode=2;
+                        i->promptmode = 2;
                         i->__promptme = 0;
                         if (i->p && *i->p) {
-                                ch=*i->p++;
+                                ch = *i->p++;
                         }
                 } else {
                         ch = fgetc(i->file);
@@ -940,7 +932,8 @@ static int file_get(struct in_str *i)
 
                 debug_printf("b_getch: got a %d\n", ch);
         }
-        if (ch == '\n') i->__promptme=1;
+        if (ch == '\n')
+                i->__promptme = 1;
         return ch;
 }
 
@@ -964,8 +957,8 @@ static void setup_file_in_str(struct in_str *i, FILE *f)
 {
         i->peek = file_peek;
         i->get = file_get;
-        i->__promptme=1;
-        i->promptmode=1;
+        i->__promptme = 1;
+        i->promptmode = 1;
         i->file = f;
         i->p = NULL;
 }
@@ -1000,7 +993,7 @@ static void mark_closed(int fd)
 static void close_all(void)
 {
         struct close_me *c;
-        for (c=close_me_head; c; c=c->next) {
+        for (c = close_me_head; c; c = c->next) {
                 close(c->fd);
         }
         close_me_head = NULL;
@@ -1013,13 +1006,13 @@ static int setup_redirects(struct child_prog *prog, int squirrel[])
         int openfd, mode;
         struct redir_struct *redir;
 
-        for (redir=prog->redirects; redir; redir=redir->next) {
+        for (redir = prog->redirects; redir; redir = redir->next) {
                 if (redir->dup == -1 && redir->word.gl_pathv == NULL) {
                         /* something went wrong in the parse.  Pretend it didn't happen */
                         continue;
                 }
                 if (redir->dup == -1) {
-                        mode=redir_table[redir->type].mode;
+                        mode = redir_table[redir->type].mode;
                         openfd = open(redir->word.gl_pathv[0], mode, 0666);
                         if (openfd < 0) {
                         /* this could get lost if stderr has been redirected, but
@@ -1050,7 +1043,7 @@ static int setup_redirects(struct child_prog *prog, int squirrel[])
 static void restore_redirects(int squirrel[])
 {
         int i, fd;
-        for (i=0; i<3; i++) {
+        for (i = 0; i < 3; i++) {
                 fd = squirrel[i];
                 if (fd != -1) {
                         /* No error checking.  I sure wouldn't know what
@@ -1071,13 +1064,15 @@ static void pseudo_exec(struct child_prog *child)
         char *p;
         const struct built_in_command *x;
         if (child->argv) {
-                for (i=0; is_assignment(child->argv[i]); i++) {
-                        debug_printf("pid %d environment modification: %s\n",getpid(),child->argv[i]);
+                for (i = 0; is_assignment(child->argv[i]); i++) {
+                        debug_printf("pid %d environment modification: %s\n",
+                                        getpid(), child->argv[i]);
                         p = insert_var_value(child->argv[i]);
                         putenv(strdup(p));
-                        if (p != child->argv[i]) free(p);
+                        if (p != child->argv[i])
+                                free(p);
                 }
-                child->argv+=i;  /* XXX this hack isn't so horrible, since we are about
+                child->argv += i;  /* XXX this hack isn't so horrible, since we are about
                                         to exit, and therefore don't need to keep data
                                         structures consistent for free() use. */
                 /* If a variable is assigned in a forest, and nobody listens,
@@ -1118,19 +1113,20 @@ static void pseudo_exec(struct child_prog *child)
                         char *name = child->argv[0];
 
                         /* Count argc for use in a second... */
-                        for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
+                        for (argc_l = 0; *argv_l; argv_l++, argc_l++)
+                                /**/;
                         optind = 1;
                         debug_printf("running applet %s\n", name);
                         run_applet_by_name(name, argc_l, child->argv);
                 }
 #endif
-                debug_printf("exec of %s\n",child->argv[0]);
-                execvp(child->argv[0],child->argv);
-                bb_perror_msg("cannot exec: %s",child->argv[0]);
+                debug_printf("exec of %s\n", child->argv[0]);
+                execvp(child->argv[0], child->argv);
+                bb_perror_msg("cannot exec: %s", child->argv[0]);
                 _exit(1);
         } else if (child->group) {
                 debug_printf("runtime nesting to group\n");
-                interactive=0;    /* crucial!!!! */
+                interactive = 0;    /* crucial!!!! */
                 rcode = run_list_real(child->group);
                 /* OK to leak memory by not calling free_pipe_list,
                  * since this process is about to exit */
@@ -1156,7 +1152,8 @@ static void insert_bg_job(struct pipe *pi)
         if (!job_list) {
                 thejob = job_list = xmalloc(sizeof(*thejob));
         } else {
-                for (thejob = job_list; thejob->next; thejob = thejob->next) /* nothing */;
+                for (thejob = job_list; thejob->next; thejob = thejob->next)
+                        /* nothing */;
                 thejob->next = xmalloc(sizeof(*thejob));
                 thejob = thejob->next;
         }
@@ -1170,11 +1167,11 @@ static void insert_bg_job(struct pipe *pi)
 
         //if (pi->progs[0] && pi->progs[0].argv && pi->progs[0].argv[0])
         {
-                char *bar=thejob->text;
-                char **foo=pi->progs[0].argv;
-                while(foo && *foo) {
-                        bar += sprintf(bar, "%s ", *foo++);
-                }
+                char *bar = thejob->text;
+                char **foo = pi->progs[0].argv;
+                if (foo)
+                        while (*foo)
+                                bar += sprintf(bar, "%s ", *foo++);
         }
 
         /* we don't wait for background thejobs to return -- append it
@@ -1218,18 +1215,18 @@ static int checkjobs(struct pipe* fg_pipe)
         pid_t childpid;
 
         attributes = WUNTRACED;
-        if (fg_pipe==NULL) {
+        if (fg_pipe == NULL) {
                 attributes |= WNOHANG;
         }
 
         while ((childpid = waitpid(-1, &status, attributes)) > 0) {
                 if (fg_pipe) {
                         int i, rcode = 0;
-                        for (i=0; i < fg_pipe->num_progs; i++) {
+                        for (i = 0; i < fg_pipe->num_progs; i++) {
                                 if (fg_pipe->progs[i].pid == childpid) {
-                                        if (i==fg_pipe->num_progs-1)
-                                                rcode=WEXITSTATUS(status);
-                                        (fg_pipe->num_progs)--;
+                                        if (i == fg_pipe->num_progs-1)
+                                                rcode = WEXITSTATUS(status);
+                                        fg_pipe->num_progs--;
                                         return rcode;
                                 }
                         }
@@ -1244,8 +1241,9 @@ static int checkjobs(struct pipe* fg_pipe)
                                 break;
                 }
 
-                if(pi==NULL) {
-                        debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
+                if (pi == NULL) {
+                        debug_printf("checkjobs: pid %d was not in our list!\n",
+                                        childpid);
                         continue;
                 }
 
@@ -1255,7 +1253,8 @@ static int checkjobs(struct pipe* fg_pipe)
                         pi->progs[prognum].pid = 0;
 
                         if (!pi->running_progs) {
-                                printf(JOB_STATUS_FORMAT, pi->jobid, "Done", pi->text);
+                                printf(JOB_STATUS_FORMAT, pi->jobid,
+                                                        "Done", pi->text);
                                 remove_bg_job(pi);
                         }
                 } else {
@@ -1306,9 +1305,9 @@ static int run_pipe_real(struct pipe *pi)
          * Builtins within pipes have to fork anyway, and are handled in
          * pseudo_exec.  "echo foo | read bar" doesn't work on bash, either.
          */
-        child = & (pi->progs[0]);
+        child = &(pi->progs[0]);
         if (pi->num_progs == 1 && child->group && child->subshell == 0) {
-                int squirrel[] = {-1, -1, -1};
+                int squirrel[] = { -1, -1, -1 };
                 int rcode;
                 debug_printf("non-subshell grouping\n");
                 setup_redirects(child, squirrel);
@@ -1318,31 +1317,32 @@ static int run_pipe_real(struct pipe *pi)
                 restore_redirects(squirrel);
                 return rcode;
         } else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
-                for (i=0; is_assignment(child->argv[i]); i++) { /* nothing */ }
-                if (i!=0 && child->argv[i]==NULL) {
+                for (i = 0; is_assignment(child->argv[i]); i++)
+                        /* nothing */;
+                if (i != 0 && child->argv[i] == NULL) {
                         /* assignments, but no command: set the local environment */
-                        for (i=0; child->argv[i]!=NULL; i++) {
-
+                        for (i = 0; child->argv[i] != NULL; i++) {
                                 /* Ok, this case is tricky.  We have to decide if this is a
                                  * local variable, or an already exported variable.  If it is
                                  * already exported, we have to export the new value.  If it is
                                  * not exported, we need only set this as a local variable.
                                  * This junk is all to decide whether or not to export this
                                  * variable. */
-                                int export_me=0;
+                                int export_me = 0;
                                 char *name, *value;
                                 name = xstrdup(child->argv[i]);
                                 debug_printf("Local environment set: %s\n", name);
                                 value = strchr(name, '=');
                                 if (value)
-                                        *value=0;
-                                if ( get_local_var(name)) {
-                                        export_me=1;
+                                        *value = 0;
+                                if (get_local_var(name)) {
+                                        export_me = 1;
                                 }
                                 free(name);
                                 p = insert_var_value(child->argv[i]);
                                 set_local_var(p, export_me);
-                                if (p != child->argv[i]) free(p);
+                                if (p != child->argv[i])
+                                        free(p);
                         }
                         return EXIT_SUCCESS;   /* don't worry about errors in set_local_var() yet */
                 }
@@ -1355,7 +1355,7 @@ static int run_pipe_real(struct pipe *pi)
                         }
                 }
                 if (child->sp) {
-                        char * str = NULL;
+                        char *str = NULL;
 
                         str = make_string((child->argv + i));
                         parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING);
@@ -1364,9 +1364,9 @@ static int run_pipe_real(struct pipe *pi)
                 }
                 for (x = bltins; x->cmd; x++) {
                         if (strcmp(child->argv[i], x->cmd) == 0 ) {
-                                int squirrel[] = {-1, -1, -1};
+                                int squirrel[] = { -1, -1, -1 };
                                 int rcode;
-                                if (x->function == builtin_exec && child->argv[i+1]==NULL) {
+                                if (x->function == builtin_exec && child->argv[i+1] == NULL) {
                                         debug_printf("magic exec\n");
                                         setup_redirects(child,NULL);
                                         return EXIT_SUCCESS;
@@ -1377,9 +1377,9 @@ static int run_pipe_real(struct pipe *pi)
                                  * Is it really safe for inline use?  Experimentally,
                                  * things seem to work with glibc. */
                                 setup_redirects(child, squirrel);
-                                child->argv+=i;  /* XXX horrible hack */
+                                child->argv += i;  /* XXX horrible hack */
                                 rcode = x->function(child);
-                                child->argv-=i;  /* XXX restore hack so free() can work right */
+                                child->argv -= i;  /* XXX restore hack so free() can work right */
                                 restore_redirects(squirrel);
                                 return rcode;
                         }
@@ -1387,24 +1387,25 @@ static int run_pipe_real(struct pipe *pi)
         }
 
         for (i = 0; i < pi->num_progs; i++) {
-                child = & (pi->progs[i]);
+                child = &(pi->progs[i]);
 
                 /* pipes are inserted between pairs of commands */
                 if ((i + 1) < pi->num_progs) {
-                        if (pipe(pipefds)<0) bb_perror_msg_and_die("pipe");
+                        if (pipe(pipefds) < 0)
+                                bb_perror_msg_and_die("pipe");
                         nextout = pipefds[1];
                 } else {
-                        nextout=1;
+                        nextout = 1;
                         pipefds[0] = -1;
                 }
 
                 /* XXX test for failed fork()? */
 #if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__)
-                if (!(child->pid = fork()))
+                child->pid = fork();
 #else
-                if (!(child->pid = vfork()))
+                child->pid = vfork();
 #endif
-                {
+                if (!child->pid) {
                         /* Set the handling for job control signals back to the default.  */
                         signal(SIGINT, SIG_DFL);
                         signal(SIGQUIT, SIG_DFL);
@@ -1446,7 +1447,6 @@ static int run_pipe_real(struct pipe *pi)
                         pseudo_exec(child);
                 }
 
-
                 /* put our child in the process group whose leader is the
                    first process in this pipe */
                 if (pi->pgrp < 0) {
@@ -1476,81 +1476,87 @@ static int run_list_real(struct pipe *pi)
         struct pipe *rpipe;
         int flag_rep = 0;
         int save_num_progs;
-        int rcode=0, flag_skip=1;
+        int rcode = 0, flag_skip = 1;
         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;
+        int if_code = 0, next_if_code = 0;  /* need double-buffer to handle elif */
+        reserved_style rmode, skip_more_in_this_rmode = RES_XXXX;
         /* check syntax for "for" */
         for (rpipe = pi; rpipe; rpipe = rpipe->next) {
-                if ((rpipe->r_mode == RES_IN ||
-                    rpipe->r_mode == RES_FOR) &&
-                    (rpipe->next == NULL)) {
-                                syntax();
-                                return 1;
+                if ((rpipe->r_mode == RES_IN || rpipe->r_mode == RES_FOR)
+                 && (rpipe->next == NULL)
+                ) {
+                        syntax();
+                        return 1;
                 }
-                if ((rpipe->r_mode == RES_IN &&
-                        (rpipe->next->r_mode == RES_IN &&
-                        rpipe->next->progs->argv != NULL))||
-                        (rpipe->r_mode == RES_FOR &&
-                        rpipe->next->r_mode != RES_IN)) {
-                                syntax();
-                                return 1;
+                if ((rpipe->r_mode == RES_IN && rpipe->next->r_mode == RES_IN && rpipe->next->progs->argv != NULL)
+                 || (rpipe->r_mode == RES_FOR && rpipe->next->r_mode != RES_IN)
+                ) {
+                        syntax();
+                        return 1;
                 }
         }
         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) {
-                                flag_restore = 0;
-                                if (!rpipe) {
-                                        flag_rep = 0;
-                                        rpipe = pi;
-                                }
+                if (pi->r_mode == RES_WHILE || pi->r_mode == RES_UNTIL
+                 || pi->r_mode == RES_FOR
+                ) {
+                        flag_restore = 0;
+                        if (!rpipe) {
+                                flag_rep = 0;
+                                rpipe = pi;
+                        }
                 }
                 rmode = pi->r_mode;
-                debug_printf("rmode=%d  if_code=%d  next_if_code=%d skip_more=%d\n", rmode, if_code, next_if_code, skip_more_in_this_rmode);
+                debug_printf("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) {
-                        if (pi->followup == PIPE_SEQ) flag_skip=0;
+                        if (pi->followup == PIPE_SEQ)
+                                flag_skip = 0;
                         continue;
                 }
                 flag_skip = 1;
                 skip_more_in_this_rmode = RES_XXXX;
-                if (rmode == RES_THEN || rmode == RES_ELSE) if_code = next_if_code;
-                if (rmode == RES_THEN &&  if_code) continue;
-                if (rmode == RES_ELSE && !if_code) continue;
-                if (rmode == RES_ELIF && !if_code) break;
+                if (rmode == RES_THEN || rmode == RES_ELSE)
+                        if_code = next_if_code;
+                if (rmode == RES_THEN &&  if_code)
+                        continue;
+                if (rmode == RES_ELSE && !if_code)
+                        continue;
+                if (rmode == RES_ELIF && !if_code)
+                        break;
                 if (rmode == RES_FOR && pi->num_progs) {
                         if (!list) {
                                 /* if no variable values after "in" we skip "for" */
-                                if (!pi->next->progs->argv) continue;
+                                if (!pi->next->progs->argv)
+                                        continue;
                                 /* create list of variable values */
                                 list = make_list_in(pi->next->progs->argv,
-                                        pi->progs->argv[0]);
+                                                pi->progs->argv[0]);
                                 save_list = list;
                                 save_name = pi->progs->argv[0];
                                 pi->progs->argv[0] = NULL;
                                 flag_rep = 1;
                         }
-                        if (!(*list)) {
+                        if (!*list) {
                                 free(pi->progs->argv[0]);
                                 free(save_list);
                                 list = NULL;
                                 flag_rep = 0;
                                 pi->progs->argv[0] = save_name;
-                                pi->progs->glob_result.gl_pathv[0] =
-                                        pi->progs->argv[0];
+                                pi->progs->glob_result.gl_pathv[0] = pi->progs->argv[0];
                                 continue;
                         } else {
                                 /* insert new value from list for variable */
                                 if (pi->progs->argv[0])
                                         free(pi->progs->argv[0]);
                                 pi->progs->argv[0] = *list++;
-                                pi->progs->glob_result.gl_pathv[0] =
-                                        pi->progs->argv[0];
+                                pi->progs->glob_result.gl_pathv[0] = pi->progs->argv[0];
                         }
                 }
-                if (rmode == RES_IN) continue;
+                if (rmode == RES_IN)
+                        continue;
                 if (rmode == RES_DO) {
-                        if (!flag_rep) continue;
+                        if (!flag_rep)
+                                continue;
                 }
                 if ((rmode == RES_DONE)) {
                         if (flag_rep) {
@@ -1559,14 +1565,15 @@ static int run_list_real(struct pipe *pi)
                                 rpipe = NULL;
                         }
                 }
-                if (pi->num_progs == 0) continue;
+                if (pi->num_progs == 0)
+                        continue;
                 save_num_progs = pi->num_progs; /* save number of programs */
                 rcode = run_pipe_real(pi);
                 debug_printf("run_pipe_real returned %d\n",rcode);
-                if (rcode!=-1) {
+                if (rcode != -1) {
                         /* We only ran a builtin: rcode was set by the return value
                          * of run_pipe_real(), and we don't need to wait for anything. */
-                } else if (pi->followup==PIPE_BG) {
+                } else if (pi->followup == PIPE_BG) {
                         /* XXX check bash's behavior with nontrivial pipes */
                         /* XXX compute jobid */
                         /* XXX what does bash do with attempts to background builtins? */
@@ -1586,17 +1593,19 @@ static int run_list_real(struct pipe *pi)
                         }
                         debug_printf("checkjobs returned %d\n",rcode);
                 }
-                last_return_code=rcode;
+                last_return_code = rcode;
                 pi->num_progs = save_num_progs; /* restore number of programs */
                 if ( rmode == RES_IF || rmode == RES_ELIF )
-                        next_if_code=rcode;  /* can be overwritten a number of times */
+                        next_if_code = rcode;  /* can be overwritten a number of times */
                 if (rmode == RES_WHILE)
                         flag_rep = !last_return_code;
                 if (rmode == RES_UNTIL)
                         flag_rep = last_return_code;
-                if ( (rcode==EXIT_SUCCESS && pi->followup==PIPE_OR) ||
-                     (rcode!=EXIT_SUCCESS && pi->followup==PIPE_AND) )
-                        skip_more_in_this_rmode=rmode;
+                if ((rcode == EXIT_SUCCESS && pi->followup == PIPE_OR)
+                 || (rcode != EXIT_SUCCESS && pi->followup == PIPE_AND)
+                ) {
+                        skip_more_in_this_rmode = rmode;
+                }
                 checkjobs(NULL);
         }
         return rcode;
@@ -1608,28 +1617,28 @@ static int free_pipe(struct pipe *pi, int indent)
         char **p;
         struct child_prog *child;
         struct redir_struct *r, *rnext;
-        int a, i, ret_code=0;
+        int a, i, ret_code = 0;
 
         if (pi->stopped_progs > 0)
                 return ret_code;
-        final_printf("%s run pipe: (pid %d)\n",indenter(indent),getpid());
-        for (i=0; i<pi->num_progs; i++) {
+        final_printf("%s run pipe: (pid %d)\n", indenter(indent), getpid());
+        for (i = 0; i < pi->num_progs; i++) {
                 child = &pi->progs[i];
-                final_printf("%s  command %d:\n",indenter(indent),i);
+                final_printf("%s  command %d:\n", indenter(indent), i);
                 if (child->argv) {
-                        for (a=0,p=child->argv; *p; a++,p++) {
-                                final_printf("%s   argv[%d] = %s\n",indenter(indent),a,*p);
+                        for (a = 0, p = child->argv; *p; a++, p++) {
+                                final_printf("%s   argv[%d] = %s\n", indenter(indent), a, *p);
                         }
                         globfree(&child->glob_result);
-                        child->argv=NULL;
+                        child->argv = NULL;
                 } else if (child->group) {
-                        final_printf("%s   begin group (subshell:%d)\n",indenter(indent), child->subshell);
-                        ret_code = free_pipe_list(child->group,indent+3);
-                        final_printf("%s   end group\n",indenter(indent));
+                        final_printf("%s   begin group (subshell:%d)\n", indenter(indent), child->subshell);
+                        ret_code = free_pipe_list(child->group, indent+3);
+                        final_printf("%s   end group\n", indenter(indent));
                 } else {
-                        final_printf("%s   (nil)\n",indenter(indent));
+                        final_printf("%s   (nil)\n", indenter(indent));
                 }
-                for (r=child->redirects; r; r=rnext) {
+                for (r = child->redirects; r; r = rnext) {
                         final_printf("%s   redirect %d%s", indenter(indent), r->fd, redir_table[r->type].descrip);
                         if (r->dup == -1) {
                                 /* guard against the case >$FOO, where foo is unset or blank */
@@ -1640,26 +1649,26 @@ static int free_pipe(struct pipe *pi, int indent)
                         } else {
                                 final_printf("&%d\n", r->dup);
                         }
-                        rnext=r->next;
+                        rnext = r->next;
                         free(r);
                 }
-                child->redirects=NULL;
+                child->redirects = NULL;
         }
         free(pi->progs);   /* children are an array, they get freed all at once */
-        pi->progs=NULL;
+        pi->progs = NULL;
         return ret_code;
 }
 
 static int free_pipe_list(struct pipe *head, int indent)
 {
-        int rcode=0;   /* if list has no members */
+        int rcode = 0;   /* if list has no members */
         struct pipe *pi, *next;
-        for (pi=head; pi; pi=next) {
+        for (pi = head; pi; pi = next) {
                 final_printf("%s pipe reserved mode %d\n", indenter(indent), pi->r_mode);
                 rcode = free_pipe(pi, indent);
                 final_printf("%s pipe followup code %d\n", indenter(indent), pi->followup);
-                next=pi->next;
-                pi->next=NULL;
+                next = pi->next;
+                pi->next = NULL;
                 free(pi);
         }
         return rcode;
@@ -1668,8 +1677,8 @@ static int free_pipe_list(struct pipe *head, int indent)
 /* Select which version we will use */
 static int run_list(struct pipe *pi)
 {
-        int rcode=0;
-        if (fake_mode==0) {
+        int rcode = 0;
+        if (fake_mode == 0) {
                 rcode = run_list_real(pi);
         }
         /* free_pipe_list has the side effect of clearing memory
@@ -1688,31 +1697,31 @@ static int run_list(struct pipe *pi)
  */
 static int globhack(const char *src, int flags, glob_t *pglob)
 {
-        int cnt=0, pathc;
+        int cnt = 0, pathc;
         const char *s;
         char *dest;
-        for (cnt=1, s=src; s && *s; s++) {
+        for (cnt = 1, s = src; s && *s; s++) {
                 if (*s == '\\') s++;
                 cnt++;
         }
         dest = malloc(cnt);
         if (!dest) return GLOB_NOSPACE;
         if (!(flags & GLOB_APPEND)) {
-                pglob->gl_pathv=NULL;
-                pglob->gl_pathc=0;
-                pglob->gl_offs=0;
-                pglob->gl_offs=0;
+                pglob->gl_pathv = NULL;
+                pglob->gl_pathc = 0;
+                pglob->gl_offs = 0;
+                pglob->gl_offs = 0;
         }
         pathc = ++pglob->gl_pathc;
         pglob->gl_pathv = realloc(pglob->gl_pathv, (pathc+1)*sizeof(*pglob->gl_pathv));
         if (pglob->gl_pathv == NULL) return GLOB_NOSPACE;
-        pglob->gl_pathv[pathc-1]=dest;
-        pglob->gl_pathv[pathc]=NULL;
-        for (s=src; s && *s; s++, dest++) {
+        pglob->gl_pathv[pathc-1] = dest;
+        pglob->gl_pathv[pathc] = NULL;
+        for (s = src; s && *s; s++, dest++) {
                 if (*s == '\\') s++;
                 *dest = *s;
         }
-        *dest='\0';
+        *dest = '\0';
         return 0;
 }
 
@@ -1721,7 +1730,7 @@ static int glob_needed(const char *s)
 {
         for (; *s; s++) {
                 if (*s == '\\') s++;
-                if (strchr("*[?",*s)) return 1;
+                if (strchr("*[?", *s)) return 1;
         }
         return 0;
 }
@@ -1736,26 +1745,26 @@ static int xglob(o_string *dest, int flags, glob_t *pglob)
                 if (dest->nonnull) {
                         /* bash man page calls this an "explicit" null */
                         gr = globhack(dest->data, flags, pglob);
-                        debug_printf("globhack returned %d\n",gr);
+                        debug_printf("globhack returned %d\n", gr);
                 } else {
                         return 0;
                 }
         } else if (glob_needed(dest->data)) {
                 gr = glob(dest->data, flags, NULL, pglob);
-                debug_printf("glob returned %d\n",gr);
+                debug_printf("glob returned %d\n", gr);
                 if (gr == GLOB_NOMATCH) {
                         /* quote removal, or more accurately, backslash removal */
                         gr = globhack(dest->data, flags, pglob);
-                        debug_printf("globhack returned %d\n",gr);
+                        debug_printf("globhack returned %d\n", gr);
                 }
         } else {
                 gr = globhack(dest->data, flags, pglob);
-                debug_printf("globhack returned %d\n",gr);
+                debug_printf("globhack returned %d\n", gr);
         }
         if (gr == GLOB_NOSPACE)
                 bb_error_msg_and_die("out of memory during glob");
         if (gr != 0) { /* GLOB_ABORTED ? */
-                bb_error_msg("glob(3) error %d",gr);
+                bb_error_msg("glob(3) error %d", gr);
         }
         /* globprint(glob_target); */
         return gr;
@@ -1768,8 +1777,8 @@ static const char *get_local_var(const char *s)
 
         if (!s)
                 return NULL;
-        for (cur = top_vars; cur; cur=cur->next)
-                if(strcmp(cur->name, s)==0)
+        for (cur = top_vars; cur; cur = cur->next)
+                if (strcmp(cur->name, s) == 0)
                         return cur->value;
         return NULL;
 }
@@ -1781,39 +1790,39 @@ static const char *get_local_var(const char *s)
 static int set_local_var(const char *s, int flg_export)
 {
         char *name, *value;
-        int result=0;
+        int result = 0;
         struct variables *cur;
 
-        name=strdup(s);
+        name = strdup(s);
 
         /* Assume when we enter this function that we are already in
          * NAME=VALUE format.  So the first order of business is to
          * split 's' on the '=' into 'name' and 'value' */
         value = strchr(name, '=');
-        if (value==0 && ++value==0) {
+        if (value == 0 && ++value == 0) {
                 free(name);
                 return -1;
         }
         *value++ = 0;
 
-        for(cur = top_vars; cur; cur = cur->next) {
-                if(strcmp(cur->name, name)==0)
+        for (cur = top_vars; cur; cur = cur->next) {
+                if (strcmp(cur->name, name) == 0)
                         break;
         }
 
-        if(cur) {
-                if(strcmp(cur->value, value)==0) {
-                        if(flg_export>0 && cur->flg_export==0)
+        if (cur) {
+                if (strcmp(cur->value, value) == 0) {
+                        if (flg_export>0 && cur->flg_export == 0)
                                 cur->flg_export = flg_export;
                         else
                                 result++;
                 } else {
-                        if(cur->flg_read_only) {
+                        if (cur->flg_read_only) {
                                 bb_error_msg("%s: readonly variable", name);
                                 result = -1;
                         } else {
-                                if(flg_export>0 || cur->flg_export>1)
-                                        cur->flg_export=1;
+                                if (flg_export > 0 || cur->flg_export>1)
+                                        cur->flg_export = 1;
                                 free((char*)cur->value);
 
                                 cur->value = strdup(value);
@@ -1821,11 +1830,11 @@ static int set_local_var(const char *s, int flg_export)
                 }
         } else {
                 cur = malloc(sizeof(struct variables));
-                if(!cur) {
+                if (!cur) {
                         result = -1;
                 } else {
                         cur->name = strdup(name);
-                        if(cur->name == 0) {
+                        if (cur->name) {
                                 free(cur);
                                 result = -1;
                         } else {
@@ -1834,18 +1843,19 @@ static int set_local_var(const char *s, int flg_export)
                                 cur->next = 0;
                                 cur->flg_export = flg_export;
                                 cur->flg_read_only = 0;
-                                while(bottom->next) bottom=bottom->next;
+                                while (bottom->next)
+                                        bottom = bottom->next;
                                 bottom->next = cur;
                         }
                 }
         }
 
-        if(result==0 && cur->flg_export==1) {
+        if (result == 0 && cur->flg_export == 1) {
                 *(value-1) = '=';
                 result = putenv(name);
         } else {
                 free(name);
-                if(result>0)            /* equivalent to previous set */
+                if (result > 0)            /* equivalent to previous set */
                         result = 0;
         }
         return result;
@@ -1856,24 +1866,23 @@ static void unset_local_var(const char *name)
         struct variables *cur;
 
         if (name) {
-                for (cur = top_vars; cur; cur=cur->next) {
-                        if(strcmp(cur->name, name)==0)
+                for (cur = top_vars; cur; cur = cur->next) {
+                        if (strcmp(cur->name, name) == 0)
                                 break;
                 }
-                if(cur!=0) {
+                if (cur != 0) {
                         struct variables *next = top_vars;
-                        if(cur->flg_read_only) {
+                        if (cur->flg_read_only) {
                                 bb_error_msg("%s: readonly variable", name);
                                 return;
-                        } else {
-                                if(cur->flg_export)
-                                        unsetenv(cur->name);
-                                free((char*)cur->name);
-                                free((char*)cur->value);
-                                while (next->next != cur)
-                                        next = next->next;
-                                next->next = cur->next;
                         }
+                        if (cur->flg_export)
+                                unsetenv(cur->name);
+                        free((char*)cur->name);
+                        free((char*)cur->value);
+                        while (next->next != cur)
+                                next = next->next;
+                        next->next = cur->next;
                         free(cur);
                 }
         }
@@ -1881,10 +1890,12 @@ static void unset_local_var(const char *name)
 
 static int is_assignment(const char *s)
 {
-        if (s==NULL || !isalpha(*s)) return 0;
-        ++s;
-        while(isalnum(*s) || *s=='_') ++s;
-        return *s=='=';
+        if (!s || !isalpha(*s))
+                return 0;
+        s++;
+        while (isalnum(*s) || *s == '_')
+                s++;
+        return *s == '=';
 }
 
 /* the src parameter allows us to peek forward to a possible &n syntax
@@ -1894,26 +1905,26 @@ static int is_assignment(const char *s)
 static int setup_redirect(struct p_context *ctx, int fd, redir_type style,
         struct in_str *input)
 {
-        struct child_prog *child=ctx->child;
+        struct child_prog *child = ctx->child;
         struct redir_struct *redir = child->redirects;
-        struct redir_struct *last_redir=NULL;
+        struct redir_struct *last_redir = NULL;
 
         /* Create a new redir_struct and drop it onto the end of the linked list */
-        while(redir) {
-                last_redir=redir;
-                redir=redir->next;
+        while (redir) {
+                last_redir = redir;
+                redir = redir->next;
         }
         redir = xmalloc(sizeof(struct redir_struct));
-        redir->next=NULL;
-        redir->word.gl_pathv=NULL;
+        redir->next = NULL;
+        redir->word.gl_pathv = NULL;
         if (last_redir) {
-                last_redir->next=redir;
+                last_redir->next = redir;
         } else {
-                child->redirects=redir;
+                child->redirects = redir;
         }
 
-        redir->type=style;
-        redir->fd= (fd==-1) ? redir_table[style].default_fd : fd ;
+        redir->type = style;
+        redir->fd = (fd == -1) ? redir_table[style].default_fd : fd;
 
         debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
 
@@ -1949,14 +1960,14 @@ static struct pipe *new_pipe(void) {
 
 static void initialize_context(struct p_context *ctx)
 {
-        ctx->pipe=NULL;
-        ctx->pending_redirect=NULL;
-        ctx->child=NULL;
-        ctx->list_head=new_pipe();
-        ctx->pipe=ctx->list_head;
-        ctx->w=RES_NONE;
-        ctx->stack=NULL;
-        ctx->old_flag=0;
+        ctx->pipe = NULL;
+        ctx->pending_redirect = NULL;
+        ctx->child = NULL;
+        ctx->list_head = new_pipe();
+        ctx->pipe = ctx->list_head;
+        ctx->w = RES_NONE;
+        ctx->stack = NULL;
+        ctx->old_flag = 0;
         done_command(ctx);   /* creates the memory for working child */
 }
 
@@ -1991,9 +2002,8 @@ static int reserved_word(o_string *dest, struct p_context *ctx)
                 { "done",  RES_DONE,  FLAG_END  }
         };
         struct reserved_combo *r;
-        for (r=reserved_list;
 #define NRES sizeof(reserved_list)/sizeof(struct reserved_combo)
-                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) {
@@ -2180,7 +2190,7 @@ static int redirect_opt_num(o_string *o)
         int num;
 
         if (o->length==0) return -1;
-        for(num=0; num<o->length; num++) {
+        for (num=0; num<o->length; num++) {
                 if (!isdigit(*(o->data+num))) {
                         return -1;
                 }
@@ -2310,7 +2320,7 @@ static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *i
         if (isalpha(ch)) {
                 b_addchr(dest, SPECIAL_VAR_SYMBOL);
                 ctx->child->sp++;
-                while(ch=b_peek(input),isalnum(ch) || ch=='_') {
+                while (ch=b_peek(input),isalnum(ch) || ch=='_') {
                         b_getch(input);
                         b_addchr(dest,ch);
                 }
@@ -2343,7 +2353,7 @@ static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *i
                         ctx->child->sp++;
                         b_getch(input);
                         /* XXX maybe someone will try to escape the '}' */
-                        while(ch=b_getch(input),ch!=EOF && ch!='}') {
+                        while (ch=b_getch(input),ch!=EOF && ch!='}') {
                                 b_addchr(dest,ch);
                         }
                         if (ch != '}') {
@@ -2427,7 +2437,12 @@ int parse_stream(o_string *dest, struct p_context *ctx,
                         if (m!=2) switch (ch) {
                 case '#':
                         if (dest->length == 0 && !dest->quote) {
-                                while(ch=b_peek(input),ch!=EOF && ch!='\n') { b_getch(input); }
+                                while (1) {
+                                        ch = b_peek(input);
+                                        if (ch == EOF || ch == '\n')
+                                                break;
+                                        b_getch(input);
+                                }
                         } else {
                                 b_addqchr(dest, ch, dest->quote);
                         }
@@ -2445,10 +2460,13 @@ int parse_stream(o_string *dest, struct p_context *ctx,
                         break;
                 case '\'':
                         dest->nonnull = 1;
-                        while(ch=b_getch(input),ch!=EOF && ch!='\'') {
+                        while (1) {
+                                ch = b_getch(input);
+                                if (ch == EOF || ch == '\'')
+                                        break;
                                 b_addchr(dest,ch);
                         }
-                        if (ch==EOF) {
+                        if (ch == EOF) {
                                 syntax();
                                 return 1;
                         }
@@ -2766,7 +2784,7 @@ int hush_main(int argc, char **argv)
                 free((char*)cwd);
         {
                 struct variables *cur, *tmp;
-                for(cur = top_vars; cur; cur = tmp) {
+                for (cur = top_vars; cur; cur = tmp) {
                         tmp = cur->next;
                         if (!cur->flg_read_only) {
                                 free(cur->name);