Moving to 2.13.2.

1 files changed, 2802 insertions, 0 deletions

diff --git a/awk.tab.c b/awk.tab.c
new file mode 100644
index 00000000..c61d2553
--- /dev/null
+++ b/awk.tab.c
@@ -0,0 +1,2802 @@
+
+# line 27 "awk.y"
+#ifdef DEBUG
+#define YYDEBUG 12
+#endif
+
+#define	YYMAXDEPTH	300
+
+#include "awk.h"
+
+static void yyerror (); /* va_alist */
+static char *get_src_buf P((void));
+static int yylex P((void));
+static NODE *node_common P((NODETYPE op));
+static NODE *snode P((NODE *subn, NODETYPE op, int index));
+static NODE *mkrangenode P((NODE *cpair));
+static NODE *make_for_loop P((NODE *init, NODE *cond, NODE *incr));
+static NODE *append_right P((NODE *list, NODE *new));
+static void func_install P((NODE *params, NODE *def));
+static void pop_var P((NODE *np, int freeit));
+static void pop_params P((NODE *params));
+static NODE *make_param P((char *name));
+static NODE *mk_rexp P((NODE *exp));
+
+static int want_assign;		/* lexical scanning kludge */
+static int want_regexp;		/* lexical scanning kludge */
+static int can_return;		/* lexical scanning kludge */
+static int io_allowed = 1;	/* lexical scanning kludge */
+static char *lexptr;		/* pointer to next char during parsing */
+static char *lexend;
+static char *lexptr_begin;	/* keep track of where we were for error msgs */
+static char *lexeme;		/* beginning of lexeme for debugging */
+static char *thisline = NULL;
+#define YYDEBUG_LEXER_TEXT (lexeme)
+static int param_counter;
+static char *tokstart = NULL;
+static char *token = NULL;
+static char *tokend;
+
+NODE *variables[HASHSIZE];
+
+extern char *source;
+extern int sourceline;
+extern char *cmdline_src;
+extern char **srcfiles;
+extern int errcount;
+extern NODE *begin_block;
+extern NODE *end_block;
+
+# line 75 "awk.y"
+typedef union  {
+	long lval;
+	AWKNUM fval;
+	NODE *nodeval;
+	NODETYPE nodetypeval;
+	char *sval;
+	NODE *(*ptrval)();
+} YYSTYPE;
+# define FUNC_CALL 257
+# define NAME 258
+# define REGEXP 259
+# define ERROR 260
+# define YNUMBER 261
+# define YSTRING 262
+# define RELOP 263
+# define APPEND_OP 264
+# define ASSIGNOP 265
+# define MATCHOP 266
+# define NEWLINE 267
+# define CONCAT_OP 268
+# define LEX_BEGIN 269
+# define LEX_END 270
+# define LEX_IF 271
+# define LEX_ELSE 272
+# define LEX_RETURN 273
+# define LEX_DELETE 274
+# define LEX_WHILE 275
+# define LEX_DO 276
+# define LEX_FOR 277
+# define LEX_BREAK 278
+# define LEX_CONTINUE 279
+# define LEX_PRINT 280
+# define LEX_PRINTF 281
+# define LEX_NEXT 282
+# define LEX_EXIT 283
+# define LEX_FUNCTION 284
+# define LEX_GETLINE 285
+# define LEX_IN 286
+# define LEX_AND 287
+# define LEX_OR 288
+# define INCREMENT 289
+# define DECREMENT 290
+# define LEX_BUILTIN 291
+# define LEX_LENGTH 292
+# define UNARY 293
+#define yyclearin yychar = -1
+#define yyerrok yyerrflag = 0
+extern int yychar;
+extern int yyerrflag;
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 150
+#endif
+YYSTYPE yylval, yyval;
+# define YYERRCODE 256
+
+# line 709 "awk.y"
+
+
+struct token {
+	char *operator;		/* text to match */
+	NODETYPE value;		/* node type */
+	int class;		/* lexical class */
+	unsigned flags;		/* # of args. allowed and compatability */
+#	define	ARGS	0xFF	/* 0, 1, 2, 3 args allowed (any combination */
+#	define	A(n)	(1<<(n))
+#	define	VERSION	0xFF00	/* old awk is zero */
+#	define	NOT_OLD		0x0100	/* feature not in old awk */
+#	define	NOT_POSIX	0x0200	/* feature not in POSIX */
+#	define	GAWK		0x0400	/* gawk extension */
+	NODE *(*ptr) ();	/* function that implements this keyword */
+};
+
+extern NODE
+	*do_exp(),	*do_getline(),	*do_index(),	*do_length(),
+	*do_sqrt(),	*do_log(),	*do_sprintf(),	*do_substr(),
+	*do_split(),	*do_system(),	*do_int(),	*do_close(),
+	*do_atan2(),	*do_sin(),	*do_cos(),	*do_rand(),
+	*do_srand(),	*do_match(),	*do_tolower(),	*do_toupper(),
+	*do_sub(),	*do_gsub(),	*do_strftime(),	*do_systime();
+
+/* Tokentab is sorted ascii ascending order, so it can be binary searched. */
+
+static struct token tokentab[] = {
+{"BEGIN",	Node_illegal,	 LEX_BEGIN,	0,		0},
+{"END",		Node_illegal,	 LEX_END,	0,		0},
+{"atan2",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(2),	do_atan2},
+{"break",	Node_K_break,	 LEX_BREAK,	0,		0},
+{"close",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(1),	do_close},
+{"continue",	Node_K_continue, LEX_CONTINUE,	0,		0},
+{"cos",		Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(1),	do_cos},
+{"delete",	Node_K_delete,	 LEX_DELETE,	NOT_OLD,	0},
+{"do",		Node_K_do,	 LEX_DO,	NOT_OLD,	0},
+{"else",	Node_illegal,	 LEX_ELSE,	0,		0},
+{"exit",	Node_K_exit,	 LEX_EXIT,	0,		0},
+{"exp",		Node_builtin,	 LEX_BUILTIN,	A(1),		do_exp},
+{"for",		Node_K_for,	 LEX_FOR,	0,		0},
+{"func",	Node_K_function, LEX_FUNCTION,	NOT_POSIX|NOT_OLD,	0},
+{"function",	Node_K_function, LEX_FUNCTION,	NOT_OLD,	0},
+{"getline",	Node_K_getline,	 LEX_GETLINE,	NOT_OLD,	0},
+{"gsub",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(2)|A(3),	do_gsub},
+{"if",		Node_K_if,	 LEX_IF,	0,		0},
+{"in",		Node_illegal,	 LEX_IN,	0,		0},
+{"index",	Node_builtin,	 LEX_BUILTIN,	A(2),		do_index},
+{"int",		Node_builtin,	 LEX_BUILTIN,	A(1),		do_int},
+{"length",	Node_builtin,	 LEX_LENGTH,	A(0)|A(1),	do_length},
+{"log",		Node_builtin,	 LEX_BUILTIN,	A(1),		do_log},
+{"match",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(2),	do_match},
+{"next",	Node_K_next,	 LEX_NEXT,	0,		0},
+{"print",	Node_K_print,	 LEX_PRINT,	0,		0},
+{"printf",	Node_K_printf,	 LEX_PRINTF,	0,		0},
+{"rand",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(0),	do_rand},
+{"return",	Node_K_return,	 LEX_RETURN,	NOT_OLD,	0},
+{"sin",		Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(1),	do_sin},
+{"split",	Node_builtin,	 LEX_BUILTIN,	A(2)|A(3),	do_split},
+{"sprintf",	Node_builtin,	 LEX_BUILTIN,	0,		do_sprintf},
+{"sqrt",	Node_builtin,	 LEX_BUILTIN,	A(1),		do_sqrt},
+{"srand",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(0)|A(1),	do_srand},
+{"strftime",	Node_builtin,	 LEX_BUILTIN,	GAWK|A(1)|A(2),	do_strftime},
+{"sub",		Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(2)|A(3),	do_sub},
+{"substr",	Node_builtin,	 LEX_BUILTIN,	A(2)|A(3),	do_substr},
+{"system",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(1),	do_system},
+{"systime",	Node_builtin,	 LEX_BUILTIN,	GAWK|A(0),	do_systime},
+{"tolower",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(1),	do_tolower},
+{"toupper",	Node_builtin,	 LEX_BUILTIN,	NOT_OLD|A(1),	do_toupper},
+{"while",	Node_K_while,	 LEX_WHILE,	0,		0},
+};
+
+/* VARARGS0 */
+static void
+yyerror(va_alist)
+va_dcl
+{
+	va_list args;
+	char *mesg;
+	register char *ptr, *beg;
+	char *scan;
+
+	errcount++;
+	/* Find the current line in the input file */
+	if (lexptr) {
+		if (!thisline) {
+			for (beg = lexeme; beg != lexptr_begin && *beg != '\n'; --beg)
+				;
+			if (*beg == '\n')
+				beg++;
+			thisline = beg;
+		}
+		/* NL isn't guaranteed */
+		ptr = lexeme;
+		while (ptr < lexend && *ptr && *ptr != '\n')
+			ptr++;
+	} else {
+		thisline = "(END OF FILE)";
+		ptr = thisline + 13;
+	}
+	msg("syntax error");
+	fprintf(stderr, "%.*s\n", (int) (ptr - thisline), thisline);
+	if (lexptr) {
+		scan = thisline;
+		while (scan < lexeme)
+			if (*scan++ == '\t')
+				putc('\t', stderr);
+			else
+				putc(' ', stderr);
+		putc('^', stderr);
+		putc(' ', stderr);
+	}
+	va_start(args);
+	mesg = va_arg(args, char *);
+	vfprintf(stderr, mesg, args);
+	va_end(args);
+	putc('\n', stderr);
+	exit(2);
+}
+
+static char *
+get_src_buf()
+{
+	static int samefile = 0;
+	static int nextfile = 0;
+	static char *buf = NULL;
+	static int fd;
+	int n;
+	register char *scan;
+	static int len = 0;
+	static int did_newline = 0;
+#	define	SLOP	128	/* enough space to hold most source lines */
+
+	if (cmdline_src) {
+		if (len == 0) {
+			len = strlen(cmdline_src);
+			if (len == 0)
+				cmdline_src = NULL;
+			sourceline = 1;
+			lexptr = lexptr_begin = cmdline_src;
+			lexend = lexptr + len;
+		} else if (!did_newline && *(lexptr-1) != '\n') {
+			/*
+			 * The following goop is to ensure that the source
+			 * ends with a newline and that the entire current
+			 * line is available for error messages.
+			 */
+			int offset;
+
+			did_newline = 1;
+			offset = lexptr - lexeme;
+			for (scan = lexeme; scan > lexptr_begin; scan--)
+				if (*scan == '\n') {
+					scan++;
+					break;
+				}
+			len = lexptr - scan;
+			emalloc(buf, char *, len+1, "get_src_buf");
+			memcpy(buf, scan, len);
+			thisline = buf;
+			lexptr = buf + len;
+			*lexptr = '\n';
+			lexeme = lexptr - offset;
+			lexptr_begin = buf;
+			lexend = lexptr + 1;
+		} else
+			lexptr = lexptr_begin = NULL;
+		return lexptr;
+	}
+	if (!samefile) {
+		source = srcfiles[nextfile];
+		if (source == NULL) {
+			if (buf)
+				free(buf);
+			return lexptr = lexptr_begin = NULL;
+		}
+		fd = pathopen(source);
+		if (fd == -1)
+			fatal("can't open source file \"%s\" for reading (%s)",
+				source, strerror(errno));
+		len = optimal_bufsize(fd);
+		if (buf)
+			free(buf);
+		emalloc(buf, char *, len + SLOP, "get_src_buf");
+		lexptr_begin = buf + SLOP;
+		samefile = 1;
+		sourceline = 1;
+	} else {
+		/*
+		 * Here, we retain the current source line (up to length SLOP)
+		 * in the beginning of the buffer that was overallocated above
+		 */
+		int offset;
+		int linelen;
+
+		offset = lexptr - lexeme;
+		for (scan = lexeme; scan > lexptr_begin; scan--)
+			if (*scan == '\n') {
+				scan++;
+				break;
+			}
+		linelen = lexptr - scan;
+		if (linelen > SLOP)
+			len = SLOP;
+		thisline = buf + SLOP - linelen;
+		memcpy(thisline, scan, linelen);
+		lexeme = buf + SLOP - offset;
+		lexptr_begin = thisline;
+	}
+	n = read(fd, buf + SLOP, len);
+	if (n == -1)
+		fatal("can't read sourcefile \"%s\" (%s)",
+			source, strerror(errno));
+	if (n == 0) {
+		samefile = 0;
+		nextfile++;
+		return get_src_buf();
+	}
+	lexptr = buf + SLOP;
+	lexend = lexptr + n;
+	return buf;
+}
+
+#define	tokadd(x) (*token++ = (x), token == tokend ? tokexpand() : token)
+
+char *
+tokexpand()
+{
+	static int toksize = 60;
+	int tokoffset;
+
+	tokoffset = token - tokstart;
+	toksize *= 2;
+	if (tokstart)
+		erealloc(tokstart, char *, toksize, "tokexpand");
+	else
+		emalloc(tokstart, char *, toksize, "tokexpand");
+	tokend = tokstart + toksize;
+	token = tokstart + tokoffset;
+	return token;
+}
+
+#ifdef DEBUG
+char
+nextc() {
+	if (lexptr && lexptr < lexend)
+		return *lexptr++;
+	if (get_src_buf())
+		return *lexptr++;
+	return '\0';
+}
+#else
+#define	nextc()	((lexptr && lexptr < lexend) ? \
+			*lexptr++ : \
+			(get_src_buf() ? *lexptr++ : '\0') \
+		)
+#endif
+#define pushback() (lexptr && lexptr > lexptr_begin ? lexptr-- : lexptr)
+
+/*
+ * Read the input and turn it into tokens.
+ */
+
+static int
+yylex()
+{
+	register int c;
+	int seen_e = 0;		/* These are for numbers */
+	int seen_point = 0;
+	int esc_seen;		/* for literal strings */
+	int low, mid, high;
+	static int did_newline = 0;
+	char *tokkey;
+
+	if (!nextc())
+		return 0;
+	pushback();
+	lexeme = lexptr;
+	thisline = NULL;
+	if (want_regexp) {
+		int in_brack = 0;
+
+		want_regexp = 0;
+		token = tokstart;
+		while (c = nextc()) {
+			switch (c) {
+			case '[':
+				in_brack = 1;
+				break;
+			case ']':
+				in_brack = 0;
+				break;
+			case '\\':
+				if ((c = nextc()) == '\0') {
+					yyerror("unterminated regexp ends with \\ at end of file");
+				} else if (c == '\n') {
+					sourceline++;
+					continue;
+				} else
+					tokadd('\\');
+				break;
+			case '/':	/* end of the regexp */
+				if (in_brack)
+					break;
+
+				pushback();
+				tokadd('\0');
+				yylval.sval = tokstart;
+				return REGEXP;
+			case '\n':
+				pushback();
+				yyerror("unterminated regexp");
+			case '\0':
+				yyerror("unterminated regexp at end of file");
+			}
+			tokadd(c);
+		}
+	}
+retry:
+	while ((c = nextc()) == ' ' || c == '\t')
+		;
+
+	lexeme = lexptr-1;
+	thisline = NULL;
+	token = tokstart;
+	yylval.nodetypeval = Node_illegal;
+
+	switch (c) {
+	case 0:
+		return 0;
+
+	case '\n':
+		sourceline++;
+		return NEWLINE;
+
+	case '#':		/* it's a comment */
+		while ((c = nextc()) != '\n') {
+			if (c == '\0')
+				return 0;
+		}
+		sourceline++;
+		return NEWLINE;
+
+	case '\\':
+#ifdef RELAXED_CONTINUATION
+		if (!strict) {	/* strip trailing white-space and/or comment */
+			while ((c = nextc()) == ' ' || c == '\t') continue;
+			if (c == '#')
+				while ((c = nextc()) != '\n') if (!c) break;
+			pushback();
+		}
+#endif /*RELAXED_CONTINUATION*/
+		if (nextc() == '\n') {
+			sourceline++;
+			goto retry;
+		} else
+			yyerror("inappropriate use of backslash");
+		break;
+
+	case '$':
+		want_assign = 1;
+		return '$';
+
+	case ')':
+	case ']':
+	case '(':	
+	case '[':
+	case ';':
+	case ':':
+	case '?':
+	case '{':
+	case ',':
+		return c;
+
+	case '*':
+		if ((c = nextc()) == '=') {
+			yylval.nodetypeval = Node_assign_times;
+			return ASSIGNOP;
+		} else if (do_posix) {
+			pushback();
+			return '*';
+		} else if (c == '*') {
+			/* make ** and **= aliases for ^ and ^= */
+			static int did_warn_op = 0, did_warn_assgn = 0;
+
+			if (nextc() == '=') {
+				if (do_lint && ! did_warn_assgn) {
+					did_warn_assgn = 1;
+					warning("**= is not allowed by POSIX");
+				}
+				yylval.nodetypeval = Node_assign_exp;
+				return ASSIGNOP;
+			} else {
+				pushback();
+				if (do_lint && ! did_warn_op) {
+					did_warn_op = 1;
+					warning("** is not allowed by POSIX");
+				}
+				return '^';
+			}
+		}
+		pushback();
+		return '*';
+
+	case '/':
+		if (want_assign) {
+			if (nextc() == '=') {
+				yylval.nodetypeval = Node_assign_quotient;
+				return ASSIGNOP;
+			}
+			pushback();
+		}
+		return '/';
+
+	case '%':
+		if (nextc() == '=') {
+			yylval.nodetypeval = Node_assign_mod;
+			return ASSIGNOP;
+		}
+		pushback();
+		return '%';
+
+	case '^':
+	{
+		static int did_warn_op = 0, did_warn_assgn = 0;
+
+		if (nextc() == '=') {
+
+			if (do_lint && ! did_warn_assgn) {
+				did_warn_assgn = 1;
+				warning("operator `^=' is not supported in old awk");
+			}
+			yylval.nodetypeval = Node_assign_exp;
+			return ASSIGNOP;
+		}
+		pushback();
+		if (do_lint && ! did_warn_op) {
+			did_warn_op = 1;
+			warning("operator `^' is not supported in old awk");
+		}
+		return '^';
+	}
+
+	case '+':
+		if ((c = nextc()) == '=') {
+			yylval.nodetypeval = Node_assign_plus;
+			return ASSIGNOP;
+		}
+		if (c == '+')
+			return INCREMENT;
+		pushback();
+		return '+';
+
+	case '!':
+		if ((c = nextc()) == '=') {
+			yylval.nodetypeval = Node_notequal;
+			return RELOP;
+		}
+		if (c == '~') {
+			yylval.nodetypeval = Node_nomatch;
+			want_assign = 0;
+			return MATCHOP;
+		}
+		pushback();
+		return '!';
+
+	case '<':
+		if (nextc() == '=') {
+			yylval.nodetypeval = Node_leq;
+			return RELOP;
+		}
+		yylval.nodetypeval = Node_less;
+		pushback();
+		return '<';
+
+	case '=':
+		if (nextc() == '=') {
+			yylval.nodetypeval = Node_equal;
+			return RELOP;
+		}
+		yylval.nodetypeval = Node_assign;
+		pushback();
+		return ASSIGNOP;
+
+	case '>':
+		if ((c = nextc()) == '=') {
+			yylval.nodetypeval = Node_geq;
+			return RELOP;
+		} else if (c == '>') {
+			yylval.nodetypeval = Node_redirect_append;
+			return APPEND_OP;
+		}
+		yylval.nodetypeval = Node_greater;
+		pushback();
+		return '>';
+
+	case '~':
+		yylval.nodetypeval = Node_match;
+		want_assign = 0;
+		return MATCHOP;
+
+	case '}':
+		/*
+		 * Added did newline stuff.  Easier than
+		 * hacking the grammar
+		 */
+		if (did_newline) {
+			did_newline = 0;
+			return c;
+		}
+		did_newline++;
+		--lexptr;	/* pick up } next time */
+		return NEWLINE;
+
+	case '"':
+		esc_seen = 0;
+		while ((c = nextc()) != '"') {
+			if (c == '\n') {
+				pushback();
+				yyerror("unterminated string");
+			}
+			if (c == '\\') {
+				c = nextc();
+				if (c == '\n') {
+					sourceline++;
+					continue;
+				}
+				esc_seen = 1;
+				tokadd('\\');
+			}
+			if (c == '\0') {
+				pushback();
+				yyerror("unterminated string");
+			}
+			tokadd(c);
+		}
+		yylval.nodeval = make_str_node(tokstart,
+					token - tokstart, esc_seen ? SCAN : 0);
+		yylval.nodeval->flags |= PERM;
+		return YSTRING;
+
+	case '-':
+		if ((c = nextc()) == '=') {
+			yylval.nodetypeval = Node_assign_minus;
+			return ASSIGNOP;
+		}
+		if (c == '-')
+			return DECREMENT;
+		pushback();
+		return '-';
+
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	case '.':
+		/* It's a number */
+		for (;;) {
+			int gotnumber = 0;
+
+			tokadd(c);
+			switch (c) {
+			case '.':
+				if (seen_point) {
+					gotnumber++;
+					break;
+				}
+				++seen_point;
+				break;
+			case 'e':
+			case 'E':
+				if (seen_e) {
+					gotnumber++;
+					break;
+				}
+				++seen_e;
+				if ((c = nextc()) == '-' || c == '+')
+					tokadd(c);
+				else
+					pushback();
+				break;
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+			case '8':
+			case '9':
+				break;
+			default:
+				gotnumber++;
+			}
+			if (gotnumber)
+				break;
+			c = nextc();
+		}
+		pushback();
+		yylval.nodeval = make_number(atof(tokstart));
+		yylval.nodeval->flags |= PERM;
+		return YNUMBER;
+
+	case '&':
+		if ((c = nextc()) == '&') {
+			yylval.nodetypeval = Node_and;
+			for (;;) {
+				c = nextc();
+				if (c == '\0')
+					break;
+				if (c == '#') {
+					while ((c = nextc()) != '\n' && c != '\0')
+						;
+					if (c == '\0')
+						break;
+				}
+				if (c == '\n')
+					sourceline++;
+				if (! isspace(c)) {
+					pushback();
+					break;
+				}
+			}
+			want_assign = 0;
+			return LEX_AND;
+		}
+		pushback();
+		return '&';
+
+	case '|':
+		if ((c = nextc()) == '|') {
+			yylval.nodetypeval = Node_or;
+			for (;;) {
+				c = nextc();
+				if (c == '\0')
+					break;
+				if (c == '#') {
+					while ((c = nextc()) != '\n' && c != '\0')
+						;
+					if (c == '\0')
+						break;
+				}
+				if (c == '\n')
+					sourceline++;
+				if (! isspace(c)) {
+					pushback();
+					break;
+				}
+			}
+			want_assign = 0;
+			return LEX_OR;
+		}
+		pushback();
+		return '|';
+	}
+
+	if (c != '_' && ! isalpha(c))
+		yyerror("Invalid char '%c' in expression\n", c);
+
+	/* it's some type of name-type-thing.  Find its length */
+	token = tokstart;
+	while (is_identchar(c)) {
+		tokadd(c);
+		c = nextc();
+	}
+	tokadd('\0');
+	emalloc(tokkey, char *, token - tokstart, "yylex");
+	memcpy(tokkey, tokstart, token - tokstart);
+	pushback();
+
+	/* See if it is a special token.  */
+	low = 0;
+	high = (sizeof (tokentab) / sizeof (tokentab[0])) - 1;
+	while (low <= high) {
+		int i, c;
+
+		mid = (low + high) / 2;
+		c = *tokstart - tokentab[mid].operator[0];
+		i = c ? c : strcmp (tokstart, tokentab[mid].operator);
+
+		if (i < 0) {		/* token < mid */
+			high = mid - 1;
+		} else if (i > 0) {	/* token > mid */
+			low = mid + 1;
+		} else {
+			if (do_lint) {
+				if (tokentab[mid].flags & GAWK)
+					warning("%s() is a gawk extension",
+						tokentab[mid].operator);
+				if (tokentab[mid].flags & NOT_POSIX)
+					warning("POSIX does not allow %s",
+						tokentab[mid].operator);
+				if (tokentab[mid].flags & NOT_OLD)
+					warning("%s is not supported in old awk",
+						tokentab[mid].operator);
+			}
+			if ((strict && (tokentab[mid].flags & GAWK))
+			    || (do_posix && (tokentab[mid].flags & NOT_POSIX)))
+				break;
+			if (tokentab[mid].class == LEX_BUILTIN
+			    || tokentab[mid].class == LEX_LENGTH
+			   )
+				yylval.lval = mid;
+			else
+				yylval.nodetypeval = tokentab[mid].value;
+
+			return tokentab[mid].class;
+		}
+	}
+
+	yylval.sval = tokkey;
+	if (*lexptr == '(')
+		return FUNC_CALL;
+	else {
+		want_assign = 1;
+		return NAME;
+	}
+}
+
+static NODE *
+node_common(op)
+NODETYPE op;
+{
+	register NODE *r;
+
+	getnode(r);
+	r->type = op;
+	r->flags = MALLOC;
+	/* if lookahead is NL, lineno is 1 too high */
+	if (lexeme && *lexeme == '\n')
+		r->source_line = sourceline - 1;
+	else
+		r->source_line = sourceline;
+	r->source_file = source;
+	return r;
+}
+
+/*
+ * This allocates a node with defined lnode and rnode. 
+ */
+NODE *
+node(left, op, right)
+NODE *left, *right;
+NODETYPE op;
+{
+	register NODE *r;
+
+	r = node_common(op);
+	r->lnode = left;
+	r->rnode = right;
+	return r;
+}
+
+/*
+ * This allocates a node with defined subnode and proc for builtin functions
+ * Checks for arg. count and supplies defaults where possible.
+ */
+static NODE *
+snode(subn, op, index)
+NODETYPE op;
+int index;
+NODE *subn;
+{
+	register NODE *r;
+	register NODE *n;
+	int nexp = 0;
+	int args_allowed;
+
+	r = node_common(op);
+
+	/* traverse expression list to see how many args. given */
+	for (n= subn; n; n= n->rnode) {
+		nexp++;
+		if (nexp > 3)
+			break;
+	}
+
+	/* check against how many args. are allowed for this builtin */
+	args_allowed = tokentab[index].flags & ARGS;
+	if (args_allowed && !(args_allowed & A(nexp)))
+		fatal("%s() cannot have %d argument%c",
+			tokentab[index].operator, nexp, nexp == 1 ? ' ' : 's');
+
+	r->proc = tokentab[index].ptr;
+
+	/* special case processing for a few builtins */
+	if (nexp == 0 && r->proc == do_length) {
+		subn = node(node(make_number(0.0),Node_field_spec,(NODE *)NULL),
+		            Node_expression_list,
+			    (NODE *) NULL);
+	} else if (r->proc == do_match) {
+		if (subn->rnode->lnode->type != Node_regex)
+			subn->rnode->lnode = mk_rexp(subn->rnode->lnode);
+	} else if (r->proc == do_sub || r->proc == do_gsub) {
+		if (subn->lnode->type != Node_regex)
+			subn->lnode = mk_rexp(subn->lnode);
+		if (nexp == 2)
+			append_right(subn, node(node(make_number(0.0),
+						     Node_field_spec,
+						     (NODE *) NULL),
+					        Node_expression_list,
+						(NODE *) NULL));
+		else if (do_lint && subn->rnode->rnode->lnode->type == Node_val)
+			warning("string literal as last arg of substitute");
+	} else if (r->proc == do_split) {
+		if (nexp == 2)
+			append_right(subn,
+			    node(FS_node, Node_expression_list, (NODE *) NULL));
+		n = subn->rnode->rnode->lnode;
+		if (n->type != Node_regex)
+			subn->rnode->rnode->lnode = mk_rexp(n);
+		if (nexp == 2)
+			subn->rnode->rnode->lnode->re_flags |= FS_DFLT;
+	}
+
+	r->subnode = subn;
+	return r;
+}
+
+/*
+ * This allocates a Node_line_range node with defined condpair and
+ * zeroes the trigger word to avoid the temptation of assuming that calling
+ * 'node( foo, Node_line_range, 0)' will properly initialize 'triggered'. 
+ */
+/* Otherwise like node() */
+static NODE *
+mkrangenode(cpair)
+NODE *cpair;
+{
+	register NODE *r;
+
+	getnode(r);
+	r->type = Node_line_range;
+	r->condpair = cpair;
+	r->triggered = 0;
+	return r;
+}
+
+/* Build a for loop */
+static NODE *
+make_for_loop(init, cond, incr)
+NODE *init, *cond, *incr;
+{
+	register FOR_LOOP_HEADER *r;
+	NODE *n;
+
+	emalloc(r, FOR_LOOP_HEADER *, sizeof(FOR_LOOP_HEADER), "make_for_loop");
+	getnode(n);
+	n->type = Node_illegal;
+	r->init = init;
+	r->cond = cond;
+	r->incr = incr;
+	n->sub.nodep.r.hd = r;
+	return n;
+}
+
+/*
+ * Install a name in the symbol table, even if it is already there.
+ * Caller must check against redefinition if that is desired. 
+ */
+NODE *
+install(name, value)
+char *name;
+NODE *value;
+{
+	register NODE *hp;
+	register int len, bucket;
+
+	len = strlen(name);
+	bucket = hash(name, len);
+	getnode(hp);
+	hp->type = Node_hashnode;
+	hp->hnext = variables[bucket];
+	variables[bucket] = hp;
+	hp->hlength = len;
+	hp->hvalue = value;
+	hp->hname = name;
+	return hp->hvalue;
+}
+
+/* find the most recent hash node for name installed by install */
+NODE *
+lookup(name)
+char *name;
+{
+	register NODE *bucket;
+	register int len;
+
+	len = strlen(name);
+	bucket = variables[hash(name, len)];
+	while (bucket) {
+		if (bucket->hlength == len && STREQN(bucket->hname, name, len))
+			return bucket->hvalue;
+		bucket = bucket->hnext;
+	}
+	return NULL;
+}
+
+/*
+ * Add new to the rightmost branch of LIST.  This uses n^2 time, so we make
+ * a simple attempt at optimizing it.
+ */
+static NODE *
+append_right(list, new)
+NODE *list, *new;
+{
+	register NODE *oldlist;
+	static NODE *savefront = NULL, *savetail = NULL;
+
+	oldlist = list;
+	if (savefront == oldlist) {
+		savetail = savetail->rnode = new;
+		return oldlist;
+	} else
+		savefront = oldlist;
+	while (list->rnode != NULL)
+		list = list->rnode;
+	savetail = list->rnode = new;
+	return oldlist;
+}
+
+/*
+ * check if name is already installed;  if so, it had better have Null value,
+ * in which case def is added as the value. Otherwise, install name with def
+ * as value. 
+ */
+static void
+func_install(params, def)
+NODE *params;
+NODE *def;
+{
+	NODE *r;
+
+	pop_params(params->rnode);
+	pop_var(params, 0);
+	r = lookup(params->param);
+	if (r != NULL) {
+		fatal("function name `%s' previously defined", params->param);
+	} else
+		(void) install(params->param, node(params, Node_func, def));
+}
+
+static void
+pop_var(np, freeit)
+NODE *np;
+int freeit;
+{
+	register NODE *bucket, **save;
+	register int len;
+	char *name;
+
+	name = np->param;
+	len = strlen(name);
+	save = &(variables[hash(name, len)]);
+	for (bucket = *save; bucket; bucket = bucket->hnext) {
+		if (len == bucket->hlength && STREQN(bucket->hname, name, len)) {
+			*save = bucket->hnext;
+			freenode(bucket);
+			if (freeit)
+				free(np->param);
+			return;
+		}
+		save = &(bucket->hnext);
+	}
+}
+
+static void
+pop_params(params)
+NODE *params;
+{
+	register NODE *np;
+
+	for (np = params; np != NULL; np = np->rnode)
+		pop_var(np, 1);
+}
+
+static NODE *
+make_param(name)
+char *name;
+{
+	NODE *r;
+
+	getnode(r);
+	r->type = Node_param_list;
+	r->rnode = NULL;
+	r->param = name;
+	r->param_cnt = param_counter++;
+	return (install(name, r));
+}
+
+/* Name points to a variable name.  Make sure its in the symbol table */
+NODE *
+variable(name, can_free)
+char *name;
+int can_free;
+{
+	register NODE *r;
+	static int env_loaded = 0;
+
+	if (!env_loaded && STREQ(name, "ENVIRON")) {
+		load_environ();
+		env_loaded = 1;
+	}
+	if ((r = lookup(name)) == NULL)
+		r = install(name, node(Nnull_string, Node_var, (NODE *) NULL));
+	else if (can_free)
+		free(name);
+	return r;
+}
+
+static NODE *
+mk_rexp(exp)
+NODE *exp;
+{
+	if (exp->type == Node_regex)
+		return exp;
+	else {
+		NODE *n;
+
+		getnode(n);
+		n->type = Node_regex;
+		n->re_exp = exp;
+		n->re_text = NULL;
+		n->re_reg = NULL;
+		n->re_flags = 0;
+		n->re_cnt = 1;
+		return n;
+	}
+}
+int yyexca[] ={
+-1, 1,
+	0, -1,
+	-2, 0,
+-1, 5,
+	0, 59,
+	-2, 0,
+-1, 77,
+	264, 76,
+	267, 76,
+	62, 76,
+	124, 76,
+	59, 76,
+	-2, 0,
+-1, 111,
+	41, 84,
+	-2, 0,
+-1, 112,
+	41, 84,
+	-2, 0,
+-1, 113,
+	41, 84,
+	-2, 0,
+-1, 126,
+	266, 0,
+	-2, 99,
+-1, 128,
+	263, 0,
+	60, 0,
+	62, 0,
+	124, 0,
+	-2, 103,
+-1, 129,
+	263, 0,
+	60, 0,
+	62, 0,
+	124, 0,
+	-2, 104,
+-1, 130,
+	263, 0,
+	60, 0,
+	62, 0,
+	124, 0,
+	-2, 105,
+-1, 149,
+	264, 77,
+	267, 77,
+	62, 77,
+	124, 77,
+	59, 77,
+	-2, 0,
+-1, 186,
+	41, 85,
+	-2, 0,
+-1, 220,
+	41, 67,
+	-2, 0,
+-1, 248,
+	266, 0,
+	-2, 116,
+-1, 250,
+	263, 0,
+	-2, 118,
+-1, 258,
+	41, 68,
+	-2, 0,
+	};
+# define YYNPROD 158
+# define YYLAST 1843
+int yyact[]={
+
+    62,   212,    20,    13,   107,    24,    13,    87,   225,    17,
+    88,    89,    36,   123,    35,    82,    25,   291,    91,   235,
+    45,    45,     4,    37,   168,    88,    89,   286,    45,   285,
+   264,    88,    89,   200,   260,    24,   259,   261,    52,   184,
+   166,   165,   249,   161,    63,   127,   199,    22,   100,   186,
+   158,   173,    82,   122,    65,   124,   125,   126,    63,   128,
+   129,   130,   131,    20,   218,    82,    24,    90,   107,   171,
+    17,    82,    63,    36,    45,    35,    64,    25,    63,   174,
+   159,   136,    63,    93,    22,   171,   228,    63,   263,    45,
+   220,   185,    22,   270,    68,   202,   163,   144,   142,   175,
+   113,   103,   112,   111,     6,   252,   101,   227,   183,   167,
+    39,   102,   183,   183,   183,   160,    26,   157,   110,   133,
+    20,    86,    82,    24,    11,   140,    97,    17,   121,    24,
+    36,    46,    35,    98,    25,    48,    36,    41,    35,   164,
+    25,   108,    82,   194,    82,   159,    45,   141,    91,    77,
+   257,    71,   148,    22,   149,    68,   258,   182,   100,    10,
+    27,   159,     5,     1,   219,    50,   118,    12,   221,   222,
+   224,   120,    20,     0,   203,    24,   189,     0,    97,    17,
+     0,    24,    36,     0,    35,    98,    25,     0,    36,     0,
+    35,     0,   233,     0,     0,   197,   193,   198,    45,   236,
+     0,   240,   241,   242,   187,   188,     0,   190,     0,     0,
+    22,   217,     0,     0,     0,   192,     0,     0,     0,   183,
+     0,     0,     0,     0,     0,   135,    30,    23,     4,     4,
+    33,    34,     0,     0,     0,   201,     0,   213,   265,     0,
+    83,     0,    80,    81,    72,    73,    74,    75,    76,    84,
+    85,    78,    79,     0,    18,     0,   169,    23,    31,    32,
+    28,    29,    22,    82,   276,   253,    20,   159,   255,    24,
+   169,   232,    82,    17,     0,     0,    36,     0,    35,   159,
+    25,     0,     0,   273,   169,   267,    67,    30,    23,    82,
+   274,    33,    34,    59,   169,    60,    82,    82,    82,   204,
+     0,    83,    19,    80,    81,    72,    73,    74,    75,    76,
+    84,    85,    78,    79,     0,    18,     0,   279,     0,    31,
+    32,    28,    29,    95,     0,     0,     0,     0,     0,   289,
+   103,     0,     0,     0,     0,   101,   104,     0,   105,     0,
+   102,     0,     0,    67,    30,    23,     0,     0,    33,    34,
+    30,    23,     0,     0,    33,    34,     0,    53,    83,     0,
+    80,    81,    72,    73,    74,    75,    76,    84,    85,    78,
+    79,     0,    18,     0,     0,     0,    31,    32,    28,    29,
+   154,     0,    31,    32,    28,    29,     0,   100,     0,     0,
+     0,     0,     0,     0,     0,   211,    30,    23,     0,     0,
+    33,    34,    30,    23,     0,     0,    33,    34,     0,     0,
+    83,     0,    80,    81,    72,    73,    74,    75,    76,    84,
+    85,    78,    79,    16,    18,     0,     0,     0,    31,    32,
+    28,    29,     0,     0,    31,    32,    28,    29,     0,     0,
+     0,     0,    94,     0,    99,     0,     0,     0,   109,     0,
+     0,     0,     0,   154,    20,   114,   115,    24,   214,    99,
+    99,    17,     0,     0,    36,     0,    35,     0,    25,     0,
+     0,     0,     0,   150,     0,     0,     0,     0,     0,     0,
+    45,    59,     0,    60,    61,     0,     0,     0,     0,     0,
+    20,    23,     0,    24,    33,    34,    58,    17,   171,     0,
+    36,   152,    35,     0,    25,     0,   154,   154,   154,   154,
+   154,     0,   154,   154,   154,     0,     0,    59,     0,    60,
+    61,    99,    31,    32,    99,    99,    99,    99,    99,    99,
+    20,     0,     0,    24,     0,     0,     0,    17,     0,     0,
+    36,     0,    35,     0,    25,    53,   154,    94,   154,   154,
+   154,   154,     0,   154,   154,   154,    45,    59,     0,    60,
+    61,     0,     0,     0,     0,     0,    20,     0,     0,    24,
+     0,   154,   154,    17,   152,     0,    36,    94,    35,    99,
+    25,    53,     0,     0,   154,     0,     0,     0,     0,     0,
+     0,   191,     0,    59,     0,    60,    61,     0,    99,   243,
+   245,   246,   247,   248,     0,   250,   251,    70,     0,     0,
+    14,     0,    20,    14,     0,    24,     0,     0,    14,    17,
+    51,    53,    36,    63,    35,     0,    25,   152,   152,   152,
+   152,   152,     0,   152,   152,   152,     0,     0,     0,    59,
+     0,    60,    61,     0,     0,     0,     0,     0,   269,    14,
+     0,     0,     0,     0,    14,     0,     0,    53,     0,     0,
+     0,     0,     0,     0,   281,     0,     0,   152,     0,   152,
+   152,   152,   152,     0,   152,   152,   152,     0,    30,    23,
+     0,     0,    33,    34,    58,     0,     0,    56,     4,     0,
+     0,     0,   152,   152,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,    53,     0,   152,    18,    57,    54,    55,
+    31,    32,    28,    29,    30,    23,     0,     0,    33,    34,
+    58,     0,     0,    56,     0,     0,   155,     0,     0,    24,
+     0,     0,     0,    98,     0,     0,    36,     0,    35,     0,
+    25,     0,    18,    57,    54,    55,    31,    32,    28,    29,
+     0,   268,     0,     0,    30,    23,   210,     0,    33,    34,
+    58,     0,   155,    56,     0,    24,     0,     0,     0,    98,
+     0,     0,    36,     0,    35,     0,    25,     0,     0,     0,
+     0,     0,    18,    57,    54,    55,    31,    32,    28,    29,
+    30,    23,   210,     0,    33,    34,    58,     0,     0,    56,
+    20,     0,     0,    24,     0,     0,     0,    17,     0,     0,
+    36,     0,    35,     0,    25,     0,     0,     0,    18,    57,
+    54,    55,    31,    32,    28,    29,     0,    59,     0,    60,
+    61,     0,     0,     0,     0,     0,    30,    23,    21,     0,
+    33,    34,    58,     0,     0,    56,     0,     0,   155,     0,
+     0,    24,     0,     0,     0,    98,     0,     0,    36,    96,
+    35,     0,    25,     0,    18,    57,    54,    55,    31,    32,
+    28,    29,     0,    20,   116,   117,    24,     0,     0,     0,
+    17,     0,     0,    36,     0,    35,     0,    25,     0,     0,
+     0,    53,     0,     0,     0,     0,     0,     0,     0,     0,
+    59,     0,    60,     0,     0,     0,     0,     0,     0,     0,
+   155,     0,     0,    24,     0,     0,   156,    98,    20,     0,
+    36,    24,    35,     0,    25,    17,     0,     0,    36,     0,
+    35,     0,    25,     0,     0,     0,    96,     0,     0,   176,
+   177,   178,   179,   180,   181,    59,     0,    60,     0,     0,
+    30,    23,     0,     0,    33,    34,   209,     0,     0,   207,
+     0,     0,     0,    20,    53,     0,    24,     0,     0,     0,
+    17,     0,     0,    36,     0,    35,     0,    25,   153,   208,
+   205,   206,    31,    32,    28,    29,    30,    23,     0,   156,
+    33,    34,   209,    20,    96,   207,    24,     0,     0,     0,
+    17,     0,     0,    36,     0,    35,     0,    25,     0,    53,
+     0,     0,     0,   226,   153,   208,   205,   206,    31,    32,
+    28,    29,     0,     0,    30,    23,     0,     0,    33,    34,
+    58,     0,     0,    56,     0,     0,     0,     0,     0,     0,
+     0,     0,   156,   156,   156,   156,   156,     0,   156,   156,
+   156,     0,    18,    57,    54,    55,    31,    32,    28,    29,
+    20,     0,     0,    24,     0,     0,     0,    17,     0,     0,
+    36,     0,    35,    23,    25,     0,    33,    34,   209,     0,
+     0,     0,   156,    22,   156,   156,   156,   156,     0,   156,
+   156,   156,     0,     0,     0,     0,     0,    30,    23,     0,
+     0,    33,    34,    58,    31,    32,    56,   156,   156,   155,
+     0,     0,    24,     0,     0,     0,    98,     0,     0,    36,
+   156,    35,     0,    25,     0,    18,    57,    54,     0,    31,
+    32,    28,    29,     0,     0,    23,     0,     0,    33,    34,
+     0,     0,    30,    23,     0,     0,    33,    34,    58,   155,
+    22,    56,    24,     0,     0,     0,    98,     0,     0,    36,
+     0,    35,     2,    25,     0,     0,    31,    32,    38,     0,
+    18,    57,     0,     0,    31,    32,    28,    29,     0,     0,
+     0,     0,     0,     0,     0,   106,    20,     0,    23,    24,
+     0,    33,    34,    17,     0,     0,    36,     0,    35,     0,
+    25,     0,     0,     0,     0,     0,     0,   119,     0,     0,
+     0,     0,    45,     0,     0,     0,    40,    30,    23,    31,
+    32,    33,    34,     0,     0,     0,   132,     4,     0,     8,
+     9,   138,   139,     0,     0,     0,   143,     0,     0,     0,
+     0,     0,     0,     0,    15,    18,     0,     0,     0,    31,
+    32,    28,    29,    20,     0,     0,    24,     0,     0,     0,
+    17,   155,     0,    36,    24,    35,     0,    25,    98,     0,
+     0,    36,     0,    35,     0,    25,     0,     0,     0,     0,
+     0,    66,     0,     7,    30,    23,     0,     0,    33,    34,
+     0,     0,     0,     0,     0,     0,     8,     9,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,    15,    18,     0,     0,     0,    31,    32,    28,    29,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,    30,    23,   172,     0,    33,    34,   209,
+    20,     0,   207,    24,     0,     0,   134,    17,     0,     0,
+    36,     0,    35,     0,    25,     0,     0,     0,     0,     0,
+     0,   153,   208,   205,     0,    31,    32,    28,    29,     0,
+     0,     0,     0,    30,    23,     0,     0,    33,    34,   209,
+   155,     0,   207,    24,     0,     0,     0,   147,     0,     0,
+    36,     0,    35,     0,    25,     0,     0,   262,     0,     0,
+     0,   153,   208,   134,     0,    31,    32,    28,    29,     0,
+    30,    23,     0,     0,    33,    34,     0,    20,     0,   271,
+    24,     0,     0,   134,    17,   195,   170,    36,     0,    35,
+     0,    25,     0,     0,     0,   284,     0,     0,    18,     0,
+   288,     0,    31,    32,    28,    29,     0,     0,     0,     0,
+   292,     0,     0,   295,   296,   155,     0,   297,    24,     0,
+    42,     0,    98,     0,     0,    36,     0,    35,     0,    25,
+    47,    49,     0,     0,     0,     0,    92,    30,    23,     0,
+     0,    33,    34,     0,   244,    30,    23,     0,     0,    33,
+    34,     0,    20,     0,     0,    24,     0,     0,     0,    17,
+     0,     0,    36,     0,    35,    18,    25,     0,     0,    31,
+    32,    28,    29,   153,     0,     0,     0,    31,    32,    28,
+    29,   229,     0,   230,   231,     0,     0,     0,     0,     0,
+   234,     0,     0,     0,   238,     0,   145,   146,     0,     0,
+     0,     0,     0,   162,   275,     0,     0,    69,     0,     0,
+     0,     0,     0,   283,     0,   256,    44,    44,    44,     0,
+     0,     0,     0,   223,    30,    23,     0,     0,    33,    34,
+   293,     3,     0,     0,     0,     0,     0,   298,   299,   300,
+    43,    43,    43,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,    18,   272,     0,     0,    31,    32,    28,    29,
+   277,     0,     0,   151,    30,    23,     0,     0,    33,    34,
+     0,     0,   287,   137,     0,   290,     0,     0,   215,   216,
+     0,     0,     0,    44,    44,   294,     0,     0,     0,     0,
+    44,     0,   153,     0,     0,     0,    31,    32,    28,    29,
+     0,    30,    23,     0,     0,    33,    34,    43,    43,     0,
+     0,     0,     0,     0,    43,     0,     0,     0,     0,     0,
+   239,     0,     0,     0,     0,     0,     0,     0,     0,    18,
+     0,     0,     0,    31,    32,    28,    29,     0,   254,    30,
+    23,   137,     0,    33,    34,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,    44,    44,   153,     0,     0,
+     0,    31,    32,    28,    29,     0,    30,   196,     0,     0,
+    33,    34,     0,     0,     0,     0,     0,     0,   280,    43,
+    43,   282,     0,     0,     0,     0,     0,   137,     0,     0,
+     0,     0,     0,     0,    18,   237,     0,    44,    31,    32,
+    28,    29,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,    44,     0,     0,     0,     0,
+     0,    43,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   266,     0,     0,     0,    43,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   278,     0,    44,     0,     0,    44,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,    43,
+     0,     0,    43 };
+int yypact[]={
+
+  -245, -1000,  1027,  -244, -1000,   960, -1000, -1000,   -38,   -38,
+   -39, -1000,   -76,   579,    30, -1000,  -258,  1220,    -1, -1000,
+    93,   293,  -245,   -23,   145, -1000, -1000, -1000,    63,    62,
+    60,    -1,    -1, -1000, -1000,   145,   145, -1000, -1000, -1000,
+ -1000,   -76, -1000,  -244,  -245, -1000,   -76, -1000, -1000, -1000,
+ -1000,    87,  1384,  -272,  1384,  1384,  1384,  -213,  1384,  1384,
+  1384,  1384,   930,  -245,   -31,    15, -1000, -1000,  -245,  -245,
+    30, -1000,    58,  -245,    57,   -38,   -38,  1347, -1000,  1384,
+ -1000,  -215,   421,    56, -1000, -1000,  -217, -1000, -1000, -1000,
+    28,   457, -1000,    19, -1000, -1000,   -46,   145,  1384,  -279,
+   145,   145,   145,   145,   145,   145, -1000,  1220, -1000, -1000,
+  -220,  1220,  1220,  1220, -1000, -1000,   -46,   -46, -1000, -1000,
+ -1000,   -31,   767,    -1,   885,   840,   233, -1000,   930,   930,
+   930,   533, -1000,    15, -1000, -1000, -1000, -1000, -1000, -1000,
+ -1000,   -31,  1384,   139,  1459, -1000, -1000,  1220,   -29,    43,
+   729, -1000,  -264,    -1, -1000,    93,   293,   -38,   -38,   767,
+  1384,   -27, -1000,  1384,    50, -1000, -1000,  1384,  1307,  1384,
+  -278, -1000, -1000, -1000,   145,   457,   -46,   -46,   -46,   -46,
+    64,    64,    14,   767,    39,    44,    38,    44,    44,    15,
+ -1000,  1384, -1000, -1000,   457,  -256,   -87,    15,    28,   -38,
+  1384,  1384,  1384,  1228,  1422,  1422,  1422,  1422,  -216,  1422,
+  1422,   877, -1000,    19, -1000, -1000, -1000,   -38,  1220,   457,
+  -222,   767,   767, -1000,   767,  -221,   293, -1000, -1000, -1000,
+ -1000, -1000, -1000,   767,  -245,    48,  -228,  1153,   -29, -1000,
+   767,   767,   767,   729, -1000,   729,  1116,  1076,   815, -1000,
+   877,   693,  1422, -1000, -1000,     0,  -245,    44,    34, -1000,
+ -1000, -1000,   139,  1384,    44,   497,  1384,   -38,  1422,   729,
+   -38,   139,  -245,  -229, -1000, -1000,   457,  -245,  1384,    44,
+ -1000,   729, -1000,  -255, -1000, -1000, -1000,  -245,   139,    44,
+  -245,  -245, -1000, -1000,  -245,   139,   139,   139, -1000, -1000,
+ -1000 };
+int yypgo[]={
+
+     0,   167,   165,   395,     0,   163,   162,   104,   838,   116,
+   160,   159,   124,   423,   156,   154,   152,    49,    91,    76,
+  1281,   151,   150,    50,    83,   302,    51,    46,   149,   139,
+  1162,   137,   131,  1460,   121,  1335,   607,    54,    81,    24,
+   118,  1571,  1547,   117,   115,   109,   105 };
+int yyr1[]={
+
+     0,     5,     6,     6,     6,     6,    31,     7,    32,     7,
+     7,     7,     7,     7,     7,     7,    29,    29,    34,     1,
+     2,    11,    11,    40,    25,    12,    12,    19,    19,    19,
+    19,    33,    33,    20,    20,    20,    20,    20,    20,    20,
+    20,    20,    20,    20,    20,    20,    43,    20,    20,    44,
+    20,    20,    20,    28,    28,    21,    21,    41,    41,    30,
+    30,    26,    26,    27,    27,    27,    27,    22,    22,    14,
+    14,    14,    14,    14,    23,    23,    16,    16,    15,    15,
+    15,    15,    15,    15,    18,    18,    17,    17,    17,    17,
+    17,    17,    45,     4,     4,     4,     4,     4,     4,     4,
+     4,     4,     4,     4,     4,     4,     4,     4,     4,    46,
+     3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+     3,     3,     8,     8,     8,     8,     8,     8,     8,     8,
+     9,     9,     9,     9,     9,     9,     9,     9,     9,     9,
+     9,     9,    10,    10,    10,    24,    24,    13,    13,    13,
+    13,    36,    37,    35,    38,    38,    42,    39 };
+int yyr2[]={
+
+     0,     7,     3,     5,     3,     5,     1,     7,     1,     7,
+     5,     5,     5,     3,     5,     5,     3,     3,     1,    15,
+     9,     3,     7,     1,     9,     9,     7,     3,     5,     3,
+     5,     2,     4,     5,     5,     7,     3,    13,    17,    17,
+    21,    19,     5,     5,    13,     9,     1,     7,     7,     1,
+     9,    13,     5,     3,     3,    13,    19,     3,     4,     0,
+     2,     1,     5,     1,     5,     5,     5,     1,     3,     3,
+     7,     3,     5,     7,     1,     3,     1,     3,     3,     7,
+     3,     5,     7,     7,     1,     3,     3,     7,     3,     5,
+     7,     7,     1,     9,    11,     9,     7,     7,     7,     7,
+     3,     5,     7,     7,     7,     7,    11,     3,     5,     1,
+     9,     7,     7,     7,     3,     5,     7,     7,     7,    11,
+     3,     5,     2,     2,     7,     7,     7,     7,     7,     7,
+     5,     7,     9,     9,     3,     9,     5,     5,     3,     3,
+     5,     5,     5,     5,     2,     1,     3,     3,     9,     5,
+     5,     4,     5,     3,     0,     2,     3,     5 };
+int yychk[]={
+
+ -1000,    -5,   -30,   -41,   267,    -6,    -7,   256,   269,   270,
+   -11,   -12,    -1,    -4,   -36,   284,   -13,    40,   285,   -25,
+    33,    -8,   123,   258,    36,    47,    -9,   -10,   291,   292,
+   257,   289,   290,   261,   262,    45,    43,   267,   -30,    -7,
+   256,   -31,   -33,   -41,   -42,    59,   -32,   -33,   -12,   -33,
+    -2,   -36,   -39,   124,   287,   288,   266,   286,   263,    60,
+    62,    63,    -4,    44,   -19,   -37,   -20,   256,   125,   -42,
+   -36,   -21,   275,   276,   277,   278,   279,   -28,   282,   283,
+   273,   274,    -4,   271,   280,   281,   -34,   265,   289,   290,
+   -17,    -4,   256,   -24,   -13,   -25,    -8,    33,    40,   -13,
+    94,    42,    47,    37,    43,    45,   -30,    91,    -9,   -13,
+   -40,    40,    40,    40,   -13,   -13,    -8,    -8,   -12,   -30,
+   -12,   -19,    -4,   285,    -4,    -4,    -4,   258,    -4,    -4,
+    -4,    -4,   -30,   -37,   -20,   256,   -38,   -42,   -30,   -30,
+   -37,   -19,    40,   -30,    40,   -33,   -33,    40,   -16,   -15,
+    -3,   256,   -13,   285,   -25,    33,    -8,   -43,   -23,    -4,
+   -44,   258,   -33,    40,   -29,   258,   257,   -45,   -39,   256,
+   -35,    41,   -35,   -26,    60,    -4,    -8,    -8,    -8,    -8,
+    -8,    -8,   -17,    -4,   259,   -18,   -17,   -18,   -18,   -37,
+   -24,    58,   -38,   -37,    -4,   -20,   258,   -23,   -17,   -27,
+    62,   264,   124,   -39,   256,   287,   288,   266,   286,   263,
+    63,    -3,   265,   -24,   -25,   -33,   -33,   -23,    91,    -4,
+    40,    -4,    -4,   256,    -4,   286,    -8,    93,    47,   -35,
+   -35,   -35,   -38,    -4,   -35,   275,   286,   -42,   -35,   -33,
+    -4,    -4,    -4,    -3,   256,    -3,    -3,    -3,    -3,   258,
+    -3,    -3,   -46,   -26,   -33,   -17,   -35,   -22,   -14,   258,
+   256,   258,   -30,    40,   258,    -4,   -42,   -27,    58,    -3,
+    93,   -30,   -35,   -39,   256,   -20,    -4,   -35,   -42,   -23,
+   -33,    -3,   -33,   -20,   -30,   258,   256,   -35,   -30,   -23,
+   -35,   272,   -30,   -20,   -35,   -30,   -30,   -30,   -20,   -20,
+   -20 };
+int yydef[]={
+
+    59,    -2,     0,    60,    57,    -2,     2,     4,     6,     8,
+     0,    13,     0,    21,     0,    18,   144,     0,   145,   100,
+     0,   107,    59,   147,     0,    23,   122,   123,     0,   134,
+     0,     0,     0,   138,   139,     0,     0,    58,     1,     3,
+     5,     0,    10,    31,    59,   156,     0,    11,    12,    14,
+    15,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,   108,    59,     0,   154,    27,    29,    59,    59,
+     0,    36,     0,    59,     0,     0,     0,    -2,    46,    74,
+    49,     0,     0,     0,    53,    54,     0,    92,   142,   143,
+     0,    86,    88,    61,   146,   101,   130,     0,     0,   144,
+     0,     0,     0,     0,     0,     0,   151,     0,   149,   150,
+     0,    -2,    -2,    -2,   136,   137,   140,   141,     7,    32,
+     9,     0,    22,   145,    97,    98,    -2,   102,    -2,    -2,
+    -2,     0,   157,   154,    28,    30,    26,   155,   152,    33,
+    34,     0,     0,     0,    74,    42,    43,     0,    63,    -2,
+    78,    80,   144,   145,   114,     0,   120,     0,     0,    75,
+    74,     0,    52,     0,     0,    16,    17,     0,     0,    89,
+     0,   153,   131,    96,     0,     0,   124,   125,   126,   127,
+   128,   129,     0,    86,     0,     0,    -2,     0,     0,   154,
+    95,     0,    25,    35,     0,     0,   147,     0,     0,     0,
+     0,     0,     0,     0,    81,     0,     0,     0,     0,     0,
+     0,   121,   109,    61,   115,    47,    48,     0,     0,     0,
+    -2,    93,    87,    91,    90,     0,    62,   148,    24,   132,
+   133,   135,    20,   106,    59,     0,     0,     0,    63,    45,
+    64,    65,    66,    79,    83,    82,   111,   112,    -2,   117,
+    -2,     0,     0,   113,    50,     0,    59,     0,    -2,    69,
+    71,    94,     0,     0,     0,     0,    74,     0,     0,   110,
+     0,     0,    59,     0,    72,    37,     0,    59,    74,     0,
+    44,   119,    51,    55,    19,    70,    73,    59,     0,     0,
+    59,    59,    38,    39,    59,     0,     0,     0,    41,    56,
+    40 };
+typedef struct { char *t_name; int t_val; } yytoktype;
+#ifndef YYDEBUG
+#	define YYDEBUG	0	/* don't allow debugging */
+#endif
+
+#if YYDEBUG
+
+yytoktype yytoks[] =
+{
+	"FUNC_CALL",	257,
+	"NAME",	258,
+	"REGEXP",	259,
+	"ERROR",	260,
+	"YNUMBER",	261,
+	"YSTRING",	262,
+	"RELOP",	263,
+	"APPEND_OP",	264,
+	"ASSIGNOP",	265,
+	"MATCHOP",	266,
+	"NEWLINE",	267,
+	"CONCAT_OP",	268,
+	"LEX_BEGIN",	269,
+	"LEX_END",	270,
+	"LEX_IF",	271,
+	"LEX_ELSE",	272,
+	"LEX_RETURN",	273,
+	"LEX_DELETE",	274,
+	"LEX_WHILE",	275,
+	"LEX_DO",	276,
+	"LEX_FOR",	277,
+	"LEX_BREAK",	278,
+	"LEX_CONTINUE",	279,
+	"LEX_PRINT",	280,
+	"LEX_PRINTF",	281,
+	"LEX_NEXT",	282,
+	"LEX_EXIT",	283,
+	"LEX_FUNCTION",	284,
+	"LEX_GETLINE",	285,
+	"LEX_IN",	286,
+	"LEX_AND",	287,
+	"LEX_OR",	288,
+	"INCREMENT",	289,
+	"DECREMENT",	290,
+	"LEX_BUILTIN",	291,
+	"LEX_LENGTH",	292,
+	"?",	63,
+	":",	58,
+	"<",	60,
+	">",	62,
+	"|",	124,
+	"+",	43,
+	"-",	45,
+	"*",	42,
+	"/",	47,
+	"%",	37,
+	"!",	33,
+	"UNARY",	293,
+	"^",	94,
+	"$",	36,
+	"(",	40,
+	")",	41,
+	"-unknown-",	-1	/* ends search */
+};
+
+char * yyreds[] =
+{
+	"-no such reduction-",
+	"start : opt_nls program opt_nls",
+	"program : rule",
+	"program : program rule",
+	"program : error",
+	"program : program error",
+	"rule : LEX_BEGIN",
+	"rule : LEX_BEGIN action",
+	"rule : LEX_END",
+	"rule : LEX_END action",
+	"rule : LEX_BEGIN statement_term",
+	"rule : LEX_END statement_term",
+	"rule : pattern action",
+	"rule : action",
+	"rule : pattern statement_term",
+	"rule : function_prologue function_body",
+	"func_name : NAME",
+	"func_name : FUNC_CALL",
+	"function_prologue : LEX_FUNCTION",
+	"function_prologue : LEX_FUNCTION func_name '(' opt_param_list r_paren opt_nls",
+	"function_body : l_brace statements r_brace opt_semi",
+	"pattern : exp",
+	"pattern : exp comma exp",
+	"regexp : '/'",
+	"regexp : '/' REGEXP '/'",
+	"action : l_brace statements r_brace opt_semi",
+	"action : l_brace r_brace opt_semi",
+	"statements : statement",
+	"statements : statements statement",
+	"statements : error",
+	"statements : statements error",
+	"statement_term : nls",
+	"statement_term : semi opt_nls",
+	"statement : semi opt_nls",
+	"statement : l_brace r_brace",
+	"statement : l_brace statements r_brace",
+	"statement : if_statement",
+	"statement : LEX_WHILE '(' exp r_paren opt_nls statement",
+	"statement : LEX_DO opt_nls statement LEX_WHILE '(' exp r_paren opt_nls",
+	"statement : LEX_FOR '(' NAME LEX_IN NAME r_paren opt_nls statement",
+	"statement : LEX_FOR '(' opt_exp semi exp semi opt_exp r_paren opt_nls statement",
+	"statement : LEX_FOR '(' opt_exp semi semi opt_exp r_paren opt_nls statement",
+	"statement : LEX_BREAK statement_term",
+	"statement : LEX_CONTINUE statement_term",
+	"statement : print '(' expression_list r_paren output_redir statement_term",
+	"statement : print opt_rexpression_list output_redir statement_term",
+	"statement : LEX_NEXT",
+	"statement : LEX_NEXT statement_term",
+	"statement : LEX_EXIT opt_exp statement_term",
+	"statement : LEX_RETURN",
+	"statement : LEX_RETURN opt_exp statement_term",
+	"statement : LEX_DELETE NAME '[' expression_list ']' statement_term",
+	"statement : exp statement_term",
+	"print : LEX_PRINT",
+	"print : LEX_PRINTF",
+	"if_statement : LEX_IF '(' exp r_paren opt_nls statement",
+	"if_statement : LEX_IF '(' exp r_paren opt_nls statement LEX_ELSE opt_nls statement",
+	"nls : NEWLINE",
+	"nls : nls NEWLINE",
+	"opt_nls : /* empty */",
+	"opt_nls : nls",
+	"input_redir : /* empty */",
+	"input_redir : '<' simp_exp",
+	"output_redir : /* empty */",
+	"output_redir : '>' exp",
+	"output_redir : APPEND_OP exp",
+	"output_redir : '|' exp",
+	"opt_param_list : /* empty */",
+	"opt_param_list : param_list",
+	"param_list : NAME",
+	"param_list : param_list comma NAME",
+	"param_list : error",
+	"param_list : param_list error",
+	"param_list : param_list comma error",
+	"opt_exp : /* empty */",
+	"opt_exp : exp",
+	"opt_rexpression_list : /* empty */",
+	"opt_rexpression_list : rexpression_list",
+	"rexpression_list : rexp",
+	"rexpression_list : rexpression_list comma rexp",
+	"rexpression_list : error",
+	"rexpression_list : rexpression_list error",
+	"rexpression_list : rexpression_list error rexp",
+	"rexpression_list : rexpression_list comma error",
+	"opt_expression_list : /* empty */",
+	"opt_expression_list : expression_list",
+	"expression_list : exp",
+	"expression_list : expression_list comma exp",
+	"expression_list : error",
+	"expression_list : expression_list error",
+	"expression_list : expression_list error exp",
+	"expression_list : expression_list comma error",
+	"exp : variable ASSIGNOP",
+	"exp : variable ASSIGNOP exp",
+	"exp : '(' expression_list r_paren LEX_IN NAME",
+	"exp : exp '|' LEX_GETLINE opt_variable",
+	"exp : LEX_GETLINE opt_variable input_redir",
+	"exp : exp LEX_AND exp",
+	"exp : exp LEX_OR exp",
+	"exp : exp MATCHOP exp",
+	"exp : regexp",
+	"exp : '!' regexp",
+	"exp : exp LEX_IN NAME",
+	"exp : exp RELOP exp",
+	"exp : exp '<' exp",
+	"exp : exp '>' exp",
+	"exp : exp '?' exp ':' exp",
+	"exp : simp_exp",
+	"exp : exp exp",
+	"rexp : variable ASSIGNOP",
+	"rexp : variable ASSIGNOP rexp",
+	"rexp : rexp LEX_AND rexp",
+	"rexp : rexp LEX_OR rexp",
+	"rexp : LEX_GETLINE opt_variable input_redir",
+	"rexp : regexp",
+	"rexp : '!' regexp",
+	"rexp : rexp MATCHOP rexp",
+	"rexp : rexp LEX_IN NAME",
+	"rexp : rexp RELOP rexp",
+	"rexp : rexp '?' rexp ':' rexp",
+	"rexp : simp_exp",
+	"rexp : rexp rexp",
+	"simp_exp : non_post_simp_exp",
+	"simp_exp : post_inc_dec_exp",
+	"simp_exp : simp_exp '^' simp_exp",
+	"simp_exp : simp_exp '*' simp_exp",
+	"simp_exp : simp_exp '/' simp_exp",
+	"simp_exp : simp_exp '%' simp_exp",
+	"simp_exp : simp_exp '+' simp_exp",
+	"simp_exp : simp_exp '-' simp_exp",
+	"non_post_simp_exp : '!' simp_exp",
+	"non_post_simp_exp : '(' exp r_paren",
+	"non_post_simp_exp : LEX_BUILTIN '(' opt_expression_list r_paren",
+	"non_post_simp_exp : LEX_LENGTH '(' opt_expression_list r_paren",
+	"non_post_simp_exp : LEX_LENGTH",
+	"non_post_simp_exp : FUNC_CALL '(' opt_expression_list r_paren",
+	"non_post_simp_exp : INCREMENT variable",
+	"non_post_simp_exp : DECREMENT variable",
+	"non_post_simp_exp : YNUMBER",
+	"non_post_simp_exp : YSTRING",
+	"non_post_simp_exp : '-' simp_exp",
+	"non_post_simp_exp : '+' simp_exp",
+	"post_inc_dec_exp : variable INCREMENT",
+	"post_inc_dec_exp : variable DECREMENT",
+	"post_inc_dec_exp : variable",
+	"opt_variable : /* empty */",
+	"opt_variable : variable",
+	"variable : NAME",
+	"variable : NAME '[' expression_list ']'",
+	"variable : '$' non_post_simp_exp",
+	"variable : '$' variable",
+	"l_brace : '{' opt_nls",
+	"r_brace : '}' opt_nls",
+	"r_paren : ')'",
+	"opt_semi : /* empty */",
+	"opt_semi : semi",
+	"semi : ';'",
+	"comma : ',' opt_nls",
+};
+#endif /* YYDEBUG */
+#line 1 "/usr/lib/yaccpar"
+/*	@(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10	*/
+
+/*
+** Skeleton parser driver for yacc output
+*/
+
+/*
+** yacc user known macros and defines
+*/
+#define YYERROR		goto yyerrlab
+#define YYACCEPT	{ free(yys); free(yyv); return(0); }
+#define YYABORT		{ free(yys); free(yyv); return(1); }
+#define YYBACKUP( newtoken, newvalue )\
+{\
+	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
+	{\
+		yyerror( "syntax error - cannot backup" );\
+		goto yyerrlab;\
+	}\
+	yychar = newtoken;\
+	yystate = *yyps;\
+	yylval = newvalue;\
+	goto yynewstate;\
+}
+#define YYRECOVERING()	(!!yyerrflag)
+#ifndef YYDEBUG
+#	define YYDEBUG	1	/* make debugging available */
+#endif
+
+/*
+** user known globals
+*/
+int yydebug;			/* set to 1 to get debugging */
+
+/*
+** driver internal defines
+*/
+#define YYFLAG		(-1000)
+
+/*
+** static variables used by the parser
+*/
+static YYSTYPE *yyv;			/* value stack */
+static int *yys;			/* state stack */
+
+static YYSTYPE *yypv;			/* top of value stack */
+static int *yyps;			/* top of state stack */
+
+static int yystate;			/* current state */
+static int yytmp;			/* extra var (lasts between blocks) */
+
+int yynerrs;			/* number of errors */
+
+int yyerrflag;			/* error recovery flag */
+int yychar;			/* current input token number */
+
+
+/*
+** yyparse - return 0 if worked, 1 if syntax error not recovered from
+*/
+int
+yyparse()
+{
+	register YYSTYPE *yypvt;	/* top of value stack for $vars */
+	unsigned yymaxdepth = YYMAXDEPTH;
+
+	/*
+	** Initialize externals - yyparse may be called more than once
+	*/
+	yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
+	yys = (int*)malloc(yymaxdepth*sizeof(int));
+	if (!yyv || !yys)
+	{
+		yyerror( "out of memory" );
+		return(1);
+	}
+	yypv = &yyv[-1];
+	yyps = &yys[-1];
+	yystate = 0;
+	yytmp = 0;
+	yynerrs = 0;
+	yyerrflag = 0;
+	yychar = -1;
+
+	goto yystack;
+	{
+		register YYSTYPE *yy_pv;	/* top of value stack */
+		register int *yy_ps;		/* top of state stack */
+		register int yy_state;		/* current state */
+		register int  yy_n;		/* internal state number info */
+
+		/*
+		** get globals into registers.
+		** branch to here only if YYBACKUP was called.
+		*/
+	yynewstate:
+		yy_pv = yypv;
+		yy_ps = yyps;
+		yy_state = yystate;
+		goto yy_newstate;
+
+		/*
+		** get globals into registers.
+		** either we just started, or we just finished a reduction
+		*/
+	yystack:
+		yy_pv = yypv;
+		yy_ps = yyps;
+		yy_state = yystate;
+
+		/*
+		** top of for (;;) loop while no reductions done
+		*/
+	yy_stack:
+		/*
+		** put a state and value onto the stacks
+		*/
+#if YYDEBUG
+		/*
+		** if debugging, look up token value in list of value vs.
+		** name pairs.  0 and negative (-1) are special values.
+		** Note: linear search is used since time is not a real
+		** consideration while debugging.
+		*/
+		if ( yydebug )
+		{
+			register int yy_i;
+
+			(void)printf( "State %d, token ", yy_state );
+			if ( yychar == 0 )
+				(void)printf( "end-of-file\n" );
+			else if ( yychar < 0 )
+				(void)printf( "-none-\n" );
+			else
+			{
+				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
+					yy_i++ )
+				{
+					if ( yytoks[yy_i].t_val == yychar )
+						break;
+				}
+				(void)printf( "%s\n", yytoks[yy_i].t_name );
+			}
+		}
+#endif /* YYDEBUG */
+		if ( ++yy_ps >= &yys[ yymaxdepth ] )	/* room on stack? */
+		{
+			/*
+			** reallocate and recover.  Note that pointers
+			** have to be reset, or bad things will happen
+			*/
+			int yyps_index = (yy_ps - yys);
+			int yypv_index = (yy_pv - yyv);
+			int yypvt_index = (yypvt - yyv);
+			yymaxdepth += YYMAXDEPTH;
+			yyv = (YYSTYPE*)realloc((char*)yyv,
+				yymaxdepth * sizeof(YYSTYPE));
+			yys = (int*)realloc((char*)yys,
+				yymaxdepth * sizeof(int));
+			if (!yyv || !yys)
+			{
+				yyerror( "yacc stack overflow" );
+				return(1);
+			}
+			yy_ps = yys + yyps_index;
+			yy_pv = yyv + yypv_index;
+			yypvt = yyv + yypvt_index;
+		}
+		*yy_ps = yy_state;
+		*++yy_pv = yyval;
+
+		/*
+		** we have a new state - find out what to do
+		*/
+	yy_newstate:
+		if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
+			goto yydefault;		/* simple state */
+#if YYDEBUG
+		/*
+		** if debugging, need to mark whether new token grabbed
+		*/
+		yytmp = yychar < 0;
+#endif
+		if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
+			yychar = 0;		/* reached EOF */
+#if YYDEBUG
+		if ( yydebug && yytmp )
+		{
+			register int yy_i;
+
+			(void)printf( "Received token " );
+			if ( yychar == 0 )
+				(void)printf( "end-of-file\n" );
+			else if ( yychar < 0 )
+				(void)printf( "-none-\n" );
+			else
+			{
+				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
+					yy_i++ )
+				{
+					if ( yytoks[yy_i].t_val == yychar )
+						break;
+				}
+				(void)printf( "%s\n", yytoks[yy_i].t_name );
+			}
+		}
+#endif /* YYDEBUG */
+		if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
+			goto yydefault;
+		if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )	/*valid shift*/
+		{
+			yychar = -1;
+			yyval = yylval;
+			yy_state = yy_n;
+			if ( yyerrflag > 0 )
+				yyerrflag--;
+			goto yy_stack;
+		}
+
+	yydefault:
+		if ( ( yy_n = yydef[ yy_state ] ) == -2 )
+		{
+#if YYDEBUG
+			yytmp = yychar < 0;
+#endif
+			if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
+				yychar = 0;		/* reached EOF */
+#if YYDEBUG
+			if ( yydebug && yytmp )
+			{
+				register int yy_i;
+
+				(void)printf( "Received token " );
+				if ( yychar == 0 )
+					(void)printf( "end-of-file\n" );
+				else if ( yychar < 0 )
+					(void)printf( "-none-\n" );
+				else
+				{
+					for ( yy_i = 0;
+						yytoks[yy_i].t_val >= 0;
+						yy_i++ )
+					{
+						if ( yytoks[yy_i].t_val
+							== yychar )
+						{
+							break;
+						}
+					}
+					(void)printf( "%s\n", yytoks[yy_i].t_name );
+				}
+			}
+#endif /* YYDEBUG */
+			/*
+			** look through exception table
+			*/
+			{
+				register int *yyxi = yyexca;
+
+				while ( ( *yyxi != -1 ) ||
+					( yyxi[1] != yy_state ) )
+				{
+					yyxi += 2;
+				}
+				while ( ( *(yyxi += 2) >= 0 ) &&
+					( *yyxi != yychar ) )
+					;
+				if ( ( yy_n = yyxi[1] ) < 0 )
+					YYACCEPT;
+			}
+		}
+
+		/*
+		** check for syntax error
+		*/
+		if ( yy_n == 0 )	/* have an error */
+		{
+			/* no worry about speed here! */
+			switch ( yyerrflag )
+			{
+			case 0:		/* new error */
+				yyerror( "syntax error" );
+				goto skip_init;
+			yyerrlab:
+				/*
+				** get globals into registers.
+				** we have a user generated syntax type error
+				*/
+				yy_pv = yypv;
+				yy_ps = yyps;
+				yy_state = yystate;
+				yynerrs++;
+			skip_init:
+			case 1:
+			case 2:		/* incompletely recovered error */
+					/* try again... */
+				yyerrflag = 3;
+				/*
+				** find state where "error" is a legal
+				** shift action
+				*/
+				while ( yy_ps >= yys )
+				{
+					yy_n = yypact[ *yy_ps ] + YYERRCODE;
+					if ( yy_n >= 0 && yy_n < YYLAST &&
+						yychk[yyact[yy_n]] == YYERRCODE)					{
+						/*
+						** simulate shift of "error"
+						*/
+						yy_state = yyact[ yy_n ];
+						goto yy_stack;
+					}
+					/*
+					** current state has no shift on
+					** "error", pop stack
+					*/
+#if YYDEBUG
+#	define _POP_ "Error recovery pops state %d, uncovers state %d\n"
+					if ( yydebug )
+						(void)printf( _POP_, *yy_ps,
+							yy_ps[-1] );
+#	undef _POP_
+#endif
+					yy_ps--;
+					yy_pv--;
+				}
+				/*
+				** there is no state on stack with "error" as
+				** a valid shift.  give up.
+				*/
+				YYABORT;
+			case 3:		/* no shift yet; eat a token */
+#if YYDEBUG
+				/*
+				** if debugging, look up token in list of
+				** pairs.  0 and negative shouldn't occur,
+				** but since timing doesn't matter when
+				** debugging, it doesn't hurt to leave the
+				** tests here.
+				*/
+				if ( yydebug )
+				{
+					register int yy_i;
+
+					(void)printf( "Error recovery discards " );
+					if ( yychar == 0 )
+						(void)printf( "token end-of-file\n" );
+					else if ( yychar < 0 )
+						(void)printf( "token -none-\n" );
+					else
+					{
+						for ( yy_i = 0;
+							yytoks[yy_i].t_val >= 0;
+							yy_i++ )
+						{
+							if ( yytoks[yy_i].t_val
+								== yychar )
+							{
+								break;
+							}
+						}
+						(void)printf( "token %s\n",
+							yytoks[yy_i].t_name );
+					}
+				}
+#endif /* YYDEBUG */
+				if ( yychar == 0 )	/* reached EOF. quit */
+					YYABORT;
+				yychar = -1;
+				goto yy_newstate;
+			}
+		}/* end if ( yy_n == 0 ) */
+		/*
+		** reduction by production yy_n
+		** put stack tops, etc. so things right after switch
+		*/
+#if YYDEBUG
+		/*
+		** if debugging, print the string that is the user's
+		** specification of the reduction which is just about
+		** to be done.
+		*/
+		if ( yydebug )
+			(void)printf( "Reduce by (%d) \"%s\"\n",
+				yy_n, yyreds[ yy_n ] );
+#endif
+		yytmp = yy_n;			/* value to switch over */
+		yypvt = yy_pv;			/* $vars top of value stack */
+		/*
+		** Look in goto table for next state
+		** Sorry about using yy_state here as temporary
+		** register variable, but why not, if it works...
+		** If yyr2[ yy_n ] doesn't have the low order bit
+		** set, then there is no action to be done for
+		** this reduction.  So, no saving & unsaving of
+		** registers done.  The only difference between the
+		** code just after the if and the body of the if is
+		** the goto yy_stack in the body.  This way the test
+		** can be made before the choice of what to do is needed.
+		*/
+		{
+			/* length of production doubled with extra bit */
+			register int yy_len = yyr2[ yy_n ];
+
+			if ( !( yy_len & 01 ) )
+			{
+				yy_len >>= 1;
+				yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
+				yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
+					*( yy_ps -= yy_len ) + 1;
+				if ( yy_state >= YYLAST ||
+					yychk[ yy_state =
+					yyact[ yy_state ] ] != -yy_n )
+				{
+					yy_state = yyact[ yypgo[ yy_n ] ];
+				}
+				goto yy_stack;
+			}
+			yy_len >>= 1;
+			yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
+			yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
+				*( yy_ps -= yy_len ) + 1;
+			if ( yy_state >= YYLAST ||
+				yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
+			{
+				yy_state = yyact[ yypgo[ yy_n ] ];
+			}
+		}
+					/* save until reenter driver code */
+		yystate = yy_state;
+		yyps = yy_ps;
+		yypv = yy_pv;
+	}
+	/*
+	** code supplied by user is placed in this switch
+	*/
+	switch( yytmp )
+	{
+		
+case 1:
+# line 135 "awk.y"
+{ expression_value = yypvt[-1].nodeval; } break;
+case 2:
+# line 140 "awk.y"
+{ 
+			if (yypvt[-0].nodeval != NULL)
+				yyval.nodeval = yypvt[-0].nodeval;
+			else
+				yyval.nodeval = NULL;
+			yyerrok;
+		} break;
+case 3:
+# line 149 "awk.y"
+{
+			if (yypvt[-0].nodeval == NULL)
+				yyval.nodeval = yypvt[-1].nodeval;
+			else if (yypvt[-1].nodeval == NULL)
+				yyval.nodeval = yypvt[-0].nodeval;
+			else {
+				if (yypvt[-1].nodeval->type != Node_rule_list)
+					yypvt[-1].nodeval = node(yypvt[-1].nodeval, Node_rule_list,
+						(NODE*)NULL);
+				yyval.nodeval = append_right (yypvt[-1].nodeval,
+				   node(yypvt[-0].nodeval, Node_rule_list,(NODE *) NULL));
+			}
+			yyerrok;
+		} break;
+case 4:
+# line 163 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 5:
+# line 164 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 6:
+# line 168 "awk.y"
+{ io_allowed = 0; } break;
+case 7:
+# line 170 "awk.y"
+{
+		if (begin_block) {
+			if (begin_block->type != Node_rule_list)
+				begin_block = node(begin_block, Node_rule_list,
+					(NODE *)NULL);
+			(void) append_right (begin_block, node(
+			    node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval),
+			    Node_rule_list, (NODE *)NULL) );
+		} else
+			begin_block = node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval);
+		yyval.nodeval = NULL;
+		io_allowed = 1;
+		yyerrok;
+	  } break;
+case 8:
+# line 184 "awk.y"
+{ io_allowed = 0; } break;
+case 9:
+# line 186 "awk.y"
+{
+		if (end_block) {
+			if (end_block->type != Node_rule_list)
+				end_block = node(end_block, Node_rule_list,
+					(NODE *)NULL);
+			(void) append_right (end_block, node(
+			    node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval),
+			    Node_rule_list, (NODE *)NULL));
+		} else
+			end_block = node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval);
+		yyval.nodeval = NULL;
+		io_allowed = 1;
+		yyerrok;
+	  } break;
+case 10:
+# line 201 "awk.y"
+{
+		warning("BEGIN blocks must have an action part");
+		errcount++;
+		yyerrok;
+	  } break;
+case 11:
+# line 207 "awk.y"
+{
+		warning("END blocks must have an action part");
+		errcount++;
+		yyerrok;
+	  } break;
+case 12:
+# line 213 "awk.y"
+{ yyval.nodeval = node (yypvt[-1].nodeval, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;
+case 13:
+# line 215 "awk.y"
+{ yyval.nodeval = node ((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;
+case 14:
+# line 217 "awk.y"
+{
+		  yyval.nodeval = node (yypvt[-1].nodeval,
+			     Node_rule_node,
+			     node(node(node(make_number(0.0),
+					    Node_field_spec,
+					    (NODE *) NULL),
+					Node_expression_list,
+					(NODE *) NULL),
+				  Node_K_print,
+				  (NODE *) NULL));
+		  yyerrok;
+		} break;
+case 15:
+# line 230 "awk.y"
+{
+			func_install(yypvt[-1].nodeval, yypvt[-0].nodeval);
+			yyval.nodeval = NULL;
+			yyerrok;
+		} break;
+case 16:
+# line 239 "awk.y"
+{ yyval.sval = yypvt[-0].sval; } break;
+case 17:
+# line 241 "awk.y"
+{ yyval.sval = yypvt[-0].sval; } break;
+case 18:
+# line 246 "awk.y"
+{
+			param_counter = 0;
+		} break;
+case 19:
+# line 250 "awk.y"
+{
+			yyval.nodeval = append_right(make_param(yypvt[-4].sval), yypvt[-2].nodeval);
+			can_return = 1;
+		} break;
+case 20:
+# line 258 "awk.y"
+{
+		yyval.nodeval = yypvt[-2].nodeval;
+		can_return = 0;
+	  } break;
+case 21:
+# line 267 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 22:
+# line 269 "awk.y"
+{ yyval.nodeval = mkrangenode ( node(yypvt[-2].nodeval, Node_cond_pair, yypvt[-0].nodeval) ); } break;
+case 23:
+# line 278 "awk.y"
+{ ++want_regexp; } break;
+case 24:
+# line 280 "awk.y"
+{
+		  NODE *n;
+
+		  getnode(n);
+		  n->type = Node_regex;
+		  n->re_exp = make_string(yypvt[-1].sval, strlen(yypvt[-1].sval));
+		  n->re_reg = mk_re_parse(yypvt[-1].sval, 0);
+		  n->re_text = NULL;
+		  n->re_flags = CONST;
+		  n->re_cnt = 1;
+		  yyval.nodeval = n;
+		} break;
+case 25:
+# line 296 "awk.y"
+{ yyval.nodeval = yypvt[-2].nodeval ; } break;
+case 26:
+# line 298 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 27:
+# line 303 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 28:
+# line 305 "awk.y"
+{
+			if (yypvt[-1].nodeval == NULL || yypvt[-1].nodeval->type != Node_statement_list)
+				yypvt[-1].nodeval = node(yypvt[-1].nodeval, Node_statement_list,(NODE *)NULL);
+	    		yyval.nodeval = append_right(yypvt[-1].nodeval,
+				node( yypvt[-0].nodeval, Node_statement_list, (NODE *)NULL));
+	    		yyerrok;
+		} break;
+case 29:
+# line 313 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 30:
+# line 315 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 33:
+# line 325 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 34:
+# line 327 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 35:
+# line 329 "awk.y"
+{ yyval.nodeval = yypvt[-1].nodeval; } break;
+case 36:
+# line 331 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 37:
+# line 333 "awk.y"
+{ yyval.nodeval = node (yypvt[-3].nodeval, Node_K_while, yypvt[-0].nodeval); } break;
+case 38:
+# line 335 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_K_do, yypvt[-5].nodeval); } break;
+case 39:
+# line 337 "awk.y"
+{
+		yyval.nodeval = node (yypvt[-0].nodeval, Node_K_arrayfor, make_for_loop(variable(yypvt[-5].sval,1),
+			(NODE *)NULL, variable(yypvt[-3].sval,1)));
+	  } break;
+case 40:
+# line 342 "awk.y"
+{
+		yyval.nodeval = node(yypvt[-0].nodeval, Node_K_for, (NODE *)make_for_loop(yypvt[-7].nodeval, yypvt[-5].nodeval, yypvt[-3].nodeval));
+	  } break;
+case 41:
+# line 346 "awk.y"
+{
+		yyval.nodeval = node (yypvt[-0].nodeval, Node_K_for,
+			(NODE *)make_for_loop(yypvt[-6].nodeval, (NODE *)NULL, yypvt[-3].nodeval));
+	  } break;
+case 42:
+# line 352 "awk.y"
+{ yyval.nodeval = node ((NODE *)NULL, Node_K_break, (NODE *)NULL); } break;
+case 43:
+# line 355 "awk.y"
+{ yyval.nodeval = node ((NODE *)NULL, Node_K_continue, (NODE *)NULL); } break;
+case 44:
+# line 357 "awk.y"
+{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-5].nodetypeval, yypvt[-1].nodeval); } break;
+case 45:
+# line 359 "awk.y"
+{
+			if (yypvt[-3].nodetypeval == Node_K_print && yypvt[-2].nodeval == NULL)
+				yypvt[-2].nodeval = node(node(make_number(0.0),
+					       Node_field_spec,
+					       (NODE *) NULL),
+					  Node_expression_list,
+					  (NODE *) NULL);
+
+			yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-3].nodetypeval, yypvt[-1].nodeval);
+		} break;
+case 46:
+# line 370 "awk.y"
+{ if (! io_allowed) yyerror("next used in BEGIN or END action"); } break;
+case 47:
+# line 372 "awk.y"
+{ yyval.nodeval = node ((NODE *)NULL, Node_K_next, (NODE *)NULL); } break;
+case 48:
+# line 374 "awk.y"
+{ yyval.nodeval = node (yypvt[-1].nodeval, Node_K_exit, (NODE *)NULL); } break;
+case 49:
+# line 376 "awk.y"
+{ if (! can_return) yyerror("return used outside function context"); } break;
+case 50:
+# line 378 "awk.y"
+{ yyval.nodeval = node (yypvt[-1].nodeval, Node_K_return, (NODE *)NULL); } break;
+case 51:
+# line 380 "awk.y"
+{ yyval.nodeval = node (variable(yypvt[-4].sval,1), Node_K_delete, yypvt[-2].nodeval); } break;
+case 52:
+# line 382 "awk.y"
+{ yyval.nodeval = yypvt[-1].nodeval; } break;
+case 53:
+# line 387 "awk.y"
+{ yyval.nodetypeval = yypvt[-0].nodetypeval; } break;
+case 54:
+# line 389 "awk.y"
+{ yyval.nodetypeval = yypvt[-0].nodetypeval; } break;
+case 55:
+# line 394 "awk.y"
+{
+		yyval.nodeval = node(yypvt[-3].nodeval, Node_K_if, 
+			node(yypvt[-0].nodeval, Node_if_branches, (NODE *)NULL));
+	  } break;
+case 56:
+# line 400 "awk.y"
+{ yyval.nodeval = node (yypvt[-6].nodeval, Node_K_if,
+				node (yypvt[-3].nodeval, Node_if_branches, yypvt[-0].nodeval)); } break;
+case 57:
+# line 406 "awk.y"
+{ want_assign = 0; } break;
+case 61:
+# line 417 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 62:
+# line 419 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_input, (NODE *)NULL); } break;
+case 63:
+# line 424 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 64:
+# line 426 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_output, (NODE *)NULL); } break;
+case 65:
+# line 428 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_append, (NODE *)NULL); } break;
+case 66:
+# line 430 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_pipe, (NODE *)NULL); } break;
+case 67:
+# line 435 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 68:
+# line 437 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 69:
+# line 442 "awk.y"
+{ yyval.nodeval = make_param(yypvt[-0].sval); } break;
+case 70:
+# line 444 "awk.y"
+{ yyval.nodeval = append_right(yypvt[-2].nodeval, make_param(yypvt[-0].sval)); yyerrok; } break;
+case 71:
+# line 446 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 72:
+# line 448 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 73:
+# line 450 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 74:
+# line 456 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 75:
+# line 458 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 76:
+# line 463 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 77:
+# line 465 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 78:
+# line 470 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;
+case 79:
+# line 472 "awk.y"
+{
+		yyval.nodeval = append_right(yypvt[-2].nodeval,
+			node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));
+		yyerrok;
+	  } break;
+case 80:
+# line 478 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 81:
+# line 480 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 82:
+# line 482 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 83:
+# line 484 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 84:
+# line 489 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 85:
+# line 491 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 86:
+# line 496 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;
+case 87:
+# line 498 "awk.y"
+{
+			yyval.nodeval = append_right(yypvt[-2].nodeval,
+				node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));
+			yyerrok;
+		} break;
+case 88:
+# line 504 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 89:
+# line 506 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 90:
+# line 508 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 91:
+# line 510 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 92:
+# line 515 "awk.y"
+{ want_assign = 0; } break;
+case 93:
+# line 517 "awk.y"
+{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval); } break;
+case 94:
+# line 519 "awk.y"
+{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-3].nodeval); } break;
+case 95:
+# line 521 "awk.y"
+{
+		  yyval.nodeval = node (yypvt[-0].nodeval, Node_K_getline,
+			 node (yypvt[-3].nodeval, Node_redirect_pipein, (NODE *)NULL));
+		} break;
+case 96:
+# line 526 "awk.y"
+{
+		  if (do_lint && ! io_allowed && yypvt[-0].nodeval == NULL)
+			warning("non-redirected getline undefined inside BEGIN or END action");
+		  yyval.nodeval = node (yypvt[-1].nodeval, Node_K_getline, yypvt[-0].nodeval);
+		} break;
+case 97:
+# line 532 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;
+case 98:
+# line 534 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;
+case 99:
+# line 536 "awk.y"
+{
+		  if (yypvt[-2].nodeval->type == Node_regex)
+			warning("Regular expression on left of MATCH operator.");
+		  yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, mk_rexp(yypvt[-0].nodeval));
+		} break;
+case 100:
+# line 542 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 101:
+# line 544 "awk.y"
+{
+		  yyval.nodeval = node(node(make_number(0.0),
+				 Node_field_spec,
+				 (NODE *) NULL),
+		            Node_nomatch,
+			    yypvt[-0].nodeval);
+		} break;
+case 102:
+# line 552 "awk.y"
+{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;
+case 103:
+# line 554 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval); } break;
+case 104:
+# line 556 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_less, yypvt[-0].nodeval); } break;
+case 105:
+# line 558 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_greater, yypvt[-0].nodeval); } break;
+case 106:
+# line 560 "awk.y"
+{ yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;
+case 107:
+# line 562 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 108:
+# line 564 "awk.y"
+{ yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;
+case 109:
+# line 569 "awk.y"
+{ want_assign = 0; } break;
+case 110:
+# line 571 "awk.y"
+{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval); } break;
+case 111:
+# line 573 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;
+case 112:
+# line 575 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;
+case 113:
+# line 577 "awk.y"
+{
+		  if (do_lint && ! io_allowed && yypvt[-0].nodeval == NULL)
+			warning("non-redirected getline undefined inside BEGIN or END action");
+		  yyval.nodeval = node (yypvt[-1].nodeval, Node_K_getline, yypvt[-0].nodeval);
+		} break;
+case 114:
+# line 583 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 115:
+# line 585 "awk.y"
+{ yyval.nodeval = node((NODE *) NULL, Node_nomatch, yypvt[-0].nodeval); } break;
+case 116:
+# line 587 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, mk_rexp(yypvt[-0].nodeval)); } break;
+case 117:
+# line 589 "awk.y"
+{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;
+case 118:
+# line 591 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval); } break;
+case 119:
+# line 593 "awk.y"
+{ yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;
+case 120:
+# line 595 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 121:
+# line 597 "awk.y"
+{ yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;
+case 124:
+# line 605 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_exp, yypvt[-0].nodeval); } break;
+case 125:
+# line 607 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_times, yypvt[-0].nodeval); } break;
+case 126:
+# line 609 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_quotient, yypvt[-0].nodeval); } break;
+case 127:
+# line 611 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_mod, yypvt[-0].nodeval); } break;
+case 128:
+# line 613 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_plus, yypvt[-0].nodeval); } break;
+case 129:
+# line 615 "awk.y"
+{ yyval.nodeval = node (yypvt[-2].nodeval, Node_minus, yypvt[-0].nodeval); } break;
+case 130:
+# line 620 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_not,(NODE *) NULL); } break;
+case 131:
+# line 622 "awk.y"
+{ yyval.nodeval = yypvt[-1].nodeval; } break;
+case 132:
+# line 624 "awk.y"
+{ yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-3].lval); } break;
+case 133:
+# line 626 "awk.y"
+{ yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-3].lval); } break;
+case 134:
+# line 628 "awk.y"
+{ yyval.nodeval = snode ((NODE *)NULL, Node_builtin, (int) yypvt[-0].lval); } break;
+case 135:
+# line 630 "awk.y"
+{
+		yyval.nodeval = node (yypvt[-1].nodeval, Node_func_call, make_string(yypvt[-3].sval, strlen(yypvt[-3].sval)));
+	  } break;
+case 136:
+# line 634 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_preincrement, (NODE *)NULL); } break;
+case 137:
+# line 636 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_predecrement, (NODE *)NULL); } break;
+case 138:
+# line 638 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 139:
+# line 640 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 140:
+# line 643 "awk.y"
+{ if (yypvt[-0].nodeval->type == Node_val) {
+			yypvt[-0].nodeval->numbr = -(force_number(yypvt[-0].nodeval));
+			yyval.nodeval = yypvt[-0].nodeval;
+		  } else
+			yyval.nodeval = node (yypvt[-0].nodeval, Node_unary_minus, (NODE *)NULL);
+		} break;
+case 141:
+# line 650 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 142:
+# line 655 "awk.y"
+{ yyval.nodeval = node (yypvt[-1].nodeval, Node_postincrement, (NODE *)NULL); } break;
+case 143:
+# line 657 "awk.y"
+{ yyval.nodeval = node (yypvt[-1].nodeval, Node_postdecrement, (NODE *)NULL); } break;
+case 145:
+# line 663 "awk.y"
+{ yyval.nodeval = NULL; } break;
+case 146:
+# line 665 "awk.y"
+{ yyval.nodeval = yypvt[-0].nodeval; } break;
+case 147:
+# line 670 "awk.y"
+{ yyval.nodeval = variable(yypvt[-0].sval,1); } break;
+case 148:
+# line 672 "awk.y"
+{
+		if (yypvt[-1].nodeval->rnode == NULL) {
+			yyval.nodeval = node (variable(yypvt[-3].sval,1), Node_subscript, yypvt[-1].nodeval->lnode);
+			freenode(yypvt[-1].nodeval);
+		} else
+			yyval.nodeval = node (variable(yypvt[-3].sval,1), Node_subscript, yypvt[-1].nodeval);
+		} break;
+case 149:
+# line 680 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;
+case 150:
+# line 682 "awk.y"
+{ yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;
+case 152:
+# line 690 "awk.y"
+{ yyerrok; } break;
+case 153:
+# line 694 "awk.y"
+{ yyerrok; } break;
+case 156:
+# line 703 "awk.y"
+{ yyerrok; want_assign = 0; } break;
+case 157:
+# line 706 "awk.y"
+{ yyerrok; } break;
+	}
+	goto yystack;		/* reset registers in driver code */
+}