X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=editors%2Fawk.c;h=9386f4ec0a6bec002cc4e4fc1659f58711437b94;hb=4126b1f5c6983b7c2dd4f92d635ab762d861c2d6;hp=44c2f45b2733bb21700a468d600f1281b5fde817;hpb=a170e1c858d35c474ceb9fecb41b37d681424094;p=oweals%2Fbusybox.git

diff --git a/editors/awk.c b/editors/awk.c
index 44c2f45b2..9386f4ec0 100644
--- a/editors/awk.c
+++ b/editors/awk.c
@@ -4,34 +4,12 @@
  *
  * Copyright (C) 2002 by Dmitry Zakharov <dmit@crp.bank.gov.ua>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
-#include <time.h>
-#include <math.h>
-#include <ctype.h>
-#include <getopt.h>
-#include <regex.h>
-
 #include "busybox.h"
+#include "xregex.h"
+#include <math.h>
 
 
 #define	MAXVARFMT	240
@@ -58,7 +36,7 @@ typedef struct var_s {
 	double number;
 	char *string;
 	union {
-		int aidx;				/* func arg index (on compilation stage) */
+		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) */
@@ -82,6 +60,7 @@ typedef struct func_s {
 typedef struct rstream_s {
 	FILE *F;
 	char *buffer;
+	int adv;
 	int size;
 	int pos;
 	unsigned short is_pipe;
@@ -107,7 +86,7 @@ typedef struct xhash_s {
 
 /* Tree node */
 typedef struct node_s {
-	unsigned long info;
+	uint32_t info;
 	unsigned short lineno;
 	union {
 		struct node_s *n;
@@ -270,7 +249,8 @@ enum {
 /* 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_ge,	B_gs,	B_su,
+	B_an,	B_co,	B_ls,	B_or,	B_rs,	B_xo,
 };
 
 /* tokens and their corresponding info values */
@@ -310,6 +290,8 @@ static char * const tokenlist =
 	"\5while"	NTC
 	"\4else"	NTC
 
+	"\3and"		"\5compl"	"\6lshift"	"\2or"
+	"\6rshift"	"\3xor"
 	"\5close"	"\6system"	"\6fflush"	"\5atan2"	/* BUILTIN */
 	"\3cos"		"\3exp"		"\3int"		"\3log"
 	"\4rand"	"\3sin"		"\4sqrt"	"\5srand"
@@ -323,7 +305,7 @@ static char * const tokenlist =
 	"\3END"		"\0"
 	;
 
-static unsigned long tokeninfo[] = {
+static const uint32_t tokeninfo[] = {
 
 	0,
 	0,
@@ -363,6 +345,8 @@ static unsigned long tokeninfo[] = {
 	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,
 	OC_FBLTIN|F_rn,    OC_FBLTIN|Nx|F_si, OC_FBLTIN|Nx|F_sq, OC_FBLTIN|Nx|F_sr,
@@ -377,7 +361,7 @@ static unsigned long tokeninfo[] = {
 };
 
 /* internal variable names and their initial values       */
-/* asterisk marks SPECIAL vars; $ is just no-named Field0 */ 
+/* asterisk marks SPECIAL vars; $ is just no-named Field0 */
 enum {
 	CONVFMT=0,	OFMT,		FS,			OFS,
 	ORS,		RS,			RT,			FILENAME,
@@ -389,7 +373,7 @@ enum {
 
 static char * vNames =
 	"CONVFMT\0"	"OFMT\0"	"FS\0*"		"OFS\0"
-	"ORS\0"		"RS\0*"		"RT\0"		"FILENAME\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*"
@@ -404,7 +388,7 @@ static char * vValues =
 /* hash size may grow to these values */
 #define FIRST_PRIME 61;
 static const unsigned int PRIMES[] = { 251, 1021, 4093, 16381, 65521 };
-static const unsigned int NPRIMES = sizeof(PRIMES) / sizeof(unsigned int);
+enum { NPRIMES = sizeof(PRIMES) / sizeof(unsigned int) };
 
 /* globals */
 
@@ -419,17 +403,18 @@ static xhash *vhash, *ahash, *fdhash, *fnhash;
 static char *programname;
 static short lineno;
 static int is_f0_split;
-static int nfields = 0;
-static var *Fields = NULL;
+static int nfields;
+static var *Fields;
 static tsplitter fsplitter, rsplitter;
-static nvblock *cb = NULL;
+static nvblock *cb;
 static char *pos;
 static char *buf;
-static int icase = FALSE;
+static int icase;
+static int exiting;
 
 static struct {
-	unsigned long tclass;
-	unsigned long info;
+	uint32_t tclass;
+	uint32_t info;
 	char *string;
 	double number;
 	short lineno;
@@ -437,14 +422,13 @@ static struct {
 } t;
 
 /* function prototypes */
-extern void xregcomp(regex_t *preg, const char *regex, int cflags);
 static void handle_special(var *);
-static node *parse_expr(unsigned long);
+static node *parse_expr(uint32_t);
 static void chain_group(void);
 static var *evaluate(node *, var *);
 static rstream *next_input_file(void);
-static int fmt_num(char *, int, char *, double, int);
-static int awk_exit(int);
+static int fmt_num(char *, int, const char *, double, int);
+static int awk_exit(int) ATTRIBUTE_NORETURN;
 
 /* ---- error handling ---- */
 
@@ -461,10 +445,10 @@ static const char EMSG_UNDEF_FUNC[] = "Call to undefined function";
 static const char EMSG_NO_MATH[] = "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)
 {
-	error_msg("%s:%i: %s", programname, lineno, message);
-	awk_exit(1);
+	bb_error_msg_and_die("%s:%i: %s", programname, lineno, message);
 }
 
 #define runtime_error(x) syntax_error(x)
@@ -472,29 +456,29 @@ static void syntax_error(const char * const message)
 
 /* ---- hash stuff ---- */
 
-static unsigned int hashidx(char *name) {
-
-	register unsigned int idx=0;
+static unsigned int hashidx(const char *name)
+{
+	unsigned int idx=0;
 
 	while (*name)  idx = *name++ + (idx << 6) - idx;
 	return idx;
 }
 
 /* create new hash */
-static xhash *hash_init(void) {
-
+static xhash *hash_init(void)
+{
 	xhash *newhash;
-	
-	newhash = (xhash *)xcalloc(1, sizeof(xhash));
+
+	newhash = (xhash *)xzalloc(sizeof(xhash));
 	newhash->csize = FIRST_PRIME;
-	newhash->items = (hash_item **)xcalloc(newhash->csize, sizeof(hash_item *));
+	newhash->items = (hash_item **)xzalloc(newhash->csize * sizeof(hash_item *));
 
 	return newhash;
 }
 
 /* find item in hash, return ptr to data, NULL if not found */
-static void *hash_search(xhash *hash, char *name) {
-
+static void *hash_search(xhash *hash, const char *name)
+{
 	hash_item *hi;
 
 	hi = hash->items [ hashidx(name) % hash->csize ];
@@ -507,8 +491,8 @@ static void *hash_search(xhash *hash, char *name) {
 }
 
 /* grow hash if it becomes too big */
-static void hash_rebuild(xhash *hash) {
-
+static void hash_rebuild(xhash *hash)
+{
 	unsigned int newsize, i, idx;
 	hash_item **newitems, *hi, *thi;
 
@@ -516,7 +500,7 @@ static void hash_rebuild(xhash *hash) {
 		return;
 
 	newsize = PRIMES[hash->nprime++];
-	newitems = (hash_item **)xcalloc(newsize, sizeof(hash_item *));
+	newitems = (hash_item **)xzalloc(newsize * sizeof(hash_item *));
 
 	for (i=0; i<hash->csize; i++) {
 		hi = hash->items[i];
@@ -535,8 +519,8 @@ static void hash_rebuild(xhash *hash) {
 }
 
 /* find item in hash, add it if necessary. Return ptr to data */
-static void *hash_find(xhash *hash, char *name) {
-
+static void *hash_find(xhash *hash, const char *name)
+{
 	hash_item *hi;
 	unsigned int idx;
 	int l;
@@ -546,8 +530,8 @@ static void *hash_find(xhash *hash, char *name) {
 		if (++hash->nel / hash->csize > 10)
 			hash_rebuild(hash);
 
-		l = xstrlen(name) + 1;
-		hi = xcalloc(sizeof(hash_item) + l, 1);
+		l = strlen(name) + 1;
+		hi = xzalloc(sizeof(hash_item) + l);
 		memcpy(hi->name, name, l);
 
 		idx = hashidx(name) % hash->csize;
@@ -563,15 +547,15 @@ static void *hash_find(xhash *hash, char *name) {
 #define newfile(name) (rstream *) hash_find ( fdhash , (name) )
 #define newfunc(name) (func *) hash_find ( fnhash , (name) )
 
-static void hash_remove(xhash *hash, char *name) {
-
+static void hash_remove(xhash *hash, const char *name)
+{
 	hash_item *hi, **phi;
 
 	phi = &(hash->items[ hashidx(name) % hash->csize ]);
 	while (*phi) {
 		hi = *phi;
 		if (strcmp(hi->name, name) == 0) {
-			hash->glen -= (xstrlen(name) + 1);
+			hash->glen -= (strlen(name) + 1);
 			hash->nel--;
 			*phi = hi->next;
 			free(hi);
@@ -583,51 +567,51 @@ static void hash_remove(xhash *hash, char *name) {
 
 /* ------ some useful functions ------ */
 
-static void skip_spaces(char **s) {
-
-	register char *p = *s;
+static void skip_spaces(char **s)
+{
+	char *p = *s;
 
 	while(*p == ' ' || *p == '\t' ||
-					(*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) {
-	 	p++;
+			(*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) {
+		p++;
 	}
 	*s = p;
 }
 
-static char *nextword(char **s) {
-
-	register char *p = *s;
+static char *nextword(char **s)
+{
+	char *p = *s;
 
 	while (*(*s)++) ;
 
 	return p;
 }
 
-static char nextchar(char **s) {
-
-	register char c, *pps;
+static char nextchar(char **s)
+{
+	char c, *pps;
 
 	c = *((*s)++);
 	pps = *s;
-	if (c == '\\') c = process_escape_sequence((const char**)s);
+	if (c == '\\') c = bb_process_escape_sequence((const char**)s);
 	if (c == '\\' && *s == pps) c = *((*s)++);
 	return c;
 }
 
-static inline int isalnum_(int c) {
-
+static int ATTRIBUTE_ALWAYS_INLINE isalnum_(int c)
+{
 	return (isalnum(c) || c == '_');
 }
 
-static FILE *afopen(const char *path, const char *mode) {
-
+static FILE *afopen(const char *path, const char *mode)
+{
 	return (*path == '-' && *(path+1) == '\0') ? stdin : xfopen(path, mode);
 }
 
 /* -------- working with variables (set/get/copy/etc) -------- */
 
-static xhash *iamarray(var *v) {
-
+static xhash *iamarray(var *v)
+{
 	var *a = v;
 
 	while (a->type & VF_CHILD)
@@ -640,8 +624,8 @@ static xhash *iamarray(var *v) {
 	return a->x.array;
 }
 
-static void clear_array(xhash *array) {
-
+static void clear_array(xhash *array)
+{
 	unsigned int i;
 	hash_item *hi, *thi;
 
@@ -659,8 +643,8 @@ static void clear_array(xhash *array) {
 }
 
 /* clear a variable */
-static var *clrvar(var *v) {
-
+static var *clrvar(var *v)
+{
 	if (!(v->type & VF_FSTR))
 		free(v->string);
 
@@ -671,8 +655,8 @@ static var *clrvar(var *v) {
 }
 
 /* assign string value to variable */
-static var *setvar_p(var *v, char *value) {
-
+static var *setvar_p(var *v, char *value)
+{
 	clrvar(v);
 	v->string = value;
 	handle_special(v);
@@ -681,23 +665,23 @@ static var *setvar_p(var *v, char *value) {
 }
 
 /* same as setvar_p but make a copy of string */
-static var *setvar_s(var *v, char *value) {
-
+static var *setvar_s(var *v, const char *value)
+{
 	return setvar_p(v, (value && *value) ? xstrdup(value) : NULL);
 }
 
 /* same as setvar_s but set USER flag */
-static var *setvar_u(var *v, char *value) {
-
+static var *setvar_u(var *v, const char *value)
+{
 	setvar_s(v, value);
 	v->type |= VF_USER;
 	return v;
 }
 
 /* set array element to user string */
-static void setari_u(var *a, int idx, char *s) {
-
-	register var *v;
+static void setari_u(var *a, int idx, const char *s)
+{
+	var *v;
 	static char sidx[12];
 
 	sprintf(sidx, "%d", idx);
@@ -706,8 +690,8 @@ static void setari_u(var *a, int idx, char *s) {
 }
 
 /* assign numeric value to variable */
-static var *setvar_i(var *v, double value) {
-
+static var *setvar_i(var *v, double value)
+{
 	clrvar(v);
 	v->type |= VF_NUMBER;
 	v->number = value;
@@ -715,8 +699,8 @@ static var *setvar_i(var *v, double value) {
 	return v;
 }
 
-static char *getvar_s(var *v) {
-
+static 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);
@@ -726,8 +710,8 @@ static char *getvar_s(var *v) {
 	return (v->string == NULL) ? "" : v->string;
 }
 
-static double getvar_i(var *v) {
-
+static double getvar_i(var *v)
+{
 	char *s;
 
 	if ((v->type & (VF_NUMBER | VF_CACHED)) == 0) {
@@ -748,8 +732,8 @@ static double getvar_i(var *v) {
 	return v->number;
 }
 
-static var *copyvar(var *dest, var *src) {
-
+static var *copyvar(var *dest, const var *src)
+{
 	if (dest != src) {
 		clrvar(dest);
 		dest->type |= (src->type & ~VF_DONTTOUCH);
@@ -761,30 +745,30 @@ static var *copyvar(var *dest, var *src) {
 	return dest;
 }
 
-static var *incvar(var *v) {
-
+static var *incvar(var *v)
+{
 	return setvar_i(v, getvar_i(v)+1.);
 }
 
 /* return true if v is number or numeric string */
-static int is_numeric(var *v) {
-
+static int is_numeric(var *v)
+{
 	getvar_i(v);
 	return ((v->type ^ VF_DIRTY) & (VF_NUMBER | VF_USER | VF_DIRTY));
 }
 
 /* return 1 when value of v corresponds to true, 0 otherwise */
-static int istrue(var *v) {
-
+static int istrue(var *v)
+{
 	if (is_numeric(v))
 		return (v->number == 0) ? 0 : 1;
 	else
 		return (v->string && *(v->string)) ? 1 : 0;
 }
 
-/* temporary varables allocator. Last allocated should be first freed */
-static var *nvalloc(int n) {
-
+/* temporary variables allocator. Last allocated should be first freed */
+static var *nvalloc(int n)
+{
 	nvblock *pb = NULL;
 	var *v, *r;
 	int size;
@@ -817,8 +801,8 @@ static var *nvalloc(int n) {
 	return r;
 }
 
-static void nvfree(var *v) {
-
+static void nvfree(var *v)
+{
 	var *p;
 
 	if (v < cb->nv || v >= cb->pos)
@@ -847,15 +831,16 @@ static void nvfree(var *v) {
 /* Parse next token pointed by global pos, place results into global t.
  * If token isn't expected, give away. Return token class
  */
-static unsigned long next_token(unsigned long expected) {
-
+static uint32_t next_token(uint32_t expected)
+{
 	char *p, *pp, *s;
 	char *tl;
-	unsigned long tc, *ti;
+	uint32_t tc;
+	const uint32_t *ti;
 	int l;
-	static int concat_inserted = FALSE;
-	static unsigned long save_tclass, save_info;
-	static unsigned long ltclass = TC_OPTERM;
+	static int concat_inserted;
+	static uint32_t save_tclass, save_info;
+	static uint32_t ltclass = TC_OPTERM;
 
 	if (t.rollback) {
 
@@ -903,7 +888,7 @@ static unsigned long next_token(unsigned long expected) {
 					syntax_error(EMSG_UNEXP_EOS);
 				if ((*s++ = *p++) == '\\') {
 					pp = p;
-					*(s-1) = process_escape_sequence((const char **)&p);
+					*(s-1) = bb_process_escape_sequence((const char **)&p);
 					if (*pp == '\\') *s++ = '\\';
 					if (p == pp) *s++ = *p++;
 				}
@@ -958,10 +943,11 @@ static unsigned long next_token(unsigned long expected) {
 				}
 				*(p-1) = '\0';
 				tc = TC_VARIABLE;
+				/* also consume whitespace between functionname and bracket */
+				if (! (expected & TC_VARIABLE)) skip_spaces(&p);
 				if (*p == '(') {
 					tc = TC_FUNCTION;
 				} else {
-					skip_spaces(&p);
 					if (*p == '[') {
 						p++;
 						tc = TC_ARRAY;
@@ -998,18 +984,18 @@ static unsigned long next_token(unsigned long expected) {
 
 static void rollback_token(void) { t.rollback = TRUE; }
 
-static node *new_node(unsigned long info) {
-
-	register node *n;
+static node *new_node(uint32_t info)
+{
+	node *n;
 
-	n = (node *)xcalloc(sizeof(node), 1);
+	n = (node *)xzalloc(sizeof(node));
 	n->info = info;
 	n->lineno = lineno;
 	return n;
 }
 
-static node *mk_re_node(char *s, node *n, regex_t *re) {
-
+static node *mk_re_node(char *s, node *n, regex_t *re)
+{
 	n->info = OC_REGEXP;
 	n->l.re = re;
 	n->r.ire = re + 1;
@@ -1019,20 +1005,20 @@ static node *mk_re_node(char *s, node *n, regex_t *re) {
 	return n;
 }
 
-static node *condition(void) {
-
+static node *condition(void)
+{
 	next_token(TC_SEQSTART);
 	return parse_expr(TC_SEQTERM);
 }
 
 /* parse expression terminated by given argument, return ptr
  * to built subtree. Terminator is eaten by parse_expr */
-static node *parse_expr(unsigned long iexp) {
-
+static node *parse_expr(uint32_t iexp)
+{
 	node sn;
 	node *cn = &sn;
 	node *vn, *glptr;
-	unsigned long tc, xtc;
+	uint32_t tc, xtc;
 	var *v;
 
 	sn.info = PRIMASK;
@@ -1043,6 +1029,7 @@ static node *parse_expr(unsigned long 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->a.n = glptr;
 			xtc = TC_OPERAND | TC_UOPPRE;
 			glptr = NULL;
 
@@ -1050,7 +1037,7 @@ static node *parse_expr(unsigned long iexp) {
 			/* for binary and postfix-unary operators, jump back over
 			 * previous operators with higher priority */
 			vn = cn;
-			while ( ((t.info & PRIMASK) > (vn->a.n->info & PRIMASK2)) || 
+			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)
@@ -1077,34 +1064,33 @@ static node *parse_expr(unsigned long iexp) {
 			/* for operands and prefix-unary operators, attach them
 			 * 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;
 			if (tc & (TC_OPERAND | TC_REGEXP)) {
-				xtc = TC_UOPPRE | TC_BINOP | TC_OPERAND | iexp;
-				/* one should be very careful with switch on tclass - 
+				xtc = TC_UOPPRE | TC_UOPPOST | TC_BINOP | TC_OPERAND | iexp;
+				/* one should be very careful with switch on tclass -
 				 * only simple tclasses should be used! */
 				switch (tc) {
 				  case TC_VARIABLE:
 				  case TC_ARRAY:
 					cn->info = OC_VAR;
-				  	if ((v = hash_search(ahash, t.string)) != NULL) {
+					if ((v = hash_search(ahash, t.string)) != 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) {
 						cn->info |= xS;
 						cn->r.n = parse_expr(TC_ARRTERM);
 					}
-					xtc = TC_UOPPOST | TC_UOPPRE | TC_BINOP | TC_OPERAND | iexp;
 					break;
-				  	
+
 				  case TC_NUMBER:
 				  case TC_STRING:
 					cn->info = OC_VAR;
-					v = cn->l.v = xcalloc(sizeof(var), 1);
+					v = cn->l.v = xzalloc(sizeof(var));
 					if (tc & TC_NUMBER)
 						setvar_i(v, t.number);
 					else
@@ -1113,11 +1099,11 @@ static node *parse_expr(unsigned long iexp) {
 
 				  case TC_REGEXP:
 					mk_re_node(t.string, cn,
-									(regex_t *)xcalloc(sizeof(regex_t),2));
+									(regex_t *)xzalloc(sizeof(regex_t)*2));
 					break;
 
 				  case TC_FUNCTION:
-				  	cn->info = OC_FUNC;
+					cn->info = OC_FUNC;
 					cn->r.f = newfunc(t.string);
 					cn->l.n = condition();
 					break;
@@ -1143,9 +1129,9 @@ static node *parse_expr(unsigned long iexp) {
 }
 
 /* add node to chain. Return ptr to alloc'd node */
-static node *chain_node(unsigned long info) {
-
-	register node *n;
+static node *chain_node(uint32_t info)
+{
+	node *n;
 
 	if (! seq->first)
 		seq->first = seq->last = new_node(0);
@@ -1163,8 +1149,8 @@ static node *chain_node(unsigned long info) {
 	return n;
 }
 
-static void chain_expr(unsigned long info) {
-
+static void chain_expr(uint32_t info)
+{
 	node *n;
 
 	n = chain_node(info);
@@ -1173,8 +1159,8 @@ static void chain_expr(unsigned long info) {
 		rollback_token();
 }
 
-static node *chain_loop(node *nn) {
-
+static node *chain_loop(node *nn)
+{
 	node *n, *n2, *save_brk, *save_cont;
 
 	save_brk = break_ptr;
@@ -1197,9 +1183,9 @@ static node *chain_loop(node *nn) {
 }
 
 /* parse group and attach it to chain */
-static void chain_group(void) {
-
-	unsigned long c;
+static void chain_group(void)
+{
+	uint32_t c;
 	node *n, *n2, *n3;
 
 	do {
@@ -1208,6 +1194,7 @@ static void chain_group(void) {
 
 	if (c & TC_GRPSTART) {
 		while(next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
+			if (t.tclass & TC_NEWLINE) continue;
 			rollback_token();
 			chain_group();
 		}
@@ -1298,9 +1285,9 @@ static void chain_group(void) {
 	}
 }
 
-static void parse_program(char *p) {
-
-	unsigned long tclass;
+static void parse_program(char *p)
+{
+	uint32_t tclass;
 	node *cn;
 	func *f;
 	var *v;
@@ -1361,33 +1348,33 @@ static void parse_program(char *p) {
 
 /* -------- program execution part -------- */
 
-static node *mk_splitter(char *s, tsplitter *spl) {
-
-	register regex_t *re, *ire;
+static node *mk_splitter(char *s, tsplitter *spl)
+{
+	regex_t *re, *ire;
 	node *n;
 
 	re = &spl->re[0];
 	ire = &spl->re[1];
 	n = &spl->n;
-	if ((n->info && OPCLSMASK) == OC_REGEXP) {
+	if ((n->info & OPCLSMASK) == OC_REGEXP) {
 		regfree(re);
 		regfree(ire);
 	}
-	if (xstrlen(s) > 1) {
+	if (strlen(s) > 1) {
 		mk_re_node(s, n, re);
 	} else {
-		n->info = (unsigned long) *s;
+		n->info = (uint32_t) *s;
 	}
 
 	return n;
 }
 
 /* use node as a regular expression. Supplied with node ptr and regex_t
- * storage space. Return ptr to regex (if result points to preg, it shuold
+ * storage space. Return ptr to regex (if result points to preg, it should
  * be later regfree'd manually
  */
-static regex_t *as_regex(node *op, regex_t *preg) {
-
+static regex_t *as_regex(node *op, regex_t *preg)
+{
 	var *v;
 	char *s;
 
@@ -1403,15 +1390,15 @@ static regex_t *as_regex(node *op, regex_t *preg) {
 }
 
 /* gradually increasing buffer */
-static void qrealloc(char **b, int n, int *size) {
-
+static void qrealloc(char **b, int n, int *size)
+{
 	if (! *b || n >= *size)
 		*b = xrealloc(*b, *size = n + (n>>1) + 80);
 }
 
 /* resize field storage space */
-static void fsrealloc(int size) {
-
+static void fsrealloc(int size)
+{
 	static int maxfields = 0;
 	int i;
 
@@ -1433,15 +1420,15 @@ static void fsrealloc(int size) {
 	nfields = size;
 }
 
-static int awk_split(char *s, node *spl, char **slist) {
-
+static int awk_split(char *s, node *spl, char **slist)
+{
 	int l, n=0;
 	char c[4];
 	char *s1;
 	regmatch_t pmatch[2];
 
 	/* in worst case, each char would be a separate field */
-	*slist = s1 = xstrndup(s, xstrlen(s) * 2 + 3);
+	*slist = s1 = xstrndup(s, strlen(s) * 2 + 3);
 
 	c[0] = c[1] = (char)spl->info;
 	c[2] = c[3] = '\0';
@@ -1483,7 +1470,7 @@ static int awk_split(char *s, node *spl, char **slist) {
 		}
 	} else {				/* space split */
 		while (*s) {
-			while (isspace(*s)) s++;
+			s = skip_whitespace(s);
 			if (! *s) break;
 			n++;
 			while (*s && !isspace(*s))
@@ -1494,8 +1481,8 @@ static int awk_split(char *s, node *spl, char **slist) {
 	return n;
 }
 
-static void split_f0(void) {
-
+static void split_f0(void)
+{
 	static char *fstrings = NULL;
 	int i, n;
 	char *s;
@@ -1521,8 +1508,8 @@ static void split_f0(void) {
 }
 
 /* perform additional actions when some internal variables changed */
-static void handle_special(var *v) {
-
+static void handle_special(var *v)
+{
 	int n;
 	char *b, *sep, *s;
 	int sl, l, len, i, bsize;
@@ -1536,12 +1523,12 @@ static void handle_special(var *v) {
 
 		/* recalculate $0 */
 		sep = getvar_s(V[OFS]);
-		sl = xstrlen(sep);
+		sl = strlen(sep);
 		b = NULL;
 		len = 0;
 		for (i=0; i<n; i++) {
 			s = getvar_s(&Fields[i]);
-			l = xstrlen(s);
+			l = strlen(s);
 			if (b) {
 				memcpy(b+len, sep, sl);
 				len += sl;
@@ -1550,7 +1537,7 @@ static void handle_special(var *v) {
 			memcpy(b+len, s, l);
 			len += l;
 		}
-		b[len] = '\0';
+		if (b) b[len] = '\0';
 		setvar_p(V[F0], b);
 		is_f0_split = TRUE;
 
@@ -1574,8 +1561,8 @@ static void handle_special(var *v) {
 }
 
 /* step through func/builtin/etc arguments */
-static node *nextarg(node **pn) {
-
+static node *nextarg(node **pn)
+{
 	node *n;
 
 	n = *pn;
@@ -1588,8 +1575,8 @@ static node *nextarg(node **pn) {
 	return n;
 }
 
-static void hashwalk_init(var *v, xhash *array) {
-
+static void hashwalk_init(var *v, xhash *array)
+{
 	char **w;
 	hash_item *hi;
 	int i;
@@ -1598,7 +1585,7 @@ static void hashwalk_init(var *v, xhash *array) {
 		free(v->x.walker);
 
 	v->type |= VF_WALK;
-	w = v->x.walker = (char **)xcalloc(2 + 2*sizeof(char *) + array->glen, 1);
+	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++) {
 		hi = array->items[i];
@@ -1610,8 +1597,8 @@ static void hashwalk_init(var *v, xhash *array) {
 	}
 }
 
-static int hashwalk_next(var *v) {
-
+static int hashwalk_next(var *v)
+{
 	char **w;
 
 	w = v->x.walker;
@@ -1623,32 +1610,35 @@ static int hashwalk_next(var *v) {
 }
 
 /* evaluate node, return 1 when result is true, 0 otherwise */
-static int ptest(node *pattern) {
+static int ptest(node *pattern)
+{
 	static var v;
-
 	return istrue(evaluate(pattern, &v));
 }
 
 /* read next record from stream rsm into a variable v */
-static int awk_getline(rstream *rsm, var *v) {
-
+static int awk_getline(rstream *rsm, var *v)
+{
 	char *b;
 	regmatch_t pmatch[2];
-	int p, pp=0, size;
+	int a, p, pp=0, size;
 	int fd, so, eo, r, rp;
-	char c, *s;
+	char c, *m, *s;
 
 	/* we're using our own buffer since we need access to accumulating
 	 * characters
 	 */
 	fd = fileno(rsm->F);
-	b = rsm->buffer;
+	m = rsm->buffer;
+	a = rsm->adv;
 	p = rsm->pos;
 	size = rsm->size;
 	c = (char) rsplitter.n.info;
 	rp = 0;
+
+	if (! m) qrealloc(&m, 256, &size);
 	do {
-		qrealloc(&b, p+128, &size);
+		b = m + a;
 		so = eo = p;
 		r = 1;
 		if (p > 0) {
@@ -1662,6 +1652,7 @@ static int awk_getline(rstream *rsm, var *v) {
 				}
 			} else if (c != '\0') {
 				s = strchr(b+pp, c);
+				if (! s) s = memchr(b+pp, '\0', p - pp);
 				if (s) {
 					so = eo = s-b;
 					eo++;
@@ -1680,6 +1671,14 @@ static int awk_getline(rstream *rsm, var *v) {
 			}
 		}
 
+		if (a > 0) {
+			memmove(m, (const void *)(m+a), p+1);
+			b = m;
+			a = 0;
+		}
+
+		qrealloc(&m, a+p+128, &size);
+		b = m + a;
 		pp = p;
 		p += safe_read(fd, b+p, size-p-1);
 		if (p < pp) {
@@ -1703,20 +1702,19 @@ static int awk_getline(rstream *rsm, var *v) {
 		b[eo] = c;
 	}
 
-	p -= eo;
-	if (p) memmove(b, (const void *)(b+eo), p+1);
-
-	rsm->buffer = b;
-	rsm->pos = p;
+	rsm->buffer = m;
+	rsm->adv = a + eo;
+	rsm->pos = p - eo;
 	rsm->size = size;
 
 	return r;
 }
 
-static int fmt_num(char *b, int size, char *format, double n, int int_as_int) {
-
+static int fmt_num(char *b, int size, const char *format, double n, int int_as_int)
+{
 	int r=0;
-	char c, *s=format;
+	char c;
+	const char *s=format;
 
 	if (int_as_int && n == (int)n) {
 		r = snprintf(b, size, "%d", (int)n);
@@ -1735,8 +1733,8 @@ static int fmt_num(char *b, int size, char *format, double n, int int_as_int) {
 
 
 /* formatted output into an allocated buffer, return ptr to buffer */
-static char *awk_printf(node *n) {
-
+static char *awk_printf(node *n)
+{
 	char *b = NULL;
 	char *fmt, *s, *s1, *f;
 	int i, j, incr, bsize;
@@ -1751,7 +1749,7 @@ static char *awk_printf(node *n) {
 		s = f;
 		while (*f && (*f != '%' || *(++f) == '%'))
 			f++;
-		while (*f && !isalpha(*f)) 
+		while (*f && !isalpha(*f))
 			f++;
 
 		incr = (f - s) + MAXVARFMT;
@@ -1766,8 +1764,8 @@ static char *awk_printf(node *n) {
 					is_numeric(arg) ? (char)getvar_i(arg) : *getvar_s(arg));
 
 		} else if (c == 's') {
-		    s1 = getvar_s(arg);
-			qrealloc(&b, incr+i+xstrlen(s1), &bsize);
+			s1 = getvar_s(arg);
+			qrealloc(&b, incr+i+strlen(s1), &bsize);
 			i += sprintf(b+i, s, s1);
 
 		} else {
@@ -1793,8 +1791,8 @@ static char *awk_printf(node *n) {
  * all matches. If src or dst is NULL, use $0. If ex=TRUE, enable
  * 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, char *repl, int nm, var *src, var *dest, int ex)
+{
 	char *ds = NULL;
 	char *sp, *s;
 	int c, i, j, di, rl, so, eo, nbs, n, dssize;
@@ -1807,7 +1805,7 @@ static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex) {
 
 	i = di = 0;
 	sp = getvar_s(src);
-	rl = xstrlen(repl);
+	rl = strlen(repl);
 	while (regexec(re, sp, 10, pmatch, sp==getvar_s(src) ? 0:REG_NOTBOL) == 0) {
 		so = pmatch[0].rm_so;
 		eo = pmatch[0].rm_eo;
@@ -1859,8 +1857,8 @@ static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex) {
 	return i;
 }
 
-static var *exec_builtin(node *op, var *res) {
-
+static var *exec_builtin(node *op, var *res)
+{
 	int (*to_xxx)(int);
 	var *tv;
 	node *an[4];
@@ -1870,7 +1868,7 @@ static var *exec_builtin(node *op, var *res) {
 	regex_t sreg, *re;
 	static tsplitter tspl;
 	node *spl;
-	unsigned long isr, info;
+	uint32_t isr, info;
 	int nargs;
 	time_t tt;
 	char *s, *s1;
@@ -1920,7 +1918,7 @@ static var *exec_builtin(node *op, var *res) {
 		break;
 
 	  case B_ss:
-		l = xstrlen(as[0]);
+		l = strlen(as[0]);
 		i = getvar_i(av[1]) - 1;
 		if (i>l) i=l; if (i<0) i=0;
 		n = (nargs > 2) ? getvar_i(av[2]) : l-i;
@@ -1930,6 +1928,30 @@ static var *exec_builtin(node *op, var *res) {
 		s[n] = '\0';
 		setvar_p(res, s);
 		break;
+		
+	 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;
@@ -1948,8 +1970,8 @@ lo_cont:
 
 	  case B_ix:
 		n = 0;
-		ll = xstrlen(as[1]);
-		l = xstrlen(as[0]) - ll;
+		ll = strlen(as[1]);
+		l = strlen(as[0]) - ll;
 		if (ll > 0 && l >= 0) {
 			if (! icase) {
 				s = strstr(as[0], as[1]);
@@ -2019,9 +2041,9 @@ lo_cont:
  */
 #define XC(n) ((n) >> 8)
 
-static var *evaluate(node *op, var *res) {
-
- 	/* This procedure is recursive so we should count every byte */
+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;
@@ -2033,7 +2055,7 @@ static var *evaluate(node *op, var *res) {
 		double d;
 		int i;
 	} L, R;
-	unsigned long opinfo;
+	uint32_t opinfo;
 	short opn;
 	union {
 		char *s;
@@ -2041,7 +2063,7 @@ static var *evaluate(node *op, var *res) {
 		FILE *F;
 		var *v;
 		regex_t *re;
-		unsigned long info;
+		uint32_t info;
 	} X;
 
 	if (! op)
@@ -2055,7 +2077,7 @@ static var *evaluate(node *op, var *res) {
 		opn = (short)(opinfo & OPNMASK);
 		lineno = op->lineno;
 
- 		/* execute inevitable things */
+		/* execute inevitable things */
 		op1 = op->l.n;
 		if (opinfo & OF_RES1) X.v = L.v = evaluate(op1, v1);
 		if (opinfo & OF_RES2) R.v = evaluate(op->r.n, v1+1);
@@ -2087,16 +2109,16 @@ static var *evaluate(node *op, var *res) {
 
 		  /* just evaluate an expression, also used as unconditional jump */
 		  case XC( OC_EXEC ):
-		  	break;
+			break;
 
 		  /* branch, used in if-else and various loops */
 		  case XC( OC_BR ):
-		  	op = istrue(L.v) ? op->a.n : op->r.n;
+			op = istrue(L.v) ? op->a.n : op->r.n;
 			break;
 
 		  /* initialize for-in loop */
 		  case XC( OC_WALKINIT ):
-		  	hashwalk_init(L.v, iamarray(R.v));
+			hashwalk_init(L.v, iamarray(R.v));
 			break;
 
 		  /* get next array item */
@@ -2107,12 +2129,12 @@ static var *evaluate(node *op, var *res) {
 		  case XC( OC_PRINT ):
 		  case XC( OC_PRINTF ):
 			X.F = stdout;
-		  	if (op->r.n) {
+			if (op->r.n) {
 				X.rsm = newfile(R.s);
 				if (! X.rsm->F) {
 					if (opn == '|') {
 						if((X.rsm->F = popen(R.s, "w")) == NULL)
-							perror_msg_and_die("popen");
+							bb_perror_msg_and_die("popen");
 						X.rsm->is_pipe = 1;
 					} else {
 						X.rsm->F = xfopen(R.s, opn=='w' ? "w" : "a");
@@ -2122,14 +2144,14 @@ static var *evaluate(node *op, var *res) {
 			}
 
 			if ((opinfo & OPCLSMASK) == OC_PRINT) {
-		  		if (! op1) {
+				if (! op1) {
 					fputs(getvar_s(V[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);
+									getvar_i(L.v), TRUE);
 							fputs(buf, X.F);
 						} else {
 							fputs(getvar_s(L.v), X.F);
@@ -2149,8 +2171,8 @@ static var *evaluate(node *op, var *res) {
 			break;
 
 		  case XC( OC_DELETE ):
-		  	X.info = op1->info & OPCLSMASK;
-		  	if (X.info == OC_VAR) {
+			X.info = op1->info & OPCLSMASK;
+			if (X.info == OC_VAR) {
 				R.v = op1->l.v;
 			} else if (X.info == OC_FNARG) {
 				R.v = &fnargs[op1->l.i];
@@ -2158,7 +2180,7 @@ static var *evaluate(node *op, var *res) {
 				runtime_error(EMSG_NOT_ARRAY);
 			}
 
-		  	if (op1->r.n) {
+			if (op1->r.n) {
 				clrvar(L.v);
 				L.s = getvar_s(evaluate(op1->r.n, v1));
 				hash_remove(iamarray(R.v), L.s);
@@ -2168,7 +2190,7 @@ static var *evaluate(node *op, var *res) {
 			break;
 
 		  case XC( OC_NEWSOURCE ):
-		  	programname = op->l.s;
+			programname = op->l.s;
 			break;
 
 		  case XC( OC_RETURN ):
@@ -2176,29 +2198,29 @@ static var *evaluate(node *op, var *res) {
 			break;
 
 		  case XC( OC_NEXTFILE ):
-		  	nextfile = TRUE;
+			nextfile = TRUE;
 		  case XC( OC_NEXT ):
-		  	nextrec = TRUE;
+			nextrec = TRUE;
 		  case XC( OC_DONE ):
 			clrvar(res);
 			break;
 
 		  case XC( OC_EXIT ):
-		  	awk_exit(L.d);
+			awk_exit(L.d);
 
 		  /* -- recursive node type -- */
 
 		  case XC( OC_VAR ):
-		  	L.v = op->l.v;
+			L.v = op->l.v;
 			if (L.v == V[NF])
 				split_f0();
 			goto v_cont;
 
 		  case XC( OC_FNARG ):
-		  	L.v = &fnargs[op->l.i];
+			L.v = &fnargs[op->l.i];
 
 v_cont:
-		 	res = (op->r.n) ? findvar(iamarray(L.v), R.s) : L.v;
+			res = (op->r.n) ? findvar(iamarray(L.v), R.s) : L.v;
 			break;
 
 		  case XC( OC_IN ):
@@ -2206,12 +2228,12 @@ v_cont:
 			break;
 
 		  case XC( OC_REGEXP ):
-		  	op1 = op;
+			op1 = op;
 			L.s = getvar_s(V[F0]);
 			goto re_cont;
 
 		  case XC( OC_MATCH ):
-		  	op1 = op->r.n;
+			op1 = op->r.n;
 re_cont:
 			X.re = as_regex(op1, &sreg);
 			R.i = regexec(X.re, L.s, 0, NULL, 0);
@@ -2220,23 +2242,23 @@ re_cont:
 			break;
 
 		  case XC( OC_MOVE ):
-		  	/* if source is a temporary string, jusk relink it to dest */
+			/* if source is a temporary string, jusk relink it to dest */
 			if (R.v == v1+1 && R.v->string) {
 				res = setvar_p(L.v, R.v->string);
 				R.v->string = NULL;
 			} else {
-		  		res = copyvar(L.v, R.v);
+				res = copyvar(L.v, R.v);
 			}
 			break;
 
 		  case XC( OC_TERNARY ):
-		  	if ((op->r.n->info & OPCLSMASK) != OC_COLON)
+			if ((op->r.n->info & OPCLSMASK) != OC_COLON)
 				runtime_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)
+			if (! op->r.f->body.first)
 				runtime_error(EMSG_UNDEF_FUNC);
 
 			X.v = R.v = nvalloc(op->r.f->nargs+1);
@@ -2262,7 +2284,7 @@ re_cont:
 
 		  case XC( OC_GETLINE ):
 		  case XC( OC_PGETLINE ):
-		  	if (op1) {
+			if (op1) {
 				X.rsm = newfile(L.s);
 				if (! X.rsm->F) {
 					if ((opinfo & OPCLSMASK) == OC_PGETLINE) {
@@ -2296,37 +2318,37 @@ re_cont:
 			setvar_i(res, L.i);
 			break;
 
-   		  /* simple builtins */
+		  /* simple builtins */
 		  case XC( OC_FBLTIN ):
-		  	switch (opn) {
+			switch (opn) {
 
 			  case F_in:
-			  	R.d = (int)L.d;
+				R.d = (int)L.d;
 				break;
 
 			  case F_rn:
-			  	R.d =  (double)rand() / (double)RAND_MAX;
+				R.d =  (double)rand() / (double)RAND_MAX;
 				break;
 
 #ifdef CONFIG_FEATURE_AWK_MATH
 			  case F_co:
-			  	R.d = cos(L.d);
+				R.d = cos(L.d);
 				break;
 
 			  case F_ex:
-			  	R.d = exp(L.d);
+				R.d = exp(L.d);
 				break;
 
 			  case F_lg:
-			  	R.d = log(L.d);
+				R.d = log(L.d);
 				break;
 
 			  case F_si:
-			  	R.d = sin(L.d);
+				R.d = sin(L.d);
 				break;
 
 			  case F_sq:
-			  	R.d = sqrt(L.d);
+				R.d = sqrt(L.d);
 				break;
 #else
 			  case F_co:
@@ -2349,14 +2371,14 @@ re_cont:
 				break;
 
 			  case F_le:
-			  	if (! op1)
+				if (! op1)
 					L.s = getvar_s(V[F0]);
-				R.d = xstrlen(L.s);
+				R.d = strlen(L.s);
 				break;
 
 			  case F_sy:
 				fflush(NULL);
-				R.d = (L.s && *L.s) ? system(L.s) : 0;
+				R.d = (L.s && *L.s) ? (system(L.s) >> 8) : 0;
 				break;
 
 			  case F_ff:
@@ -2392,30 +2414,30 @@ re_cont:
 			break;
 
 		  case XC( OC_SPRINTF ):
-		  	setvar_p(res, awk_printf(op1));
+			setvar_p(res, awk_printf(op1));
 			break;
 
 		  case XC( OC_UNARY ):
-		  	X.v = R.v;
-		  	L.d = R.d = getvar_i(R.v);
-		  	switch (opn) {
+			X.v = R.v;
+			L.d = R.d = getvar_i(R.v);
+			switch (opn) {
 			  case 'P':
-			  	L.d = ++R.d;
+				L.d = ++R.d;
 				goto r_op_change;
 			  case 'p':
-			  	R.d++;
+				R.d++;
 				goto r_op_change;
 			  case 'M':
-			  	L.d = --R.d;
+				L.d = --R.d;
 				goto r_op_change;
 			  case 'm':
-			  	R.d--;
+				R.d--;
 				goto r_op_change;
 			  case '!':
-			    L.d = istrue(X.v) ? 0 : 1;
+				L.d = istrue(X.v) ? 0 : 1;
 				break;
 			  case '-':
-			  	L.d = -R.d;
+				L.d = -R.d;
 				break;
 			r_op_change:
 				setvar_i(X.v, R.d);
@@ -2424,8 +2446,8 @@ re_cont:
 			break;
 
 		  case XC( OC_FIELD ):
-		  	R.i = (int)getvar_i(R.v);
-		  	if (R.i == 0) {
+			R.i = (int)getvar_i(R.v);
+			if (R.i == 0) {
 				res = V[F0];
 			} else {
 				split_f0();
@@ -2439,12 +2461,12 @@ re_cont:
 		  /* concatenation (" ") and index joining (",") */
 		  case XC( OC_CONCAT ):
 		  case XC( OC_COMMA ):
-			opn = xstrlen(L.s) + xstrlen(R.s) + 2;
-		  	X.s = (char *)xmalloc(opn);
+			opn = strlen(L.s) + strlen(R.s) + 2;
+			X.s = (char *)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 + xstrlen(L.s));
+				X.s = (char *)xrealloc(X.s, opn + strlen(L.s));
 				strcat(X.s, L.s);
 			}
 			strcat(X.s, R.s);
@@ -2461,31 +2483,31 @@ re_cont:
 
 		  case XC( OC_BINARY ):
 		  case XC( OC_REPLACE ):
-		  	R.d = getvar_i(R.v);
+			R.d = getvar_i(R.v);
 			switch (opn) {
 			  case '+':
-			  	L.d += R.d;
+				L.d += R.d;
 				break;
 			  case '-':
-			  	L.d -= R.d;
+				L.d -= R.d;
 				break;
 			  case '*':
-			  	L.d *= R.d;
+				L.d *= R.d;
 				break;
 			  case '/':
-			  	if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
-			  	L.d /= R.d;
+				if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
+				L.d /= R.d;
 				break;
 			  case '&':
 #ifdef CONFIG_FEATURE_AWK_MATH
-			  	L.d = pow(L.d, R.d);
+				L.d = pow(L.d, R.d);
 #else
 				runtime_error(EMSG_NO_MATH);
 #endif
 				break;
 			  case '%':
-			  	if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
-			  	L.d -= (int)(L.d / R.d) * R.d;
+				if (R.d == 0) runtime_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);
@@ -2501,20 +2523,20 @@ re_cont:
 			}
 			switch (opn & 0xfe) {
 			  case 0:
-			  	R.i = (L.d > 0);
+				R.i = (L.d > 0);
 				break;
 			  case 2:
-			  	R.i = (L.d >= 0);
+				R.i = (L.d >= 0);
 				break;
 			  case 4:
-			  	R.i = (L.d == 0);
+				R.i = (L.d == 0);
 				break;
 			}
 			setvar_i(res, (opn & 0x1 ? R.i : !R.i) ? 1 : 0);
 			break;
 
 		  default:
-		  	runtime_error(EMSG_POSSIBLE_ERROR);
+			runtime_error(EMSG_POSSIBLE_ERROR);
 		}
 		if ((opinfo & OPCLSMASK) <= SHIFT_TIL_THIS)
 			op = op->a.n;
@@ -2530,10 +2552,17 @@ re_cont:
 
 /* -------- main & co. -------- */
 
-static int awk_exit(int r) {
-
+static int awk_exit(int r)
+{
 	unsigned int i;
 	hash_item *hi;
+	static var tv;
+
+	if (! exiting) {
+		exiting = TRUE;
+		nextrec = FALSE;
+		evaluate(endseq.first, &tv);
+	}
 
 	/* waiting for children */
 	for (i=0; i<fdhash->csize; i++) {
@@ -2550,8 +2579,8 @@ static int awk_exit(int r) {
 
 /* if expr looks like "var=value", perform assignment and return 1,
  * otherwise return 0 */
-static int is_assignment(char *expr) {
-
+static int is_assignment(const char *expr)
+{
 	char *exprc, *s, *s0, *s1;
 
 	exprc = xstrdup(expr);
@@ -2572,8 +2601,8 @@ static int is_assignment(char *expr) {
 }
 
 /* switch to next input file */
-static rstream *next_input_file(void) {
-
+static rstream *next_input_file(void)
+{
 	static rstream rsm;
 	FILE *F = NULL;
 	char *fname, *ind;
@@ -2581,7 +2610,7 @@ static rstream *next_input_file(void) {
 
 	if (rsm.F) fclose(rsm.F);
 	rsm.F = NULL;
-	rsm.pos = 0;
+	rsm.pos = rsm.adv = 0;
 
 	do {
 		if (getvar_i(V[ARGIND])+1 >= getvar_i(V[ARGC])) {
@@ -2603,10 +2632,12 @@ static rstream *next_input_file(void) {
 	return &rsm;
 }
 
-extern int awk_main(int argc, char **argv) {
-
+int awk_main(int argc, char **argv)
+{
+	unsigned opt;
+	char *opt_F, *opt_v, *opt_W;
 	char *s, *s1;
-	int i, j, c;
+	int i, j, c, flen;
 	var *v;
 	static var tv;
 	char **envp;
@@ -2651,47 +2682,46 @@ extern int awk_main(int argc, char **argv) {
 	for (envp=environ; *envp; envp++) {
 		s = xstrdup(*envp);
 		s1 = strchr(s, '=');
+		if (!s1) {
+			goto keep_going;
+		}
 		*(s1++) = '\0';
 		setvar_u(findvar(iamarray(V[ENVIRON]), s), s1);
+keep_going:
 		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))
-					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 */
-				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':
-				error_msg("Warning: unrecognized option '-W %s' ignored\n", optarg);
-				break;
-
-			default:
-				show_usage();
+	opt = getopt32(argc, argv, "F:v:f:W:", &opt_F, &opt_v, &programname, &opt_W);
+	if (opt & 0x1) setvar_s(V[FS], opt_F); // -F
+	if (opt & 0x2) if (!is_assignment(opt_v)) bb_show_usage(); // -v
+	if (opt & 0x4) { // -f
+		from_file = TRUE;
+		F = afopen(programname, "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);
 	}
+	if (opt & 0x8) // -W
+		bb_error_msg("warning: unrecognized option '-W %s' ignored", opt_W);
 
 	if (!from_file) {
 		if (argc == optind)
-			show_usage();
-		programname="cmd. line";
+			bb_show_usage();
+		programname = "cmd. line";
 		parse_program(argv[optind++]);
 
 	}
@@ -2733,9 +2763,7 @@ extern int awk_main(int argc, char **argv) {
 
 	}
 
-	evaluate(endseq.first, &tv);
 	awk_exit(EXIT_SUCCESS);
 
 	return 0;
 }
-