Changeset 1770 in MondoRescue for branches/stable/mindi-busybox/editors/awk.c

Timestamp:

Nov 6, 2007, 11:01:53 AM (16 years ago)

Author:

Bruno Cornec

Message:

• Better output for mindi-busybox revision
• Remove dummy file created on NFS - report from Arnaud Tiger <arnaud.tiger_at_hp.com>
• strace useful for debug
• fix new versions for pb (2.0.0 for mindi and 1.7.2 for mindi-busybox)
• fix build process for mindi-busybox + options used in that version (dd for label-partitions-as-necessary)
• fix typo in label-partitions-as-necessary which doesn't seem to work
• Update to busybox 1.7.2
• perl is now required at restore time to support uuid swap partitions (and will be used for many other thigs

in the future for sure)

• next mindi version will be 2.0.0 due to all the changes made in it (udev may break working distros)
• small optimization in mindi on keyboard handling (one single find instead of multiple)
• better interaction for USB device when launching mindi manually
• attempt to automatically guess block disk size for ramdisk
• fix typos in bkphw
• Fix the remaining problem with UUID support for swap partitions
• Updates mondoarchive man page for USB support
• Adds preliminary Hardware support to mindi (Proliant SSSTK)
• Tries to add udev support also for rhel4
• Fix UUID support which was still broken.
• Be conservative in test for the start-nfs script
• Update config file for mindi-busybox for 1.7.2 migration
• Try to run around a busybox bug (1.2.2 pb on inexistant links)
• Add build content for mindi-busybox in pb
• Remove distributions content for mindi-busybox
• Fix a warning on inexistant raidtab
• Solve problem on tmpfs in restore init (Problem of inexistant symlink and busybox)
• Create MONDO_CACHE and use it everywhere + creation at start
• Really never try to eject a USB device
• Fix a issue with &> usage (replaced with 1> and 2>)
• Adds magic file to depllist in order to have file working + ldd which helps for debugging issues
• tty modes correct to avoid sh error messages
• Use ext3 normally and not ext2 instead
• USB device should be corrected after reading (take 1st part)
• Adds a mount_USB_here function derived from mount_CDROM_here
• usb detection place before /dev detection in device name at restore time
• Fix when restoring from USB: media is asked in interactive mode
• Adds USB support for mondorestore
• mount_cdrom => mount_media
• elilo.efi is now searched throughout /boot/efi and not in a fixed place as there is no standard
• untar-and-softlink => untar (+ interface change)
• suppress useless softlinks creation/removal in boot process
• avoids udevd messages on groups
• Increase # of disks to 99 as in mindi at restore time (should be a conf file parameter)
• skip existing big file creation
• seems to work correctly for USB mindi boot
• Adds group and tty link to udev conf
• Always load usb-torage (even 2.6) to initiate USB bus discovery
• Better printing of messages
• Attempt to fix a bug in supporting OpenSusE 10.3 kernel for initramfs (mindi may now use multiple regex for kernel initrd detection)
• Links were not correctly done as non relative for modules in mindi
• exclusion of modules denied now works
• Also create modules in their ordinary place, so that classical modprobe works + copy modules.dep
• Fix bugs for DENY_MODS handling
• Add device /dev/console for udev
• ide-generic should now really be excluded
• Fix a bug in major number for tty
• If udev then adds modprobe/insmod to rootfs
• tty0 is also cretaed with udev
• ide-generic put rather in DENY_MODS
• udevd remove from deplist s handled in mindi directly
• better default for mindi when using --usb
• Handles dynamically linked busybox (in case we want to use it soon ;-)
• Adds fixed devices to create for udev
• ide-generic should not be part of the initrd when using libata v2
• support a dynamically linked udev (case on Ubuntu 7.10 and Mandriva 2008.0 so should be quite generic) This will give incitation to move to dyn. linked binaries in the initrd which will help for other tasks (ia6 4)
• Improvement in udev support (do not use cl options not available in busybox)
• Udev in mindi
  • auto creation of the right links at boot time with udev-links.conf(from Mandriva 2008.0)
  • rework startup of udev as current makes kernel crash (from Mandriva 2008.0)
  • add support for 64 bits udev
• Try to render MyInsmod silent at boot time
• Adds udev support (mandatory for newest distributions to avoid remapping of devices in a different way as on the original system)
• We also need vaft format support for USB boot
• Adds libusual support (Ubuntu 7.10 needs it for USB)
• Improve Ubuntu/Debian keyboard detection and support
• pbinit adapted to new pb (0.8.10). Filtering of docs done in it
• Suppress some mondo warnings and errors on USB again
• Tries to fix lack of files in deb mindi package
• Verify should now work for USB devices
• More log/mesages improvement for USB support
• - Supress g_erase_tmpdir_and_scratchdir
• Improve some log messages for USB support
• Try to improve install in mindi to avoid issues with isolinux.cfg not installed vene if in the pkg :-(
• Improve mindi-busybox build
• In conformity with pb 0.8.9
• Add support for Ubuntu 7.10 in build process
• Add USB Key button to Menu UI (CD streamer removed)
• Attempt to fix error messages on tmp/scratch files at the end by removing those dir at the latest possible.
• Fix a bug linked to the size of the -E param which could be used (Arnaud Tiger/René Ribaud).
• Integrate ~/.pbrc content into mondorescue.pb (required project-builder >= 0.8.7)
• Put mondorescue in conformity with new pb filtering rules
• Add USB support at restore time (no test done yet). New start-usb script PB varibale added where useful
• Unmounting USB device before removal of temporary scratchdir
• Stil refining USB copy back to mondo (one command was not executed)
• No need to have the image subdor in the csratchdir when USB.
• umount the USB partition before attempting to use it
• Remove useless copy from mindi to mondo at end of USB handling

(risky merge, we are raising the limits of 2 diverging branches. The status of stable is not completely sure as such. Will need lots of tests, but it's not yet done :-()
(merge -r1692:1769 $SVN_M/branches/2.2.5)

File:

• branches/stable/mindi-busybox/editors/awk.c (modified) (126 diffs)

branches/stable/mindi-busybox/editors/awk.c

@@ -8 +8 @@
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
-#include <strings.h>
-#include <time.h>
+#include "libbb.h"
+#include "xregex.h"
 #include <math.h>
-#include <ctype.h>
-#include <getopt.h>
-
-#include "xregex.h"
-#include "busybox.h"
-
-
-#define MAXVARFMT   240
-#define MINNVBLOCK  64
+extern char **environ;
+
+/* This is a NOEXEC applet. Be very careful! */
+
+
+#define MAXVARFMT       240
+#define MINNVBLOCK      64
 
 /* variable flags */
-#define VF_NUMBER   0x0001  /* 1 = primary type is number */
-#define VF_ARRAY    0x0002  /* 1 = it's an array */
-
-#define VF_CACHED   0x0100  /* 1 = num/str value has cached str/num eq */
-#define VF_USER     0x0200  /* 1 = user input (may be numeric string) */
-#define VF_SPECIAL  0x0400  /* 1 = requires extra handling when changed */
-#define VF_WALK     0x0800  /* 1 = variable has alloc'd x.walker list */
-#define VF_FSTR     0x1000  /* 1 = string points to fstring buffer */
-#define VF_CHILD    0x2000  /* 1 = function arg; x.parent points to source */
-#define VF_DIRTY    0x4000  /* 1 = variable was set explicitly */
+#define VF_NUMBER       0x0001  /* 1 = primary type is number */
+#define VF_ARRAY        0x0002  /* 1 = it's an array */
+
+#define VF_CACHED       0x0100  /* 1 = num/str value has cached str/num eq */
+#define VF_USER         0x0200  /* 1 = user input (may be numeric string) */
+#define VF_SPECIAL      0x0400  /* 1 = requires extra handling when changed */
+#define VF_WALK         0x0800  /* 1 = variable has alloc'd x.walker list */
+#define VF_FSTR         0x1000  /* 1 = var::string points to fstring buffer */
+#define VF_CHILD        0x2000  /* 1 = function arg; x.parent points to source */
+#define VF_DIRTY        0x4000  /* 1 = variable was set explicitly */
 
 /* these flags are static, don't change them when value is changed */
-#define VF_DONTTOUCH (VF_ARRAY | VF_SPECIAL | VF_WALK | VF_CHILD | VF_DIRTY)
+#define VF_DONTTOUCH    (VF_ARRAY | VF_SPECIAL | VF_WALK | VF_CHILD | VF_DIRTY)
 
 /* Variable */
 typedef struct var_s {
-    unsigned short type;        /* flags */
+    unsigned type;            /* flags */
     double number;
     char *string;
     union {
-        int aidx;               /* func arg idx (for compilation stage) */
-        struct xhash_s *array;  /* array ptr */
-        struct var_s *parent;   /* for func args, ptr to actual parameter */
-        char **walker;          /* list of array elements (for..in) */
+        int aidx;               /* func arg idx (for compilation stage) */
+        struct xhash_s *array;  /* array ptr */
+        struct var_s *parent;   /* for func args, ptr to actual parameter */
+        char **walker;          /* list of array elements (for..in) */
     } x;
 } var;
@@ -58 +51 @@
     struct node_s *first;
     struct node_s *last;
-    char *programname;
+    const char *programname;
 } chain;
 
 /* Function */
 typedef struct func_s {
-    unsigned short nargs;
+    unsigned nargs;
     struct chain_s body;
 } func;
@@ -74 +67 @@
     int size;
     int pos;
-    unsigned short is_pipe;
+    smallint is_pipe;
 } rstream;
 
 typedef struct hash_item_s {
     union {
-        struct var_s v;         /* variable/array hash */
-        struct rstream_s rs;    /* redirect streams hash */
-        struct func_s f;        /* functions hash */
+        struct var_s v;         /* variable/array hash */
+        struct rstream_s rs;    /* redirect streams hash */
+        struct func_s f;        /* functions hash */
     } data;
-    struct hash_item_s *next;   /* next in chain */
-    char name[1];               /* really it's longer */
+    struct hash_item_s *next;       /* next in chain */
+    char name[1];                   /* really it's longer */
 } hash_item;
 
 typedef struct xhash_s {
-    unsigned int nel;                   /* num of elements */
-    unsigned int csize;                 /* current hash size */
-    unsigned int nprime;                /* next hash size in PRIMES[] */
-    unsigned int glen;                  /* summary length of item names */
+    unsigned nel;           /* num of elements */
+    unsigned csize;         /* current hash size */
+    unsigned nprime;        /* next hash size in PRIMES[] */
+    unsigned glen;          /* summary length of item names */
     struct hash_item_s **items;
 } xhash;
@@ -98 +91 @@
 typedef struct node_s {
     uint32_t info;
-    unsigned short lineno;
+    unsigned lineno;
     union {
         struct node_s *n;
@@ -164 +157 @@
 #define TC_NUMBER   (1 << 29)
 
-#define TC_UOPPRE   (TC_UOPPRE1 | TC_UOPPRE2)
+#define TC_UOPPRE  (TC_UOPPRE1 | TC_UOPPRE2)
 
 /* combined token classes */
-#define TC_BINOP    (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN)
-#define TC_UNARYOP  (TC_UOPPRE | TC_UOPPOST)
-#define TC_OPERAND  (TC_VARIABLE | TC_ARRAY | TC_FUNCTION | \
-    TC_BUILTIN | TC_GETLINE | TC_SEQSTART | TC_STRING | TC_NUMBER)
-
-#define TC_STATEMNT (TC_STATX | TC_WHILE)
-#define TC_OPTERM   (TC_SEMICOL | TC_NEWLINE)
+#define TC_BINOP   (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN)
+#define TC_UNARYOP (TC_UOPPRE | TC_UOPPOST)
+#define TC_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION \
+                   | TC_BUILTIN | TC_GETLINE | TC_SEQSTART | TC_STRING | TC_NUMBER)
+
+#define TC_STATEMNT (TC_STATX | TC_WHILE)
+#define TC_OPTERM  (TC_SEMICOL | TC_NEWLINE)
 
 /* word tokens, cannot mean something else if not expected */
-#define TC_WORD     (TC_IN | TC_STATEMNT | TC_ELSE | TC_BUILTIN | \
-    TC_GETLINE | TC_FUNCDECL | TC_BEGIN | TC_END)
+#define TC_WORD    (TC_IN | TC_STATEMNT | TC_ELSE | TC_BUILTIN \
+                   | TC_GETLINE | TC_FUNCDECL | TC_BEGIN | TC_END)
 
 /* discard newlines after these */
-#define TC_NOTERM   (TC_COMMA | TC_GRPSTART | TC_GRPTERM | \
-    TC_BINOP | TC_OPTERM)
+#define TC_NOTERM  (TC_COMMA | TC_GRPSTART | TC_GRPTERM \
+                   | TC_BINOP | TC_OPTERM)
 
 /* what can expression begin with */
-#define TC_OPSEQ    (TC_OPERAND | TC_UOPPRE | TC_REGEXP)
+#define TC_OPSEQ   (TC_OPERAND | TC_UOPPRE | TC_REGEXP)
 /* what can group begin with */
-#define TC_GRPSEQ   (TC_OPSEQ | TC_OPTERM | TC_STATEMNT | TC_GRPSTART)
+#define TC_GRPSEQ  (TC_OPSEQ | TC_OPTERM | TC_STATEMNT | TC_GRPSTART)
 
 /* if previous token class is CONCAT1 and next is CONCAT2, concatenation */
 /* operator is inserted between them */
-#define TC_CONCAT1  (TC_VARIABLE | TC_ARRTERM | TC_SEQTERM | \
-    TC_STRING | TC_NUMBER | TC_UOPPOST)
-#define TC_CONCAT2  (TC_OPERAND | TC_UOPPRE)
-
-#define OF_RES1     0x010000
-#define OF_RES2     0x020000
-#define OF_STR1     0x040000
-#define OF_STR2     0x080000
-#define OF_NUM1     0x100000
-#define OF_CHECKED  0x200000
+#define TC_CONCAT1 (TC_VARIABLE | TC_ARRTERM | TC_SEQTERM \
+                   | TC_STRING | TC_NUMBER | TC_UOPPOST)
+#define TC_CONCAT2 (TC_OPERAND | TC_UOPPRE)
+
+#define OF_RES1    0x010000
+#define OF_RES2    0x020000
+#define OF_STR1    0x040000
+#define OF_STR2    0x080000
+#define OF_NUM1    0x100000
+#define OF_CHECKED 0x200000
 
 /* combined operator flags */
