This is awktab.c in view mode; [Download] [Up]
# line 27 "awk.y"
#ifdef DEBUG
#define YYDEBUG 12
#endif
#define YYMAXDEPTH 300
#define YYSSIZE YYMAXDEPTH
#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 sindex));
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 76 "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 751 "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 GAWKX 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, GAWKX|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, GAWKX|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 *bp, *cp;
char *scan;
char buf[120];
errcount++;
/* Find the current line in the input file */
if (lexptr) {
if (!thisline) {
for (cp=lexeme; cp != lexptr_begin && *cp != '\n'; --cp)
;
if (*cp == '\n')
cp++;
thisline = cp;
}
/* NL isn't guaranteed */
bp = lexeme;
while (bp < lexend && *bp && *bp != '\n')
bp++;
} else {
thisline = "(END OF FILE)";
bp = thisline + 13;
}
msg("%.*s", (int) (bp - thisline), thisline);
bp = buf;
cp = buf + sizeof(buf) - 24; /* 24 more than longest msg. input */
if (lexptr) {
scan = thisline;
while (bp < cp && scan < lexeme)
if (*scan++ == '\t')
*bp++ = '\t';
else
*bp++ = ' ';
*bp++ = '^';
*bp++ = ' ';
}
va_start(args);
mesg = va_arg(args, char *);
strcpy(bp, mesg);
err("", buf, args);
va_end(args);
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
lexeme = lexptr = lexptr_begin = NULL;
return lexptr;
}
if (!samefile) {
source = srcfiles[nextfile];
if (source == NULL) {
if (buf)
free(buf);
return lexeme = 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()) != 0) {
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 '.':
c = nextc();
pushback();
if (!isdigit(c))
return '.';
else
c = '.'; /* FALL THROUGH */
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* 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 & GAWKX)
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 & GAWKX))
|| (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, idx)
NODETYPE op;
int idx;
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[idx].flags & ARGS;
if (args_allowed && !(args_allowed & A(nexp)))
fatal("%s() cannot have %d argument%c",
tokentab[idx].operator, nexp, nexp == 1 ? ' ' : 's');
r->proc = tokentab[idx].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, 61,
-2, 0,
-1, 77,
264, 78,
267, 78,
62, 78,
124, 78,
59, 78,
-2, 0,
-1, 112,
41, 86,
-2, 0,
-1, 113,
41, 86,
-2, 0,
-1, 126,
266, 0,
-2, 101,
-1, 128,
263, 0,
60, 0,
62, 0,
124, 0,
-2, 105,
-1, 129,
263, 0,
60, 0,
62, 0,
124, 0,
-2, 106,
-1, 130,
263, 0,
60, 0,
62, 0,
124, 0,
-2, 107,
-1, 149,
264, 79,
267, 79,
62, 79,
124, 79,
59, 79,
-2, 0,
-1, 188,
41, 86,
-2, 0,
-1, 190,
41, 87,
-2, 0,
-1, 224,
41, 69,
-2, 0,
-1, 253,
266, 0,
-2, 118,
-1, 255,
263, 0,
-2, 120,
-1, 263,
41, 70,
-2, 0,
};
# define YYNPROD 161
# define YYLAST 1998
int yyact[]={
62, 216, 107, 13, 87, 229, 13, 88, 89, 166,
165, 123, 240, 297, 4, 82, 45, 37, 91, 45,
292, 265, 291, 264, 204, 88, 89, 187, 88, 89,
270, 24, 171, 266, 254, 155, 63, 161, 24, 127,
176, 65, 98, 168, 169, 36, 52, 35, 157, 25,
63, 174, 82, 122, 63, 124, 125, 126, 22, 128,
129, 130, 131, 93, 136, 82, 189, 203, 66, 63,
100, 82, 103, 222, 107, 64, 177, 101, 63, 158,
158, 45, 102, 22, 103, 276, 206, 63, 232, 101,
104, 174, 105, 269, 102, 224, 188, 163, 16, 178,
144, 142, 113, 112, 6, 11, 133, 26, 186, 111,
39, 257, 140, 186, 186, 170, 48, 94, 231, 99,
160, 110, 82, 109, 86, 46, 41, 121, 159, 100,
114, 115, 108, 134, 99, 99, 167, 164, 77, 262,
71, 100, 82, 198, 82, 158, 141, 118, 91, 148,
149, 263, 120, 10, 27, 20, 5, 1, 24, 50,
12, 158, 17, 192, 223, 36, 0, 35, 0, 25,
0, 225, 226, 228, 0, 0, 152, 0, 0, 0,
191, 45, 207, 197, 0, 0, 0, 193, 0, 186,
134, 0, 0, 201, 0, 237, 99, 241, 195, 99,
99, 99, 99, 99, 99, 245, 246, 247, 0, 221,
134, 0, 199, 0, 0, 0, 190, 217, 0, 0,
0, 0, 94, 186, 4, 20, 205, 4, 24, 0,
0, 0, 17, 0, 90, 36, 0, 35, 0, 25,
0, 0, 0, 271, 0, 22, 0, 68, 172, 152,
0, 45, 94, 23, 99, 233, 0, 236, 258, 30,
23, 0, 280, 33, 34, 213, 172, 0, 211, 82,
282, 0, 20, 158, 0, 24, 99, 0, 82, 17,
0, 172, 36, 0, 35, 158, 25, 153, 212, 209,
172, 31, 32, 28, 29, 82, 279, 0, 45, 208,
0, 0, 82, 82, 82, 0, 152, 152, 152, 152,
152, 273, 152, 152, 152, 22, 20, 68, 0, 24,
0, 285, 155, 17, 185, 24, 36, 0, 35, 98,
25, 0, 36, 295, 35, 0, 25, 281, 0, 0,
0, 0, 45, 0, 0, 0, 289, 152, 0, 152,
152, 152, 152, 0, 152, 152, 152, 0, 0, 0,
0, 0, 22, 299, 202, 0, 0, 0, 0, 0,
304, 305, 306, 152, 152, 0, 0, 0, 135, 30,
23, 0, 0, 33, 34, 0, 152, 0, 0, 0,
0, 0, 0, 83, 0, 80, 81, 72, 73, 74,
75, 76, 84, 85, 78, 79, 22, 18, 0, 0,
0, 31, 32, 28, 29, 20, 0, 0, 24, 0,
215, 0, 17, 0, 0, 36, 0, 35, 0, 25,
0, 0, 0, 0, 0, 0, 0, 0, 0, 260,
0, 45, 59, 0, 60, 61, 0, 0, 67, 30,
23, 0, 0, 33, 34, 0, 0, 0, 0, 0,
0, 0, 0, 83, 0, 80, 81, 72, 73, 74,
75, 76, 84, 85, 78, 79, 0, 18, 0, 0,
0, 31, 32, 28, 29, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 67, 30, 23, 150, 0,
33, 34, 21, 0, 0, 0, 53, 0, 0, 0,
83, 0, 80, 81, 72, 73, 74, 75, 76, 84,
85, 78, 79, 96, 18, 0, 0, 0, 31, 32,
28, 29, 0, 0, 0, 0, 0, 0, 116, 117,
30, 23, 0, 0, 33, 34, 2, 23, 0, 0,
33, 34, 38, 0, 83, 0, 80, 81, 72, 73,
74, 75, 76, 84, 85, 78, 79, 0, 18, 106,
0, 0, 31, 32, 28, 29, 0, 0, 31, 32,
156, 0, 0, 0, 0, 20, 0, 0, 24, 0,
0, 119, 17, 0, 0, 36, 0, 35, 0, 25,
96, 0, 0, 179, 180, 181, 182, 183, 184, 0,
132, 0, 59, 0, 60, 138, 139, 0, 0, 0,
143, 0, 0, 0, 0, 0, 0, 0, 248, 250,
251, 252, 253, 0, 255, 256, 0, 0, 0, 30,
23, 0, 0, 33, 34, 58, 0, 0, 56, 4,
0, 0, 20, 156, 0, 24, 0, 0, 96, 17,
174, 0, 36, 0, 35, 0, 25, 18, 57, 54,
55, 31, 32, 28, 29, 0, 53, 0, 275, 59,
230, 60, 61, 196, 0, 0, 70, 0, 0, 14,
0, 0, 14, 20, 0, 287, 24, 14, 0, 51,
17, 0, 0, 36, 0, 35, 0, 25, 0, 0,
156, 156, 156, 156, 156, 0, 156, 156, 156, 45,
59, 0, 60, 61, 0, 0, 0, 0, 14, 0,
0, 0, 0, 14, 0, 0, 0, 0, 20, 0,
0, 24, 238, 53, 0, 17, 0, 0, 36, 0,
35, 156, 25, 156, 156, 156, 156, 0, 156, 156,
156, 0, 0, 194, 0, 59, 0, 60, 61, 0,
0, 0, 0, 0, 0, 0, 0, 156, 156, 0,
0, 0, 20, 0, 53, 24, 268, 0, 0, 17,
156, 0, 36, 63, 35, 0, 25, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 277, 59,
23, 60, 61, 33, 34, 58, 0, 0, 0, 0,
0, 20, 0, 0, 24, 290, 0, 0, 17, 53,
294, 36, 0, 35, 0, 25, 0, 0, 0, 0,
298, 31, 32, 301, 302, 0, 0, 303, 59, 0,
60, 61, 0, 0, 0, 0, 0, 0, 155, 0,
0, 24, 0, 0, 0, 98, 0, 0, 36, 0,
35, 0, 25, 53, 0, 0, 30, 23, 0, 0,
33, 34, 58, 274, 0, 56, 0, 0, 214, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 18, 57, 54, 55, 31, 32,
28, 29, 53, 0, 0, 0, 0, 30, 23, 0,
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, 0, 0, 0,
0, 0, 30, 23, 0, 0, 33, 34, 58, 155,
0, 56, 24, 0, 0, 155, 98, 0, 24, 36,
0, 35, 98, 25, 0, 36, 0, 35, 0, 25,
18, 57, 54, 55, 31, 32, 28, 29, 0, 214,
0, 0, 0, 19, 0, 0, 30, 23, 0, 0,
33, 34, 58, 20, 0, 56, 24, 0, 53, 0,
17, 0, 0, 36, 95, 35, 0, 25, 0, 0,
0, 0, 0, 0, 18, 57, 54, 55, 31, 32,
28, 29, 0, 0, 0, 30, 23, 0, 0, 33,
34, 58, 20, 0, 56, 24, 0, 0, 0, 17,
0, 0, 36, 0, 35, 0, 25, 0, 0, 0,
0, 0, 0, 18, 57, 54, 55, 31, 32, 28,
29, 154, 30, 23, 0, 0, 33, 34, 213, 0,
0, 211, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 22, 0, 0, 0, 0, 0, 0,
153, 212, 209, 210, 31, 32, 28, 29, 20, 0,
0, 24, 0, 0, 0, 17, 0, 0, 36, 0,
35, 0, 25, 0, 155, 0, 0, 24, 0, 0,
0, 98, 22, 0, 36, 59, 35, 60, 25, 0,
0, 30, 23, 0, 154, 33, 34, 58, 0, 218,
56, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 18,
57, 54, 0, 31, 32, 28, 29, 0, 0, 0,
0, 0, 0, 30, 23, 0, 0, 33, 34, 213,
23, 0, 211, 33, 34, 213, 0, 0, 0, 53,
0, 154, 154, 154, 154, 154, 0, 154, 154, 154,
0, 153, 212, 209, 210, 31, 32, 28, 29, 0,
0, 31, 32, 0, 0, 0, 40, 30, 23, 0,
0, 33, 34, 0, 0, 0, 0, 4, 0, 8,
9, 0, 154, 0, 154, 154, 154, 154, 0, 154,
154, 154, 0, 0, 15, 18, 0, 0, 0, 31,
32, 28, 29, 0, 0, 7, 30, 23, 154, 154,
33, 34, 0, 0, 0, 0, 0, 20, 8, 9,
24, 154, 0, 0, 17, 0, 0, 36, 0, 35,
0, 25, 0, 15, 18, 0, 0, 0, 31, 32,
28, 29, 20, 45, 0, 24, 0, 0, 0, 17,
0, 0, 36, 0, 35, 155, 25, 0, 24, 0,
0, 0, 98, 0, 0, 36, 0, 35, 0, 25,
0, 0, 30, 23, 0, 0, 33, 34, 58, 0,
0, 56, 0, 0, 0, 0, 0, 0, 30, 23,
0, 0, 33, 34, 213, 0, 0, 211, 0, 0,
18, 57, 0, 0, 31, 32, 28, 29, 0, 0,
0, 0, 0, 0, 0, 0, 153, 212, 0, 0,
31, 32, 28, 29, 20, 0, 0, 24, 0, 0,
175, 17, 155, 0, 36, 24, 35, 0, 25, 147,
0, 0, 36, 0, 35, 0, 25, 0, 0, 0,
20, 0, 0, 24, 0, 0, 0, 17, 0, 0,
36, 0, 35, 0, 25, 0, 0, 0, 0, 0,
0, 155, 0, 0, 24, 0, 0, 0, 98, 0,
0, 36, 0, 35, 0, 25, 20, 0, 0, 24,
0, 0, 0, 17, 0, 0, 36, 0, 35, 0,
25, 0, 0, 0, 0, 0, 0, 0, 97, 0,
0, 24, 0, 0, 0, 98, 0, 0, 36, 0,
35, 173, 25, 97, 0, 0, 24, 0, 0, 0,
98, 0, 0, 36, 0, 35, 0, 0, 0, 0,
0, 30, 23, 0, 20, 33, 34, 24, 0, 0,
0, 17, 0, 0, 36, 0, 35, 0, 25, 0,
0, 0, 0, 0, 0, 92, 30, 23, 0, 18,
33, 34, 0, 31, 32, 28, 29, 0, 249, 30,
23, 0, 0, 33, 34, 0, 0, 0, 0, 0,
0, 0, 0, 0, 18, 0, 0, 0, 31, 32,
28, 29, 0, 0, 0, 0, 0, 153, 0, 0,
0, 31, 32, 28, 29, 0, 0, 0, 0, 0,
234, 0, 235, 0, 0, 0, 0, 0, 0, 239,
0, 0, 0, 243, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 227, 30, 23,
0, 0, 33, 34, 261, 151, 30, 23, 69, 0,
33, 34, 0, 0, 267, 0, 0, 44, 44, 44,
0, 0, 0, 0, 30, 23, 18, 0, 33, 34,
31, 32, 28, 29, 153, 0, 0, 0, 31, 32,
28, 29, 0, 278, 3, 30, 23, 0, 0, 33,
34, 283, 18, 43, 43, 43, 31, 32, 28, 29,
30, 200, 0, 293, 33, 34, 296, 0, 0, 0,
0, 0, 0, 153, 137, 0, 300, 31, 32, 28,
29, 0, 30, 23, 44, 44, 33, 34, 18, 0,
0, 44, 31, 32, 28, 29, 0, 30, 23, 0,
42, 33, 34, 0, 0, 0, 0, 0, 0, 0,
47, 49, 0, 0, 31, 32, 28, 29, 0, 23,
43, 43, 33, 34, 0, 0, 0, 43, 0, 31,
32, 28, 29, 0, 0, 0, 0, 0, 0, 0,
0, 0, 137, 0, 0, 0, 0, 0, 0, 0,
31, 32, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 44, 0, 44, 0,
0, 0, 0, 0, 0, 0, 145, 146, 0, 0,
0, 0, 0, 162, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 137, 43, 0, 43, 0, 0, 0, 0, 0,
242, 0, 44, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
44, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 43, 0,
0, 272, 0, 0, 0, 0, 0, 0, 219, 0,
220, 0, 0, 0, 0, 0, 43, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
284, 0, 44, 0, 0, 44, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 244, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 43, 0,
0, 43, 259, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 286, 0, 0, 288 };
int yypact[]={
-253, -1000, 1019, -250, -1000, 980, -1000, -1000, -43, -43,
-40, -1000, -65, 749, 192, -1000, -261, 1279, -5, -1000,
1445, 47, -253, -17, 1460, -1000, -1000, -1000, -1000, 63,
62, -5, -5, -1000, -1000, 1460, 1460, -1000, -1000, -1000,
-1000, -65, -1000, -250, -253, -1000, -65, -1000, -1000, -1000,
-1000, 239, 1387, -274, 1387, 1387, 1387, -219, 1387, 1387,
1387, 1387, 1481, -253, 122, 22, -1000, -1000, -253, -253,
192, -1000, 61, -253, 60, -43, -43, 1369, 1387, 1387,
-1000, -221, 382, 57, -1000, -1000, -248, -1000, -1000, -1000,
10, 619, -1000, 16, -1000, -1000, -24, 1460, 1387, -282,
1460, 1460, 1460, 1460, 1460, 1460, -1000, 1279, -1000, -1000,
-232, 56, 1279, 1279, -1000, -1000, -24, -24, -1000, -1000,
-1000, 122, 788, -5, 1085, 894, 552, -1000, 1481, 1481,
1481, 705, -1000, 22, -1000, -1000, -253, -1000, -1000, -1000,
-1000, 122, 1387, 283, 1423, -1000, -1000, 1279, -38, 43,
936, -1000, -264, -5, -1000, 1445, 47, -43, 788, -43,
1387, -18, -1000, 1387, 55, -1000, -1000, -1000, -1000, -1000,
1387, 1361, 1387, -281, -1000, -1000, -1000, 1460, 619, -24,
-24, -24, -24, 35, 35, 25, 788, 41, 1279, 50,
34, 50, 22, -1000, 1387, -253, -1000, -1000, 619, -263,
-89, 22, 10, -43, 1387, 1387, 1387, 1292, 1408, 1408,
1408, 1408, -224, 1408, 1408, 289, -1000, 16, -1000, -1000,
-1000, -43, 1279, 619, -235, 788, 788, -1000, 788, -225,
47, -1000, -1000, 50, -1000, -1000, -1000, 788, -1000, -253,
53, -228, 1254, -38, -1000, 788, 788, 788, 936, -1000,
936, 1101, 2, 942, -1000, 289, 825, 1408, -1000, -1000,
-8, -253, 50, 6, -1000, -1000, -1000, -1000, 283, 1387,
50, 660, 1387, -43, 1408, 936, -43, 283, -253, -236,
-1000, -1000, 619, -253, 1387, 50, -1000, 936, -1000, -259,
-1000, -1000, -1000, -253, 283, 50, -253, -253, -1000, -1000,
-253, 283, 283, 283, -1000, -1000, -1000 };
int yypgo[]={
0, 160, 159, 420, 0, 157, 156, 104, 502, 107,
154, 153, 105, 98, 151, 150, 149, 216, 66, 75,
68, 140, 139, 48, 63, 1003, 40, 67, 138, 137,
136, 546, 126, 125, 1720, 124, 1400, 686, 41, 64,
32, 121, 1664, 1628, 120, 115, 111, 109 };
int yyr1[]={
0, 5, 6, 6, 6, 6, 32, 7, 33, 7,
7, 7, 7, 7, 7, 7, 29, 29, 29, 30,
30, 35, 1, 2, 11, 11, 41, 25, 12, 12,
19, 19, 19, 19, 34, 34, 20, 20, 20, 20,
20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
20, 44, 20, 20, 20, 28, 28, 21, 21, 42,
42, 31, 31, 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, 47, 9, 9, 9, 9, 9,
9, 9, 9, 9, 9, 10, 10, 10, 24, 24,
13, 13, 13, 13, 37, 38, 36, 39, 39, 43,
40 };
int yyr2[]={
0, 7, 3, 5, 3, 5, 1, 7, 1, 7,
5, 5, 5, 3, 5, 5, 3, 3, 3, 2,
2, 1, 15, 9, 3, 7, 1, 9, 11, 9,
3, 5, 3, 5, 2, 4, 5, 5, 7, 3,
13, 17, 17, 21, 19, 5, 5, 13, 9, 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, 1, 11, 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, -31, -42, 267, -6, -7, 256, 269, 270,
-11, -12, -1, -4, -37, 284, -13, 40, 285, -25,
33, -8, 123, 258, 36, 47, -9, -10, 291, 292,
257, 289, 290, 261, 262, 45, 43, 267, -31, -7,
256, -32, -34, -42, -43, 59, -33, -34, -12, -34,
-2, -37, -40, 124, 287, 288, 266, 286, 263, 60,
62, 63, -4, 44, -19, -38, -20, 256, 125, -43,
-37, -21, 275, 276, 277, 278, 279, -28, 282, 283,
273, 274, -4, 271, 280, 281, -35, 265, 289, 290,
-17, -4, 256, -24, -13, -25, -8, 33, 40, -13,
94, 42, 47, 37, 43, 45, -31, 91, -9, -13,
-41, -47, 40, 40, -13, -13, -8, -8, -12, -31,
-12, -19, -4, 285, -4, -4, -4, 258, -4, -4,
-4, -4, -31, -38, -20, 256, -39, -43, -31, -31,
-38, -19, 40, -31, 40, -34, -34, 40, -16, -15,
-3, 256, -13, 285, -25, 33, -8, -23, -4, -23,
-44, 258, -34, 40, -29, 258, 257, -30, 291, 292,
-45, -40, 256, -36, 41, -36, -26, 60, -4, -8,
-8, -8, -8, -8, -8, -17, -4, 259, 40, -18,
-17, -18, -38, -24, 58, -39, -31, -38, -4, -20,
258, -23, -17, -27, 62, 264, 124, -40, 256, 287,
288, 266, 286, 263, 63, -3, 265, -24, -25, -34,
-34, -23, 91, -4, 40, -4, -4, 256, -4, 286,
-8, 93, 47, -18, -36, -36, -39, -4, -31, -36,
275, 286, -43, -36, -34, -4, -4, -4, -3, 256,
-3, -3, -3, -3, 258, -3, -3, -46, -26, -34,
-17, -36, -22, -14, 258, 256, 258, -36, -31, 40,
258, -4, -43, -27, 58, -3, 93, -31, -36, -40,
256, -20, -4, -36, -43, -23, -34, -3, -34, -20,
-31, 258, 256, -36, -31, -23, -36, 272, -31, -20,
-36, -31, -31, -31, -20, -20, -20 };
int yydef[]={
61, -2, 0, 62, 59, -2, 2, 4, 6, 8,
0, 13, 0, 24, 0, 21, 147, 0, 148, 102,
0, 109, 61, 150, 0, 26, 124, 125, 134, 137,
0, 0, 0, 141, 142, 0, 0, 60, 1, 3,
5, 0, 10, 34, 61, 159, 0, 11, 12, 14,
15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 110, 61, 0, 157, 30, 32, 61, 61,
0, 39, 0, 61, 0, 0, 0, -2, 76, 76,
51, 0, 0, 0, 55, 56, 0, 94, 145, 146,
0, 88, 90, 63, 149, 103, 132, 0, 0, 147,
0, 0, 0, 0, 0, 0, 154, 0, 152, 153,
0, 0, -2, -2, 139, 140, 143, 144, 7, 35,
9, 0, 25, 148, 99, 100, -2, 104, -2, -2,
-2, 0, 160, 157, 31, 33, 61, 158, 155, 36,
37, 0, 0, 0, 76, 45, 46, 0, 65, -2,
80, 82, 147, 148, 116, 0, 122, 0, 77, 0,
76, 0, 54, 0, 0, 16, 17, 18, 19, 20,
0, 0, 91, 0, 156, 133, 98, 0, 0, 126,
127, 128, 129, 130, 131, 0, 88, 0, -2, 0,
-2, 0, 157, 97, 0, 61, 29, 38, 0, 0,
150, 0, 0, 0, 0, 0, 0, 0, 83, 0,
0, 0, 0, 0, 0, 123, 111, 63, 117, 49,
50, 0, 0, 0, -2, 95, 89, 93, 92, 0,
64, 151, 27, 0, 136, 138, 23, 108, 28, 61,
0, 0, 0, 65, 48, 66, 67, 68, 81, 85,
84, 113, 114, -2, 119, -2, 0, 0, 115, 52,
0, 61, 0, -2, 71, 73, 96, 135, 0, 0,
0, 0, 76, 0, 0, 112, 0, 0, 61, 0,
74, 40, 0, 61, 76, 0, 47, 121, 53, 57,
22, 72, 75, 61, 0, 0, 61, 61, 41, 42,
61, 0, 0, 0, 44, 58, 43 };
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",
"func_name : lex_builtin",
"lex_builtin : LEX_BUILTIN",
"lex_builtin : LEX_LENGTH",
"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 opt_nls",
"action : l_brace r_brace opt_semi opt_nls",
"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 opt_exp 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",
"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 137 "awk.y"
{ expression_value = yypvt[-1].nodeval; } break;
case 2:
# line 142 "awk.y"
{
if (yypvt[-0].nodeval != NULL)
yyval.nodeval = yypvt[-0].nodeval;
else
yyval.nodeval = NULL;
yyerrok;
} break;
case 3:
# line 151 "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 165 "awk.y"
{ yyval.nodeval = NULL; } break;
case 5:
# line 166 "awk.y"
{ yyval.nodeval = NULL; } break;
case 6:
# line 170 "awk.y"
{ io_allowed = 0; } break;
case 7:
# line 172 "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 186 "awk.y"
{ io_allowed = 0; } break;
case 9:
# line 188 "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 203 "awk.y"
{
warning("BEGIN blocks must have an action part");
errcount++;
yyerrok;
} break;
case 11:
# line 209 "awk.y"
{
warning("END blocks must have an action part");
errcount++;
yyerrok;
} break;
case 12:
# line 215 "awk.y"
{ yyval.nodeval = node (yypvt[-1].nodeval, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;
case 13:
# line 217 "awk.y"
{ yyval.nodeval = node ((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;
case 14:
# line 219 "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 232 "awk.y"
{
func_install(yypvt[-1].nodeval, yypvt[-0].nodeval);
yyval.nodeval = NULL;
yyerrok;
} break;
case 16:
# line 241 "awk.y"
{ yyval.sval = yypvt[-0].sval; } break;
case 17:
# line 243 "awk.y"
{ yyval.sval = yypvt[-0].sval; } break;
case 18:
# line 245 "awk.y"
{
yyerror("%s() is a built-in function, it cannot be redefined",
tokstart);
errcount++;
/* yyerrok; */
} break;
case 21:
# line 260 "awk.y"
{
param_counter = 0;
} break;
case 22:
# line 264 "awk.y"
{
yyval.nodeval = append_right(make_param(yypvt[-4].sval), yypvt[-2].nodeval);
can_return = 1;
} break;
case 23:
# line 272 "awk.y"
{
yyval.nodeval = yypvt[-2].nodeval;
can_return = 0;
} break;
case 24:
# line 281 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 25:
# line 283 "awk.y"
{ yyval.nodeval = mkrangenode ( node(yypvt[-2].nodeval, Node_cond_pair, yypvt[-0].nodeval) ); } break;
case 26:
# line 292 "awk.y"
{ ++want_regexp; } break;
case 27:
# line 294 "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 28:
# line 310 "awk.y"
{ yyval.nodeval = yypvt[-3].nodeval ; } break;
case 29:
# line 312 "awk.y"
{ yyval.nodeval = NULL; } break;
case 30:
# line 317 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 31:
# line 319 "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 32:
# line 327 "awk.y"
{ yyval.nodeval = NULL; } break;
case 33:
# line 329 "awk.y"
{ yyval.nodeval = NULL; } break;
case 36:
# line 339 "awk.y"
{ yyval.nodeval = NULL; } break;
case 37:
# line 341 "awk.y"
{ yyval.nodeval = NULL; } break;
case 38:
# line 343 "awk.y"
{ yyval.nodeval = yypvt[-1].nodeval; } break;
case 39:
# line 345 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 40:
# line 347 "awk.y"
{ yyval.nodeval = node (yypvt[-3].nodeval, Node_K_while, yypvt[-0].nodeval); } break;
case 41:
# line 349 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_K_do, yypvt[-5].nodeval); } break;
case 42:
# line 351 "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 43:
# line 356 "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 44:
# line 360 "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 45:
# line 366 "awk.y"
{ yyval.nodeval = node ((NODE *)NULL, Node_K_break, (NODE *)NULL); } break;
case 46:
# line 369 "awk.y"
{ yyval.nodeval = node ((NODE *)NULL, Node_K_continue, (NODE *)NULL); } break;
case 47:
# line 371 "awk.y"
{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-5].nodetypeval, yypvt[-1].nodeval); } break;
case 48:
# line 373 "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 49:
# line 384 "awk.y"
{ NODETYPE type;
if (! io_allowed) yyerror("next used in BEGIN or END action");
if (yypvt[-1].nodeval && yypvt[-1].nodeval == lookup("file")) {
if (do_lint)
warning("`next file' is a gawk extension");
else if (strict || do_posix)
yyerror("`next file' is a gawk extension");
type = Node_K_nextfile;
} else type = Node_K_next;
yyval.nodeval = node ((NODE *)NULL, type, (NODE *)NULL);
} break;
case 50:
# line 397 "awk.y"
{ yyval.nodeval = node (yypvt[-1].nodeval, Node_K_exit, (NODE *)NULL); } break;
case 51:
# line 399 "awk.y"
{ if (! can_return) yyerror("return used outside function context"); } break;
case 52:
# line 401 "awk.y"
{ yyval.nodeval = node (yypvt[-1].nodeval, Node_K_return, (NODE *)NULL); } break;
case 53:
# line 403 "awk.y"
{ yyval.nodeval = node (variable(yypvt[-4].sval,1), Node_K_delete, yypvt[-2].nodeval); } break;
case 54:
# line 405 "awk.y"
{ yyval.nodeval = yypvt[-1].nodeval; } break;
case 55:
# line 410 "awk.y"
{ yyval.nodetypeval = yypvt[-0].nodetypeval; } break;
case 56:
# line 412 "awk.y"
{ yyval.nodetypeval = yypvt[-0].nodetypeval; } break;
case 57:
# line 417 "awk.y"
{
yyval.nodeval = node(yypvt[-3].nodeval, Node_K_if,
node(yypvt[-0].nodeval, Node_if_branches, (NODE *)NULL));
} break;
case 58:
# line 423 "awk.y"
{ yyval.nodeval = node (yypvt[-6].nodeval, Node_K_if,
node (yypvt[-3].nodeval, Node_if_branches, yypvt[-0].nodeval)); } break;
case 59:
# line 429 "awk.y"
{ want_assign = 0; } break;
case 63:
# line 440 "awk.y"
{ yyval.nodeval = NULL; } break;
case 64:
# line 442 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_input, (NODE *)NULL); } break;
case 65:
# line 447 "awk.y"
{ yyval.nodeval = NULL; } break;
case 66:
# line 449 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_output, (NODE *)NULL); } break;
case 67:
# line 451 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_append, (NODE *)NULL); } break;
case 68:
# line 453 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_pipe, (NODE *)NULL); } break;
case 69:
# line 458 "awk.y"
{ yyval.nodeval = NULL; } break;
case 70:
# line 460 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 71:
# line 465 "awk.y"
{ yyval.nodeval = make_param(yypvt[-0].sval); } break;
case 72:
# line 467 "awk.y"
{ yyval.nodeval = append_right(yypvt[-2].nodeval, make_param(yypvt[-0].sval)); yyerrok; } break;
case 73:
# line 469 "awk.y"
{ yyval.nodeval = NULL; } break;
case 74:
# line 471 "awk.y"
{ yyval.nodeval = NULL; } break;
case 75:
# line 473 "awk.y"
{ yyval.nodeval = NULL; } break;
case 76:
# line 479 "awk.y"
{ yyval.nodeval = NULL; } break;
case 77:
# line 481 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 78:
# line 486 "awk.y"
{ yyval.nodeval = NULL; } break;
case 79:
# line 488 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 80:
# line 493 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;
case 81:
# line 495 "awk.y"
{
yyval.nodeval = append_right(yypvt[-2].nodeval,
node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));
yyerrok;
} break;
case 82:
# line 501 "awk.y"
{ yyval.nodeval = NULL; } break;
case 83:
# line 503 "awk.y"
{ yyval.nodeval = NULL; } break;
case 84:
# line 505 "awk.y"
{ yyval.nodeval = NULL; } break;
case 85:
# line 507 "awk.y"
{ yyval.nodeval = NULL; } break;
case 86:
# line 512 "awk.y"
{ yyval.nodeval = NULL; } break;
case 87:
# line 514 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 88:
# line 519 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;
case 89:
# line 521 "awk.y"
{
yyval.nodeval = append_right(yypvt[-2].nodeval,
node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));
yyerrok;
} break;
case 90:
# line 527 "awk.y"
{ yyval.nodeval = NULL; } break;
case 91:
# line 529 "awk.y"
{ yyval.nodeval = NULL; } break;
case 92:
# line 531 "awk.y"
{ yyval.nodeval = NULL; } break;
case 93:
# line 533 "awk.y"
{ yyval.nodeval = NULL; } break;
case 94:
# line 538 "awk.y"
{ want_assign = 0; } break;
case 95:
# line 540 "awk.y"
{
if (do_lint && yypvt[-0].nodeval->type == Node_regex)
warning("Regular expression on left of assignment.");
yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval);
} break;
case 96:
# line 546 "awk.y"
{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-3].nodeval); } break;
case 97:
# line 548 "awk.y"
{
yyval.nodeval = node (yypvt[-0].nodeval, Node_K_getline,
node (yypvt[-3].nodeval, Node_redirect_pipein, (NODE *)NULL));
} break;
case 98:
# line 553 "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 99:
# line 559 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;
case 100:
# line 561 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;
case 101:
# line 563 "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 102:
# line 569 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 103:
# line 571 "awk.y"
{
yyval.nodeval = node(node(make_number(0.0),
Node_field_spec,
(NODE *) NULL),
Node_nomatch,
yypvt[-0].nodeval);
} break;
case 104:
# line 579 "awk.y"
{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;
case 105:
# line 581 "awk.y"
{
if (do_lint && yypvt[-0].nodeval->type == Node_regex)
warning("Regular expression on left of comparison.");
yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval);
} break;
case 106:
# line 587 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_less, yypvt[-0].nodeval); } break;
case 107:
# line 589 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_greater, yypvt[-0].nodeval); } break;
case 108:
# line 591 "awk.y"
{ yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;
case 109:
# line 593 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 110:
# line 595 "awk.y"
{ yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;
case 111:
# line 600 "awk.y"
{ want_assign = 0; } break;
case 112:
# line 602 "awk.y"
{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval); } break;
case 113:
# line 604 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;
case 114:
# line 606 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;
case 115:
# line 608 "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 116:
# line 614 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 117:
# line 616 "awk.y"
{ yyval.nodeval = node((NODE *) NULL, Node_nomatch, yypvt[-0].nodeval); } break;
case 118:
# line 618 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, mk_rexp(yypvt[-0].nodeval)); } break;
case 119:
# line 620 "awk.y"
{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;
case 120:
# line 622 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval); } break;
case 121:
# line 624 "awk.y"
{ yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;
case 122:
# line 626 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 123:
# line 628 "awk.y"
{ yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;
case 126:
# line 636 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_exp, yypvt[-0].nodeval); } break;
case 127:
# line 638 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_times, yypvt[-0].nodeval); } break;
case 128:
# line 640 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_quotient, yypvt[-0].nodeval); } break;
case 129:
# line 642 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_mod, yypvt[-0].nodeval); } break;
case 130:
# line 644 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_plus, yypvt[-0].nodeval); } break;
case 131:
# line 646 "awk.y"
{ yyval.nodeval = node (yypvt[-2].nodeval, Node_minus, yypvt[-0].nodeval); } break;
case 132:
# line 651 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_not,(NODE *) NULL); } break;
case 133:
# line 653 "awk.y"
{ yyval.nodeval = yypvt[-1].nodeval; } break;
case 134:
# line 655 "awk.y"
{
if (! io_allowed && strcmp(tokstart, "nextfile") == 0)
yyerror("nextfile() is illegal in BEGIN and END");
} break;
case 135:
# line 660 "awk.y"
{ yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-4].lval); } break;
case 136:
# line 662 "awk.y"
{ yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-3].lval); } break;
case 137:
# line 664 "awk.y"
{
if (do_lint)
warning("call of `length' without parentheses is not portable");
yyval.nodeval = snode ((NODE *)NULL, Node_builtin, (int) yypvt[-0].lval);
if (do_posix)
warning( "call of `length' without parentheses is deprecated by POSIX");
} break;
case 138:
# line 672 "awk.y"
{
yyval.nodeval = node (yypvt[-1].nodeval, Node_func_call, make_string(yypvt[-3].sval, strlen(yypvt[-3].sval)));
} break;
case 139:
# line 676 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_preincrement, (NODE *)NULL); } break;
case 140:
# line 678 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_predecrement, (NODE *)NULL); } break;
case 141:
# line 680 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 142:
# line 682 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 143:
# line 685 "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 144:
# line 692 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 145:
# line 697 "awk.y"
{ yyval.nodeval = node (yypvt[-1].nodeval, Node_postincrement, (NODE *)NULL); } break;
case 146:
# line 699 "awk.y"
{ yyval.nodeval = node (yypvt[-1].nodeval, Node_postdecrement, (NODE *)NULL); } break;
case 148:
# line 705 "awk.y"
{ yyval.nodeval = NULL; } break;
case 149:
# line 707 "awk.y"
{ yyval.nodeval = yypvt[-0].nodeval; } break;
case 150:
# line 712 "awk.y"
{ yyval.nodeval = variable(yypvt[-0].sval,1); } break;
case 151:
# line 714 "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 152:
# line 722 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;
case 153:
# line 724 "awk.y"
{ yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;
case 155:
# line 732 "awk.y"
{ yyerrok; } break;
case 156:
# line 736 "awk.y"
{ yyerrok; } break;
case 159:
# line 745 "awk.y"
{ yyerrok; want_assign = 0; } break;
case 160:
# line 748 "awk.y"
{ yyerrok; } break;
}
goto yystack; /* reset registers in driver code */
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.