Run through indent, fix comments

1 files changed, 2705 insertions, 2790 deletions

diff --git a/shell/ash.c b/shell/ash.c
index 09975198d..15ec04380 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -90,21 +90,21 @@
  */
 
 /* Syntax classes */
-#define CWORD 0                 /* character is nothing special */
-#define CNL 1                   /* newline character */
-#define CBACK 2                 /* a backslash character */
-#define CSQUOTE 3               /* single quote */
-#define CDQUOTE 4               /* double quote */
-#define CENDQUOTE 5             /* a terminating quote */
-#define CBQUOTE 6               /* backwards single quote */
-#define CVAR 7                  /* a dollar sign */
-#define CENDVAR 8               /* a '}' character */
-#define CLP 9                   /* a left paren in arithmetic */
-#define CRP 10                  /* a right paren in arithmetic */
-#define CENDFILE 11             /* end of file */
-#define CCTL 12                 /* like CWORD, except it must be escaped */
-#define CSPCL 13                /* these terminate a word */
-#define CIGN 14                 /* character should be ignored */
+#define CWORD 0                 /* character is nothing special */
+#define CNL 1                   /* newline character */
+#define CBACK 2                 /* a backslash character */
+#define CSQUOTE 3               /* single quote */
+#define CDQUOTE 4               /* double quote */
+#define CENDQUOTE 5             /* a terminating quote */
+#define CBQUOTE 6               /* backwards single quote */
+#define CVAR 7                  /* a dollar sign */
+#define CENDVAR 8               /* a '}' character */
+#define CLP 9                   /* a left paren in arithmetic */
+#define CRP 10                  /* a right paren in arithmetic */
+#define CENDFILE 11             /* end of file */
+#define CCTL 12                 /* like CWORD, except it must be escaped */
+#define CSPCL 13                /* these terminate a word */
+#define CIGN 14                 /* character should be ignored */
 
 #define SYNBASE 130
 #define PEOF -130
@@ -149,7 +149,7 @@
 #define CTLVAR '\202'
 #define CTLENDVAR '\203'
 #define CTLBACKQ '\204'
-#define CTLQUOTE 01             /* ored with CTLBACKQ code if in quotes */
+#define CTLQUOTE 01             /* ored with CTLBACKQ code if in quotes */
 /*      CTLBACKQ | CTLQUOTE == '\205' */
 #define CTLARI  '\206'
 #define CTLENDARI '\207'
@@ -171,33 +171,33 @@
 #define digit_val(c)    ((c) - '0')
 
 
-#define S_DFL 1                 /* default signal handling (SIG_DFL) */
-#define S_CATCH 2               /* signal is caught */
-#define S_IGN 3                 /* signal is ignored (SIG_IGN) */
-#define S_HARD_IGN 4            /* signal is ignored permenantly */
-#define S_RESET 5               /* temporary - to reset a hard ignored sig */
+#define S_DFL 1                 /* default signal handling (SIG_DFL) */
+#define S_CATCH 2               /* signal is caught */
+#define S_IGN 3                 /* signal is ignored (SIG_IGN) */
+#define S_HARD_IGN 4    /* signal is ignored permenantly */
+#define S_RESET 5               /* temporary - to reset a hard ignored sig */
 
 
 /* variable substitution byte (follows CTLVAR) */
-#define VSTYPE  0x0f            /* type of variable substitution */
-#define VSNUL   0x10            /* colon--treat the empty string as unset */
-#define VSQUOTE 0x80            /* inside double quotes--suppress splitting */
+#define VSTYPE  0x0f    /* type of variable substitution */
+#define VSNUL   0x10    /* colon--treat the empty string as unset */
+#define VSQUOTE 0x80    /* inside double quotes--suppress splitting */
 
 /* values of VSTYPE field */
-#define VSNORMAL        0x1             /* normal variable:  $var or ${var} */
-#define VSMINUS         0x2             /* ${var-text} */
-#define VSPLUS          0x3             /* ${var+text} */
-#define VSQUESTION      0x4             /* ${var?message} */
-#define VSASSIGN        0x5             /* ${var=text} */
-#define VSTRIMLEFT      0x6             /* ${var#pattern} */
-#define VSTRIMLEFTMAX   0x7             /* ${var##pattern} */
-#define VSTRIMRIGHT     0x8             /* ${var%pattern} */
-#define VSTRIMRIGHTMAX  0x9             /* ${var%%pattern} */
-#define VSLENGTH        0xa             /* ${#var} */
+#define VSNORMAL        0x1     /* normal variable:  $var or ${var} */
+#define VSMINUS         0x2     /* ${var-text} */
+#define VSPLUS          0x3     /* ${var+text} */
+#define VSQUESTION      0x4     /* ${var?message} */
+#define VSASSIGN        0x5     /* ${var=text} */
+#define VSTRIMLEFT      0x6     /* ${var#pattern} */
+#define VSTRIMLEFTMAX   0x7     /* ${var##pattern} */
+#define VSTRIMRIGHT     0x8     /* ${var%pattern} */
+#define VSTRIMRIGHTMAX  0x9     /* ${var%%pattern} */
+#define VSLENGTH        0xa     /* ${#var} */
 
 /* flags passed to redirect */
-#define REDIR_PUSH 01           /* save previous values of file descriptors */
-#define REDIR_BACKQ 02          /* save the command output to pipe */
+#define REDIR_PUSH 01   /* save previous values of file descriptors */
+#define REDIR_BACKQ 02  /* save the command output to pipe */
 
 /*
  * BSD setjmp saves the signal mask, which violates ANSI C and takes time,
@@ -236,7 +236,7 @@ static void change_lc_ctype(const char *value);
  * more fun than worrying about efficiency and portability. :-))
  */
 
-static void onint (void);
+static void onint(void);
 static volatile int suppressint;
 static volatile int intpending;
 
@@ -245,8 +245,9 @@ static volatile int intpending;
 #define INTON { if (--suppressint == 0 && intpending) onint(); }
 #define FORCEINTON {suppressint = 0; if (intpending) onint();}
 #else
-static void __inton (void);
-static void forceinton (void);
+static void __inton(void);
+static void forceinton(void);
+
 #define INTON __inton()
 #define FORCEINTON forceinton()
 #endif
@@ -256,16 +257,17 @@ static void forceinton (void);
 
 
 typedef void *pointer;
+
 #ifndef NULL
 #define NULL (void *)0
 #endif
 
-static pointer stalloc (int);
-static void stunalloc (pointer);
-static void ungrabstackstr (char *, char *);
-static char * growstackstr(void);
-static char * makestrspace(size_t newlen);
-static char *sstrdup (const char *);
+static pointer stalloc(int);
+static void stunalloc(pointer);
+static void ungrabstackstr(char *, char *);
+static char *growstackstr(void);
+static char *makestrspace(size_t newlen);
+static char *sstrdup(const char *);
 
 /*
  * Parse trees for commands are allocated in lifo order, so we use a stack
@@ -276,7 +278,7 @@ static char *sstrdup (const char *);
  * well.
  */
 
-#define MINSIZE 504             /* minimum size of a block */
+#define MINSIZE 504             /* minimum size of a block */
 
 
 struct stack_block {
@@ -313,12 +315,12 @@ static int stacknleft = MINSIZE;
 #ifdef DEBUG
 #define TRACE(param)    trace param
 typedef union node unode;
-static void trace (const char *, ...);
-static void trargs (char **);
-static void showtree (unode *);
-static void trputc (int);
-static void trputs (const char *);
-static void opentrace (void);
+static void trace(const char *, ...);
+static void trargs(char **);
+static void showtree(unode *);
+static void trputc(int);
+static void trputs(const char *);
+static void opentrace(void);
 #else
 #define TRACE(param)
 #endif
@@ -353,19 +355,19 @@ static void opentrace (void);
 /*
  * expandarg() flags
  */
-#define EXP_FULL        0x1     /* perform word splitting & file globbing */
-#define EXP_TILDE       0x2     /* do normal tilde expansion */
-#define EXP_VARTILDE    0x4     /* expand tildes in an assignment */
-#define EXP_REDIR       0x8     /* file glob for a redirection (1 match only) */
-#define EXP_CASE        0x10    /* keeps quotes around for CASE pattern */
-#define EXP_RECORD      0x20    /* need to record arguments for ifs breakup */
+#define EXP_FULL        0x1     /* perform word splitting & file globbing */
+#define EXP_TILDE       0x2     /* do normal tilde expansion */
+#define EXP_VARTILDE    0x4     /* expand tildes in an assignment */
+#define EXP_REDIR       0x8     /* file glob for a redirection (1 match only) */
+#define EXP_CASE        0x10    /* keeps quotes around for CASE pattern */
+#define EXP_RECORD      0x20    /* need to record arguments for ifs breakup */
 
 
 #define NOPTS   16
 
 static char optet_vals[NOPTS];
 
-static const char * const optlist[NOPTS] = {
+static const char *const optlist[NOPTS] = {
         "e" "errexit",
         "f" "noglob",
         "I" "ignoreeof",
@@ -413,121 +415,121 @@ static const char * const optlist[NOPTS] = {
 
 
 struct nbinary {
-      int type;
-      union node *ch1;
-      union node *ch2;
+        int type;
+        union node *ch1;
+        union node *ch2;
 };
 
 
 struct ncmd {
-      int type;
-      int backgnd;
-      union node *assign;
-      union node *args;
-      union node *redirect;
+        int type;
+        int backgnd;
+        union node *assign;
+        union node *args;
+        union node *redirect;
 };
 
 
 struct npipe {
-      int type;
-      int backgnd;
-      struct nodelist *cmdlist;
+        int type;
+        int backgnd;
+        struct nodelist *cmdlist;
 };
 
 
 struct nredir {
-      int type;
-      union node *n;
-      union node *redirect;
+        int type;
+        union node *n;
+        union node *redirect;
 };
 
 
 struct nif {
-      int type;
-      union node *test;
-      union node *ifpart;
-      union node *elsepart;
+        int type;
+        union node *test;
+        union node *ifpart;
+        union node *elsepart;
 };
 
 
 struct nfor {
-      int type;
-      union node *args;
-      union node *body;
-      char *var;
+        int type;
+        union node *args;
+        union node *body;
+        char *var;
 };
 
 
 struct ncase {
-      int type;
-      union node *expr;
-      union node *cases;
+        int type;
+        union node *expr;
+        union node *cases;
 };
 
 
 struct nclist {
-      int type;
-      union node *next;
-      union node *pattern;
-      union node *body;
+        int type;
+        union node *next;
+        union node *pattern;
+        union node *body;
 };
 
 
 struct narg {
-      int type;
-      union node *next;
-      char *text;
-      struct nodelist *backquote;
+        int type;
+        union node *next;
+        char *text;
+        struct nodelist *backquote;
 };
 
 
 struct nfile {
-      int type;
-      union node *next;
-      int fd;
-      union node *fname;
-      char *expfname;
+        int type;
+        union node *next;
+        int fd;
+        union node *fname;
+        char *expfname;
 };
 
 
 struct ndup {
-      int type;
-      union node *next;
-      int fd;
-      int dupfd;
-      union node *vname;
+        int type;
+        union node *next;
+        int fd;
+        int dupfd;
+        union node *vname;
 };
 
 
 struct nhere {
-      int type;
-      union node *next;
-      int fd;
-      union node *doc;
+        int type;
+        union node *next;
+        int fd;
+        union node *doc;
 };
 
 
 struct nnot {
-      int type;
-      union node *com;
+        int type;
+        union node *com;
 };
 
 
 union node {
-      int type;
-      struct nbinary nbinary;
-      struct ncmd ncmd;
-      struct npipe npipe;
-      struct nredir nredir;
-      struct nif nif;
-      struct nfor nfor;
-      struct ncase ncase;
-      struct nclist nclist;
-      struct narg narg;
-      struct nfile nfile;
-      struct ndup ndup;
-      struct nhere nhere;
-      struct nnot nnot;
+        int type;
+        struct nbinary nbinary;
+        struct ncmd ncmd;
+        struct npipe npipe;
+        struct nredir nredir;
+        struct nif nif;
+        struct nfor nfor;
+        struct ncase ncase;
+        struct nclist nclist;
+        struct narg narg;
+        struct nfile nfile;
+        struct ndup ndup;
+        struct nhere nhere;
+        struct nnot nnot;
 };
 
 
@@ -536,11 +538,11 @@ struct nodelist {
         union node *n;
 };
 
-struct backcmd {                /* result of evalbackcmd */
-        int fd;                 /* file descriptor to read from */
-        char *buf;              /* buffer */
-        int nleft;              /* number of chars in buffer */
-        struct job *jp;         /* job structure for command */
+struct backcmd {                /* result of evalbackcmd */
+        int fd;                         /* file descriptor to read from */
+        char *buf;                      /* buffer */
+        int nleft;                      /* number of chars in buffer */
+        struct job *jp;         /* job structure for command */
 };
 
 struct cmdentry {
@@ -564,25 +566,25 @@ struct arglist {
 };
 
 struct strpush {
-        struct strpush *prev;   /* preceding string on stack */
+        struct strpush *prev;   /* preceding string on stack */
         char *prevstring;
         int prevnleft;
 #ifdef CONFIG_ASH_ALIAS
-        struct alias *ap;       /* if push was associated with an alias */
+        struct alias *ap;       /* if push was associated with an alias */
 #endif
-        char *string;           /* remember the string since it may change */
+        char *string;           /* remember the string since it may change */
 };
 
 struct parsefile {
-        struct parsefile *prev; /* preceding file on stack */
-        int linno;              /* current line */
-        int fd;                 /* file descriptor (or -1 if string) */
-        int nleft;              /* number of chars left in this line */
-        int lleft;              /* number of chars left in this buffer */
-        char *nextc;            /* next char in buffer */
-        char *buf;              /* input buffer */
-        struct strpush *strpush; /* for pushing strings at this level */
-        struct strpush basestrpush; /* so pushing one is fast */
+        struct parsefile *prev; /* preceding file on stack */
+        int linno;                      /* current line */
+        int fd;                         /* file descriptor (or -1 if string) */
+        int nleft;                      /* number of chars left in this line */
+        int lleft;                      /* number of chars left in this buffer */
+        char *nextc;            /* next char in buffer */
+        char *buf;                      /* input buffer */
+        struct strpush *strpush;        /* for pushing strings at this level */
+        struct strpush basestrpush;     /* so pushing one is fast */
 };
 
 struct stackmark {
@@ -593,11 +595,11 @@ struct stackmark {
 };
 
 struct shparam {
-        int nparam;             /* # of positional parameters (without $0) */
-        unsigned char malloc;   /* if parameter list dynamically allocated */
-        char **p;               /* parameter list */
-        int optind;             /* next parameter to be processed by getopts */
-        int optoff;             /* used by getopts */
+        int nparam;                     /* # of positional parameters (without $0) */
+        unsigned char malloc;   /* if parameter list dynamically allocated */
+        char **p;                       /* parameter list */
+        int optind;                     /* next parameter to be processed by getopts */
+        int optoff;                     /* used by getopts */
 };
 
 /*
@@ -608,46 +610,58 @@ struct shparam {
  * We should investigate converting to a linear search, even though that
  * would make the command name "hash" a misnomer.
  */
-#define CMDTABLESIZE 31         /* should be prime */
-#define ARB 1                   /* actual size determined at run time */
+#define CMDTABLESIZE 31 /* should be prime */
+#define ARB 1                   /* actual size determined at run time */
 
 
 
 struct tblentry {
-        struct tblentry *next;  /* next entry in hash chain */
-        union param param;      /* definition of builtin function */
-        short cmdtype;          /* index identifying command */
-        char rehash;            /* if set, cd done since entry created */
-        char cmdname[ARB];      /* name of command */
+        struct tblentry *next;  /* next entry in hash chain */
+        union param param;      /* definition of builtin function */
+        short cmdtype;          /* index identifying command */
+        char rehash;            /* if set, cd done since entry created */
+        char cmdname[ARB];      /* name of command */
 };
 
 
 static struct tblentry *cmdtable[CMDTABLESIZE];
-static int builtinloc = -1;             /* index in path of %builtin, or -1 */
-static int exerrno = 0;                 /* Last exec error */
+static int builtinloc = -1;     /* index in path of %builtin, or -1 */
+static int exerrno = 0; /* Last exec error */
 
 
-static void tryexec (char *, char **, char **);
-static void printentry (struct tblentry *, int);
-static void clearcmdentry (int);
-static struct tblentry *cmdlookup (const char *, int);
-static void delete_cmd_entry (void);
-static int path_change (const char *, int *);
+static void tryexec(char *, char **, char **);
+static void printentry(struct tblentry *, int);
+static void clearcmdentry(int);
+static struct tblentry *cmdlookup(const char *, int);
+static void delete_cmd_entry(void);
+static int path_change(const char *, int *);
 
 
-static void flushall (void);
-static void out2fmt (const char *, ...)
-    __attribute__((__format__(__printf__,1,2)));
-static int xwrite (int, const char *, int);
+static void flushall(void);
+static void out2fmt(const char *, ...)
+        __attribute__ ((__format__(__printf__, 1, 2)));
+static int xwrite(int, const char *, int);
 
-static inline void outstr (const char *p, FILE *file) { fputs(p, file); }
-static void out1str(const char *p) { outstr(p, stdout); }
-static void out2str(const char *p) { outstr(p, stderr); }
+static inline void outstr(const char *p, FILE * file)
+{
+        fputs(p, file);
+}
+static void out1str(const char *p)
+{
+        outstr(p, stdout);
+}
+static void out2str(const char *p)
+{
+        outstr(p, stderr);
+}
 
 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
 #define out2c(c)        putc((c), stderr)
 #else
-static void out2c(int c)           { putc(c, stderr); }
+static void out2c(int c)
+{
+        putc(c, stderr);
+}
 #endif
 
 
@@ -656,28 +670,43 @@ static void out2c(int c)           { putc(c, stderr); }
 #endif
 
 /* number syntax index */
-#define  BASESYNTAX  0                  /* not in quotes */
-#define  DQSYNTAX    1                  /* in double quotes */
-#define  SQSYNTAX    2                  /* in single quotes */
-#define  ARISYNTAX   3                  /* in arithmetic */
+#define  BASESYNTAX  0  /* not in quotes */
+#define  DQSYNTAX    1  /* in double quotes */
+#define  SQSYNTAX    2  /* in single quotes */
+#define  ARISYNTAX   3  /* in arithmetic */
 
 static const char S_I_T[][4] = {
-  /*  0 */  { CSPCL,    CIGN,      CIGN,      CIGN     },   /* PEOA */
-  /*  1 */  { CSPCL,    CWORD,     CWORD,     CWORD    },   /* ' ' */
-  /*  2 */  { CNL,      CNL,       CNL,       CNL      },   /* \n */
-  /*  3 */  { CWORD,    CCTL,      CCTL,      CWORD    },   /* !*-/:=?[]~ */
-  /*  4 */  { CDQUOTE,  CENDQUOTE, CWORD,     CDQUOTE  },   /* '"' */
-  /*  5 */  { CVAR,     CVAR,      CWORD,     CVAR     },   /* $ */
-  /*  6 */  { CSQUOTE,  CWORD,     CENDQUOTE, CSQUOTE  },   /* "'" */
-  /*  7 */  { CSPCL,    CWORD,     CWORD,     CLP      },   /* ( */
-  /*  8 */  { CSPCL,    CWORD,     CWORD,     CRP      },   /* ) */
-  /*  9 */  { CBACK,    CBACK,     CCTL,      CBACK    },   /* \ */
-  /* 10 */  { CBQUOTE,  CBQUOTE,   CWORD,     CBQUOTE  },   /* ` */
-  /* 11 */  { CENDVAR,  CENDVAR,   CWORD,     CENDVAR  },   /* } */
+                                                                                /*  0 */ {CSPCL, CIGN, CIGN, CIGN},
+                                                                                /* PEOA */
+                                                                                        /*  1 */ {CSPCL, CWORD, CWORD, CWORD},
+                                                                                        /* ' ' */
+                                                                        /*  2 */ {CNL, CNL, CNL, CNL},
+                                                                        /* \n */
+                                                                                        /*  3 */ {CWORD, CCTL, CCTL, CWORD},
+                                                                                        /* !*-/:=?[]~ */
+                                                                                                        /*  4 */ {CDQUOTE, CENDQUOTE, CWORD, CDQUOTE},
+                                                                                                        /* '"' */
+                                                                                /*  5 */ {CVAR, CVAR, CWORD, CVAR},
+                                                                                /* $ */
+                                                                                                        /*  6 */ {CSQUOTE, CWORD, CENDQUOTE, CSQUOTE},
+                                                                                                        /* "'" */
+                                                                                        /*  7 */ {CSPCL, CWORD, CWORD, CLP},
+                                                                                        /* ( */
+                                                                                        /*  8 */ {CSPCL, CWORD, CWORD, CRP},
+                                                                                        /* ) */
+                                                                                        /*  9 */ {CBACK, CBACK, CCTL, CBACK},
+                                                                                        /* \ */
+                                                                                                        /* 10 */ {CBQUOTE, CBQUOTE, CWORD, CBQUOTE},
+                                                                                                        /* ` */
+                                                                                                        /* 11 */ {CENDVAR, CENDVAR, CWORD, CENDVAR},
+                                                                                                        /* } */
 #ifndef USE_SIT_FUNCTION
-  /* 12 */  { CENDFILE, CENDFILE,  CENDFILE,  CENDFILE },   /* PEOF */
-  /* 13 */  { CWORD,    CWORD,     CWORD,     CWORD    },   /* 0-9A-Za-z */
-  /* 14 */  { CCTL,     CCTL,      CCTL,      CCTL     }    /* CTLESC ... */
+                                                                                                                /* 12 */ {CENDFILE, CENDFILE, CENDFILE, CENDFILE},
+                                                                                                                /* PEOF */
+                                                                                        /* 13 */ {CWORD, CWORD, CWORD, CWORD},
+                                                                                        /* 0-9A-Za-z */
+                                                                                /* 14 */ {CCTL, CCTL, CCTL, CCTL}
+                                                                                /* CTLESC ... */
 #endif
 };
 
@@ -687,31 +716,32 @@ static const char S_I_T[][4] = {
 
 static int SIT(int c, int syntax)
 {
-        static const char spec_symbls[]="\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
-        static const char syntax_index_table [] = {
-                                1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
-                                7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
-                                3, 1, 3, 3, 9, 3,10, 1, /* "=>?[\\]`|" */
-                                11,3 }; /* "}~" */
+        static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
+        static const char syntax_index_table[] = {
+                1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
+                7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
+                3, 1, 3, 3, 9, 3, 10, 1,        /* "=>?[\\]`|" */
+                11, 3
+        };                                      /* "}~" */
         const char *s;
         int indx;
 
-        if(c==PEOF)             /* 2^8+2 */
+        if (c == PEOF)          /* 2^8+2 */
                 return CENDFILE;
-        if(c==PEOA)             /* 2^8+1 */
+        if (c == PEOA)          /* 2^8+1 */
                 indx = 0;
-         else if(U_C(c)>=U_C(CTLESC) && U_C(c)<=U_C(CTLQUOTEMARK))
+        else if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK))
                 return CCTL;
-         else {
+        else {
                 s = strchr(spec_symbls, c);
-                if(s==0)
+                if (s == 0)
                         return CWORD;
-                indx = syntax_index_table[(s-spec_symbls)];
+                indx = syntax_index_table[(s - spec_symbls)];
         }
         return S_I_T[indx][syntax];
 }
 
-#else  /* USE_SIT_FUNCTION */
+#else                                                   /* USE_SIT_FUNCTION */
 
 #define SIT(c, syntax) S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax]
 
@@ -732,268 +762,270 @@ static int SIT(int c, int syntax)
 #define CCTL_CCTL_CCTL_CCTL                           14
 
 static const char syntax_index_table[258] = {
-                 /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
-  /*   0  -130 PEOF */  CENDFILE_CENDFILE_CENDFILE_CENDFILE,
-  /*   1  -129 PEOA */  CSPCL_CIGN_CIGN_CIGN,
-  /*   2  -128 0xff */  CWORD_CWORD_CWORD_CWORD,
-  /*   3  -127      */  CCTL_CCTL_CCTL_CCTL,    /* CTLQUOTEMARK */
-  /*   4  -126      */  CCTL_CCTL_CCTL_CCTL,
-  /*   5  -125      */  CCTL_CCTL_CCTL_CCTL,
-  /*   6  -124      */  CCTL_CCTL_CCTL_CCTL,
-  /*   7  -123      */  CCTL_CCTL_CCTL_CCTL,
-  /*   8  -122      */  CCTL_CCTL_CCTL_CCTL,
-  /*   9  -121      */  CCTL_CCTL_CCTL_CCTL,
-  /*  10  -120      */  CCTL_CCTL_CCTL_CCTL,    /* CTLESC */
-  /*  11  -119      */  CWORD_CWORD_CWORD_CWORD,
-  /*  12  -118      */  CWORD_CWORD_CWORD_CWORD,
-  /*  13  -117      */  CWORD_CWORD_CWORD_CWORD,
-  /*  14  -116      */  CWORD_CWORD_CWORD_CWORD,
-  /*  15  -115      */  CWORD_CWORD_CWORD_CWORD,
-  /*  16  -114      */  CWORD_CWORD_CWORD_CWORD,
-  /*  17  -113      */  CWORD_CWORD_CWORD_CWORD,
-  /*  18  -112      */  CWORD_CWORD_CWORD_CWORD,
-  /*  19  -111      */  CWORD_CWORD_CWORD_CWORD,
-  /*  20  -110      */  CWORD_CWORD_CWORD_CWORD,
-  /*  21  -109      */  CWORD_CWORD_CWORD_CWORD,
-  /*  22  -108      */  CWORD_CWORD_CWORD_CWORD,
-  /*  23  -107      */  CWORD_CWORD_CWORD_CWORD,
-  /*  24  -106      */  CWORD_CWORD_CWORD_CWORD,
-  /*  25  -105      */  CWORD_CWORD_CWORD_CWORD,
-  /*  26  -104      */  CWORD_CWORD_CWORD_CWORD,
-  /*  27  -103      */  CWORD_CWORD_CWORD_CWORD,
-  /*  28  -102      */  CWORD_CWORD_CWORD_CWORD,
-  /*  29  -101      */  CWORD_CWORD_CWORD_CWORD,
-  /*  30  -100      */  CWORD_CWORD_CWORD_CWORD,
-  /*  31   -99      */  CWORD_CWORD_CWORD_CWORD,
-  /*  32   -98      */  CWORD_CWORD_CWORD_CWORD,
-  /*  33   -97      */  CWORD_CWORD_CWORD_CWORD,
-  /*  34   -96      */  CWORD_CWORD_CWORD_CWORD,
-  /*  35   -95      */  CWORD_CWORD_CWORD_CWORD,
-  /*  36   -94      */  CWORD_CWORD_CWORD_CWORD,
-  /*  37   -93      */  CWORD_CWORD_CWORD_CWORD,
-  /*  38   -92      */  CWORD_CWORD_CWORD_CWORD,
-  /*  39   -91      */  CWORD_CWORD_CWORD_CWORD,
-  /*  40   -90      */  CWORD_CWORD_CWORD_CWORD,
-  /*  41   -89      */  CWORD_CWORD_CWORD_CWORD,
-  /*  42   -88      */  CWORD_CWORD_CWORD_CWORD,
-  /*  43   -87      */  CWORD_CWORD_CWORD_CWORD,
-  /*  44   -86      */  CWORD_CWORD_CWORD_CWORD,
-  /*  45   -85      */  CWORD_CWORD_CWORD_CWORD,
-  /*  46   -84      */  CWORD_CWORD_CWORD_CWORD,
-  /*  47   -83      */  CWORD_CWORD_CWORD_CWORD,
-  /*  48   -82      */  CWORD_CWORD_CWORD_CWORD,
-  /*  49   -81      */  CWORD_CWORD_CWORD_CWORD,
-  /*  50   -80      */  CWORD_CWORD_CWORD_CWORD,
-  /*  51   -79      */  CWORD_CWORD_CWORD_CWORD,
-  /*  52   -78      */  CWORD_CWORD_CWORD_CWORD,
-  /*  53   -77      */  CWORD_CWORD_CWORD_CWORD,
-  /*  54   -76      */  CWORD_CWORD_CWORD_CWORD,
-  /*  55   -75      */  CWORD_CWORD_CWORD_CWORD,
-  /*  56   -74      */  CWORD_CWORD_CWORD_CWORD,
-  /*  57   -73      */  CWORD_CWORD_CWORD_CWORD,
-  /*  58   -72      */  CWORD_CWORD_CWORD_CWORD,
-  /*  59   -71      */  CWORD_CWORD_CWORD_CWORD,
-  /*  60   -70      */  CWORD_CWORD_CWORD_CWORD,
-  /*  61   -69      */  CWORD_CWORD_CWORD_CWORD,
-  /*  62   -68      */  CWORD_CWORD_CWORD_CWORD,
-  /*  63   -67      */  CWORD_CWORD_CWORD_CWORD,
-  /*  64   -66      */  CWORD_CWORD_CWORD_CWORD,
-  /*  65   -65      */  CWORD_CWORD_CWORD_CWORD,
-  /*  66   -64      */  CWORD_CWORD_CWORD_CWORD,
-  /*  67   -63      */  CWORD_CWORD_CWORD_CWORD,
-  /*  68   -62      */  CWORD_CWORD_CWORD_CWORD,
-  /*  69   -61      */  CWORD_CWORD_CWORD_CWORD,
-  /*  70   -60      */  CWORD_CWORD_CWORD_CWORD,
-  /*  71   -59      */  CWORD_CWORD_CWORD_CWORD,
-  /*  72   -58      */  CWORD_CWORD_CWORD_CWORD,
-  /*  73   -57      */  CWORD_CWORD_CWORD_CWORD,
-  /*  74   -56      */  CWORD_CWORD_CWORD_CWORD,
-  /*  75   -55      */  CWORD_CWORD_CWORD_CWORD,
-  /*  76   -54      */  CWORD_CWORD_CWORD_CWORD,
-  /*  77   -53      */  CWORD_CWORD_CWORD_CWORD,
-  /*  78   -52      */  CWORD_CWORD_CWORD_CWORD,
-  /*  79   -51      */  CWORD_CWORD_CWORD_CWORD,
-  /*  80   -50      */  CWORD_CWORD_CWORD_CWORD,
-  /*  81   -49      */  CWORD_CWORD_CWORD_CWORD,
-  /*  82   -48      */  CWORD_CWORD_CWORD_CWORD,
-  /*  83   -47      */  CWORD_CWORD_CWORD_CWORD,
-  /*  84   -46      */  CWORD_CWORD_CWORD_CWORD,
-  /*  85   -45      */  CWORD_CWORD_CWORD_CWORD,
-  /*  86   -44      */  CWORD_CWORD_CWORD_CWORD,
-  /*  87   -43      */  CWORD_CWORD_CWORD_CWORD,
-  /*  88   -42      */  CWORD_CWORD_CWORD_CWORD,
-  /*  89   -41      */  CWORD_CWORD_CWORD_CWORD,
-  /*  90   -40      */  CWORD_CWORD_CWORD_CWORD,
-  /*  91   -39      */  CWORD_CWORD_CWORD_CWORD,
-  /*  92   -38      */  CWORD_CWORD_CWORD_CWORD,
-  /*  93   -37      */  CWORD_CWORD_CWORD_CWORD,
-  /*  94   -36      */  CWORD_CWORD_CWORD_CWORD,
-  /*  95   -35      */  CWORD_CWORD_CWORD_CWORD,
-  /*  96   -34      */  CWORD_CWORD_CWORD_CWORD,
-  /*  97   -33      */  CWORD_CWORD_CWORD_CWORD,
-  /*  98   -32      */  CWORD_CWORD_CWORD_CWORD,
-  /*  99   -31      */  CWORD_CWORD_CWORD_CWORD,
-  /* 100   -30      */  CWORD_CWORD_CWORD_CWORD,
-  /* 101   -29      */  CWORD_CWORD_CWORD_CWORD,
-  /* 102   -28      */  CWORD_CWORD_CWORD_CWORD,
-  /* 103   -27      */  CWORD_CWORD_CWORD_CWORD,
-  /* 104   -26      */  CWORD_CWORD_CWORD_CWORD,
-  /* 105   -25      */  CWORD_CWORD_CWORD_CWORD,
-  /* 106   -24      */  CWORD_CWORD_CWORD_CWORD,
-  /* 107   -23      */  CWORD_CWORD_CWORD_CWORD,
-  /* 108   -22      */  CWORD_CWORD_CWORD_CWORD,
-  /* 109   -21      */  CWORD_CWORD_CWORD_CWORD,
-  /* 110   -20      */  CWORD_CWORD_CWORD_CWORD,
-  /* 111   -19      */  CWORD_CWORD_CWORD_CWORD,
-  /* 112   -18      */  CWORD_CWORD_CWORD_CWORD,
-  /* 113   -17      */  CWORD_CWORD_CWORD_CWORD,
-  /* 114   -16      */  CWORD_CWORD_CWORD_CWORD,
-  /* 115   -15      */  CWORD_CWORD_CWORD_CWORD,
-  /* 116   -14      */  CWORD_CWORD_CWORD_CWORD,
-  /* 117   -13      */  CWORD_CWORD_CWORD_CWORD,
-  /* 118   -12      */  CWORD_CWORD_CWORD_CWORD,
-  /* 119   -11      */  CWORD_CWORD_CWORD_CWORD,
-  /* 120   -10      */  CWORD_CWORD_CWORD_CWORD,
-  /* 121    -9      */  CWORD_CWORD_CWORD_CWORD,
-  /* 122    -8      */  CWORD_CWORD_CWORD_CWORD,
-  /* 123    -7      */  CWORD_CWORD_CWORD_CWORD,
-  /* 124    -6      */  CWORD_CWORD_CWORD_CWORD,
-  /* 125    -5      */  CWORD_CWORD_CWORD_CWORD,
-  /* 126    -4      */  CWORD_CWORD_CWORD_CWORD,
-  /* 127    -3      */  CWORD_CWORD_CWORD_CWORD,
-  /* 128    -2      */  CWORD_CWORD_CWORD_CWORD,
-  /* 129    -1      */  CWORD_CWORD_CWORD_CWORD,
-  /* 130     0      */  CWORD_CWORD_CWORD_CWORD,
-  /* 131     1      */  CWORD_CWORD_CWORD_CWORD,
-  /* 132     2      */  CWORD_CWORD_CWORD_CWORD,
-  /* 133     3      */  CWORD_CWORD_CWORD_CWORD,
-  /* 134     4      */  CWORD_CWORD_CWORD_CWORD,
-  /* 135     5      */  CWORD_CWORD_CWORD_CWORD,
-  /* 136     6      */  CWORD_CWORD_CWORD_CWORD,
-  /* 137     7      */  CWORD_CWORD_CWORD_CWORD,
-  /* 138     8      */  CWORD_CWORD_CWORD_CWORD,
-  /* 139     9 "\t" */  CSPCL_CWORD_CWORD_CWORD,
-  /* 140    10 "\n" */  CNL_CNL_CNL_CNL,
-  /* 141    11      */  CWORD_CWORD_CWORD_CWORD,
-  /* 142    12      */  CWORD_CWORD_CWORD_CWORD,
-  /* 143    13      */  CWORD_CWORD_CWORD_CWORD,
-  /* 144    14      */  CWORD_CWORD_CWORD_CWORD,
-  /* 145    15      */  CWORD_CWORD_CWORD_CWORD,
-  /* 146    16      */  CWORD_CWORD_CWORD_CWORD,
-  /* 147    17      */  CWORD_CWORD_CWORD_CWORD,
-  /* 148    18      */  CWORD_CWORD_CWORD_CWORD,
-  /* 149    19      */  CWORD_CWORD_CWORD_CWORD,
-  /* 150    20      */  CWORD_CWORD_CWORD_CWORD,
-  /* 151    21      */  CWORD_CWORD_CWORD_CWORD,
-  /* 152    22      */  CWORD_CWORD_CWORD_CWORD,
-  /* 153    23      */  CWORD_CWORD_CWORD_CWORD,
-  /* 154    24      */  CWORD_CWORD_CWORD_CWORD,
-  /* 155    25      */  CWORD_CWORD_CWORD_CWORD,
-  /* 156    26      */  CWORD_CWORD_CWORD_CWORD,
-  /* 157    27      */  CWORD_CWORD_CWORD_CWORD,
-  /* 158    28      */  CWORD_CWORD_CWORD_CWORD,
-  /* 159    29      */  CWORD_CWORD_CWORD_CWORD,
-  /* 160    30      */  CWORD_CWORD_CWORD_CWORD,
-  /* 161    31      */  CWORD_CWORD_CWORD_CWORD,
-  /* 162    32  " " */  CSPCL_CWORD_CWORD_CWORD,
-  /* 163    33  "!" */  CWORD_CCTL_CCTL_CWORD,
-  /* 164    34  """ */  CDQUOTE_CENDQUOTE_CWORD_CDQUOTE,
-  /* 165    35  "#" */  CWORD_CWORD_CWORD_CWORD,
-  /* 166    36  "$" */  CVAR_CVAR_CWORD_CVAR,
-  /* 167    37  "%" */  CWORD_CWORD_CWORD_CWORD,
-  /* 168    38  "&" */  CSPCL_CWORD_CWORD_CWORD,
-  /* 169    39  "'" */  CSQUOTE_CWORD_CENDQUOTE_CSQUOTE,
-  /* 170    40  "(" */  CSPCL_CWORD_CWORD_CLP,
-  /* 171    41  ")" */  CSPCL_CWORD_CWORD_CRP,
-  /* 172    42  "*" */  CWORD_CCTL_CCTL_CWORD,
-  /* 173    43  "+" */  CWORD_CWORD_CWORD_CWORD,
-  /* 174    44  "," */  CWORD_CWORD_CWORD_CWORD,
-  /* 175    45  "-" */  CWORD_CCTL_CCTL_CWORD,
-  /* 176    46  "." */  CWORD_CWORD_CWORD_CWORD,
-  /* 177    47  "/" */  CWORD_CCTL_CCTL_CWORD,
-  /* 178    48  "0" */  CWORD_CWORD_CWORD_CWORD,
-  /* 179    49  "1" */  CWORD_CWORD_CWORD_CWORD,
-  /* 180    50  "2" */  CWORD_CWORD_CWORD_CWORD,
-  /* 181    51  "3" */  CWORD_CWORD_CWORD_CWORD,
-  /* 182    52  "4" */  CWORD_CWORD_CWORD_CWORD,
-  /* 183    53  "5" */  CWORD_CWORD_CWORD_CWORD,
-  /* 184    54  "6" */  CWORD_CWORD_CWORD_CWORD,
-  /* 185    55  "7" */  CWORD_CWORD_CWORD_CWORD,
-  /* 186    56  "8" */  CWORD_CWORD_CWORD_CWORD,
-  /* 187    57  "9" */  CWORD_CWORD_CWORD_CWORD,
-  /* 188    58  ":" */  CWORD_CCTL_CCTL_CWORD,
-  /* 189    59  ";" */  CSPCL_CWORD_CWORD_CWORD,
-  /* 190    60  "<" */  CSPCL_CWORD_CWORD_CWORD,
-  /* 191    61  "=" */  CWORD_CCTL_CCTL_CWORD,
-  /* 192    62  ">" */  CSPCL_CWORD_CWORD_CWORD,
-  /* 193    63  "?" */  CWORD_CCTL_CCTL_CWORD,
-  /* 194    64  "@" */  CWORD_CWORD_CWORD_CWORD,
-  /* 195    65  "A" */  CWORD_CWORD_CWORD_CWORD,
-  /* 196    66  "B" */  CWORD_CWORD_CWORD_CWORD,
-  /* 197    67  "C" */  CWORD_CWORD_CWORD_CWORD,
-  /* 198    68  "D" */  CWORD_CWORD_CWORD_CWORD,
-  /* 199    69  "E" */  CWORD_CWORD_CWORD_CWORD,
-  /* 200    70  "F" */  CWORD_CWORD_CWORD_CWORD,
-  /* 201    71  "G" */  CWORD_CWORD_CWORD_CWORD,
-  /* 202    72  "H" */  CWORD_CWORD_CWORD_CWORD,
-  /* 203    73  "I" */  CWORD_CWORD_CWORD_CWORD,
-  /* 204    74  "J" */  CWORD_CWORD_CWORD_CWORD,
-  /* 205    75  "K" */  CWORD_CWORD_CWORD_CWORD,
-  /* 206    76  "L" */  CWORD_CWORD_CWORD_CWORD,
-  /* 207    77  "M" */  CWORD_CWORD_CWORD_CWORD,
-  /* 208    78  "N" */  CWORD_CWORD_CWORD_CWORD,
-  /* 209    79  "O" */  CWORD_CWORD_CWORD_CWORD,
-  /* 210    80  "P" */  CWORD_CWORD_CWORD_CWORD,
-  /* 211    81  "Q" */  CWORD_CWORD_CWORD_CWORD,
-  /* 212    82  "R" */  CWORD_CWORD_CWORD_CWORD,
-  /* 213    83  "S" */  CWORD_CWORD_CWORD_CWORD,
-  /* 214    84  "T" */  CWORD_CWORD_CWORD_CWORD,
-  /* 215    85  "U" */  CWORD_CWORD_CWORD_CWORD,
-  /* 216    86  "V" */  CWORD_CWORD_CWORD_CWORD,
-  /* 217    87  "W" */  CWORD_CWORD_CWORD_CWORD,
-  /* 218    88  "X" */  CWORD_CWORD_CWORD_CWORD,
-  /* 219    89  "Y" */  CWORD_CWORD_CWORD_CWORD,
-  /* 220    90  "Z" */  CWORD_CWORD_CWORD_CWORD,
-  /* 221    91  "[" */  CWORD_CCTL_CCTL_CWORD,
-  /* 222    92  "\" */  CBACK_CBACK_CCTL_CBACK,
-  /* 223    93  "]" */  CWORD_CCTL_CCTL_CWORD,
-  /* 224    94  "^" */  CWORD_CWORD_CWORD_CWORD,
-  /* 225    95  "_" */  CWORD_CWORD_CWORD_CWORD,
-  /* 226    96  "`" */  CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
-  /* 227    97  "a" */  CWORD_CWORD_CWORD_CWORD,
-  /* 228    98  "b" */  CWORD_CWORD_CWORD_CWORD,
-  /* 229    99  "c" */  CWORD_CWORD_CWORD_CWORD,
-  /* 230   100  "d" */  CWORD_CWORD_CWORD_CWORD,
-  /* 231   101  "e" */  CWORD_CWORD_CWORD_CWORD,
-  /* 232   102  "f" */  CWORD_CWORD_CWORD_CWORD,
-  /* 233   103  "g" */  CWORD_CWORD_CWORD_CWORD,
-  /* 234   104  "h" */  CWORD_CWORD_CWORD_CWORD,
-  /* 235   105  "i" */  CWORD_CWORD_CWORD_CWORD,
-  /* 236   106  "j" */  CWORD_CWORD_CWORD_CWORD,
-  /* 237   107  "k" */  CWORD_CWORD_CWORD_CWORD,
-  /* 238   108  "l" */  CWORD_CWORD_CWORD_CWORD,
-  /* 239   109  "m" */  CWORD_CWORD_CWORD_CWORD,
-  /* 240   110  "n" */  CWORD_CWORD_CWORD_CWORD,
-  /* 241   111  "o" */  CWORD_CWORD_CWORD_CWORD,
-  /* 242   112  "p" */  CWORD_CWORD_CWORD_CWORD,
-  /* 243   113  "q" */  CWORD_CWORD_CWORD_CWORD,
-  /* 244   114  "r" */  CWORD_CWORD_CWORD_CWORD,
-  /* 245   115  "s" */  CWORD_CWORD_CWORD_CWORD,
-  /* 246   116  "t" */  CWORD_CWORD_CWORD_CWORD,
-  /* 247   117  "u" */  CWORD_CWORD_CWORD_CWORD,
-  /* 248   118  "v" */  CWORD_CWORD_CWORD_CWORD,
-  /* 249   119  "w" */  CWORD_CWORD_CWORD_CWORD,
-  /* 250   120  "x" */  CWORD_CWORD_CWORD_CWORD,
-  /* 251   121  "y" */  CWORD_CWORD_CWORD_CWORD,
-  /* 252   122  "z" */  CWORD_CWORD_CWORD_CWORD,
-  /* 253   123  "{" */  CWORD_CWORD_CWORD_CWORD,
-  /* 254   124  "|" */  CSPCL_CWORD_CWORD_CWORD,
-  /* 255   125  "}" */  CENDVAR_CENDVAR_CWORD_CENDVAR,
-  /* 256   126  "~" */  CWORD_CCTL_CCTL_CWORD,
-  /* 257   127      */  CWORD_CWORD_CWORD_CWORD,
+        /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
+        /*   0  -130 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE,
+        /*   1  -129 PEOA */ CSPCL_CIGN_CIGN_CIGN,
+        /*   2  -128 0xff */ CWORD_CWORD_CWORD_CWORD,
+                                                                                                /*   3  -127      */ CCTL_CCTL_CCTL_CCTL,
+                                                                                                /* CTLQUOTEMARK */
+        /*   4  -126      */ CCTL_CCTL_CCTL_CCTL,
+        /*   5  -125      */ CCTL_CCTL_CCTL_CCTL,
+        /*   6  -124      */ CCTL_CCTL_CCTL_CCTL,
+        /*   7  -123      */ CCTL_CCTL_CCTL_CCTL,
+        /*   8  -122      */ CCTL_CCTL_CCTL_CCTL,
+        /*   9  -121      */ CCTL_CCTL_CCTL_CCTL,
+                                                                                                /*  10  -120      */ CCTL_CCTL_CCTL_CCTL,
+                                                                                                /* CTLESC */
+        /*  11  -119      */ CWORD_CWORD_CWORD_CWORD,
+        /*  12  -118      */ CWORD_CWORD_CWORD_CWORD,
+        /*  13  -117      */ CWORD_CWORD_CWORD_CWORD,
+        /*  14  -116      */ CWORD_CWORD_CWORD_CWORD,
+        /*  15  -115      */ CWORD_CWORD_CWORD_CWORD,
+        /*  16  -114      */ CWORD_CWORD_CWORD_CWORD,
+        /*  17  -113      */ CWORD_CWORD_CWORD_CWORD,
+        /*  18  -112      */ CWORD_CWORD_CWORD_CWORD,
+        /*  19  -111      */ CWORD_CWORD_CWORD_CWORD,
+        /*  20  -110      */ CWORD_CWORD_CWORD_CWORD,
+        /*  21  -109      */ CWORD_CWORD_CWORD_CWORD,
+        /*  22  -108      */ CWORD_CWORD_CWORD_CWORD,
+        /*  23  -107      */ CWORD_CWORD_CWORD_CWORD,
+        /*  24  -106      */ CWORD_CWORD_CWORD_CWORD,
+        /*  25  -105      */ CWORD_CWORD_CWORD_CWORD,
+        /*  26  -104      */ CWORD_CWORD_CWORD_CWORD,
+        /*  27  -103      */ CWORD_CWORD_CWORD_CWORD,
+        /*  28  -102      */ CWORD_CWORD_CWORD_CWORD,
+        /*  29  -101      */ CWORD_CWORD_CWORD_CWORD,
+        /*  30  -100      */ CWORD_CWORD_CWORD_CWORD,
+        /*  31   -99      */ CWORD_CWORD_CWORD_CWORD,
+        /*  32   -98      */ CWORD_CWORD_CWORD_CWORD,
+        /*  33   -97      */ CWORD_CWORD_CWORD_CWORD,
+        /*  34   -96      */ CWORD_CWORD_CWORD_CWORD,
+        /*  35   -95      */ CWORD_CWORD_CWORD_CWORD,
+        /*  36   -94      */ CWORD_CWORD_CWORD_CWORD,
+        /*  37   -93      */ CWORD_CWORD_CWORD_CWORD,
+        /*  38   -92      */ CWORD_CWORD_CWORD_CWORD,
+        /*  39   -91      */ CWORD_CWORD_CWORD_CWORD,
+        /*  40   -90      */ CWORD_CWORD_CWORD_CWORD,
+        /*  41   -89      */ CWORD_CWORD_CWORD_CWORD,
+        /*  42   -88      */ CWORD_CWORD_CWORD_CWORD,
+        /*  43   -87      */ CWORD_CWORD_CWORD_CWORD,
+        /*  44   -86      */ CWORD_CWORD_CWORD_CWORD,
+        /*  45   -85      */ CWORD_CWORD_CWORD_CWORD,
+        /*  46   -84      */ CWORD_CWORD_CWORD_CWORD,
+        /*  47   -83      */ CWORD_CWORD_CWORD_CWORD,
+        /*  48   -82      */ CWORD_CWORD_CWORD_CWORD,
+        /*  49   -81      */ CWORD_CWORD_CWORD_CWORD,
+        /*  50   -80      */ CWORD_CWORD_CWORD_CWORD,
+        /*  51   -79      */ CWORD_CWORD_CWORD_CWORD,
+        /*  52   -78      */ CWORD_CWORD_CWORD_CWORD,
+        /*  53   -77      */ CWORD_CWORD_CWORD_CWORD,
+        /*  54   -76      */ CWORD_CWORD_CWORD_CWORD,
+        /*  55   -75      */ CWORD_CWORD_CWORD_CWORD,
+        /*  56   -74      */ CWORD_CWORD_CWORD_CWORD,
+        /*  57   -73      */ CWORD_CWORD_CWORD_CWORD,
+        /*  58   -72      */ CWORD_CWORD_CWORD_CWORD,
+        /*  59   -71      */ CWORD_CWORD_CWORD_CWORD,
+        /*  60   -70      */ CWORD_CWORD_CWORD_CWORD,
+        /*  61   -69      */ CWORD_CWORD_CWORD_CWORD,
+        /*  62   -68      */ CWORD_CWORD_CWORD_CWORD,
+        /*  63   -67      */ CWORD_CWORD_CWORD_CWORD,
+        /*  64   -66      */ CWORD_CWORD_CWORD_CWORD,
+        /*  65   -65      */ CWORD_CWORD_CWORD_CWORD,
+        /*  66   -64      */ CWORD_CWORD_CWORD_CWORD,
+        /*  67   -63      */ CWORD_CWORD_CWORD_CWORD,
+        /*  68   -62      */ CWORD_CWORD_CWORD_CWORD,
+        /*  69   -61      */ CWORD_CWORD_CWORD_CWORD,
+        /*  70   -60      */ CWORD_CWORD_CWORD_CWORD,
+        /*  71   -59      */ CWORD_CWORD_CWORD_CWORD,
+        /*  72   -58      */ CWORD_CWORD_CWORD_CWORD,
+        /*  73   -57      */ CWORD_CWORD_CWORD_CWORD,
+        /*  74   -56      */ CWORD_CWORD_CWORD_CWORD,
+        /*  75   -55      */ CWORD_CWORD_CWORD_CWORD,
+        /*  76   -54      */ CWORD_CWORD_CWORD_CWORD,
+        /*  77   -53      */ CWORD_CWORD_CWORD_CWORD,
+        /*  78   -52      */ CWORD_CWORD_CWORD_CWORD,
+        /*  79   -51      */ CWORD_CWORD_CWORD_CWORD,
+        /*  80   -50      */ CWORD_CWORD_CWORD_CWORD,
+        /*  81   -49      */ CWORD_CWORD_CWORD_CWORD,
+        /*  82   -48      */ CWORD_CWORD_CWORD_CWORD,
+        /*  83   -47      */ CWORD_CWORD_CWORD_CWORD,
+        /*  84   -46      */ CWORD_CWORD_CWORD_CWORD,
+        /*  85   -45      */ CWORD_CWORD_CWORD_CWORD,
+        /*  86   -44      */ CWORD_CWORD_CWORD_CWORD,
+        /*  87   -43      */ CWORD_CWORD_CWORD_CWORD,
+        /*  88   -42      */ CWORD_CWORD_CWORD_CWORD,
+        /*  89   -41      */ CWORD_CWORD_CWORD_CWORD,
+        /*  90   -40      */ CWORD_CWORD_CWORD_CWORD,
+        /*  91   -39      */ CWORD_CWORD_CWORD_CWORD,
+        /*  92   -38      */ CWORD_CWORD_CWORD_CWORD,
+        /*  93   -37      */ CWORD_CWORD_CWORD_CWORD,
+        /*  94   -36      */ CWORD_CWORD_CWORD_CWORD,
+        /*  95   -35      */ CWORD_CWORD_CWORD_CWORD,
+        /*  96   -34      */ CWORD_CWORD_CWORD_CWORD,
+        /*  97   -33      */ CWORD_CWORD_CWORD_CWORD,
+        /*  98   -32      */ CWORD_CWORD_CWORD_CWORD,
+        /*  99   -31      */ CWORD_CWORD_CWORD_CWORD,
+        /* 100   -30      */ CWORD_CWORD_CWORD_CWORD,
+        /* 101   -29      */ CWORD_CWORD_CWORD_CWORD,
+        /* 102   -28      */ CWORD_CWORD_CWORD_CWORD,
+        /* 103   -27      */ CWORD_CWORD_CWORD_CWORD,
+        /* 104   -26      */ CWORD_CWORD_CWORD_CWORD,
+        /* 105   -25      */ CWORD_CWORD_CWORD_CWORD,
+        /* 106   -24      */ CWORD_CWORD_CWORD_CWORD,
+        /* 107   -23      */ CWORD_CWORD_CWORD_CWORD,
+        /* 108   -22      */ CWORD_CWORD_CWORD_CWORD,
+        /* 109   -21      */ CWORD_CWORD_CWORD_CWORD,
+        /* 110   -20      */ CWORD_CWORD_CWORD_CWORD,
+        /* 111   -19      */ CWORD_CWORD_CWORD_CWORD,
+        /* 112   -18      */ CWORD_CWORD_CWORD_CWORD,
+        /* 113   -17      */ CWORD_CWORD_CWORD_CWORD,
+        /* 114   -16      */ CWORD_CWORD_CWORD_CWORD,
+        /* 115   -15      */ CWORD_CWORD_CWORD_CWORD,
+        /* 116   -14      */ CWORD_CWORD_CWORD_CWORD,
+        /* 117   -13      */ CWORD_CWORD_CWORD_CWORD,
+        /* 118   -12      */ CWORD_CWORD_CWORD_CWORD,
+        /* 119   -11      */ CWORD_CWORD_CWORD_CWORD,
+        /* 120   -10      */ CWORD_CWORD_CWORD_CWORD,
+        /* 121    -9      */ CWORD_CWORD_CWORD_CWORD,
+        /* 122    -8      */ CWORD_CWORD_CWORD_CWORD,
+        /* 123    -7      */ CWORD_CWORD_CWORD_CWORD,
+        /* 124    -6      */ CWORD_CWORD_CWORD_CWORD,
+        /* 125    -5      */ CWORD_CWORD_CWORD_CWORD,
+        /* 126    -4      */ CWORD_CWORD_CWORD_CWORD,
+        /* 127    -3      */ CWORD_CWORD_CWORD_CWORD,
+        /* 128    -2      */ CWORD_CWORD_CWORD_CWORD,
+        /* 129    -1      */ CWORD_CWORD_CWORD_CWORD,
+        /* 130     0      */ CWORD_CWORD_CWORD_CWORD,
+        /* 131     1      */ CWORD_CWORD_CWORD_CWORD,
+        /* 132     2      */ CWORD_CWORD_CWORD_CWORD,
+        /* 133     3      */ CWORD_CWORD_CWORD_CWORD,
+        /* 134     4      */ CWORD_CWORD_CWORD_CWORD,
+        /* 135     5      */ CWORD_CWORD_CWORD_CWORD,
+        /* 136     6      */ CWORD_CWORD_CWORD_CWORD,
+        /* 137     7      */ CWORD_CWORD_CWORD_CWORD,
+        /* 138     8      */ CWORD_CWORD_CWORD_CWORD,
+        /* 139     9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
+        /* 140    10 "\n" */ CNL_CNL_CNL_CNL,
+        /* 141    11      */ CWORD_CWORD_CWORD_CWORD,
+        /* 142    12      */ CWORD_CWORD_CWORD_CWORD,
+        /* 143    13      */ CWORD_CWORD_CWORD_CWORD,
+        /* 144    14      */ CWORD_CWORD_CWORD_CWORD,
+        /* 145    15      */ CWORD_CWORD_CWORD_CWORD,
+        /* 146    16      */ CWORD_CWORD_CWORD_CWORD,
+        /* 147    17      */ CWORD_CWORD_CWORD_CWORD,
+        /* 148    18      */ CWORD_CWORD_CWORD_CWORD,
+        /* 149    19      */ CWORD_CWORD_CWORD_CWORD,
+        /* 150    20      */ CWORD_CWORD_CWORD_CWORD,
+        /* 151    21      */ CWORD_CWORD_CWORD_CWORD,
+        /* 152    22      */ CWORD_CWORD_CWORD_CWORD,
+        /* 153    23      */ CWORD_CWORD_CWORD_CWORD,
+        /* 154    24      */ CWORD_CWORD_CWORD_CWORD,
+        /* 155    25      */ CWORD_CWORD_CWORD_CWORD,
+        /* 156    26      */ CWORD_CWORD_CWORD_CWORD,
+        /* 157    27      */ CWORD_CWORD_CWORD_CWORD,
+        /* 158    28      */ CWORD_CWORD_CWORD_CWORD,
+        /* 159    29      */ CWORD_CWORD_CWORD_CWORD,
+        /* 160    30      */ CWORD_CWORD_CWORD_CWORD,
+        /* 161    31      */ CWORD_CWORD_CWORD_CWORD,
+        /* 162    32  " " */ CSPCL_CWORD_CWORD_CWORD,
+        /* 163    33  "!" */ CWORD_CCTL_CCTL_CWORD,
+        /* 164    34  """ */ CDQUOTE_CENDQUOTE_CWORD_CDQUOTE,
+        /* 165    35  "#" */ CWORD_CWORD_CWORD_CWORD,
+        /* 166    36  "$" */ CVAR_CVAR_CWORD_CVAR,
+        /* 167    37  "%" */ CWORD_CWORD_CWORD_CWORD,
+        /* 168    38  "&" */ CSPCL_CWORD_CWORD_CWORD,
+        /* 169    39  "'" */ CSQUOTE_CWORD_CENDQUOTE_CSQUOTE,
+        /* 170    40  "(" */ CSPCL_CWORD_CWORD_CLP,
+        /* 171    41  ")" */ CSPCL_CWORD_CWORD_CRP,
+        /* 172    42  "*" */ CWORD_CCTL_CCTL_CWORD,
+        /* 173    43  "+" */ CWORD_CWORD_CWORD_CWORD,
+        /* 174    44  "," */ CWORD_CWORD_CWORD_CWORD,
+        /* 175    45  "-" */ CWORD_CCTL_CCTL_CWORD,
+        /* 176    46  "." */ CWORD_CWORD_CWORD_CWORD,
+        /* 177    47  "/" */ CWORD_CCTL_CCTL_CWORD,
+        /* 178    48  "0" */ CWORD_CWORD_CWORD_CWORD,
+        /* 179    49  "1" */ CWORD_CWORD_CWORD_CWORD,
+        /* 180    50  "2" */ CWORD_CWORD_CWORD_CWORD,
+        /* 181    51  "3" */ CWORD_CWORD_CWORD_CWORD,
+        /* 182    52  "4" */ CWORD_CWORD_CWORD_CWORD,
+        /* 183    53  "5" */ CWORD_CWORD_CWORD_CWORD,
+        /* 184    54  "6" */ CWORD_CWORD_CWORD_CWORD,
+        /* 185    55  "7" */ CWORD_CWORD_CWORD_CWORD,
+        /* 186    56  "8" */ CWORD_CWORD_CWORD_CWORD,
+        /* 187    57  "9" */ CWORD_CWORD_CWORD_CWORD,
+        /* 188    58  ":" */ CWORD_CCTL_CCTL_CWORD,
+        /* 189    59  ";" */ CSPCL_CWORD_CWORD_CWORD,
+        /* 190    60  "<" */ CSPCL_CWORD_CWORD_CWORD,
+        /* 191    61  "=" */ CWORD_CCTL_CCTL_CWORD,
+        /* 192    62  ">" */ CSPCL_CWORD_CWORD_CWORD,
+        /* 193    63  "?" */ CWORD_CCTL_CCTL_CWORD,
+        /* 194    64  "@" */ CWORD_CWORD_CWORD_CWORD,
+        /* 195    65  "A" */ CWORD_CWORD_CWORD_CWORD,
+        /* 196    66  "B" */ CWORD_CWORD_CWORD_CWORD,
+        /* 197    67  "C" */ CWORD_CWORD_CWORD_CWORD,
+        /* 198    68  "D" */ CWORD_CWORD_CWORD_CWORD,
+        /* 199    69  "E" */ CWORD_CWORD_CWORD_CWORD,
+        /* 200    70  "F" */ CWORD_CWORD_CWORD_CWORD,
+        /* 201    71  "G" */ CWORD_CWORD_CWORD_CWORD,
+        /* 202    72  "H" */ CWORD_CWORD_CWORD_CWORD,
+        /* 203    73  "I" */ CWORD_CWORD_CWORD_CWORD,
+        /* 204    74  "J" */ CWORD_CWORD_CWORD_CWORD,
+        /* 205    75  "K" */ CWORD_CWORD_CWORD_CWORD,
+        /* 206    76  "L" */ CWORD_CWORD_CWORD_CWORD,
+        /* 207    77  "M" */ CWORD_CWORD_CWORD_CWORD,
+        /* 208    78  "N" */ CWORD_CWORD_CWORD_CWORD,
+        /* 209    79  "O" */ CWORD_CWORD_CWORD_CWORD,
+        /* 210    80  "P" */ CWORD_CWORD_CWORD_CWORD,
+        /* 211    81  "Q" */ CWORD_CWORD_CWORD_CWORD,
+        /* 212    82  "R" */ CWORD_CWORD_CWORD_CWORD,
+        /* 213    83  "S" */ CWORD_CWORD_CWORD_CWORD,
+        /* 214    84  "T" */ CWORD_CWORD_CWORD_CWORD,
+        /* 215    85  "U" */ CWORD_CWORD_CWORD_CWORD,
+        /* 216    86  "V" */ CWORD_CWORD_CWORD_CWORD,
+        /* 217    87  "W" */ CWORD_CWORD_CWORD_CWORD,
+        /* 218    88  "X" */ CWORD_CWORD_CWORD_CWORD,
+        /* 219    89  "Y" */ CWORD_CWORD_CWORD_CWORD,
+        /* 220    90  "Z" */ CWORD_CWORD_CWORD_CWORD,
+        /* 221    91  "[" */ CWORD_CCTL_CCTL_CWORD,
+        /* 222    92  "\" */ CBACK_CBACK_CCTL_CBACK,
+        /* 223    93  "]" */ CWORD_CCTL_CCTL_CWORD,
+        /* 224    94  "^" */ CWORD_CWORD_CWORD_CWORD,
+        /* 225    95  "_" */ CWORD_CWORD_CWORD_CWORD,
+        /* 226    96  "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
+        /* 227    97  "a" */ CWORD_CWORD_CWORD_CWORD,
+        /* 228    98  "b" */ CWORD_CWORD_CWORD_CWORD,
+        /* 229    99  "c" */ CWORD_CWORD_CWORD_CWORD,
+        /* 230   100  "d" */ CWORD_CWORD_CWORD_CWORD,
+        /* 231   101  "e" */ CWORD_CWORD_CWORD_CWORD,
+        /* 232   102  "f" */ CWORD_CWORD_CWORD_CWORD,
+        /* 233   103  "g" */ CWORD_CWORD_CWORD_CWORD,
+        /* 234   104  "h" */ CWORD_CWORD_CWORD_CWORD,
+        /* 235   105  "i" */ CWORD_CWORD_CWORD_CWORD,
+        /* 236   106  "j" */ CWORD_CWORD_CWORD_CWORD,
+        /* 237   107  "k" */ CWORD_CWORD_CWORD_CWORD,
+        /* 238   108  "l" */ CWORD_CWORD_CWORD_CWORD,
+        /* 239   109  "m" */ CWORD_CWORD_CWORD_CWORD,
+        /* 240   110  "n" */ CWORD_CWORD_CWORD_CWORD,
+        /* 241   111  "o" */ CWORD_CWORD_CWORD_CWORD,
+        /* 242   112  "p" */ CWORD_CWORD_CWORD_CWORD,
+        /* 243   113  "q" */ CWORD_CWORD_CWORD_CWORD,
+        /* 244   114  "r" */ CWORD_CWORD_CWORD_CWORD,
+        /* 245   115  "s" */ CWORD_CWORD_CWORD_CWORD,
+        /* 246   116  "t" */ CWORD_CWORD_CWORD_CWORD,
+        /* 247   117  "u" */ CWORD_CWORD_CWORD_CWORD,
+        /* 248   118  "v" */ CWORD_CWORD_CWORD_CWORD,
+        /* 249   119  "w" */ CWORD_CWORD_CWORD_CWORD,
+        /* 250   120  "x" */ CWORD_CWORD_CWORD_CWORD,
+        /* 251   121  "y" */ CWORD_CWORD_CWORD_CWORD,
+        /* 252   122  "z" */ CWORD_CWORD_CWORD_CWORD,
+        /* 253   123  "{" */ CWORD_CWORD_CWORD_CWORD,
+        /* 254   124  "|" */ CSPCL_CWORD_CWORD_CWORD,
+        /* 255   125  "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
+        /* 256   126  "~" */ CWORD_CCTL_CCTL_CWORD,
+        /* 257   127      */ CWORD_CWORD_CWORD_CWORD,
 };
 
-#endif  /* USE_SIT_FUNCTION */
+#endif                                                  /* USE_SIT_FUNCTION */
 
 
 /* first char is indicating which tokens mark the end of a list */
@@ -1036,20 +1068,20 @@ static const char *tokname(int tok)
 {
         static char buf[16];
 
-        if(tok>=TSEMI)
+        if (tok >= TSEMI)
                 buf[0] = '"';
-        sprintf(buf+(tok>=TSEMI), "%s%c",
-                        tokname_array[tok]+1, (tok>=TSEMI ? '"' : 0));
+        sprintf(buf + (tok >= TSEMI), "%s%c",
+                        tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
         return buf;
 }
 
-static int plinno = 1;          /* input line number */
+static int plinno = 1;  /* input line number */
 
-static int parselleft;          /* copy of parsefile->lleft */
+static int parselleft;  /* copy of parsefile->lleft */
 
-static struct parsefile basepf; /* top level input file */
-static char basebuf[BUFSIZ];    /* buffer for top level input file */
-static struct parsefile *parsefile = &basepf;  /* current input file */
+static struct parsefile basepf; /* top level input file */
+static char basebuf[BUFSIZ];    /* buffer for top level input file */
+static struct parsefile *parsefile = &basepf;   /* current input file */
 
 /*
  * NEOF is returned by parsecmd when it encounters an end of file.  It
@@ -1057,31 +1089,32 @@ static struct parsefile *parsefile = &basepf;  /* current input file */
  * happens to be handy.
  */
 
-static int tokpushback;         /* last token pushed back */
+static int tokpushback; /* last token pushed back */
+
 #define NEOF ((union node *)&tokpushback)
-static int checkkwd;            /* 1 == check for kwds, 2 == also eat newlines */
+static int checkkwd;    /* 1 == check for kwds, 2 == also eat newlines */
 
 
-static void error (const char *, ...) __attribute__((__noreturn__));
-static void exerror (int, const char *, ...) __attribute__((__noreturn__));
-static void shellexec (char **, char **, const char *, int)
-    __attribute__((noreturn));
-static void exitshell (int) __attribute__((noreturn));
+static void error(const char *, ...) __attribute__ ((__noreturn__));
+static void exerror(int, const char *, ...) __attribute__ ((__noreturn__));
+static void shellexec(char **, char **, const char *, int)
+        __attribute__ ((noreturn));
+static void exitshell(int) __attribute__ ((noreturn));
 
-static int  goodname(const char *);
-static void ignoresig (int);
-static void onsig (int);
-static void dotrap (void);
-static int  decode_signal (const char *, int);
+static int goodname(const char *);
+static void ignoresig(int);
+static void onsig(int);
+static void dotrap(void);
+static int decode_signal(const char *, int);
 
 static void shprocvar(void);
 static void deletefuncs(void);
-static void setparam (char **);
-static void freeparam (volatile struct shparam *);
+static void setparam(char **);
+static void freeparam(volatile struct shparam *);
 
-static void find_command (const char *, struct cmdentry *, int, const char *);
+static void find_command(const char *, struct cmdentry *, int, const char *);
 
-static inline void hashcd (void);
+static inline void hashcd(void);
 
 /* reasons for skipping commands (see comment on breakcmd routine) */
 #define SKIPBREAK       1
@@ -1090,76 +1123,76 @@ static inline void hashcd (void);
 #define SKIPFILE        4
 
 /* values of cmdtype */
-#define CMDUNKNOWN -1           /* no entry in table for command */
-#define CMDNORMAL 0             /* command is an executable program */
-#define CMDBUILTIN 1            /* command is a shell builtin */
-#define CMDFUNCTION 2           /* command is a shell function */
+#define CMDUNKNOWN -1   /* no entry in table for command */
+#define CMDNORMAL 0             /* command is an executable program */
+#define CMDBUILTIN 1    /* command is a shell builtin */
+#define CMDFUNCTION 2   /* command is a shell function */
 
-#define DO_ERR  1               /* find_command prints errors */
-#define DO_ABS  2               /* find_command checks absolute paths */
-#define DO_NOFUN        4       /* find_command ignores functions */
-#define DO_BRUTE        8       /* find_command ignores hash table */
+#define DO_ERR  1               /* find_command prints errors */
+#define DO_ABS  2               /* find_command checks absolute paths */
+#define DO_NOFUN        4       /* find_command ignores functions */
+#define DO_BRUTE        8       /* find_command ignores hash table */
 
 /*
  * Shell variables.
  */
 
 /* flags */
-#define VEXPORT         0x01    /* variable is exported */
-#define VREADONLY       0x02    /* variable cannot be modified */
-#define VSTRFIXED       0x04    /* variable struct is staticly allocated */
-#define VTEXTFIXED      0x08    /* text is staticly allocated */
-#define VSTACK          0x10    /* text is allocated on the stack */
-#define VUNSET          0x20    /* the variable is not set */
-#define VNOFUNC         0x40    /* don't call the callback function */
+#define VEXPORT         0x01    /* variable is exported */
+#define VREADONLY       0x02    /* variable cannot be modified */
+#define VSTRFIXED       0x04    /* variable struct is staticly allocated */
+#define VTEXTFIXED      0x08    /* text is staticly allocated */
+#define VSTACK          0x10    /* text is allocated on the stack */
+#define VUNSET          0x20    /* the variable is not set */
+#define VNOFUNC         0x40    /* don't call the callback function */
 
 
 struct var {
-        struct var *next;               /* next entry in hash list */
-        int flags;                      /* flags are defined above */
-        char *text;                     /* name=value */
+        struct var *next;       /* next entry in hash list */
+        int flags;                      /* flags are defined above */
+        char *text;                     /* name=value */
         void (*func) (const char *);
-                                        /* function to be called when  */
-                                        /* the variable gets set/unset */
+        /* function to be called when  */
+        /* the variable gets set/unset */
 };
 
 struct localvar {
-        struct localvar *next;          /* next local variable in list */
-        struct var *vp;                 /* the variable that was made local */
-        int flags;                      /* saved flags */
-        char *text;                     /* saved text */
+        struct localvar *next;  /* next local variable in list */
+        struct var *vp;         /* the variable that was made local */
+        int flags;                      /* saved flags */
+        char *text;                     /* saved text */
 };
 
 
 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
 #define rmescapes(p) _rmescapes((p), 0)
-static char *_rmescapes (char *, int);
+static char *_rmescapes(char *, int);
 #else
-static void rmescapes (char *);
+static void rmescapes(char *);
 #endif
 
-static int  casematch (union node *, const char *);
+static int casematch(union node *, const char *);
 static void clearredir(void);
 static void popstring(void);
-static void readcmdfile (const char *);
+static void readcmdfile(const char *);
 
-static int number (const char *);
-static int is_number (const char *, int *num);
-static char *single_quote (const char *);
-static int nextopt (const char *);
+static int number(const char *);
+static int is_number(const char *, int *num);
+static char *single_quote(const char *);
+static int nextopt(const char *);
 
-static void redirect (union node *, int);
-static void popredir (void);
-static int dup_as_newfd (int, int);
+static void redirect(union node *, int);
+static void popredir(void);
+static int dup_as_newfd(int, int);
 
 static void changepath(const char *newval);
 static void getoptsreset(const char *value);
 
 
-static int parsenleft;                  /* copy of parsefile->nleft */
-static char *parsenextc;                /* copy of parsefile->nextc */
-static int rootpid;     /* pid of main shell */
-static int rootshell;   /* true if we aren't a child of the main shell */
+static int parsenleft;  /* copy of parsefile->nleft */
+static char *parsenextc;        /* copy of parsefile->nextc */
+static int rootpid;             /* pid of main shell */
+static int rootshell;   /* true if we aren't a child of the main shell */
 
 static const char spcstr[] = " ";
 static const char snlfmt[] = "%s\n";
@@ -1176,6 +1209,7 @@ static struct var vpath;
 static struct var vps1;
 static struct var vps2;
 static struct var voptind;
+
 #ifdef CONFIG_LOCALE_SUPPORT
 static struct var vlc_all;
 static struct var vlc_ctype;
@@ -1194,6 +1228,7 @@ static const char defpathvar[] =
 
 #ifdef IFS_BROKEN
 static const char defifsvar[] = "IFS= \t\n";
+
 #define defifs (defifsvar + 4)
 #else
 static const char defifs[] = " \t\n";
@@ -1201,33 +1236,33 @@ static const char defifs[] = " \t\n";
 
 static const struct varinit varinit[] = {
 #ifdef IFS_BROKEN
-        { &vifs,        VSTRFIXED|VTEXTFIXED,           defifsvar,
+        {&vifs, VSTRFIXED | VTEXTFIXED, defifsvar,
 #else
-        { &vifs,        VSTRFIXED|VTEXTFIXED|VUNSET,    "IFS=",
-#endif
-          NULL },
-        { &vmail,       VSTRFIXED|VTEXTFIXED|VUNSET,    "MAIL=",
-          NULL },
-        { &vmpath,      VSTRFIXED|VTEXTFIXED|VUNSET,    "MAILPATH=",
-          NULL },
-        { &vpath,       VSTRFIXED|VTEXTFIXED,           defpathvar,
-          changepath },
+        {&vifs, VSTRFIXED | VTEXTFIXED | VUNSET, "IFS=",
+#endif
+         NULL},
+        {&vmail, VSTRFIXED | VTEXTFIXED | VUNSET, "MAIL=",
+         NULL},
+        {&vmpath, VSTRFIXED | VTEXTFIXED | VUNSET, "MAILPATH=",
+         NULL},
+        {&vpath, VSTRFIXED | VTEXTFIXED, defpathvar,
+         changepath},
 #if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
-        { &vps1,        VSTRFIXED|VTEXTFIXED,           "PS1=\\w \\$ ",
-          NULL },
-#endif /* else vps1 depends on uid */
-        { &vps2,        VSTRFIXED|VTEXTFIXED,           "PS2=> ",
-          NULL },
-        { &voptind,     VSTRFIXED|VTEXTFIXED,           "OPTIND=1",
-          getoptsreset },
+        {&vps1, VSTRFIXED | VTEXTFIXED, "PS1=\\w \\$ ",
+         NULL},
+#endif                                                  /* else vps1 depends on uid */
+        {&vps2, VSTRFIXED | VTEXTFIXED, "PS2=> ",
+         NULL},
+        {&voptind, VSTRFIXED | VTEXTFIXED, "OPTIND=1",
+         getoptsreset},
 #ifdef CONFIG_LOCALE_SUPPORT
-        { &vlc_all,     VSTRFIXED|VTEXTFIXED|VUNSET,    "LC_ALL=",
-          change_lc_all },
-        { &vlc_ctype,   VSTRFIXED|VTEXTFIXED|VUNSET,    "LC_CTYPE=",
-          change_lc_ctype },
+        {&vlc_all, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL=",
+         change_lc_all},
+        {&vlc_ctype, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE=",
+         change_lc_ctype},
 #endif
-        { NULL, 0,                              NULL,
-          NULL }
+        {NULL, 0, NULL,
+         NULL}
 };
 
 #define VTABSIZE 39
@@ -1251,26 +1286,26 @@ static struct var *vartab[VTABSIZE];
 
 #define mpathset()      ((vmpath.flags & VUNSET) == 0)
 
-static void initvar (void);
-static void setvar (const char *, const char *, int);
-static void setvareq (char *, int);
-static void listsetvar (struct strlist *);
-static const char *lookupvar (const char *);
-static const char *bltinlookup (const char *);
-static char **environment (void);
-static int showvarscmd (int, char **);
-static void mklocal (char *);
-static void poplocalvars (void);
-static int unsetvar (const char *);
-static int varequal (const char *, const char *);
+static void initvar(void);
+static void setvar(const char *, const char *, int);
+static void setvareq(char *, int);
+static void listsetvar(struct strlist *);
+static const char *lookupvar(const char *);
+static const char *bltinlookup(const char *);
+static char **environment(void);
+static int showvarscmd(int, char **);
+static void mklocal(char *);
+static void poplocalvars(void);
+static int unsetvar(const char *);
+static int varequal(const char *, const char *);
 
 
-static char *arg0;                      /* value of $0 */
-static struct shparam shellparam;       /* current positional parameters */
-static char **argptr;                   /* argument list for builtin commands */
-static char *optionarg;                 /* set by nextopt (like getopt) */
-static char *optptr;                    /* used by nextopt */
-static char *minusc;                    /* argument to -c option */
+static char *arg0;              /* value of $0 */
+static struct shparam shellparam;       /* current positional parameters */
+static char **argptr;   /* argument list for builtin commands */
+static char *optionarg; /* set by nextopt (like getopt) */
+static char *optptr;    /* used by nextopt */
+static char *minusc;    /* argument to -c option */
 
 
 #ifdef CONFIG_ASH_ALIAS
@@ -1289,13 +1324,12 @@ struct alias {
 
 static struct alias *atab[ATABSIZE];
 
-static void setalias (char *, char *);
-static struct alias **hashalias (const char *);
-static struct alias *freealias (struct alias *);
-static struct alias **__lookupalias (const char *);
+static void setalias(char *, char *);
+static struct alias **hashalias(const char *);
+static struct alias *freealias(struct alias *);
+static struct alias **__lookupalias(const char *);
 
-static void
-setalias(char *name, char *val)
+static void setalias(char *name, char *val)
 {
         struct alias *ap, **app;
 
@@ -1310,7 +1344,7 @@ setalias(char *name, char *val)
                 ap->flag &= ~ALIASDEAD;
         } else {
                 /* not found */
-                ap = xmalloc(sizeof (struct alias));
+                ap = xmalloc(sizeof(struct alias));
                 ap->name = xstrdup(name);
                 ap->val = xstrdup(val);
                 ap->flag = 0;
@@ -1320,8 +1354,7 @@ setalias(char *name, char *val)
         INTON;
 }
 
-static int
-unalias(char *name)
+static int unalias(char *name)
 {
         struct alias **app;
 
@@ -1337,8 +1370,7 @@ unalias(char *name)
         return (1);
 }
 
-static void
-rmaliases(void)
+static void rmaliases(void)
 {
         struct alias *ap, **app;
         int i;
@@ -1356,8 +1388,8 @@ rmaliases(void)
         INTON;
 }
 
-static void
-printalias(const struct alias *ap) {
+static void printalias(const struct alias *ap)
+{
         char *p;
 
         p = single_quote(ap->val);
@@ -1369,8 +1401,7 @@ printalias(const struct alias *ap) {
 /*
  * TODO - sort output
  */
-static int
-aliascmd(int argc, char **argv)
+static int aliascmd(int argc, char **argv)
 {
         char *n, *v;
         int ret = 0;
@@ -1386,14 +1417,13 @@ aliascmd(int argc, char **argv)
                 return (0);
         }
         while ((n = *++argv) != NULL) {
-                if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
+                if ((v = strchr(n + 1, '=')) == NULL) { /* n+1: funny ksh stuff */
                         if ((ap = *__lookupalias(n)) == NULL) {
                                 out2fmt("%s: %s not found\n", "alias", n);
                                 ret = 1;
                         } else
                                 printalias(ap);
-                }
-                else {
+                } else {
                         *v++ = '\0';
                         setalias(n, v);
                 }
@@ -1402,8 +1432,7 @@ aliascmd(int argc, char **argv)
         return (ret);
 }
 
-static int
-unaliascmd(int argc, char **argv)
+static int unaliascmd(int argc, char **argv)
 {
         int i;
 
@@ -1423,19 +1452,17 @@ unaliascmd(int argc, char **argv)
         return (i);
 }
 
-static struct alias **
-hashalias(const char *p)
+static struct alias **hashalias(const char *p)
 {
         unsigned int hashval;
 
         hashval = *p << 4;
         while (*p)
-                hashval+= *p++;
+                hashval += *p++;
         return &atab[hashval % ATABSIZE];
 }
 
-static struct alias *
-freealias(struct alias *ap)
+static struct alias *freealias(struct alias *ap)
 {
         struct alias *next;
 
@@ -1452,8 +1479,7 @@ freealias(struct alias *ap)
 }
 
 
-static struct alias **
-__lookupalias(const char *name)
+static struct alias **__lookupalias(const char *name)
 {
         struct alias **app = hashalias(name);
 
@@ -1472,71 +1498,75 @@ __lookupalias(const char *name)
  * written implementation written by Aaron Lehmann <aaronl@vitelus.com>.
  * This is now part of libbb, so that it can be used by all the shells
  * in busybox. */
-static void expari (int);
+static void expari(int);
 #endif
 
-static char *trap[NSIG];                /* trap handler commands */
-static char sigmode[NSIG - 1];  /* current value of signal */
-static char gotsig[NSIG - 1];           /* indicates specified signal received */
-static int pendingsigs;                 /* indicates some signal received */
+static char *trap[NSIG];        /* trap handler commands */
+static char sigmode[NSIG - 1];  /* current value of signal */
+static char gotsig[NSIG - 1];   /* indicates specified signal received */
+static int pendingsigs; /* indicates some signal received */
 
 /*
  * This file was generated by the mkbuiltins program.
  */
 
 #ifdef CONFIG_ASH_JOB_CONTROL
-static int bgcmd (int, char **);
-static int fgcmd (int, char **);
-static int killcmd (int, char **);
+static int bgcmd(int, char **);
+static int fgcmd(int, char **);
+static int killcmd(int, char **);
 #endif
-static int bltincmd (int, char **);
-static int cdcmd (int, char **);
-static int breakcmd (int, char **);
+static int bltincmd(int, char **);
+static int cdcmd(int, char **);
+static int breakcmd(int, char **);
+
 #ifdef CONFIG_ASH_CMDCMD
-static int commandcmd (int, char **);
-#endif
-static int dotcmd (int, char **);
-static int evalcmd (int, char **);
-static int execcmd (int, char **);
-static int exitcmd (int, char **);
-static int exportcmd (int, char **);
-static int histcmd (int, char **);
-static int hashcmd (int, char **);
-static int helpcmd (int, char **);
-static int jobscmd (int, char **);
-static int localcmd (int, char **);
-static int pwdcmd (int, char **);
-static int readcmd (int, char **);
-static int returncmd (int, char **);
-static int setcmd (int, char **);
-static int setvarcmd (int, char **);
-static int shiftcmd (int, char **);
-static int trapcmd (int, char **);
-static int umaskcmd (int, char **);
+static int commandcmd(int, char **);
+#endif
+static int dotcmd(int, char **);
+static int evalcmd(int, char **);
+static int execcmd(int, char **);
+static int exitcmd(int, char **);
+static int exportcmd(int, char **);
+static int histcmd(int, char **);
+static int hashcmd(int, char **);
+static int helpcmd(int, char **);
+static int jobscmd(int, char **);
+static int localcmd(int, char **);
+static int pwdcmd(int, char **);
+static int readcmd(int, char **);
+static int returncmd(int, char **);
+static int setcmd(int, char **);
+static int setvarcmd(int, char **);
+static int shiftcmd(int, char **);
+static int trapcmd(int, char **);
+static int umaskcmd(int, char **);
+
 #ifdef CONFIG_ASH_ALIAS
-static int aliascmd (int, char **);
-static int unaliascmd (int, char **);
+static int aliascmd(int, char **);
+static int unaliascmd(int, char **);
 #endif
-static int unsetcmd (int, char **);
-static int waitcmd (int, char **);
-static int ulimitcmd (int, char **);
-static int timescmd (int, char **);
+static int unsetcmd(int, char **);
+static int waitcmd(int, char **);
+static int ulimitcmd(int, char **);
+static int timescmd(int, char **);
+
 #ifdef CONFIG_ASH_MATH_SUPPORT
-static int letcmd (int, char **);
+static int letcmd(int, char **);
 #endif
-static int typecmd (int, char **);
+static int typecmd(int, char **);
+
 #ifdef CONFIG_ASH_GETOPTS
-static int getoptscmd (int, char **);
+static int getoptscmd(int, char **);
 #endif
 
 #ifndef CONFIG_TRUE
-static int true_main (int, char **);
+static int true_main(int, char **);
 #endif
 #ifndef CONFIG_FALSE
-static int false_main (int, char **);
+static int false_main(int, char **);
 #endif
 
-static void     setpwd (const char *, int);
+static void setpwd(const char *, int);
 
 
 #define BUILTIN_NOSPEC  "0"
@@ -1553,7 +1583,7 @@ static void     setpwd (const char *, int);
 struct builtincmd {
         const char *name;
         int (*const builtinfunc) (int, char **);
-        //unsigned flags;
+        /* unsigned flags; */
 };
 
 
@@ -1564,63 +1594,64 @@ struct builtincmd {
  * have been warned.
  */
 static const struct builtincmd builtincmds[] = {
-        { BUILTIN_SPECIAL   ".", dotcmd },    /* first, see declare DOTCMD */
-        { BUILTIN_SPECIAL   ":", true_main },
+        {BUILTIN_SPECIAL ".", dotcmd},  /* first, see declare DOTCMD */
+        {BUILTIN_SPECIAL ":", true_main},
 #ifdef CONFIG_ASH_ALIAS
-        { BUILTIN_REG_ASSG  "alias", aliascmd },
+        {BUILTIN_REG_ASSG "alias", aliascmd},
 #endif
 #ifdef CONFIG_ASH_JOB_CONTROL
-        { BUILTIN_REGULAR   "bg", bgcmd },
+        {BUILTIN_REGULAR "bg", bgcmd},
 #endif
-        { BUILTIN_SPECIAL   "break", breakcmd },
-        { BUILTIN_SPECIAL   "builtin", bltincmd },
-        { BUILTIN_REGULAR   "cd", cdcmd },
-        { BUILTIN_NOSPEC    "chdir", cdcmd },
+        {BUILTIN_SPECIAL "break", breakcmd},
+        {BUILTIN_SPECIAL "builtin", bltincmd},
+        {BUILTIN_REGULAR "cd", cdcmd},
+        {BUILTIN_NOSPEC "chdir", cdcmd},
 #ifdef CONFIG_ASH_CMDCMD
-        { BUILTIN_REGULAR   "command", commandcmd },
-#endif
-        { BUILTIN_SPECIAL   "continue", breakcmd },
-        { BUILTIN_SPECIAL   "eval", evalcmd },
-        { BUILTIN_SPECIAL   "exec", execcmd },
-        { BUILTIN_SPECIAL   "exit", exitcmd },
-        { BUILTIN_SPEC_ASSG "export", exportcmd },
-        { BUILTIN_REGULAR   "false", false_main },
-        { BUILTIN_REGULAR   "fc", histcmd },
+        {BUILTIN_REGULAR "command", commandcmd},
+#endif
+        {BUILTIN_SPECIAL "continue", breakcmd},
+        {BUILTIN_SPECIAL "eval", evalcmd},
+        {BUILTIN_SPECIAL "exec", execcmd},
+        {BUILTIN_SPECIAL "exit", exitcmd},
+        {BUILTIN_SPEC_ASSG "export", exportcmd},
+        {BUILTIN_REGULAR "false", false_main},
+        {BUILTIN_REGULAR "fc", histcmd},
 #ifdef CONFIG_ASH_JOB_CONTROL
-        { BUILTIN_REGULAR   "fg", fgcmd },
+        {BUILTIN_REGULAR "fg", fgcmd},
 #endif
 #ifdef CONFIG_ASH_GETOPTS
-        { BUILTIN_REGULAR   "getopts", getoptscmd },
+        {BUILTIN_REGULAR "getopts", getoptscmd},
 #endif
-        { BUILTIN_NOSPEC    "hash", hashcmd },
-        { BUILTIN_NOSPEC    "help", helpcmd },
-        { BUILTIN_REGULAR   "jobs", jobscmd },
+        {BUILTIN_NOSPEC "hash", hashcmd},
+        {BUILTIN_NOSPEC "help", helpcmd},
+        {BUILTIN_REGULAR "jobs", jobscmd},
 #ifdef CONFIG_ASH_JOB_CONTROL
-        { BUILTIN_REGULAR   "kill", killcmd },
+        {BUILTIN_REGULAR "kill", killcmd},
 #endif
 #ifdef CONFIG_ASH_MATH_SUPPORT
-        { BUILTIN_REGULAR    "let", letcmd },
-#endif
-        { BUILTIN_ASSIGN    "local", localcmd },
-        { BUILTIN_NOSPEC    "pwd", pwdcmd },
-        { BUILTIN_REGULAR   "read", readcmd },
-        { BUILTIN_SPEC_ASSG "readonly", exportcmd },
-        { BUILTIN_SPECIAL   "return", returncmd },
-        { BUILTIN_SPECIAL   "set", setcmd },
-        { BUILTIN_NOSPEC    "setvar", setvarcmd },
-        { BUILTIN_SPECIAL   "shift", shiftcmd },
-        { BUILTIN_SPECIAL   "times", timescmd },
-        { BUILTIN_SPECIAL   "trap", trapcmd },
-        { BUILTIN_REGULAR   "true", true_main },
-        { BUILTIN_NOSPEC    "type", typecmd },
-        { BUILTIN_NOSPEC    "ulimit", ulimitcmd },
-        { BUILTIN_REGULAR   "umask", umaskcmd },
+        {BUILTIN_REGULAR "let", letcmd},
+#endif
+        {BUILTIN_ASSIGN "local", localcmd},
+        {BUILTIN_NOSPEC "pwd", pwdcmd},
+        {BUILTIN_REGULAR "read", readcmd},
+        {BUILTIN_SPEC_ASSG "readonly", exportcmd},
+        {BUILTIN_SPECIAL "return", returncmd},
+        {BUILTIN_SPECIAL "set", setcmd},
+        {BUILTIN_NOSPEC "setvar", setvarcmd},
+        {BUILTIN_SPECIAL "shift", shiftcmd},
+        {BUILTIN_SPECIAL "times", timescmd},
+        {BUILTIN_SPECIAL "trap", trapcmd},
+        {BUILTIN_REGULAR "true", true_main},
+        {BUILTIN_NOSPEC "type", typecmd},
+        {BUILTIN_NOSPEC "ulimit", ulimitcmd},
+        {BUILTIN_REGULAR "umask", umaskcmd},
 #ifdef CONFIG_ASH_ALIAS
-        { BUILTIN_REGULAR   "unalias", unaliascmd },
+        {BUILTIN_REGULAR "unalias", unaliascmd},
 #endif
-        { BUILTIN_SPECIAL   "unset", unsetcmd },
-        { BUILTIN_REGULAR   "wait", waitcmd },
+        {BUILTIN_SPECIAL "unset", unsetcmd},
+        {BUILTIN_REGULAR "wait", waitcmd},
 };
+
 #define NUMBUILTINS  (sizeof (builtincmds) / sizeof (struct builtincmd) )
 
 #define DOTCMD &builtincmds[0]
@@ -1629,8 +1660,8 @@ static struct builtincmd *EXECCMD;
 static struct builtincmd *EVALCMD;
 
 /* states */
-#define CONFIG_ASH_JOB_CONTROLTOPPED 1            /* all procs are stopped */
-#define JOBDONE 2               /* all procs are completed */
+#define CONFIG_ASH_JOB_CONTROLTOPPED 1  /* all procs are stopped */
+#define JOBDONE 2               /* all procs are completed */
 
 /*
  * A job structure contains information about a job.  A job is either a
@@ -1640,58 +1671,58 @@ static struct builtincmd *EVALCMD;
  */
 
 struct procstat {
-        pid_t pid;              /* process id */
-        int status;             /* status flags (defined above) */
-        char *cmd;              /* text of command being run */
+        pid_t pid;                      /* process id */
+        int status;                     /* status flags (defined above) */
+        char *cmd;                      /* text of command being run */
 };
 
 
-static int job_warning;         /* user was warned about stopped jobs */
+static int job_warning; /* user was warned about stopped jobs */
 
 #ifdef CONFIG_ASH_JOB_CONTROL
 static void setjobctl(int enable);
 #else
-#define setjobctl(on)   /* do nothing */
+#define setjobctl(on)   /* do nothing */
 #endif
 
 
 struct job {
-        struct procstat ps0;    /* status of process */
-        struct procstat *ps;    /* status or processes when more than one */
-        short nprocs;           /* number of processes */
-        short pgrp;             /* process group of this job */
-        char state;             /* true if job is finished */
-        char used;              /* true if this entry is in used */
-        char changed;           /* true if status has changed */
+        struct procstat ps0;    /* status of process */
+        struct procstat *ps;    /* status or processes when more than one */
+        short nprocs;           /* number of processes */
+        short pgrp;                     /* process group of this job */
+        char state;                     /* true if job is finished */
+        char used;                      /* true if this entry is in used */
+        char changed;           /* true if status has changed */
 #ifdef CONFIG_ASH_JOB_CONTROL
-        char jobctl;            /* job running under job control */
+        char jobctl;            /* job running under job control */
 #endif
 };
 
-static struct job *jobtab;      /* array of jobs */
-static int njobs;               /* size of array */
-static int backgndpid = -1;     /* pid of last background process */
+static struct job *jobtab;      /* array of jobs */
+static int njobs;               /* size of array */
+static int backgndpid = -1;     /* pid of last background process */
+
 #ifdef CONFIG_ASH_JOB_CONTROL
-static int initialpgrp;         /* pgrp of shell on invocation */
-static int curjob;              /* current job */
+static int initialpgrp; /* pgrp of shell on invocation */
+static int curjob;              /* current job */
 static int jobctl;
 #endif
 static int intreceived;
 
-static struct job *makejob (const union node *, int);
-static int forkshell (struct job *, const union node *, int);
-static int waitforjob (struct job *);
+static struct job *makejob(const union node *, int);
+static int forkshell(struct job *, const union node *, int);
+static int waitforjob(struct job *);
 
-static int docd (char *, int);
-static void getpwd (void);
+static int docd(char *, int);
+static void getpwd(void);
 
-static char *padvance (const char **, const char *);
+static char *padvance(const char **, const char *);
 
-static char nullstr[1];         /* zero length string */
-static char *curdir = nullstr;          /* current working directory */
+static char nullstr[1]; /* zero length string */
+static char *curdir = nullstr;  /* current working directory */
 
-static int
-cdcmd(int argc, char **argv)
+static int cdcmd(int argc, char **argv)
 {
         const char *dest;
         const char *path;
@@ -1742,8 +1773,7 @@ cdcmd(int argc, char **argv)
  * directory name if "print" is nonzero.
  */
 
-static int
-docd(char *dest, int print)
+static int docd(char *dest, int print)
 {
         TRACE(("docd(\"%s\", %d) called\n", dest, print));
         INTOFF;
@@ -1770,24 +1800,21 @@ docd(char *dest, int print)
 }
 
 
-static int
-pwdcmd(int argc, char **argv)
+static int pwdcmd(int argc, char **argv)
 {
         puts(curdir);
         return 0;
 }
 
 /* Ask system the current directory */
-static void
-getpwd(void)
+static void getpwd(void)
 {
         curdir = xgetcwd(0);
-        if(curdir==0)
+        if (curdir == 0)
                 curdir = nullstr;
 }
 
-static void
-setpwd(const char *val, int setold)
+static void setpwd(const char *val, int setold)
 {
         char *cated = NULL;
 
@@ -1796,13 +1823,13 @@ setpwd(const char *val, int setold)
         }
         INTOFF;
         if (curdir != nullstr) {
-                if(val!=NULL && *val != '/')
+                if (val != NULL && *val != '/')
                         val = cated = concat_path_file(curdir, val);
                 free(curdir);
         }
         if (!val)
                 getpwd();
-         else
+        else
                 curdir = simplify_path(val);
         free(cated);
         INTON;
@@ -1832,16 +1859,16 @@ struct jmploc {
 };
 
 /* exceptions */
-#define EXINT 0         /* SIGINT received */
-#define EXERROR 1       /* a generic error */
-#define EXSHELLPROC 2   /* execute a shell procedure */
-#define EXEXEC 3        /* command execution failed */
+#define EXINT 0                 /* SIGINT received */
+#define EXERROR 1               /* a generic error */
+#define EXSHELLPROC 2   /* execute a shell procedure */
+#define EXEXEC 3                /* command execution failed */
 
 static struct jmploc *handler;
 static int exception;
 
-static void exverror (int, const char *, va_list)
-    __attribute__((__noreturn__));
+static void exverror(int, const char *, va_list)
+        __attribute__ ((__noreturn__));
 
 /*
  * Called to raise an exception.  Since C doesn't include exceptions, we
@@ -1849,10 +1876,9 @@ static void exverror (int, const char *, va_list)
  * stored in the global variable "exception".
  */
 
-static void exraise (int) __attribute__((__noreturn__));
+static void exraise(int) __attribute__ ((__noreturn__));
 
-static void
-exraise(int e)
+static void exraise(int e)
 {
 #ifdef DEBUG
         if (handler == NULL)
@@ -1874,8 +1900,8 @@ exraise(int e)
  * just defensive programming.)
  */
 
-static void
-onint(void) {
+static void onint(void)
+{
         sigset_t mysigset;
 
         if (suppressint) {
@@ -1895,15 +1921,14 @@ onint(void) {
 }
 
 
-static char *commandname;       /* currently executing command */
+static char *commandname;       /* currently executing command */
 
 /*
  * Exverror is called to raise the error exception.  If the first argument
  * is not NULL then error prints an error message using printf style
  * formatting.  It then raises the error exception.
  */
-static void
-exverror(int cond, const char *msg, va_list ap)
+static void exverror(int cond, const char *msg, va_list ap)
 {
         CLEAR_PENDING_INT;
         INTOFF;
@@ -1925,10 +1950,10 @@ exverror(int cond, const char *msg, va_list ap)
 }
 
 
-static void
-error(const char *msg, ...)
+static void error(const char *msg, ...)
 {
         va_list ap;
+
         va_start(ap, msg);
         exverror(EXERROR, msg, ap);
         /* NOTREACHED */
@@ -1936,10 +1961,10 @@ error(const char *msg, ...)
 }
 
 
-static void
-exerror(int cond, const char *msg, ...)
+static void exerror(int cond, const char *msg, ...)
 {
         va_list ap;
+
         va_start(ap, msg);
         exverror(cond, msg, ap);
         /* NOTREACHED */
@@ -1953,71 +1978,71 @@ exerror(int cond, const char *msg, ...)
  */
 
 struct errname {
-        short errcode;          /* error number */
-        short  action;           /* operation which encountered the error */
+        short errcode;          /* error number */
+        short action;           /* operation which encountered the error */
 };
 
 /*
  * Types of operations (passed to the errmsg routine).
  */
 
-#define E_OPEN 01       /* opening a file */
-#define E_CREAT 02      /* creating a file */
-#define E_EXEC 04       /* executing a program */
+#define E_OPEN 01               /* opening a file */
+#define E_CREAT 02              /* creating a file */
+#define E_EXEC 04               /* executing a program */
 
 #define ALL (E_OPEN|E_CREAT|E_EXEC)
 
 static const struct errname errormsg[] = {
-        { EINTR,        ALL     },
-        { EACCES,       ALL     },
-        { EIO,          ALL     },
-        { ENOENT,       E_OPEN  },
-        { ENOENT,       E_CREAT },
-        { ENOENT,       E_EXEC  },
-        { ENOTDIR,      E_OPEN  },
-        { ENOTDIR,      E_CREAT },
-        { ENOTDIR,      E_EXEC  },
-        { EISDIR,       ALL     },
-        { EEXIST,       E_CREAT },
+        {EINTR, ALL},
+        {EACCES, ALL},
+        {EIO, ALL},
+        {ENOENT, E_OPEN},
+        {ENOENT, E_CREAT},
+        {ENOENT, E_EXEC},
+        {ENOTDIR, E_OPEN},
+        {ENOTDIR, E_CREAT},
+        {ENOTDIR, E_EXEC},
+        {EISDIR, ALL},
+        {EEXIST, E_CREAT},
 #ifdef EMFILE
-        { EMFILE,       ALL     },
+        {EMFILE, ALL},
 #endif
-        { ENFILE,       ALL     },
-        { ENOSPC,       ALL     },
+        {ENFILE, ALL},
+        {ENOSPC, ALL},
 #ifdef EDQUOT
-        { EDQUOT,       ALL     },
+        {EDQUOT, ALL},
 #endif
 #ifdef ENOSR
-        { ENOSR,        ALL     },
+        {ENOSR, ALL},
 #endif
-        { ENXIO,        ALL     },
-        { EROFS,        ALL     },
-        { ETXTBSY,      ALL     },
+        {ENXIO, ALL},
+        {EROFS, ALL},
+        {ETXTBSY, ALL},
 #ifdef EAGAIN
-        { EAGAIN,       E_EXEC  },
+        {EAGAIN, E_EXEC},
 #endif
-        { ENOMEM,       ALL     },
+        {ENOMEM, ALL},
 #ifdef ENOLINK
-        { ENOLINK,      ALL     },
+        {ENOLINK, ALL},
 #endif
 #ifdef EMULTIHOP
-        { EMULTIHOP,    ALL     },
+        {EMULTIHOP, ALL},
 #endif
 #ifdef ECOMM
-        { ECOMM,        ALL     },
+        {ECOMM, ALL},
 #endif
 #ifdef ESTALE
-        { ESTALE,       ALL     },
+        {ESTALE, ALL},
 #endif
 #ifdef ETIMEDOUT
-        { ETIMEDOUT,    ALL     },
+        {ETIMEDOUT, ALL},
 #endif
 #ifdef ELOOP
-        { ELOOP,        ALL     },
+        {ELOOP, ALL},
 #endif
-        { E2BIG,        E_EXEC  },
+        {E2BIG, E_EXEC},
 #ifdef ELIBACC
-        { ELIBACC,      E_EXEC  },
+        {ELIBACC, E_EXEC},
 #endif
 };
 
@@ -2029,13 +2054,12 @@ static const struct errname errormsg[] = {
  * Action describes the operation that got the error.
  */
 
-static const char *
-errmsg(int e, int action)
+static const char *errmsg(int e, int action)
 {
         struct errname const *ep;
         static char buf[12];
 
-        for (ep = errormsg ; ep < errormsg+ERRNAME_SIZE; ep++) {
+        for (ep = errormsg; ep < errormsg + ERRNAME_SIZE; ep++) {
                 if (ep->errcode == e && (ep->action & action) != 0)
                         return strerror(e);
         }
@@ -2046,13 +2070,14 @@ errmsg(int e, int action)
 
 
 #ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
-static void
-__inton() {
+static void __inton()
+{
         if (--suppressint == 0 && intpending) {
                 onint();
         }
 }
-static void forceinton (void) {
+static void forceinton(void)
+{
         suppressint = 0;
         if (intpending)
                 onint();
@@ -2060,25 +2085,26 @@ static void forceinton (void) {
 #endif
 
 /* flags in argument to evaltree */
-#define EV_EXIT 01              /* exit after evaluating tree */
-#define EV_TESTED 02            /* exit status is checked; ignore -e flag */
-#define EV_BACKCMD 04           /* command executing within back quotes */
+#define EV_EXIT 01              /* exit after evaluating tree */
+#define EV_TESTED 02    /* exit status is checked; ignore -e flag */
+#define EV_BACKCMD 04   /* command executing within back quotes */
 
-static int evalskip;                    /* set if we are skipping commands */
-static int skipcount;           /* number of levels to skip */
-static int loopnest;            /* current loop nesting level */
-static int funcnest;                    /* depth of function calls */
+static int evalskip;    /* set if we are skipping commands */
+static int skipcount;   /* number of levels to skip */
+static int loopnest;    /* current loop nesting level */
+static int funcnest;    /* depth of function calls */
 
 
-static struct strlist *cmdenviron;      /* environment for builtin command */
-static int exitstatus;                  /* exit status of last command */
-static int oexitstatus;         /* saved exit status */
+static struct strlist *cmdenviron;      /* environment for builtin command */
+static int exitstatus;  /* exit status of last command */
+static int oexitstatus; /* saved exit status */
 
-static void evalsubshell (const union node *, int);
-static void expredir (union node *);
-static void eprintlist (struct strlist *);
+static void evalsubshell(const union node *, int);
+static void expredir(union node *);
+static void eprintlist(struct strlist *);
 
 static union node *parsecmd(int);
+
 /*
  * Called to reset things after an exception.
  */
@@ -2086,10 +2112,9 @@ static union node *parsecmd(int);
 /*
  * The eval commmand.
  */
-static void evalstring (char *, int);
+static void evalstring(char *, int);
 
-static int
-evalcmd(int argc, char **argv)
+static int evalcmd(int argc, char **argv)
 {
         char *p;
         char *concat;
@@ -2119,15 +2144,14 @@ evalcmd(int argc, char **argv)
  * Execute a command or commands contained in a string.
  */
 
-static void evaltree (union node *, int);
-static void setinputstring (char *);
-static void popfile (void);
+static void evaltree(union node *, int);
+static void setinputstring(char *);
+static void popfile(void);
 static void setstackmark(struct stackmark *mark);
 static void popstackmark(struct stackmark *mark);
 
 
-static void
-evalstring(char *s, int flag)
+static void evalstring(char *s, int flag)
 {
         union node *n;
         struct stackmark smark;
@@ -2142,23 +2166,22 @@ evalstring(char *s, int flag)
         popstackmark(&smark);
 }
 
-static struct builtincmd *find_builtin (const char *);
-static void expandarg (union node *, struct arglist *, int);
-static void calcsize (const union node *);
-static union node *copynode (const union node *);
+static struct builtincmd *find_builtin(const char *);
+static void expandarg(union node *, struct arglist *, int);
+static void calcsize(const union node *);
+static union node *copynode(const union node *);
 
 /*
  * Make a copy of a parse tree.
  */
 
-static int     funcblocksize;           /* size of structures in function */
-static int     funcstringsize;          /* size of strings in node */
-static pointer funcblock;              /* block to allocate function from */
-static char   *funcstring;              /* block to allocate strings from */
+static int funcblocksize;       /* size of structures in function */
+static int funcstringsize;      /* size of strings in node */
+static pointer funcblock;       /* block to allocate function from */
+static char *funcstring;        /* block to allocate strings from */
 
 
-static inline union node *
-copyfunc(union node *n)
+static inline union node *copyfunc(union node *n)
 {
         if (n == NULL)
                 return NULL;
@@ -2175,8 +2198,7 @@ copyfunc(union node *n)
  * the same name.
  */
 
-static inline void
-addcmdentry(char *name, struct cmdentry *entry)
+static inline void addcmdentry(char *name, struct cmdentry *entry)
 {
         struct tblentry *cmdp;
 
@@ -2190,8 +2212,7 @@ addcmdentry(char *name, struct cmdentry *entry)
         INTON;
 }
 
-static inline void
-evalloop(const union node *n, int flags)
+static inline void evalloop(const union node *n, int flags)
 {
         int status;
 
@@ -2200,7 +2221,7 @@ evalloop(const union node *n, int flags)
         for (;;) {
                 evaltree(n->nbinary.ch1, EV_TESTED);
                 if (evalskip) {
-skipping:         if (evalskip == SKIPCONT && --skipcount <= 0) {
+                  skipping:if (evalskip == SKIPCONT && --skipcount <= 0) {
                                 evalskip = 0;
                                 continue;
                         }
@@ -2224,8 +2245,7 @@ skipping:         if (evalskip == SKIPCONT && --skipcount <= 0) {
         exitstatus = status;
 }
 
-static void
-evalfor(const union node *n, int flags)
+static void evalfor(const union node *n, int flags)
 {
         struct arglist arglist;
         union node *argp;
@@ -2234,7 +2254,7 @@ evalfor(const union node *n, int flags)
 
         setstackmark(&smark);
         arglist.lastp = &arglist.list;
-        for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
+        for (argp = n->nfor.args; argp; argp = argp->narg.next) {
                 oexitstatus = exitstatus;
                 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
                 if (evalskip)
@@ -2244,7 +2264,7 @@ evalfor(const union node *n, int flags)
 
         exitstatus = 0;
         loopnest++;
-        for (sp = arglist.list ; sp ; sp = sp->next) {
+        for (sp = arglist.list; sp; sp = sp->next) {
                 setvar(n->nfor.var, sp->text, 0);
                 evaltree(n->nfor.body, flags & EV_TESTED);
                 if (evalskip) {
@@ -2258,12 +2278,11 @@ evalfor(const union node *n, int flags)
                 }
         }
         loopnest--;
-out:
+  out:
         popstackmark(&smark);
 }
 
-static inline void
-evalcase(const union node *n, int flags)
+static inline void evalcase(const union node *n, int flags)
 {
         union node *cp;
         union node *patp;
@@ -2274,8 +2293,8 @@ evalcase(const union node *n, int flags)
         arglist.lastp = &arglist.list;
         oexitstatus = exitstatus;
         expandarg(n->ncase.expr, &arglist, EXP_TILDE);
-        for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
-                for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
+        for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
+                for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
                         if (casematch(patp, arglist.list->text)) {
                                 if (evalskip == 0) {
                                         evaltree(cp->nclist.body, flags);
@@ -2284,7 +2303,7 @@ evalcase(const union node *n, int flags)
                         }
                 }
         }
-out:
+  out:
         popstackmark(&smark);
 }
 
@@ -2303,14 +2322,14 @@ static inline void evalpipe(union node *n)
         int prevfd;
         int pip[2];
 
-        TRACE(("evalpipe(0x%lx) called\n", (long)n));
+        TRACE(("evalpipe(0x%lx) called\n", (long) n));
         pipelen = 0;
-        for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
+        for (lp = n->npipe.cmdlist; lp; lp = lp->next)
                 pipelen++;
         INTOFF;
         jp = makejob(n, pipelen);
         prevfd = -1;
-        for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
+        for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
                 /*
                  * Search for a command.  This is called before we fork so that the
                  * location of the command will be available in the parent as well as
@@ -2320,7 +2339,9 @@ static inline void evalpipe(union node *n)
 
                 struct cmdentry entry;
                 union node *lpn = lp->n;
-                if (lpn->type == NCMD && lpn->ncmd.args && goodname(lpn->ncmd.args->narg.text))
+
+                if (lpn->type == NCMD && lpn->ncmd.args
+                        && goodname(lpn->ncmd.args->narg.text))
                         find_command(lpn->ncmd.args->narg.text, &entry, 0, pathval());
 
                 pip[1] = -1;
@@ -2366,8 +2387,8 @@ static inline void evalpipe(union node *n)
         }
 }
 
-static int
-isassignment(const char *word) {
+static int isassignment(const char *word)
+{
         if (!is_name(*word)) {
                 return 0;
         }
@@ -2378,8 +2399,7 @@ isassignment(const char *word) {
 }
 
 
-static void
-evalcommand(union node *cmd, int flags)
+static void evalcommand(union node *cmd, int flags)
 {
         struct stackmark smark;
         union node *argp;
@@ -2401,6 +2421,7 @@ evalcommand(union node *cmd, int flags)
         const struct builtincmd *firstbltin;
         struct jmploc *volatile savehandler;
         struct jmploc jmploc;
+
 #if __GNUC__
         /* Avoid longjmp clobbering */
         (void) &argv;
@@ -2410,7 +2431,7 @@ evalcommand(union node *cmd, int flags)
 #endif
 
         /* First expand the arguments. */
-        TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
+        TRACE(("evalcommand(0x%lx, %d) called\n", (long) cmd, flags));
         setstackmark(&smark);
         arglist.lastp = &arglist.list;
         varlist.lastp = &varlist.list;
@@ -2421,15 +2442,13 @@ evalcommand(union node *cmd, int flags)
         for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
                 expandarg(argp, &varlist, EXP_VARTILDE);
         }
-        for (
-                argp = cmd->ncmd.args; argp && !arglist.list;
-                argp = argp->narg.next
-        ) {
+        for (argp = cmd->ncmd.args; argp && !arglist.list; argp = argp->narg.next) {
                 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
         }
         if (argp) {
                 struct builtincmd *bcmd;
                 int pseudovarflag;
+
                 bcmd = find_builtin(arglist.list->text);
                 pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
                 for (; argp; argp = argp->narg.next) {
@@ -2444,11 +2463,11 @@ evalcommand(union node *cmd, int flags)
         *varlist.lastp = NULL;
         expredir(cmd->ncmd.redirect);
         argc = 0;
-        for (sp = arglist.list ; sp ; sp = sp->next)
+        for (sp = arglist.list; sp; sp = sp->next)
                 argc++;
-        argv = stalloc(sizeof (char *) * (argc + 1));
+        argv = stalloc(sizeof(char *) * (argc + 1));
 
-        for (sp = arglist.list ; sp ; sp = sp->next) {
+        for (sp = arglist.list; sp; sp = sp->next) {
                 TRACE(("evalcommand arg: %s\n", sp->text));
                 *argv++ = sp->text;
         }
@@ -2479,7 +2498,7 @@ evalcommand(union node *cmd, int flags)
                  * Modify the command lookup path, if a PATH= assignment
                  * is present
                  */
-                for (sp = varlist.list ; sp ; sp = sp->next)
+                for (sp = varlist.list; sp; sp = sp->next)
                         if (varequal(sp->text, defpathvar)) {
                                 path = sp->text + 5;
                                 findflag |= DO_BRUTE;
@@ -2487,9 +2506,9 @@ evalcommand(union node *cmd, int flags)
                 oldpath = path;
                 oldfindflag = findflag;
                 firstbltin = 0;
-                for(;;) {
+                for (;;) {
                         find_command(argv[0], &cmdentry, findflag, path);
-                        if (cmdentry.cmdtype == CMDUNKNOWN) {   /* command not found */
+                        if (cmdentry.cmdtype == CMDUNKNOWN) {   /* command not found */
                                 exitstatus = 127;
                                 goto out;
                         }
@@ -2501,7 +2520,7 @@ evalcommand(union node *cmd, int flags)
                                 firstbltin = cmdentry.u.cmd;
                         }
                         if (cmdentry.u.cmd == BLTINCMD) {
-                                for(;;) {
+                                for (;;) {
                                         struct builtincmd *bcmd;
 
                                         argv++;
@@ -2541,19 +2560,19 @@ evalcommand(union node *cmd, int flags)
                                 findflag |= DO_NOFUN;
                                 continue;
                         }
-found:
+                  found:
                         break;
                 }
         }
 
         /* Fork off a child process if necessary. */
         if (cmd->ncmd.backgnd
-         || (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)
-        ) {
+                || (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)
+                ) {
                 jp = makejob(cmd, 1);
                 mode = cmd->ncmd.backgnd;
                 if (forkshell(jp, cmd, mode) != 0)
-                        goto parent;    /* at end of routine */
+                        goto parent;    /* at end of routine */
                 flags |= EV_EXIT;
         }
 
@@ -2561,7 +2580,8 @@ found:
         /* Execute the command. */
         if (cmdentry.cmdtype == CMDFUNCTION) {
 #ifdef DEBUG
-                trputs("Shell function:  ");  trargs(argv);
+                trputs("Shell function:  ");
+                trargs(argv);
 #endif
                 exitstatus = oexitstatus;
                 redirect(cmd->ncmd.redirect, REDIR_PUSH);
@@ -2576,7 +2596,7 @@ found:
                 if (setjmp(jmploc.loc)) {
                         if (exception == EXSHELLPROC) {
                                 freeparam((volatile struct shparam *)
-                                    &saveparam);
+                                                  &saveparam);
                         } else {
                                 saveparam.optind = shellparam.optind;
                                 saveparam.optoff = shellparam.optoff;
@@ -2590,7 +2610,7 @@ found:
                 }
                 savehandler = handler;
                 handler = &jmploc;
-                for (sp = varlist.list ; sp ; sp = sp->next)
+                for (sp = varlist.list; sp; sp = sp->next)
                         mklocal(sp->text);
                 funcnest++;
                 evaltree(cmdentry.u.func, flags & EV_TESTED);
@@ -2613,9 +2633,10 @@ found:
                         exitshell(exitstatus);
         } else if (cmdentry.cmdtype == CMDBUILTIN) {
 #ifdef DEBUG
-                trputs("builtin command:  ");  trargs(argv);
+                trputs("builtin command:  ");
+                trargs(argv);
 #endif
-                mode = (cmdentry.u.cmd == EXECCMD)? 0 : REDIR_PUSH;
+                mode = (cmdentry.u.cmd == EXECCMD) ? 0 : REDIR_PUSH;
                 redirect(cmd->ncmd.redirect, mode);
                 savecmdname = commandname;
                 if (IS_BUILTIN_SPECIAL(firstbltin)) {
@@ -2626,17 +2647,17 @@ found:
                 e = -1;
                 if (setjmp(jmploc.loc)) {
                         e = exception;
-                        exitstatus = (e == EXINT)? SIGINT+128 : 2;
+                        exitstatus = (e == EXINT) ? SIGINT + 128 : 2;
                         goto cmddone;
                 }
                 savehandler = handler;
                 handler = &jmploc;
                 commandname = argv[0];
                 argptr = argv + 1;
-                optptr = NULL;                  /* initialize nextopt */
-                exitstatus = (*cmdentry.u.cmd->builtinfunc)(argc, argv);
+                optptr = NULL;  /* initialize nextopt */
+                exitstatus = (*cmdentry.u.cmd->builtinfunc) (argc, argv);
                 flushall();
-cmddone:
+          cmddone:
                 cmdenviron = NULL;
                 if (e != EXSHELLPROC) {
                         commandname = savecmdname;
@@ -2646,10 +2667,9 @@ cmddone:
                 handler = savehandler;
                 if (e != -1) {
                         if ((e != EXERROR && e != EXEXEC)
-                           || cmdentry.u.cmd == BLTINCMD
-                           || cmdentry.u.cmd == DOTCMD
-                           || cmdentry.u.cmd == EVALCMD
-                           || cmdentry.u.cmd == EXECCMD)
+                                || cmdentry.u.cmd == BLTINCMD
+                                || cmdentry.u.cmd == DOTCMD
+                                || cmdentry.u.cmd == EVALCMD || cmdentry.u.cmd == EXECCMD)
                                 exraise(e);
                         FORCEINTON;
                 }
@@ -2657,25 +2677,26 @@ cmddone:
                         popredir();
         } else {
 #ifdef DEBUG
-                trputs("normal command:  ");  trargs(argv);
+                trputs("normal command:  ");
+                trargs(argv);
 #endif
                 redirect(cmd->ncmd.redirect, 0);
                 clearredir();
-                for (sp = varlist.list ; sp ; sp = sp->next)
-                        setvareq(sp->text, VEXPORT|VSTACK);
+                for (sp = varlist.list; sp; sp = sp->next)
+                        setvareq(sp->text, VEXPORT | VSTACK);
                 envp = environment();
                 shellexec(argv, envp, path, cmdentry.u.index);
         }
         goto out;
 
-parent: /* parent process gets here (if we forked) */
-        if (mode == 0) {        /* argument to fork */
+  parent:                               /* parent process gets here (if we forked) */
+        if (mode == 0) {        /* argument to fork */
                 INTOFF;
                 exitstatus = waitforjob(jp);
                 INTON;
         }
 
-out:
+  out:
         if (lastarg)
                 setvar("_", lastarg, 0);
         popstackmark(&smark);
@@ -2685,15 +2706,15 @@ out:
  * Evaluate a parse tree.  The value is left in the global variable
  * exitstatus.
  */
-static void
-evaltree(union node *n, int flags)
+static void evaltree(union node *n, int flags)
 {
         int checkexit = 0;
+
         if (n == NULL) {
                 TRACE(("evaltree(NULL) called\n"));
                 goto out;
         }
-        TRACE(("evaltree(0x%lx: %d) called\n", (long)n, n->type));
+        TRACE(("evaltree(0x%lx: %d) called\n", (long) n, n->type));
         switch (n->type) {
         case NSEMI:
                 evaltree(n->nbinary.ch1, flags & EV_TESTED);
@@ -2725,7 +2746,7 @@ evaltree(union node *n, int flags)
         case NBACKGND:
                 evalsubshell(n, flags);
                 break;
-        case NIF: {
+        case NIF:{
                 evaltree(n->nif.test, EV_TESTED);
                 if (evalskip)
                         goto out;
@@ -2747,13 +2768,12 @@ evaltree(union node *n, int flags)
         case NCASE:
                 evalcase(n, flags);
                 break;
-        case NDEFUN: {
+        case NDEFUN:{
                 struct builtincmd *bcmd;
                 struct cmdentry entry;
-                if (
-                        (bcmd = find_builtin(n->narg.text)) &&
-                        IS_BUILTIN_SPECIAL(bcmd)
-                ) {
+
+                if ((bcmd = find_builtin(n->narg.text)) && IS_BUILTIN_SPECIAL(bcmd)
+                        ) {
                         out2fmt("%s is a special built-in\n", n->narg.text);
                         exitstatus = 1;
                         break;
@@ -2783,13 +2803,12 @@ evaltree(union node *n, int flags)
                 break;
 #endif
         }
-out:
+  out:
         if (pendingsigs)
                 dotrap();
-        if (
-                flags & EV_EXIT ||
+        if (flags & EV_EXIT ||
                 (checkexit && eflag && exitstatus && !(flags & EV_TESTED))
-        )
+                )
                 exitshell(exitstatus);
 }
 
@@ -2797,8 +2816,7 @@ out:
  * Kick off a subshell to evaluate a tree.
  */
 
-static void
-evalsubshell(const union node *n, int flags)
+static void evalsubshell(const union node *n, int flags)
 {
         struct job *jp;
         int backgnd = (n->type == NBACKGND);
@@ -2807,11 +2825,11 @@ evalsubshell(const union node *n, int flags)
         jp = makejob(n, 1);
         if (forkshell(jp, n, backgnd) == 0) {
                 if (backgnd)
-                        flags &=~ EV_TESTED;
+                        flags &= ~EV_TESTED;
                 redirect(n->nredir.redirect, 0);
-                evaltree(n->nredir.n, flags | EV_EXIT); /* never returns */
+                evaltree(n->nredir.n, flags | EV_EXIT); /* never returns */
         }
-        if (! backgnd) {
+        if (!backgnd) {
                 INTOFF;
                 exitstatus = waitforjob(jp);
                 INTON;
@@ -2824,13 +2842,13 @@ evalsubshell(const union node *n, int flags)
 
 static void fixredir(union node *n, const char *text, int err);
 
-static void
-expredir(union node *n)
+static void expredir(union node *n)
 {
         union node *redir;
 
-        for (redir = n ; redir ; redir = redir->nfile.next) {
+        for (redir = n; redir; redir = redir->nfile.next) {
                 struct arglist fn;
+
                 fn.lastp = &fn.list;
                 oexitstatus = exitstatus;
                 switch (redir->type) {
@@ -2861,12 +2879,11 @@ expredir(union node *n)
  * Should be called with interrupts off.
  */
 
-static void
-evalbackcmd(union node *n, struct backcmd *result)
+static void evalbackcmd(union node *n, struct backcmd *result)
 {
         int pip[2];
         struct job *jp;
-        struct stackmark smark;         /* unnecessary */
+        struct stackmark smark; /* unnecessary */
 
         setstackmark(&smark);
         result->fd = -1;
@@ -2895,10 +2912,10 @@ evalbackcmd(union node *n, struct backcmd *result)
         close(pip[1]);
         result->fd = pip[0];
         result->jp = jp;
-out:
+  out:
         popstackmark(&smark);
         TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
-                result->fd, result->buf, result->nleft, result->jp));
+                   result->fd, result->buf, result->nleft, result->jp));
 }
 
 
@@ -2917,8 +2934,7 @@ out:
  * specified variables.
  */
 
-int
-bltincmd(int argc, char **argv)
+int bltincmd(int argc, char **argv)
 {
         /*
          * Preserve exitstatus of a previous possible redirection
@@ -2939,8 +2955,7 @@ bltincmd(int argc, char **argv)
  * in the standard shell so we don't make it one here.
  */
 
-static int
-breakcmd(int argc, char **argv)
+static int breakcmd(int argc, char **argv)
 {
         int n = argc > 1 ? number(argv[1]) : 1;
 
@@ -2949,7 +2964,7 @@ breakcmd(int argc, char **argv)
         if (n > loopnest)
                 n = loopnest;
         if (n > 0) {
-                evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
+                evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
                 skipcount = n;
         }
         return 0;
@@ -2960,8 +2975,7 @@ breakcmd(int argc, char **argv)
  * The return command.
  */
 
-static int
-returncmd(int argc, char **argv)
+static int returncmd(int argc, char **argv)
 {
         int ret = argc > 1 ? number(argv[1]) : oexitstatus;
 
@@ -2969,8 +2983,7 @@ returncmd(int argc, char **argv)
                 evalskip = SKIPFUNC;
                 skipcount = 1;
                 return ret;
-        }
-        else {
+        } else {
                 /* Do what ksh does; skip the rest of the file */
                 evalskip = SKIPFILE;
                 skipcount = 1;
@@ -2980,16 +2993,14 @@ returncmd(int argc, char **argv)
 
 
 #ifndef CONFIG_FALSE
-static int
-false_main(int argc, char **argv)
+static int false_main(int argc, char **argv)
 {
         return 1;
 }
 #endif
 
 #ifndef CONFIG_TRUE
-static int
-true_main(int argc, char **argv)
+static int true_main(int argc, char **argv)
 {
         return 0;
 }
@@ -3005,11 +3016,10 @@ static void setsignal(int signo);
 static void chkmail(int silent);
 #endif
 
-static void
-setinteractive(int on)
+static void setinteractive(int on)
 {
         static int is_interactive;
-        static int do_banner=0;
+        static int do_banner = 0;
 
         if (on == is_interactive)
                 return;
@@ -3020,45 +3030,42 @@ setinteractive(int on)
         chkmail(1);
 #endif
         is_interactive = on;
-        if (do_banner==0 && is_interactive) {
+        if (do_banner == 0 && is_interactive) {
                 /* Looks like they want an interactive shell */
-#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET 
-                printf( "\n\n" BB_BANNER " Built-in shell (ash)\n");
-                printf( "Enter 'help' for a list of built-in commands.\n\n");
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+                printf("\n\n" BB_BANNER " Built-in shell (ash)\n");
+                printf("Enter 'help' for a list of built-in commands.\n\n");
 #endif
-                do_banner=1;
+                do_banner = 1;
         }
 }
 
-static void
-optschanged(void)
+static void optschanged(void)
 {
         setinteractive(iflag);
         setjobctl(mflag);
 }
 
 
-static int
-execcmd(int argc, char **argv)
+static int execcmd(int argc, char **argv)
 {
         if (argc > 1) {
                 struct strlist *sp;
 
-                iflag = 0;              /* exit on error */
+                iflag = 0;              /* exit on error */
                 mflag = 0;
                 optschanged();
-                for (sp = cmdenviron; sp ; sp = sp->next)
-                        setvareq(sp->text, VEXPORT|VSTACK);
+                for (sp = cmdenviron; sp; sp = sp->next)
+                        setvareq(sp->text, VEXPORT | VSTACK);
                 shellexec(argv + 1, environment(), pathval(), 0);
         }
         return 0;
 }
 
-static void
-eprintlist(struct strlist *sp)
+static void eprintlist(struct strlist *sp)
 {
         for (; sp; sp = sp->next) {
-                out2fmt(" %s",sp->text);
+                out2fmt(" %s", sp->text);
         }
 }
 
@@ -3067,10 +3074,9 @@ eprintlist(struct strlist *sp)
  * have to change the find_command routine as well.
  */
 
-static const char *pathopt;     /* set by padvance */
+static const char *pathopt;     /* set by padvance */
 
-static void
-shellexec(char **argv, char **envp, const char *path, int idx)
+static void shellexec(char **argv, char **envp, const char *path, int idx)
 {
         char *cmdname;
         int e;
@@ -3109,13 +3115,12 @@ shellexec(char **argv, char **envp, const char *path, int idx)
 /*
  * Clear traps on a fork.
  */
-static void
-clear_traps(void)
+static void clear_traps(void)
 {
         char **tp;
 
-        for (tp = trap ; tp < &trap[NSIG] ; tp++) {
-                if (*tp && **tp) {      /* trap not NULL or SIG_IGN */
+        for (tp = trap; tp < &trap[NSIG]; tp++) {
+                if (*tp && **tp) {      /* trap not NULL or SIG_IGN */
                         INTOFF;
                         free(*tp);
                         *tp = NULL;
@@ -3127,68 +3132,67 @@ clear_traps(void)
 }
 
 
-static void
-initshellproc(void)
+static void initshellproc(void)
 {
 
 #ifdef CONFIG_ASH_ALIAS
-      /* from alias.c: */
-      {
-              rmaliases();
-      }
-#endif
-      /* from eval.c: */
-      {
-              exitstatus = 0;
-      }
-
-      /* from exec.c: */
-      {
-              deletefuncs();
-      }
-
-      /* from jobs.c: */
-      {
-              backgndpid = -1;
+        /* from alias.c: */
+        {
+                rmaliases();
+        }
+#endif
+        /* from eval.c: */
+        {
+                exitstatus = 0;
+        }
+
+        /* from exec.c: */
+        {
+                deletefuncs();
+        }
+
+        /* from jobs.c: */
+        {
+                backgndpid = -1;
 #ifdef CONFIG_ASH_JOB_CONTROL
-              jobctl = 0;
+                jobctl = 0;
 #endif
-      }
+        }
 
-      /* from options.c: */
-      {
-              int i;
+        /* from options.c: */
+        {
+                int i;
 
-              for (i = 0; i < NOPTS; i++)
-                      optent_val(i) = 0;
-              optschanged();
+                for (i = 0; i < NOPTS; i++)
+                        optent_val(i) = 0;
+                optschanged();
 
-      }
+        }
 
-      /* from redir.c: */
-      {
-              clearredir();
-      }
+        /* from redir.c: */
+        {
+                clearredir();
+        }
 
-      /* from trap.c: */
-      {
-              char *sm;
+        /* from trap.c: */
+        {
+                char *sm;
 
-              clear_traps();
-              for (sm = sigmode ; sm < sigmode + NSIG - 1; sm++) {
-                      if (*sm == S_IGN)
-                              *sm = S_HARD_IGN;
-              }
-      }
+                clear_traps();
+                for (sm = sigmode; sm < sigmode + NSIG - 1; sm++) {
+                        if (*sm == S_IGN)
+                                *sm = S_HARD_IGN;
+                }
+        }
 
-      /* from var.c: */
-      {
-              shprocvar();
-      }
+        /* from var.c: */
+        {
+                shprocvar();
+        }
 }
 
 static int preadbuffer(void);
-static void pushfile (void);
+static void pushfile(void);
 
 /*
  * Read a character from the script, returning PEOF on end of file.
@@ -3197,20 +3201,17 @@ static void pushfile (void);
 
 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
 #define pgetc_macro()   (--parsenleft >= 0? *parsenextc++ : preadbuffer())
-static int
-pgetc(void)
+static int pgetc(void)
 {
         return pgetc_macro();
 }
 #else
-static int
-pgetc_macro(void)
+static int pgetc_macro(void)
 {
-        return --parsenleft >= 0? *parsenextc++ : preadbuffer();
+        return --parsenleft >= 0 ? *parsenextc++ : preadbuffer();
 }
 
-static inline int
-pgetc(void)
+static inline int pgetc(void)
 {
         return pgetc_macro();
 }
@@ -3222,15 +3223,14 @@ pgetc(void)
  * PEOF may be pushed back.
  */
 
-static void pungetc(void) 
+static void pungetc(void)
 {
         parsenleft++;
         parsenextc--;
 }
 
 
-static void
-popfile(void)
+static void popfile(void)
 {
         struct parsefile *pf = parsefile;
 
@@ -3254,8 +3254,7 @@ popfile(void)
  * Return to top level.
  */
 
-static void
-popallfiles(void)
+static void popallfiles(void)
 {
         while (parsefile != &basepf)
                 popfile();
@@ -3266,7 +3265,7 @@ popallfiles(void)
  * after a fork is done.
  */
 
-static void closescript(void) 
+static void closescript(void)
 {
         popallfiles();
         if (parsefile->fd > 0) {
@@ -3305,8 +3304,7 @@ static void setinputfd(int fd, int push)
  * old input onto the stack first.
  */
 
-static void
-setinputfile(const char *fname, int push)
+static void setinputfile(const char *fname, int push)
 {
         int fd;
         int myfileno2;
@@ -3326,24 +3324,24 @@ setinputfile(const char *fname, int push)
 }
 
 
-static void
-tryexec(char *cmd, char **argv, char **envp)
+static void tryexec(char *cmd, char **argv, char **envp)
 {
         int e;
 
 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
         char *name = cmd;
-        char** argv_l=argv;
+        char **argv_l = argv;
         int argc_l;
+
 #ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
         name = get_last_path_component(name);
 #endif
-        argv_l=envp;
-        for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++)
+        argv_l = envp;
+        for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
                 putenv(*argv_l);
-        argv_l=argv;
-        for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++)
-        optind = 1;
+        argv_l = argv;
+        for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
+                optind = 1;
         run_applet_by_name(name, argc_l, argv);
 #endif
         execve(cmd, argv, envp);
@@ -3359,7 +3357,7 @@ tryexec(char *cmd, char **argv, char **envp)
         errno = e;
 }
 
-static char *commandtext (const union node *);
+static char *commandtext(const union node *);
 
 /*
  * Do a path search.  The variable path (passed by reference) should be
@@ -3376,8 +3374,7 @@ static const char *pathopt;
 static void growstackblock(void);
 
 
-static char *
-padvance(const char **path, const char *name)
+static char *padvance(const char **path, const char *name)
 {
         const char *p;
         char *q;
@@ -3387,8 +3384,8 @@ padvance(const char **path, const char *name)
         if (*path == NULL)
                 return NULL;
         start = *path;
-        for (p = start ; *p && *p != ':' && *p != '%' ; p++);
-        len = p - start + strlen(name) + 2;     /* "2" is for '/' and '\0' */
+        for (p = start; *p && *p != ':' && *p != '%'; p++);
+        len = p - start + strlen(name) + 2;     /* "2" is for '/' and '\0' */
         while (stackblocksize() < len)
                 growstackblock();
         q = stackblock();
@@ -3401,7 +3398,8 @@ padvance(const char **path, const char *name)
         pathopt = NULL;
         if (*p == '%') {
                 pathopt = ++p;
-                while (*p && *p != ':')  p++;
+                while (*p && *p != ':')
+                        p++;
         }
         if (*p == ':')
                 *path = p + 1;
@@ -3413,8 +3411,7 @@ padvance(const char **path, const char *name)
 /*
  * Wrapper around strcmp for qsort/bsearch/...
  */
-static int
-pstrcmp(const void *a, const void *b)
+static int pstrcmp(const void *a, const void *b)
 {
         return strcmp((const char *) a, (*(const char *const *) b) + 1);
 }
@@ -3423,20 +3420,18 @@ pstrcmp(const void *a, const void *b)
  * Find a keyword is in a sorted array.
  */
 
-static const char *const *
-findkwd(const char *s)
+static const char *const *findkwd(const char *s)
 {
-        return  bsearch(s, tokname_array + KWDOFFSET,
-                                        (sizeof(tokname_array)/sizeof(const char *)) - KWDOFFSET,
-                                        sizeof(const char *), pstrcmp);
+        return bsearch(s, tokname_array + KWDOFFSET,
+                                   (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
+                                   sizeof(const char *), pstrcmp);
 }
 
 
 /*** Command hashing code ***/
 
 
-static int
-hashcmd(int argc, char **argv)
+static int hashcmd(int argc, char **argv)
 {
         struct tblentry **pp;
         struct tblentry *cmdp;
@@ -3444,6 +3439,7 @@ hashcmd(int argc, char **argv)
         int verbose;
         struct cmdentry entry;
         char *name;
+
 #ifdef CONFIG_ASH_ALIAS
         const struct alias *ap;
 #endif
@@ -3458,8 +3454,8 @@ hashcmd(int argc, char **argv)
                 }
         }
         if (*argptr == NULL) {
-                for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
-                        for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
+                for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
+                        for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
                                 if (cmdp->cmdtype != CMDBUILTIN) {
                                         printentry(cmdp, verbose);
                                 }
@@ -3470,22 +3466,22 @@ hashcmd(int argc, char **argv)
         c = 0;
         while ((name = *argptr++) != NULL) {
                 if ((cmdp = cmdlookup(name, 0)) != NULL
-                 && (cmdp->cmdtype == CMDNORMAL
-                     || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
+                        && (cmdp->cmdtype == CMDNORMAL
+                                || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
                         delete_cmd_entry();
 #ifdef CONFIG_ASH_ALIAS
-        /* Then look at the aliases */
+                /* Then look at the aliases */
                 if ((ap = *__lookupalias(name)) != NULL) {
-                        if (verbose=='v')
+                        if (verbose == 'v')
                                 printf("%s is an alias for %s\n", name, ap->val);
                         else
                                 printalias(ap);
                         continue;
                 }
 #endif
-                        /* First look at the keywords */
-                if (findkwd(name)!=0) {
-                        if (verbose=='v')
+                /* First look at the keywords */
+                if (findkwd(name) != 0) {
+                        if (verbose == 'v')
                                 printf("%s is a shell keyword\n", name);
                         else
                                 puts(name);
@@ -3493,18 +3489,19 @@ hashcmd(int argc, char **argv)
                 }
 
                 find_command(name, &entry, DO_ERR, pathval());
-                if (entry.cmdtype == CMDUNKNOWN) c = 1;
+                if (entry.cmdtype == CMDUNKNOWN)
+                        c = 1;
                 else if (verbose) {
                         cmdp = cmdlookup(name, 0);
-                        if (cmdp) printentry(cmdp, verbose=='v');
+                        if (cmdp)
+                                printentry(cmdp, verbose == 'v');
                         flushall();
                 }
         }
         return c;
 }
 
-static void
-printentry(struct tblentry *cmdp, int verbose)
+static void printentry(struct tblentry *cmdp, int verbose)
 {
         int idx;
         const char *path;
@@ -3518,10 +3515,10 @@ printentry(struct tblentry *cmdp, int verbose)
                         name = padvance(&path, cmdp->cmdname);
                         stunalloc(name);
                 } while (--idx >= 0);
-                if(verbose)
+                if (verbose)
                         out1str(name);
         } else if (cmdp->cmdtype == CMDBUILTIN) {
-                if(verbose)
+                if (verbose)
                         out1str("a shell builtin");
         } else if (cmdp->cmdtype == CMDFUNCTION) {
                 if (verbose) {
@@ -3545,14 +3542,14 @@ printentry(struct tblentry *cmdp, int verbose)
 /*** List the available builtins ***/
 
 
-static int helpcmd(int argc, char** argv)
+static int helpcmd(int argc, char **argv)
 {
         int col, i;
 
         printf("\nBuilt-in commands:\n-------------------\n");
-        for (col=0, i=0; i < NUMBUILTINS; i++) {
+        for (col = 0, i = 0; i < NUMBUILTINS; i++) {
                 col += printf("%c%s", ((col == 0) ? '\t' : ' '),
-                                builtincmds[i].name+1);
+                                          builtincmds[i].name + 1);
                 if (col > 60) {
                         printf("\n");
                         col = 0;
@@ -3563,10 +3560,9 @@ static int helpcmd(int argc, char** argv)
                 extern const struct BB_applet applets[];
                 extern const size_t NUM_APPLETS;
 
-                for (i=0; i < NUM_APPLETS; i++) {
+                for (i = 0; i < NUM_APPLETS; i++) {
 
-                        col += printf("%c%s", ((col == 0) ? '\t' : ' '),
-                                        applets[i].name);
+                        col += printf("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
                         if (col > 60) {
                                 printf("\n");
                                 col = 0;
@@ -3583,10 +3579,11 @@ static int helpcmd(int argc, char** argv)
  * change the shellexec routine as well.
  */
 
-static int prefix (const char *, const char *);
+static int prefix(const char *, const char *);
 
 static void
-find_command(const char *name, struct cmdentry *entry, int act, const char *path)
+find_command(const char *name, struct cmdentry *entry, int act,
+                         const char *path)
 {
         struct tblentry *cmdp;
         int idx;
@@ -3637,10 +3634,10 @@ find_command(const char *name, struct cmdentry *entry, int act, const char *path
                         }
                 } else if (act & DO_BRUTE) {
                         if ((cmdp->cmdtype == CMDNORMAL &&
-                             cmdp->param.index >= firstchange) ||
-                            (cmdp->cmdtype == CMDBUILTIN &&
-                             ((builtinloc < 0 && bltin >= 0) ?
-                              bltin : builtinloc) >= firstchange)) {
+                                 cmdp->param.index >= firstchange) ||
+                                (cmdp->cmdtype == CMDBUILTIN &&
+                                 ((builtinloc < 0 && bltin >= 0) ?
+                                  bltin : builtinloc) >= firstchange)) {
                                 /* need to recompute the entry */
                         } else {
                                 goto success;
@@ -3665,7 +3662,7 @@ find_command(const char *name, struct cmdentry *entry, int act, const char *path
 
         /* If %builtin not in path, check for builtin next */
         if (regular || (bltin < 0 && bcmd)) {
-builtin:
+          builtin:
                 if (!updatetbl) {
                         entry->cmdtype = CMDBUILTIN;
                         entry->u.cmd = bcmd;
@@ -3680,8 +3677,8 @@ builtin:
         }
 
         /* We have to search path. */
-        prev = -1;              /* where to start */
-        if (cmdp && cmdp->rehash) {     /* doing a rehash */
+        prev = -1;                      /* where to start */
+        if (cmdp && cmdp->rehash) {     /* doing a rehash */
                 if (cmdp->cmdtype == CMDBUILTIN)
                         prev = builtinloc;
                 else
@@ -3690,7 +3687,7 @@ builtin:
 
         e = ENOENT;
         idx = -1;
-loop:
+  loop:
         while ((fullname = padvance(&path, name)) != NULL) {
                 stunalloc(fullname);
                 idx++;
@@ -3703,16 +3700,14 @@ loop:
                                         goto builtin;
                                 }
                                 continue;
-                        } else if (!(act & DO_NOFUN) &&
-                                   prefix("func", pathopt)) {
+                        } else if (!(act & DO_NOFUN) && prefix("func", pathopt)) {
                                 /* handled below */
                         } else {
-                                continue;       /* ignore unimplemented options */
+                                continue;       /* ignore unimplemented options */
                         }
                 }
                 /* if rehash, don't redo absolute path names */
-                if (fullname[0] == '/' && idx <= prev &&
-                    idx < firstchange) {
+                if (fullname[0] == '/' && idx <= prev && idx < firstchange) {
                         if (idx < prev)
                                 continue;
                         TRACE(("searchexec \"%s\": no change\n", name));
@@ -3723,13 +3718,14 @@ loop:
                                 e = errno;
                         goto loop;
                 }
-                e = EACCES;     /* if we fail, this will be the error */
+                e = EACCES;             /* if we fail, this will be the error */
                 if (!S_ISREG(statb.st_mode))
                         continue;
-                if (pathopt) {          /* this is a %func directory */
+                if (pathopt) {  /* this is a %func directory */
                         stalloc(strlen(fullname) + 1);
                         readcmdfile(fullname);
-                        if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION)
+                        if ((cmdp = cmdlookup(name, 0)) == NULL
+                                || cmdp->cmdtype != CMDFUNCTION)
                                 error("%s not defined in %s", name, fullname);
                         stunalloc(fullname);
                         goto success;
@@ -3758,7 +3754,7 @@ loop:
         entry->cmdtype = CMDUNKNOWN;
         return;
 
-success:
+  success:
         cmdp->rehash = 0;
         entry->cmdtype = cmdp->cmdtype;
         entry->u = cmdp->param;
@@ -3770,20 +3766,17 @@ success:
  * Search the table of builtin commands.
  */
 
-static int
-bstrcmp(const void *name, const void *b)
+static int bstrcmp(const void *name, const void *b)
 {
-        return strcmp((const char *)name, (*(const char *const *) b)+1);
+        return strcmp((const char *) name, (*(const char *const *) b) + 1);
 }
 
-static struct builtincmd *
-find_builtin(const char *name)
+static struct builtincmd *find_builtin(const char *name)
 {
         struct builtincmd *bp;
 
         bp = bsearch(name, builtincmds, NUMBUILTINS, sizeof(struct builtincmd),
-                bstrcmp
-        );
+                                 bstrcmp);
         return bp;
 }
 
@@ -3793,16 +3786,15 @@ find_builtin(const char *name)
  * are executed they will be rehashed.
  */
 
-static inline void
-hashcd(void)
+static inline void hashcd(void)
 {
         struct tblentry **pp;
         struct tblentry *cmdp;
 
-        for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
-                for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
+        for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
+                for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
                         if (cmdp->cmdtype == CMDNORMAL
-                         || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
+                                || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
                                 cmdp->rehash = 1;
                 }
         }
@@ -3816,15 +3808,14 @@ hashcd(void)
  * interrupts off.
  */
 
-static void
-changepath(const char *newval)
+static void changepath(const char *newval)
 {
         int firstchange;
         int bltin;
 
         firstchange = path_change(newval, &bltin);
         if (builtinloc < 0 && bltin >= 0)
-                builtinloc = bltin;             /* zap builtins */
+                builtinloc = bltin;     /* zap builtins */
         clearcmdentry(firstchange);
         builtinloc = bltin;
         /* Ensure that getenv("PATH") stays current */
@@ -3837,21 +3828,19 @@ changepath(const char *newval)
  * PATH which has changed.
  */
 
-static void
-clearcmdentry(int firstchange)
+static void clearcmdentry(int firstchange)
 {
         struct tblentry **tblp;
         struct tblentry **pp;
         struct tblentry *cmdp;
 
         INTOFF;
-        for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
+        for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
                 pp = tblp;
                 while ((cmdp = *pp) != NULL) {
                         if ((cmdp->cmdtype == CMDNORMAL &&
-                             cmdp->param.index >= firstchange)
-                         || (cmdp->cmdtype == CMDBUILTIN &&
-                             builtinloc >= firstchange)) {
+                                 cmdp->param.index >= firstchange)
+                                || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= firstchange)) {
                                 *pp = cmdp->next;
                                 free(cmdp);
                         } else {
@@ -3867,15 +3856,14 @@ clearcmdentry(int firstchange)
  * Delete all functions.
  */
 
-static void
-deletefuncs(void)
+static void deletefuncs(void)
 {
         struct tblentry **tblp;
         struct tblentry **pp;
         struct tblentry *cmdp;
 
         INTOFF;
-        for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
+        for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
                 pp = tblp;
                 while ((cmdp = *pp) != NULL) {
                         if (cmdp->cmdtype == CMDFUNCTION) {
@@ -3902,8 +3890,7 @@ deletefuncs(void)
 
 static struct tblentry **lastcmdentry;
 
-static struct tblentry *
-cmdlookup(const char *name, int add)
+static struct tblentry *cmdlookup(const char *name, int add)
 {
         int hashval;
         const char *p;
@@ -3916,15 +3903,15 @@ cmdlookup(const char *name, int add)
                 hashval += *p++;
         hashval &= 0x7FFF;
         pp = &cmdtable[hashval % CMDTABLESIZE];
-        for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
+        for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
                 if (equal(cmdp->cmdname, name))
                         break;
                 pp = &cmdp->next;
         }
         if (add && cmdp == NULL) {
                 INTOFF;
-                cmdp = *pp = xmalloc(sizeof (struct tblentry) - ARB
-                                        + strlen(name) + 1);
+                cmdp = *pp = xmalloc(sizeof(struct tblentry) - ARB
+                                                         + strlen(name) + 1);
                 cmdp->next = NULL;
                 cmdp->cmdtype = CMDUNKNOWN;
                 cmdp->rehash = 0;
@@ -3939,8 +3926,7 @@ cmdlookup(const char *name, int add)
  * Delete the command entry returned on the last lookup.
  */
 
-static void
-delete_cmd_entry()
+static void delete_cmd_entry()
 {
         struct tblentry *cmdp;
 
@@ -3956,32 +3942,32 @@ delete_cmd_entry()
 
 
 static const unsigned char nodesize[26] = {
-      ALIGN(sizeof (struct nbinary)),
-      ALIGN(sizeof (struct ncmd)),
-      ALIGN(sizeof (struct npipe)),
-      ALIGN(sizeof (struct nredir)),
-      ALIGN(sizeof (struct nredir)),
-      ALIGN(sizeof (struct nredir)),
-      ALIGN(sizeof (struct nbinary)),
-      ALIGN(sizeof (struct nbinary)),
-      ALIGN(sizeof (struct nif)),
-      ALIGN(sizeof (struct nbinary)),
-      ALIGN(sizeof (struct nbinary)),
-      ALIGN(sizeof (struct nfor)),
-      ALIGN(sizeof (struct ncase)),
-      ALIGN(sizeof (struct nclist)),
-      ALIGN(sizeof (struct narg)),
-      ALIGN(sizeof (struct narg)),
-      ALIGN(sizeof (struct nfile)),
-      ALIGN(sizeof (struct nfile)),
-      ALIGN(sizeof (struct nfile)),
-      ALIGN(sizeof (struct nfile)),
-      ALIGN(sizeof (struct nfile)),
-      ALIGN(sizeof (struct ndup)),
-      ALIGN(sizeof (struct ndup)),
-      ALIGN(sizeof (struct nhere)),
-      ALIGN(sizeof (struct nhere)),
-      ALIGN(sizeof (struct nnot)),
+        ALIGN(sizeof(struct nbinary)),
+        ALIGN(sizeof(struct ncmd)),
+        ALIGN(sizeof(struct npipe)),
+        ALIGN(sizeof(struct nredir)),
+        ALIGN(sizeof(struct nredir)),
+        ALIGN(sizeof(struct nredir)),
+        ALIGN(sizeof(struct nbinary)),
+        ALIGN(sizeof(struct nbinary)),
+        ALIGN(sizeof(struct nif)),
+        ALIGN(sizeof(struct nbinary)),
+        ALIGN(sizeof(struct nbinary)),
+        ALIGN(sizeof(struct nfor)),
+        ALIGN(sizeof(struct ncase)),
+        ALIGN(sizeof(struct nclist)),
+        ALIGN(sizeof(struct narg)),
+        ALIGN(sizeof(struct narg)),
+        ALIGN(sizeof(struct nfile)),
+        ALIGN(sizeof(struct nfile)),
+        ALIGN(sizeof(struct nfile)),
+        ALIGN(sizeof(struct nfile)),
+        ALIGN(sizeof(struct nfile)),
+        ALIGN(sizeof(struct ndup)),
+        ALIGN(sizeof(struct ndup)),
+        ALIGN(sizeof(struct nhere)),
+        ALIGN(sizeof(struct nhere)),
+        ALIGN(sizeof(struct nnot)),
 };
 
 
@@ -3990,8 +3976,7 @@ static const unsigned char nodesize[26] = {
  * Delete a function if it exists.
  */
 
-static void
-unsetfunc(char *name)
+static void unsetfunc(char *name)
 {
         struct tblentry *cmdp;
 
@@ -4006,8 +3991,7 @@ unsetfunc(char *name)
  * Locate and print what a word is...
  */
 
-static int
-typecmd(int argc, char **argv)
+static int typecmd(int argc, char **argv)
 {
         int i;
         int err = 0;
@@ -4025,8 +4009,7 @@ typecmd(int argc, char **argv)
 }
 
 #ifdef CONFIG_ASH_CMDCMD
-static int
-commandcmd(int argc, char **argv)
+static int commandcmd(int argc, char **argv)
 {
         int c;
         int default_path = 0;
@@ -4046,12 +4029,10 @@ commandcmd(int argc, char **argv)
                         break;
                 }
 
-        if (default_path + verify_only + verbose_verify_only > 1 ||
-            !*argptr) {
-                        out2str(
-                                "command [-p] command [arg ...]\n"
+        if (default_path + verify_only + verbose_verify_only > 1 || !*argptr) {
+                out2str("command [-p] command [arg ...]\n"
                                 "command {-v|-V} command\n");
-                        return EX_USAGE;
+                return EX_USAGE;
         }
 
         if (verify_only || verbose_verify_only) {
@@ -4060,7 +4041,7 @@ commandcmd(int argc, char **argv)
                 argv_a[1] = 0;
                 argv_a[0] = *argptr;
                 argptr = argv_a;
-                optptr = verbose_verify_only ? "v" : "V"; /* reverse special */
+                optptr = verbose_verify_only ? "v" : "V";       /* reverse special */
                 return hashcmd(argc, argv);
         }
 
@@ -4068,8 +4049,7 @@ commandcmd(int argc, char **argv)
 }
 #endif
 
-static int
-path_change(const char *newval, int *bltin)
+static int path_change(const char *newval, int *bltin)
 {
         const char *old, *new;
         int idx;
@@ -4077,16 +4057,16 @@ path_change(const char *newval, int *bltin)
 
         old = pathval();
         new = newval;
-        firstchange = 9999;     /* assume no change */
+        firstchange = 9999;     /* assume no change */
         idx = 0;
         *bltin = -1;
         for (;;) {
                 if (*old != *new) {
                         firstchange = idx;
                         if ((*old == '\0' && *new == ':')
-                         || (*old == ':' && *new == '\0'))
+                                || (*old == ':' && *new == '\0'))
                                 firstchange++;
-                        old = new;      /* ignore subsequent differences */
+                        old = new;      /* ignore subsequent differences */
                 }
                 if (*new == '\0')
                         break;
@@ -4101,6 +4081,7 @@ path_change(const char *newval, int *bltin)
                 firstchange = 0;
         return firstchange;
 }
+
 /*
  * Routines to expand arguments to commands.  We have to deal with
  * backquotes, shell variables, and file metacharacters.
@@ -4108,8 +4089,8 @@ path_change(const char *newval, int *bltin)
 /*
  * _rmescape() flags
  */
-#define RMESCAPE_ALLOC  0x1     /* Allocate a new string */
-#define RMESCAPE_GLOB   0x2     /* Add backslashes for glob */
+#define RMESCAPE_ALLOC  0x1     /* Allocate a new string */
+#define RMESCAPE_GLOB   0x2     /* Add backslashes for glob */
 
 /*
  * Structure specifying which parts of the string should be searched
@@ -4117,63 +4098,65 @@ path_change(const char *newval, int *bltin)
  */
 
 struct ifsregion {
-        struct ifsregion *next; /* next region in list */
-        int begoff;             /* offset of start of region */
-        int endoff;             /* offset of end of region */
-        int nulonly;            /* search for nul bytes only */
+        struct ifsregion *next; /* next region in list */
+        int begoff;                     /* offset of start of region */
+        int endoff;                     /* offset of end of region */
+        int nulonly;            /* search for nul bytes only */
 };
 
 
-static char *expdest;                   /* output of current string */
-static struct nodelist *argbackq;      /* list of back quote expressions */
-static struct ifsregion ifsfirst;      /* first struct in list of ifs regions */
-static struct ifsregion *ifslastp;     /* last struct in list */
-static struct arglist exparg;          /* holds expanded arg list */
-
-static void argstr (char *, int);
-static char *exptilde (char *, int);
-static void expbackq (union node *, int, int);
-static int subevalvar (char *, char *, int, int, int, int, int);
-static int varisset (char *, int);
-static void strtodest (const char *, int, int);
-static inline void varvalue (char *, int, int);
-static void recordregion (int, int, int);
-static void removerecordregions (int);
-static void ifsbreakup (char *, struct arglist *);
-static void ifsfree (void);
-static void expandmeta (struct strlist *, int);
+static char *expdest;   /* output of current string */
+static struct nodelist *argbackq;       /* list of back quote expressions */
+static struct ifsregion ifsfirst;       /* first struct in list of ifs regions */
+static struct ifsregion *ifslastp;      /* last struct in list */
+static struct arglist exparg;   /* holds expanded arg list */
+
+static void argstr(char *, int);
+static char *exptilde(char *, int);
+static void expbackq(union node *, int, int);
+static int subevalvar(char *, char *, int, int, int, int, int);
+static int varisset(char *, int);
+static void strtodest(const char *, int, int);
+static inline void varvalue(char *, int, int);
+static void recordregion(int, int, int);
+static void removerecordregions(int);
+static void ifsbreakup(char *, struct arglist *);
+static void ifsfree(void);
+static void expandmeta(struct strlist *, int);
+
 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
 #define preglob(p) _rmescapes((p), RMESCAPE_ALLOC | RMESCAPE_GLOB)
 #if !defined(GLOB_BROKEN)
-static inline void addglob (const glob_t *);
+static inline void addglob(const glob_t *);
 #endif
 #endif
 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
-static void expmeta (char *, char *);
+static void expmeta(char *, char *);
 #endif
 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
-static struct strlist *expsort (struct strlist *);
-static struct strlist *msort (struct strlist *, int);
+static struct strlist *expsort(struct strlist *);
+static struct strlist *msort(struct strlist *, int);
 #endif
-static int patmatch (char *, char *, int);
+static int patmatch(char *, char *, int);
+
 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
-static int patmatch2 (char *, char *, int);
+static int patmatch2(char *, char *, int);
 #else
-static int pmatch (char *, char *, int);
+static int pmatch(char *, char *, int);
+
 #define patmatch2 patmatch
 #endif
-static char *cvtnum (int, char *);
+static char *cvtnum(int, char *);
 
 /*
  * Expand shell variables and backquotes inside a here document.
  */
 
 /* arg: the document, fd: where to write the expanded version */
-static inline void
-expandhere(union node *arg, int fd)
+static inline void expandhere(union node *arg, int fd)
 {
         herefd = fd;
-        expandarg(arg, (struct arglist *)NULL, 0);
+        expandarg(arg, (struct arglist *) NULL, 0);
         xwrite(fd, stackblock(), expdest - stackblock());
 }
 
@@ -4185,8 +4168,7 @@ expandhere(union node *arg, int fd)
  * here document expansion.
  */
 
-static void
-expandarg(union node *arg, struct arglist *arglist, int flag)
+static void expandarg(union node *arg, struct arglist *arglist, int flag)
 {
         struct strlist *sp;
         char *p;
@@ -4197,7 +4179,7 @@ expandarg(union node *arg, struct arglist *arglist, int flag)
         ifslastp = NULL;
         argstr(arg->narg.text, flag);
         if (arglist == NULL) {
-                return;                 /* here document expanded */
+                return;                 /* here document expanded */
         }
         STPUTC('\0', expdest);
         p = grabstackstr(expdest);
@@ -4211,9 +4193,9 @@ expandarg(union node *arg, struct arglist *arglist, int flag)
                 exparg.lastp = &exparg.list;
                 expandmeta(exparg.list, flag);
         } else {
-                if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
+                if (flag & EXP_REDIR)   /*XXX - for now, just remove escapes */
                         rmescapes(p);
-                sp = (struct strlist *)stalloc(sizeof (struct strlist));
+                sp = (struct strlist *) stalloc(sizeof(struct strlist));
                 sp->text = p;
                 *exparg.lastp = sp;
                 exparg.lastp = &sp->next;
@@ -4232,7 +4214,7 @@ expandarg(union node *arg, struct arglist *arglist, int flag)
  * input string.
  */
 
-static inline char * evalvar(char *p, int flag)
+static inline char *evalvar(char *p, int flag)
 {
         int subtype;
         int varflags;
@@ -4251,10 +4233,10 @@ static inline char * evalvar(char *p, int flag)
         subtype = varflags & VSTYPE;
         var = p;
         special = 0;
-        if (! is_name(*p))
+        if (!is_name(*p))
                 special = 1;
         p = strchr(p, '=') + 1;
-again: /* jump here after setting a variable with ${var=text} */
+  again:                                /* jump here after setting a variable with ${var=text} */
         if (special) {
                 set = varisset(var, varflags & VSNUL);
                 val = NULL;
@@ -4280,21 +4262,17 @@ again: /* jump here after setting a variable with ${var=text} */
                         if (subtype == VSLENGTH) {
                                 varlen = strlen(val);
                         } else {
-                                strtodest(
-                                        val,
-                                        varflags & VSQUOTE ?
-                                                DQSYNTAX : BASESYNTAX,
-                                        quotes
-                                );
+                                strtodest(val,
+                                                  varflags & VSQUOTE ? DQSYNTAX : BASESYNTAX, quotes);
                         }
                 }
         }
 
         if (subtype == VSPLUS)
-                set = ! set;
+                set = !set;
 
         easy = ((varflags & VSQUOTE) == 0 ||
-                (*var == '@' && shellparam.nparam != 1));
+                        (*var == '@' && shellparam.nparam != 1));
 
 
         switch (subtype) {
@@ -4305,9 +4283,8 @@ again: /* jump here after setting a variable with ${var=text} */
         case VSNORMAL:
                 if (!easy)
                         break;
-record:
-                recordregion(startloc, expdest - stackblock(),
-                             varflags & VSQUOTE);
+          record:
+                recordregion(startloc, expdest - stackblock(), varflags & VSQUOTE);
                 break;
 
         case VSPLUS:
@@ -4333,8 +4310,9 @@ record:
                 STPUTC('\0', expdest);
                 patloc = expdest - stackblock();
                 if (subevalvar(p, NULL, patloc, subtype,
-                               startloc, varflags, quotes) == 0) {
+                                           startloc, varflags, quotes) == 0) {
                         int amount = (expdest - stackblock() - patloc) + 1;
+
                         STADJUST(-amount, expdest);
                 }
                 /* Remove any recorded regions beyond start of variable */
@@ -4344,8 +4322,7 @@ record:
         case VSASSIGN:
         case VSQUESTION:
                 if (!set) {
-                        if (subevalvar(p, var, 0, subtype, startloc,
-                                       varflags, quotes)) {
+                        if (subevalvar(p, var, 0, subtype, startloc, varflags, quotes)) {
                                 varflags &= ~VSNUL;
                                 /*
                                  * Remove any recorded regions beyond
@@ -4366,12 +4343,13 @@ record:
 #endif
         }
 
-        if (subtype != VSNORMAL) {      /* skip to end of alternative */
+        if (subtype != VSNORMAL) {      /* skip to end of alternative */
                 int nesting = 1;
+
                 for (;;) {
                         if ((c = *p++) == CTLESC)
                                 p++;
-                        else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
+                        else if (c == CTLBACKQ || c == (CTLBACKQ | CTLQUOTE)) {
                                 if (set)
                                         argbackq = argbackq->next;
                         } else if (c == CTLVAR) {
@@ -4393,11 +4371,10 @@ record:
  * $@ like $* since no splitting will be performed.
  */
 
-static void
-argstr(char *p, int flag)
+static void argstr(char *p, int flag)
 {
         char c;
-        int quotes = flag & (EXP_FULL | EXP_CASE);      /* do CTLESC */
+        int quotes = flag & (EXP_FULL | EXP_CASE);      /* do CTLESC */
         int firsteq = 1;
 
         if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
@@ -4405,7 +4382,7 @@ argstr(char *p, int flag)
         for (;;) {
                 switch (c = *p++) {
                 case '\0':
-                case CTLENDVAR: /* ??? */
+                case CTLENDVAR: /* ??? */
                         return;
                 case CTLQUOTEMARK:
                         /* "$@" syntax adherence hack */
@@ -4424,7 +4401,7 @@ argstr(char *p, int flag)
                         p = evalvar(p, flag);
                         break;
                 case CTLBACKQ:
-                case CTLBACKQ|CTLQUOTE:
+                case CTLBACKQ | CTLQUOTE:
                         expbackq(argbackq->n, c & CTLQUOTE, flag);
                         argbackq = argbackq->next;
                         break;
@@ -4457,8 +4434,7 @@ argstr(char *p, int flag)
         return;
 }
 
-static char *
-exptilde(char *p, int flag)
+static char *exptilde(char *p, int flag)
 {
         char c, *startp = p;
         struct passwd *pw;
@@ -4466,7 +4442,7 @@ exptilde(char *p, int flag)
         int quotes = flag & (EXP_FULL | EXP_CASE);
 
         while ((c = *p) != '\0') {
-                switch(c) {
+                switch (c) {
                 case CTLESC:
                         return (startp);
                 case CTLQUOTEMARK:
@@ -4480,13 +4456,13 @@ exptilde(char *p, int flag)
                 }
                 p++;
         }
-done:
+  done:
         *p = '\0';
-        if (*(startp+1) == '\0') {
+        if (*(startp + 1) == '\0') {
                 if ((home = lookupvar("HOME")) == NULL)
                         goto lose;
         } else {
-                if ((pw = getpwnam(startp+1)) == NULL)
+                if ((pw = getpwnam(startp + 1)) == NULL)
                         goto lose;
                 home = pw->pw_dir;
         }
@@ -4495,14 +4471,13 @@ done:
         *p = c;
         strtodest(home, SQSYNTAX, quotes);
         return (p);
-lose:
+  lose:
         *p = c;
         return (startp);
 }
 
 
-static void
-removerecordregions(int endoff)
+static void removerecordregions(int endoff)
 {
         if (ifslastp == NULL)
                 return;
@@ -4510,6 +4485,7 @@ removerecordregions(int endoff)
         if (ifsfirst.endoff > endoff) {
                 while (ifsfirst.next != NULL) {
                         struct ifsregion *ifsp;
+
                         INTOFF;
                         ifsp = ifsfirst.next->next;
                         free(ifsfirst.next);
@@ -4527,9 +4503,10 @@ removerecordregions(int endoff)
 
         ifslastp = &ifsfirst;
         while (ifslastp->next && ifslastp->next->begoff < endoff)
-                ifslastp=ifslastp->next;
+                ifslastp = ifslastp->next;
         while (ifslastp->next != NULL) {
                 struct ifsregion *ifsp;
+
                 INTOFF;
                 ifsp = ifslastp->next->next;
                 free(ifslastp->next);
@@ -4546,8 +4523,7 @@ removerecordregions(int endoff)
  * Expand arithmetic expression.  Backup to start of expression,
  * evaluate, place result in (backed up) result, adjust string position.
  */
-static void
-expari(int flag)
+static void expari(int flag)
 {
         char *p, *start;
         int errcode;
@@ -4576,30 +4552,29 @@ expari(int flag)
                 --p;
         if (*p != CTLARI)
                 error("missing CTLARI (shouldn't happen)");
-        if (p > start && *(p-1) == CTLESC)
+        if (p > start && *(p - 1) == CTLESC)
                 for (p = start; *p != CTLARI; p++)
                         if (*p == CTLESC)
                                 p++;
 
         if (p[1] == '"')
-                quoted=1;
+                quoted = 1;
         else
-                quoted=0;
+                quoted = 0;
         begoff = p - start;
         removerecordregions(begoff);
         if (quotes)
-                rmescapes(p+2);
-        result = arith(p+2, &errcode);
+                rmescapes(p + 2);
+        result = arith(p + 2, &errcode);
         if (errcode < 0) {
-                if(errcode == -2)
+                if (errcode == -2)
                         error("divide by zero");
                 else
-                        error("syntax error: \"%s\"\n", p+2);
+                        error("syntax error: \"%s\"\n", p + 2);
         }
         snprintf(p, 12, "%d", result);
 
-        while (*p++)
-                ;
+        while (*p++);
 
         if (quoted == 0)
                 recordregion(begoff, p - 1 - start, 0);
@@ -4612,8 +4587,7 @@ expari(int flag)
  * Expand stuff in backwards quotes.
  */
 
-static void
-expbackq(union node *cmd, int quoted, int flag)
+static void expbackq(union node *cmd, int quoted, int flag)
 {
         volatile struct backcmd in;
         int i;
@@ -4657,7 +4631,7 @@ expbackq(union node *cmd, int quoted, int flag)
         p = grabstackstr(dest);
         evalbackcmd(cmd, (struct backcmd *) &in);
         ungrabstackstr(p, dest);
-err1:
+  err1:
         INTOFF;
         ifsfirst = saveifs;
         ifslastp = savelastp;
@@ -4692,7 +4666,7 @@ err1:
         for (; dest > stackblock() && dest[-1] == '\n';)
                 STUNPUTC(dest);
 
-err2:
+  err2:
         if (in.fd >= 0)
                 close(in.fd);
         free(in.buf);
@@ -4705,15 +4679,15 @@ err2:
         if (quoted == 0)
                 recordregion(startloc, dest - stackblock(), 0);
         TRACE(("evalbackq: size=%d: \"%.*s\"\n",
-                (dest - stackblock()) - startloc,
-                (dest - stackblock()) - startloc,
-                stackblock() + startloc));
+                   (dest - stackblock()) - startloc,
+                   (dest - stackblock()) - startloc, stackblock() + startloc));
         expdest = dest;
         INTON;
 }
 
 static int
-subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes)
+subevalvar(char *p, char *str, int strloc, int subtype, int startloc,
+                   int varflags, int quotes)
 {
         char *startp;
         char *loc = NULL;
@@ -4730,7 +4704,7 @@ subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varfla
         argbackq = saveargbackq;
         startp = stackblock() + startloc;
         if (str == NULL)
-            str = stackblock() + strloc;
+                str = stackblock() + strloc;
 
         switch (subtype) {
         case VSASSIGN:
@@ -4745,11 +4719,10 @@ subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varfla
         case VSQUESTION:
                 if (*p != CTLENDVAR) {
                         out2fmt(snlfmt, startp);
-                        error((char *)NULL);
+                        error((char *) NULL);
                 }
                 error("%.*s: parameter %snot set", p - str - 1,
-                      str, (varflags & VSNUL) ? "null or "
-                                              : nullstr);
+                          str, (varflags & VSNUL) ? "null or " : nullstr);
                 /* NOTREACHED */
 
         case VSTRIMLEFT:
@@ -4812,7 +4785,7 @@ subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varfla
 #endif
         }
 
-recordleft:
+  recordleft:
         *loc = c;
         amount = ((str - 1) - (loc - startp)) - expdest;
         STADJUST(amount, expdest);
@@ -4820,7 +4793,7 @@ recordleft:
                 *startp++ = *loc++;
         return 1;
 
-recordright:
+  recordright:
         amount = loc - expdest;
         STADJUST(amount, expdest);
         STPUTC('\0', expdest);
@@ -4833,8 +4806,7 @@ recordright:
  * Test whether a specialized variable is set.
  */
 
-static int
-varisset(char *name, int nulok)
+static int varisset(char *name, int nulok)
 {
         if (*name == '!')
                 return backgndpid != -1;
@@ -4872,11 +4844,10 @@ varisset(char *name, int nulok)
  * Put a string on the stack.
  */
 
-static void
-strtodest(const char *p, int syntax, int quotes)
+static void strtodest(const char *p, int syntax, int quotes)
 {
         while (*p) {
-                if (quotes && SIT(*p,syntax) == CCTL)
+                if (quotes && SIT(*p, syntax) == CCTL)
                         STPUTC(CTLESC, expdest);
                 STPUTC(*p++, expdest);
         }
@@ -4886,8 +4857,7 @@ strtodest(const char *p, int syntax, int quotes)
  * Add the value of a specialized variable to the stack string.
  */
 
-static inline void
-varvalue(char *name, int quoted, int flags)
+static inline void varvalue(char *name, int quoted, int flags)
 {
         int num;
         char *p;
@@ -4912,11 +4882,11 @@ varvalue(char *name, int quoted, int flags)
                 goto numvar;
         case '!':
                 num = backgndpid;
-numvar:
+          numvar:
                 expdest = cvtnum(num, expdest);
                 break;
         case '-':
-                for (i = 0 ; i < NOPTS ; i++) {
+                for (i = 0; i < NOPTS; i++) {
                         if (optent_val(i))
                                 STPUTC(optent_letter(optlist[i]), expdest);
                 }
@@ -4928,12 +4898,12 @@ numvar:
                 }
                 /* fall through */
         case '*':
-                sep = ifsset() ? ifsval()[0] : ' ';
+                sep = ifsset()? ifsval()[0] : ' ';
                 if (quotes) {
-                        sepq = SIT(sep,syntax) == CCTL;
+                        sepq = SIT(sep, syntax) == CCTL;
                 }
-param:
-                for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
+          param:
+                for (ap = shellparam.p; (p = *ap++) != NULL;) {
                         strtodest(p, syntax, quotes);
                         if (*ap && sep) {
                                 if (sepq)
@@ -4960,8 +4930,7 @@ param:
  * string for IFS characters.
  */
 
-static void
-recordregion(int start, int end, int nulonly)
+static void recordregion(int start, int end, int nulonly)
 {
         struct ifsregion *ifsp;
 
@@ -4969,7 +4938,7 @@ recordregion(int start, int end, int nulonly)
                 ifsp = &ifsfirst;
         } else {
                 INTOFF;
-                ifsp = (struct ifsregion *)xmalloc(sizeof (struct ifsregion));
+                ifsp = (struct ifsregion *) xmalloc(sizeof(struct ifsregion));
                 ifsp->next = NULL;
                 ifslastp->next = ifsp;
                 INTON;
@@ -4987,8 +4956,7 @@ recordregion(int start, int end, int nulonly)
  * strings to the argument list.  The regions of the string to be
  * searched for IFS characters have been stored by recordregion.
  */
-static void
-ifsbreakup(char *string, struct arglist *arglist)
+static void ifsbreakup(char *string, struct arglist *arglist)
 {
         struct ifsregion *ifsp;
         struct strlist *sp;
@@ -5003,7 +4971,7 @@ ifsbreakup(char *string, struct arglist *arglist)
         start = string;
         ifsspc = 0;
         nulonly = 0;
-        realifs = ifsset() ? ifsval() : defifs;
+        realifs = ifsset()? ifsval() : defifs;
         if (ifslastp != NULL) {
                 ifsp = &ifsfirst;
                 do {
@@ -5025,7 +4993,7 @@ ifsbreakup(char *string, struct arglist *arglist)
                                                 continue;
                                         }
                                         *q = '\0';
-                                        sp = (struct strlist *)stalloc(sizeof *sp);
+                                        sp = (struct strlist *) stalloc(sizeof *sp);
                                         sp->text = start;
                                         *arglist->lastp = sp;
                                         arglist->lastp = &sp->next;
@@ -5038,7 +5006,7 @@ ifsbreakup(char *string, struct arglist *arglist)
                                                         q = p;
                                                         if (*p == CTLESC)
                                                                 p++;
-                                                        if (strchr(ifs, *p) == NULL ) {
+                                                        if (strchr(ifs, *p) == NULL) {
                                                                 p = q;
                                                                 break;
                                                         } else if (strchr(defifs, *p) == NULL) {
@@ -5063,17 +5031,17 @@ ifsbreakup(char *string, struct arglist *arglist)
                 }
         }
 
-        sp = (struct strlist *)stalloc(sizeof *sp);
+        sp = (struct strlist *) stalloc(sizeof *sp);
         sp->text = start;
         *arglist->lastp = sp;
         arglist->lastp = &sp->next;
 }
 
-static void
-ifsfree(void)
+static void ifsfree(void)
 {
         while (ifsfirst.next != NULL) {
                 struct ifsregion *ifsp;
+
                 INTOFF;
                 ifsp = ifsfirst.next->next;
                 free(ifsfirst.next);
@@ -5088,12 +5056,11 @@ ifsfree(void)
  * Add a file name to the list.
  */
 
-static void
-addfname(const char *name)
+static void addfname(const char *name)
 {
         struct strlist *sp;
 
-        sp = (struct strlist *)stalloc(sizeof *sp);
+        sp = (struct strlist *) stalloc(sizeof *sp);
         sp->text = sstrdup(name);
         *exparg.lastp = sp;
         exparg.lastp = &sp->next;
@@ -5105,11 +5072,11 @@ addfname(const char *name)
  */
 
 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
-static void
-expandmeta(struct strlist *str, int flag)
+static void expandmeta(struct strlist *str, int flag)
 {
         const char *p;
         glob_t pglob;
+
         /* TODO - EXP_REDIR */
 
         while (str) {
@@ -5119,22 +5086,22 @@ expandmeta(struct strlist *str, int flag)
                 INTOFF;
                 switch (glob(p, 0, 0, &pglob)) {
                 case 0:
-                        if(pglob.gl_pathv[1]==0 && !strcmp(p, pglob.gl_pathv[0]))
+                        if (pglob.gl_pathv[1] == 0 && !strcmp(p, pglob.gl_pathv[0]))
                                 goto nometa2;
                         addglob(&pglob);
                         globfree(&pglob);
                         INTON;
                         break;
                 case GLOB_NOMATCH:
-nometa2:
+                  nometa2:
                         globfree(&pglob);
                         INTON;
-nometa:
+                  nometa:
                         *exparg.lastp = str;
                         rmescapes(str->text);
                         exparg.lastp = &str->next;
                         break;
-                default:        /* GLOB_NOSPACE */
+                default:                /* GLOB_NOSPACE */
                         error("Out of space");
                 }
                 str = str->next;
@@ -5146,8 +5113,7 @@ nometa:
  * Add the result of glob(3) to the list.
  */
 
-static inline void
-addglob(const glob_t *pglob)
+static inline void addglob(const glob_t * pglob)
 {
         char **p = pglob->gl_pathv;
 
@@ -5157,24 +5123,24 @@ addglob(const glob_t *pglob)
 }
 
 
-#else   /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
+#else                                                   /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
 static char *expdir;
 
 
-static void
-expandmeta(struct strlist *str, int flag)
+static void expandmeta(struct strlist *str, int flag)
 {
         char *p;
         struct strlist **savelastp;
         struct strlist *sp;
         char c;
+
         /* TODO - EXP_REDIR */
 
         while (str) {
                 if (fflag)
                         goto nometa;
                 p = str->text;
-                for (;;) {                      /* fast check for meta chars */
+                for (;;) {              /* fast check for meta chars */
                         if ((c = *p++) == '\0')
                                 goto nometa;
                         if (c == '*' || c == '?' || c == '[' || c == '!')
@@ -5184,7 +5150,8 @@ expandmeta(struct strlist *str, int flag)
                 INTOFF;
                 if (expdir == NULL) {
                         int i = strlen(str->text);
-                        expdir = xmalloc(i < 2048 ? 2048 : i); /* XXX */
+
+                        expdir = xmalloc(i < 2048 ? 2048 : i);  /* XXX */
                 }
 
                 expmeta(expdir, str->text);
@@ -5195,7 +5162,7 @@ expandmeta(struct strlist *str, int flag)
                         /*
                          * no matches
                          */
-nometa:
+                  nometa:
                         *exparg.lastp = str;
                         rmescapes(str->text);
                         exparg.lastp = &str->next;
@@ -5215,8 +5182,7 @@ nometa:
  * Do metacharacter (i.e. *, ?, [...]) expansion.
  */
 
-static void
-expmeta(char *enddir, char *name)
+static void expmeta(char *enddir, char *name)
 {
         char *p;
         const char *cp;
@@ -5232,7 +5198,7 @@ expmeta(char *enddir, char *name)
 
         metaflag = 0;
         start = name;
-        for (p = name ; ; p++) {
+        for (p = name;; p++) {
                 if (*p == '*' || *p == '?')
                         metaflag = 1;
                 else if (*p == '[') {
@@ -5265,10 +5231,10 @@ expmeta(char *enddir, char *name)
                         start = p + 1;
                 }
         }
-        if (metaflag == 0) {    /* we've reached the end of the file name */
+        if (metaflag == 0) {    /* we've reached the end of the file name */
                 if (enddir != expdir)
                         metaflag++;
-                for (p = name ; ; p++) {
+                for (p = name;; p++) {
                         if (*p == CTLQUOTEMARK)
                                 continue;
                         if (*p == CTLESC)
@@ -5318,16 +5284,15 @@ expmeta(char *enddir, char *name)
                 p++;
         if (*p == '.')
                 matchdot++;
-        while (! int_pending() && (dp = readdir(dirp)) != NULL) {
-                if (dp->d_name[0] == '.' && ! matchdot)
+        while (!int_pending() && (dp = readdir(dirp)) != NULL) {
+                if (dp->d_name[0] == '.' && !matchdot)
                         continue;
                 if (patmatch(start, dp->d_name, 0)) {
                         if (atend) {
                                 strcpy(enddir, dp->d_name);
                                 addfname(expdir);
                         } else {
-                                for (p = enddir, cp = dp->d_name;
-                                     (*p++ = *cp++) != '\0';)
+                                for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';)
                                         continue;
                                 p[-1] = '/';
                                 expmeta(p, endname);
@@ -5335,10 +5300,10 @@ expmeta(char *enddir, char *name)
                 }
         }
         closedir(dirp);
-        if (! atend)
+        if (!atend)
                 endname[-1] = '/';
 }
-#endif  /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
+#endif                                                  /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
 
 
 
@@ -5349,21 +5314,19 @@ expmeta(char *enddir, char *name)
  * work.
  */
 
-static struct strlist *
-expsort(struct strlist *str)
+static struct strlist *expsort(struct strlist *str)
 {
         int len;
         struct strlist *sp;
 
         len = 0;
-        for (sp = str ; sp ; sp = sp->next)
+        for (sp = str; sp; sp = sp->next)
                 len++;
         return msort(str, len);
 }
 
 
-static struct strlist *
-msort(struct strlist *list, int len)
+static struct strlist *msort(struct strlist *list, int len)
 {
         struct strlist *p, *q = NULL;
         struct strlist **lpp;
@@ -5374,13 +5337,13 @@ msort(struct strlist *list, int len)
                 return list;
         half = len >> 1;
         p = list;
-        for (n = half ; --n >= 0 ; ) {
+        for (n = half; --n >= 0;) {
                 q = p;
                 p = p->next;
         }
-        q->next = NULL;                 /* terminate first half of list */
-        q = msort(list, half);          /* sort first half of list */
-        p = msort(p, len - half);               /* sort second half */
+        q->next = NULL;         /* terminate first half of list */
+        q = msort(list, half);  /* sort first half of list */
+        p = msort(p, len - half);       /* sort second half */
         lpp = &list;
         for (;;) {
                 if (strcmp(p->text, q->text) < 0) {
@@ -5411,8 +5374,7 @@ msort(struct strlist *list, int len)
 
 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
 /* squoted: string might have quote chars */
-static int
-patmatch(char *pattern, char *string, int squoted)
+static int patmatch(char *pattern, char *string, int squoted)
 {
         const char *p;
         char *q;
@@ -5424,8 +5386,7 @@ patmatch(char *pattern, char *string, int squoted)
 }
 
 
-static int
-patmatch2(char *pattern, char *string, int squoted)
+static int patmatch2(char *pattern, char *string, int squoted)
 {
         char *p;
         int res;
@@ -5437,14 +5398,13 @@ patmatch2(char *pattern, char *string, int squoted)
         return res;
 }
 #else
-static int
-patmatch(char *pattern, char *string, int squoted) {
+static int patmatch(char *pattern, char *string, int squoted)
+{
         return pmatch(pattern, string, squoted);
 }
 
 
-static int
-pmatch(char *pattern, char *string, int squoted)
+static int pmatch(char *pattern, char *string, int squoted)
 {
         char *p, *q;
         char c;
@@ -5473,11 +5433,10 @@ pmatch(char *pattern, char *string, int squoted)
                         c = *p;
                         while (c == CTLQUOTEMARK || c == '*')
                                 c = *++p;
-                        if (c != CTLESC &&  c != CTLQUOTEMARK &&
-                            c != '?' && c != '*' && c != '[') {
+                        if (c != CTLESC && c != CTLQUOTEMARK &&
+                                c != '?' && c != '*' && c != '[') {
                                 while (*q != c) {
-                                        if (squoted && *q == CTLESC &&
-                                            q[1] == c)
+                                        if (squoted && *q == CTLESC && q[1] == c)
                                                 break;
                                         if (*q == '\0')
                                                 return 0;
@@ -5493,7 +5452,7 @@ pmatch(char *pattern, char *string, int squoted)
                                         q++;
                         } while (*q++ != '\0');
                         return 0;
-                case '[': {
+                case '[':{
                         char *endp;
                         int invert, found;
                         char chr;
@@ -5505,7 +5464,7 @@ pmatch(char *pattern, char *string, int squoted)
                                 while (*endp == CTLQUOTEMARK)
                                         endp++;
                                 if (*endp == '\0')
-                                        goto dft;               /* no matching ] */
+                                        goto dft;       /* no matching ] */
                                 if (*endp == CTLESC)
                                         endp++;
                                 if (*++endp == ']')
@@ -5546,7 +5505,7 @@ pmatch(char *pattern, char *string, int squoted)
                                 return 0;
                         break;
                 }
-dft:            default:
+                dft: default:
                         if (squoted && *q == CTLESC)
                                 q++;
                         if (*q++ != c)
@@ -5554,7 +5513,7 @@ dft:            default:
                         break;
                 }
         }
-breakloop:
+  breakloop:
         if (*q != '\0')
                 return 0;
         return 1;
@@ -5568,8 +5527,7 @@ breakloop:
  */
 
 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
-static char *
-_rmescapes(char *str, int flag)
+static char *_rmescapes(char *str, int flag)
 {
         char *p, *q, *r;
         static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
@@ -5582,6 +5540,7 @@ _rmescapes(char *str, int flag)
         r = str;
         if (flag & RMESCAPE_ALLOC) {
                 size_t len = p - str;
+
                 q = r = stalloc(strlen(p) + len + 1);
                 if (len > 0) {
                         memcpy(q, str, len);
@@ -5605,8 +5564,7 @@ _rmescapes(char *str, int flag)
         return r;
 }
 #else
-static void
-rmescapes(char *str)
+static void rmescapes(char *str)
 {
         char *p, *q;
 
@@ -5635,8 +5593,7 @@ rmescapes(char *str)
  * See if a pattern matches in a case statement.
  */
 
-static int
-casematch(union node *pattern, const char *val)
+static int casematch(union node *pattern, const char *val)
 {
         struct stackmark smark;
         int result;
@@ -5649,7 +5606,7 @@ casematch(union node *pattern, const char *val)
         argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
         STPUTC('\0', expdest);
         p = grabstackstr(expdest);
-        result = patmatch(p, (char *)val, 0);
+        result = patmatch(p, (char *) val, 0);
         popstackmark(&smark);
         return result;
 }
@@ -5658,8 +5615,7 @@ casematch(union node *pattern, const char *val)
  * Our own itoa().
  */
 
-static char *
-cvtnum(int num, char *buf)
+static char *cvtnum(int num, char *buf)
 {
         int len;
 
@@ -5668,6 +5624,7 @@ cvtnum(int num, char *buf)
         STADJUST(len, buf);
         return buf;
 }
+
 /*
  * Editline and history functions (and glue).
  */
@@ -5680,7 +5637,7 @@ static int histcmd(int argc, char **argv)
 
 struct redirtab {
         struct redirtab *next;
-        short renamed[10]; /* Current ash support only 0-9 descriptors */
+        short renamed[10];      /* Current ash support only 0-9 descriptors */
         /* char on arm (and others) can't be negative */
 };
 
@@ -5694,35 +5651,35 @@ extern char **environ;
  * Initialization code.
  */
 
-static void
-init(void) {
+static void init(void)
+{
 
-      /* from cd.c: */
-      {
-              curdir = nullstr;
-              setpwd(0, 0);
-      }
+        /* from cd.c: */
+        {
+                curdir = nullstr;
+                setpwd(0, 0);
+        }
 
-      /* from input.c: */
-      {
-              basepf.nextc = basepf.buf = basebuf;
-      }
+        /* from input.c: */
+        {
+                basepf.nextc = basepf.buf = basebuf;
+        }
 
-      /* from var.c: */
-      {
-              char **envp;
-              char ppid[32];
+        /* from var.c: */
+        {
+                char **envp;
+                char ppid[32];
 
-              initvar();
-              for (envp = environ ; *envp ; envp++) {
-                      if (strchr(*envp, '=')) {
-                              setvareq(*envp, VEXPORT|VTEXTFIXED);
-                      }
-              }
+                initvar();
+                for (envp = environ; *envp; envp++) {
+                        if (strchr(*envp, '=')) {
+                                setvareq(*envp, VEXPORT | VTEXTFIXED);
+                        }
+                }
 
-              snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
-              setvar("PPID", ppid, 0);
-      }
+                snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
+                setvar("PPID", ppid, 0);
+        }
 }
 
 
@@ -5733,37 +5690,37 @@ init(void) {
  */
 
 /* 1 == check for aliases, 2 == also check for assignments */
-static int checkalias;  /* also used in no alias mode for check assignments */
+static int checkalias;  /* also used in no alias mode for check assignments */
 
-static void
-reset(void) {
+static void reset(void)
+{
 
-      /* from eval.c: */
-      {
-              evalskip = 0;
-              loopnest = 0;
-              funcnest = 0;
-      }
+        /* from eval.c: */
+        {
+                evalskip = 0;
+                loopnest = 0;
+                funcnest = 0;
+        }
 
-      /* from input.c: */
-      {
-              if (exception != EXSHELLPROC)
-                      parselleft = parsenleft = 0;      /* clear input buffer */
-              popallfiles();
-      }
+        /* from input.c: */
+        {
+                if (exception != EXSHELLPROC)
+                        parselleft = parsenleft = 0;    /* clear input buffer */
+                popallfiles();
+        }
 
-      /* from parser.c: */
-      {
-              tokpushback = 0;
-              checkkwd = 0;
-              checkalias = 0;
-      }
+        /* from parser.c: */
+        {
+                tokpushback = 0;
+                checkkwd = 0;
+                checkalias = 0;
+        }
 
-      /* from redir.c: */
-      {
-              while (redirlist)
-                      popredir();
-      }
+        /* from redir.c: */
+        {
+                while (redirlist)
+                        popredir();
+        }
 
 }
 
@@ -5774,17 +5731,19 @@ reset(void) {
  */
 
 #ifdef CONFIG_FEATURE_COMMAND_EDITING
-static const char * cmdedit_prompt;
-static inline void putprompt(const char *s) {
-    cmdedit_prompt = s;
+static const char *cmdedit_prompt;
+static inline void putprompt(const char *s)
+{
+        cmdedit_prompt = s;
 }
 #else
-static inline void putprompt(const char *s) {
-    out2str(s);
+static inline void putprompt(const char *s)
+{
+        out2str(s);
 }
 #endif
 
-#define EOF_NLEFT -99           /* value of parsenleft when EOF pushed back */
+#define EOF_NLEFT -99   /* value of parsenleft when EOF pushed back */
 
 
 
@@ -5793,25 +5752,27 @@ static inline void putprompt(const char *s) {
  */
 
 #ifdef CONFIG_ASH_ALIAS
-static int
-pgetc2(void)
+static int pgetc2(void)
 {
         int c;
+
         do {
                 c = pgetc_macro();
         } while (c == PEOA);
         return c;
 }
 #else
-static inline int pgetc2(void) { return pgetc_macro(); }
+static inline int pgetc2(void)
+{
+        return pgetc_macro();
+}
 #endif
 
 /*
  * Read a line from the script.
  */
 
-static inline char *
-pfgets(char *line, int len)
+static inline char *pfgets(char *line, int len)
 {
         char *p = line;
         int nleft = len;
@@ -5832,21 +5793,21 @@ pfgets(char *line, int len)
         return line;
 }
 
-static inline int
-preadfd(void)
+static inline int preadfd(void)
 {
-    int nr;
-    char *buf =  parsefile->buf;
-    parsenextc = buf;
+        int nr;
+        char *buf = parsefile->buf;
 
-retry:
+        parsenextc = buf;
+
+  retry:
 #ifdef CONFIG_FEATURE_COMMAND_EDITING
         {
-            if (!iflag || parsefile->fd)
-                    nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
-            else {
-                    nr = cmdedit_read_input((char*)cmdedit_prompt, buf);
-            }
+                if (!iflag || parsefile->fd)
+                        nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
+                else {
+                        nr = cmdedit_read_input((char *) cmdedit_prompt, buf);
+                }
         }
 #else
         nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
@@ -5855,8 +5816,9 @@ retry:
         if (nr < 0) {
                 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
                         int flags = fcntl(0, F_GETFL, 0);
+
                         if (flags >= 0 && flags & O_NONBLOCK) {
-                                flags &=~ O_NONBLOCK;
+                                flags &= ~O_NONBLOCK;
                                 if (fcntl(0, F_SETFL, flags) >= 0) {
                                         out2str("sh: turning off NDELAY mode\n");
                                         goto retry;
@@ -5867,8 +5829,7 @@ retry:
         return nr;
 }
 
-static void
-popstring(void)
+static void popstring(void)
 {
         struct strpush *sp = parsefile->strpush;
 
@@ -5910,8 +5871,7 @@ popstring(void)
  * 4) Process input up to the next newline, deleting nul characters.
  */
 
-static int
-preadbuffer(void)
+static int preadbuffer(void)
 {
         char *p, *q;
         int more;
@@ -5932,7 +5892,7 @@ preadbuffer(void)
                 return PEOF;
         flushall();
 
-again:
+  again:
         if (parselleft <= 0) {
                 if ((parselleft = preadfd()) <= 0) {
                         parselleft = parsenleft = EOF_NLEFT;
@@ -5946,18 +5906,18 @@ again:
         for (more = 1; more;) {
                 switch (*p) {
                 case '\0':
-                        p++;    /* Skip nul */
+                        p++;            /* Skip nul */
                         goto check;
 
 
                 case '\n':
                         parsenleft = q - parsenextc;
-                        more = 0; /* Stop processing here */
+                        more = 0;       /* Stop processing here */
                         break;
                 }
 
                 *q++ = *p++;
-check:
+          check:
                 if (--parselleft <= 0 && more) {
                         parsenleft = q - parsenextc - 1;
                         if (parsenleft < 0)
@@ -5983,15 +5943,14 @@ check:
  * Push a string back onto the input at this current parsefile level.
  * We handle aliases this way.
  */
-static void
-pushstring(char *s, int len, void *ap)
+static void pushstring(char *s, int len, void *ap)
 {
         struct strpush *sp;
 
         INTOFF;
 /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
         if (parsefile->strpush) {
-                sp = xmalloc(sizeof (struct strpush));
+                sp = xmalloc(sizeof(struct strpush));
                 sp->prev = parsefile->strpush;
                 parsefile->strpush = sp;
         } else
@@ -5999,9 +5958,9 @@ pushstring(char *s, int len, void *ap)
         sp->prevstring = parsenextc;
         sp->prevnleft = parsenleft;
 #ifdef CONFIG_ASH_ALIAS
-        sp->ap = (struct alias *)ap;
+        sp->ap = (struct alias *) ap;
         if (ap) {
-                ((struct alias *)ap)->flag |= ALIASINUSE;
+                ((struct alias *) ap)->flag |= ALIASINUSE;
                 sp->string = s;
         }
 #endif
@@ -6015,8 +5974,7 @@ pushstring(char *s, int len, void *ap)
  * Like setinputfile, but takes input from a string.
  */
 
-static void
-setinputstring(char *string)
+static void setinputstring(char *string)
 {
         INTOFF;
         pushfile();
@@ -6034,8 +5992,7 @@ setinputstring(char *string)
  * adds a new entry to the stack and popfile restores the previous level.
  */
 
-static void
-pushfile(void)
+static void pushfile(void)
 {
         struct parsefile *pf;
 
@@ -6043,7 +6000,7 @@ pushfile(void)
         parsefile->lleft = parselleft;
         parsefile->nextc = parsenextc;
         parsefile->linno = plinno;
-        pf = (struct parsefile *)xmalloc(sizeof (struct parsefile));
+        pf = (struct parsefile *) xmalloc(sizeof(struct parsefile));
         pf->prev = parsefile;
         pf->fd = -1;
         pf->strpush = NULL;
@@ -6052,11 +6009,11 @@ pushfile(void)
 }
 
 #ifdef CONFIG_ASH_JOB_CONTROL
-static void restartjob (struct job *);
+static void restartjob(struct job *);
 #endif
-static void freejob (struct job *);
-static struct job *getjob (const char *);
-static int dowait (int, struct job *);
+static void freejob(struct job *);
+static struct job *getjob(const char *);
+static int dowait(int, struct job *);
 static void waitonint(int);
 
 
@@ -6068,13 +6025,12 @@ static void waitonint(int);
 static int fd0_redirected = 0;
 
 /* Return true if fd 0 has already been redirected at least once.  */
-static inline int
-fd0_redirected_p (void) 
+static inline int fd0_redirected_p(void)
 {
         return fd0_redirected != 0;
 }
 
-static void dupredirect (const union node *, int, int fd1dup);
+static void dupredirect(const union node *, int, int fd1dup);
 
 #ifdef CONFIG_ASH_JOB_CONTROL
 /*
@@ -6096,9 +6052,9 @@ static void setjobctl(int enable)
         if (enable == jobctl || rootshell == 0)
                 return;
         if (enable) {
-                do { /* while we are in the background */
+                do {                    /* while we are in the background */
 #ifdef OLD_TTY_DRIVER
-                        if (ioctl(2, TIOCGPGRP, (char *)&initialpgrp) < 0) {
+                        if (ioctl(2, TIOCGPGRP, (char *) &initialpgrp) < 0) {
 #else
                         initialpgrp = tcgetpgrp(2);
                         if (initialpgrp < 0) {
@@ -6115,8 +6071,9 @@ static void setjobctl(int enable)
                         }
                 } while (0);
 #ifdef OLD_TTY_DRIVER
-                if (ioctl(2, TIOCGETD, (char *)&ldisc) < 0 || ldisc != NTTYDISC) {
-                        out2str("sh: need new tty driver to run job control; job control turned off\n");
+                if (ioctl(2, TIOCGETD, (char *) &ldisc) < 0 || ldisc != NTTYDISC) {
+                        out2str
+                                ("sh: need new tty driver to run job control; job control turned off\n");
                         mflag = 0;
                         return;
                 }
@@ -6126,14 +6083,14 @@ static void setjobctl(int enable)
                 setsignal(SIGTTIN);
                 setpgid(0, rootpid);
 #ifdef OLD_TTY_DRIVER
-                ioctl(2, TIOCSPGRP, (char *)&rootpid);
+                ioctl(2, TIOCSPGRP, (char *) &rootpid);
 #else
                 tcsetpgrp(2, rootpid);
 #endif
-        } else { /* turning job control off */
+        } else {                        /* turning job control off */
                 setpgid(0, initialpgrp);
 #ifdef OLD_TTY_DRIVER
-                ioctl(2, TIOCSPGRP, (char *)&initialpgrp);
+                ioctl(2, TIOCSPGRP, (char *) &initialpgrp);
 #else
                 tcsetpgrp(2, initialpgrp);
 #endif
@@ -6147,8 +6104,7 @@ static void setjobctl(int enable)
 
 
 #ifdef CONFIG_ASH_JOB_CONTROL
-static int
-killcmd(int argc, char **argv)
+static int killcmd(int argc, char **argv)
 {
         int signo = -1;
         int list = 0;
@@ -6157,11 +6113,10 @@ killcmd(int argc, char **argv)
         struct job *jp;
 
         if (argc <= 1) {
-usage:
-                error(
-"Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
-"kill -l [exitstatus]"
-                );
+          usage:
+                error
+                        ("Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
+                         "kill -l [exitstatus]");
         }
 
         if (*argv[1] == '-') {
@@ -6177,18 +6132,14 @@ usage:
                                 case 's':
                                         signo = decode_signal(optionarg, 1);
                                         if (signo < 0) {
-                                                error(
-                                                        "invalid signal number or name: %s",
-                                                        optionarg
-                                                );
+                                                error("invalid signal number or name: %s", optionarg);
                                         }
                                         break;
 #ifdef DEBUG
                                 default:
-                                        error(
-        "nextopt returned character code 0%o", c);
+                                        error("nextopt returned character code 0%o", c);
 #endif
-                        }
+                                }
                 } else
                         argptr++;
         }
@@ -6207,7 +6158,7 @@ usage:
                         out1str("0\n");
                         for (i = 1; i < NSIG; i++) {
                                 name = u_signal_names(0, &i, 1);
-                                if(name)
+                                if (name)
                                         puts(name);
                         }
                         return 0;
@@ -6216,8 +6167,7 @@ usage:
                 if (name)
                         puts(name);
                 else
-                        error("invalid signal number or exit status: %s",
-                              *argptr);
+                        error("invalid signal number or exit status: %s", *argptr);
                 return 0;
         }
 
@@ -6225,8 +6175,7 @@ usage:
                 if (**argptr == '%') {
                         jp = getjob(*argptr);
                         if (jp->jobctl == 0)
-                                error("job %s not created under job control",
-                                      *argptr);
+                                error("job %s not created under job control", *argptr);
                         pid = -jp->ps[0].pid;
                 } else
                         pid = atoi(*argptr);
@@ -6237,8 +6186,7 @@ usage:
         return 0;
 }
 
-static int
-fgcmd(int argc, char **argv)
+static int fgcmd(int argc, char **argv)
 {
         struct job *jp;
         int pgrp;
@@ -6249,7 +6197,7 @@ fgcmd(int argc, char **argv)
                 error("job not created under job control");
         pgrp = jp->ps[0].pid;
 #ifdef OLD_TTY_DRIVER
-        ioctl(2, TIOCSPGRP, (char *)&pgrp);
+        ioctl(2, TIOCSPGRP, (char *) &pgrp);
 #else
         tcsetpgrp(2, pgrp);
 #endif
@@ -6259,8 +6207,7 @@ fgcmd(int argc, char **argv)
 }
 
 
-static int
-bgcmd(int argc, char **argv)
+static int bgcmd(int argc, char **argv)
 {
         struct job *jp;
 
@@ -6274,8 +6221,7 @@ bgcmd(int argc, char **argv)
 }
 
 
-static void
-restartjob(struct job *jp)
+static void restartjob(struct job *jp)
 {
         struct procstat *ps;
         int i;
@@ -6284,7 +6230,7 @@ restartjob(struct job *jp)
                 return;
         INTOFF;
         killpg(jp->ps[0].pid, SIGCONT);
-        for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
+        for (ps = jp->ps, i = jp->nprocs; --i >= 0; ps++) {
                 if (WIFSTOPPED(ps->status)) {
                         ps->status = -1;
                         jp->state = 0;
@@ -6297,8 +6243,7 @@ restartjob(struct job *jp)
 static void showjobs(int change);
 
 
-static int
-jobscmd(int argc, char **argv)
+static int jobscmd(int argc, char **argv)
 {
         showjobs(0);
         return 0;
@@ -6314,8 +6259,7 @@ jobscmd(int argc, char **argv)
  * will be freed here.
  */
 
-static void
-showjobs(int change)
+static void showjobs(int change)
 {
         int jobno;
         int procno;
@@ -6326,37 +6270,34 @@ showjobs(int change)
         char s[64];
 
         TRACE(("showjobs(%d) called\n", change));
-        while (dowait(0, (struct job *)NULL) > 0);
-        for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
-                if (! jp->used)
+        while (dowait(0, (struct job *) NULL) > 0);
+        for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
+                if (!jp->used)
                         continue;
                 if (jp->nprocs == 0) {
                         freejob(jp);
                         continue;
                 }
-                if (change && ! jp->changed)
+                if (change && !jp->changed)
                         continue;
                 procno = jp->nprocs;
-                for (ps = jp->ps ; ; ps++) {    /* for each process */
+                for (ps = jp->ps;; ps++) {      /* for each process */
                         if (ps == jp->ps)
-                                snprintf(s, 64, "[%d] %ld ", jobno,
-                                    (long)ps->pid);
+                                snprintf(s, 64, "[%d] %ld ", jobno, (long) ps->pid);
                         else
-                                snprintf(s, 64, "    %ld ",
-                                    (long)ps->pid);
+                                snprintf(s, 64, "    %ld ", (long) ps->pid);
                         out1str(s);
                         col = strlen(s);
                         s[0] = '\0';
                         if (ps->status == -1) {
                                 /* don't print anything */
                         } else if (WIFEXITED(ps->status)) {
-                                snprintf(s, 64, "Exit %d",
-                                       WEXITSTATUS(ps->status));
+                                snprintf(s, 64, "Exit %d", WEXITSTATUS(ps->status));
                         } else {
 #ifdef CONFIG_ASH_JOB_CONTROL
                                 if (WIFSTOPPED(ps->status))
                                         i = WSTOPSIG(ps->status);
-                                else /* WIFSIGNALED(ps->status) */
+                                else    /* WIFSIGNALED(ps->status) */
 #endif
                                         i = WTERMSIG(ps->status);
                                 if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F])
@@ -6368,10 +6309,7 @@ showjobs(int change)
                         }
                         out1str(s);
                         col += strlen(s);
-                        printf(
-                                "%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ',
-                                ps->cmd
-                        );
+                        printf("%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ', ps->cmd);
                         if (--procno <= 0)
                                 break;
                 }
@@ -6387,14 +6325,13 @@ showjobs(int change)
  * Mark a job structure as unused.
  */
 
-static void
-freejob(struct job *jp)
+static void freejob(struct job *jp)
 {
         const struct procstat *ps;
         int i;
 
         INTOFF;
-        for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) {
+        for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
                 if (ps->cmd != nullstr)
                         free(ps->cmd);
         }
@@ -6410,24 +6347,23 @@ freejob(struct job *jp)
 
 
 
-static int
-waitcmd(int argc, char **argv)
+static int waitcmd(int argc, char **argv)
 {
         struct job *job;
         int status, retval;
         struct job *jp;
 
         if (--argc > 0) {
-start:
+          start:
                 job = getjob(*++argv);
         } else {
                 job = NULL;
         }
-        for (;;) {      /* loop until process terminated or stopped */
+        for (;;) {                      /* loop until process terminated or stopped */
                 if (job != NULL) {
                         if (job->state) {
                                 status = job->ps[job->nprocs - 1].status;
-                                if (! iflag)
+                                if (!iflag)
                                         freejob(job);
                                 if (--argc) {
                                         goto start;
@@ -6445,8 +6381,8 @@ start:
                                 return retval;
                         }
                 } else {
-                        for (jp = jobtab ; ; jp++) {
-                                if (jp >= jobtab + njobs) {     /* no running procs */
+                        for (jp = jobtab;; jp++) {
+                                if (jp >= jobtab + njobs) {     /* no running procs */
                                         return 0;
                                 }
                                 if (jp->used && jp->state == 0)
@@ -6465,8 +6401,7 @@ start:
  * Convert a job name to a job structure.
  */
 
-static struct job *
-getjob(const char *name)
+static struct job *getjob(const char *name)
 {
         int jobno;
         struct job *jp;
@@ -6475,7 +6410,7 @@ getjob(const char *name)
 
         if (name == NULL) {
 #ifdef CONFIG_ASH_JOB_CONTROL
-currentjob:
+          currentjob:
                 if ((jobno = curjob) == 0 || jobtab[jobno - 1].used == 0)
                         error("No current job");
                 return &jobtab[jobno - 1];
@@ -6485,8 +6420,7 @@ currentjob:
         } else if (name[0] == '%') {
                 if (is_digit(name[1])) {
                         jobno = number(name + 1);
-                        if (jobno > 0 && jobno <= njobs
-                         && jobtab[jobno - 1].used != 0)
+                        if (jobno > 0 && jobno <= njobs && jobtab[jobno - 1].used != 0)
                                 return &jobtab[jobno - 1];
 #ifdef CONFIG_ASH_JOB_CONTROL
                 } else if (name[1] == '%' && name[2] == '\0') {
@@ -6494,9 +6428,10 @@ currentjob:
 #endif
                 } else {
                         struct job *found = NULL;
-                        for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
+
+                        for (jp = jobtab, i = njobs; --i >= 0; jp++) {
                                 if (jp->used && jp->nprocs > 0
-                                 && prefix(name + 1, jp->ps[0].cmd)) {
+                                        && prefix(name + 1, jp->ps[0].cmd)) {
                                         if (found)
                                                 error("%s: ambiguous", name);
                                         found = jp;
@@ -6506,9 +6441,9 @@ currentjob:
                                 return found;
                 }
         } else if (is_number(name, &pid)) {
-                for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
+                for (jp = jobtab, i = njobs; --i >= 0; jp++) {
                         if (jp->used && jp->nprocs > 0
-                         && jp->ps[jp->nprocs - 1].pid == pid)
+                                && jp->ps[jp->nprocs - 1].pid == pid)
                                 return jp;
                 }
         }
@@ -6522,13 +6457,12 @@ currentjob:
  * Return a new job structure,
  */
 
-static struct job *
-makejob(const union node *node, int nprocs)
+static struct job *makejob(const union node *node, int nprocs)
 {
         int i;
         struct job *jp;
 
-        for (i = njobs, jp = jobtab ; ; jp++) {
+        for (i = njobs, jp = jobtab;; jp++) {
                 if (--i < 0) {
                         INTOFF;
                         if (njobs == 0) {
@@ -6544,7 +6478,7 @@ makejob(const union node *node, int nprocs)
                                 jobtab = jp;
                         }
                         jp = jobtab + njobs;
-                        for (i = 4 ; --i >= 0 ; jobtab[njobs++].used = 0);
+                        for (i = 4; --i >= 0; jobtab[njobs++].used = 0);
                         INTON;
                         break;
                 }
@@ -6560,13 +6494,13 @@ makejob(const union node *node, int nprocs)
         jp->jobctl = jobctl;
 #endif
         if (nprocs > 1) {
-                jp->ps = xmalloc(nprocs * sizeof (struct procstat));
+                jp->ps = xmalloc(nprocs * sizeof(struct procstat));
         } else {
                 jp->ps = &jp->ps0;
         }
         INTON;
-        TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
-            jp - jobtab + 1));
+        TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long) node, nprocs,
+                   jp - jobtab + 1));
         return jp;
 }
 
@@ -6588,18 +6522,18 @@ makejob(const union node *node, int nprocs)
 
 
 
-static int
-forkshell(struct job *jp, const union node *n, int mode)
+static int forkshell(struct job *jp, const union node *n, int mode)
 {
         int pid;
+
 #ifdef CONFIG_ASH_JOB_CONTROL
         int pgrp;
 #endif
         const char *devnull = _PATH_DEVNULL;
         const char *nullerr = "Can't open %s";
 
-        TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long)n,
-            mode));
+        TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long) n,
+                   mode));
         INTOFF;
 #if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
         pid = fork();
@@ -6623,7 +6557,7 @@ forkshell(struct job *jp, const union node *n, int mode)
                 INTON;
                 clear_traps();
 #ifdef CONFIG_ASH_JOB_CONTROL
-                jobctl = 0;             /* do job control only in root shell */
+                jobctl = 0;             /* do job control only in root shell */
                 if (wasroot && mode != FORK_NOJOB && mflag) {
                         if (jp == NULL || jp->nprocs == 0)
                                 pgrp = getpid();
@@ -6633,7 +6567,7 @@ forkshell(struct job *jp, const union node *n, int mode)
                         if (mode == FORK_FG) {
                                 /*** this causes superfluous TIOCSPGRPS ***/
 #ifdef OLD_TTY_DRIVER
-                                if (ioctl(2, TIOCSPGRP, (char *)&pgrp) < 0)
+                                if (ioctl(2, TIOCSPGRP, (char *) &pgrp) < 0)
                                         error("TIOCSPGRP failed, errno=%d", errno);
 #else
                                 if (tcsetpgrp(2, pgrp) < 0)
@@ -6648,14 +6582,13 @@ forkshell(struct job *jp, const union node *n, int mode)
 #endif
                         ignoresig(SIGINT);
                         ignoresig(SIGQUIT);
-                        if ((jp == NULL || jp->nprocs == 0) &&
-                            ! fd0_redirected_p ()) {
+                        if ((jp == NULL || jp->nprocs == 0) && !fd0_redirected_p()) {
                                 close(0);
                                 if (open(devnull, O_RDONLY) != 0)
                                         error(nullerr, devnull);
                         }
                 }
-                for (i = njobs, p = jobtab ; --i >= 0 ; p++)
+                for (i = njobs, p = jobtab; --i >= 0; p++)
                         if (p->used)
                                 freejob(p);
                 if (wasroot && iflag) {
@@ -6675,9 +6608,10 @@ forkshell(struct job *jp, const union node *n, int mode)
         }
 #endif
         if (mode == FORK_BG)
-                backgndpid = pid;               /* set $! */
+                backgndpid = pid;       /* set $! */
         if (jp) {
                 struct procstat *ps = &jp->ps[jp->nprocs++];
+
                 ps->pid = pid;
                 ps->status = -1;
                 ps->cmd = nullstr;
@@ -6710,8 +6644,7 @@ forkshell(struct job *jp, const union node *n, int mode)
  * confuse this approach.
  */
 
-static int
-waitforjob(struct job *jp)
+static int waitforjob(struct job *jp)
 {
 #ifdef CONFIG_ASH_JOB_CONTROL
         int mypgrp = getpgrp();
@@ -6741,12 +6674,13 @@ waitforjob(struct job *jp)
         if (!iflag) {
 #endif
                 sigaction(SIGINT, &oact, 0);
-                if (intreceived) kill(getpid(), SIGINT);
+                if (intreceived)
+                        kill(getpid(), SIGINT);
         }
 #ifdef CONFIG_ASH_JOB_CONTROL
         if (jp->jobctl) {
 #ifdef OLD_TTY_DRIVER
-                if (ioctl(2, TIOCSPGRP, (char *)&mypgrp) < 0)
+                if (ioctl(2, TIOCSPGRP, (char *) &mypgrp) < 0)
                         error("TIOCSPGRP failed, errno=%d\n", errno);
 #else
                 if (tcsetpgrp(2, mypgrp) < 0)
@@ -6780,7 +6714,6 @@ waitforjob(struct job *jp)
                         raise(SIGINT);
         }
         if (jp->state == JOBDONE)
-
 #endif
                 freejob(jp);
         INTON;
@@ -6817,8 +6750,7 @@ waitforjob(struct job *jp)
  *
  */
 
-static inline int
-waitproc(int block, int *status)
+static inline int waitproc(int block, int *status)
 {
         int flags;
 
@@ -6829,11 +6761,10 @@ waitproc(int block, int *status)
 #endif
         if (block == 0)
                 flags |= WNOHANG;
-        return wait3(status, flags, (struct rusage *)NULL);
+        return wait3(status, flags, (struct rusage *) NULL);
 }
 
-static int
-dowait(int block, struct job *job)
+static int dowait(int block, struct job *job)
 {
         int pid;
         int status;
@@ -6854,15 +6785,16 @@ dowait(int block, struct job *job)
                 return pid;
         INTOFF;
         thisjob = NULL;
-        for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
+        for (jp = jobtab; jp < jobtab + njobs; jp++) {
                 if (jp->used) {
                         done = 1;
                         stopped = 1;
-                        for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
+                        for (sp = jp->ps; sp < jp->ps + jp->nprocs; sp++) {
                                 if (sp->pid == -1)
                                         continue;
                                 if (sp->pid == pid) {
-                                        TRACE(("Changing status of proc %d from 0x%x to 0x%x\n", pid, sp->status, status));
+                                        TRACE(("Changing status of proc %d from 0x%x to 0x%x\n",
+                                                   pid, sp->status, status));
                                         sp->status = status;
                                         thisjob = jp;
                                 }
@@ -6871,36 +6803,40 @@ dowait(int block, struct job *job)
                                 else if (WIFSTOPPED(sp->status))
                                         done = 0;
                         }
-                        if (stopped) {          /* stopped or done */
-                                int state = done? JOBDONE : CONFIG_ASH_JOB_CONTROLTOPPED;
+                        if (stopped) {  /* stopped or done */
+                                int state = done ? JOBDONE : CONFIG_ASH_JOB_CONTROLTOPPED;
+
                                 if (jp->state != state) {
-                                        TRACE(("Job %d: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
+                                        TRACE(("Job %d: changing state from %d to %d\n",
+                                                   jp - jobtab + 1, jp->state, state));
                                         jp->state = state;
 #ifdef CONFIG_ASH_JOB_CONTROL
                                         if (done && curjob == jp - jobtab + 1)
-                                                curjob = 0;             /* no current job */
+                                                curjob = 0;     /* no current job */
 #endif
                                 }
                         }
                 }
         }
         INTON;
-        if (! rootshell || ! iflag || (job && thisjob == job)) {
+        if (!rootshell || !iflag || (job && thisjob == job)) {
                 core = WCOREDUMP(status);
 #ifdef CONFIG_ASH_JOB_CONTROL
-                if (WIFSTOPPED(status)) sig = WSTOPSIG(status);
+                if (WIFSTOPPED(status))
+                        sig = WSTOPSIG(status);
                 else
 #endif
-                if (WIFEXITED(status)) sig = 0;
-                else sig = WTERMSIG(status);
+                if (WIFEXITED(status))
+                        sig = 0;
+                else
+                        sig = WTERMSIG(status);
 
                 if (sig != 0 && sig != SIGINT && sig != SIGPIPE) {
                         if (thisjob != job)
                                 out2fmt("%d: ", pid);
 #ifdef CONFIG_ASH_JOB_CONTROL
                         if (sig == SIGTSTP && rootshell && iflag)
-                                out2fmt("%%%ld ",
-                                    (long)(job - jobtab + 1));
+                                out2fmt("%%%ld ", (long) (job - jobtab + 1));
 #endif
                         if (sig < NSIG && sys_siglist[sig])
                                 out2str(sys_siglist[sig]);
@@ -6910,11 +6846,11 @@ dowait(int block, struct job *job)
                                 out2str(" - core dumped");
                         out2c('\n');
                 } else {
-                        TRACE(("Not printing status: status=%d, sig=%d\n",
-                               status, sig));
+                        TRACE(("Not printing status: status=%d, sig=%d\n", status, sig));
                 }
         } else {
-                TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell, job));
+                TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell,
+                           job));
                 if (thisjob)
                         thisjob->changed = 1;
         }
@@ -6927,8 +6863,7 @@ dowait(int block, struct job *job)
 /*
  * return 1 if there are stopped jobs, otherwise 0
  */
-static int
-stoppedjobs(void)
+static int stoppedjobs(void)
 {
         int jobno;
         struct job *jp;
@@ -6955,10 +6890,10 @@ stoppedjobs(void)
 
 static char *cmdnextc;
 static int cmdnleft;
+
 #define MAXCMDTEXT      200
 
-static void
-cmdputs(const char *s)
+static void cmdputs(const char *s)
 {
         const char *p;
         char *q;
@@ -6982,8 +6917,8 @@ cmdputs(const char *s)
                         subtype = 0;
                 } else if (c == CTLENDVAR) {
                         *q++ = '}';
-                } else if (c == CTLBACKQ || c == CTLBACKQ+CTLQUOTE)
-                        cmdnleft++;             /* ignore it */
+                } else if (c == CTLBACKQ || c == CTLBACKQ + CTLQUOTE)
+                        cmdnleft++;     /* ignore it */
                 else
                         *q++ = c;
                 if (--cmdnleft <= 0) {
@@ -7019,30 +6954,30 @@ cmdputs(const char *s)
  *          end-of-instructions flag in bit 0.
  */
 
-#define CMDTXT_NOMORE      0x01 /* NOTE: no offset should be odd */
+#define CMDTXT_NOMORE      0x01 /* NOTE: no offset should be odd */
 #define CMDTXT_CHARPTR     0x40
 #define CMDTXT_STRING      0x80
 #define CMDTXT_SPECIAL     0xC0
 #define CMDTXT_OFFSETMASK  0x3E
 
-static const char * const cmdtxt_strings[] = {
- /* 0     1    2    3       4       5      6          7     */
+static const char *const cmdtxt_strings[] = {
+        /* 0     1    2    3       4       5      6          7     */
         "; ", "(", ")", " && ", " || ", "if ", "; then ", "...",
- /* 8         9        10       11        12      13       */
-    "while ", "; do ", "; done", "until ", "for ", " in ...",
- /* 14       15     16        17     */
+        /* 8         9        10       11        12      13       */
+        "while ", "; do ", "; done", "until ", "for ", " in ...",
+        /* 14       15     16        17     */
         "case ", "???", "() ...", "<<..."
 };
 
-static const char * const redir_strings[] = {
+static const char *const redir_strings[] = {
         ">", "<", "<>", ">>", ">|", ">&", "<&"
 };
 
 static const unsigned char cmdtxt_ops[] = {
 #define CMDTXT_NSEMI    0
         offsetof(union node, nbinary.ch1),
-        0|CMDTXT_STRING,
-        offsetof(union node, nbinary.ch2)|CMDTXT_NOMORE,
+        0 | CMDTXT_STRING,
+        offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
 #define CMDTXT_NCMD     (CMDTXT_NSEMI + 3)
 #define CMDTXT_NPIPE    (CMDTXT_NCMD)
 #define  CMDTXT_NCASE    (CMDTXT_NCMD)
@@ -7056,52 +6991,52 @@ static const unsigned char cmdtxt_ops[] = {
         CMDTXT_SPECIAL,
 #define CMDTXT_NREDIR   (CMDTXT_NPIPE + 1)
 #define CMDTXT_NBACKGND (CMDTXT_NREDIR)
-        offsetof(union node, nredir.n)|CMDTXT_NOMORE,
+        offsetof(union node, nredir.n) | CMDTXT_NOMORE,
 #define CMDTXT_NSUBSHELL (CMDTXT_NBACKGND + 1)
-        (1*2)|CMDTXT_STRING,
+        (1 * 2) | CMDTXT_STRING,
         offsetof(union node, nredir.n),
-        (2*2)|CMDTXT_STRING|CMDTXT_NOMORE,
+        (2 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
 #define CMDTXT_NAND     (CMDTXT_NSUBSHELL + 3)
         offsetof(union node, nbinary.ch1),
-        (3*2)|CMDTXT_STRING,
-        offsetof(union node, nbinary.ch2)|CMDTXT_NOMORE,
+        (3 * 2) | CMDTXT_STRING,
+        offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
 #define CMDTXT_NOR      (CMDTXT_NAND + 3)
         offsetof(union node, nbinary.ch1),
-        (4*2)|CMDTXT_STRING,
-        offsetof(union node, nbinary.ch2)|CMDTXT_NOMORE,
+        (4 * 2) | CMDTXT_STRING,
+        offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
 #define CMDTXT_NIF      (CMDTXT_NOR + 3)
-        (5*2)|CMDTXT_STRING,
+        (5 * 2) | CMDTXT_STRING,
         offsetof(union node, nif.test),
-        (6*2)|CMDTXT_STRING,
+        (6 * 2) | CMDTXT_STRING,
         offsetof(union node, nif.ifpart),
-        (7*2)|CMDTXT_STRING|CMDTXT_NOMORE,
+        (7 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
 #define CMDTXT_NWHILE   (CMDTXT_NIF + 5)
-        (8*2)|CMDTXT_STRING,
+        (8 * 2) | CMDTXT_STRING,
         offsetof(union node, nbinary.ch1),
-        (9*2)|CMDTXT_STRING,
+        (9 * 2) | CMDTXT_STRING,
         offsetof(union node, nbinary.ch2),
-        (10*2)|CMDTXT_STRING|CMDTXT_NOMORE,
+        (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
 #define CMDTXT_NUNTIL   (CMDTXT_NWHILE + 5)
-        (11*2)|CMDTXT_STRING,
+        (11 * 2) | CMDTXT_STRING,
         offsetof(union node, nbinary.ch1),
-        (9*2)|CMDTXT_STRING,
+        (9 * 2) | CMDTXT_STRING,
         offsetof(union node, nbinary.ch2),
-        (10*2)|CMDTXT_STRING|CMDTXT_NOMORE,
+        (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
 #define CMDTXT_NFOR     (CMDTXT_NUNTIL + 5)
-        (12*2)|CMDTXT_STRING,
-        offsetof(union node, nfor.var)|CMDTXT_CHARPTR,
-        (13*2)|CMDTXT_STRING|CMDTXT_NOMORE,
-#define CMDTXT_NCLIST   (CMDTXT_NFOR + 3) /* TODO: IS THIS CORRECT??? */
-#define  CMDTXT_NNOT     (CMDTXT_NCLIST)        /* TODO: IS THIS CORRECT??? */
-        (15*2)|CMDTXT_STRING|CMDTXT_NOMORE,
+        (12 * 2) | CMDTXT_STRING,
+        offsetof(union node, nfor.var) | CMDTXT_CHARPTR,
+        (13 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
+#define CMDTXT_NCLIST   (CMDTXT_NFOR + 3)       /* TODO: IS THIS CORRECT??? */
+#define  CMDTXT_NNOT     (CMDTXT_NCLIST)        /* TODO: IS THIS CORRECT??? */
+        (15 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
 #define CMDTXT_NDEFUN   (CMDTXT_NCLIST + 1)
-        offsetof(union node, narg.text)|CMDTXT_CHARPTR,
-        (16*2)|CMDTXT_STRING|CMDTXT_NOMORE,
+        offsetof(union node, narg.text) | CMDTXT_CHARPTR,
+        (16 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
 #define CMDTXT_NARG     (CMDTXT_NDEFUN + 2)
-        offsetof(union node, narg.text)|CMDTXT_CHARPTR|CMDTXT_NOMORE,
+        offsetof(union node, narg.text) | CMDTXT_CHARPTR | CMDTXT_NOMORE,
 #define CMDTXT_NHERE    (CMDTXT_NARG + 1)
 #define CMDTXT_NXHERE   (CMDTXT_NHERE)
-        (17*2)|CMDTXT_STRING|CMDTXT_NOMORE,
+        (17 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
 };
 
 #if CMDTXT_NXHERE != 36
@@ -7137,8 +7072,7 @@ static const unsigned char cmdtxt_ops_index[26] = {
         CMDTXT_NNOT,
 };
 
-static void
-cmdtxt(const union node *n)
+static void cmdtxt(const union node *n)
 {
         const char *p;
 
@@ -7146,34 +7080,38 @@ cmdtxt(const union node *n)
                 return;
 
         p = cmdtxt_ops + (int) cmdtxt_ops_index[n->type];
-        if ((*p & CMDTXT_SPECIAL) != CMDTXT_SPECIAL) { /* normal case */
+        if ((*p & CMDTXT_SPECIAL) != CMDTXT_SPECIAL) {  /* normal case */
                 do {
-                        if (*p & CMDTXT_STRING) { /* output fixed string */
-                                cmdputs(cmdtxt_strings[((int)(*p & CMDTXT_OFFSETMASK) >> 1)]);
+                        if (*p & CMDTXT_STRING) {       /* output fixed string */
+                                cmdputs(cmdtxt_strings
+                                                [((int) (*p & CMDTXT_OFFSETMASK) >> 1)]);
                         } else {
                                 const char *pf = ((const char *) n)
-                                                                  + ((int)(*p & CMDTXT_OFFSETMASK));
-                                if (*p & CMDTXT_CHARPTR) { /* output dynamic string */
+                                        + ((int) (*p & CMDTXT_OFFSETMASK));
+
+                                if (*p & CMDTXT_CHARPTR) {      /* output dynamic string */
                                         cmdputs(*((const char **) pf));
-                                } else {                /* output field */
+                                } else {        /* output field */
                                         cmdtxt(*((const union node **) pf));
                                 }
                         }
                 } while (!(*p++ & CMDTXT_NOMORE));
         } else if (n->type == NCMD) {
                 union node *np;
-                for (np = n->ncmd.args ; np ; np = np->narg.next) {
+
+                for (np = n->ncmd.args; np; np = np->narg.next) {
                         cmdtxt(np);
                         if (np->narg.next)
                                 cmdputs(spcstr);
                 }
-                for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
+                for (np = n->ncmd.redirect; np; np = np->nfile.next) {
                         cmdputs(spcstr);
                         cmdtxt(np);
                 }
         } else if (n->type == NPIPE) {
                 struct nodelist *lp;
-                for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
+
+                for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
                         cmdtxt(lp->n);
                         if (lp->next)
                                 cmdputs(" | ");
@@ -7208,9 +7146,8 @@ cmdtxt(const union node *n)
                 }
         }
 }
-#else  /* CMDTXT_TABLE */
-static void
-cmdtxt(const union node *n)
+#else                                                   /* CMDTXT_TABLE */
+static void cmdtxt(const union node *n)
 {
         union node *np;
         struct nodelist *lp;
@@ -7237,7 +7174,7 @@ cmdtxt(const union node *n)
                 cmdtxt(n->nbinary.ch2);
                 break;
         case NPIPE:
-                for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
+                for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
                         cmdtxt(lp->n);
                         if (lp->next)
                                 cmdputs(" | ");
@@ -7264,7 +7201,7 @@ cmdtxt(const union node *n)
                 goto until;
         case NUNTIL:
                 cmdputs("until ");
-until:
+          until:
                 cmdtxt(n->nbinary.ch1);
                 cmdputs("; do ");
                 cmdtxt(n->nbinary.ch2);
@@ -7285,12 +7222,12 @@ until:
                 cmdputs("() ...");
                 break;
         case NCMD:
-                for (np = n->ncmd.args ; np ; np = np->narg.next) {
+                for (np = n->ncmd.args; np; np = np->narg.next) {
                         cmdtxt(np);
                         if (np->narg.next)
                                 cmdputs(spcstr);
                 }
-                for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
+                for (np = n->ncmd.redirect; np; np = np->nfile.next) {
                         cmdputs(spcstr);
                         cmdtxt(np);
                 }
@@ -7299,20 +7236,34 @@ until:
                 cmdputs(n->narg.text);
                 break;
         case NTO:
-                p = ">";  i = 1;  goto redir;
+                p = ">";
+                i = 1;
+                goto redir;
         case NAPPEND:
-                p = ">>";  i = 1;  goto redir;
+                p = ">>";
+                i = 1;
+                goto redir;
         case NTOFD:
-                p = ">&";  i = 1;  goto redir;
+                p = ">&";
+                i = 1;
+                goto redir;
         case NTOOV:
-                p = ">|";  i = 1;  goto redir;
+                p = ">|";
+                i = 1;
+                goto redir;
         case NFROM:
-                p = "<";  i = 0;  goto redir;
+                p = "<";
+                i = 0;
+                goto redir;
         case NFROMFD:
-                p = "<&";  i = 0;  goto redir;
+                p = "<&";
+                i = 0;
+                goto redir;
         case NFROMTO:
-                p = "<>";  i = 0;  goto redir;
-redir:
+                p = "<>";
+                i = 0;
+                goto redir;
+          redir:
                 if (n->nfile.fd != i) {
                         s[0] = n->nfile.fd + '0';
                         s[1] = '\0';
@@ -7336,10 +7287,9 @@ redir:
                 break;
         }
 }
-#endif /* CMDTXT_TABLE */
+#endif                                                  /* CMDTXT_TABLE */
 
-static char *
-commandtext(const union node *n)
+static char *commandtext(const union node *n)
 {
         char *name;
 
@@ -7351,7 +7301,8 @@ commandtext(const union node *n)
 }
 
 
-static void waitonint(int sig) {
+static void waitonint(int sig)
+{
         intreceived = 1;
 }
 
@@ -7365,8 +7316,8 @@ static void waitonint(int sig) {
 #define MAXMBOXES 10
 
 
-static int nmboxes;                     /* number of mailboxes */
-static time_t mailtime[MAXMBOXES];      /* times of mailboxes */
+static int nmboxes;             /* number of mailboxes */
+static time_t mailtime[MAXMBOXES];      /* times of mailboxes */
 
 
 
@@ -7376,8 +7327,7 @@ static time_t mailtime[MAXMBOXES];      /* times of mailboxes */
  * values.
  */
 
-static void
-chkmail(int silent)
+static void chkmail(int silent)
 {
         int i;
         const char *mpath;
@@ -7392,23 +7342,22 @@ chkmail(int silent)
                 return;
         setstackmark(&smark);
         mpath = mpathset()? mpathval() : mailval();
-        for (i = 0 ; i < nmboxes ; i++) {
+        for (i = 0; i < nmboxes; i++) {
                 p = padvance(&mpath, nullstr);
                 if (p == NULL)
                         break;
                 if (*p == '\0')
                         continue;
-                for (q = p ; *q ; q++);
+                for (q = p; *q; q++);
 #ifdef DEBUG
                 if (q[-1] != '/')
                         abort();
 #endif
-                q[-1] = '\0';                   /* delete trailing '/' */
+                q[-1] = '\0';   /* delete trailing '/' */
                 if (stat(p, &statb) < 0)
                         statb.st_size = 0;
-                if (statb.st_size > mailtime[i] && ! silent) {
-                        out2fmt(snlfmt,
-                                pathopt? pathopt : "you have mail");
+                if (statb.st_size > mailtime[i] && !silent) {
+                        out2fmt(snlfmt, pathopt ? pathopt : "you have mail");
                 }
                 mailtime[i] = statb.st_size;
         }
@@ -7416,7 +7365,7 @@ chkmail(int silent)
         popstackmark(&smark);
 }
 
-#endif /* CONFIG_ASH_MAIL */
+#endif                                                  /* CONFIG_ASH_MAIL */
 
 #define PROFILE 0
 
@@ -7427,11 +7376,11 @@ extern int etext();
 
 static int isloginsh = 0;
 
-static void read_profile (const char *);
-static void cmdloop (int);
-static void options (int);
-static void setoption (int, int);
-static void procargs (int, char **);
+static void read_profile(const char *);
+static void cmdloop(int);
+static void options(int);
+static void setoption(int, int);
+static void procargs(int, char **);
 
 
 /*
@@ -7442,8 +7391,7 @@ static void procargs (int, char **);
  * is used to figure out how far we had gotten.
  */
 
-int
-ash_main(int argc, char **argv)
+int ash_main(int argc, char **argv)
 {
         struct jmploc jmploc;
         struct stackmark smark;
@@ -7484,15 +7432,15 @@ ash_main(int argc, char **argv)
                         } else if (exception == EXERROR) {
                                 exitstatus = 2;
                         }
-                    if (state == 0 || iflag == 0 || ! rootshell)
-                            exitshell(exitstatus);
+                        if (state == 0 || iflag == 0 || !rootshell)
+                                exitshell(exitstatus);
                 }
                 reset();
                 if (exception == EXINT) {
                         out2c('\n');
                 }
                 popstackmark(&smark);
-                FORCEINTON;                             /* enable interrupts */
+                FORCEINTON;             /* enable interrupts */
                 if (state == 1)
                         goto state1;
                 else if (state == 2)
@@ -7505,7 +7453,8 @@ ash_main(int argc, char **argv)
         handler = &jmploc;
 #ifdef DEBUG
         opentrace();
-        trputs("Shell args:  ");  trargs(argv);
+        trputs("Shell args:  ");
+        trargs(argv);
 #endif
         rootpid = getpid();
         rootshell = 1;
@@ -7517,11 +7466,11 @@ ash_main(int argc, char **argv)
         if (isloginsh) {
                 state = 1;
                 read_profile("/etc/profile");
-state1:
+          state1:
                 state = 2;
                 read_profile(".profile");
         }
-state2:
+  state2:
         state = 3;
 #ifndef linux
         if (getuid() == geteuid() && getgid() == getegid()) {
@@ -7533,28 +7482,29 @@ state2:
 #ifndef linux
         }
 #endif
-state3:
+  state3:
         state = 4;
         if (sflag == 0 || minusc) {
-                static const char sigs[] =  {
-                    SIGINT, SIGQUIT, SIGHUP,
+                static const char sigs[] = {
+                        SIGINT, SIGQUIT, SIGHUP,
 #ifdef SIGTSTP
-                    SIGTSTP,
+                        SIGTSTP,
 #endif
-                    SIGPIPE
+                        SIGPIPE
                 };
-#define SIGSSIZE ((sizeof(sigs)/sizeof(sigs[0])) - 1) /* trailing nul */
+
+#define SIGSSIZE ((sizeof(sigs)/sizeof(sigs[0])) - 1)   /* trailing nul */
                 int i;
 
                 for (i = 0; i < SIGSSIZE; i++)
-                    setsignal(sigs[i]);
+                        setsignal(sigs[i]);
         }
 
         if (minusc)
                 evalstring(minusc, 0);
 
         if (sflag || minusc == NULL) {
-state4: /* XXX ??? - why isn't this before the "if" statement */
+          state4:                       /* XXX ??? - why isn't this before the "if" statement */
                 cmdloop(1);
         }
 #if PROFILE
@@ -7570,8 +7520,7 @@ state4: /* XXX ??? - why isn't this before the "if" statement */
  * loop; it turns on prompting if the shell is interactive.
  */
 
-static void
-cmdloop(int top)
+static void cmdloop(int top)
 {
         union node *n;
         struct stackmark smark;
@@ -7624,8 +7573,7 @@ cmdloop(int top)
  * Read /etc/profile or .profile.  Return on error.
  */
 
-static void
-read_profile(const char *name)
+static void read_profile(const char *name)
 {
         int fd;
         int xflag_save;
@@ -7641,7 +7589,7 @@ read_profile(const char *name)
         /* Note: Might do a little redundant work, but reduces code size. */
         xflag_save = xflag;
         vflag_save = vflag;
-        if (qflag)  {
+        if (qflag) {
                 vflag = xflag = 0;
         }
         cmdloop(0);
@@ -7656,8 +7604,7 @@ read_profile(const char *name)
  * Read a file containing shell functions.
  */
 
-static void
-readcmdfile(const char *name)
+static void readcmdfile(const char *name)
 {
         int fd;
 
@@ -7678,8 +7625,7 @@ readcmdfile(const char *name)
  * search for the file, which is necessary to find sub-commands.
  */
 
-static inline char *
-find_dot_file(char *mybasename)
+static inline char *find_dot_file(char *mybasename)
 {
         char *fullname;
         const char *path = pathval();
@@ -7705,24 +7651,24 @@ find_dot_file(char *mybasename)
         /* NOTREACHED */
 }
 
-static int
-dotcmd(int argc, char **argv)
+static int dotcmd(int argc, char **argv)
 {
         struct strlist *sp;
         volatile struct shparam saveparam;
+
         exitstatus = 0;
 
-        for (sp = cmdenviron; sp ; sp = sp->next)
-                setvareq(xstrdup(sp->text), VSTRFIXED|VTEXTFIXED);
+        for (sp = cmdenviron; sp; sp = sp->next)
+                setvareq(xstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
 
-        if (argc >= 2) {                /* That's what SVR2 does */
+        if (argc >= 2) {        /* That's what SVR2 does */
                 char *fullname;
                 struct stackmark smark;
 
                 setstackmark(&smark);
                 fullname = find_dot_file(argv[1]);
 
-                if (argc>2) {
+                if (argc > 2) {
                         saveparam = shellparam;
                         shellparam.malloc = 0;
                         shellparam.nparam = argc - 2;
@@ -7734,7 +7680,7 @@ dotcmd(int argc, char **argv)
                 cmdloop(0);
                 popfile();
 
-                if (argc>2) {
+                if (argc > 2) {
                         freeparam(&shellparam);
                         shellparam = saveparam;
                 };
@@ -7745,8 +7691,7 @@ dotcmd(int argc, char **argv)
 }
 
 
-static int
-exitcmd(int argc, char **argv)
+static int exitcmd(int argc, char **argv)
 {
         if (stoppedjobs())
                 return 0;
@@ -7758,8 +7703,7 @@ exitcmd(int argc, char **argv)
         /* NOTREACHED */
 }
 
-static pointer
-stalloc(int nbytes)
+static pointer stalloc(int nbytes)
 {
         char *p;
 
@@ -7786,25 +7730,23 @@ stalloc(int nbytes)
 }
 
 
-static void
-stunalloc(pointer p)
+static void stunalloc(pointer p)
 {
 #ifdef DEBUG
-        if (p == NULL) {                /*DEBUG */
+        if (p == NULL) {        /*DEBUG */
                 write(2, "stunalloc\n", 10);
                 abort();
         }
 #endif
-        if (!(stacknxt >= (char *)p && (char *)p >= stackp->space)) {
+        if (!(stacknxt >= (char *) p && (char *) p >= stackp->space)) {
                 p = stackp->space;
         }
-        stacknleft += stacknxt - (char *)p;
+        stacknleft += stacknxt - (char *) p;
         stacknxt = p;
 }
 
 
-static void
-setstackmark(struct stackmark *mark)
+static void setstackmark(struct stackmark *mark)
 {
         mark->stackp = stackp;
         mark->stacknxt = stacknxt;
@@ -7814,8 +7756,7 @@ setstackmark(struct stackmark *mark)
 }
 
 
-static void
-popstackmark(struct stackmark *mark)
+static void popstackmark(struct stackmark *mark)
 {
         struct stack_block *sp;
 
@@ -7842,8 +7783,8 @@ popstackmark(struct stackmark *mark)
  * part of the block that has been used.
  */
 
-static void
-growstackblock(void) {
+static void growstackblock(void)
+{
         char *p;
         int newlen = ALIGN(stacknleft * 2 + 100);
         char *oldspace = stacknxt;
@@ -7856,37 +7797,38 @@ growstackblock(void) {
                 oldstackp = stackp;
                 sp = stackp;
                 stackp = sp->prev;
-                sp = xrealloc((pointer)sp, sizeof(struct stack_block) - MINSIZE + newlen);
+                sp = xrealloc((pointer) sp,
+                                          sizeof(struct stack_block) - MINSIZE + newlen);
                 sp->prev = stackp;
                 stackp = sp;
                 stacknxt = sp->space;
                 stacknleft = newlen;
                 {
-                  /* Stack marks pointing to the start of the old block
-                   * must be relocated to point to the new block
-                   */
-                  struct stackmark *xmark;
-                  xmark = markp;
-                  while (xmark != NULL && xmark->stackp == oldstackp) {
-                    xmark->stackp = stackp;
-                    xmark->stacknxt = stacknxt;
-                    xmark->stacknleft = stacknleft;
-                    xmark = xmark->marknext;
-                  }
+                        /* Stack marks pointing to the start of the old block
+                         * must be relocated to point to the new block
+                         */
+                        struct stackmark *xmark;
+
+                        xmark = markp;
+                        while (xmark != NULL && xmark->stackp == oldstackp) {
+                                xmark->stackp = stackp;
+                                xmark->stacknxt = stacknxt;
+                                xmark->stacknleft = stacknleft;
+                                xmark = xmark->marknext;
+                        }
                 }
                 INTON;
         } else {
                 p = stalloc(newlen);
                 memcpy(p, oldspace, oldlen);
-                stacknxt = p;                   /* free the space */
-                stacknleft += newlen;           /* we just allocated */
+                stacknxt = p;   /* free the space */
+                stacknleft += newlen;   /* we just allocated */
         }
 }
 
 
 
-static inline void
-grabstackblock(int len)
+static inline void grabstackblock(int len)
 {
         len = ALIGN(len);
         stacknxt += len;
@@ -7914,9 +7856,10 @@ grabstackblock(int len)
  */
 
 
-static char *
-growstackstr(void) {
+static char *growstackstr(void)
+{
         int len = stackblocksize();
+
         if (herefd >= 0 && len >= 1024) {
                 xwrite(herefd, stackblock(), len);
                 sstrnleft = len - 1;
@@ -7932,9 +7875,10 @@ growstackstr(void) {
  * Called from CHECKSTRSPACE.
  */
 
-static char *
-makestrspace(size_t newlen) {
+static char *makestrspace(size_t newlen)
+{
         int len = stackblocksize() - sstrnleft;
+
         do {
                 growstackblock();
                 sstrnleft = stackblocksize() - len;
@@ -7944,13 +7888,13 @@ makestrspace(size_t newlen) {
 
 
 
-static void
-ungrabstackstr(char *s, char *p)
+static void ungrabstackstr(char *s, char *p)
 {
         stacknleft += stacknxt - s;
         stacknxt = s;
         sstrnleft = stacknleft - (p - s);
 }
+
 /*
  * Miscelaneous builtins.
  */
@@ -7971,8 +7915,7 @@ typedef long rlim_t;
  * This uses unbuffered input, which may be avoidable in some cases.
  */
 
-static int
-readcmd(int argc, char **argv)
+static int readcmd(int argc, char **argv)
 {
         char **ap;
         int backslash;
@@ -7994,7 +7937,7 @@ readcmd(int argc, char **argv)
                         rflag = 1;
         }
         if (prompt && isatty(0)) {
-                out2str(prompt);     /* read without cmdedit */
+                out2str(prompt);        /* read without cmdedit */
                 flushall();
         }
         if (*(ap = argptr) == NULL)
@@ -8056,8 +7999,7 @@ readcmd(int argc, char **argv)
 
 
 
-static int
-umaskcmd(int argc, char **argv)
+static int umaskcmd(int argc, char **argv)
 {
         static const char permuser[3] = "ugo";
         static const char permmode[3] = "rwx";
@@ -8085,12 +8027,14 @@ umaskcmd(int argc, char **argv)
                 if (symbolic_mode) {
                         char buf[18];
                         char *p = buf;
-                        for (i=0 ; i<3 ; i++) {
+
+                        for (i = 0; i < 3; i++) {
                                 int j;
+
                                 *p++ = permuser[i];
                                 *p++ = '=';
-                                for (j=0 ; j<3 ; j++) {
-                                        if ((mask & permmask[3*i+j]) == 0) {
+                                for (j = 0; j < 3; j++) {
+                                        if ((mask & permmask[3 * i + j]) == 0) {
                                                 *p++ = permmode[j];
                                         }
                                 }
@@ -8102,7 +8046,7 @@ umaskcmd(int argc, char **argv)
                         printf("%.4o\n", mask);
                 }
         } else {
-                if (is_digit((unsigned char)*ap)) {
+                if (is_digit((unsigned char) *ap)) {
                         mask = 0;
                         do {
                                 if (*ap >= '8' || *ap < '0')
@@ -8112,7 +8056,7 @@ umaskcmd(int argc, char **argv)
                         umask(mask);
                 } else {
                         mask = ~mask & 0777;
-                        if (! parse_mode(ap, &mask)) {
+                        if (!parse_mode(ap, &mask)) {
                                 error("Illegal mode: %s", ap);
                         }
                         umask(~mask & 0777);
@@ -8133,97 +8077,95 @@ umaskcmd(int argc, char **argv)
 
 struct limits {
         const char *name;
-        short   cmd;
-        short   factor; /* multiply by to get rlim_{cur,max} values */
+        short cmd;
+        short factor;           /* multiply by to get rlim_{cur,max} values */
 };
 
 static const struct limits limits[] = {
 #ifdef RLIMIT_CPU
-        { "time(seconds)",             RLIMIT_CPU,        1 },
+        {"time(seconds)", RLIMIT_CPU, 1},
 #endif
 #ifdef RLIMIT_FSIZE
-        { "file(blocks)",              RLIMIT_FSIZE,    512 },
+        {"file(blocks)", RLIMIT_FSIZE, 512},
 #endif
 #ifdef RLIMIT_DATA
-        { "data(kbytes)",              RLIMIT_DATA,    1024 },
+        {"data(kbytes)", RLIMIT_DATA, 1024},
 #endif
 #ifdef RLIMIT_STACK
-        { "stack(kbytes)",             RLIMIT_STACK,   1024 },
+        {"stack(kbytes)", RLIMIT_STACK, 1024},
 #endif
 #ifdef  RLIMIT_CORE
-        { "coredump(blocks)",          RLIMIT_CORE,     512 },
+        {"coredump(blocks)", RLIMIT_CORE, 512},
 #endif
 #ifdef RLIMIT_RSS
-        { "memory(kbytes)",            RLIMIT_RSS,     1024 },
+        {"memory(kbytes)", RLIMIT_RSS, 1024},
 #endif
 #ifdef RLIMIT_MEMLOCK
-        { "locked memory(kbytes)",     RLIMIT_MEMLOCK, 1024 },
+        {"locked memory(kbytes)", RLIMIT_MEMLOCK, 1024},
 #endif
 #ifdef RLIMIT_NPROC
-        { "process(processes)",        RLIMIT_NPROC,      1 },
+        {"process(processes)", RLIMIT_NPROC, 1},
 #endif
 #ifdef RLIMIT_NOFILE
-        { "nofiles(descriptors)",      RLIMIT_NOFILE,     1 },
+        {"nofiles(descriptors)", RLIMIT_NOFILE, 1},
 #endif
 #ifdef RLIMIT_VMEM
-        { "vmemory(kbytes)",           RLIMIT_VMEM,    1024 },
+        {"vmemory(kbytes)", RLIMIT_VMEM, 1024},
 #endif
 #ifdef RLIMIT_SWAP
-        { "swap(kbytes)",              RLIMIT_SWAP,    1024 },
+        {"swap(kbytes)", RLIMIT_SWAP, 1024},
 #endif
-        { NULL,                         0,                 0 }
+        {NULL, 0, 0}
 };
 
-static int
-ulimitcmd(int argc, char **argv)
+static int ulimitcmd(int argc, char **argv)
 {
         static const char unlimited_string[] = "unlimited";
-        int     c;
+        int c;
         rlim_t val = 0;
-        enum { SOFT = 0x1, HARD = 0x2 }
-                        how = SOFT | HARD;
-        const struct limits     *l;
-        int             set, all = 0;
-        int             optc, what;
-        struct rlimit   limit;
+        enum { SOFT = 0x1, HARD = 0x2 } how = SOFT | HARD;
+        const struct limits *l;
+        int set, all = 0;
+        int optc, what;
+        struct rlimit limit;
 
         what = 'f';
 
         while ((optc = nextopt("HSa"
 #ifdef RLIMIT_CPU
-        "t"
+                                                   "t"
 #endif
 #ifdef RLIMIT_FSIZE
-        "f"
+                                                   "f"
 #endif
 #ifdef RLIMIT_DATA
-        "d"
+                                                   "d"
 #endif
 #ifdef RLIMIT_STACK
-        "s"
+                                                   "s"
 #endif
 #ifdef  RLIMIT_CORE
-        "c"
+                                                   "c"
 #endif
 #ifdef RLIMIT_RSS
-        "m"
+                                                   "m"
 #endif
 #ifdef RLIMIT_MEMLOCK
-        "l"
+                                                   "l"
 #endif
 #ifdef RLIMIT_NPROC
-        "p"
+                                                   "p"
 #endif
 #ifdef RLIMIT_NOFILE
-        "n"
+                                                   "n"
 #endif
 #ifdef RLIMIT_VMEM
-        "v"
+                                                   "v"
 #endif
 #ifdef RLIMIT_SWAP
-        "w"
+                                                   "w"
 #endif
-                                        )) != '\0') {
+                        )) != '\0') {
                 if (optc == 'H') {
                         how = HARD;
                 } else if (optc == 'S') {
@@ -8236,9 +8178,9 @@ ulimitcmd(int argc, char **argv)
         }
 
         for (l = limits; l->name; l++) {
-                if(l->name[0] == what)
+                if (l->name[0] == what)
                         break;
-                if(l->name[1]=='w' && what=='w')
+                if (l->name[1] == 'w' && what == 'w')
                         break;
         }
 
@@ -8253,9 +8195,8 @@ ulimitcmd(int argc, char **argv)
                 else {
                         val = (rlim_t) 0;
 
-                        while ((c = *p++) >= '0' && c <= '9')
-                        {
-                                val = (val * 10) + (long)(c - '0');
+                        while ((c = *p++) >= '0' && c <= '9') {
+                                val = (val * 10) + (long) (c - '0');
                                 if (val < (rlim_t) 0)
                                         break;
                         }
@@ -8269,7 +8210,7 @@ ulimitcmd(int argc, char **argv)
                 for (l = limits; l->name; l++) {
                         printf("%-20s ", l->name);
                         getrlimit(l->cmd, &limit);
-                OUTPUT_LIMIT:
+                  OUTPUT_LIMIT:
                         if (how & SOFT)
                                 val = limit.rlim_cur;
                         else if (how & HARD)
@@ -8277,8 +8218,7 @@ ulimitcmd(int argc, char **argv)
 
                         if (val == RLIM_INFINITY)
                                 puts(unlimited_string);
-                        else
-                        {
+                        else {
                                 val /= l->factor;
                                 printf("%lld\n", (long long) val);
                         }
@@ -8302,12 +8242,12 @@ ulimitcmd(int argc, char **argv)
                 error("error setting limit (%m)");
         return 0;
 }
+
 /*
  * prefix -- see if pfx is a prefix of string.
  */
 
-static int
-prefix(char const *pfx, char const *string)
+static int prefix(char const *pfx, char const *string)
 {
         while (*pfx) {
                 if (*pfx++ != *string++)
@@ -8321,13 +8261,12 @@ prefix(char const *pfx, char const *string)
  * nagative is bad
  */
 
-static int
-is_number(const char *p, int *intptr)
+static int is_number(const char *p, int *intptr)
 {
         int ret = 0;
 
         do {
-                if (! is_digit(*p))
+                if (!is_digit(*p))
                         return 0;
                 ret *= 10;
                 ret += digit_val(*p);
@@ -8343,11 +8282,11 @@ is_number(const char *p, int *intptr)
  * failure.
  */
 
-static int
-number(const char *s)
+static int number(const char *s)
 {
         int i;
-        if (! is_number(s, &i))
+
+        if (!is_number(s, &i))
                 error("Illegal number: %s", s);
         return i;
 }
@@ -8357,8 +8296,7 @@ number(const char *s)
  * The return string is allocated on the stack.
  */
 
-static char *
-single_quote(const char *s)
+static char *single_quote(const char *s)
 {
         char *p;
 
@@ -8408,10 +8346,10 @@ single_quote(const char *s)
  * Like strdup but works with the ash stack.
  */
 
-static char *
-sstrdup(const char *p)
+static char *sstrdup(const char *p)
 {
         size_t len = strlen(p) + 1;
+
         return memcpy(stalloc(len), p, len);
 }
 
@@ -8421,9 +8359,9 @@ sstrdup(const char *p)
  */
 
 
-static void sizenodelist (const struct nodelist *);
-static struct nodelist *copynodelist (const struct nodelist *);
-static char *nodexstrdup (const char *);
+static void sizenodelist(const struct nodelist *);
+static struct nodelist *copynodelist(const struct nodelist *);
+static char *nodexstrdup(const char *);
 
 #define CALCSIZE_TABLE
 #define COPYNODE_TABLE
@@ -8451,59 +8389,59 @@ static char *nodexstrdup (const char *);
 #define NODE_INTEGER    0x40
 #define NODE_NODELIST   0x80
 #define NODE_CHARPTR    0xC0
-#define NODE_NOMORE             0x01    /* Note: no offset should be odd (aligned)*/
+#define NODE_NOMORE             0x01    /* Note: no offset should be odd (aligned) */
 #define NODE_MBRMASK    0xC0
 #define NODE_OFFSETMASK 0x3E
 
 static const unsigned char copynode_ops[35] = {
 #define COPYNODE_OPS0   0
         offsetof(union node, nbinary.ch2),
-        offsetof(union node, nbinary.ch1)|NODE_NOMORE,
+        offsetof(union node, nbinary.ch1) | NODE_NOMORE,
 #define COPYNODE_OPS1   (COPYNODE_OPS0 + 2)
         offsetof(union node, ncmd.redirect),
         offsetof(union node, ncmd.args),
         offsetof(union node, ncmd.assign),
-        offsetof(union node, ncmd.backgnd)|NODE_INTEGER|NODE_NOMORE,
+        offsetof(union node, ncmd.backgnd) | NODE_INTEGER | NODE_NOMORE,
 #define COPYNODE_OPS2   (COPYNODE_OPS1 + 4)
-        offsetof(union node, npipe.cmdlist)|NODE_NODELIST,
-        offsetof(union node, npipe.backgnd)|NODE_INTEGER|NODE_NOMORE,
+        offsetof(union node, npipe.cmdlist) | NODE_NODELIST,
+        offsetof(union node, npipe.backgnd) | NODE_INTEGER | NODE_NOMORE,
 #define COPYNODE_OPS3   (COPYNODE_OPS2 + 2)
         offsetof(union node, nredir.redirect),
-        offsetof(union node, nredir.n)|NODE_NOMORE,
+        offsetof(union node, nredir.n) | NODE_NOMORE,
 #define COPYNODE_OPS4   (COPYNODE_OPS3 + 2)
         offsetof(union node, nif.elsepart),
         offsetof(union node, nif.ifpart),
-        offsetof(union node, nif.test)|NODE_NOMORE,
+        offsetof(union node, nif.test) | NODE_NOMORE,
 #define COPYNODE_OPS5   (COPYNODE_OPS4 + 3)
-        offsetof(union node, nfor.var)|NODE_CHARPTR,
+        offsetof(union node, nfor.var) | NODE_CHARPTR,
         offsetof(union node, nfor.body),
-        offsetof(union node, nfor.args)|NODE_NOMORE,
+        offsetof(union node, nfor.args) | NODE_NOMORE,
 #define COPYNODE_OPS6   (COPYNODE_OPS5 + 3)
         offsetof(union node, ncase.cases),
-        offsetof(union node, ncase.expr)|NODE_NOMORE,
+        offsetof(union node, ncase.expr) | NODE_NOMORE,
 #define COPYNODE_OPS7   (COPYNODE_OPS6 + 2)
         offsetof(union node, nclist.body),
         offsetof(union node, nclist.pattern),
-        offsetof(union node, nclist.next)|NODE_NOMORE,
+        offsetof(union node, nclist.next) | NODE_NOMORE,
 #define COPYNODE_OPS8   (COPYNODE_OPS7 + 3)
-        offsetof(union node, narg.backquote)|NODE_NODELIST,
-        offsetof(union node, narg.text)|NODE_CHARPTR,
-        offsetof(union node, narg.next)|NODE_NOMORE,
+        offsetof(union node, narg.backquote) | NODE_NODELIST,
+        offsetof(union node, narg.text) | NODE_CHARPTR,
+        offsetof(union node, narg.next) | NODE_NOMORE,
 #define COPYNODE_OPS9   (COPYNODE_OPS8 + 3)
         offsetof(union node, nfile.fname),
-        offsetof(union node, nfile.fd)|NODE_INTEGER,
-        offsetof(union node, nfile.next)|NODE_NOMORE,
+        offsetof(union node, nfile.fd) | NODE_INTEGER,
+        offsetof(union node, nfile.next) | NODE_NOMORE,
 #define COPYNODE_OPS10   (COPYNODE_OPS9 + 3)
         offsetof(union node, ndup.vname),
-        offsetof(union node, ndup.dupfd)|NODE_INTEGER,
-        offsetof(union node, ndup.fd)|NODE_INTEGER,
-        offsetof(union node, ndup.next)|NODE_NOMORE,
+        offsetof(union node, ndup.dupfd) | NODE_INTEGER,
+        offsetof(union node, ndup.fd) | NODE_INTEGER,
+        offsetof(union node, ndup.next) | NODE_NOMORE,
 #define COPYNODE_OPS11   (COPYNODE_OPS10 + 4)
         offsetof(union node, nhere.doc),
-        offsetof(union node, nhere.fd)|NODE_INTEGER,
-        offsetof(union node, nhere.next)|NODE_NOMORE,
+        offsetof(union node, nhere.fd) | NODE_INTEGER,
+        offsetof(union node, nhere.next) | NODE_NOMORE,
 #define COPYNODE_OPS12   (COPYNODE_OPS11 + 3)
-        offsetof(union node, nnot.com)|NODE_NOMORE,
+        offsetof(union node, nnot.com) | NODE_NOMORE,
 };
 
 #if COPYNODE_OPS12 != 34
@@ -8511,266 +8449,261 @@ static const unsigned char copynode_ops[35] = {
 #endif
 
 static const unsigned char copynode_ops_index[26] = {
-        COPYNODE_OPS0, /* NSEMI */
-        COPYNODE_OPS1, /* NCMD */
-        COPYNODE_OPS2, /* NPIPE */
-        COPYNODE_OPS3, /* NREDIR */
-        COPYNODE_OPS3, /* NBACKGND */
-        COPYNODE_OPS3, /* NSUBSHELL */
-        COPYNODE_OPS0, /* NAND */
-        COPYNODE_OPS0, /* NOR */
-        COPYNODE_OPS4, /* NIF */
-        COPYNODE_OPS0, /* NWHILE */
-        COPYNODE_OPS0, /* NUNTIL */
-        COPYNODE_OPS5, /* NFOR */
-        COPYNODE_OPS6, /* NCASE */
-        COPYNODE_OPS7, /* NCLIST */
-        COPYNODE_OPS8, /* NDEFUN */
-        COPYNODE_OPS8, /* NARG */
-        COPYNODE_OPS9, /* NTO */
-        COPYNODE_OPS9, /* NFROM */
-        COPYNODE_OPS9, /* NFROMTO */
-        COPYNODE_OPS9, /* NAPPEND */
-        COPYNODE_OPS9, /* NTOOV */
-        COPYNODE_OPS10, /* NTOFD */
-        COPYNODE_OPS10, /* NFROMFD */
-        COPYNODE_OPS11, /* NHERE */
-        COPYNODE_OPS11, /* NXHERE */
-        COPYNODE_OPS12, /* NNOT */
+        COPYNODE_OPS0,          /* NSEMI */
+        COPYNODE_OPS1,          /* NCMD */
+        COPYNODE_OPS2,          /* NPIPE */
+        COPYNODE_OPS3,          /* NREDIR */
+        COPYNODE_OPS3,          /* NBACKGND */
+        COPYNODE_OPS3,          /* NSUBSHELL */
+        COPYNODE_OPS0,          /* NAND */
+        COPYNODE_OPS0,          /* NOR */
+        COPYNODE_OPS4,          /* NIF */
+        COPYNODE_OPS0,          /* NWHILE */
+        COPYNODE_OPS0,          /* NUNTIL */
+        COPYNODE_OPS5,          /* NFOR */
+        COPYNODE_OPS6,          /* NCASE */
+        COPYNODE_OPS7,          /* NCLIST */
+        COPYNODE_OPS8,          /* NDEFUN */
+        COPYNODE_OPS8,          /* NARG */
+        COPYNODE_OPS9,          /* NTO */
+        COPYNODE_OPS9,          /* NFROM */
+        COPYNODE_OPS9,          /* NFROMTO */
+        COPYNODE_OPS9,          /* NAPPEND */
+        COPYNODE_OPS9,          /* NTOOV */
+        COPYNODE_OPS10,         /* NTOFD */
+        COPYNODE_OPS10,         /* NFROMFD */
+        COPYNODE_OPS11,         /* NHERE */
+        COPYNODE_OPS11,         /* NXHERE */
+        COPYNODE_OPS12,         /* NNOT */
 };
 
 #if NODE_CHARPTR != NODE_MBRMASK
 #error NODE_CHARPTR != NODE_MBRMASK!!!
 #endif
-#endif /* defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) */
+#endif                                                  /* defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) */
 
 #ifdef COPYNODE_TABLE
-static union node *
-copynode(const union node *n)
-{
-      union node *new;
-          const unsigned char *p;
-
-      if (n == NULL) {
-          return NULL;
-          }
-      new = funcblock;
-      new->type = n->type;
-      funcblock = (char *) funcblock + (int) nodesize[n->type];
-          p = copynode_ops + (int) copynode_ops_index[n->type];
-          do {
-                  char *nn = ((char *) new) + ((int)(*p & NODE_OFFSETMASK));
-                  const char *no = ((const char *) n) + ((int)(*p & NODE_OFFSETMASK));
-
-                  if (!(*p & NODE_MBRMASK)) { /* standard node */
-                          *((union node **)nn) = copynode(*((const union node **) no));
-                  } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
-                          *((const char **)nn) = nodexstrdup(*((const char **)no));
-                  } else if (*p & NODE_NODELIST) { /* nodelist */
-                          *((struct nodelist **)nn)
-                                  = copynodelist(*((const struct nodelist **) no));
-                  } else {                              /* integer */
-                          *((int *) nn) = *((int *) no);
-                  }
-          } while (!(*p++ & NODE_NOMORE));
-      return new;
-}
-#else  /* COPYNODE_TABLE */
-static union node *
-copynode(const union node *n)
-{
-      union node *new;
-
-      if (n == NULL)
-        return NULL;
-      new = funcblock;
-      funcblock = (char *) funcblock + nodesize[n->type];
-      switch (n->type) {
-      case NSEMI:
-      case NAND:
-      case NOR:
-      case NWHILE:
-      case NUNTIL:
-            new->nbinary.ch2 = copynode(n->nbinary.ch2);
-            new->nbinary.ch1 = copynode(n->nbinary.ch1);
-            break;
-      case NCMD:
-            new->ncmd.redirect = copynode(n->ncmd.redirect);
-            new->ncmd.args = copynode(n->ncmd.args);
-            new->ncmd.assign = copynode(n->ncmd.assign);
-            new->ncmd.backgnd = n->ncmd.backgnd;
-            break;
-      case NPIPE:
-            new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
-            new->npipe.backgnd = n->npipe.backgnd;
-            break;
-      case NREDIR:
-      case NBACKGND:
-      case NSUBSHELL:
-            new->nredir.redirect = copynode(n->nredir.redirect);
-            new->nredir.n = copynode(n->nredir.n);
-            break;
-      case NIF:
-            new->nif.elsepart = copynode(n->nif.elsepart);
-            new->nif.ifpart = copynode(n->nif.ifpart);
-            new->nif.test = copynode(n->nif.test);
-            break;
-      case NFOR:
-            new->nfor.var = nodexstrdup(n->nfor.var);
-            new->nfor.body = copynode(n->nfor.body);
-            new->nfor.args = copynode(n->nfor.args);
-            break;
-      case NCASE:
-            new->ncase.cases = copynode(n->ncase.cases);
-            new->ncase.expr = copynode(n->ncase.expr);
-            break;
-      case NCLIST:
-            new->nclist.body = copynode(n->nclist.body);
-            new->nclist.pattern = copynode(n->nclist.pattern);
-            new->nclist.next = copynode(n->nclist.next);
-            break;
-      case NDEFUN:
-      case NARG:
-            new->narg.backquote = copynodelist(n->narg.backquote);
-            new->narg.text = nodexstrdup(n->narg.text);
-            new->narg.next = copynode(n->narg.next);
-            break;
-      case NTO:
-      case NFROM:
-      case NFROMTO:
-      case NAPPEND:
-      case NTOOV:
-            new->nfile.fname = copynode(n->nfile.fname);
-            new->nfile.fd = n->nfile.fd;
-            new->nfile.next = copynode(n->nfile.next);
-            break;
-      case NTOFD:
-      case NFROMFD:
-            new->ndup.vname = copynode(n->ndup.vname);
-            new->ndup.dupfd = n->ndup.dupfd;
-            new->ndup.fd = n->ndup.fd;
-            new->ndup.next = copynode(n->ndup.next);
-            break;
-      case NHERE:
-      case NXHERE:
-            new->nhere.doc = copynode(n->nhere.doc);
-            new->nhere.fd = n->nhere.fd;
-            new->nhere.next = copynode(n->nhere.next);
-            break;
-      case NNOT:
-            new->nnot.com = copynode(n->nnot.com);
-            break;
-      };
-      new->type = n->type;
-      return new;
-}
-#endif /* COPYNODE_TABLE */
+static union node *copynode(const union node *n)
+{
+        union node *new;
+        const unsigned char *p;
+
+        if (n == NULL) {
+                return NULL;
+        }
+        new = funcblock;
+        new->type = n->type;
+        funcblock = (char *) funcblock + (int) nodesize[n->type];
+        p = copynode_ops + (int) copynode_ops_index[n->type];
+        do {
+                char *nn = ((char *) new) + ((int) (*p & NODE_OFFSETMASK));
+                const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
+
+                if (!(*p & NODE_MBRMASK)) {     /* standard node */
+                        *((union node **) nn) = copynode(*((const union node **) no));
+                } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) {       /* string */
+                        *((const char **) nn) = nodexstrdup(*((const char **) no));
+                } else if (*p & NODE_NODELIST) {        /* nodelist */
+                        *((struct nodelist **) nn)
+                                = copynodelist(*((const struct nodelist **) no));
+                } else {                /* integer */
+                        *((int *) nn) = *((int *) no);
+                }
+        } while (!(*p++ & NODE_NOMORE));
+        return new;
+}
+#else                                                   /* COPYNODE_TABLE */
+static union node *copynode(const union node *n)
+{
+        union node *new;
+
+        if (n == NULL)
+                return NULL;
+        new = funcblock;
+        funcblock = (char *) funcblock + nodesize[n->type];
+        switch (n->type) {
+        case NSEMI:
+        case NAND:
+        case NOR:
+        case NWHILE:
+        case NUNTIL:
+                new->nbinary.ch2 = copynode(n->nbinary.ch2);
+                new->nbinary.ch1 = copynode(n->nbinary.ch1);
+                break;
+        case NCMD:
+                new->ncmd.redirect = copynode(n->ncmd.redirect);
+                new->ncmd.args = copynode(n->ncmd.args);
+                new->ncmd.assign = copynode(n->ncmd.assign);
+                new->ncmd.backgnd = n->ncmd.backgnd;
+                break;
+        case NPIPE:
+                new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
+                new->npipe.backgnd = n->npipe.backgnd;
+                break;
+        case NREDIR:
+        case NBACKGND:
+        case NSUBSHELL:
+                new->nredir.redirect = copynode(n->nredir.redirect);
+                new->nredir.n = copynode(n->nredir.n);
+                break;
+        case NIF:
+                new->nif.elsepart = copynode(n->nif.elsepart);
+                new->nif.ifpart = copynode(n->nif.ifpart);
+                new->nif.test = copynode(n->nif.test);
+                break;
+        case NFOR:
+                new->nfor.var = nodexstrdup(n->nfor.var);
+                new->nfor.body = copynode(n->nfor.body);
+                new->nfor.args = copynode(n->nfor.args);
+                break;
+        case NCASE:
+                new->ncase.cases = copynode(n->ncase.cases);
+                new->ncase.expr = copynode(n->ncase.expr);
+                break;
+        case NCLIST:
+                new->nclist.body = copynode(n->nclist.body);
+                new->nclist.pattern = copynode(n->nclist.pattern);
+                new->nclist.next = copynode(n->nclist.next);
+                break;
+        case NDEFUN:
+        case NARG:
+                new->narg.backquote = copynodelist(n->narg.backquote);
+                new->narg.text = nodexstrdup(n->narg.text);
+                new->narg.next = copynode(n->narg.next);
+                break;
+        case NTO:
+        case NFROM:
+        case NFROMTO:
+        case NAPPEND:
+        case NTOOV:
+                new->nfile.fname = copynode(n->nfile.fname);
+                new->nfile.fd = n->nfile.fd;
+                new->nfile.next = copynode(n->nfile.next);
+                break;
+        case NTOFD:
+        case NFROMFD:
+                new->ndup.vname = copynode(n->ndup.vname);
+                new->ndup.dupfd = n->ndup.dupfd;
+                new->ndup.fd = n->ndup.fd;
+                new->ndup.next = copynode(n->ndup.next);
+                break;
+        case NHERE:
+        case NXHERE:
+                new->nhere.doc = copynode(n->nhere.doc);
+                new->nhere.fd = n->nhere.fd;
+                new->nhere.next = copynode(n->nhere.next);
+                break;
+        case NNOT:
+                new->nnot.com = copynode(n->nnot.com);
+                break;
+        };
+        new->type = n->type;
+        return new;
+}
+#endif                                                  /* COPYNODE_TABLE */
 
 #ifdef CALCSIZE_TABLE
-static void
-calcsize(const union node *n)
+static void calcsize(const union node *n)
 {
-          const unsigned char *p;
+        const unsigned char *p;
 
-      if (n == NULL)
-            return;
-      funcblocksize += (int) nodesize[n->type];
+        if (n == NULL)
+                return;
+        funcblocksize += (int) nodesize[n->type];
 
-          p = copynode_ops + (int) copynode_ops_index[n->type];
-          do {
-                  const char *no = ((const char *) n) + ((int)(*p & NODE_OFFSETMASK));
+        p = copynode_ops + (int) copynode_ops_index[n->type];
+        do {
+                const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
 
-                  if (!(*p & NODE_MBRMASK)) { /* standard node */
-                          calcsize(*((const union node **) no));
-                  } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
-                          funcstringsize += strlen(*((const char **)no)) + 1;
-                  } else if (*p & NODE_NODELIST) { /* nodelist */
-                          sizenodelist(*((const struct nodelist **) no));
-                  }     /* else integer -- ignore */
-          } while (!(*p++ & NODE_NOMORE));
+                if (!(*p & NODE_MBRMASK)) {     /* standard node */
+                        calcsize(*((const union node **) no));
+                } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) {       /* string */
+                        funcstringsize += strlen(*((const char **) no)) + 1;
+                } else if (*p & NODE_NODELIST) {        /* nodelist */
+                        sizenodelist(*((const struct nodelist **) no));
+                }                               /* else integer -- ignore */
+        } while (!(*p++ & NODE_NOMORE));
 }
-#else  /* CALCSIZE_TABLE */
-static void
-calcsize(const union node *n)
-{
-      if (n == NULL)
-            return;
-      funcblocksize += nodesize[n->type];
-      switch (n->type) {
-      case NSEMI:
-      case NAND:
-      case NOR:
-      case NWHILE:
-      case NUNTIL:
-            calcsize(n->nbinary.ch2);
-            calcsize(n->nbinary.ch1);
-            break;
-      case NCMD:
-            calcsize(n->ncmd.redirect);
-            calcsize(n->ncmd.args);
-            calcsize(n->ncmd.assign);
-            break;
-      case NPIPE:
-            sizenodelist(n->npipe.cmdlist);
-            break;
-      case NREDIR:
-      case NBACKGND:
-      case NSUBSHELL:
-            calcsize(n->nredir.redirect);
-            calcsize(n->nredir.n);
-            break;
-      case NIF:
-            calcsize(n->nif.elsepart);
-            calcsize(n->nif.ifpart);
-            calcsize(n->nif.test);
-            break;
-      case NFOR:
-            funcstringsize += strlen(n->nfor.var) + 1;
-            calcsize(n->nfor.body);
-            calcsize(n->nfor.args);
-            break;
-      case NCASE:
-            calcsize(n->ncase.cases);
-            calcsize(n->ncase.expr);
-            break;
-      case NCLIST:
-            calcsize(n->nclist.body);
-            calcsize(n->nclist.pattern);
-            calcsize(n->nclist.next);
-            break;
-      case NDEFUN:
-      case NARG:
-            sizenodelist(n->narg.backquote);
-            funcstringsize += strlen(n->narg.text) + 1;
-            calcsize(n->narg.next);
-            break;
-      case NTO:
-      case NFROM:
-      case NFROMTO:
-      case NAPPEND:
-      case NTOOV:
-            calcsize(n->nfile.fname);
-            calcsize(n->nfile.next);
-            break;
-      case NTOFD:
-      case NFROMFD:
-            calcsize(n->ndup.vname);
-            calcsize(n->ndup.next);
-            break;
-      case NHERE:
-      case NXHERE:
-            calcsize(n->nhere.doc);
-            calcsize(n->nhere.next);
-            break;
-      case NNOT:
-            calcsize(n->nnot.com);
-            break;
-      };
-}
-#endif /* CALCSIZE_TABLE */
+#else                                                   /* CALCSIZE_TABLE */
+static void calcsize(const union node *n)
+{
+        if (n == NULL)
+                return;
+        funcblocksize += nodesize[n->type];
+        switch (n->type) {
+        case NSEMI:
+        case NAND:
+        case NOR:
+        case NWHILE:
+        case NUNTIL:
+                calcsize(n->nbinary.ch2);
+                calcsize(n->nbinary.ch1);
+                break;
+        case NCMD:
+                calcsize(n->ncmd.redirect);
+                calcsize(n->ncmd.args);
+                calcsize(n->ncmd.assign);
+                break;
+        case NPIPE:
+                sizenodelist(n->npipe.cmdlist);
+                break;
+        case NREDIR:
+        case NBACKGND:
+        case NSUBSHELL:
+                calcsize(n->nredir.redirect);
+                calcsize(n->nredir.n);
+                break;
+        case NIF:
+                calcsize(n->nif.elsepart);
+                calcsize(n->nif.ifpart);
+                calcsize(n->nif.test);
+                break;
+        case NFOR:
+                funcstringsize += strlen(n->nfor.var) + 1;
+                calcsize(n->nfor.body);
+                calcsize(n->nfor.args);
+                break;
+        case NCASE:
+                calcsize(n->ncase.cases);
+                calcsize(n->ncase.expr);
+                break;
+        case NCLIST:
+                calcsize(n->nclist.body);
+                calcsize(n->nclist.pattern);
+                calcsize(n->nclist.next);
+                break;
+        case NDEFUN:
+        case NARG:
+                sizenodelist(n->narg.backquote);
+                funcstringsize += strlen(n->narg.text) + 1;
+                calcsize(n->narg.next);
+                break;
+        case NTO:
+        case NFROM:
+        case NFROMTO:
+        case NAPPEND:
+        case NTOOV:
+                calcsize(n->nfile.fname);
+                calcsize(n->nfile.next);
+                break;
+        case NTOFD:
+        case NFROMFD:
+                calcsize(n->ndup.vname);
+                calcsize(n->ndup.next);
+                break;
+        case NHERE:
+        case NXHERE:
+                calcsize(n->nhere.doc);
+                calcsize(n->nhere.next);
+                break;
+        case NNOT:
+                calcsize(n->nnot.com);
+                break;
+        };
+}
+#endif                                                  /* CALCSIZE_TABLE */
 
-static void
-sizenodelist(const struct nodelist *lp)
+static void sizenodelist(const struct nodelist *lp)
 {
         while (lp) {
                 funcblocksize += ALIGN(sizeof(struct nodelist));
@@ -8780,8 +8713,7 @@ sizenodelist(const struct nodelist *lp)
 }
 
 
-static struct nodelist *
-copynodelist(const struct nodelist *lp)
+static struct nodelist *copynodelist(const struct nodelist *lp)
 {
         struct nodelist *start;
         struct nodelist **lpp;
@@ -8799,12 +8731,11 @@ copynodelist(const struct nodelist *lp)
 }
 
 
-static char *
-nodexstrdup(const char *s)
+static char *nodexstrdup(const char *s)
 {
         const char *p = s;
         char *q = funcstring;
-        char   *rtn = funcstring;
+        char *rtn = funcstring;
 
         while ((*q++ = *p++) != '\0')
                 continue;
@@ -8813,15 +8744,14 @@ nodexstrdup(const char *s)
 }
 
 #ifdef CONFIG_ASH_GETOPTS
-static int getopts (char *, char *, char **, int *, int *);
+static int getopts(char *, char *, char **, int *, int *);
 #endif
 
 /*
  * Process the shell command line arguments.
  */
 
-static void
-procargs(int argc, char **argv)
+static void procargs(int argc, char **argv)
 {
         int i;
 
@@ -8869,8 +8799,7 @@ procargs(int argc, char **argv)
  * to the argument list; we advance it past the options.
  */
 
-static inline void
-minus_o(const char *name, int val)
+static inline void minus_o(const char *name, int val)
 {
         int i;
 
@@ -8878,7 +8807,7 @@ minus_o(const char *name, int val)
                 out1str("Current option settings\n");
                 for (i = 0; i < NOPTS; i++)
                         printf("%-16s%s\n", optent_name(optlist[i]),
-                                optent_val(i) ? "on" : "off");
+                                   optent_val(i) ? "on" : "off");
         } else {
                 for (i = 0; i < NOPTS; i++)
                         if (equal(name, optent_name(optlist[i]))) {
@@ -8890,8 +8819,7 @@ minus_o(const char *name, int val)
 }
 
 
-static void
-options(int cmdline)
+static void options(int cmdline)
 {
         char *p;
         int val;
@@ -8912,7 +8840,7 @@ options(int cmdline)
                                         else if (*argptr == NULL)
                                                 setparam(argptr);
                                 }
-                                break;    /* "-" or  "--" terminates options */
+                                break;  /* "-" or  "--" terminates options */
                         }
                 } else if (c == '+') {
                         val = 0;
@@ -8923,7 +8851,8 @@ options(int cmdline)
                 while ((c = *p++) != '\0') {
                         if (c == 'c' && cmdline) {
                                 char *q;
-#ifdef NOHACK   /* removing this code allows sh -ce 'foo' for compat */
+
+#ifdef NOHACK                   /* removing this code allows sh -ce 'foo' for compat */
                                 if (*p == '\0')
 #endif
                                         q = *argptr++;
@@ -8937,8 +8866,8 @@ options(int cmdline)
                                 minus_o(*argptr, val);
                                 if (*argptr)
                                         argptr++;
-                        } else if (cmdline && (c == '-')) { // long options
-                                if ( strcmp ( p, "login" ) == 0 )
+                        } else if (cmdline && (c == '-')) {     /* long options */
+                                if (strcmp(p, "login") == 0)
                                         isloginsh = 1;
                                 break;
                         } else {
@@ -8949,8 +8878,7 @@ options(int cmdline)
 }
 
 
-static void
-setoption(int flag, int val)
+static void setoption(int flag, int val)
 {
         int i;
 
@@ -8976,14 +8904,13 @@ setoption(int flag, int val)
  * Set the shell parameters.
  */
 
-static void
-setparam(char **argv)
+static void setparam(char **argv)
 {
         char **newparam;
         char **ap;
         int nparam;
 
-        for (nparam = 0 ; argv[nparam] ; nparam++);
+        for (nparam = 0; argv[nparam]; nparam++);
         ap = newparam = xmalloc((nparam + 1) * sizeof *ap);
         while (*argv) {
                 *ap++ = xstrdup(*argv++);
@@ -9002,13 +8929,12 @@ setparam(char **argv)
  * Free the list of positional parameters.
  */
 
-static void
-freeparam(volatile struct shparam *param)
+static void freeparam(volatile struct shparam *param)
 {
         char **ap;
 
         if (param->malloc) {
-                for (ap = param->p ; *ap ; ap++)
+                for (ap = param->p; *ap; ap++)
                         free(*ap);
                 free(param->p);
         }
@@ -9020,8 +8946,7 @@ freeparam(volatile struct shparam *param)
  * The shift builtin command.
  */
 
-static int
-shiftcmd(int argc, char **argv)
+static int shiftcmd(int argc, char **argv)
 {
         int n;
         char **ap1, **ap2;
@@ -9033,7 +8958,7 @@ shiftcmd(int argc, char **argv)
                 error("can't shift that many");
         INTOFF;
         shellparam.nparam -= n;
-        for (ap1 = shellparam.p ; --n >= 0 ; ap1++) {
+        for (ap1 = shellparam.p; --n >= 0; ap1++) {
                 if (shellparam.malloc)
                         free(*ap1);
         }
@@ -9051,8 +8976,7 @@ shiftcmd(int argc, char **argv)
  * The set command builtin.
  */
 
-static int
-setcmd(int argc, char **argv)
+static int setcmd(int argc, char **argv)
 {
         if (argc == 1)
                 return showvarscmd(argc, argv);
@@ -9067,8 +8991,7 @@ setcmd(int argc, char **argv)
 }
 
 
-static void
-getoptsreset(const char *value)
+static void getoptsreset(const char *value)
 {
         shellparam.optind = number(value);
         shellparam.optoff = -1;
@@ -9077,13 +9000,13 @@ getoptsreset(const char *value)
 #ifdef CONFIG_LOCALE_SUPPORT
 static void change_lc_all(const char *value)
 {
-        if(value != 0 && *value != 0)
+        if (value != 0 && *value != 0)
                 setlocale(LC_ALL, value);
 }
 
 static void change_lc_ctype(const char *value)
 {
-        if(value != 0 && *value != 0)
+        if (value != 0 && *value != 0)
                 setlocale(LC_CTYPE, value);
 }
 
@@ -9097,8 +9020,7 @@ static void change_lc_ctype(const char *value)
  * then it's the first time getopts has been called.
  */
 
-static int
-getoptscmd(int argc, char **argv)
+static int getoptscmd(int argc, char **argv)
 {
         char **optbase;
 
@@ -9110,8 +9032,7 @@ getoptscmd(int argc, char **argv)
                         shellparam.optind = 1;
                         shellparam.optoff = -1;
                 }
-        }
-        else {
+        } else {
                 optbase = &argv[3];
                 if (shellparam.optind > argc - 2) {
                         shellparam.optind = 1;
@@ -9120,19 +9041,19 @@ getoptscmd(int argc, char **argv)
         }
 
         return getopts(argv[1], argv[2], optbase, &shellparam.optind,
-                       &shellparam.optoff);
+                                   &shellparam.optoff);
 }
 
 /*
  * Safe version of setvar, returns 1 on success 0 on failure.
  */
 
-static int
-setvarsafe(const char *name, const char *val, int flags)
+static int setvarsafe(const char *name, const char *val, int flags)
 {
         struct jmploc jmploc;
         struct jmploc *volatile savehandler = handler;
         int err = 0;
+
 #ifdef __GNUC__
         (void) &err;
 #endif
@@ -9148,7 +9069,8 @@ setvarsafe(const char *name, const char *val, int flags)
 }
 
 static int
-getopts(char *optstr, char *optvar, char **optfirst, int *myoptind, int *optoff)
+getopts(char *optstr, char *optvar, char **optfirst, int *myoptind,
+                int *optoff)
 {
         char *p, *q;
         char c = '?';
@@ -9158,7 +9080,7 @@ getopts(char *optstr, char *optvar, char **optfirst, int *myoptind, int *optoff)
         char **optnext = optfirst + *myoptind - 1;
 
         if (*myoptind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
-            strlen(*(optnext - 1)) < *optoff)
+                strlen(*(optnext - 1)) < *optoff)
                 p = NULL;
         else
                 p = *(optnext - 1) + *optoff;
@@ -9168,26 +9090,25 @@ getopts(char *optstr, char *optvar, char **optfirst, int *myoptind, int *optoff)
                         return 1;
                 p = *optnext;
                 if (p == NULL || *p != '-' || *++p == '\0') {
-atend:
+                  atend:
                         *myoptind = optnext - optfirst + 1;
                         p = NULL;
                         done = 1;
                         goto out;
                 }
                 optnext++;
-                if (p[0] == '-' && p[1] == '\0')        /* check for "--" */
+                if (p[0] == '-' && p[1] == '\0')        /* check for "--" */
                         goto atend;
         }
 
         c = *p++;
-        for (q = optstr; *q != c; ) {
+        for (q = optstr; *q != c;) {
                 if (*q == '\0') {
                         if (optstr[0] == ':') {
                                 s[0] = c;
                                 s[1] = '\0';
                                 err |= setvarsafe("OPTARG", s, 0);
-                        }
-                        else {
+                        } else {
                                 out2fmt("Illegal option -%c\n", c);
                                 (void) unsetvar("OPTARG");
                         }
@@ -9205,8 +9126,7 @@ atend:
                                 s[1] = '\0';
                                 err |= setvarsafe("OPTARG", s, 0);
                                 c = ':';
-                        }
-                        else {
+                        } else {
                                 out2fmt("No arg for -%c option\n", c);
                                 (void) unsetvar("OPTARG");
                                 c = '?';
@@ -9218,16 +9138,15 @@ atend:
                         optnext++;
                 setvarsafe("OPTARG", p, 0);
                 p = NULL;
-        }
-        else
+        } else
                 setvarsafe("OPTARG", "", 0);
         *myoptind = optnext - optfirst + 1;
         goto out;
 
-bad:
+  bad:
         *myoptind = 1;
         p = NULL;
-out:
+  out:
         *optoff = p ? p - *(optnext - 1) : -1;
         snprintf(s, sizeof(s), "%d", *myoptind);
         err |= setvarsafe("OPTIND", s, VNOFUNC);
@@ -9254,8 +9173,7 @@ out:
  * end of input.
  */
 
-static int
-nextopt(const char *optstring)
+static int nextopt(const char *optstring)
 {
         char *p;
         const char *q;
@@ -9266,11 +9184,11 @@ nextopt(const char *optstring)
                 if (p == NULL || *p != '-' || *++p == '\0')
                         return '\0';
                 argptr++;
-                if (p[0] == '-' && p[1] == '\0')        /* check for "--" */
+                if (p[0] == '-' && p[1] == '\0')        /* check for "--" */
                         return '\0';
         }
         c = *p++;
-        for (q = optstring ; *q != c ; ) {
+        for (q = optstring; *q != c;) {
                 if (*q == '\0')
                         error("Illegal option -%c", c);
                 if (*++q == ':')
@@ -9286,18 +9204,18 @@ nextopt(const char *optstring)
         return c;
 }
 
-static void
-flushall() {
+static void flushall()
+{
         INTOFF;
         fflush(stdout);
         INTON;
 }
 
 
-static void
-out2fmt(const char *fmt, ...)
+static void out2fmt(const char *fmt, ...)
 {
         va_list ap;
+
         va_start(ap, fmt);
         vfprintf(stderr, fmt, ap);
         va_end(ap);
@@ -9307,8 +9225,7 @@ out2fmt(const char *fmt, ...)
  * Version of write which resumes after a signal is caught.
  */
 
-static int
-xwrite(int fd, const char *buf, int nbytes)
+static int xwrite(int fd, const char *buf, int nbytes)
 {
         int ntry;
         int i;
@@ -9342,42 +9259,42 @@ xwrite(int fd, const char *buf, int nbytes)
 
 
 struct heredoc {
-        struct heredoc *next;   /* next here document in list */
-        union node *here;               /* redirection node */
-        char *eofmark;          /* string indicating end of input */
-        int striptabs;          /* if set, strip leading tabs */
+        struct heredoc *next;   /* next here document in list */
+        union node *here;       /* redirection node */
+        char *eofmark;          /* string indicating end of input */
+        int striptabs;          /* if set, strip leading tabs */
 };
 
-static struct heredoc *heredoclist;     /* list of here documents to read */
-static int parsebackquote;              /* nonzero if we are inside backquotes */
-static int doprompt;                    /* if set, prompt the user */
-static int needprompt;                  /* true if interactive and at start of line */
-static int lasttoken;                   /* last token read */
+static struct heredoc *heredoclist;     /* list of here documents to read */
+static int parsebackquote;      /* nonzero if we are inside backquotes */
+static int doprompt;    /* if set, prompt the user */
+static int needprompt;  /* true if interactive and at start of line */
+static int lasttoken;   /* last token read */
 
-static char *wordtext;                  /* text of last word returned by readtoken */
+static char *wordtext;  /* text of last word returned by readtoken */
 
 static struct nodelist *backquotelist;
 static union node *redirnode;
 static struct heredoc *heredoc;
-static int quoteflag;                   /* set if (part of) last token was quoted */
-static int startlinno;                  /* line # where last token started */
+static int quoteflag;   /* set if (part of) last token was quoted */
+static int startlinno;  /* line # where last token started */
 
 
-static union node *list (int);
-static union node *andor (void);
-static union node *pipeline (void);
-static union node *command (void);
+static union node *list(int);
+static union node *andor(void);
+static union node *pipeline(void);
+static union node *command(void);
 static union node *simplecmd(union node **rpp, union node *redir);
-static void parsefname (void);
-static void parseheredoc (void);
-static char peektoken (void);
-static int readtoken (void);
-static int xxreadtoken (void);
-static int readtoken1 (int, int, const char *, int);
-static int noexpand (char *);
-static void synexpect (int) __attribute__((noreturn));
-static void synerror (const char *) __attribute__((noreturn));
-static void setprompt (int);
+static void parsefname(void);
+static void parseheredoc(void);
+static char peektoken(void);
+static int readtoken(void);
+static int xxreadtoken(void);
+static int readtoken1(int, int, const char *, int);
+static int noexpand(char *);
+static void synexpect(int) __attribute__ ((noreturn));
+static void synerror(const char *) __attribute__ ((noreturn));
+static void setprompt(int);
 
 
 /*
@@ -9385,8 +9302,7 @@ static void setprompt (int);
  * valid parse tree indicating a blank line.)
  */
 
-static union node *
-parsecmd(int interact)
+static union node *parsecmd(int interact)
 {
         int t;
 
@@ -9407,8 +9323,7 @@ parsecmd(int interact)
 }
 
 
-static union node *
-list(int nlflag)
+static union node *list(int nlflag)
 {
         union node *n1, *n2, *n3;
         int tok;
@@ -9426,7 +9341,7 @@ list(int nlflag)
                         } else if (n2->type == NREDIR) {
                                 n2->type = NBACKGND;
                         } else {
-                                n3 = (union node *)stalloc(sizeof (struct nredir));
+                                n3 = (union node *) stalloc(sizeof(struct nredir));
                                 n3->type = NBACKGND;
                                 n3->nredir.n = n2;
                                 n3->nredir.redirect = NULL;
@@ -9435,9 +9350,8 @@ list(int nlflag)
                 }
                 if (n1 == NULL) {
                         n1 = n2;
-                }
-                else {
-                        n3 = (union node *)stalloc(sizeof (struct nbinary));
+                } else {
+                        n3 = (union node *) stalloc(sizeof(struct nbinary));
                         n3->type = NSEMI;
                         n3->nbinary.ch1 = n1;
                         n3->nbinary.ch2 = n2;
@@ -9464,7 +9378,7 @@ list(int nlflag)
                         if (heredoclist)
                                 parseheredoc();
                         else
-                                pungetc();              /* push back EOF on input */
+                                pungetc();      /* push back EOF on input */
                         return n1;
                 default:
                         if (nlflag)
@@ -9477,8 +9391,8 @@ list(int nlflag)
 
 
 
-static union node *
-andor() {
+static union node *andor()
+{
         union node *n1, *n2, *n3;
         int t;
 
@@ -9495,7 +9409,7 @@ andor() {
                 }
                 checkkwd = 2;
                 n2 = pipeline();
-                n3 = (union node *)stalloc(sizeof (struct nbinary));
+                n3 = (union node *) stalloc(sizeof(struct nbinary));
                 n3->type = t;
                 n3->nbinary.ch1 = n1;
                 n3->nbinary.ch2 = n2;
@@ -9505,8 +9419,8 @@ andor() {
 
 
 
-static union node *
-pipeline() {
+static union node *pipeline()
+{
         union node *n1, *n2, *pipenode;
         struct nodelist *lp, *prev;
         int negate;
@@ -9520,15 +9434,15 @@ pipeline() {
                 tokpushback++;
         n1 = command();
         if (readtoken() == TPIPE) {
-                pipenode = (union node *)stalloc(sizeof (struct npipe));
+                pipenode = (union node *) stalloc(sizeof(struct npipe));
                 pipenode->type = NPIPE;
                 pipenode->npipe.backgnd = 0;
-                lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+                lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
                 pipenode->npipe.cmdlist = lp;
                 lp->n = n1;
                 do {
                         prev = lp;
-                        lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+                        lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
                         checkkwd = 2;
                         lp->n = command();
                         prev->next = lp;
@@ -9538,7 +9452,7 @@ pipeline() {
         }
         tokpushback++;
         if (negate) {
-                n2 = (union node *)stalloc(sizeof (struct nnot));
+                n2 = (union node *) stalloc(sizeof(struct nnot));
                 n2->type = NNOT;
                 n2->nnot.com = n1;
                 return n2;
@@ -9548,8 +9462,8 @@ pipeline() {
 
 
 
-static union node *
-command(void) {
+static union node *command(void)
+{
         union node *n1, *n2;
         union node *ap, **app;
         union node *cp, **cpp;
@@ -9570,7 +9484,7 @@ command(void) {
 
         switch (readtoken()) {
         case TIF:
-                n1 = (union node *)stalloc(sizeof (struct nif));
+                n1 = (union node *) stalloc(sizeof(struct nif));
                 n1->type = NIF;
                 n1->nif.test = list(0);
                 if (readtoken() != TTHEN)
@@ -9578,7 +9492,7 @@ command(void) {
                 n1->nif.ifpart = list(0);
                 n2 = n1;
                 while (readtoken() == TELIF) {
-                        n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
+                        n2->nif.elsepart = (union node *) stalloc(sizeof(struct nif));
                         n2 = n2->nif.elsepart;
                         n2->type = NIF;
                         n2->nif.test = list(0);
@@ -9597,13 +9511,14 @@ command(void) {
                 checkkwd = 1;
                 break;
         case TWHILE:
-        case TUNTIL: {
+        case TUNTIL:{
                 int got;
-                n1 = (union node *)stalloc(sizeof (struct nbinary));
-                n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
+                n1 = (union node *) stalloc(sizeof(struct nbinary));
+                n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
                 n1->nbinary.ch1 = list(0);
-                if ((got=readtoken()) != TDO) {
-TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
+                if ((got = readtoken()) != TDO) {
+                        TRACE(("expecting DO got %s %s\n", tokname(got),
+                                   got == TWORD ? wordtext : ""));
                         synexpect(TDO);
                 }
                 n1->nbinary.ch2 = list(0);
@@ -9613,16 +9528,16 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
                 break;
         }
         case TFOR:
-                if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
+                if (readtoken() != TWORD || quoteflag || !goodname(wordtext))
                         synerror("Bad for loop variable");
-                n1 = (union node *)stalloc(sizeof (struct nfor));
+                n1 = (union node *) stalloc(sizeof(struct nfor));
                 n1->type = NFOR;
                 n1->nfor.var = wordtext;
                 checkkwd = 1;
                 if (readtoken() == TIN) {
                         app = &ap;
                         while (readtoken() == TWORD) {
-                                n2 = (union node *)stalloc(sizeof (struct narg));
+                                n2 = (union node *) stalloc(sizeof(struct narg));
                                 n2->type = NARG;
                                 n2->narg.text = wordtext;
                                 n2->narg.backquote = backquotelist;
@@ -9634,9 +9549,10 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
                         if (lasttoken != TNL && lasttoken != TSEMI)
                                 synexpect(-1);
                 } else {
-                        static char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE,
-                                                                   '@', '=', '\0'};
-                        n2 = (union node *)stalloc(sizeof (struct narg));
+                        static char argvars[5] = { CTLVAR, VSNORMAL | VSQUOTE,
+                                '@', '=', '\0'
+                        };
+                        n2 = (union node *) stalloc(sizeof(struct narg));
                         n2->type = NARG;
                         n2->narg.text = argvars;
                         n2->narg.backquote = NULL;
@@ -9658,11 +9574,11 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
                 checkkwd = 1;
                 break;
         case TCASE:
-                n1 = (union node *)stalloc(sizeof (struct ncase));
+                n1 = (union node *) stalloc(sizeof(struct ncase));
                 n1->type = NCASE;
                 if (readtoken() != TWORD)
                         synexpect(TWORD);
-                n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
+                n1->ncase.expr = n2 = (union node *) stalloc(sizeof(struct narg));
                 n2->type = NARG;
                 n2->narg.text = wordtext;
                 n2->narg.backquote = backquotelist;
@@ -9677,11 +9593,11 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
                 do {
                         if (lasttoken == TLP)
                                 readtoken();
-                        *cpp = cp = (union node *)stalloc(sizeof (struct nclist));
+                        *cpp = cp = (union node *) stalloc(sizeof(struct nclist));
                         cp->type = NCLIST;
                         app = &cp->nclist.pattern;
                         for (;;) {
-                                *app = ap = (union node *)stalloc(sizeof (struct narg));
+                                *app = ap = (union node *) stalloc(sizeof(struct narg));
                                 ap->type = NARG;
                                 ap->narg.text = wordtext;
                                 ap->narg.backquote = backquotelist;
@@ -9703,12 +9619,12 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
                                         checkkwd = 2, readtoken();
                         }
                         cpp = &cp->nclist.next;
-                } while(lasttoken != TESAC);
+                } while (lasttoken != TESAC);
                 *cpp = NULL;
                 checkkwd = 1;
                 break;
         case TLP:
-                n1 = (union node *)stalloc(sizeof (struct nredir));
+                n1 = (union node *) stalloc(sizeof(struct nredir));
                 n1->type = NSUBSHELL;
                 n1->nredir.n = list(0);
                 n1->nredir.redirect = NULL;
@@ -9722,7 +9638,7 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
                         synexpect(TEND);
                 checkkwd = 1;
                 break;
-        /* Handle an empty command like other simple commands.  */
+                /* Handle an empty command like other simple commands.  */
         case TSEMI:
         case TAND:
         case TOR:
@@ -9755,7 +9671,7 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
         *rpp = NULL;
         if (redir) {
                 if (n1->type != NSUBSHELL) {
-                        n2 = (union node *)stalloc(sizeof (struct nredir));
+                        n2 = (union node *) stalloc(sizeof(struct nredir));
                         n2->type = NREDIR;
                         n2->nredir.n = n1;
                         n1 = n2;
@@ -9767,8 +9683,8 @@ TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
 }
 
 
-static union node *
-simplecmd(union node **rpp, union node *redir) {
+static union node *simplecmd(union node **rpp, union node *redir)
+{
         union node *args, **app;
         union node *n = NULL;
         union node *vars, **vpp;
@@ -9780,12 +9696,12 @@ simplecmd(union node **rpp, union node *redir) {
         vpp = &vars;
 
         /* If we don't have any redirections already, then we must reset
-          rpp to be the address of the local redir variable.  */
+           rpp to be the address of the local redir variable.  */
         if (redir == 0)
-        rpp = &redir;
+                rpp = &redir;
         /* We save the incoming value, because we need this for shell
-          functions.  There can not be a redirect or an argument between
-          the function name and the open parenthesis.  */
+           functions.  There can not be a redirect or an argument between
+           the function name and the open parenthesis.  */
         orig_rpp = rpp;
 
         checkalias = 2;
@@ -9793,7 +9709,7 @@ simplecmd(union node **rpp, union node *redir) {
                 switch (readtoken()) {
                 case TWORD:
                 case TASSIGN:
-                        n = (union node *)stalloc(sizeof (struct narg));
+                        n = (union node *) stalloc(sizeof(struct narg));
                         n->type = NARG;
                         n->narg.text = wordtext;
                         n->narg.backquote = backquotelist;
@@ -9808,13 +9724,10 @@ simplecmd(union node **rpp, union node *redir) {
                 case TREDIR:
                         *rpp = n = redirnode;
                         rpp = &n->nfile.next;
-                        parsefname();   /* read name of redirection file */
+                        parsefname();   /* read name of redirection file */
                         break;
                 case TLP:
-                        if (
-                                args && app == &args->narg.next &&
-                                !vars && rpp == orig_rpp
-                        ) {
+                        if (args && app == &args->narg.next && !vars && rpp == orig_rpp) {
                                 /* We have a function */
                                 if (readtoken() != TRP)
                                         synexpect(TRP);
@@ -9829,11 +9742,11 @@ simplecmd(union node **rpp, union node *redir) {
                         goto out;
                 }
         }
-out:
+  out:
         *app = NULL;
         *vpp = NULL;
         *rpp = NULL;
-        n = (union node *)stalloc(sizeof (struct ncmd));
+        n = (union node *) stalloc(sizeof(struct ncmd));
         n->type = NCMD;
         n->ncmd.backgnd = 0;
         n->ncmd.args = args;
@@ -9842,11 +9755,11 @@ out:
         return n;
 }
 
-static union node *
-makename(void) {
+static union node *makename(void)
+{
         union node *n;
 
-        n = (union node *)stalloc(sizeof (struct narg));
+        n = (union node *) stalloc(sizeof(struct narg));
         n->type = NARG;
         n->narg.next = NULL;
         n->narg.text = wordtext;
@@ -9874,8 +9787,8 @@ static void fixredir(union node *n, const char *text, int err)
 }
 
 
-static void
-parsefname(void) {
+static void parsefname(void)
+{
         union node *n = redirnode;
 
         if (readtoken() != TWORD)
@@ -9892,7 +9805,8 @@ parsefname(void) {
                         while (*wordtext == '\t')
                                 wordtext++;
                 }
-                if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
+                if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0
+                        || i > EOFMARKLEN)
                         synerror("Illegal eof marker for << redirection");
                 rmescapes(wordtext);
                 here->eofmark = wordtext;
@@ -9900,7 +9814,7 @@ parsefname(void) {
                 if (heredoclist == NULL)
                         heredoclist = here;
                 else {
-                        for (p = heredoclist ; p->next ; p = p->next);
+                        for (p = heredoclist; p->next; p = p->next);
                         p->next = here;
                 }
         } else if (n->type == NTOFD || n->type == NFROMFD) {
@@ -9915,8 +9829,8 @@ parsefname(void) {
  * Input any here documents.
  */
 
-static void
-parseheredoc() {
+static void parseheredoc()
+{
         struct heredoc *here;
         union node *n;
 
@@ -9927,9 +9841,9 @@ parseheredoc() {
                         setprompt(2);
                         needprompt = 0;
                 }
-                readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
-                                here->eofmark, here->striptabs);
-                n = (union node *)stalloc(sizeof (struct narg));
+                readtoken1(pgetc(), here->here->type == NHERE ? SQSYNTAX : DQSYNTAX,
+                                   here->eofmark, here->striptabs);
+                n = (union node *) stalloc(sizeof(struct narg));
                 n->narg.type = NARG;
                 n->narg.next = NULL;
                 n->narg.text = wordtext;
@@ -9938,8 +9852,8 @@ parseheredoc() {
         }
 }
 
-static char
-peektoken() {
+static char peektoken()
+{
         int t;
 
         t = readtoken();
@@ -9947,11 +9861,12 @@ peektoken() {
         return tokname_array[t][0];
 }
 
-static int
-readtoken() {
+static int readtoken()
+{
         int t;
 
         int savecheckalias = checkalias;
+
 #ifdef CONFIG_ASH_ALIAS
         int savecheckkwd = checkkwd;
         struct alias *ap;
@@ -9962,7 +9877,7 @@ readtoken() {
 #endif
 
 #ifdef CONFIG_ASH_ALIAS
-top:
+  top:
 #endif
 
         t = xxreadtoken();
@@ -9984,8 +9899,7 @@ top:
                 /*
                  * check for keywords
                  */
-                if (t == TWORD && !quoteflag)
-                {
+                if (t == TWORD && !quoteflag) {
                         const char *const *pp;
 
                         if ((pp = findkwd(wordtext))) {
@@ -10005,7 +9919,8 @@ top:
                 lasttoken = t = TASSIGN;
         } else if (checkalias) {
 #ifdef CONFIG_ASH_ALIAS
-                if (!quoteflag && (ap = *__lookupalias(wordtext)) != NULL && !(ap->flag & ALIASINUSE)) {
+                if (!quoteflag && (ap = *__lookupalias(wordtext)) != NULL
+                        && !(ap->flag & ALIASINUSE)) {
                         if (*ap->val) {
                                 pushstring(ap->val, strlen(ap->val), ap);
                         }
@@ -10015,12 +9930,14 @@ top:
 #endif
                 checkalias = 0;
         }
-out:
+  out:
 #ifdef DEBUG
         if (!alreadyseen)
-            TRACE(("token %s %s\n", tokname(t), t == TWORD || t == TASSIGN ? wordtext : ""));
+                TRACE(("token %s %s\n", tokname(t), t == TWORD
+                           || t == TASSIGN ? wordtext : ""));
         else
-            TRACE(("reread token %s %s\n", tokname(t), t == TWORD || t == TASSIGN ? wordtext : ""));
+                TRACE(("reread token %s %s\n", tokname(t), t == TWORD
+                           || t == TASSIGN ? wordtext : ""));
 #endif
         return (t);
 }
@@ -10047,12 +9964,12 @@ out:
 #define NEW_xxreadtoken
 #ifdef NEW_xxreadtoken
 
-static const char xxreadtoken_chars[] = "\n()&|;"; /* singles must be first! */
+static const char xxreadtoken_chars[] = "\n()&|;";      /* singles must be first! */
 static const char xxreadtoken_tokens[] = {
-        TNL, TLP, TRP,                          /* only single occurrence allowed */
-        TBACKGND, TPIPE, TSEMI,         /* if single occurrence */
-        TEOF,                                           /* corresponds to trailing nul */
-        TAND, TOR, TENDCASE,            /* if double occurrence */
+        TNL, TLP, TRP,          /* only single occurrence allowed */
+        TBACKGND, TPIPE, TSEMI, /* if single occurrence */
+        TEOF,                           /* corresponds to trailing nul */
+        TAND, TOR, TENDCASE,    /* if double occurrence */
 };
 
 #define xxreadtoken_doubles \
@@ -10060,8 +9977,8 @@ static const char xxreadtoken_tokens[] = {
 #define xxreadtoken_singles \
         (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
 
-static int
-xxreadtoken() {
+static int xxreadtoken()
+{
         int c;
 
         if (tokpushback) {
@@ -10073,18 +9990,18 @@ xxreadtoken() {
                 needprompt = 0;
         }
         startlinno = plinno;
-        for (;;) {      /* until token or start of word found */
+        for (;;) {                      /* until token or start of word found */
                 c = pgetc_macro();
 
-                if ((c!=' ') && (c!='\t')
+                if ((c != ' ') && (c != '\t')
 #ifdef CONFIG_ASH_ALIAS
-                        && (c!=PEOA)
+                        && (c != PEOA)
 #endif
                         ) {
-                        if (c=='#') {
+                        if (c == '#') {
                                 while ((c = pgetc()) != '\n' && c != PEOF);
                                 pungetc();
-                        } else if (c=='\\') {
+                        } else if (c == '\\') {
                                 if (pgetc() != '\n') {
                                         pungetc();
                                         goto READTOKEN1;
@@ -10095,20 +10012,20 @@ xxreadtoken() {
                                 const char *p
                                         = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
 
-                                if (c!=PEOF) {
-                                        if (c=='\n') {
+                                if (c != PEOF) {
+                                        if (c == '\n') {
                                                 plinno++;
                                                 needprompt = doprompt;
                                         }
 
                                         p = strchr(xxreadtoken_chars, c);
                                         if (p == NULL) {
-                                        READTOKEN1:
-                                                return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
+                                          READTOKEN1:
+                                                return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
                                         }
-                        
-                                        if (p-xxreadtoken_chars >= xxreadtoken_singles) {
-                                                if (pgetc() == *p) { /* double occurrence? */
+
+                                        if (p - xxreadtoken_chars >= xxreadtoken_singles) {
+                                                if (pgetc() == *p) {    /* double occurrence? */
                                                         p += xxreadtoken_doubles + 1;
                                                 } else {
                                                         pungetc();
@@ -10116,7 +10033,7 @@ xxreadtoken() {
                                         }
                                 }
 
-                                return lasttoken = xxreadtoken_tokens[p-xxreadtoken_chars];
+                                return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
                         }
                 }
         }
@@ -10126,8 +10043,8 @@ xxreadtoken() {
 #else
 #define RETURN(token)   return lasttoken = token
 
-static int
-xxreadtoken() {
+static int xxreadtoken()
+{
         int c;
 
         if (tokpushback) {
@@ -10139,10 +10056,11 @@ xxreadtoken() {
                 needprompt = 0;
         }
         startlinno = plinno;
-        for (;;) {      /* until token or start of word found */
+        for (;;) {                      /* until token or start of word found */
                 c = pgetc_macro();
                 switch (c) {
-                case ' ': case '\t':
+                case ' ':
+                case '\t':
 #ifdef CONFIG_ASH_ALIAS
                 case PEOA:
 #endif
@@ -10191,8 +10109,8 @@ xxreadtoken() {
                         goto breakloop;
                 }
         }
-breakloop:
-        return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
+  breakloop:
+        return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
 #undef RETURN
 }
 #endif
@@ -10226,12 +10144,13 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
         struct nodelist *bqlist;
         int quotef;
         int dblquote;
-        int varnest;    /* levels of variables expansion */
-        int arinest;    /* levels of arithmetic expansion */
-        int parenlevel; /* levels of parens in arithmetic */
-        int dqvarnest;  /* levels of variables expansion within double quotes */
+        int varnest;            /* levels of variables expansion */
+        int arinest;            /* levels of arithmetic expansion */
+        int parenlevel;         /* levels of parens in arithmetic */
+        int dqvarnest;          /* levels of variables expansion within double quotes */
         int oldstyle;
-        int prevsyntax; /* syntax before arithmetic */
+        int prevsyntax;         /* syntax before arithmetic */
+
 #if __GNUC__
         /* Avoid longjmp clobbering */
         (void) &out;
@@ -10258,14 +10177,14 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
         dqvarnest = 0;
 
         STARTSTACKSTR(out);
-        loop: { /* for each line, until end of word */
-                CHECKEND();     /* set c to PEOF if at end of here document */
-                for (;;) {      /* until end of line or end of word */
-                        CHECKSTRSPACE(3, out);  /* permit 3 calls to USTPUTC */
-                        switch(SIT(c,syntax)) {
-                        case CNL:       /* '\n' */
+  loop:{                                /* for each line, until end of word */
+                CHECKEND();             /* set c to PEOF if at end of here document */
+                for (;;) {              /* until end of line or end of word */
+                        CHECKSTRSPACE(3, out);  /* permit 3 calls to USTPUTC */
+                        switch (SIT(c, syntax)) {
+                        case CNL:       /* '\n' */
                                 if (syntax == BASESYNTAX)
-                                        goto endword;   /* exit outer loop */
+                                        goto endword;   /* exit outer loop */
                                 USTPUTC(c, out);
                                 plinno++;
                                 if (doprompt)
@@ -10273,17 +10192,16 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
                                 else
                                         setprompt(0);
                                 c = pgetc();
-                                goto loop;              /* continue outer loop */
+                                goto loop;      /* continue outer loop */
                         case CWORD:
                                 USTPUTC(c, out);
                                 break;
                         case CCTL:
-                                if ((eofmark == NULL || dblquote) &&
-                                    dqvarnest == 0)
+                                if ((eofmark == NULL || dblquote) && dqvarnest == 0)
                                         USTPUTC(CTLESC, out);
                                 USTPUTC(c, out);
                                 break;
-                        case CBACK:     /* backslash */
+                        case CBACK:     /* backslash */
                                 c = pgetc2();
                                 if (c == PEOF) {
                                         USTPUTC('\\', out);
@@ -10295,9 +10213,9 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
                                                 setprompt(0);
                                 } else {
                                         if (dblquote && c != '\\' && c != '`' && c != '$'
-                                                         && (c != '"' || eofmark != NULL))
+                                                && (c != '"' || eofmark != NULL))
                                                 USTPUTC('\\', out);
-                                        if (SIT(c,SQSYNTAX) == CCTL)
+                                        if (SIT(c, SQSYNTAX) == CCTL)
                                                 USTPUTC(CTLESC, out);
                                         else if (eofmark == NULL)
                                                 USTPUTC(CTLQUOTEMARK, out);
@@ -10317,25 +10235,23 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
                                 dblquote = 1;
                                 break;
                         case CENDQUOTE:
-                                if (eofmark != NULL && arinest == 0 &&
-                                    varnest == 0) {
+                                if (eofmark != NULL && arinest == 0 && varnest == 0) {
                                         USTPUTC(c, out);
                                 } else {
                                         if (arinest) {
                                                 syntax = ARISYNTAX;
                                                 dblquote = 0;
-                                        } else if (eofmark == NULL &&
-                                                   dqvarnest == 0) {
+                                        } else if (eofmark == NULL && dqvarnest == 0) {
                                                 syntax = BASESYNTAX;
                                                 dblquote = 0;
                                         }
                                         quotef++;
                                 }
                                 break;
-                        case CVAR:      /* '$' */
-                                PARSESUB();             /* parse substitution */
+                        case CVAR:      /* '$' */
+                                PARSESUB();     /* parse substitution */
                                 break;
-                        case CENDVAR:   /* '}' */
+                        case CENDVAR:   /* '}' */
                                 if (varnest > 0) {
                                         varnest--;
                                         if (dqvarnest > 0) {
@@ -10347,11 +10263,11 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
                                 }
                                 break;
 #ifdef CONFIG_ASH_MATH_SUPPORT
-                        case CLP:       /* '(' in arithmetic */
+                        case CLP:       /* '(' in arithmetic */
                                 parenlevel++;
                                 USTPUTC(c, out);
                                 break;
-                        case CRP:       /* ')' in arithmetic */
+                        case CRP:       /* ')' in arithmetic */
                                 if (parenlevel > 0) {
                                         USTPUTC(c, out);
                                         --parenlevel;
@@ -10377,16 +10293,16 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
                                 }
                                 break;
 #endif
-                        case CBQUOTE:   /* '`' */
+                        case CBQUOTE:   /* '`' */
                                 PARSEBACKQOLD();
                                 break;
                         case CENDFILE:
-                                goto endword;           /* exit outer loop */
+                                goto endword;   /* exit outer loop */
                         case CIGN:
                                 break;
                         default:
                                 if (varnest == 0)
-                                        goto endword;   /* exit outer loop */
+                                        goto endword;   /* exit outer loop */
 #ifdef CONFIG_ASH_ALIAS
                                 if (c != PEOA)
 #endif
@@ -10396,10 +10312,10 @@ readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
                         c = pgetc_macro();
                 }
         }
-endword:
+  endword:
         if (syntax == ARISYNTAX)
                 synerror("Missing '))'");
-        if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
+        if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL)
                 synerror("Unterminated quoted string");
         if (varnest != 0) {
                 startlinno = plinno;
@@ -10410,9 +10326,7 @@ endword:
         out = stackblock();
         if (eofmark == NULL) {
                 if ((c == '>' || c == '<')
-                 && quotef == 0
-                 && len <= 2
-                 && (*out == '\0' || is_digit(*out))) {
+                        && quotef == 0 && len <= 2 && (*out == '\0' || is_digit(*out))) {
                         PARSEREDIR();
                         return lasttoken = TREDIR;
                 } else {
@@ -10434,36 +10348,36 @@ endword:
  * we are at the end of the here document, this routine sets the c to PEOF.
  */
 
-checkend: {
-        if (eofmark) {
+  checkend:{
+                if (eofmark) {
 #ifdef CONFIG_ASH_ALIAS
-                if (c == PEOA) {
-                        c = pgetc2();
-                }
-#endif
-                if (striptabs) {
-                        while (c == '\t') {
+                        if (c == PEOA) {
                                 c = pgetc2();
                         }
-                }
-                if (c == *eofmark) {
-                        if (pfgets(line, sizeof line) != NULL) {
-                                const char *p, *q;
-
-                                p = line;
-                                for (q = eofmark + 1 ; *q && *p == *q ; p++, q++);
-                                if (*p == '\n' && *q == '\0') {
-                                        c = PEOF;
-                                        plinno++;
-                                        needprompt = doprompt;
-                                } else {
-                                        pushstring(line, strlen(line), NULL);
+#endif
+                        if (striptabs) {
+                                while (c == '\t') {
+                                        c = pgetc2();
+                                }
+                        }
+                        if (c == *eofmark) {
+                                if (pfgets(line, sizeof line) != NULL) {
+                                        const char *p, *q;
+
+                                        p = line;
+                                        for (q = eofmark + 1; *q && *p == *q; p++, q++);
+                                        if (*p == '\n' && *q == '\0') {
+                                                c = PEOF;
+                                                plinno++;
+                                                needprompt = doprompt;
+                                        } else {
+                                                pushstring(line, strlen(line), NULL);
+                                        }
                                 }
                         }
                 }
+                goto checkend_return;
         }
-        goto checkend_return;
-}
 
 
 /*
@@ -10472,62 +10386,62 @@ checkend: {
  * first character of the redirection operator.
  */
 
-parseredir: {
-        char fd = *out;
-        union node *np;
+  parseredir:{
+                char fd = *out;
+                union node *np;
 
-        np = (union node *)stalloc(sizeof (struct nfile));
-        if (c == '>') {
-                np->nfile.fd = 1;
-                c = pgetc();
-                if (c == '>')
-                        np->type = NAPPEND;
-                else if (c == '&')
-                        np->type = NTOFD;
-                else if (c == '|')
-                        np->type = NTOOV;
-                else {
-                        np->type = NTO;
-                        pungetc();
-                }
-        } else {        /* c == '<' */
-                np->nfile.fd = 0;
-                switch (c = pgetc()) {
-                case '<':
-                        if (sizeof (struct nfile) != sizeof (struct nhere)) {
-                                np = (union node *)stalloc(sizeof (struct nhere));
-                                np->nfile.fd = 0;
-                        }
-                        np->type = NHERE;
-                        heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
-                        heredoc->here = np;
-                        if ((c = pgetc()) == '-') {
-                                heredoc->striptabs = 1;
-                        } else {
-                                heredoc->striptabs = 0;
+                np = (union node *) stalloc(sizeof(struct nfile));
+                if (c == '>') {
+                        np->nfile.fd = 1;
+                        c = pgetc();
+                        if (c == '>')
+                                np->type = NAPPEND;
+                        else if (c == '&')
+                                np->type = NTOFD;
+                        else if (c == '|')
+                                np->type = NTOOV;
+                        else {
+                                np->type = NTO;
                                 pungetc();
                         }
-                        break;
+                } else {                /* c == '<' */
+                        np->nfile.fd = 0;
+                        switch (c = pgetc()) {
+                        case '<':
+                                if (sizeof(struct nfile) != sizeof(struct nhere)) {
+                                        np = (union node *) stalloc(sizeof(struct nhere));
+                                        np->nfile.fd = 0;
+                                }
+                                np->type = NHERE;
+                                heredoc = (struct heredoc *) stalloc(sizeof(struct heredoc));
+                                heredoc->here = np;
+                                if ((c = pgetc()) == '-') {
+                                        heredoc->striptabs = 1;
+                                } else {
+                                        heredoc->striptabs = 0;
+                                        pungetc();
+                                }
+                                break;
 
-                case '&':
-                        np->type = NFROMFD;
-                        break;
+                        case '&':
+                                np->type = NFROMFD;
+                                break;
 
-                case '>':
-                        np->type = NFROMTO;
-                        break;
+                        case '>':
+                                np->type = NFROMTO;
+                                break;
 
-                default:
-                        np->type = NFROM;
-                        pungetc();
-                        break;
+                        default:
+                                np->type = NFROM;
+                                pungetc();
+                                break;
+                        }
                 }
+                if (fd != '\0')
+                        np->nfile.fd = digit_val(fd);
+                redirnode = np;
+                goto parseredir_return;
         }
-        if (fd != '\0')
-                np->nfile.fd = digit_val(fd);
-        redirnode = np;
-        goto parseredir_return;
-}
 
 
 /*
@@ -10535,81 +10449,76 @@ parseredir: {
  * and nothing else.
  */
 
-parsesub: {
-        int subtype;
-        int typeloc;
-        int flags;
-        char *p;
-        static const char types[] = "}-+?=";
-
-        c = pgetc();
-        if (
-                c <= PEOA  ||
-                (c != '(' && c != '{' && !is_name(c) && !is_special(c))
-        ) {
-                USTPUTC('$', out);
-                pungetc();
-        } else if (c == '(') {  /* $(command) or $((arith)) */
-                if (pgetc() == '(') {
-                        PARSEARITH();
-                } else {
+  parsesub:{
+                int subtype;
+                int typeloc;
+                int flags;
+                char *p;
+                static const char types[] = "}-+?=";
+
+                c = pgetc();
+                if (c <= PEOA ||
+                        (c != '(' && c != '{' && !is_name(c) && !is_special(c))
+                        ) {
+                        USTPUTC('$', out);
                         pungetc();
-                        PARSEBACKQNEW();
-                }
-        } else {
-                USTPUTC(CTLVAR, out);
-                typeloc = out - stackblock();
-                USTPUTC(VSNORMAL, out);
-                subtype = VSNORMAL;
-                if (c == '{') {
-                        c = pgetc();
-                        if (c == '#') {
-                                if ((c = pgetc()) == '}')
-                                        c = '#';
-                                else
-                                        subtype = VSLENGTH;
+                } else if (c == '(') {  /* $(command) or $((arith)) */
+                        if (pgetc() == '(') {
+                                PARSEARITH();
+                        } else {
+                                pungetc();
+                                PARSEBACKQNEW();
                         }
-                        else
-                                subtype = 0;
-                }
-                if (c > PEOA && is_name(c)) {
-                        do {
-                                STPUTC(c, out);
+                } else {
+                        USTPUTC(CTLVAR, out);
+                        typeloc = out - stackblock();
+                        USTPUTC(VSNORMAL, out);
+                        subtype = VSNORMAL;
+                        if (c == '{') {
                                 c = pgetc();
-                        } while (c > PEOA && is_in_name(c));
-                } else if (is_digit(c)) {
-                        do {
+                                if (c == '#') {
+                                        if ((c = pgetc()) == '}')
+                                                c = '#';
+                                        else
+                                                subtype = VSLENGTH;
+                                } else
+                                        subtype = 0;
+                        }
+                        if (c > PEOA && is_name(c)) {
+                                do {
+                                        STPUTC(c, out);
+                                        c = pgetc();
+                                } while (c > PEOA && is_in_name(c));
+                        } else if (is_digit(c)) {
+                                do {
+                                        USTPUTC(c, out);
+                                        c = pgetc();
+                                } while (is_digit(c));
+                        } else if (is_special(c)) {
                                 USTPUTC(c, out);
                                 c = pgetc();
-                        } while (is_digit(c));
-                }
-                else if (is_special(c)) {
-                        USTPUTC(c, out);
-                        c = pgetc();
-                }
-                else
-badsub:                 synerror("Bad substitution");
-
-                STPUTC('=', out);
-                flags = 0;
-                if (subtype == 0) {
-                        switch (c) {
-                        case ':':
-                                flags = VSNUL;
-                                c = pgetc();
-                                /*FALLTHROUGH*/
-                        default:
-                                p = strchr(types, c);
-                                if (p == NULL)
-                                        goto badsub;
-                                subtype = p - types + VSNORMAL;
-                                break;
-                        case '%':
-                        case '#':
+                        } else
+                          badsub:synerror("Bad substitution");
+
+                        STPUTC('=', out);
+                        flags = 0;
+                        if (subtype == 0) {
+                                switch (c) {
+                                case ':':
+                                        flags = VSNUL;
+                                        c = pgetc();
+                                 /*FALLTHROUGH*/ default:
+                                        p = strchr(types, c);
+                                        if (p == NULL)
+                                                goto badsub;
+                                        subtype = p - types + VSNORMAL;
+                                        break;
+                                case '%':
+                                case '#':
                                 {
                                         int cc = c;
-                                        subtype = c == '#' ? VSTRIMLEFT :
-                                                             VSTRIMRIGHT;
+
+                                        subtype = c == '#' ? VSTRIMLEFT : VSTRIMRIGHT;
                                         c = pgetc();
                                         if (c == cc)
                                                 subtype++;
@@ -10617,22 +10526,22 @@ badsub:                 synerror("Bad substitution");
                                                 pungetc();
                                         break;
                                 }
+                                }
+                        } else {
+                                pungetc();
                         }
-                } else {
-                        pungetc();
-                }
-                if (dblquote || arinest)
-                        flags |= VSQUOTE;
-                *(stackblock() + typeloc) = subtype | flags;
-                if (subtype != VSNORMAL) {
-                        varnest++;
-                        if (dblquote) {
-                                dqvarnest++;
+                        if (dblquote || arinest)
+                                flags |= VSQUOTE;
+                        *(stackblock() + typeloc) = subtype | flags;
+                        if (subtype != VSNORMAL) {
+                                varnest++;
+                                if (dblquote) {
+                                        dqvarnest++;
+                                }
                         }
                 }
+                goto parsesub_return;
         }
-        goto parsesub_return;
-}
 
 
 /*
@@ -10642,181 +10551,182 @@ badsub:                 synerror("Bad substitution");
  * characters on the top of the stack which must be preserved.
  */
 
-parsebackq: {
-        struct nodelist **nlpp;
-        int savepbq;
-        union node *n;
-        char *volatile str;
-        struct jmploc jmploc;
-        struct jmploc *volatile savehandler;
-        int savelen;
-        int saveprompt;
+  parsebackq:{
+                struct nodelist **nlpp;
+                int savepbq;
+                union node *n;
+                char *volatile str;
+                struct jmploc jmploc;
+                struct jmploc *volatile savehandler;
+                int savelen;
+                int saveprompt;
+
 #ifdef __GNUC__
-        (void) &saveprompt;
+                (void) &saveprompt;
 #endif
 
-        savepbq = parsebackquote;
-        if (setjmp(jmploc.loc)) {
-                free(str);
-                parsebackquote = 0;
-                handler = savehandler;
-                longjmp(handler->loc, 1);
-        }
-        INTOFF;
-        str = NULL;
-        savelen = out - stackblock();
-        if (savelen > 0) {
-                str = xmalloc(savelen);
-                memcpy(str, stackblock(), savelen);
-        }
-        savehandler = handler;
-        handler = &jmploc;
-        INTON;
-        if (oldstyle) {
-                /* We must read until the closing backquote, giving special
-                   treatment to some slashes, and then push the string and
-                   reread it as input, interpreting it normally.  */
-                char *pout;
-                int pc;
-                int psavelen;
-                char *pstr;
-
+                savepbq = parsebackquote;
+                if (setjmp(jmploc.loc)) {
+                        free(str);
+                        parsebackquote = 0;
+                        handler = savehandler;
+                        longjmp(handler->loc, 1);
+                }
+                INTOFF;
+                str = NULL;
+                savelen = out - stackblock();
+                if (savelen > 0) {
+                        str = xmalloc(savelen);
+                        memcpy(str, stackblock(), savelen);
+                }
+                savehandler = handler;
+                handler = &jmploc;
+                INTON;
+                if (oldstyle) {
+                        /* We must read until the closing backquote, giving special
+                           treatment to some slashes, and then push the string and
+                           reread it as input, interpreting it normally.  */
+                        char *pout;
+                        int pc;
+                        int psavelen;
+                        char *pstr;
 
-                STARTSTACKSTR(pout);
-                for (;;) {
-                        if (needprompt) {
-                                setprompt(2);
-                                needprompt = 0;
-                        }
-                        switch (pc = pgetc()) {
-                        case '`':
-                                goto done;
 
-                        case '\\':
-                                if ((pc = pgetc()) == '\n') {
-                                        plinno++;
-                                        if (doprompt)
-                                                setprompt(2);
-                                        else
-                                                setprompt(0);
-                                        /*
-                                         * If eating a newline, avoid putting
-                                         * the newline into the new character
-                                         * stream (via the STPUTC after the
-                                         * switch).
-                                         */
-                                        continue;
-                                }
-                                if (pc != '\\' && pc != '`' && pc != '$'
-                                    && (!dblquote || pc != '"'))
-                                        STPUTC('\\', pout);
-                                if (pc > PEOA) {
-                                        break;
+                        STARTSTACKSTR(pout);
+                        for (;;) {
+                                if (needprompt) {
+                                        setprompt(2);
+                                        needprompt = 0;
                                 }
-                                /* fall through */
+                                switch (pc = pgetc()) {
+                                case '`':
+                                        goto done;
+
+                                case '\\':
+                                        if ((pc = pgetc()) == '\n') {
+                                                plinno++;
+                                                if (doprompt)
+                                                        setprompt(2);
+                                                else
+                                                        setprompt(0);
+                                                /*
+                                                 * If eating a newline, avoid putting
+                                                 * the newline into the new character
+                                                 * stream (via the STPUTC after the
+                                                 * switch).
+                                                 */
+                                                continue;
+                                        }
+                                        if (pc != '\\' && pc != '`' && pc != '$'
+                                                && (!dblquote || pc != '"'))
+                                                STPUTC('\\', pout);
+                                        if (pc > PEOA) {
+                                                break;
+                                        }
+                                        /* fall through */
 
-                        case PEOF:
+                                case PEOF:
 #ifdef CONFIG_ASH_ALIAS
-                        case PEOA:
+                                case PEOA:
 #endif
-                                startlinno = plinno;
-                                synerror("EOF in backquote substitution");
+                                        startlinno = plinno;
+                                        synerror("EOF in backquote substitution");
 
-                        case '\n':
-                                plinno++;
-                                needprompt = doprompt;
-                                break;
+                                case '\n':
+                                        plinno++;
+                                        needprompt = doprompt;
+                                        break;
 
-                        default:
-                                break;
+                                default:
+                                        break;
+                                }
+                                STPUTC(pc, pout);
+                        }
+                  done:
+                        STPUTC('\0', pout);
+                        psavelen = pout - stackblock();
+                        if (psavelen > 0) {
+                                pstr = grabstackstr(pout);
+                                setinputstring(pstr);
                         }
-                        STPUTC(pc, pout);
-                }
-done:
-                STPUTC('\0', pout);
-                psavelen = pout - stackblock();
-                if (psavelen > 0) {
-                        pstr = grabstackstr(pout);
-                        setinputstring(pstr);
                 }
-        }
-        nlpp = &bqlist;
-        while (*nlpp)
-                nlpp = &(*nlpp)->next;
-        *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
-        (*nlpp)->next = NULL;
-        parsebackquote = oldstyle;
+                nlpp = &bqlist;
+                while (*nlpp)
+                        nlpp = &(*nlpp)->next;
+                *nlpp = (struct nodelist *) stalloc(sizeof(struct nodelist));
+                (*nlpp)->next = NULL;
+                parsebackquote = oldstyle;
 
-        if (oldstyle) {
-                saveprompt = doprompt;
-                doprompt = 0;
-        }
+                if (oldstyle) {
+                        saveprompt = doprompt;
+                        doprompt = 0;
+                }
 
-        n = list(0);
+                n = list(0);
 
-        if (oldstyle)
-                doprompt = saveprompt;
-        else {
-                if (readtoken() != TRP)
-                        synexpect(TRP);
-        }
+                if (oldstyle)
+                        doprompt = saveprompt;
+                else {
+                        if (readtoken() != TRP)
+                                synexpect(TRP);
+                }
 
-        (*nlpp)->n = n;
-        if (oldstyle) {
-                /*
-                 * Start reading from old file again, ignoring any pushed back
-                 * tokens left from the backquote parsing
-                 */
-                popfile();
-                tokpushback = 0;
-        }
-        while (stackblocksize() <= savelen)
-                growstackblock();
-        STARTSTACKSTR(out);
-        if (str) {
-                memcpy(out, str, savelen);
-                STADJUST(savelen, out);
-                INTOFF;
-                free(str);
-                str = NULL;
-                INTON;
+                (*nlpp)->n = n;
+                if (oldstyle) {
+                        /*
+                         * Start reading from old file again, ignoring any pushed back
+                         * tokens left from the backquote parsing
+                         */
+                        popfile();
+                        tokpushback = 0;
+                }
+                while (stackblocksize() <= savelen)
+                        growstackblock();
+                STARTSTACKSTR(out);
+                if (str) {
+                        memcpy(out, str, savelen);
+                        STADJUST(savelen, out);
+                        INTOFF;
+                        free(str);
+                        str = NULL;
+                        INTON;
+                }
+                parsebackquote = savepbq;
+                handler = savehandler;
+                if (arinest || dblquote)
+                        USTPUTC(CTLBACKQ | CTLQUOTE, out);
+                else
+                        USTPUTC(CTLBACKQ, out);
+                if (oldstyle)
+                        goto parsebackq_oldreturn;
+                else
+                        goto parsebackq_newreturn;
         }
-        parsebackquote = savepbq;
-        handler = savehandler;
-        if (arinest || dblquote)
-                USTPUTC(CTLBACKQ | CTLQUOTE, out);
-        else
-                USTPUTC(CTLBACKQ, out);
-        if (oldstyle)
-                goto parsebackq_oldreturn;
-        else
-                goto parsebackq_newreturn;
-}
 
 /*
  * Parse an arithmetic expansion (indicate start of one and set state)
  */
-parsearith: {
+  parsearith:{
 
-        if (++arinest == 1) {
-                prevsyntax = syntax;
-                syntax = ARISYNTAX;
-                USTPUTC(CTLARI, out);
-                if (dblquote)
-                        USTPUTC('"',out);
-                else
-                        USTPUTC(' ',out);
-        } else {
-                /*
-                 * we collapse embedded arithmetic expansion to
-                 * parenthesis, which should be equivalent
-                 */
-                USTPUTC('(', out);
+                if (++arinest == 1) {
+                        prevsyntax = syntax;
+                        syntax = ARISYNTAX;
+                        USTPUTC(CTLARI, out);
+                        if (dblquote)
+                                USTPUTC('"', out);
+                        else
+                                USTPUTC(' ', out);
+                } else {
+                        /*
+                         * we collapse embedded arithmetic expansion to
+                         * parenthesis, which should be equivalent
+                         */
+                        USTPUTC('(', out);
+                }
+                goto parsearith_return;
         }
-        goto parsearith_return;
-}
 
-} /* end of readtoken */
+}                                               /* end of readtoken */
 
 
 /*
@@ -10824,8 +10734,7 @@ parsearith: {
  * or backquotes).
  */
 
-static int
-noexpand(char *text)
+static int noexpand(char *text)
 {
         char *p;
         char c;
@@ -10836,7 +10745,7 @@ noexpand(char *text)
                         continue;
                 if (c == CTLESC)
                         p++;
-                else if (SIT(c,BASESYNTAX) == CCTL)
+                else if (SIT(c, BASESYNTAX) == CCTL)
                         return 0;
         }
         return 1;
@@ -10848,16 +10757,15 @@ noexpand(char *text)
  * underscore followed by zero or more letters, underscores, and digits).
  */
 
-static int
-goodname(const char *name)
+static int goodname(const char *name)
 {
         const char *p;
 
         p = name;
-        if (! is_name(*p))
+        if (!is_name(*p))
                 return 0;
         while (*++p) {
-                if (! is_in_name(*p))
+                if (!is_in_name(*p))
                         return 0;
         }
         return 1;
@@ -10870,27 +10778,25 @@ goodname(const char *name)
  * occur at this point.
  */
 
-static void
-synexpect(int token)
+static void synexpect(int token)
 {
         char msg[64];
         int l;
 
         l = sprintf(msg, "%s unexpected", tokname(lasttoken));
         if (token >= 0)
-                sprintf(msg+l, " (expecting %s)", tokname(token));
+                sprintf(msg + l, " (expecting %s)", tokname(token));
         synerror(msg);
         /* NOTREACHED */
 }
 
 
-static void
-synerror(const char *msg)
+static void synerror(const char *msg)
 {
         if (commandname)
                 out2fmt("%s: %d: ", commandname, startlinno);
         out2fmt("Syntax error: %s\n", msg);
-        error((char *)NULL);
+        error((char *) NULL);
         /* NOTREACHED */
 }
 
@@ -10899,21 +10805,21 @@ synerror(const char *msg)
  * called by editline -- any expansions to the prompt
  *    should be added here.
  */
-static void
-setprompt(int whichprompt)
+static void setprompt(int whichprompt)
 {
-    char *prompt;
-    switch (whichprompt) {
+        char *prompt;
+
+        switch (whichprompt) {
         case 1:
                 prompt = ps1val();
                 break;
         case 2:
                 prompt = ps2val();
                 break;
-        default:                /* 0 */
+        default:                        /* 0 */
                 prompt = "";
-    }
-    putprompt(prompt);
+        }
+        putprompt(prompt);
 }
 
 
@@ -10921,9 +10827,9 @@ setprompt(int whichprompt)
  * Code for dealing with input/output redirection.
  */
 
-#define EMPTY -2                /* marks an unused slot in redirtab */
+#define EMPTY -2                /* marks an unused slot in redirtab */
 #ifndef PIPE_BUF
-# define PIPESIZE 4096          /* amount of buffering in a pipe */
+# define PIPESIZE 4096  /* amount of buffering in a pipe */
 #else
 # define PIPESIZE PIPE_BUF
 #endif
@@ -10933,8 +10839,7 @@ setprompt(int whichprompt)
  * Open a file in noclobber mode.
  * The code was copied from bash.
  */
-static inline int
-noclobberopen(const char *fname)
+static inline int noclobberopen(const char *fname)
 {
         int r, fd;
         struct stat finfo, finfo2;
@@ -10957,8 +10862,8 @@ noclobberopen(const char *fname)
          * file was not a regular file, we leave O_EXCL off.
          */
         if (r != 0)
-                return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
-        fd = open(fname, O_WRONLY|O_CREAT, 0666);
+                return open(fname, O_WRONLY | O_CREAT | O_EXCL, 0666);
+        fd = open(fname, O_WRONLY | O_CREAT, 0666);
 
         /* If the open failed, return the file descriptor right away. */
         if (fd < 0)
@@ -10977,8 +10882,8 @@ noclobberopen(const char *fname)
          * revealed that it was a regular file, and the file has not been
          * replaced, return the file descriptor.
          */
-         if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
-             finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
+        if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
+                finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
                 return fd;
 
         /* The file has been replaced.  badness. */
@@ -10993,8 +10898,7 @@ noclobberopen(const char *fname)
  * the pipe without forking.
  */
 
-static inline int
-openhere(const union node *redir)
+static inline int openhere(const union node *redir)
 {
         int pip[2];
         int len = 0;
@@ -11008,7 +10912,7 @@ openhere(const union node *redir)
                         goto out;
                 }
         }
-        if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
+        if (forkshell((struct job *) NULL, (union node *) NULL, FORK_NOJOB) == 0) {
                 close(pip[0]);
                 signal(SIGINT, SIG_IGN);
                 signal(SIGQUIT, SIG_IGN);
@@ -11023,14 +10927,13 @@ openhere(const union node *redir)
                         expandhere(redir->nhere.doc, pip[1]);
                 _exit(0);
         }
-out:
+  out:
         close(pip[1]);
         return pip[0];
 }
 
 
-static inline int
-openredirect(const union node *redir)
+static inline int openredirect(const union node *redir)
 {
         char *fname;
         int f;
@@ -11043,7 +10946,7 @@ openredirect(const union node *redir)
                 break;
         case NFROMTO:
                 fname = redir->nfile.expfname;
-                if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
+                if ((f = open(fname, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
                         goto ecreate;
                 break;
         case NTO:
@@ -11057,7 +10960,7 @@ openredirect(const union node *redir)
         case NTOOV:
                 fname = redir->nfile.expfname;
 #ifdef O_CREAT
-                if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
+                if ((f = open(fname, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
                         goto ecreate;
 #else
                 if ((f = creat(fname, 0666)) < 0)
@@ -11067,13 +10970,12 @@ openredirect(const union node *redir)
         case NAPPEND:
                 fname = redir->nfile.expfname;
 #ifdef O_APPEND
-                if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)
+                if ((f = open(fname, O_WRONLY | O_CREAT | O_APPEND, 0666)) < 0)
                         goto ecreate;
 #else
-                if ((f = open(fname, O_WRONLY)) < 0
-                 && (f = creat(fname, 0666)) < 0)
+                if ((f = open(fname, O_WRONLY)) < 0 && (f = creat(fname, 0666)) < 0)
                         goto ecreate;
-                lseek(f, (off_t)0, 2);
+                lseek(f, (off_t) 0, 2);
 #endif
                 break;
         default:
@@ -11092,9 +10994,9 @@ openredirect(const union node *redir)
         }
 
         return f;
-ecreate:
+  ecreate:
         error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
-eopen:
+  eopen:
         error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
 }
 
@@ -11107,8 +11009,7 @@ eopen:
  * stdout.
  */
 
-static void
-redirect(union node *redir, int flags)
+static void redirect(union node *redir, int flags)
 {
         union node *n;
         struct redirtab *sv = NULL;
@@ -11116,21 +11017,21 @@ redirect(union node *redir, int flags)
         int fd;
         int newfd;
         int try;
-        int fd1dup = flags & REDIR_BACKQ;; /* stdout `cmd` redir to pipe */
+        int fd1dup = flags & REDIR_BACKQ;;      /* stdout `cmd` redir to pipe */
 
         if (flags & REDIR_PUSH) {
-                sv = xmalloc(sizeof (struct redirtab));
-                for (i = 0 ; i < 10 ; i++)
+                sv = xmalloc(sizeof(struct redirtab));
+                for (i = 0; i < 10; i++)
                         sv->renamed[i] = EMPTY;
                 sv->next = redirlist;
                 redirlist = sv;
         }
-        for (n = redir ; n ; n = n->nfile.next) {
+        for (n = redir; n; n = n->nfile.next) {
                 fd = n->nfile.fd;
                 try = 0;
                 if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
-                    n->ndup.dupfd == fd)
-                        continue; /* redirect from/to same file descriptor */
+                        n->ndup.dupfd == fd)
+                        continue;       /* redirect from/to same file descriptor */
 
                 INTOFF;
                 newfd = openredirect(n);
@@ -11145,7 +11046,7 @@ redirect(union node *redir, int flags)
                                                 try++;
                                                 break;
                                         }
-                                        /* FALLTHROUGH*/
+                                        /* FALLTHROUGH */
                                 default:
                                         if (newfd >= 0) {
                                                 close(newfd);
@@ -11173,16 +11074,15 @@ redirect(union node *redir, int flags)
 }
 
 
-static void
-dupredirect(const union node *redir, int f, int fd1dup)
+static void dupredirect(const union node *redir, int f, int fd1dup)
 {
         int fd = redir->nfile.fd;
 
-        if(fd==1)
+        if (fd == 1)
                 fd1dup = 0;
         if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
-                if (redir->ndup.dupfd >= 0) {   /* if not ">&-" */
-                        if (redir->ndup.dupfd!=1 || fd1dup!=1)
+                if (redir->ndup.dupfd >= 0) {   /* if not ">&-" */
+                        if (redir->ndup.dupfd != 1 || fd1dup != 1)
                                 dup_as_newfd(redir->ndup.dupfd, fd);
                 }
                 return;
@@ -11201,14 +11101,13 @@ dupredirect(const union node *redir, int f, int fd1dup)
  * Undo the effects of the last redirection.
  */
 
-static void
-popredir(void)
+static void popredir(void)
 {
         struct redirtab *rp = redirlist;
         int i;
 
         INTOFF;
-        for (i = 0 ; i < 10 ; i++) {
+        for (i = 0; i < 10; i++) {
                 if (rp->renamed[i] != EMPTY) {
                         if (i == 0)
                                 fd0_redirected--;
@@ -11228,13 +11127,13 @@ popredir(void)
  * Discard all saved file descriptors.
  */
 
-static void
-clearredir(void) {
+static void clearredir(void)
+{
         struct redirtab *rp;
         int i;
 
-        for (rp = redirlist ; rp ; rp = rp->next) {
-                for (i = 0 ; i < 10 ; i++) {
+        for (rp = redirlist; rp; rp = rp->next) {
+                for (i = 0; i < 10; i++) {
                         if (rp->renamed[i] >= 0) {
                                 close(rp->renamed[i]);
                         }
@@ -11250,8 +11149,7 @@ clearredir(void) {
  * file descriptors left.
  */
 
-static int
-dup_as_newfd(int from, int to)
+static int dup_as_newfd(int from, int to)
 {
         int newfd;
 
@@ -11269,15 +11167,14 @@ dup_as_newfd(int from, int to)
 /*
  * Debugging stuff.
  */
-static void shtree (union node *, int, char *, FILE*);
-static void shcmd (union node *, FILE *);
-static void sharg (union node *, FILE *);
-static void indent (int, char *, FILE *);
-static void trstring (char *);
+static void shtree(union node *, int, char *, FILE *);
+static void shcmd(union node *, FILE *);
+static void sharg(union node *, FILE *);
+static void indent(int, char *, FILE *);
+static void trstring(char *);
 
 
-static void
-showtree(n)
+static void showtree(n)
         unode *n;
 {
         trputs("showtree called\n");
@@ -11285,8 +11182,7 @@ showtree(n)
 }
 
 
-static void
-shtree(union node *n, int ind, char *pfx, FILE *fp)
+static void shtree(union node *n, int ind, char *pfx, FILE * fp)
 {
         struct nodelist *lp;
         const char *s;
@@ -11295,7 +11191,7 @@ shtree(union node *n, int ind, char *pfx, FILE *fp)
                 return;
 
         indent(ind, pfx, fp);
-        switch(n->type) {
+        switch (n->type) {
         case NSEMI:
                 s = "; ";
                 goto binop;
@@ -11304,10 +11200,10 @@ shtree(union node *n, int ind, char *pfx, FILE *fp)
                 goto binop;
         case NOR:
                 s = " || ";
-binop:
+          binop:
                 shtree(n->nbinary.ch1, ind, NULL, fp);
-           /*    if (ind < 0) */
-                        fputs(s, fp);
+                /*    if (ind < 0) */
+                fputs(s, fp);
                 shtree(n->nbinary.ch2, ind, NULL, fp);
                 break;
         case NCMD:
@@ -11316,7 +11212,7 @@ binop:
                         putc('\n', fp);
                 break;
         case NPIPE:
-                for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
+                for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
                         shcmd(lp->n, fp);
                         if (lp->next)
                                 fputs(" | ", fp);
@@ -11336,8 +11232,7 @@ binop:
 
 
 
-static void
-shcmd(union node *cmd, FILE *fp)
+static void shcmd(union node *cmd, FILE * fp)
 {
         union node *np;
         int first;
@@ -11345,14 +11240,14 @@ shcmd(union node *cmd, FILE *fp)
         int dftfd;
 
         first = 1;
-        for (np = cmd->ncmd.args ; np ; np = np->narg.next) {
-                if (! first)
+        for (np = cmd->ncmd.args; np; np = np->narg.next) {
+                if (!first)
                         putchar(' ');
                 sharg(np, fp);
                 first = 0;
         }
-        for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) {
-                if (! first)
+        for (np = cmd->ncmd.redirect; np; np = np->nfile.next) {
+                if (!first)
                         putchar(' ');
 #if 1
                 s = "*error*";
@@ -11365,14 +11260,38 @@ shcmd(union node *cmd, FILE *fp)
                 }
 #else
                 switch (np->nfile.type) {
-                        case NTO:       s = ">";  dftfd = 1; break;
-                        case NAPPEND:   s = ">>"; dftfd = 1; break;
-                        case NTOFD:     s = ">&"; dftfd = 1; break;
-                        case NTOOV:     s = ">|"; dftfd = 1; break;
-                        case NFROM:     s = "<";  dftfd = 0; break;
-                        case NFROMFD:   s = "<&"; dftfd = 0; break;
-                        case NFROMTO:   s = "<>"; dftfd = 0; break;
-                        default:        s = "*error*"; dftfd = 0; break;
+                case NTO:
+                        s = ">";
+                        dftfd = 1;
+                        break;
+                case NAPPEND:
+                        s = ">>";
+                        dftfd = 1;
+                        break;
+                case NTOFD:
+                        s = ">&";
+                        dftfd = 1;
+                        break;
+                case NTOOV:
+                        s = ">|";
+                        dftfd = 1;
+                        break;
+                case NFROM:
+                        s = "<";
+                        dftfd = 0;
+                        break;
+                case NFROMFD:
+                        s = "<&";
+                        dftfd = 0;
+                        break;
+                case NFROMTO:
+                        s = "<>";
+                        dftfd = 0;
+                        break;
+                default:
+                        s = "*error*";
+                        dftfd = 0;
+                        break;
                 }
 #endif
                 if (np->nfile.fd != dftfd)
@@ -11387,8 +11306,7 @@ shcmd(union node *cmd, FILE *fp)
         }
 }
 
-static void
-sharg(union node *arg, FILE *fp)
+static void sharg(union node *arg, FILE * fp)
 {
         char *p;
         struct nodelist *bqlist;
@@ -11400,7 +11318,7 @@ sharg(union node *arg, FILE *fp)
                 abort();
         }
         bqlist = arg->narg.backquote;
-        for (p = arg->narg.text ; *p ; p++) {
+        for (p = arg->narg.text; *p; p++) {
                 switch (*p) {
                 case CTLESC:
                         putc(*++p, fp);
@@ -11455,10 +11373,10 @@ sharg(union node *arg, FILE *fp)
                         }
                         break;
                 case CTLENDVAR:
-                     putc('}', fp);
-                     break;
+                        putc('}', fp);
+                        break;
                 case CTLBACKQ:
-                case CTLBACKQ|CTLQUOTE:
+                case CTLBACKQ | CTLQUOTE:
                         putc('$', fp);
                         putc('(', fp);
                         shtree(bqlist->n, -1, NULL, fp);
@@ -11472,12 +11390,11 @@ sharg(union node *arg, FILE *fp)
 }
 
 
-static void
-indent(int amount, char *pfx, FILE *fp)
+static void indent(int amount, char *pfx, FILE * fp)
 {
         int i;
 
-        for (i = 0 ; i < amount ; i++) {
+        for (i = 0; i < amount; i++) {
                 if (pfx && i == amount - 1)
                         fputs(pfx, fp);
                 putc('\t', fp);
@@ -11494,8 +11411,7 @@ static int debug = 0;
 #endif
 
 
-static void
-trputc(int c)
+static void trputc(int c)
 {
         if (tracefile == NULL)
                 return;
@@ -11504,10 +11420,10 @@ trputc(int c)
                 fflush(tracefile);
 }
 
-static void
-trace(const char *fmt, ...)
+static void trace(const char *fmt, ...)
 {
         va_list va;
+
         va_start(va, fmt);
         if (tracefile != NULL) {
                 (void) vfprintf(tracefile, fmt, va);
@@ -11518,8 +11434,7 @@ trace(const char *fmt, ...)
 }
 
 
-static void
-trputs(const char *s)
+static void trputs(const char *s)
 {
         if (tracefile == NULL)
                 return;
@@ -11529,8 +11444,7 @@ trputs(const char *s)
 }
 
 
-static void
-trstring(char *s)
+static void trstring(char *s)
 {
         char *p;
         char c;
@@ -11538,19 +11452,39 @@ trstring(char *s)
         if (tracefile == NULL)
                 return;
         putc('"', tracefile);
-        for (p = s ; *p ; p++) {
+        for (p = s; *p; p++) {
                 switch (*p) {
-                case '\n':  c = 'n';  goto backslash;
-                case '\t':  c = 't';  goto backslash;
-                case '\r':  c = 'r';  goto backslash;
-                case '"':  c = '"';  goto backslash;
-                case '\\':  c = '\\';  goto backslash;
-                case CTLESC:  c = 'e';  goto backslash;
-                case CTLVAR:  c = 'v';  goto backslash;
-                case CTLVAR+CTLQUOTE:  c = 'V';  goto backslash;
-                case CTLBACKQ:  c = 'q';  goto backslash;
-                case CTLBACKQ+CTLQUOTE:  c = 'Q';  goto backslash;
-backslash:        putc('\\', tracefile);
+                case '\n':
+                        c = 'n';
+                        goto backslash;
+                case '\t':
+                        c = 't';
+                        goto backslash;
+                case '\r':
+                        c = 'r';
+                        goto backslash;
+                case '"':
+                        c = '"';
+                        goto backslash;
+                case '\\':
+                        c = '\\';
+                        goto backslash;
+                case CTLESC:
+                        c = 'e';
+                        goto backslash;
+                case CTLVAR:
+                        c = 'v';
+                        goto backslash;
+                case CTLVAR + CTLQUOTE:
+                        c = 'V';
+                        goto backslash;
+                case CTLBACKQ:
+                        c = 'q';
+                        goto backslash;
+                case CTLBACKQ + CTLQUOTE:
+                        c = 'Q';
+                        goto backslash;
+                  backslash:putc('\\', tracefile);
                         putc(c, tracefile);
                         break;
                 default:
@@ -11569,8 +11503,7 @@ backslash:        putc('\\', tracefile);
 }
 
 
-static void
-trargs(char **ap)
+static void trargs(char **ap)
 {
         if (tracefile == NULL)
                 return;
@@ -11585,10 +11518,10 @@ trargs(char **ap)
 }
 
 
-static void
-opentrace()
+static void opentrace()
 {
         char s[100];
+
 #ifdef O_APPEND
         int flags;
 #endif
@@ -11598,6 +11531,7 @@ opentrace()
 #ifdef not_this_way
         {
                 char *p;
+
                 if ((p = getenv("HOME")) == NULL) {
                         if (geteuid() == 0)
                                 p = "/";
@@ -11609,7 +11543,7 @@ opentrace()
         }
 #else
         strcpy(s, "./trace");
-#endif /* not_this_way */
+#endif                                                  /* not_this_way */
         if ((tracefile = wfopen(s, "a")) == NULL)
                 return;
 #ifdef O_APPEND
@@ -11619,31 +11553,30 @@ opentrace()
         fputs("\nTracing started.\n", tracefile);
         fflush(tracefile);
 }
-#endif /* DEBUG */
+#endif                                                  /* DEBUG */
 
 
 /*
  * The trap builtin.
  */
 
-static int
-trapcmd(int argc, char **argv)
+static int trapcmd(int argc, char **argv)
 {
         char *action;
         char **ap;
         int signo;
 
         if (argc <= 1) {
-                for (signo = 0 ; signo < NSIG ; signo++) {
+                for (signo = 0; signo < NSIG; signo++) {
                         if (trap[signo] != NULL) {
                                 char *p;
                                 const char *sn;
 
                                 p = single_quote(trap[signo]);
                                 sn = sys_siglist[signo];
-                                if(sn==NULL)
+                                if (sn == NULL)
                                         sn = u_signal_names(0, &signo, 0);
-                                if(sn==NULL)
+                                if (sn == NULL)
                                         sn = "???";
                                 printf("trap -- %s %s\n", p, sn);
                                 stunalloc(p);
@@ -11686,8 +11619,7 @@ trapcmd(int argc, char **argv)
  * out what it should be set to.
  */
 
-static void
-setsignal(int signo)
+static void setsignal(int signo)
 {
         int action;
         char *t;
@@ -11707,11 +11639,11 @@ setsignal(int signo)
                         break;
                 case SIGQUIT:
 #ifdef DEBUG
-                        {
+                {
 
                         if (debug)
                                 break;
-                        }
+                }
 #endif
                         /* FALLTHROUGH */
                 case SIGTERM:
@@ -11743,12 +11675,12 @@ setsignal(int signo)
                 }
                 if (act.sa_handler == SIG_IGN) {
                         if (mflag && (signo == SIGTSTP ||
-                             signo == SIGTTIN || signo == SIGTTOU)) {
-                                *t = S_IGN;     /* don't hard ignore these */
+                                                  signo == SIGTTIN || signo == SIGTTOU)) {
+                                *t = S_IGN;     /* don't hard ignore these */
                         } else
                                 *t = S_HARD_IGN;
                 } else {
-                        *t = S_RESET;   /* force to be set */
+                        *t = S_RESET;   /* force to be set */
                 }
         }
         if (*t == S_HARD_IGN || *t == action)
@@ -11765,8 +11697,7 @@ setsignal(int signo)
  * Ignore a signal.
  */
 
-static void
-ignoresig(int signo)
+static void ignoresig(int signo)
 {
         if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
                 signal(signo, SIG_IGN);
@@ -11779,8 +11710,7 @@ ignoresig(int signo)
  * Signal handler.
  */
 
-static void
-onsig(int signo)
+static void onsig(int signo)
 {
         if (signo == SIGINT && trap[SIGINT] == NULL) {
                 onint();
@@ -11796,25 +11726,24 @@ onsig(int signo)
  * handlers while we are executing a trap handler.
  */
 
-static void
-dotrap(void)
+static void dotrap(void)
 {
         int i;
         int savestatus;
 
         for (;;) {
-                for (i = 1 ; ; i++) {
+                for (i = 1;; i++) {
                         if (gotsig[i - 1])
                                 break;
                         if (i >= NSIG - 1)
                                 goto done;
                 }
                 gotsig[i - 1] = 0;
-                savestatus=exitstatus;
+                savestatus = exitstatus;
                 evalstring(trap[i], 0);
-                exitstatus=savestatus;
+                exitstatus = savestatus;
         }
-done:
+  done:
         pendingsigs = 0;
 }
 
@@ -11822,8 +11751,7 @@ done:
  * Called to exit the shell.
  */
 
-static void
-exitshell(int status)
+static void exitshell(int status)
 {
         struct jmploc loc1, loc2;
         char *p;
@@ -11840,12 +11768,12 @@ exitshell(int status)
                 trap[0] = NULL;
                 evalstring(p, 0);
         }
-l1:   handler = &loc2;                  /* probably unnecessary */
+  l1:handler = &loc2;   /* probably unnecessary */
         flushall();
 #ifdef CONFIG_ASH_JOB_CONTROL
         setjobctl(0);
 #endif
-l2:   _exit(status);
+  l2:_exit(status);
         /* NOTREACHED */
 }
 
@@ -11857,9 +11785,9 @@ static int decode_signal(const char *string, int minsig)
         return name ? signo : -1;
 }
 
-static struct var **hashvar (const char *);
-static void showvars (const char *, int, int);
-static struct var **findvar (struct var **, const char *);
+static struct var **hashvar(const char *);
+static void showvars(const char *, int, int);
+static struct var **findvar(struct var **, const char *);
 
 /*
  * Initialize the varable symbol tables and import the environment
@@ -11870,13 +11798,13 @@ static struct var **findvar (struct var **, const char *);
  * shell is initialized and again when a shell procedure is spawned.
  */
 
-static void
-initvar() {
+static void initvar()
+{
         const struct varinit *ip;
         struct var *vp;
         struct var **vpp;
 
-        for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
+        for (ip = varinit; (vp = ip->var) != NULL; ip++) {
                 if ((vp->flags & VEXPORT) == 0) {
                         vpp = hashvar(ip->text);
                         vp->next = *vpp;
@@ -11894,8 +11822,8 @@ initvar() {
                 vpp = hashvar("PS1=$");
                 vps1.next = *vpp;
                 *vpp = &vps1;
-                vps1.text = xstrdup(geteuid() ? "PS1=$ " : "PS1=# ");
-                vps1.flags = VSTRFIXED|VTEXTFIXED;
+                vps1.text = xstrdup(geteuid()? "PS1=$ " : "PS1=# ");
+                vps1.flags = VSTRFIXED | VTEXTFIXED;
         }
 #endif
 }
@@ -11905,8 +11833,7 @@ initvar() {
  * flags of the variable.  If val is NULL, the variable is unset.
  */
 
-static void
-setvar(const char *name, const char *val, int flags)
+static void setvar(const char *name, const char *val, int flags)
 {
         const char *p;
         int len;
@@ -11917,11 +11844,11 @@ setvar(const char *name, const char *val, int flags)
 
         isbad = 0;
         p = name;
-        if (! is_name(*p))
+        if (!is_name(*p))
                 isbad = 1;
         p++;
         for (;;) {
-                if (! is_in_name(*p)) {
+                if (!is_in_name(*p)) {
                         if (*p == '\0' || *p == '=')
                                 break;
                         isbad = 1;
@@ -11931,7 +11858,7 @@ setvar(const char *name, const char *val, int flags)
         namelen = p - name;
         if (isbad)
                 error("%.*s: bad variable name", namelen, name);
-        len = namelen + 2;              /* 2 is space for '=' and '\0' */
+        len = namelen + 2;      /* 2 is space for '=' and '\0' */
         if (val == NULL) {
                 flags |= VUNSET;
         } else {
@@ -11959,8 +11886,7 @@ setvar(const char *name, const char *val, int flags)
  * will go away.
  */
 
-static void
-setvareq(char *s, int flags)
+static void setvareq(char *s, int flags)
 {
         struct var *vp, **vpp;
 
@@ -11969,17 +11895,18 @@ setvareq(char *s, int flags)
         if ((vp = *findvar(vpp, s))) {
                 if (vp->flags & VREADONLY) {
                         size_t len = strchr(s, '=') - s;
+
                         error("%.*s: is read only", len, s);
                 }
                 INTOFF;
 
                 if (vp->func && (flags & VNOFUNC) == 0)
-                        (*vp->func)(strchr(s, '=') + 1);
+                        (*vp->func) (strchr(s, '=') + 1);
 
-                if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
+                if ((vp->flags & (VTEXTFIXED | VSTACK)) == 0)
                         free(vp->text);
 
-                vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET);
+                vp->flags &= ~(VTEXTFIXED | VSTACK | VUNSET);
                 vp->flags |= flags;
                 vp->text = s;
 
@@ -11995,7 +11922,7 @@ setvareq(char *s, int flags)
                 return;
         }
         /* not found */
-        vp = xmalloc(sizeof (*vp));
+        vp = xmalloc(sizeof(*vp));
         vp->flags = flags;
         vp->text = s;
         vp->next = *vpp;
@@ -12009,13 +11936,12 @@ setvareq(char *s, int flags)
  * Process a linked list of variable assignments.
  */
 
-static void
-listsetvar(struct strlist *mylist)
+static void listsetvar(struct strlist *mylist)
 {
         struct strlist *lp;
 
         INTOFF;
-        for (lp = mylist ; lp ; lp = lp->next) {
+        for (lp = mylist; lp; lp = lp->next) {
                 setvareq(xstrdup(lp->text), 0);
         }
         INTON;
@@ -12027,8 +11953,7 @@ listsetvar(struct strlist *mylist)
  * Find the value of a variable.  Returns NULL if not set.
  */
 
-static const char *
-lookupvar(const char *name)
+static const char *lookupvar(const char *name)
 {
         struct var *v;
 
@@ -12044,12 +11969,11 @@ lookupvar(const char *name)
  * Search the environment of a builtin command.
  */
 
-static const char *
-bltinlookup(const char *name)
+static const char *bltinlookup(const char *name)
 {
         const struct strlist *sp;
 
-        for (sp = cmdenviron ; sp ; sp = sp->next) {
+        for (sp = cmdenviron; sp; sp = sp->next) {
                 if (varequal(sp->text, name))
                         return strchr(sp->text, '=') + 1;
         }
@@ -12063,8 +11987,8 @@ bltinlookup(const char *name)
  * the third argument to execve when executing a program.
  */
 
-static char **
-environment() {
+static char **environment()
+{
         int nenv;
         struct var **vpp;
         struct var *vp;
@@ -12072,14 +11996,14 @@ environment() {
         char **ep;
 
         nenv = 0;
-        for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
-                for (vp = *vpp ; vp ; vp = vp->next)
+        for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
+                for (vp = *vpp; vp; vp = vp->next)
                         if (vp->flags & VEXPORT)
                                 nenv++;
         }
         ep = env = stalloc((nenv + 1) * sizeof *env);
-        for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
-                for (vp = *vpp ; vp ; vp = vp->next)
+        for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
+                for (vp = *vpp; vp; vp = vp->next)
                         if (vp->flags & VEXPORT)
                                 *ep++ = vp->text;
         }
@@ -12094,13 +12018,13 @@ environment() {
  * VSTACK set since these are currently allocated on the stack.
  */
 
-static void
-shprocvar(void) {
+static void shprocvar(void)
+{
         struct var **vpp;
         struct var *vp, **prev;
 
-        for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
-                for (prev = vpp ; (vp = *prev) != NULL ; ) {
+        for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
+                for (prev = vpp; (vp = *prev) != NULL;) {
                         if ((vp->flags & VEXPORT) == 0) {
                                 *prev = vp->next;
                                 if ((vp->flags & VTEXTFIXED) == 0)
@@ -12110,7 +12034,7 @@ shprocvar(void) {
                         } else {
                                 if (vp->flags & VSTACK) {
                                         vp->text = xstrdup(vp->text);
-                                        vp->flags &=~ VSTACK;
+                                        vp->flags &= ~VSTACK;
                                 }
                                 prev = &vp->next;
                         }
@@ -12127,8 +12051,7 @@ shprocvar(void) {
  * any variables.
  */
 
-static int
-showvarscmd(int argc, char **argv)
+static int showvarscmd(int argc, char **argv)
 {
         showvars(nullstr, VUNSET, VUNSET);
         return 0;
@@ -12140,13 +12063,12 @@ showvarscmd(int argc, char **argv)
  * The export and readonly commands.
  */
 
-static int
-exportcmd(int argc, char **argv)
+static int exportcmd(int argc, char **argv)
 {
         struct var *vp;
         char *name;
         const char *p;
-        int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
+        int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT;
         int pflag;
 
         listsetvar(cmdenviron);
@@ -12162,7 +12084,7 @@ exportcmd(int argc, char **argv)
                                 }
                         }
                         setvar(name, p, flag);
-found:;
+                  found:;
                 }
         } else {
                 showvars(argv[0], flag, 0);
@@ -12177,12 +12099,11 @@ found:;
 
 /* funcnest nonzero if we are currently evaluating a function */
 
-static int
-localcmd(int argc, char **argv)
+static int localcmd(int argc, char **argv)
 {
         char *name;
 
-        if (! funcnest)
+        if (!funcnest)
                 error("Not in a function");
         while ((name = *argptr++) != NULL) {
                 mklocal(name);
@@ -12198,17 +12119,17 @@ localcmd(int argc, char **argv)
  * "-" as a special case.
  */
 
-static void
-mklocal(char *name)
+static void mklocal(char *name)
 {
         struct localvar *lvp;
         struct var **vpp;
         struct var *vp;
 
         INTOFF;
-        lvp = xmalloc(sizeof (struct localvar));
+        lvp = xmalloc(sizeof(struct localvar));
         if (name[0] == '-' && name[1] == '\0') {
                 char *p;
+
                 p = xmalloc(sizeof optet_vals);
                 lvp->text = memcpy(p, optet_vals, sizeof optet_vals);
                 vp = NULL;
@@ -12220,13 +12141,13 @@ mklocal(char *name)
                                 setvareq(xstrdup(name), VSTRFIXED);
                         else
                                 setvar(name, NULL, VSTRFIXED);
-                        vp = *vpp;      /* the new variable */
+                        vp = *vpp;      /* the new variable */
                         lvp->text = NULL;
                         lvp->flags = VUNSET;
                 } else {
                         lvp->text = vp->text;
                         lvp->flags = vp->flags;
-                        vp->flags |= VSTRFIXED|VTEXTFIXED;
+                        vp->flags |= VSTRFIXED | VTEXTFIXED;
                         if (strchr(name, '='))
                                 setvareq(xstrdup(name), 0);
                 }
@@ -12242,19 +12163,19 @@ mklocal(char *name)
  * Called after a function returns.
  */
 
-static void
-poplocalvars() {
+static void poplocalvars()
+{
         struct localvar *lvp;
         struct var *vp;
 
         while ((lvp = localvars) != NULL) {
                 localvars = lvp->next;
                 vp = lvp->vp;
-                if (vp == NULL) {       /* $- saved */
+                if (vp == NULL) {       /* $- saved */
                         memcpy(optet_vals, lvp->text, sizeof optet_vals);
                         free(lvp->text);
-                } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
-                        (void)unsetvar(vp->text);
+                } else if ((lvp->flags & (VUNSET | VSTRFIXED)) == VUNSET) {
+                        (void) unsetvar(vp->text);
                 } else {
                         if ((vp->flags & VTEXTFIXED) == 0)
                                 free(vp->text);
@@ -12266,8 +12187,7 @@ poplocalvars() {
 }
 
 
-static int
-setvarcmd(int argc, char **argv)
+static int setvarcmd(int argc, char **argv)
 {
         if (argc <= 2)
                 return unsetcmd(argc, argv);
@@ -12285,8 +12205,7 @@ setvarcmd(int argc, char **argv)
  * with the same name.
  */
 
-static int
-unsetcmd(int argc, char **argv)
+static int unsetcmd(int argc, char **argv)
 {
         char **ap;
         int i;
@@ -12303,7 +12222,7 @@ unsetcmd(int argc, char **argv)
         if (flg_func == 0 && flg_var == 0)
                 flg_var = 1;
 
-        for (ap = argptr; *ap ; ap++) {
+        for (ap = argptr; *ap; ap++) {
                 if (flg_func)
                         unsetfunc(*ap);
                 if (flg_var)
@@ -12317,8 +12236,7 @@ unsetcmd(int argc, char **argv)
  * Unset the specified variable.
  */
 
-static int
-unsetvar(const char *s)
+static int unsetvar(const char *s)
 {
         struct var **vpp;
         struct var *vp;
@@ -12352,8 +12270,7 @@ unsetvar(const char *s)
  * Find the appropriate entry in the hash table from the name.
  */
 
-static struct var **
-hashvar(const char *p)
+static struct var **hashvar(const char *p)
 {
         unsigned int hashval;
 
@@ -12371,8 +12288,7 @@ hashvar(const char *p)
  * either '=' or '\0'.
  */
 
-static int
-varequal(const char *p, const char *q)
+static int varequal(const char *p, const char *q)
 {
         while (*p == *q++) {
                 if (*p++ == '=')
@@ -12383,15 +12299,14 @@ varequal(const char *p, const char *q)
         return 0;
 }
 
-static void
-showvars(const char *myprefix, int mask, int xor)
+static void showvars(const char *myprefix, int mask, int xor)
 {
         struct var **vpp;
         struct var *vp;
         const char *sep = myprefix == nullstr ? myprefix : spcstr;
 
-        for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
-                for (vp = *vpp ; vp ; vp = vp->next) {
+        for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
+                for (vp = *vpp; vp; vp = vp->next) {
                         if ((vp->flags & mask) ^ xor) {
                                 char *p;
                                 int len;
@@ -12400,16 +12315,14 @@ showvars(const char *myprefix, int mask, int xor)
                                 len = p - vp->text;
                                 p = single_quote(p);
 
-                                printf("%s%s%.*s%s\n", myprefix, sep, len,
-                                        vp->text, p);
+                                printf("%s%s%.*s%s\n", myprefix, sep, len, vp->text, p);
                                 stunalloc(p);
                         }
                 }
         }
 }
 
-static struct var **
-findvar(struct var **vpp, const char *name)
+static struct var **findvar(struct var **vpp, const char *name)
 {
         for (; *vpp; vpp = &(*vpp)->next) {
                 if (varequal((*vpp)->text, name)) {
@@ -12422,23 +12335,23 @@ findvar(struct var **vpp, const char *name)
 /*
  * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
  * This file contains code for the times builtin.
- * $Id: ash.c,v 1.56 2002/08/02 06:39:47 aaronl Exp $
+ * $Id: ash.c,v 1.57 2002/08/22 18:30:15 bug1 Exp $
  */
-static int timescmd (int argc, char **argv)
+static int timescmd(int argc, char **argv)
 {
         struct tms buf;
         long int clk_tck = sysconf(_SC_CLK_TCK);
 
         times(&buf);
         printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
-               (int) (buf.tms_utime / clk_tck / 60),
-               ((double) buf.tms_utime) / clk_tck,
-               (int) (buf.tms_stime / clk_tck / 60),
-               ((double) buf.tms_stime) / clk_tck,
-               (int) (buf.tms_cutime / clk_tck / 60),
-               ((double) buf.tms_cutime) / clk_tck,
-               (int) (buf.tms_cstime / clk_tck / 60),
-               ((double) buf.tms_cstime) / clk_tck);
+                   (int) (buf.tms_utime / clk_tck / 60),
+                   ((double) buf.tms_utime) / clk_tck,
+                   (int) (buf.tms_stime / clk_tck / 60),
+                   ((double) buf.tms_stime) / clk_tck,
+                   (int) (buf.tms_cutime / clk_tck / 60),
+                   ((double) buf.tms_cutime) / clk_tck,
+                   (int) (buf.tms_cstime / clk_tck / 60),
+                   ((double) buf.tms_cstime) / clk_tck);
         return 0;
 }
 
@@ -12447,9 +12360,11 @@ static int timescmd (int argc, char **argv)
 int letcmd(int argc, char **argv)
 {
         int errcode;
-        long result=0;
+        long result = 0;
+
         if (argc == 2) {
                 char *tmp, *expression, p[13];
+
                 expression = strchr(argv[1], '=');
                 if (!expression) {
                         /* Cannot use 'error()' here, or the return code
@@ -12464,7 +12379,7 @@ int letcmd(int argc, char **argv)
                         /* Cannot use 'error()' here, or the return code
                          * will be incorrect */
                         out2fmt("sh: let: ");
-                        if(errcode == -2)
+                        if (errcode == -2)
                                 out2fmt("divide by zero");
                         else
                                 out2fmt("syntax error: \"%s=%s\"\n", argv[1], expression);