@@ -213 +206 @@
 #define SS  (OF_RES1 | OF_STR1 | OF_RES2 | OF_STR2)
 
-#define OPCLSMASK   0xFF00
-#define OPNMASK     0x007F
+#define OPCLSMASK 0xFF00
+#define OPNMASK   0x007F
 
 /* operator priority is a highest byte (even: r->l, odd: l->r grouping)
@@ -220 +213 @@
  * n - min. number of args, vN - resolve Nth arg to var, sN - resolve to string
  */
-#define P(x)    (x << 24)
-#define PRIMASK     0x7F000000
-#define PRIMASK2    0x7E000000
+#define P(x)      (x << 24)
+#define PRIMASK   0x7F000000
+#define PRIMASK2  0x7E000000
 
 /* Operation classes */
@@ -230 +223 @@
 
 enum {
-    OC_DELETE=0x0100,   OC_EXEC=0x0200,     OC_NEWSOURCE=0x0300,
-    OC_PRINT=0x0400,    OC_PRINTF=0x0500,   OC_WALKINIT=0x0600,
-
-    OC_BR=0x0700,       OC_BREAK=0x0800,    OC_CONTINUE=0x0900,
-    OC_EXIT=0x0a00,     OC_NEXT=0x0b00,     OC_NEXTFILE=0x0c00,
-    OC_TEST=0x0d00,     OC_WALKNEXT=0x0e00,
-
-    OC_BINARY=0x1000,   OC_BUILTIN=0x1100,  OC_COLON=0x1200,
-    OC_COMMA=0x1300,    OC_COMPARE=0x1400,  OC_CONCAT=0x1500,
-    OC_FBLTIN=0x1600,   OC_FIELD=0x1700,    OC_FNARG=0x1800,
-    OC_FUNC=0x1900,     OC_GETLINE=0x1a00,  OC_IN=0x1b00,
-    OC_LAND=0x1c00,     OC_LOR=0x1d00,      OC_MATCH=0x1e00,
-    OC_MOVE=0x1f00,     OC_PGETLINE=0x2000, OC_REGEXP=0x2100,
-    OC_REPLACE=0x2200,  OC_RETURN=0x2300,   OC_SPRINTF=0x2400,
-    OC_TERNARY=0x2500,  OC_UNARY=0x2600,    OC_VAR=0x2700,
-    OC_DONE=0x2800,
-
-    ST_IF=0x3000,       ST_DO=0x3100,       ST_FOR=0x3200,
-    ST_WHILE=0x3300
+    OC_DELETE = 0x0100,     OC_EXEC = 0x0200,       OC_NEWSOURCE = 0x0300,
+    OC_PRINT = 0x0400,      OC_PRINTF = 0x0500,     OC_WALKINIT = 0x0600,
+
+    OC_BR = 0x0700,         OC_BREAK = 0x0800,      OC_CONTINUE = 0x0900,
+    OC_EXIT = 0x0a00,       OC_NEXT = 0x0b00,       OC_NEXTFILE = 0x0c00,
+    OC_TEST = 0x0d00,       OC_WALKNEXT = 0x0e00,
+
+    OC_BINARY = 0x1000,     OC_BUILTIN = 0x1100,    OC_COLON = 0x1200,
+    OC_COMMA = 0x1300,      OC_COMPARE = 0x1400,    OC_CONCAT = 0x1500,
+    OC_FBLTIN = 0x1600,     OC_FIELD = 0x1700,      OC_FNARG = 0x1800,
+    OC_FUNC = 0x1900,       OC_GETLINE = 0x1a00,    OC_IN = 0x1b00,
+    OC_LAND = 0x1c00,       OC_LOR = 0x1d00,        OC_MATCH = 0x1e00,
+    OC_MOVE = 0x1f00,       OC_PGETLINE = 0x2000,   OC_REGEXP = 0x2100,
+    OC_REPLACE = 0x2200,    OC_RETURN = 0x2300,     OC_SPRINTF = 0x2400,
+    OC_TERNARY = 0x2500,    OC_UNARY = 0x2600,      OC_VAR = 0x2700,
+    OC_DONE = 0x2800,
+
+    ST_IF = 0x3000,         ST_DO = 0x3100,         ST_FOR = 0x3200,
+    ST_WHILE = 0x3300
 };
 
 /* simple builtins */
 enum {
-    F_in=0, F_rn,   F_co,   F_ex,   F_lg,   F_si,   F_sq,   F_sr,
+    F_in,   F_rn,   F_co,   F_ex,   F_lg,   F_si,   F_sq,   F_sr,
     F_ti,   F_le,   F_sy,   F_ff,   F_cl
 };
@@ -259 +252 @@
 /* builtins */
 enum {
-    B_a2=0, B_ix,   B_ma,   B_sp,   B_ss,   B_ti,   B_lo,   B_up,
-    B_ge,   B_gs,   B_su
+    B_a2,   B_ix,   B_ma,   B_sp,   B_ss,   B_ti,   B_lo,   B_up,
+    B_ge,   B_gs,   B_su,
+    B_an,   B_co,   B_ls,   B_or,   B_rs,   B_xo,
 };
 
 /* tokens and their corresponding info values */
 
-#define NTC     "\377"      /* switch to next token class (tc<<1) */
-#define NTCC    '\377'
+#define NTC     "\377"  /* switch to next token class (tc<<1) */
+#define NTCC    '\377'
 
 #define OC_B    OC_BUILTIN
 
-static char * const tokenlist =
-    "\1("       NTC
-    "\1)"       NTC
-    "\1/"       NTC                                 /* REGEXP */
-    "\2>>"      "\1>"       "\1|"       NTC         /* OUTRDR */
-    "\2++"      "\2--"      NTC                     /* UOPPOST */
-    "\2++"      "\2--"      "\1$"       NTC         /* UOPPRE1 */
-    "\2=="      "\1="       "\2+="      "\2-="      /* BINOPX */
-    "\2*="      "\2/="      "\2%="      "\2^="
-    "\1+"       "\1-"       "\3**="     "\2**"
-    "\1/"       "\1%"       "\1^"       "\1*"
-    "\2!="      "\2>="      "\2<="      "\1>"
-    "\1<"       "\2!~"      "\1~"       "\2&&"
-    "\2||"      "\1?"       "\1:"       NTC
-    "\2in"      NTC
-    "\1,"       NTC
-    "\1|"       NTC
-    "\1+"       "\1-"       "\1!"       NTC         /* UOPPRE2 */
-    "\1]"       NTC
-    "\1{"       NTC
-    "\1}"       NTC
-    "\1;"       NTC
-    "\1\n"      NTC
-    "\2if"      "\2do"      "\3for"     "\5break"   /* STATX */
-    "\10continue"           "\6delete"  "\5print"
-    "\6printf"  "\4next"    "\10nextfile"
-    "\6return"  "\4exit"    NTC
-    "\5while"   NTC
-    "\4else"    NTC
-
-    "\5close"   "\6system"  "\6fflush"  "\5atan2"   /* BUILTIN */
-    "\3cos"     "\3exp"     "\3int"     "\3log"
-    "\4rand"    "\3sin"     "\4sqrt"    "\5srand"
-    "\6gensub"  "\4gsub"    "\5index"   "\6length"
-    "\5match"   "\5split"   "\7sprintf" "\3sub"
-    "\6substr"  "\7systime" "\10strftime"
-    "\7tolower" "\7toupper" NTC
-    "\7getline" NTC
-    "\4func"    "\10function"   NTC
-    "\5BEGIN"   NTC
-    "\3END"     "\0"
+static const char tokenlist[] ALIGN1 =
+    "\1("       NTC
+    "\1)"       NTC
+    "\1/"       NTC                                 /* REGEXP */
+    "\2>>"      "\1>"       "\1|"       NTC         /* OUTRDR */
+    "\2++"      "\2--"      NTC                     /* UOPPOST */
+    "\2++"      "\2--"      "\1$"       NTC         /* UOPPRE1 */
+    "\2=="      "\1="       "\2+="      "\2-="      /* BINOPX */
+    "\2*="      "\2/="      "\2%="      "\2^="
+    "\1+"       "\1-"       "\3**="     "\2**"
+    "\1/"       "\1%"       "\1^"       "\1*"
+    "\2!="      "\2>="      "\2<="      "\1>"
+    "\1<"       "\2!~"      "\1~"       "\2&&"
+    "\2||"      "\1?"       "\1:"       NTC
+    "\2in"      NTC
+    "\1,"       NTC
+    "\1|"       NTC
+    "\1+"       "\1-"       "\1!"       NTC         /* UOPPRE2 */
+    "\1]"       NTC
+    "\1{"       NTC
+    "\1}"       NTC
+    "\1;"       NTC
+    "\1\n"      NTC
+    "\2if"      "\2do"      "\3for"     "\5break"   /* STATX */
+    "\10continue"           "\6delete"  "\5print"
+    "\6printf"  "\4next"    "\10nextfile"
+    "\6return"  "\4exit"    NTC
+    "\5while"   NTC
+    "\4else"    NTC
+
+    "\3and"     "\5compl"   "\6lshift"  "\2or"
+    "\6rshift"  "\3xor"
+    "\5close"   "\6system"  "\6fflush"  "\5atan2"   /* BUILTIN */
+    "\3cos"     "\3exp"     "\3int"     "\3log"
+    "\4rand"    "\3sin"     "\4sqrt"    "\5srand"
+    "\6gensub"  "\4gsub"    "\5index"   "\6length"
+    "\5match"   "\5split"   "\7sprintf" "\3sub"
+    "\6substr"  "\7systime" "\10strftime"
+    "\7tolower" "\7toupper" NTC
+    "\7getline" NTC
+    "\4func"    "\10function"   NTC
+    "\5BEGIN"   NTC
+    "\3END"     "\0"
     ;
 
 static const uint32_t tokeninfo[] = {
-
     0,
     0,
     OC_REGEXP,
-    xS|'a',     xS|'w',     xS|'|',
-    OC_UNARY|xV|P(9)|'p',       OC_UNARY|xV|P(9)|'m',
-    OC_UNARY|xV|P(9)|'P',       OC_UNARY|xV|P(9)|'M',
-        OC_FIELD|xV|P(5),
-    OC_COMPARE|VV|P(39)|5,      OC_MOVE|VV|P(74),
-        OC_REPLACE|NV|P(74)|'+',    OC_REPLACE|NV|P(74)|'-',
-    OC_REPLACE|NV|P(74)|'*',    OC_REPLACE|NV|P(74)|'/',
-        OC_REPLACE|NV|P(74)|'%',    OC_REPLACE|NV|P(74)|'&',
-    OC_BINARY|NV|P(29)|'+',     OC_BINARY|NV|P(29)|'-',
-        OC_REPLACE|NV|P(74)|'&',    OC_BINARY|NV|P(15)|'&',
-    OC_BINARY|NV|P(25)|'/',     OC_BINARY|NV|P(25)|'%',
-        OC_BINARY|NV|P(15)|'&',     OC_BINARY|NV|P(25)|'*',
-    OC_COMPARE|VV|P(39)|4,      OC_COMPARE|VV|P(39)|3,
-        OC_COMPARE|VV|P(39)|0,      OC_COMPARE|VV|P(39)|1,
-    OC_COMPARE|VV|P(39)|2,      OC_MATCH|Sx|P(45)|'!',
-        OC_MATCH|Sx|P(45)|'~',      OC_LAND|Vx|P(55),
-    OC_LOR|Vx|P(59),            OC_TERNARY|Vx|P(64)|'?',
-        OC_COLON|xx|P(67)|':',
+    xS|'a',     xS|'w',     xS|'|',
+    OC_UNARY|xV|P(9)|'p',       OC_UNARY|xV|P(9)|'m',
+    OC_UNARY|xV|P(9)|'P',       OC_UNARY|xV|P(9)|'M',
+        OC_FIELD|xV|P(5),
+    OC_COMPARE|VV|P(39)|5,      OC_MOVE|VV|P(74),
+        OC_REPLACE|NV|P(74)|'+',    OC_REPLACE|NV|P(74)|'-',
+    OC_REPLACE|NV|P(74)|'*',    OC_REPLACE|NV|P(74)|'/',
+        OC_REPLACE|NV|P(74)|'%',    OC_REPLACE|NV|P(74)|'&',
+    OC_BINARY|NV|P(29)|'+',     OC_BINARY|NV|P(29)|'-',
+        OC_REPLACE|NV|P(74)|'&',    OC_BINARY|NV|P(15)|'&',
+    OC_BINARY|NV|P(25)|'/',     OC_BINARY|NV|P(25)|'%',
+        OC_BINARY|NV|P(15)|'&',     OC_BINARY|NV|P(25)|'*',
+    OC_COMPARE|VV|P(39)|4,      OC_COMPARE|VV|P(39)|3,
+        OC_COMPARE|VV|P(39)|0,      OC_COMPARE|VV|P(39)|1,
+    OC_COMPARE|VV|P(39)|2,      OC_MATCH|Sx|P(45)|'!',
+        OC_MATCH|Sx|P(45)|'~',      OC_LAND|Vx|P(55),
+    OC_LOR|Vx|P(59),            OC_TERNARY|Vx|P(64)|'?',
+        OC_COLON|xx|P(67)|':',
     OC_IN|SV|P(49),
     OC_COMMA|SS|P(80),
     OC_PGETLINE|SV|P(37),
-    OC_UNARY|xV|P(19)|'+',      OC_UNARY|xV|P(19)|'-',
-        OC_UNARY|xV|P(19)|'!',
+    OC_UNARY|xV|P(19)|'+',      OC_UNARY|xV|P(19)|'-',
+        OC_UNARY|xV|P(19)|'!',
     0,
     0,
@@ -346 +341 @@
     0,
     0,
-    ST_IF,          ST_DO,          ST_FOR,         OC_BREAK,
-    OC_CONTINUE,                    OC_DELETE|Vx,   OC_PRINT,
-    OC_PRINTF,      OC_NEXT,        OC_NEXTFILE,
-    OC_RETURN|Vx,   OC_EXIT|Nx,
+    ST_IF,          ST_DO,          ST_FOR,         OC_BREAK,
+    OC_CONTINUE,                    OC_DELETE|Vx,   OC_PRINT,
+    OC_PRINTF,      OC_NEXT,        OC_NEXTFILE,
+    OC_RETURN|Vx,   OC_EXIT|Nx,
     ST_WHILE,
     0,
 
+    OC_B|B_an|P(0x83), OC_B|B_co|P(0x41), OC_B|B_ls|P(0x83), OC_B|B_or|P(0x83),
+    OC_B|B_rs|P(0x83), OC_B|B_xo|P(0x83),
     OC_FBLTIN|Sx|F_cl, OC_FBLTIN|Sx|F_sy, OC_FBLTIN|Sx|F_ff, OC_B|B_a2|P(0x83),
     OC_FBLTIN|Nx|F_co, OC_FBLTIN|Nx|F_ex, OC_FBLTIN|Nx|F_in, OC_FBLTIN|Nx|F_lg,
@@ -369 +366 @@
 /* asterisk marks SPECIAL vars; $ is just no-named Field0 */
 enum {
-    CONVFMT=0,  OFMT,       FS,         OFS,
-    ORS,        RS,         RT,         FILENAME,
-    SUBSEP,     ARGIND,     ARGC,       ARGV,
-    ERRNO,      FNR,
-    NR,         NF,         IGNORECASE,
-    ENVIRON,    F0,         _intvarcount_
+    CONVFMT,    OFMT,       FS,         OFS,
+    ORS,        RS,         RT,         FILENAME,
+    SUBSEP,     ARGIND,     ARGC,       ARGV,
+    ERRNO,      FNR,
+    NR,         NF,         IGNORECASE,
+    ENVIRON,    F0,         NUM_INTERNAL_VARS
 };
 
-static char * vNames =
-    "CONVFMT\0" "OFMT\0"    "FS\0*"     "OFS\0"
-    "ORS\0"     "RS\0*"     "RT\0"      "FILENAME\0"
-    "SUBSEP\0"  "ARGIND\0"  "ARGC\0"    "ARGV\0"
-    "ERRNO\0"   "FNR\0"
-    "NR\0"      "NF\0*"     "IGNORECASE\0*"
-    "ENVIRON\0" "$\0*"      "\0";
-
-static char * vValues =
-    "%.6g\0"    "%.6g\0"    " \0"       " \0"
-    "\n\0"      "\n\0"      "\0"        "\0"
+static const char vNames[] ALIGN1 =
+    "CONVFMT\0" "OFMT\0"    "FS\0*"     "OFS\0"
+    "ORS\0"     "RS\0*"     "RT\0"      "FILENAME\0"
+    "SUBSEP\0"  "ARGIND\0"  "ARGC\0"    "ARGV\0"
+    "ERRNO\0"   "FNR\0"
+    "NR\0"      "NF\0*"     "IGNORECASE\0*"
+    "ENVIRON\0" "$\0*"      "\0";
+
+static const char vValues[] ALIGN1 =
+    "%.6g\0"    "%.6g\0"    " \0"       " \0"
+    "\n\0"      "\n\0"      "\0"        "\0"
     "\034\0"
     "\377";
 
 /* hash size may grow to these values */
-#define FIRST_PRIME 61;
-static const unsigned int PRIMES[] = { 251, 1021, 4093, 16381, 65521 };
-enum { NPRIMES = sizeof(PRIMES) / sizeof(unsigned int) };
-
-/* globals */
-
-extern char **environ;
-
-static var * V[_intvarcount_];
-static chain beginseq, mainseq, endseq, *seq;
-static int nextrec, nextfile;
-static node *break_ptr, *continue_ptr;
-static rstream *iF;
-static xhash *vhash, *ahash, *fdhash, *fnhash;
-static char *programname;
-static short lineno;
-static int is_f0_split;
-static int nfields;
-static var *Fields;
-static tsplitter fsplitter, rsplitter;
-static nvblock *cb;
-static char *pos;
-static char *buf;
-static int icase;
-static int exiting;
-
-static struct {
-    uint32_t tclass;
-    uint32_t info;
-    char *string;
-    double number;
-    short lineno;
-    int rollback;
-} t;
+#define FIRST_PRIME 61
+static const uint16_t PRIMES[] ALIGN2 = { 251, 1021, 4093, 16381, 65521 };
+
+
+/* Globals. Split in two parts so that first one is addressed
+ * with (mostly short) negative offsets */
+struct globals {
+    chain beginseq, mainseq, endseq, *seq;
+    node *break_ptr, *continue_ptr;
+    rstream *iF;
+    xhash *vhash, *ahash, *fdhash, *fnhash;
+    const char *g_progname;
+    int g_lineno;
+    int nfields;
+    int maxfields; /* used in fsrealloc() only */
+    var *Fields;
+    nvblock *g_cb;
+    char *g_pos;
+    char *g_buf;
+    smallint icase;
+    smallint exiting;
+    smallint nextrec;
+    smallint nextfile;
+    smallint is_f0_split;
+};
+struct globals2 {
+    uint32_t t_info; /* often used */
+    uint32_t t_tclass;
+    char *t_string;
+    int t_lineno;
+    int t_rollback;
+
+    var *intvar[NUM_INTERNAL_VARS]; /* often used */
+
+    /* former statics from various functions */
+    char *split_f0__fstrings;
+
+    uint32_t next_token__save_tclass;
+    uint32_t next_token__save_info;
+    uint32_t next_token__ltclass;
+    smallint next_token__concat_inserted;
+
+    smallint next_input_file__files_happen;
+    rstream next_input_file__rsm;
+
+    var *evaluate__fnargs;
+    unsigned evaluate__seed;
+    regex_t evaluate__sreg;
+
+    var ptest__v;
+
+    tsplitter exec_builtin__tspl;
+
+    /* biggest and least used members go last */
+    double t_double;
+    tsplitter fsplitter, rsplitter;
+};
+#define G1 (ptr_to_globals[-1])
+#define G (*(struct globals2 *const)ptr_to_globals)
+/* For debug. nm --size-sort awk.o | grep -vi ' [tr] ' */
+/* char G1size[sizeof(G1)]; - 0x6c */
+/* char Gsize[sizeof(G)]; - 0x1cc */
+/* Trying to keep most of members accessible with short offsets: */
+/* char Gofs_seed[offsetof(struct globals2, evaluate__seed)]; - 0x90 */
+#define beginseq     (G1.beginseq    )
+#define mainseq      (G1.mainseq     )
+#define endseq       (G1.endseq      )
+#define seq          (G1.seq         )
+#define break_ptr    (G1.break_ptr   )
+#define continue_ptr (G1.continue_ptr)
+#define iF           (G1.iF          )
+#define vhash        (G1.vhash       )
+#define ahash        (G1.ahash       )
+#define fdhash       (G1.fdhash      )
+#define fnhash       (G1.fnhash      )
+#define g_progname   (G1.g_progname  )
+#define g_lineno     (G1.g_lineno    )
+#define nfields      (G1.nfields     )
+#define maxfields    (G1.maxfields   )
+#define Fields       (G1.Fields      )
+#define g_cb         (G1.g_cb        )
+#define g_pos        (G1.g_pos       )
+#define g_buf        (G1.g_buf       )
+#define icase        (G1.icase       )
+#define exiting      (G1.exiting     )
+#define nextrec      (G1.nextrec     )
+#define nextfile     (G1.nextfile    )
+#define is_f0_split  (G1.is_f0_split )
+#define t_info       (G.t_info      )
+#define t_tclass     (G.t_tclass    )
+#define t_string     (G.t_string    )
+#define t_double     (G.t_double    )
+#define t_lineno     (G.t_lineno    )
+#define t_rollback   (G.t_rollback  )
+#define intvar       (G.intvar      )
+#define fsplitter    (G.fsplitter   )
+#define rsplitter    (G.rsplitter   )
+#define INIT_G() do { \
+    PTR_TO_GLOBALS = xzalloc(sizeof(G1) + sizeof(G)) + sizeof(G1); \
+    G.next_token__ltclass = TC_OPTERM; \
+    G.evaluate__seed = 1; \
+} while (0)
+
 
 /* function prototypes */
@@ -438 +504 @@
 /* ---- error handling ---- */
 
-static const char EMSG_INTERNAL_ERROR[] = "Internal error";
-static const char EMSG_UNEXP_EOS[] = "Unexpected end of string";
-static const char EMSG_UNEXP_TOKEN[] = "Unexpected token";
-static const char EMSG_DIV_BY_ZERO[] = "Division by zero";
-static const char EMSG_INV_FMT[] = "Invalid format specifier";
-static const char EMSG_TOO_FEW_ARGS[] = "Too few arguments for builtin";
-static const char EMSG_NOT_ARRAY[] = "Not an array";
-static const char EMSG_POSSIBLE_ERROR[] = "Possible syntax error";
-static const char EMSG_UNDEF_FUNC[] = "Call to undefined function";
-#ifndef CONFIG_FEATURE_AWK_MATH
-static const char EMSG_NO_MATH[] = "Math support is not compiled in";
+static const char EMSG_INTERNAL_ERROR[] ALIGN1 = "Internal error";
+static const char EMSG_UNEXP_EOS[] ALIGN1 = "Unexpected end of string";
+static const char EMSG_UNEXP_TOKEN[] ALIGN1 = "Unexpected token";
+static const char EMSG_DIV_BY_ZERO[] ALIGN1 = "Division by zero";
+static const char EMSG_INV_FMT[] ALIGN1 = "Invalid format specifier";
+static const char EMSG_TOO_FEW_ARGS[] ALIGN1 = "Too few arguments for builtin";
+static const char EMSG_NOT_ARRAY[] ALIGN1 = "Not an array";
+static const char EMSG_POSSIBLE_ERROR[] ALIGN1 = "Possible syntax error";
+static const char EMSG_UNDEF_FUNC[] ALIGN1 = "Call to undefined function";
+#if !ENABLE_FEATURE_AWK_MATH
+static const char EMSG_NO_MATH[] ALIGN1 = "Math support is not compiled in";
 #endif
 
-static void syntax_error(const char * const message) ATTRIBUTE_NORETURN;
-static void syntax_error(const char * const message)
-{
-    bb_error_msg_and_die("%s:%i: %s", programname, lineno, message);
-}
-
-#define runtime_error(x) syntax_error(x)
-
+static void zero_out_var(var * vp)
+{
+    memset(vp, 0, sizeof(*vp));
+}
+
+static void syntax_error(const char *const message) ATTRIBUTE_NORETURN;
+static void syntax_error(const char *const message)
+{
+    bb_error_msg_and_die("%s:%i: %s", g_progname, g_lineno, message);
+}
 
 /* ---- hash stuff ---- */
 
-static unsigned int hashidx(const char *name)
-{
-    register unsigned int idx=0;
-
-    while (*name)  idx = *name++ + (idx << 6) - idx;
+static unsigned hashidx(const char *name)
+{
+    unsigned idx = 0;
+
+    while (*name) idx = *name++ + (idx << 6) - idx;
     return idx;
 }
@@ -475 +543 @@
     xhash *newhash;
 
-    newhash = (xhash *)xzalloc(sizeof(xhash));
+    newhash = xzalloc(sizeof(xhash));
     newhash->csize = FIRST_PRIME;
-    newhash->items = (hash_item **)xzalloc(newhash->csize * sizeof(hash_item *));
+    newhash->items = xzalloc(newhash->csize * sizeof(hash_item *));
 
     return newhash;
@@ -499 +567 @@
 static void hash_rebuild(xhash *hash)
 {
-    unsigned int newsize, i, idx;
+    unsigned newsize, i, idx;
     hash_item **newitems, *hi, *thi;
 
-    if (hash->nprime == NPRIMES)
+    if (hash->nprime == ARRAY_SIZE(PRIMES))
         return;
 
     newsize = PRIMES[hash->nprime++];
-    newitems = (hash_item **)xzalloc(newsize * sizeof(hash_item *));
-
-    for (i=0; i<hash->csize; i++) {
+    newitems = xzalloc(newsize * sizeof(hash_item *));
+
+    for (i = 0; i < hash->csize; i++) {
         hi = hash->items[i];
         while (hi) {
@@ -528 +596 @@
 {
     hash_item *hi;
-    unsigned int idx;
+    unsigned idx;
     int l;
 
     hi = hash_search(hash, name);
-    if (! hi) {
+    if (!hi) {
         if (++hash->nel / hash->csize > 10)
             hash_rebuild(hash);
@@ -548 +616 @@
 }
 
-#define findvar(hash, name) (var *) hash_find ( (hash) , (name) )
-#define newvar(name) (var *) hash_find ( vhash , (name) )
-#define newfile(name) (rstream *) hash_find ( fdhash , (name) )
-#define newfunc(name) (func *) hash_find ( fnhash , (name) )
+#define findvar(hash, name) ((var*)    hash_find((hash), (name)))
+#define newvar(name)        ((var*)    hash_find(vhash, (name)))
+#define newfile(name)       ((rstream*)hash_find(fdhash, (name)))
+#define newfunc(name)       ((func*)   hash_find(fnhash, (name)))
 
 static void hash_remove(xhash *hash, const char *name)
@@ -557 +625 @@
     hash_item *hi, **phi;
 
-    phi = &(hash->items[ hashidx(name) % hash->csize ]);
+    phi = &(hash->items[hashidx(name) % hash->csize]);
     while (*phi) {
         hi = *phi;
@@ -575 +643 @@
 static void skip_spaces(char **s)
 {
-    register char *p = *s;
-
-    while(*p == ' ' || *p == '\t' ||
-            (*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) {
+    char *p = *s;
+
+    while (1) {
+        if (*p == '\\' && p[1] == '\n') {
+            p++;
+            t_lineno++;
+        } else if (*p != ' ' && *p != '\t') {
+            break;
+        }
         p++;
     }
@@ -586 +659 @@
 static char *nextword(char **s)
 {
-    register char *p = *s;
-
-    while (*(*s)++) ;
+    char *p = *s;
+
+    while (*(*s)++) /* */;
 
     return p;
@@ -595 +668 @@
 static char nextchar(char **s)
 {
-    register char c, *pps;
+    char c, *pps;
 
     c = *((*s)++);
@@ -604 +677 @@
 }
 
-static inline int isalnum_(int c)
+static int ALWAYS_INLINE isalnum_(int c)
 {
     return (isalnum(c) || c == '_');
@@ -611 +684 @@
 static FILE *afopen(const char *path, const char *mode)
 {
-    return (*path == '-' && *(path+1) == '\0') ? stdin : bb_xfopen(path, mode);
+    return (*path == '-' && *(path+1) == '\0') ? stdin : xfopen(path, mode);
 }
 
@@ -623 +696 @@
         a = a->x.parent;
 
-    if (! (a->type & VF_ARRAY)) {
+    if (!(a->type & VF_ARRAY)) {
         a->type |= VF_ARRAY;
         a->x.array = hash_init();
@@ -632 +705 @@
 static void clear_array(xhash *array)
 {
-    unsigned int i;
+    unsigned i;
     hash_item *hi, *thi;
 
-    for (i=0; i<array->csize; i++) {
+    for (i = 0; i < array->csize; i++) {
         hi = array->items[i];
         while (hi) {
@@ -666 +739 @@
     v->string = value;
     handle_special(v);
-
     return v;
 }
@@ -673 +745 @@
 static var *setvar_s(var *v, const char *value)
 {
-    return setvar_p(v, (value && *value) ? bb_xstrdup(value) : NULL);
+    return setvar_p(v, (value && *value) ? xstrdup(value) : NULL);
 }
 
@@ -687 +759 @@
 static void setari_u(var *a, int idx, const char *s)
 {
-    register var *v;
-    static char sidx[12];
+    char sidx[sizeof(int)*3 + 1];
+    var *v;
 
     sprintf(sidx, "%d", idx);
@@ -705 +777 @@
 }
 
-static char *getvar_s(var *v)
+static const char *getvar_s(var *v)
 {
     /* if v is numeric and has no cached string, convert it to string */
     if ((v->type & (VF_NUMBER | VF_CACHED)) == VF_NUMBER) {
-        fmt_num(buf, MAXVARFMT, getvar_s(V[CONVFMT]), v->number, TRUE);
-        v->string = bb_xstrdup(buf);
+        fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[CONVFMT]), v->number, TRUE);
+        v->string = xstrdup(g_buf);
         v->type |= VF_CACHED;
     }
@@ -742 +814 @@
     if (dest != src) {
         clrvar(dest);
-        dest->type |= (src->type & ~VF_DONTTOUCH);
+        dest->type |= (src->type & ~(VF_DONTTOUCH | VF_FSTR));
         dest->number = src->number;
         if (src->string)
-            dest->string = bb_xstrdup(src->string);
+            dest->string = xstrdup(src->string);
     }
     handle_special(dest);
@@ -753 +825 @@
 static var *incvar(var *v)
 {
-    return setvar_i(v, getvar_i(v)+1.);
+    return setvar_i(v, getvar_i(v) + 1.);
 }
 
@@ -768 +840 @@
     if (is_numeric(v))
         return (v->number == 0) ? 0 : 1;
-    else
-        return (v->string && *(v->string)) ? 1 : 0;
+    return (v->string && *(v->string)) ? 1 : 0;
 }
 
@@ -779 +850 @@
     int size;
 
-    while (cb) {
-        pb = cb;
-        if ((cb->pos - cb->nv) + n <= cb->size) break;
-        cb = cb->next;
-    }
-
-    if (! cb) {
+    while (g_cb) {
+        pb = g_cb;
+        if ((g_cb->pos - g_cb->nv) + n <= g_cb->size) break;
+        g_cb = g_cb->next;
+    }
+
+    if (!g_cb) {
         size = (n <= MINNVBLOCK) ? MINNVBLOCK : n;
-        cb = (nvblock *)xmalloc(sizeof(nvblock) + size * sizeof(var));
-        cb->size = size;
-        cb->pos = cb->nv;
-        cb->prev = pb;
-        cb->next = NULL;
-        if (pb) pb->next = cb;
-    }
-
-    v = r = cb->pos;
-    cb->pos += n;
-
-    while (v < cb->pos) {
+        g_cb = xmalloc(sizeof(nvblock) + size * sizeof(var));
+        g_cb->size = size;
+        g_cb->pos = g_cb->nv;
+        g_cb->prev = pb;
+        g_cb->next = NULL;
+        if (pb) pb->next = g_cb;
+    }
+
+    v = r = g_cb->pos;
+    g_cb->pos += n;
+
+    while (v < g_cb->pos) {
         v->type = 0;
         v->string = NULL;
@@ -811 +882 @@
     var *p;
 
-    if (v < cb->nv || v >= cb->pos)
-        runtime_error(EMSG_INTERNAL_ERROR);
-
-    for (p=v; p<cb->pos; p++) {
-        if ((p->type & (VF_ARRAY|VF_CHILD)) == VF_ARRAY) {
+    if (v < g_cb->nv || v >= g_cb->pos)
+        syntax_error(EMSG_INTERNAL_ERROR);
+
+    for (p = v; p < g_cb->pos; p++) {
+        if ((p->type & (VF_ARRAY | VF_CHILD)) == VF_ARRAY) {
             clear_array(iamarray(p));
             free(p->x.array->items);
@@ -826 +897 @@
     }
 
-    cb->pos = v;
-    while (cb->prev && cb->pos == cb->nv) {
-        cb = cb->prev;
+    g_cb->pos = v;
+    while (g_cb->prev && g_cb->pos == g_cb->nv) {
+        g_cb = g_cb->prev;
     }
 }
@@ -834 +905 @@
 /* ------- awk program text parsing ------- */
 
-/* Parse next token pointed by global pos, place results into global t.
+/* Parse next token pointed by global pos, place results into global ttt.
  * If token isn't expected, give away. Return token class
  */
 static uint32_t next_token(uint32_t expected)
 {
+#define concat_inserted (G.next_token__concat_inserted)
+#define save_tclass     (G.next_token__save_tclass)
+#define save_info       (G.next_token__save_info)
+/* Initialized to TC_OPTERM: */
+#define ltclass         (G.next_token__ltclass)
+
     char *p, *pp, *s;
-    char *tl;
+    const char *tl;
     uint32_t tc;
     const uint32_t *ti;
     int l;
-    static int concat_inserted;
-    static uint32_t save_tclass, save_info;
-    static uint32_t ltclass = TC_OPTERM;
-
-    if (t.rollback) {
-
-        t.rollback = FALSE;
+
+    if (t_rollback) {
+        t_rollback = FALSE;
 
     } else if (concat_inserted) {
-
         concat_inserted = FALSE;
-        t.tclass = save_tclass;
-        t.info = save_info;
+        t_tclass = save_tclass;
+        t_info = save_info;
 
     } else {
-
-        p = pos;
-
-    readnext:
+        p = g_pos;
+ readnext:
         skip_spaces(&p);
-        lineno = t.lineno;
+        g_lineno = t_lineno;
         if (*p == '#')
-            while (*p != '\n' && *p != '\0') p++;
+            while (*p != '\n' && *p != '\0')
+                p++;
 
         if (*p == '\n')
-            t.lineno++;
+            t_lineno++;
 
         if (*p == '\0') {
@@ -876 +947 @@
         } else if (*p == '\"') {
             /* it's a string */
-            t.string = s = ++p;
+            t_string = s = ++p;
             while (*p != '\"') {
                 if (*p == '\0' || *p == '\n')
@@ -888 +959 @@
         } else if ((expected & TC_REGEXP) && *p == '/') {
             /* it's regexp */
-            t.string = s = ++p;
+            t_string = s = ++p;
             while (*p != '/') {
                 if (*p == '\0' || *p == '\n')
                     syntax_error(EMSG_UNEXP_EOS);
-                if ((*s++ = *p++) == '\\') {
+                *s = *p++;
+                if (*s++ == '\\') {
                     pp = p;
                     *(s-1) = bb_process_escape_sequence((const char **)&p);
-                    if (*pp == '\\') *s++ = '\\';
-                    if (p == pp) *s++ = *p++;
+                    if (*pp == '\\')
+                        *s++ = '\\';
+                    if (p == pp)
+                        *s++ = *p++;
                 }
             }
@@ -905 +979 @@
         } else if (*p == '.' || isdigit(*p)) {
             /* it's a number */
-            t.number = strtod(p, &p);
+            t_double = strtod(p, &p);
             if (*p == '.')
                 syntax_error(EMSG_UNEXP_TOKEN);
@@ -925 +999 @@
                  * then this is what we are looking for
                  */
-                if ((tc & (expected | TC_WORD | TC_NEWLINE)) &&
-                *tl == *p && strncmp(p, tl, l) == 0 &&
-                !((tc & TC_WORD) && isalnum_(*(p + l)))) {
-                    t.info = *ti;
+                if ((tc & (expected | TC_WORD | TC_NEWLINE))
+                 && *tl == *p && strncmp(p, tl, l) == 0
+                 && !((tc & TC_WORD) && isalnum_(p[l]))
+                ) {
+                    t_info = *ti;
                     p += l;
                     break;
@@ -936 +1011 @@
             }
 
-            if (! *tl) {
+            if (!*tl) {
                 /* it's a name (var/array/function),
                  * otherwise it's something wrong
                  */
-                if (! isalnum_(*p))
+                if (!isalnum_(*p))
                     syntax_error(EMSG_UNEXP_TOKEN);
 
-                t.string = --p;
-                while(isalnum_(*(++p))) {
+                t_string = --p;
+                while (isalnum_(*(++p))) {
                     *(p-1) = *p;
                 }
@@ -950 +1025 @@
                 tc = TC_VARIABLE;
                 /* also consume whitespace between functionname and bracket */
-                if (! (expected & TC_VARIABLE)) skip_spaces(&p);
+                if (!(expected & TC_VARIABLE))
+                    skip_spaces(&p);
                 if (*p == '(') {
                     tc = TC_FUNCTION;
@@ -961 +1037 @@
             }
         }
-        pos = p;
+        g_pos = p;
 
         /* skipping newlines in some cases */
@@ -968 +1044 @@
 
         /* insert concatenation operator when needed */
-        if ((ltclass&TC_CONCAT1) && (tc&TC_CONCAT2) && (expected&TC_BINOP)) {
+        if ((ltclass & TC_CONCAT1) && (tc & TC_CONCAT2) && (expected & TC_BINOP)) {
             concat_inserted = TRUE;
             save_tclass = tc;
-            save_info = t.info;
+            save_info = t_info;
             tc = TC_BINOP;
-            t.info = OC_CONCAT | SS | P(35);
-        }
-
-        t.tclass = tc;
-    }
-    ltclass = t.tclass;
+            t_info = OC_CONCAT | SS | P(35);
+        }
+
+        t_tclass = tc;
+    }
+    ltclass = t_tclass;
 
     /* Are we ready for this? */
-    if (! (ltclass & expected))
+    if (!(ltclass & expected))
         syntax_error((ltclass & (TC_NEWLINE | TC_EOF)) ?
-                                EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN);
+                EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN);
 
     return ltclass;
-}
-
-static void rollback_token(void) { t.rollback = TRUE; }
+#undef concat_inserted
+#undef save_tclass
+#undef save_info
+#undef ltclass
+}
+
+static void rollback_token(void)
+{
+    t_rollback = TRUE;
+}
 
 static node *new_node(uint32_t info)
 {
-    register node *n;
-
-    n = (node *)xzalloc(sizeof(node));
+    node *n;
+
+    n = xzalloc(sizeof(node));
     n->info = info;
-    n->lineno = lineno;
+    n->lineno = g_lineno;
     return n;
 }
 
-static node *mk_re_node(char *s, node *n, regex_t *re)
+static node *mk_re_node(const char *s, node *n, regex_t *re)
 {
     n->info = OC_REGEXP;
@@ -1006 +1089 @@
     n->r.ire = re + 1;
     xregcomp(re, s, REG_EXTENDED);
-    xregcomp(re+1, s, REG_EXTENDED | REG_ICASE);
+    xregcomp(re + 1, s, REG_EXTENDED | REG_ICASE);
 
     return n;
@@ -1031 +1114 @@
     xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP | iexp;
 
-    while (! ((tc = next_token(xtc)) & iexp)) {
-        if (glptr && (t.info == (OC_COMPARE|VV|P(39)|2))) {
+    while (!((tc = next_token(xtc)) & iexp)) {
+        if (glptr && (t_info == (OC_COMPARE | VV | P(39) | 2))) {
             /* input redirection (<) attached to glptr node */
-            cn = glptr->l.n = new_node(OC_CONCAT|SS|P(37));
+            cn = glptr->l.n = new_node(OC_CONCAT | SS | P(37));
             cn->a.n = glptr;
             xtc = TC_OPERAND | TC_UOPPRE;
@@ -1043 +1126 @@
              * previous operators with higher priority */
             vn = cn;
-            while ( ((t.info & PRIMASK) > (vn->a.n->info & PRIMASK2)) ||
-              ((t.info == vn->info) && ((t.info & OPCLSMASK) == OC_COLON)) )
+            while ( ((t_info & PRIMASK) > (vn->a.n->info & PRIMASK2))
+             || ((t_info == vn->info) && ((t_info & OPCLSMASK) == OC_COLON)) )
                 vn = vn->a.n;
-            if ((t.info & OPCLSMASK) == OC_TERNARY)
-                t.info += P(6);
-            cn = vn->a.n->r.n = new_node(t.info);
+            if ((t_info & OPCLSMASK) == OC_TERNARY)
+                t_info += P(6);
+            cn = vn->a.n->r.n = new_node(t_info);
             cn->a.n = vn->a.n;
             if (tc & TC_BINOP) {
                 cn->l.n = vn;
                 xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
-                if ((t.info & OPCLSMASK) == OC_PGETLINE) {
+                if ((t_info & OPCLSMASK) == OC_PGETLINE) {
                     /* it's a pipe */
                     next_token(TC_GETLINE);
@@ -1070 +1153 @@
              * to last node */
             vn = cn;
-            cn = vn->r.n = new_node(t.info);
+            cn = vn->r.n = new_node(t_info);
             cn->a.n = vn;
             xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
@@ -1078 +1161 @@
                  * only simple tclasses should be used! */
                 switch (tc) {
-                  case TC_VARIABLE:
-                  case TC_ARRAY:
+                case TC_VARIABLE:
+                case TC_ARRAY:
                     cn->info = OC_VAR;
-                    if ((v = hash_search(ahash, t.string)) != NULL) {
+                    v = hash_search(ahash, t_string);
+                    if (v != NULL) {
                         cn->info = OC_FNARG;
                         cn->l.i = v->x.aidx;
                     } else {
-                        cn->l.v = newvar(t.string);
+                        cn->l.v = newvar(t_string);
                     }
                     if (tc & TC_ARRAY) {
@@ -1093 +1177 @@
                     break;
 
-                  case TC_NUMBER:
-                  case TC_STRING:
+                case TC_NUMBER:
+                case TC_STRING:
                     cn->info = OC_VAR;
                     v = cn->l.v = xzalloc(sizeof(var));
                     if (tc & TC_NUMBER)
-                        setvar_i(v, t.number);
+                        setvar_i(v, t_double);
                     else
-                        setvar_s(v, t.string);
+                        setvar_s(v, t_string);
                     break;
 
-                  case TC_REGEXP:
-                    mk_re_node(t.string, cn,
-                                    (regex_t *)xzalloc(sizeof(regex_t)*2));
+                case TC_REGEXP:
+                    mk_re_node(t_string, cn, xzalloc(sizeof(regex_t)*2));
                     break;
 
-                  case TC_FUNCTION:
+                case TC_FUNCTION:
                     cn->info = OC_FUNC;
-                    cn->r.f = newfunc(t.string);
+                    cn->r.f = newfunc(t_string);
                     cn->l.n = condition();
                     break;
 
-                  case TC_SEQSTART:
+                case TC_SEQSTART:
                     cn = vn->r.n = parse_expr(TC_SEQTERM);
                     cn->a.n = vn;
                     break;
 
-                  case TC_GETLINE:
+                case TC_GETLINE:
                     glptr = cn;
                     xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | iexp;
                     break;
 
-                  case TC_BUILTIN:
+                case TC_BUILTIN:
                     cn->l.n = condition();
                     break;
@@ -1137 +1220 @@
 static node *chain_node(uint32_t info)
 {
-    register node *n;
-
-    if (! seq->first)
+    node *n;
+
+    if (!seq->first)
         seq->first = seq->last = new_node(0);
 
-    if (seq->programname != programname) {
-        seq->programname = programname;
+    if (seq->programname != g_progname) {
+        seq->programname = g_progname;
         n = chain_node(OC_NEWSOURCE);
-        n->l.s = bb_xstrdup(programname);
+        n->l.s = xstrdup(g_progname);
     }
 
@@ -1161 +1244 @@
     n = chain_node(info);
     n->l.n = parse_expr(TC_OPTERM | TC_GRPTERM);
-    if (t.tclass & TC_GRPTERM)
+    if (t_tclass & TC_GRPTERM)
         rollback_token();
 }
@@ -1199 +1282 @@
 
     if (c & TC_GRPSTART) {
-        while(next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
-            if (t.tclass & TC_NEWLINE) continue;
+        while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
+            if (t_tclass & TC_NEWLINE) continue;
             rollback_token();
             chain_group();
@@ -1208 +1291 @@
         chain_expr(OC_EXEC | Vx);
     } else {                        /* TC_STATEMNT */
-        switch (t.info & OPCLSMASK) {
-            case ST_IF:
-                n = chain_node(OC_BR | Vx);
-                n->l.n = condition();
+        switch (t_info & OPCLSMASK) {
+        case ST_IF:
+            n = chain_node(OC_BR | Vx);
+            n->l.n = condition();
+            chain_group();
+            n2 = chain_node(OC_EXEC);
+            n->r.n = seq->last;
+            if (next_token(TC_GRPSEQ | TC_GRPTERM | TC_ELSE) == TC_ELSE) {
                 chain_group();
-                n2 = chain_node(OC_EXEC);
-                n->r.n = seq->last;
-                if (next_token(TC_GRPSEQ | TC_GRPTERM | TC_ELSE)==TC_ELSE) {
-                    chain_group();
-                    n2->a.n = seq->last;
-                } else {
-                    rollback_token();
-                }
-                break;
-
-            case ST_WHILE:
-                n2 = condition();
+                n2->a.n = seq->last;
+            } else {
+                rollback_token();
+            }
+            break;
+
+        case ST_WHILE:
+            n2 = condition();
+            n = chain_loop(NULL);
+            n->l.n = n2;
+            break;
+
+        case ST_DO:
+            n2 = chain_node(OC_EXEC);
+            n = chain_loop(NULL);
+            n2->a.n = n->a.n;
+            next_token(TC_WHILE);
+            n->l.n = condition();
+            break;
+
+        case ST_FOR:
+            next_token(TC_SEQSTART);
+            n2 = parse_expr(TC_SEMICOL | TC_SEQTERM);
+            if (t_tclass & TC_SEQTERM) {    /* for-in */
+                if ((n2->info & OPCLSMASK) != OC_IN)
+                    syntax_error(EMSG_UNEXP_TOKEN);
+                n = chain_node(OC_WALKINIT | VV);
+                n->l.n = n2->l.n;
+                n->r.n = n2->r.n;
                 n = chain_loop(NULL);
+                n->info = OC_WALKNEXT | Vx;
+                n->l.n = n2->l.n;
+            } else {            /* for (;;) */
+                n = chain_node(OC_EXEC | Vx);
                 n->l.n = n2;
-                break;
-
-            case ST_DO:
-                n2 = chain_node(OC_EXEC);
-                n = chain_loop(NULL);
-                n2->a.n = n->a.n;
-                next_token(TC_WHILE);
-                n->l.n = condition();
-                break;
-
-            case ST_FOR:
-                next_token(TC_SEQSTART);
-                n2 = parse_expr(TC_SEMICOL | TC_SEQTERM);
-                if (t.tclass & TC_SEQTERM) {                /* for-in */
-                    if ((n2->info & OPCLSMASK) != OC_IN)
-                        syntax_error(EMSG_UNEXP_TOKEN);
-                    n = chain_node(OC_WALKINIT | VV);
-                    n->l.n = n2->l.n;
-                    n->r.n = n2->r.n;
-                    n = chain_loop(NULL);
-                    n->info = OC_WALKNEXT | Vx;
-                    n->l.n = n2->l.n;
-                } else {                                    /* for(;;) */
-                    n = chain_node(OC_EXEC | Vx);
-                    n->l.n = n2;
-                    n2 = parse_expr(TC_SEMICOL);
-                    n3 = parse_expr(TC_SEQTERM);
-                    n = chain_loop(n3);
-                    n->l.n = n2;
-                    if (! n2)
-                        n->info = OC_EXEC;
-                }
-                break;
-
-            case OC_PRINT:
-            case OC_PRINTF:
-                n = chain_node(t.info);
-                n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM);
-                if (t.tclass & TC_OUTRDR) {
-                    n->info |= t.info;
-                    n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM);
-                }
-                if (t.tclass & TC_GRPTERM)
-                    rollback_token();
-                break;
-
-            case OC_BREAK:
-                n = chain_node(OC_EXEC);
-                n->a.n = break_ptr;
-                break;
-
-            case OC_CONTINUE:
-                n = chain_node(OC_EXEC);
-                n->a.n = continue_ptr;
-                break;
-
-            /* delete, next, nextfile, return, exit */
-            default:
-                chain_expr(t.info);
-
+                n2 = parse_expr(TC_SEMICOL);
+                n3 = parse_expr(TC_SEQTERM);
+                n = chain_loop(n3);
+                n->l.n = n2;
+                if (!n2)
+                    n->info = OC_EXEC;
+            }
+            break;
+
+        case OC_PRINT:
+        case OC_PRINTF:
+            n = chain_node(t_info);
+            n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM);
+            if (t_tclass & TC_OUTRDR) {
+                n->info |= t_info;
+                n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM);
+            }
+            if (t_tclass & TC_GRPTERM)
+                rollback_token();
+            break;
+
+        case OC_BREAK:
+            n = chain_node(OC_EXEC);
+            n->a.n = break_ptr;
+            break;
+
+        case OC_CONTINUE:
+            n = chain_node(OC_EXEC);
+            n->a.n = continue_ptr;
+            break;
+
+        /* delete, next, nextfile, return, exit */
+        default:
+            chain_expr(t_info);
         }
     }
@@ -1298 +1380 @@
     var *v;
 
-    pos = p;
-    t.lineno = 1;
-    while((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART |
-                TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) {
+    g_pos = p;
+    t_lineno = 1;
+    while ((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART |
+            TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) {
 
         if (tclass & TC_OPTERM)
@@ -1317 +1399 @@
         } else if (tclass & TC_FUNCDECL) {
             next_token(TC_FUNCTION);
-            pos++;
-            f = newfunc(t.string);
+            g_pos++;
+            f = newfunc(t_string);
             f->body.first = NULL;
             f->nargs = 0;
-            while(next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) {
-                v = findvar(ahash, t.string);
+            while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) {
+                v = findvar(ahash, t_string);
                 v->x.aidx = (f->nargs)++;
 
@@ -1336 +1418 @@
             cn = chain_node(OC_TEST);
             cn->l.n = parse_expr(TC_OPTERM | TC_EOF | TC_GRPSTART);
-            if (t.tclass & TC_GRPSTART) {
+            if (t_tclass & TC_GRPSTART) {
                 rollback_token();
                 chain_group();
@@ -1354 +1436 @@
 /* -------- program execution part -------- */
 
-static node *mk_splitter(char *s, tsplitter *spl)
-{
-    register regex_t *re, *ire;
+static node *mk_splitter(const char *s, tsplitter *spl)
+{
+    regex_t *re, *ire;
     node *n;
 
@@ -1362 +1444 @@
     ire = &spl->re[1];
     n = &spl->n;
-    if ((n->info && OPCLSMASK) == OC_REGEXP) {
+    if ((n->info & OPCLSMASK) == OC_REGEXP) {
         regfree(re);
-        regfree(ire);
+        regfree(ire); // TODO: nuke ire, use re+1?
     }
     if (strlen(s) > 1) {
@@ -1382 +1464 @@
 {
     var *v;
-    char *s;
+    const char *s;
 
     if ((op->info & OPCLSMASK) == OC_REGEXP) {
         return icase ? op->r.ire : op->l.re;
-    } else {
-        v = nvalloc(1);
-        s = getvar_s(evaluate(op, v));
-        xregcomp(preg, s, icase ? REG_EXTENDED | REG_ICASE : REG_EXTENDED);
-        nvfree(v);
-        return preg;
-    }
+    }
+    v = nvalloc(1);
+    s = getvar_s(evaluate(op, v));
+    xregcomp(preg, s, icase ? REG_EXTENDED | REG_ICASE : REG_EXTENDED);
+    nvfree(v);
+    return preg;
 }
 
@@ -1398 +1479 @@
 static void qrealloc(char **b, int n, int *size)
 {
-    if (! *b || n >= *size)
+    if (!*b || n >= *size)
         *b = xrealloc(*b, *size = n + (n>>1) + 80);
 }
@@ -1405 +1486 @@
 static void fsrealloc(int size)
 {
-    static int maxfields = 0;
     int i;
 
@@ -1411 +1491 @@
         i = maxfields;
         maxfields = size + 16;
-        Fields = (var *)xrealloc(Fields, maxfields * sizeof(var));
-        for (; i<maxfields; i++) {
+        Fields = xrealloc(Fields, maxfields * sizeof(var));
+        for (; i < maxfields; i++) {
             Fields[i].type = VF_SPECIAL;
             Fields[i].string = NULL;
@@ -1419 +1499 @@
 
     if (size < nfields) {
-        for (i=size; i<nfields; i++) {
-            clrvar(Fields+i);
+        for (i = size; i < nfields; i++) {
+            clrvar(Fields + i);
         }
     }
@@ -1426 +1506 @@
 }
 
-static int awk_split(char *s, node *spl, char **slist)
-{
-    int l, n=0;
+static int awk_split(const char *s, node *spl, char **slist)
+{
+    int l, n = 0;
     char c[4];
     char *s1;
-    regmatch_t pmatch[2];
+    regmatch_t pmatch[2]; // TODO: why [2]? [1] is enough...
 
     /* in worst case, each char would be a separate field */
-    *slist = s1 = bb_xstrndup(s, strlen(s) * 2 + 3);
+    *slist = s1 = xzalloc(strlen(s) * 2 + 3);
+    strcpy(s1, s);
 
     c[0] = c[1] = (char)spl->info;
     c[2] = c[3] = '\0';
-    if (*getvar_s(V[RS]) == '\0') c[2] = '\n';
-
-    if ((spl->info & OPCLSMASK) == OC_REGEXP) {     /* regex split */
-        while (*s) {
-            l = strcspn(s, c+2);
-            if (regexec(icase ? spl->r.ire : spl->l.re, s, 1, pmatch, 0) == 0 &&
-            pmatch[0].rm_so <= l) {
+    if (*getvar_s(intvar[RS]) == '\0')
+        c[2] = '\n';
+
+    if ((spl->info & OPCLSMASK) == OC_REGEXP) {  /* regex split */
+        if (!*s)
+            return n; /* "": zero fields */
+        n++; /* at least one field will be there */
+        do {
+            l = strcspn(s, c+2); /* len till next NUL or \n */
+            if (regexec(icase ? spl->r.ire : spl->l.re, s, 1, pmatch, 0) == 0
+             && pmatch[0].rm_so <= l
+            ) {
                 l = pmatch[0].rm_so;
-                if (pmatch[0].rm_eo == 0) { l++; pmatch[0].rm_eo++; }
+                if (pmatch[0].rm_eo == 0) {
+                    l++;
+                    pmatch[0].rm_eo++;
+                }
+                n++; /* we saw yet another delimiter */
             } else {
                 pmatch[0].rm_eo = l;
-                if (*(s+l)) pmatch[0].rm_eo++;
-            }
-
+                if (s[l]) pmatch[0].rm_eo++;
+            }
             memcpy(s1, s, l);
-            *(s1+l) = '\0';
+            s1[l] = '\0';
             nextword(&s1);
             s += pmatch[0].rm_eo;
+        } while (*s);
+        return n;
+    }
+    if (c[0] == '\0') {  /* null split */
+        while (*s) {
+            *s1++ = *s++;
+            *s1++ = '\0';
             n++;
         }
-    } else if (c[0] == '\0') {      /* null split */
-        while(*s) {
-            *(s1++) = *(s++);
-            *(s1++) = '\0';
-            n++;
-        }
-    } else if (c[0] != ' ') {       /* single-character split */
+        return n;
+    }
+    if (c[0] != ' ') {  /* single-character split */
         if (icase) {
             c[0] = toupper(c[0]);
@@ -1471 +1563 @@
         if (*s1) n++;
         while ((s1 = strpbrk(s1, c))) {
-            *(s1++) = '\0';
+            *s1++ = '\0';
             n++;
         }
-    } else {                /* space split */
-        while (*s) {
-            while (isspace(*s)) s++;
-            if (! *s) break;
-            n++;
-            while (*s && !isspace(*s))
-                *(s1++) = *(s++);
-            *(s1++) = '\0';
-        }
+        return n;
+    }
+    /* space split */
+    while (*s) {
+        s = skip_whitespace(s);
+        if (!*s) break;
+        n++;
+        while (*s && !isspace(*s))
+            *s1++ = *s++;
+        *s1++ = '\0';
     }
     return n;
@@ -1489 +1582 @@
 static void split_f0(void)
 {
-    static char *fstrings = NULL;
+/* static char *fstrings; */
+#define fstrings (G.split_f0__fstrings)
+
     int i, n;
     char *s;
@@ -1499 +1594 @@
     free(fstrings);
     fsrealloc(0);
-    n = awk_split(getvar_s(V[F0]), &fsplitter.n, &fstrings);
+    n = awk_split(getvar_s(intvar[F0]), &fsplitter.n, &fstrings);
     fsrealloc(n);
     s = fstrings;
-    for (i=0; i<n; i++) {
+    for (i = 0; i < n; i++) {
         Fields[i].string = nextword(&s);
         Fields[i].type |= (VF_FSTR | VF_USER | VF_DIRTY);
@@ -1508 +1603 @@
 
     /* set NF manually to avoid side effects */
-    clrvar(V[NF]);
-    V[NF]->type = VF_NUMBER | VF_SPECIAL;
-    V[NF]->number = nfields;
+    clrvar(intvar[NF]);
+    intvar[NF]->type = VF_NUMBER | VF_SPECIAL;
+    intvar[NF]->number = nfields;
+#undef fstrings
 }
 
@@ -1517 +1613 @@
 {
     int n;
-    char *b, *sep, *s;
+    char *b;
+    const char *sep, *s;
     int sl, l, len, i, bsize;
 
-    if (! (v->type & VF_SPECIAL))
+    if (!(v->type & VF_SPECIAL))
         return;
 
-    if (v == V[NF]) {
+    if (v == intvar[NF]) {
         n = (int)getvar_i(v);
         fsrealloc(n);
 
         /* recalculate $0 */
-        sep = getvar_s(V[OFS]);
+        sep = getvar_s(intvar[OFS]);
         sl = strlen(sep);
         b = NULL;
         len = 0;
-        for (i=0; i<n; i++) {
+        for (i = 0; i < n; i++) {
             s = getvar_s(&Fields[i]);
             l = strlen(s);
@@ -1543 +1640 @@
             len += l;
         }
-        if (b) b[len] = '\0';
-        setvar_p(V[F0], b);
+        if (b)
+            b[len] = '\0';
+        setvar_p(intvar[F0], b);
         is_f0_split = TRUE;
 
-    } else if (v == V[F0]) {
+    } else if (v == intvar[F0]) {
         is_f0_split = FALSE;
 
-    } else if (v == V[FS]) {
+    } else if (v == intvar[FS]) {
         mk_splitter(getvar_s(v), &fsplitter);
 
-    } else if (v == V[RS]) {
+    } else if (v == intvar[RS]) {
         mk_splitter(getvar_s(v), &rsplitter);
 
-    } else if (v == V[IGNORECASE]) {
+    } else if (v == intvar[IGNORECASE]) {
         icase = istrue(v);
 
-    } else {                        /* $n */
-        n = getvar_i(V[NF]);
-        setvar_i(V[NF], n > v-Fields ? n : v-Fields+1);
+    } else {                /* $n */
+        n = getvar_i(intvar[NF]);
+        setvar_i(intvar[NF], n > v-Fields ? n : v-Fields+1);
         /* right here v is invalid. Just to note... */
     }
@@ -1591 +1689 @@
 
     v->type |= VF_WALK;
-    w = v->x.walker = (char **)xzalloc(2 + 2*sizeof(char *) + array->glen);
-    *w = *(w+1) = (char *)(w + 2);
-    for (i=0; i<array->csize; i++) {
+    w = v->x.walker = xzalloc(2 + 2*sizeof(char *) + array->glen);
+    w[0] = w[1] = (char *)(w + 2);
+    for (i = 0; i < array->csize; i++) {
         hi = array->items[i];
-        while(hi) {
+        while (hi) {
             strcpy(*w, hi->name);
             nextword(w);
@@ -1608 +1706 @@
 
     w = v->x.walker;
-    if (*(w+1) == *w)
+    if (w[1] == w[0])
         return FALSE;
 
@@ -1618 +1716 @@
 static int ptest(node *pattern)
 {
-    static var v;
-    return istrue(evaluate(pattern, &v));
+    /* ptest__v is "static": to save stack space? */
+    return istrue(evaluate(pattern, &G.ptest__v));
 }
 
@@ -1642 +1740 @@
     rp = 0;
 
-    if (! m) qrealloc(&m, 256, &size);
+    if (!m) qrealloc(&m, 256, &size);
     do {
         b = m + a;
@@ -1650 +1748 @@
             if ((rsplitter.n.info & OPCLSMASK) == OC_REGEXP) {
                 if (regexec(icase ? rsplitter.n.r.ire : rsplitter.n.l.re,
-                                                b, 1, pmatch, 0) == 0) {
+                            b, 1, pmatch, 0) == 0) {
                     so = pmatch[0].rm_so;
                     eo = pmatch[0].rm_eo;
@@ -1658 +1756 @@
             } else if (c != '\0') {
                 s = strchr(b+pp, c);
-                if (! s) s = memchr(b+pp, '\0', p - pp);
+                if (!s) s = memchr(b+pp, '\0', p - pp);
                 if (s) {
                     so = eo = s-b;
@@ -1690 +1788 @@
             p = 0;
             r = 0;
-            setvar_i(V[ERRNO], errno);
+            setvar_i(intvar[ERRNO], errno);
         }
         b[p] = '\0';
@@ -1704 +1802 @@
         b[so] = c;
         c = b[eo]; b[eo] = '\0';
-        setvar_s(V[RT], b+so);
+        setvar_s(intvar[RT], b+so);
         b[eo] = c;
     }
@@ -1718 +1816 @@
 static int fmt_num(char *b, int size, const char *format, double n, int int_as_int)
 {
-    int r=0;
+    int r = 0;
     char c;
-    const char *s=format;
+    const char *s = format;
 
     if (int_as_int && n == (int)n) {
         r = snprintf(b, size, "%d", (int)n);
     } else {
-        do { c = *s; } while (*s && *++s);
+        do { c = *s; } while (c && *++s);
         if (strchr("diouxX", c)) {
             r = snprintf(b, size, format, (int)n);
@@ -1731 +1829 @@
             r = snprintf(b, size, format, n);
         } else {
-            runtime_error(EMSG_INV_FMT);
+            syntax_error(EMSG_INV_FMT);
         }
     }
@@ -1742 +1840 @@
 {
     char *b = NULL;
-    char *fmt, *s, *s1, *f;
+    char *fmt, *s, *f;
+    const char *s1;
     int i, j, incr, bsize;
     char c, c1;
@@ -1748 +1847 @@
 
     v = nvalloc(1);
-    fmt = f = bb_xstrdup(getvar_s(evaluate(nextarg(&n), v)));
+    fmt = f = xstrdup(getvar_s(evaluate(nextarg(&n), v)));
 
     i = 0;
@@ -1755 +1854 @@
         while (*f && (*f != '%' || *(++f) == '%'))
             f++;
-        while (*f && !isalpha(*f))
+        while (*f && !isalpha(*f)) {
+            if (*f == '*')
+                syntax_error("%*x formats are not supported");
             f++;
+        }
 
         incr = (f - s) + MAXVARFMT;
-        qrealloc(&b, incr+i, &bsize);
-        c = *f; if (c != '\0') f++;
-        c1 = *f ; *f = '\0';
+        qrealloc(&b, incr + i, &bsize);
+        c = *f;
+        if (c != '\0') f++;
+        c1 = *f;
+        *f = '\0';
         arg = evaluate(nextarg(&n), v);
 
         j = i;
         if (c == 'c' || !c) {
-            i += sprintf(b+i, s,
-                    is_numeric(arg) ? (char)getvar_i(arg) : *getvar_s(arg));
-
+            i += sprintf(b+i, s, is_numeric(arg) ?
+                    (char)getvar_i(arg) : *getvar_s(arg));
         } else if (c == 's') {
-            s1 = getvar_s(arg);
+            s1 = getvar_s(arg);
             qrealloc(&b, incr+i+strlen(s1), &bsize);
             i += sprintf(b+i, s, s1);
-
         } else {
             i += fmt_num(b+i, incr, s, getvar_i(arg), FALSE);
@@ -1781 +1883 @@
         /* if there was an error while sprintf, return value is negative */
         if (i < j) i = j;
-
-    }
-
-    b = xrealloc(b, i+1);
+    }
+
+    b = xrealloc(b, i + 1);
     free(fmt);
     nvfree(v);
@@ -1797 +1898 @@
  * subexpression matching (\1-\9)
  */
-static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex)
+static int awk_sub(node *rn, const char *repl, int nm, var *src, var *dest, int ex)
 {
     char *ds = NULL;
-    char *sp, *s;
+    const char *s;
+    const char *sp;
     int c, i, j, di, rl, so, eo, nbs, n, dssize;
     regmatch_t pmatch[10];
@@ -1806 +1908 @@
 
     re = as_regex(rn, &sreg);
-    if (! src) src = V[F0];
-    if (! dest) dest = V[F0];
+    if (!src) src = intvar[F0];
+    if (!dest) dest = intvar[F0];
 
     i = di = 0;
     sp = getvar_s(src);
     rl = strlen(repl);
-    while (regexec(re, sp, 10, pmatch, sp==getvar_s(src) ? 0:REG_NOTBOL) == 0) {
+    while (regexec(re, sp, 10, pmatch, sp==getvar_s(src) ? 0 : REG_NOTBOL) == 0) {
         so = pmatch[0].rm_so;
         eo = pmatch[0].rm_eo;
@@ -1852 +1954 @@
         if (i == nm) break;
         if (eo == so) {
-            if (! (ds[di++] = *sp++)) break;
+            ds[di] = *sp++;
+            if (!ds[di++]) break;
         }
     }
@@ -1865 +1968 @@
 static var *exec_builtin(node *op, var *res)
 {
+#define tspl (G.exec_builtin__tspl)
+
     int (*to_xxx)(int);
     var *tv;
     node *an[4];
-    var  *av[4];
-    char *as[4];
+    var *av[4];
+    const char *as[4];
     regmatch_t pmatch[2];
     regex_t sreg, *re;
-    static tsplitter tspl;
     node *spl;
     uint32_t isr, info;
@@ -1885 +1989 @@
 
     av[2] = av[3] = NULL;
-    for (i=0 ; i<4 && op ; i++) {
+    for (i = 0; i < 4 && op; i++) {
         an[i] = nextarg(&op);
         if (isr & 0x09000000) av[i] = evaluate(an[i], &tv[i]);
@@ -1894 +1998 @@
     nargs = i;
     if (nargs < (info >> 30))
-        runtime_error(EMSG_TOO_FEW_ARGS);
+        syntax_error(EMSG_TOO_FEW_ARGS);
 
     switch (info & OPNMASK) {
 
-      case B_a2:
-#ifdef CONFIG_FEATURE_AWK_MATH
+    case B_a2:
+#if ENABLE_FEATURE_AWK_MATH
         setvar_i(res, atan2(getvar_i(av[i]), getvar_i(av[1])));
 #else
-        runtime_error(EMSG_NO_MATH);
+        syntax_error(EMSG_NO_MATH);
 #endif
         break;
 
-      case B_sp:
+    case B_sp:
         if (nargs > 2) {
             spl = (an[2]->info & OPCLSMASK) == OC_REGEXP ?
@@ -1923 +2027 @@
         break;
 
-      case B_ss:
+    case B_ss:
         l = strlen(as[0]);
         i = getvar_i(av[1]) - 1;
-        if (i>l) i=l; if (i<0) i=0;
+        if (i > l) i = l;
+        if (i < 0) i = 0;
         n = (nargs > 2) ? getvar_i(av[2]) : l-i;
-        if (n<0) n=0;
+        if (n < 0) n = 0;
         s = xmalloc(n+1);
         strncpy(s, as[0]+i, n);
@@ -1935 +2040 @@
         break;
 
-      case B_lo:
+    case B_an:
+        setvar_i(res, (long)getvar_i(av[0]) & (long)getvar_i(av[1]));
+        break;
+
+    case B_co:
+        setvar_i(res, ~(long)getvar_i(av[0]));
+        break;
+
+    case B_ls:
+        setvar_i(res, (long)getvar_i(av[0]) << (long)getvar_i(av[1]));
+        break;
+
+    case B_or:
+        setvar_i(res, (long)getvar_i(av[0]) | (long)getvar_i(av[1]));
+        break;
+
+    case B_rs:
+        setvar_i(res, (long)((unsigned long)getvar_i(av[0]) >> (unsigned long)getvar_i(av[1])));
+        break;
+
+    case B_xo:
+        setvar_i(res, (long)getvar_i(av[0]) ^ (long)getvar_i(av[1]));
+        break;
+
+    case B_lo:
         to_xxx = tolower;
         goto lo_cont;
 
-      case B_up:
+    case B_up:
         to_xxx = toupper;
-lo_cont:
-        s1 = s = bb_xstrdup(as[0]);
+ lo_cont:
+        s1 = s = xstrdup(as[0]);
         while (*s1) {
             *s1 = (*to_xxx)(*s1);
@@ -1950 +2079 @@
         break;
 
-      case B_ix:
+    case B_ix:
         n = 0;
         ll = strlen(as[1]);
         l = strlen(as[0]) - ll;
         if (ll > 0 && l >= 0) {
-            if (! icase) {
+            if (!icase) {
                 s = strstr(as[0], as[1]);
                 if (s) n = (s - as[0]) + 1;
@@ -1973 +2102 @@
         break;
 
-      case B_ti:
+    case B_ti:
         if (nargs > 1)
             tt = getvar_i(av[1]);
         else
             time(&tt);
-        s = (nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y";
-        i = strftime(buf, MAXVARFMT, s, localtime(&tt));
-        buf[i] = '\0';
-        setvar_s(res, buf);
+        //s = (nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y";
+        i = strftime(g_buf, MAXVARFMT,
+            ((nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"),
+            localtime(&tt));
+        g_buf[i] = '\0';
+        setvar_s(res, g_buf);
         break;
 
-      case B_ma:
+    case B_ma:
         re = as_regex(an[1], &sreg);
         n = regexec(re, as[0], 1, pmatch, 0);
@@ -2000 +2131 @@
         break;
 
-      case B_ge:
+    case B_ge:
         awk_sub(an[0], as[1], getvar_i(av[2]), av[3], res, TRUE);
         break;
 
-      case B_gs:
+    case B_gs:
         setvar_i(res, awk_sub(an[0], as[1], 0, av[2], av[2], FALSE));
         break;
 
-      case B_su:
+    case B_su:
         setvar_i(res, awk_sub(an[0], as[1], 1, av[2], av[2], FALSE));
         break;
@@ -2015 +2146 @@
     nvfree(tv);
     return res;
+#undef tspl
 }
 
@@ -2025 +2157 @@
 static var *evaluate(node *op, var *res)
 {
-    /* This procedure is recursive so we should count every byte */
-    static var *fnargs = NULL;
-    static unsigned int seed = 1;
-    static regex_t sreg;
+/* This procedure is recursive so we should count every byte */
+#define fnargs (G.evaluate__fnargs)
+/* seed is initialized to 1 */
+#define seed   (G.evaluate__seed)
+#define sreg   (G.evaluate__sreg)
+
     node *op1;
     var *v1;
     union {
         var *v;
-        char *s;
+        const char *s;
         double d;
         int i;
     } L, R;
     uint32_t opinfo;
-    short opn;
+    int opn;
     union {
         char *s;
@@ -2048 +2182 @@
     } X;
 
-    if (! op)
+    if (!op)
         return setvar_s(res, NULL);
 
@@ -2054 +2188 @@
 
     while (op) {
-
         opinfo = op->info;
-        opn = (short)(opinfo & OPNMASK);
-        lineno = op->lineno;
+        opn = (opinfo & OPNMASK);
+        g_lineno = op->lineno;
 
         /* execute inevitable things */
@@ -2069 +2202 @@
         switch (XC(opinfo & OPCLSMASK)) {
 
-          /* -- iterative node type -- */
-
-          /* test pattern */
-          case XC( OC_TEST ):
+        /* -- iterative node type -- */
+
+        /* test pattern */
+        case XC( OC_TEST ):
             if ((op1->info & OPCLSMASK) == OC_COMMA) {
                 /* it's range pattern */
@@ -2089 +2222 @@
             break;
 
-          /* just evaluate an expression, also used as unconditional jump */
-          case XC( OC_EXEC ):
-            break;
-
-          /* branch, used in if-else and various loops */
-          case XC( OC_BR ):
+        /* just evaluate an expression, also used as unconditional jump */
+        case XC( OC_EXEC ):
+            break;
+
+        /* branch, used in if-else and various loops */
+        case XC( OC_BR ):
             op = istrue(L.v) ? op->a.n : op->r.n;
             break;
 
-          /* initialize for-in loop */
-          case XC( OC_WALKINIT ):
+        /* initialize for-in loop */
+        case XC( OC_WALKINIT ):
             hashwalk_init(L.v, iamarray(R.v));
             break;
 
-          /* get next array item */
-          case XC( OC_WALKNEXT ):
+        /* get next array item */
+        case XC( OC_WALKNEXT ):
             op = hashwalk_next(L.v) ? op->a.n : op->r.n;
             break;
 
-          case XC( OC_PRINT ):
-          case XC( OC_PRINTF ):
+        case XC( OC_PRINT ):
+        case XC( OC_PRINTF ):
             X.F = stdout;
             if (op->r.n) {
                 X.rsm = newfile(R.s);
-                if (! X.rsm->F) {
+                if (!X.rsm->F) {
                     if (opn == '|') {
-                        if((X.rsm->F = popen(R.s, "w")) == NULL)
+                        X.rsm->F = popen(R.s, "w");
+                        if (X.rsm->F == NULL)
                             bb_perror_msg_and_die("popen");
                         X.rsm->is_pipe = 1;
                     } else {
-                        X.rsm->F = bb_xfopen(R.s, opn=='w' ? "w" : "a");
+                        X.rsm->F = xfopen(R.s, opn=='w' ? "w" : "a");
                     }
                 }
@@ -2126 +2260 @@
 
             if ((opinfo & OPCLSMASK) == OC_PRINT) {
-                if (! op1) {
-                    fputs(getvar_s(V[F0]), X.F);
+                if (!op1) {
+                    fputs(getvar_s(intvar[F0]), X.F);
                 } else {
                     while (op1) {
                         L.v = evaluate(nextarg(&op1), v1);
                         if (L.v->type & VF_NUMBER) {
-                            fmt_num(buf, MAXVARFMT, getvar_s(V[OFMT]),
-                                                        getvar_i(L.v), TRUE);
-                            fputs(buf, X.F);
+                            fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[OFMT]),
+                                    getvar_i(L.v), TRUE);
+                            fputs(g_buf, X.F);
                         } else {
                             fputs(getvar_s(L.v), X.F);
                         }
 
-                        if (op1) fputs(getvar_s(V[OFS]), X.F);
+                        if (op1) fputs(getvar_s(intvar[OFS]), X.F);
                     }
                 }
-                fputs(getvar_s(V[ORS]), X.F);
+                fputs(getvar_s(intvar[ORS]), X.F);
 
             } else {    /* OC_PRINTF */
                 L.s = awk_printf(op1);
                 fputs(L.s, X.F);
-                free(L.s);
+                free((char*)L.s);
             }
             fflush(X.F);
             break;
 
-          case XC( OC_DELETE ):
+        case XC( OC_DELETE ):
             X.info = op1->info & OPCLSMASK;
             if (X.info == OC_VAR) {
@@ -2159 +2293 @@
                 R.v = &fnargs[op1->l.i];
             } else {
-                runtime_error(EMSG_NOT_ARRAY);
+                syntax_error(EMSG_NOT_ARRAY);
             }
 
@@ -2171 +2305 @@
             break;
 
-          case XC( OC_NEWSOURCE ):
-            programname = op->l.s;
-            break;
-
-          case XC( OC_RETURN ):
+        case XC( OC_NEWSOURCE ):
+            g_progname = op->l.s;
+            break;
+
+        case XC( OC_RETURN ):
             copyvar(res, L.v);
             break;
 
-          case XC( OC_NEXTFILE ):
+        case XC( OC_NEXTFILE ):
             nextfile = TRUE;
-          case XC( OC_NEXT ):
+        case XC( OC_NEXT ):
             nextrec = TRUE;
-          case XC( OC_DONE ):
+        case XC( OC_DONE ):
             clrvar(res);
             break;
 
-          case XC( OC_EXIT ):
+        case XC( OC_EXIT ):
             awk_exit(L.d);
 
-          /* -- recursive node type -- */
-
-          case XC( OC_VAR ):
+        /* -- recursive node type -- */
+
+        case XC( OC_VAR ):
             L.v = op->l.v;
-            if (L.v == V[NF])
+            if (L.v == intvar[NF])
                 split_f0();
             goto v_cont;
 
-          case XC( OC_FNARG ):
+        case XC( OC_FNARG ):
             L.v = &fnargs[op->l.i];
-
-v_cont:
-            res = (op->r.n) ? findvar(iamarray(L.v), R.s) : L.v;
-            break;
-
-          case XC( OC_IN ):
+ v_cont:
+            res = op->r.n ? findvar(iamarray(L.v), R.s) : L.v;
+            break;
+
+        case XC( OC_IN ):
             setvar_i(res, hash_search(iamarray(R.v), L.s) ? 1 : 0);
             break;
 
-          case XC( OC_REGEXP ):
+        case XC( OC_REGEXP ):
             op1 = op;
-            L.s = getvar_s(V[F0]);
+            L.s = getvar_s(intvar[F0]);
             goto re_cont;
 
-          case XC( OC_MATCH ):
+        case XC( OC_MATCH ):
             op1 = op->r.n;
-re_cont:
+ re_cont:
             X.re = as_regex(op1, &sreg);
             R.i = regexec(X.re, L.s, 0, NULL, 0);
@@ -2223 +2356 @@
             break;
 
-          case XC( OC_MOVE ):
+        case XC( OC_MOVE ):
             /* if source is a temporary string, jusk relink it to dest */
             if (R.v == v1+1 && R.v->string) {
@@ -2233 +2366 @@
             break;
 
-          case XC( OC_TERNARY ):
+        case XC( OC_TERNARY ):
             if ((op->r.n->info & OPCLSMASK) != OC_COLON)
-                runtime_error(EMSG_POSSIBLE_ERROR);
+                syntax_error(EMSG_POSSIBLE_ERROR);
             res = evaluate(istrue(L.v) ? op->r.n->l.n : op->r.n->r.n, res);
             break;
 
-          case XC( OC_FUNC ):
-            if (! op->r.f->body.first)
-                runtime_error(EMSG_UNDEF_FUNC);
+        case XC( OC_FUNC ):
+            if (!op->r.f->body.first)
+                syntax_error(EMSG_UNDEF_FUNC);
 
             X.v = R.v = nvalloc(op->r.f->nargs+1);
@@ -2256 +2389 @@
             fnargs = X.v;
 
-            L.s = programname;
+            L.s = g_progname;
             res = evaluate(op->r.f->body.first, res);
-            programname = L.s;
+            g_progname = L.s;
 
             nvfree(fnargs);
@@ -2264 +2397 @@
             break;
 
-          case XC( OC_GETLINE ):
-          case XC( OC_PGETLINE ):
+        case XC( OC_GETLINE ):
+        case XC( OC_PGETLINE ):
             if (op1) {
                 X.rsm = newfile(L.s);
-                if (! X.rsm->F) {
+                if (!X.rsm->F) {
                     if ((opinfo & OPCLSMASK) == OC_PGETLINE) {
                         X.rsm->F = popen(L.s, "r");
                         X.rsm->is_pipe = TRUE;
                     } else {
-                        X.rsm->F = fopen(L.s, "r");     /* not bb_xfopen! */
+                        X.rsm->F = fopen(L.s, "r");     /* not xfopen! */
                     }
                 }
             } else {
-                if (! iF) iF = next_input_file();
+                if (!iF) iF = next_input_file();
                 X.rsm = iF;
             }
 
-            if (! X.rsm->F) {
-                setvar_i(V[ERRNO], errno);
+            if (!X.rsm->F) {
+                setvar_i(intvar[ERRNO], errno);
                 setvar_i(res, -1);
                 break;
             }
 
-            if (! op->r.n)
-                R.v = V[F0];
+            if (!op->r.n)
+                R.v = intvar[F0];
 
             L.i = awk_getline(X.rsm, R.v);
             if (L.i > 0) {
-                if (! op1) {
-                    incvar(V[FNR]);
-                    incvar(V[NR]);
+                if (!op1) {
+                    incvar(intvar[FNR]);
+                    incvar(intvar[NR]);
                 }
             }
@@ -2300 +2433 @@
             break;
 
-          /* simple builtins */
-          case XC( OC_FBLTIN ):
+        /* simple builtins */
+        case XC( OC_FBLTIN ):
             switch (opn) {
 
-              case F_in:
+            case F_in:
                 R.d = (int)L.d;
                 break;
 
-              case F_rn:
-                R.d =  (double)rand() / (double)RAND_MAX;
+            case F_rn:
+                R.d = (double)rand() / (double)RAND_MAX;
                 break;
-
-#ifdef CONFIG_FEATURE_AWK_MATH
-              case F_co:
+#if ENABLE_FEATURE_AWK_MATH
+            case F_co:
                 R.d = cos(L.d);
                 break;
 
-              case F_ex:
+            case F_ex:
                 R.d = exp(L.d);
                 break;
 
-              case F_lg:
+            case F_lg:
                 R.d = log(L.d);
                 break;
 
-              case F_si:
+            case F_si:
                 R.d = sin(L.d);
                 break;
 
-              case F_sq:
+            case F_sq:
                 R.d = sqrt(L.d);
                 break;
 #else
-              case F_co:
-              case F_ex:
-              case F_lg:
-              case F_si:
-              case F_sq:
-                runtime_error(EMSG_NO_MATH);
+            case F_co:
+            case F_ex:
+            case F_lg:
+            case F_si:
+            case F_sq:
+                syntax_error(EMSG_NO_MATH);
                 break;
 #endif
-
-              case F_sr:
+            case F_sr:
                 R.d = (double)seed;
-                seed = op1 ? (unsigned int)L.d : (unsigned int)time(NULL);
+                seed = op1 ? (unsigned)L.d : (unsigned)time(NULL);
                 srand(seed);
                 break;
 
-              case F_ti:
+            case F_ti:
                 R.d = time(NULL);
                 break;
 
-              case F_le:
-                if (! op1)
-                    L.s = getvar_s(V[F0]);
+            case F_le:
+                if (!op1)
+                    L.s = getvar_s(intvar[F0]);
                 R.d = strlen(L.s);
                 break;
 
-              case F_sy:
+            case F_sy:
                 fflush(NULL);
-                R.d = (L.s && *L.s) ? (system(L.s) >> 8) : 0;
+                R.d = (ENABLE_FEATURE_ALLOW_EXEC && L.s && *L.s)
+                        ? (system(L.s) >> 8) : 0;
                 break;
 
-              case F_ff:
-                if (! op1)
+            case F_ff:
+                if (!op1)
                     fflush(stdout);
                 else {
@@ -2376 +2508 @@
                 break;
 
-              case F_cl:
+            case F_cl:
                 X.rsm = (rstream *)hash_search(fdhash, L.s);
                 if (X.rsm) {
@@ -2384 +2516 @@
                 }
                 if (R.i != 0)
-                    setvar_i(V[ERRNO], errno);
+                    setvar_i(intvar[ERRNO], errno);
                 R.d = (double)R.i;
                 break;
@@ -2391 +2523 @@
             break;
 
-          case XC( OC_BUILTIN ):
+        case XC( OC_BUILTIN ):
             res = exec_builtin(op, res);
             break;
 
-          case XC( OC_SPRINTF ):
+        case XC( OC_SPRINTF ):
             setvar_p(res, awk_printf(op1));
             break;
 
-          case XC( OC_UNARY ):
+        case XC( OC_UNARY ):
             X.v = R.v;
             L.d = R.d = getvar_i(R.v);
             switch (opn) {
-              case 'P':
+            case 'P':
                 L.d = ++R.d;
                 goto r_op_change;
-              case 'p':
+            case 'p':
                 R.d++;
                 goto r_op_change;
-              case 'M':
+            case 'M':
                 L.d = --R.d;
                 goto r_op_change;
-              case 'm':
+            case 'm':
                 R.d--;
                 goto r_op_change;
-              case '!':
-                L.d = istrue(X.v) ? 0 : 1;
+            case '!':
+                L.d = istrue(X.v) ? 0 : 1;
                 break;
-              case '-':
+            case '-':
                 L.d = -R.d;
                 break;
-            r_op_change:
+ r_op_change:
                 setvar_i(X.v, R.d);
             }
@@ -2427 +2559 @@
             break;
 
-          case XC( OC_FIELD ):
+        case XC( OC_FIELD ):
             R.i = (int)getvar_i(R.v);
             if (R.i == 0) {
-                res = V[F0];
+                res = intvar[F0];
             } else {
                 split_f0();
                 if (R.i > nfields)
                     fsrealloc(R.i);
-
-                res = &Fields[R.i-1];
-            }
-            break;
-
-          /* concatenation (" ") and index joining (",") */
-          case XC( OC_CONCAT ):
-          case XC( OC_COMMA ):
+                res = &Fields[R.i - 1];
+            }
+            break;
+
+        /* concatenation (" ") and index joining (",") */
+        case XC( OC_CONCAT ):
+        case XC( OC_COMMA ):
             opn = strlen(L.s) + strlen(R.s) + 2;
-            X.s = (char *)xmalloc(opn);
+            X.s = xmalloc(opn);
             strcpy(X.s, L.s);
             if ((opinfo & OPCLSMASK) == OC_COMMA) {
-                L.s = getvar_s(V[SUBSEP]);
-                X.s = (char *)xrealloc(X.s, opn + strlen(L.s));
+                L.s = getvar_s(intvar[SUBSEP]);
+                X.s = xrealloc(X.s, opn + strlen(L.s));
                 strcat(X.s, L.s);
             }
@@ -2455 +2586 @@
             break;
 
-          case XC( OC_LAND ):
+        case XC( OC_LAND ):
             setvar_i(res, istrue(L.v) ? ptest(op->r.n) : 0);
             break;
 
-          case XC( OC_LOR ):
+        case XC( OC_LOR ):
             setvar_i(res, istrue(L.v) ? 1 : ptest(op->r.n));
             break;
 
-          case XC( OC_BINARY ):
-          case XC( OC_REPLACE ):
+        case XC( OC_BINARY ):
+        case XC( OC_REPLACE ):
             R.d = getvar_i(R.v);
             switch (opn) {
-              case '+':
+            case '+':
                 L.d += R.d;
                 break;
-              case '-':
+            case '-':
                 L.d -= R.d;
                 break;
-              case '*':
+            case '*':
                 L.d *= R.d;
                 break;
-              case '/':
-                if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
+            case '/':
+                if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO);
                 L.d /= R.d;
                 break;
-              case '&':
-#ifdef CONFIG_FEATURE_AWK_MATH
+            case '&':
+#if ENABLE_FEATURE_AWK_MATH
                 L.d = pow(L.d, R.d);
 #else
-                runtime_error(EMSG_NO_MATH);
+                syntax_error(EMSG_NO_MATH);
 #endif
                 break;
-              case '%':
-                if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
+            case '%':
+                if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO);
                 L.d -= (int)(L.d / R.d) * R.d;
                 break;
             }
-            res = setvar_i(((opinfo&OPCLSMASK) == OC_BINARY) ? res : X.v, L.d);
-            break;
-
-          case XC( OC_COMPARE ):
+            res = setvar_i(((opinfo & OPCLSMASK) == OC_BINARY) ? res : X.v, L.d);
+            break;
+
+        case XC( OC_COMPARE ):
             if (is_numeric(L.v) && is_numeric(R.v)) {
                 L.d = getvar_i(L.v) - getvar_i(R.v);
@@ -2504 +2635 @@
             }
             switch (opn & 0xfe) {
-              case 0:
+            case 0:
                 R.i = (L.d > 0);
                 break;
-              case 2:
+            case 2:
                 R.i = (L.d >= 0);
                 break;
-              case 4:
+            case 4:
                 R.i = (L.d == 0);
                 break;
@@ -2517 +2648 @@
             break;
 
-          default:
-            runtime_error(EMSG_POSSIBLE_ERROR);
+        default:
+            syntax_error(EMSG_POSSIBLE_ERROR);
         }
         if ((opinfo & OPCLSMASK) <= SHIFT_TIL_THIS)
@@ -2529 +2660 @@
     nvfree(v1);
     return res;
+#undef fnargs
+#undef seed
+#undef sreg
 }
 
@@ -2536 +2670 @@
 static int awk_exit(int r)
 {
-    unsigned int i;
+    var tv;
+    unsigned i;
     hash_item *hi;
-    static var tv;
-
-    if (! exiting) {
+
+    zero_out_var(&tv);
+
+    if (!exiting) {
         exiting = TRUE;
         nextrec = FALSE;
@@ -2547 +2683 @@
 
     /* waiting for children */
-    for (i=0; i<fdhash->csize; i++) {
+    for (i = 0; i < fdhash->csize; i++) {
         hi = fdhash->items[i];
-        while(hi) {
+        while (hi) {
             if (hi->data.rs.F && hi->data.rs.is_pipe)
                 pclose(hi->data.rs.F);
@@ -2565 +2701 @@
     char *exprc, *s, *s0, *s1;
 
-    exprc = bb_xstrdup(expr);
+    exprc = xstrdup(expr);
     if (!isalnum_(*exprc) || (s = strchr(exprc, '=')) == NULL) {
         free(exprc);
@@ -2585 +2721 @@
 static rstream *next_input_file(void)
 {
-    static rstream rsm;
+#define rsm          (G.next_input_file__rsm)
+#define files_happen (G.next_input_file__files_happen)
+
     FILE *F = NULL;
-    char *fname, *ind;
-    static int files_happen = FALSE;
+    const char *fname, *ind;
 
     if (rsm.F) fclose(rsm.F);
@@ -2595 +2732 @@
 
     do {
-        if (getvar_i(V[ARGIND])+1 >= getvar_i(V[ARGC])) {
+        if (getvar_i(intvar[ARGIND])+1 >= getvar_i(intvar[ARGC])) {
             if (files_happen)
                 return NULL;
@@ -2601 +2738 @@
             F = stdin;
         } else {
-            ind = getvar_s(incvar(V[ARGIND]));
-            fname = getvar_s(findvar(iamarray(V[ARGV]), ind));
+            ind = getvar_s(incvar(intvar[ARGIND]));
+            fname = getvar_s(findvar(iamarray(intvar[ARGV]), ind));
             if (fname && *fname && !is_assignment(fname))
                 F = afopen(fname, "r");
@@ -2609 +2746 @@
 
     files_happen = TRUE;
-    setvar_s(V[FILENAME], fname);
+    setvar_s(intvar[FILENAME], fname);
     rsm.F = F;
     return &rsm;
-}
-
+#undef rsm
+#undef files_happen
+}
+
+int awk_main(int argc, char **argv);
 int awk_main(int argc, char **argv)
 {
-    char *s, *s1;
-    int i, j, c, flen;
+    unsigned opt;
+    char *opt_F, *opt_W;
+    llist_t *opt_v = NULL;
+    int i, j, flen;
     var *v;
-    static var tv;
+    var tv;
     char **envp;
-    static int from_file = FALSE;
-    rstream *rsm;
-    FILE *F, *stdfiles[3];
-    static char * stdnames = "/dev/stdin\0/dev/stdout\0/dev/stderr";
+    char *vnames = (char *)vNames; /* cheat */
+    char *vvalues = (char *)vValues;
+
+    INIT_G();
+
+    /* Undo busybox.c, or else strtod may eat ','! This breaks parsing:
+     * $1,$2 == '$1,' '$2', NOT '$1' ',' '$2' */
+    if (ENABLE_LOCALE_SUPPORT)
+        setlocale(LC_NUMERIC, "C");
+
+    zero_out_var(&tv);
 
     /* allocate global buffer */
-    buf = xmalloc(MAXVARFMT+1);
+    g_buf = xmalloc(MAXVARFMT + 1);
 
     vhash = hash_init();
@@ -2635 +2784 @@
 
     /* initialize variables */
-    for (i=0;  *vNames;  i++) {
-        V[i] = v = newvar(nextword(&vNames));
-        if (*vValues != '\377')
-            setvar_s(v, nextword(&vValues));
+    for (i = 0; *vnames; i++) {
+        intvar[i] = v = newvar(nextword(&vnames));
+        if (*vvalues != '\377')
+            setvar_s(v, nextword(&vvalues));
         else
             setvar_i(v, 0);
 
-        if (*vNames == '*') {
+        if (*vnames == '*') {
             v->type |= VF_SPECIAL;
-            vNames++;
-        }
-    }
-
-    handle_special(V[FS]);
-    handle_special(V[RS]);
-
-    stdfiles[0] = stdin;
-    stdfiles[1] = stdout;
-    stdfiles[2] = stderr;
-    for (i=0; i<3; i++) {
-        rsm = newfile(nextword(&stdnames));
-        rsm->F = stdfiles[i];
-    }
-
-    for (envp=environ; *envp; envp++) {
-        s = bb_xstrdup(*envp);
-        s1 = strchr(s, '=');
-        if (!s1) {
-            goto keep_going;
-        }
-        *(s1++) = '\0';
-        setvar_u(findvar(iamarray(V[ENVIRON]), s), s1);
-keep_going:
+            vnames++;
+        }
+    }
+
+    handle_special(intvar[FS]);
+    handle_special(intvar[RS]);
+
+    newfile("/dev/stdin")->F = stdin;
+    newfile("/dev/stdout")->F = stdout;
+    newfile("/dev/stderr")->F = stderr;
+
+    /* Huh, people report that sometimes environ is NULL. Oh well. */
+    if (environ) for (envp = environ; *envp; envp++) {
+        /* environ is writable, thus we don't strdup it needlessly */
+        char *s = *envp;
+        char *s1 = strchr(s, '=');
+        if (s1) {
+            *s1 = '\0';
+            /* Both findvar and setvar_u take const char*
+             * as 2nd arg -> environment is not trashed */
+            setvar_u(findvar(iamarray(intvar[ENVIRON]), s), s1 + 1);
+            *s1 = '=';
+        }
+    }
+    opt_complementary = "v::";
+    opt = getopt32(argv, "F:v:f:W:", &opt_F, &opt_v, &g_progname, &opt_W);
+    argv += optind;
+    argc -= optind;
+    if (opt & 0x1)
+        setvar_s(intvar[FS], opt_F); // -F
+    while (opt_v) { /* -v */
+        if (!is_assignment(llist_pop(&opt_v)))
+            bb_show_usage();
+    }
+    if (opt & 0x4) { // -f
+        char *s = s; /* die, gcc, die */
+        FILE *from_file = afopen(g_progname, "r");
+        /* one byte is reserved for some trick in next_token */
+        if (fseek(from_file, 0, SEEK_END) == 0) {
+            flen = ftell(from_file);
+            s = xmalloc(flen + 4);
+            fseek(from_file, 0, SEEK_SET);
+            i = 1 + fread(s + 1, 1, flen, from_file);
+        } else {
+            for (i = j = 1; j > 0; i += j) {
+                s = xrealloc(s, i + 4096);
+                j = fread(s + i, 1, 4094, from_file);
+            }
+        }
+        s[i] = '\0';
+        fclose(from_file);
+        parse_program(s + 1);
         free(s);
-    }
-
-    while((c = getopt(argc, argv, "F:v:f:W:")) != EOF) {
-        switch (c) {
-            case 'F':
-                setvar_s(V[FS], optarg);
-                break;
-            case 'v':
-                if (! is_assignment(optarg))
-                    bb_show_usage();
-                break;
-            case 'f':
-                from_file = TRUE;
-                F = afopen(programname = optarg, "r");
-                s = NULL;
-                /* one byte is reserved for some trick in next_token */
-                if (fseek(F, 0, SEEK_END) == 0) {
-                    flen = ftell(F);
-                    s = (char *)xmalloc(flen+4);
-                    fseek(F, 0, SEEK_SET);
-                    i = 1 + fread(s+1, 1, flen, F);
-                } else {
-                    for (i=j=1; j>0; i+=j) {
-                        s = (char *)xrealloc(s, i+4096);
-                        j = fread(s+i, 1, 4094, F);
-                    }
-                }
-                s[i] = '\0';
-                fclose(F);
-                parse_program(s+1);
-                free(s);
-                break;
-            case 'W':
-                bb_error_msg("Warning: unrecognized option '-W %s' ignored\n", optarg);
-                break;
-
-            default:
-                bb_show_usage();
-        }
-    }
-
-    if (!from_file) {
-        if (argc == optind)
+    } else { // no -f: take program from 1st parameter
+        if (!argc)
             bb_show_usage();
-        programname="cmd. line";
-        parse_program(argv[optind++]);
-
-    }
+        g_progname = "cmd. line";
+        parse_program(*argv++);
+        argc--;
+    }
+    if (opt & 0x8) // -W
+        bb_error_msg("warning: unrecognized option '-W %s' ignored", opt_W);
 
     /* fill in ARGV array */
-    setvar_i(V[ARGC], argc - optind + 1);
-    setari_u(V[ARGV], 0, "awk");
-    for(i=optind; i < argc; i++)
-        setari_u(V[ARGV], i+1-optind, argv[i]);
+    setvar_i(intvar[ARGC], argc + 1);
+    setari_u(intvar[ARGV], 0, "awk");
+    i = 0;
+    while (*argv)
+        setari_u(intvar[ARGV], ++i, *argv++);
 
     evaluate(beginseq.first, &tv);
-    if (! mainseq.first && ! endseq.first)
+    if (!mainseq.first && !endseq.first)
         awk_exit(EXIT_SUCCESS);
 
     /* input file could already be opened in BEGIN block */
-    if (! iF) iF = next_input_file();
+    if (!iF) iF = next_input_file();
 
     /* passing through input files */
     while (iF) {
-
         nextfile = FALSE;
-        setvar_i(V[FNR], 0);
-
-        while ((c = awk_getline(iF, V[F0])) > 0) {
-
+        setvar_i(intvar[FNR], 0);
+
+        while ((i = awk_getline(iF, intvar[F0])) > 0) {
             nextrec = FALSE;
-            incvar(V[NR]);
-            incvar(V[FNR]);
+            incvar(intvar[NR]);
+            incvar(intvar[FNR]);
             evaluate(mainseq.first, &tv);
 
@@ -2748 +2885 @@
         }
 
-        if (c < 0)
-            runtime_error(strerror(errno));
+        if (i < 0)
+            syntax_error(strerror(errno));
 
         iF = next_input_file();
-
     }
 
     awk_exit(EXIT_SUCCESS);
-
-    return 0;
-}
-
+    /*return 0;*/
+}