diff options
Diffstat (limited to 'awk.tab.c')
| -rw-r--r-- | awk.tab.c | 3050 |
1 files changed, 3050 insertions, 0 deletions
diff --git a/awk.tab.c b/awk.tab.c new file mode 100644 index 00000000..02ef8a21 --- /dev/null +++ b/awk.tab.c @@ -0,0 +1,3050 @@ + +/* A Bison parser, made from awk.y */ + +#define FUNC_CALL 258 +#define NAME 259 +#define REGEXP 260 +#define YSTRING 261 +#define ERROR 262 +#define INCDEC 263 +#define NUMBER 264 +#define RELOP 265 +#define APPEND_OP 266 +#define ASSIGNOP 267 +#define MATCHOP 268 +#define NEWLINE 269 +#define CONCAT_OP 270 +#define LEX_BEGIN 271 +#define LEX_END 272 +#define LEX_IF 273 +#define LEX_ELSE 274 +#define LEX_RETURN 275 +#define LEX_DELETE 276 +#define LEX_WHILE 277 +#define LEX_DO 278 +#define LEX_FOR 279 +#define LEX_BREAK 280 +#define LEX_CONTINUE 281 +#define LEX_PRINT 282 +#define LEX_PRINTF 283 +#define LEX_NEXT 284 +#define LEX_EXIT 285 +#define LEX_FUNCTION 286 +#define LEX_GETLINE 287 +#define LEX_SUB 288 +#define LEX_MATCH 289 +#define LEX_IN 290 +#define LEX_AND 291 +#define LEX_OR 292 +#define INCREMENT 293 +#define DECREMENT 294 +#define LEX_BUILTIN 295 +#define UNARY 296 + +#line 197 "awk.y" + +#ifdef DEBUG +#define YYDEBUG 12 +#endif +#define YYIMPROVE + +#include "awk.h" + +extern void msg(); +extern struct re_pattern_buffer *mk_re_parse(); + +NODE *node(); +NODE *lookup(); +NODE *install(); + +static NODE *snode(); +static NODE *mkrangenode(); +static FILE *pathopen(); +static NODE *make_for_loop(); +static NODE *append_right(); +static void func_install(); +static NODE *make_param(); +static int hashf(); +static void pop_params(); +static void pop_var(); +static int yylex (); +static void yyerror(); + +static int want_regexp; /* lexical scanning kludge */ +static int lineno = 1; /* for error msgs */ +static char *lexptr; /* pointer to next char during parsing */ +static char *lexptr_begin; /* keep track of where we were for error msgs */ +static int curinfile = -1; /* index into sourcefiles[] */ + +NODE *variables[HASHSIZE]; + +extern int errcount; +extern NODE *begin_block; +extern NODE *end_block; +extern int param_counter; + +#line 239 "awk.y" +typedef union { + long lval; + AWKNUM fval; + NODE *nodeval; + NODETYPE nodetypeval; + char *sval; + NODE *(*ptrval)(); +} YYSTYPE; + +#ifndef YYLTYPE +typedef + struct yyltype + { + int timestamp; + int first_line; + int first_column; + int last_line; + int last_column; + char *text; + } + yyltype; + +#define YYLTYPE yyltype +#endif + +#define YYACCEPT return(0) +#define YYABORT return(1) +#define YYERROR goto yyerrlab +#include <stdio.h> + +#ifndef __STDC__ +#define const +#endif + + + +#define YYFINAL 312 +#define YYFLAG -32768 +#define YYNTBASE 63 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 103) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 53, 2, 2, 56, 52, 2, 2, 46, + 47, 50, 48, 62, 49, 2, 51, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 42, 61, 43, + 2, 44, 41, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 57, 2, 58, 55, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 59, 45, 60, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 54 +}; + +static const short yyrline[] = { 0, + 300, 305, 313, 329, 330, 334, 348, 362, 368, 374, + 376, 378, 380, 389, 391, 396, 400, 407, 413, 415, + 417, 419, 421, 423, 428, 430, 435, 448, 450, 461, + 466, 471, 473, 481, 483, 488, 490, 496, 498, 500, + 502, 504, 506, 511, 515, 520, 523, 526, 528, 530, + 532, 534, 536, 538, 543, 545, 550, 555, 562, 564, + 569, 571, 576, 578, 583, 585, 587, 589, 594, 596, + 601, 603, 605, 607, 609, 615, 617, 622, 624, 629, + 631, 637, 639, 641, 643, 648, 650, 655, 657, 663, + 665, 667, 669, 674, 676, 678, 683, 687, 689, 691, + 693, 695, 697, 699, 701, 703, 705, 707, 712, 714, + 716, 718, 722, 724, 726, 728, 730, 732, 734, 739, + 741, 743, 745, 747, 749, 751, 753, 755, 759, 761, + 763, 765, 767, 769, 771, 775, 777, 779, 781, 783, + 785, 787, 789, 794, 796, 801, 803, 805, 810, 814, + 818, 822, 823, 827, 830 +}; + +static const char * const yytname[] = { 0, +"error","$illegal.","FUNC_CALL","NAME","REGEXP","YSTRING","ERROR","INCDEC","NUMBER","RELOP", +"APPEND_OP","ASSIGNOP","MATCHOP","NEWLINE","CONCAT_OP","LEX_BEGIN","LEX_END","LEX_IF","LEX_ELSE","LEX_RETURN", +"LEX_DELETE","LEX_WHILE","LEX_DO","LEX_FOR","LEX_BREAK","LEX_CONTINUE","LEX_PRINT","LEX_PRINTF","LEX_NEXT","LEX_EXIT", +"LEX_FUNCTION","LEX_GETLINE","LEX_SUB","LEX_MATCH","LEX_IN","LEX_AND","LEX_OR","INCREMENT","DECREMENT","LEX_BUILTIN", +"'?'","':'","'<'","'>'","'|'","'('","')'","'+'","'-'","'*'", +"'/'","'%'","'!'","UNARY","'^'","'$'","'['","']'","'{'","'}'", +"';'","','","start" +}; + +static const short yyr1[] = { 0, + 63, 64, 64, 64, 64, 65, 65, 65, 65, 65, + 65, 65, 65, 66, 66, 68, 67, 69, 70, 70, + 70, 70, 70, 70, 71, 71, 72, 74, 73, 75, + 75, 76, 76, 76, 76, 77, 77, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 79, 79, 80, 80, 81, 81, + 82, 82, 83, 83, 84, 84, 84, 84, 85, 85, + 86, 86, 86, 86, 86, 87, 87, 88, 88, 89, + 89, 89, 89, 89, 89, 90, 90, 91, 91, 91, + 91, 91, 91, 92, 92, 92, 92, 92, 92, 92, + 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 94, + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, + 94, 94, 94, 95, 95, 96, 96, 96, 97, 98, + 99, 100, 100, 101, 102 +}; + +static const short yyr2[] = { 0, + 2, 1, 2, 1, 2, 2, 2, 2, 2, 2, + 1, 2, 2, 1, 1, 0, 7, 3, 1, 1, + 3, 3, 2, 3, 1, 3, 1, 0, 4, 3, + 4, 1, 2, 1, 2, 1, 2, 2, 3, 1, + 6, 8, 8, 10, 9, 2, 2, 6, 4, 2, + 3, 3, 6, 2, 1, 1, 6, 9, 1, 2, + 0, 1, 0, 2, 0, 2, 2, 2, 0, 1, + 1, 3, 1, 2, 3, 0, 1, 0, 1, 1, + 3, 1, 2, 3, 3, 0, 1, 1, 3, 1, + 2, 3, 3, 3, 5, 4, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 5, 2, 1, 3, 3, + 3, 3, 3, 3, 3, 3, 5, 2, 1, 2, + 3, 4, 1, 6, 6, 6, 6, 4, 2, 2, + 2, 2, 1, 1, 1, 3, 3, 3, 3, 3, + 3, 2, 2, 0, 1, 1, 4, 2, 2, 2, + 1, 0, 1, 1, 2 +}; + +static const short yydefact[] = { 61, + 59, 62, 0, 60, 4, 0, 146, 135, 134, 0, + 0, 16, 144, 0, 0, 0, 0, 123, 0, 0, + 0, 28, 0, 0, 61, 0, 2, 0, 25, 0, + 20, 27, 11, 19, 108, 133, 0, 0, 0, 154, + 6, 8, 36, 61, 7, 9, 0, 63, 145, 0, + 0, 129, 130, 0, 90, 0, 0, 0, 0, 88, + 0, 143, 133, 142, 0, 23, 120, 148, 149, 5, + 3, 13, 0, 61, 0, 10, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 107, 0, + 0, 0, 0, 0, 0, 0, 131, 132, 34, 0, + 76, 0, 0, 61, 0, 0, 0, 55, 56, 0, + 76, 61, 0, 32, 0, 40, 0, 0, 152, 61, + 0, 0, 88, 0, 37, 15, 14, 0, 0, 97, + 0, 0, 0, 0, 151, 24, 91, 0, 0, 121, + 0, 0, 0, 155, 26, 21, 22, 103, 100, 101, + 102, 98, 99, 0, 104, 105, 144, 140, 141, 137, + 138, 139, 136, 94, 0, 0, 77, 0, 0, 0, + 76, 46, 47, 50, 0, 150, 35, 33, 152, 82, + 144, 0, 65, 0, 80, 119, 133, 54, 0, 30, + 153, 38, 128, 147, 0, 64, 0, 0, 0, 122, + 92, 0, 93, 89, 29, 18, 0, 96, 0, 52, + 0, 0, 0, 146, 0, 51, 31, 63, 0, 0, + 0, 0, 0, 83, 0, 0, 0, 0, 0, 0, + 0, 118, 0, 39, 73, 71, 0, 0, 0, 0, + 0, 0, 95, 106, 61, 0, 61, 0, 0, 0, + 112, 65, 67, 66, 68, 49, 84, 85, 81, 116, + 113, 114, 115, 110, 111, 0, 109, 61, 74, 0, + 124, 125, 126, 127, 0, 0, 0, 0, 0, 0, + 76, 0, 0, 17, 75, 72, 57, 53, 41, 0, + 61, 76, 0, 48, 117, 61, 61, 0, 0, 61, + 0, 42, 43, 61, 0, 58, 0, 45, 44, 0, + 0, 0 +}; + +static const short yydefgoto[] = { 310, + 26, 27, 128, 28, 47, 72, 29, 30, 31, 32, + 65, 33, 113, 42, 114, 115, 116, 2, 3, 130, + 223, 237, 238, 166, 183, 184, 121, 59, 89, 232, + 35, 48, 36, 118, 119, 140, 190, 120, 139 +}; + +static const short yypact[] = { 1, +-32768, 17, 1006,-32768,-32768, -17, 31,-32768,-32768, -5, + -5,-32768, 4, 11, 19, 4, 4, 57, 1085, 1933, + 1933,-32768, 1798, 1933, 1, 809,-32768, 50, 55, -5, + 58,-32768,-32768, 1396, 191, 80, 535, 1126, 1177,-32768, +-32768,-32768, 17, 1,-32768,-32768, 93, 86,-32768, 1701, + 1836,-32768,-32768, 1126,-32768, 1177, 1933, 88, 5, 1300, + 1836, 82, 68, 82, 136,-32768, 82,-32768,-32768,-32768, +-32768,-32768, 663, 1, 1739,-32768,-32768, 1739, 1739, 1836, + 1701, 140, 1836, 1836, 1836, 1836, 1836, 117, 176, 1933, + 1933, 1933, 1933, 1933, 1933, 1836,-32768,-32768,-32768, 110, + 1836, 149, 111, 1, 112, 0, 0,-32768,-32768, 0, + 1836, 1, 602,-32768, 704,-32768, 901, 663, 98, 1, + 88, 24, 1396, 6,-32768,-32768,-32768, 115, 1933,-32768, + 55, 758, 758, 88,-32768,-32768, 1836, 119, 1218,-32768, + 1300, 122, 602,-32768,-32768,-32768,-32768, 1949,-32768, 1193, +-32768, 1533, 1444, 1348, 1949, 1949, 4, 96, 96, 82, + 82, 82, 82, 1396, 1836, 0, 1396, 106, 1836, 860, + 1874,-32768,-32768,-32768, 0,-32768,-32768,-32768, 98,-32768, + 4, 1177, 94, 29, 1581, 191, 104,-32768, 602,-32768, +-32768,-32768,-32768,-32768, 16, 191, 1177, 1177, 1701,-32768, + 1396, 170,-32768, 1396,-32768,-32768, 1836,-32768, 1300,-32768, + 1177, 1300, 153, -13, 98,-32768,-32768, 86, 5, 1933, + 1933, 1933, 0, 1912, 1259, 1912, 1777, 172, 1912, 1912, + 1912, 176, 1912,-32768,-32768,-32768, 88, 40, 5, 5, + 88, 1300,-32768, 1396, 1, 27, 1, 131, 181, 1044, +-32768, 94, 191, 191, 191,-32768, 1581,-32768, 1581, 1997, +-32768, 1060,-32768, 1663, 1622, 1492, 1581, 1,-32768, 38, +-32768,-32768,-32768,-32768, 860, 0, 860, 1836, 88, 955, + 1836, 0, 1912,-32768,-32768,-32768, 173,-32768,-32768, 1300, + 1, 1836, 88,-32768, 1581, 1, 1, 860, 88, 1, + 860,-32768,-32768, 1, 860,-32768, 860,-32768,-32768, 189, + 193,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768, 165,-32768,-32768,-32768,-32768, -29,-32768, 36, -49, +-32768, 8, -52, 15, -44,-32768,-32768, -6, 108, -12, + -43,-32768,-32768, -109,-32768,-32768, 157, -27, -3, 156, + 228, -144, 107, 177, -110, 225, 34, 367, -19 +}; + + +#define YYLAST 2053 + + +static const short yytable[] = { 34, + 131, 175, 179, 43, 43, 137, 137, 7, 1, 75, + 122, 124, 208, 1, 1, 60, 235, 41, 45, 236, + 143, 249, 34, 43, 137, 46, 122, 137, 38, 224, + 4, 149, 206, 117, 123, 123, 218, 76, 285, -79, + 269, 286, -79, 39, 77, 145, 132, 133, 146, 147, + 123, 135, 60, 25, 58, 40, 50, 141, 66, 24, + 40, 215, -69, 194, 51, 189, 74, 74, 178, 117, + -87, 34, -79, -79, 34, 34, 148, 150, 234, 152, + 153, 154, 155, 156, 276, 74, -70, 39, 74, -79, + 74, 96, 164, 78, 79, 126, 127, 167, 178, 43, + 43, 74, 54, 43, 220, 97, 98, 167, 25, 117, + 43, 197, 198, 199, 117, 233, 74, 97, 98, 49, + 172, 173, 52, 53, 174, 213, 63, 63, 129, 63, + 63, 188, 69, 201, 135, 204, 95, 221, 222, 117, + 142, 97, 98, 151, 178, 92, 93, 94, 157, 241, + 95, 125, 168, 202, 219, 165, 169, 171, 40, 43, + 195, 209, 211, 63, 225, 212, 117, 167, 43, 239, + 240, 293, 205, 243, 248, 263, 278, 261, 60, 37, + 210, 144, 299, 246, 279, 117, 37, 37, 311, 216, + 71, 296, 312, 123, 123, 242, 63, 63, 63, 63, + 63, 63, 37, 244, 73, 251, 37, 123, 282, 0, + 134, 170, 217, 16, 17, 0, 43, 0, 270, 176, + 0, 187, 0, 20, 21, 0, 0, 192, 57, 0, + 287, 24, 289, 0, 0, 63, 0, 256, 90, 91, + 92, 93, 94, 0, 0, 95, 280, 62, 64, 0, + 67, 68, 0, 303, 0, 0, 306, 0, 0, 0, + 308, 0, 309, 49, 0, 0, 0, 0, 0, 43, + 185, 117, 0, 117, 290, 43, 0, 167, 0, 0, + 0, 0, 136, 138, 67, 0, 0, 49, 167, 0, + 288, 187, 0, 0, 117, 0, 294, 117, 0, 0, + 0, 117, 0, 117, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 158, 159, 160, + 161, 162, 163, 0, 0, 0, 63, 63, 63, 0, + 187, 187, 187, 187, 0, 187, 187, 187, 187, 187, + 0, 0, 186, 0, 0, 193, 0, 0, 0, 0, + 0, 0, 275, 0, 277, 0, 196, 0, 200, 0, + 0, 0, 0, 187, 0, 187, 187, 0, 187, 0, + 187, 187, 187, 187, 0, 284, 44, 44, 0, 257, + 259, 260, 262, 0, 264, 265, 266, 0, 267, 187, + 0, 0, 0, 0, 0, 0, 44, 0, 298, 0, + 0, 187, 0, 301, 302, 0, 0, 305, 0, 0, + 0, 307, 186, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 245, 0, 0, 247, 0, 295, 0, + 0, 0, 0, 252, 0, 0, 0, 253, 254, 255, + 0, 186, 186, 186, 186, 0, 186, 186, 186, 186, + 186, 268, 0, 271, 272, 273, 274, 0, 0, 0, + 0, 0, 44, 44, 0, 0, 44, 0, 0, 0, + 0, 0, 0, 44, 186, 191, 186, 186, 0, 186, + 0, 186, 186, 186, 186, 0, 0, 0, 0, 0, + 0, 0, 0, 291, 0, 0, 0, 0, 0, 0, + 186, 0, 0, 0, 297, 0, 0, 300, 0, 0, + 0, 0, 186, 304, 0, 0, 0, 0, 0, 0, + 0, 0, 44, 0, 0, 99, 0, 6, 7, 0, + 8, 44, 0, 9, 0, 191, 0, 0, 0, 0, + 0, 0, 100, 0, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 0, 13, 14, 15, 0, + 0, 0, 16, 17, 18, 0, 0, 0, 0, 0, + 56, 250, 20, 21, 0, 0, 0, 57, 0, 44, + 24, 0, 0, 25, 112, 40, 0, 0, 0, 0, + 0, 0, 177, 0, 6, 7, 0, 8, 0, 0, + 9, 0, 0, 0, 0, 0, 281, 0, 0, 100, + 0, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 0, 13, 14, 15, 0, 0, 0, 16, + 17, 18, 44, 0, 0, 0, 292, 56, 44, 20, + 21, 0, 0, 0, 57, 0, 0, 24, 0, 0, + 25, 112, 40, 99, 0, 6, 7, 0, 8, 0, + 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, + 100, 0, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 0, 13, 14, 15, 0, 0, 0, + 16, 17, 18, 0, 180, 0, 6, 7, 56, 8, + 20, 21, 9, 0, -78, 57, 0, -78, 24, 0, + 0, 25, 0, 40, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 181, 14, 15, 0, 0, + 0, 16, 17, 18, 0, 0, 0, -78, -78, 182, + 0, 20, 21, 0, 0, 0, 57, 0, 0, 24, + 6, 7, 0, 8, -78, 0, 9, 80, 0, 0, + 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, + 14, 15, 82, 83, 84, 16, 17, 18, 85, 0, + 86, 87, 88, 56, 0, 20, 21, 0, -1, 70, + 57, 6, 7, 24, 8, 0, 0, 9, 0, 74, + 0, 0, 0, 0, 10, 11, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, + 13, 14, 15, 0, 0, 0, 16, 17, 18, 0, + 0, 0, 0, 0, 19, 0, 20, 21, 0, 22, + 0, 23, 6, 7, 24, 8, 0, 25, 9, 0, + 0, 0, 0, 0, 0, 0, 0, 100, 0, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 0, 13, 14, 15, 0, 0, 0, 16, 17, 18, + 0, 0, 0, 6, 7, 56, 8, 20, 21, 9, + 80, 0, 57, 81, 1, 24, 0, 0, 25, 0, + 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 13, 14, 15, 82, 83, 84, 16, 17, + 18, 85, 0, 86, 87, 88, 56, 0, 20, 21, + 0, 0, 0, 57, 0, 0, 24, 6, 7, 0, + 8, 40, 0, 9, 80, 0, 0, 81, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 13, 14, 15, 82, + 83, 84, 16, 17, 18, 85, 0, 86, 87, 88, + 56, 0, 20, 21, 0, 0, 5, 57, 6, 7, + 24, 8, 0, 0, 9, 40, 0, 0, 0, 0, + 0, 10, 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 12, 13, 14, 15, + 0, 0, 0, 16, 17, 18, 6, 7, 0, 8, + 0, 19, 9, 20, 21, 0, 22, 0, 23, 0, + 0, 24, 0, 7, 25, 8, 0, 0, 0, 226, + 0, 0,-32768, 0, 0, 13, 14, 15, 0, 0, + 0, 16, 17, 18, 0, 55, 0, 6, 7, 56, + 8, 20, 21, 9, 228, 0, 57, 16, 17, 24, + 0, 0, 0, 0, 40, 61, 0, 20, 21, 0, + 0, 0, 57, 0, 0, 24, 13, 14, 15, 0, + 0, 0, 16, 17, 18, 0, 55, 0, 6, 7, + 56, 8, 20, 21, 9, 22, 0, 57, 0, 0, + 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 14, 15, + 0, 0, 0, 16, 17, 18, 0, 0, 0, 0, + 0, 56, -86, 20, 21, 0, 0, 55, 57, 6, + 7, 24, 8, 0, 0, 9, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 8, 0, + 0, 0, 80, 0, 0,-32768, 0, 0, 13, 14, + 15, 0, 0, 0, 16, 17, 18, 0, 203, 0, + 6, 7, 56, 8, 20, 21, 9, 82, 0, 57, + 16, 17, 24, 0, 0, 86, 87, 88, 56, 0, + 20, 21, 0, 0, 0, 57, 0, 0, 24, 13, + 14, 15, 0, 0, 0, 16, 17, 18, 0, 258, + 0, 6, 7, 56, 8, 20, 21, 9, 0, 0, + 57, 0, 0, 24, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 181, 14, 15, 0, 0, 0, 16, 17, 18, 0, + 0, 0, 6, 7, 61, 8, 20, 21, 9, 80, + 0, 57, 81, 0, 24, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 13, 14, 15, 82, 83, 84, 16, 17, 18, + 85, 0, 86, 87, 88, 56, 135, 20, 21, 0, + 6, 7, 57, 8, 0, 24, 9, 80, 0, 0, + 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, + 14, 15, 82, 83, 84, 16, 17, 18, 85, 207, + 86, 87, 88, 56, 0, 20, 21, 0, 6, 7, + 57, 8, 0, 24, 9, 80, 0, 0, 81, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 14, 15, + 82, 83, 84, 16, 17, 18, 85, 0, 86, 87, + 88, 56, 0, 20, 21, 0, 6, 7, 57, 8, + 0, 24, 9, 80, 0, 0, 81, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 13, 14, 15, 82, 83, + 0, 16, 17, 18, 0, 0, 86, 87, 88, 56, + 0, 20, 21, 0, 6, 7, 57, 8, 0, 24, + 9, 226, 0, 0, 227, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 181, 14, 15, 228, 229, 230, 16, + 17, 18, 231, 283, 0, 6, 7, 61, 8, 20, + 21, 9, 80, 0, 57, 81, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 13, 14, 15, 82, 0, 0, + 16, 17, 18, 0, 0, 86, 87, 88, 56, 0, + 20, 21, 0, 6, 7, 57, 8, 0, 24, 9, + 226, 0, 0, 227, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 181, 14, 15, 228, 229, 230, 16, 17, + 18, 231, 0, 0, 6, 7, 61, 8, 20, 21, + 9, 226, 0, 57, 227, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 181, 14, 15, 228, 229, 0, 16, + 17, 18, 0, 0, 0, 6, 7, 61, 8, 20, + 21, 9, 226, 0, 57, 227, 0, 24, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 181, 14, 15, 228, 0, 0, + 16, 17, 18, 6, 7, 0, 8, 0, 61, 9, + 20, 21, 0, 0, 0, 57, 0, 0, 24, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 13, 14, 15, 0, 0, 0, 16, 17, + 18, 6, 7, 0, 8, 0, 56, 9, 20, 21, + 0, 22, 0, 57, 0, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 13, 14, 15, 0, 0, 0, 16, 17, 18, 6, + 7, 0, 8, 0, 19, 9, 20, 21, 0, 22, + 0, 23, 0, 0, 24, 0, 0, 0, 0, 0, + 6, 7, 0, 8, 0, 0, 9, 0, 181, 14, + 15, 0, 0, 0, 16, 17, 18, 0, 0, 0, + 0, 0, 61, 0, 20, 21, 0, 22, 0, 57, + 14, 15, 24, 0, 0, 16, 17, 18, 6, 7, + 0, 8, 0, 61, 9, 20, 21, 0, 22, 0, + 57, 0, 0, 24, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 14, 15, + 0, 0, 0, 16, 17, 18, 6, 214, 0, 8, + 0, 56, 9, 20, 21, 0, 0, 0, 57, 0, + 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 13, 14, 15, 0, 0, + 0, 16, 17, 18, 6, 7, 0, 8, 0, 56, + 9, 20, 21, 0, 0, 0, 57, 0, 0, 24, + 0, 0, 0, 0, 0, 6, 7, 0, 8, 0, + 0, 9, 0, 181, 14, 15, 0, 0, 0, 16, + 17, 18, 7, 0, 8, 0, 0, 61,-32768, 20, + 21, 0, 0, 0, 57, 14, 15, 24, 0, 0, + 16, 17, 18, 0, 0, 0, 0, 0, 61, 0, + 20, 21, 0, 82, 0, 57, 16, 17, 24, 0, + 0,-32768,-32768,-32768, 56, 0, 20, 21, 0, 0, + 7, 57, 8, 0, 24, 0,-32768, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 228, 0, 0, 16, 17, 0, 0, 0, 0, + 0, 0, 61, 0, 20, 21, 0, 0, 0, 57, + 0, 0, 24 +}; + +static const short yycheck[] = { 3, + 50, 111, 113, 10, 11, 1, 1, 4, 14, 29, + 38, 39, 157, 14, 14, 19, 1, 10, 11, 4, + 73, 35, 26, 30, 1, 11, 54, 1, 46, 1, + 14, 81, 143, 37, 38, 39, 181, 30, 1, 11, + 1, 4, 14, 57, 30, 75, 50, 51, 78, 79, + 54, 47, 56, 59, 19, 61, 46, 61, 23, 56, + 61, 171, 47, 58, 46, 118, 62, 62, 113, 73, + 47, 75, 44, 45, 78, 79, 80, 81, 189, 83, + 84, 85, 86, 87, 58, 62, 47, 57, 62, 61, + 62, 12, 96, 36, 37, 3, 4, 101, 143, 106, + 107, 62, 46, 110, 11, 38, 39, 111, 59, 113, + 117, 131, 132, 133, 118, 12, 62, 38, 39, 13, + 106, 107, 16, 17, 110, 170, 20, 21, 43, 23, + 24, 117, 25, 137, 47, 139, 55, 44, 45, 143, + 5, 38, 39, 4, 189, 50, 51, 52, 32, 199, + 55, 44, 4, 35, 182, 46, 46, 46, 61, 166, + 46, 165, 57, 57, 184, 169, 170, 171, 175, 197, + 198, 281, 51, 4, 22, 4, 46, 227, 182, 3, + 166, 74, 292, 211, 4, 189, 10, 11, 0, 175, + 26, 19, 0, 197, 198, 199, 90, 91, 92, 93, + 94, 95, 26, 207, 28, 218, 30, 211, 252, -1, + 54, 104, 179, 38, 39, -1, 223, -1, 238, 112, + -1, 115, -1, 48, 49, -1, -1, 120, 53, -1, + 275, 56, 277, -1, -1, 129, -1, 223, 48, 49, + 50, 51, 52, -1, -1, 55, 250, 20, 21, -1, + 23, 24, -1, 298, -1, -1, 301, -1, -1, -1, + 305, -1, 307, 157, -1, -1, -1, -1, -1, 276, + 115, 275, -1, 277, 278, 282, -1, 281, -1, -1, + -1, -1, 58, 59, 57, -1, -1, 181, 292, -1, + 276, 185, -1, -1, 298, -1, 282, 301, -1, -1, + -1, 305, -1, 307, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 90, 91, 92, + 93, 94, 95, -1, -1, -1, 220, 221, 222, -1, + 224, 225, 226, 227, -1, 229, 230, 231, 232, 233, + -1, -1, 115, -1, -1, 121, -1, -1, -1, -1, + -1, -1, 245, -1, 247, -1, 129, -1, 134, -1, + -1, -1, -1, 257, -1, 259, 260, -1, 262, -1, + 264, 265, 266, 267, -1, 268, 10, 11, -1, 224, + 225, 226, 227, -1, 229, 230, 231, -1, 233, 283, + -1, -1, -1, -1, -1, -1, 30, -1, 291, -1, + -1, 295, -1, 296, 297, -1, -1, 300, -1, -1, + -1, 304, 185, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 209, -1, -1, 212, -1, 283, -1, + -1, -1, -1, 219, -1, -1, -1, 220, 221, 222, + -1, 224, 225, 226, 227, -1, 229, 230, 231, 232, + 233, 237, -1, 239, 240, 241, 242, -1, -1, -1, + -1, -1, 106, 107, -1, -1, 110, -1, -1, -1, + -1, -1, -1, 117, 257, 119, 259, 260, -1, 262, + -1, 264, 265, 266, 267, -1, -1, -1, -1, -1, + -1, -1, -1, 279, -1, -1, -1, -1, -1, -1, + 283, -1, -1, -1, 290, -1, -1, 293, -1, -1, + -1, -1, 295, 299, -1, -1, -1, -1, -1, -1, + -1, -1, 166, -1, -1, 1, -1, 3, 4, -1, + 6, 175, -1, 9, -1, 179, -1, -1, -1, -1, + -1, -1, 18, -1, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, + -1, -1, 38, 39, 40, -1, -1, -1, -1, -1, + 46, 215, 48, 49, -1, -1, -1, 53, -1, 223, + 56, -1, -1, 59, 60, 61, -1, -1, -1, -1, + -1, -1, 1, -1, 3, 4, -1, 6, -1, -1, + 9, -1, -1, -1, -1, -1, 250, -1, -1, 18, + -1, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, -1, 32, 33, 34, -1, -1, -1, 38, + 39, 40, 276, -1, -1, -1, 280, 46, 282, 48, + 49, -1, -1, -1, 53, -1, -1, 56, -1, -1, + 59, 60, 61, 1, -1, 3, 4, -1, 6, -1, + -1, 9, -1, -1, -1, -1, -1, -1, -1, -1, + 18, -1, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, + 38, 39, 40, -1, 1, -1, 3, 4, 46, 6, + 48, 49, 9, -1, 11, 53, -1, 14, 56, -1, + -1, 59, -1, 61, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 32, 33, 34, -1, -1, + -1, 38, 39, 40, -1, -1, -1, 44, 45, 46, + -1, 48, 49, -1, -1, -1, 53, -1, -1, 56, + 3, 4, -1, 6, 61, -1, 9, 10, -1, -1, + 13, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, -1, + 43, 44, 45, 46, -1, 48, 49, -1, 0, 1, + 53, 3, 4, 56, 6, -1, -1, 9, -1, 62, + -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 31, + 32, 33, 34, -1, -1, -1, 38, 39, 40, -1, + -1, -1, -1, -1, 46, -1, 48, 49, -1, 51, + -1, 53, 3, 4, 56, 6, -1, 59, 9, -1, + -1, -1, -1, -1, -1, -1, -1, 18, -1, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + -1, 32, 33, 34, -1, -1, -1, 38, 39, 40, + -1, -1, -1, 3, 4, 46, 6, 48, 49, 9, + 10, -1, 53, 13, 14, 56, -1, -1, 59, -1, + 61, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, -1, 43, 44, 45, 46, -1, 48, 49, + -1, -1, -1, 53, -1, -1, 56, 3, 4, -1, + 6, 61, -1, 9, 10, -1, -1, 13, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, -1, 43, 44, 45, + 46, -1, 48, 49, -1, -1, 1, 53, 3, 4, + 56, 6, -1, -1, 9, 61, -1, -1, -1, -1, + -1, 16, 17, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 31, 32, 33, 34, + -1, -1, -1, 38, 39, 40, 3, 4, -1, 6, + -1, 46, 9, 48, 49, -1, 51, -1, 53, -1, + -1, 56, -1, 4, 59, 6, -1, -1, -1, 10, + -1, -1, 13, -1, -1, 32, 33, 34, -1, -1, + -1, 38, 39, 40, -1, 1, -1, 3, 4, 46, + 6, 48, 49, 9, 35, -1, 53, 38, 39, 56, + -1, -1, -1, -1, 61, 46, -1, 48, 49, -1, + -1, -1, 53, -1, -1, 56, 32, 33, 34, -1, + -1, -1, 38, 39, 40, -1, 1, -1, 3, 4, + 46, 6, 48, 49, 9, 51, -1, 53, -1, -1, + 56, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 32, 33, 34, + -1, -1, -1, 38, 39, 40, -1, -1, -1, -1, + -1, 46, 47, 48, 49, -1, -1, 1, 53, 3, + 4, 56, 6, -1, -1, 9, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 4, -1, 6, -1, + -1, -1, 10, -1, -1, 13, -1, -1, 32, 33, + 34, -1, -1, -1, 38, 39, 40, -1, 1, -1, + 3, 4, 46, 6, 48, 49, 9, 35, -1, 53, + 38, 39, 56, -1, -1, 43, 44, 45, 46, -1, + 48, 49, -1, -1, -1, 53, -1, -1, 56, 32, + 33, 34, -1, -1, -1, 38, 39, 40, -1, 1, + -1, 3, 4, 46, 6, 48, 49, 9, -1, -1, + 53, -1, -1, 56, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 32, 33, 34, -1, -1, -1, 38, 39, 40, -1, + -1, -1, 3, 4, 46, 6, 48, 49, 9, 10, + -1, 53, 13, -1, 56, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, -1, 43, 44, 45, 46, 47, 48, 49, -1, + 3, 4, 53, 6, -1, 56, 9, 10, -1, -1, + 13, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, -1, 48, 49, -1, 3, 4, + 53, 6, -1, 56, 9, 10, -1, -1, 13, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, -1, 43, 44, + 45, 46, -1, 48, 49, -1, 3, 4, 53, 6, + -1, 56, 9, 10, -1, -1, 13, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 32, 33, 34, 35, 36, + -1, 38, 39, 40, -1, -1, 43, 44, 45, 46, + -1, 48, 49, -1, 3, 4, 53, 6, -1, 56, + 9, 10, -1, -1, 13, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, -1, 3, 4, 46, 6, 48, + 49, 9, 10, -1, 53, 13, -1, 56, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 32, 33, 34, 35, -1, -1, + 38, 39, 40, -1, -1, 43, 44, 45, 46, -1, + 48, 49, -1, 3, 4, 53, 6, -1, 56, 9, + 10, -1, -1, 13, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, -1, -1, 3, 4, 46, 6, 48, 49, + 9, 10, -1, 53, 13, -1, 56, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 32, 33, 34, 35, 36, -1, 38, + 39, 40, -1, -1, -1, 3, 4, 46, 6, 48, + 49, 9, 10, -1, 53, 13, -1, 56, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 32, 33, 34, 35, -1, -1, + 38, 39, 40, 3, 4, -1, 6, -1, 46, 9, + 48, 49, -1, -1, -1, 53, -1, -1, 56, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 32, 33, 34, -1, -1, -1, 38, 39, + 40, 3, 4, -1, 6, -1, 46, 9, 48, 49, + -1, 51, -1, 53, -1, -1, 56, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 32, 33, 34, -1, -1, -1, 38, 39, 40, 3, + 4, -1, 6, -1, 46, 9, 48, 49, -1, 51, + -1, 53, -1, -1, 56, -1, -1, -1, -1, -1, + 3, 4, -1, 6, -1, -1, 9, -1, 32, 33, + 34, -1, -1, -1, 38, 39, 40, -1, -1, -1, + -1, -1, 46, -1, 48, 49, -1, 51, -1, 53, + 33, 34, 56, -1, -1, 38, 39, 40, 3, 4, + -1, 6, -1, 46, 9, 48, 49, -1, 51, -1, + 53, -1, -1, 56, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 32, 33, 34, + -1, -1, -1, 38, 39, 40, 3, 4, -1, 6, + -1, 46, 9, 48, 49, -1, -1, -1, 53, -1, + -1, 56, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 32, 33, 34, -1, -1, + -1, 38, 39, 40, 3, 4, -1, 6, -1, 46, + 9, 48, 49, -1, -1, -1, 53, -1, -1, 56, + -1, -1, -1, -1, -1, 3, 4, -1, 6, -1, + -1, 9, -1, 32, 33, 34, -1, -1, -1, 38, + 39, 40, 4, -1, 6, -1, -1, 46, 10, 48, + 49, -1, -1, -1, 53, 33, 34, 56, -1, -1, + 38, 39, 40, -1, -1, -1, -1, -1, 46, -1, + 48, 49, -1, 35, -1, 53, 38, 39, 56, -1, + -1, 43, 44, 45, 46, -1, 48, 49, -1, -1, + 4, 53, 6, -1, 56, -1, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 35, -1, -1, 38, 39, -1, -1, -1, -1, + -1, -1, 46, -1, 48, 49, -1, -1, -1, 53, + -1, -1, 56 +}; +#define YYPURE 1 + +#line 2 "bison.simple" +#ifdef sun +#include <alloca.h> +#endif + +/* Skeleton output parser for bison, + copyright (C) 1984 Bob Corbett and Richard Stallman + + NO WARRANTY + + BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY +NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT +WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, +RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS" +WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY +AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE +DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR +CORRECTION. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. +STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY +WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE +LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR +OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR +DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR +A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS +PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. + + GENERAL PUBLIC LICENSE TO COPY + + 1. You may copy and distribute verbatim copies of this source file +as you receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy a valid copyright notice "Copyright +(C) 1985 Free Software Foundation, Inc."; and include following the +copyright notice a verbatim copy of the above disclaimer of warranty +and of this License. You may charge a distribution fee for the +physical act of transferring a copy. + + 2. You may modify your copy or copies of this source file or +any portion of it, and copy and distribute such modifications under +the terms of Paragraph 1 above, provided that you also do the following: + + a) cause the modified files to carry prominent notices stating + that you changed the files and the date of any change; and + + b) cause the whole of any work that you distribute or publish, + that in whole or in part contains or is a derivative of this + program or any part thereof, to be licensed at no charge to all + third parties on terms identical to those contained in this + License Agreement (except that you may choose to grant more extensive + warranty protection to some or all third parties, at your option). + + c) You may charge a distribution fee for the physical act of + transferring a copy, and you may at your option offer warranty + protection in exchange for a fee. + +Mere aggregation of another unrelated program with this program (or its +derivative) on a volume of a storage or distribution medium does not bring +the other program under the scope of these terms. + + 3. You may copy and distribute this program (or a portion or derivative +of it, under Paragraph 2) in object code or executable form under the terms +of Paragraphs 1 and 2 above provided that you also do one of the following: + + a) accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of + Paragraphs 1 and 2 above; or, + + b) accompany it with a written offer, valid for at least three + years, to give any third party free (except for a nominal + shipping charge) a complete machine-readable copy of the + corresponding source code, to be distributed under the terms of + Paragraphs 1 and 2 above; or, + + c) accompany it with the information you received as to where the + corresponding source code may be obtained. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form alone.) + +For an executable file, complete source code means all the source code for +all modules it contains; but, as a special exception, it need not include +source code for modules which are standard libraries that accompany the +operating system on which the executable file runs. + + 4. You may not copy, sublicense, distribute or transfer this program +except as expressly provided under this License Agreement. Any attempt +otherwise to copy, sublicense, distribute or transfer this program is void and +your rights to use the program under this License agreement shall be +automatically terminated. However, parties who have received computer +software programs from you with this License Agreement will not have +their licenses terminated so long as such parties remain in full compliance. + + 5. If you wish to incorporate parts of this program into other free +programs whose distribution conditions are different, write to the Free +Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet +worked out a simple rule that can be stated here, but we will often permit +this. We will be guided by the two goals of preserving the free status of +all derivatives of our free software and of promoting the sharing and reuse of +software. + + +In other words, you are welcome to use, share and improve this program. +You are forbidden to forbid anyone else to use, share and improve +what you give them. Help stamp out software-hoarding! */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYFAIL goto yyerrlab; + +#define YYTERROR 1 + +#ifndef YYIMPURE +#define YYLEX yylex() +#endif + +#ifndef YYPURE +#define YYLEX yylex(&yylval, &yylloc) +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYIMPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ + +int yynerr; /* number of parse errors so far */ + +#ifdef YYDEBUG +int yydebug = 0; /* nonzero means print parse trace */ +#endif + +#endif /* YYIMPURE */ + + +/* YYMAXDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 200 +#endif + +/* YYMAXLIMIT is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#ifndef YYMAXLIMIT +#define YYMAXLIMIT 10000 +#endif + + +#line 167 "bison.simple" +int +yyparse() +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + YYLTYPE *yylsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYMAXDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */ + YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + YYLTYPE *yyls = yylsa; + + int yymaxdepth = YYMAXDEPTH; + +#ifndef YYPURE + int yychar; + YYSTYPE yylval; + YYLTYPE yylloc; +#endif + +#ifdef YYDEBUG + extern int yydebug; +#endif + + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerr = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. */ + + yyssp = yyss - 1; + yyvsp = yyvs; + yylsp = yyls; + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yymaxdepth - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + YYLTYPE *yyls1 = yyls; + short *yyss1 = yyss; + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yymaxdepth); + + yyss = yyss1; yyvs = yyvs1; yyls = yyls1; +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yymaxdepth >= YYMAXLIMIT) + yyerror("parser stack overflow"); + yymaxdepth *= 2; + if (yymaxdepth > YYMAXLIMIT) + yymaxdepth = YYMAXLIMIT; + yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp)); + bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp)); + yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp)); + bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp)); + bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yymaxdepth); +#endif + + if (yyssp >= yyss + yymaxdepth - 1) + YYABORT; + } + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +yyresume: + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]); +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#ifdef YYDEBUG + if (yydebug) + { + if (yylen == 1) + fprintf (stderr, "Reducing 1 value via line %d, ", + yyrline[yyn]); + else + fprintf (stderr, "Reducing %d values via line %d, ", + yylen, yyrline[yyn]); + } +#endif + + + switch (yyn) { + +case 1: +#line 301 "awk.y" +{ expression_value = yyvsp[0].nodeval; ; + break;} +case 2: +#line 306 "awk.y" +{ + if (yyvsp[0].nodeval != NULL) + yyval.nodeval = yyvsp[0].nodeval; + else + yyval.nodeval = NULL; + yyerrok; + ; + break;} +case 3: +#line 315 "awk.y" +{ + if (yyvsp[0].nodeval == NULL) + yyval.nodeval = yyvsp[-1].nodeval; + else if (yyvsp[-1].nodeval == NULL) + yyval.nodeval = yyvsp[0].nodeval; + else { + if (yyvsp[-1].nodeval->type != Node_rule_list) + yyvsp[-1].nodeval = node(yyvsp[-1].nodeval, Node_rule_list, + (NODE*)NULL); + yyval.nodeval = append_right (yyvsp[-1].nodeval, + node(yyvsp[0].nodeval, Node_rule_list,(NODE *) NULL)); + } + yyerrok; + ; + break;} +case 4: +#line 329 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 5: +#line 330 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 6: +#line 335 "awk.y" +{ + if (begin_block) { + if (begin_block->type != Node_rule_list) + begin_block = node(begin_block, Node_rule_list, + (NODE *)NULL); + append_right (begin_block, node( + node((NODE *)NULL, Node_rule_node, yyvsp[0].nodeval), + Node_rule_list, (NODE *)NULL) ); + } else + begin_block = node((NODE *)NULL, Node_rule_node, yyvsp[0].nodeval); + yyval.nodeval = NULL; + yyerrok; + ; + break;} +case 7: +#line 349 "awk.y" +{ + if (end_block) { + if (end_block->type != Node_rule_list) + end_block = node(end_block, Node_rule_list, + (NODE *)NULL); + append_right (end_block, node( + node((NODE *)NULL, Node_rule_node, yyvsp[0].nodeval), + Node_rule_list, (NODE *)NULL)); + } else + end_block = node((NODE *)NULL, Node_rule_node, yyvsp[0].nodeval); + yyval.nodeval = NULL; + yyerrok; + ; + break;} +case 8: +#line 363 "awk.y" +{ + msg ("error near line %d: BEGIN blocks must have an action part", lineno); + errcount++; + yyerrok; + ; + break;} +case 9: +#line 369 "awk.y" +{ + msg ("error near line %d: END blocks must have an action part", lineno); + errcount++; + yyerrok; + ; + break;} +case 10: +#line 375 "awk.y" +{ yyval.nodeval = node (yyvsp[-1].nodeval, Node_rule_node, yyvsp[0].nodeval); yyerrok; ; + break;} +case 11: +#line 377 "awk.y" +{ yyval.nodeval = node ((NODE *)NULL, Node_rule_node, yyvsp[0].nodeval); yyerrok; ; + break;} +case 12: +#line 379 "awk.y" +{ if(yyvsp[-1].nodeval) yyval.nodeval = node (yyvsp[-1].nodeval, Node_rule_node, (NODE *)NULL); yyerrok; ; + break;} +case 13: +#line 381 "awk.y" +{ + func_install(yyvsp[-1].nodeval, yyvsp[0].nodeval); + yyval.nodeval = NULL; + yyerrok; + ; + break;} +case 14: +#line 390 "awk.y" +{ yyval.sval = yyvsp[0].sval; ; + break;} +case 15: +#line 392 "awk.y" +{ yyval.sval = yyvsp[0].sval; ; + break;} +case 16: +#line 397 "awk.y" +{ + param_counter = 0; + ; + break;} +case 17: +#line 401 "awk.y" +{ + yyval.nodeval = append_right(make_param(yyvsp[-4].sval), yyvsp[-2].nodeval); + ; + break;} +case 18: +#line 408 "awk.y" +{ yyval.nodeval = yyvsp[-1].nodeval; ; + break;} +case 19: +#line 414 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 20: +#line 416 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 21: +#line 418 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_and, yyvsp[0].nodeval); ; + break;} +case 22: +#line 420 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_or, yyvsp[0].nodeval); ; + break;} +case 23: +#line 422 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_not,(NODE *) NULL); ; + break;} +case 24: +#line 424 "awk.y" +{ yyval.nodeval = yyvsp[-1].nodeval; ; + break;} +case 25: +#line 429 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 26: +#line 431 "awk.y" +{ yyval.nodeval = mkrangenode ( node(yyvsp[-2].nodeval, Node_cond_pair, yyvsp[0].nodeval) ); ; + break;} +case 27: +#line 436 "awk.y" +{ + yyval.nodeval = node( + node(make_number((AWKNUM)0),Node_field_spec,(NODE*)NULL), + Node_match, yyvsp[0].nodeval); + ; + break;} +case 28: +#line 449 "awk.y" +{ ++want_regexp; ; + break;} +case 29: +#line 451 "awk.y" +{ + want_regexp = 0; + yyval.nodeval = node((NODE *)NULL,Node_regex,(NODE *)mk_re_parse(yyvsp[-1].sval, 0)); + yyval.nodeval -> re_case = 0; + emalloc (yyval.nodeval -> re_text, char *, strlen(yyvsp[-1].sval)+1, "regexp"); + strcpy (yyval.nodeval -> re_text, yyvsp[-1].sval); + ; + break;} +case 30: +#line 462 "awk.y" +{ + /* empty actions are different from missing actions */ + yyval.nodeval = node ((NODE *) NULL, Node_illegal, (NODE *) NULL); + ; + break;} +case 31: +#line 467 "awk.y" +{ yyval.nodeval = yyvsp[-2].nodeval ; ; + break;} +case 32: +#line 472 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 33: +#line 474 "awk.y" +{ + if (yyvsp[-1].nodeval->type != Node_statement_list) + yyvsp[-1].nodeval = node(yyvsp[-1].nodeval, Node_statement_list,(NODE *)NULL); + yyval.nodeval = append_right(yyvsp[-1].nodeval, + node( yyvsp[0].nodeval, Node_statement_list, (NODE *)NULL)); + yyerrok; + ; + break;} +case 34: +#line 482 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 35: +#line 484 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 36: +#line 489 "awk.y" +{ yyval.nodetypeval = Node_illegal; ; + break;} +case 37: +#line 491 "awk.y" +{ yyval.nodetypeval = Node_illegal; ; + break;} +case 38: +#line 497 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 39: +#line 499 "awk.y" +{ yyval.nodeval = yyvsp[-1].nodeval; ; + break;} +case 40: +#line 501 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 41: +#line 503 "awk.y" +{ yyval.nodeval = node (yyvsp[-3].nodeval, Node_K_while, yyvsp[0].nodeval); ; + break;} +case 42: +#line 505 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_K_do, yyvsp[-5].nodeval); ; + break;} +case 43: +#line 507 "awk.y" +{ + yyval.nodeval = node (yyvsp[0].nodeval, Node_K_arrayfor, make_for_loop(variable(yyvsp[-5].sval), + (NODE *)NULL, variable(yyvsp[-3].sval))); + ; + break;} +case 44: +#line 512 "awk.y" +{ + yyval.nodeval = node(yyvsp[0].nodeval, Node_K_for, (NODE *)make_for_loop(yyvsp[-7].nodeval, yyvsp[-5].nodeval, yyvsp[-3].nodeval)); + ; + break;} +case 45: +#line 516 "awk.y" +{ + yyval.nodeval = node (yyvsp[0].nodeval, Node_K_for, + (NODE *)make_for_loop(yyvsp[-6].nodeval, (NODE *)NULL, yyvsp[-3].nodeval)); + ; + break;} +case 46: +#line 522 "awk.y" +{ yyval.nodeval = node ((NODE *)NULL, Node_K_break, (NODE *)NULL); ; + break;} +case 47: +#line 525 "awk.y" +{ yyval.nodeval = node ((NODE *)NULL, Node_K_continue, (NODE *)NULL); ; + break;} +case 48: +#line 527 "awk.y" +{ yyval.nodeval = node (yyvsp[-3].nodeval, yyvsp[-5].nodetypeval, yyvsp[-1].nodeval); ; + break;} +case 49: +#line 529 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-3].nodetypeval, yyvsp[-1].nodeval); ; + break;} +case 50: +#line 531 "awk.y" +{ yyval.nodeval = node ((NODE *)NULL, Node_K_next, (NODE *)NULL); ; + break;} +case 51: +#line 533 "awk.y" +{ yyval.nodeval = node (yyvsp[-1].nodeval, Node_K_exit, (NODE *)NULL); ; + break;} +case 52: +#line 535 "awk.y" +{ yyval.nodeval = node (yyvsp[-1].nodeval, Node_K_return, (NODE *)NULL); ; + break;} +case 53: +#line 537 "awk.y" +{ yyval.nodeval = node (variable(yyvsp[-4].sval), Node_K_delete, yyvsp[-2].nodeval); ; + break;} +case 54: +#line 539 "awk.y" +{ yyval.nodeval = yyvsp[-1].nodeval; ; + break;} +case 55: +#line 544 "awk.y" +{ yyval.nodetypeval = yyvsp[0].nodetypeval; ; + break;} +case 56: +#line 546 "awk.y" +{ yyval.nodetypeval = yyvsp[0].nodetypeval; ; + break;} +case 57: +#line 551 "awk.y" +{ + yyval.nodeval = node(yyvsp[-3].nodeval, Node_K_if, + node(yyvsp[0].nodeval, Node_if_branches, (NODE *)NULL)); + ; + break;} +case 58: +#line 557 "awk.y" +{ yyval.nodeval = node (yyvsp[-6].nodeval, Node_K_if, + node (yyvsp[-3].nodeval, Node_if_branches, yyvsp[0].nodeval)); ; + break;} +case 59: +#line 563 "awk.y" +{ yyval.nodetypeval = NULL; ; + break;} +case 60: +#line 565 "awk.y" +{ yyval.nodetypeval = NULL; ; + break;} +case 61: +#line 570 "awk.y" +{ yyval.nodetypeval = NULL; ; + break;} +case 62: +#line 572 "awk.y" +{ yyval.nodetypeval = NULL; ; + break;} +case 63: +#line 577 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 64: +#line 579 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_redirect_input, (NODE *)NULL); ; + break;} +case 65: +#line 584 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 66: +#line 586 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_redirect_output, (NODE *)NULL); ; + break;} +case 67: +#line 588 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_redirect_append, (NODE *)NULL); ; + break;} +case 68: +#line 590 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_redirect_pipe, (NODE *)NULL); ; + break;} +case 69: +#line 595 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 70: +#line 597 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 71: +#line 602 "awk.y" +{ yyval.nodeval = make_param(yyvsp[0].sval); ; + break;} +case 72: +#line 604 "awk.y" +{ yyval.nodeval = append_right(yyvsp[-2].nodeval, make_param(yyvsp[0].sval)); yyerrok; ; + break;} +case 73: +#line 606 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 74: +#line 608 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 75: +#line 610 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 76: +#line 616 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 77: +#line 618 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 78: +#line 623 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 79: +#line 625 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 80: +#line 630 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_expression_list, (NODE *)NULL); ; + break;} +case 81: +#line 632 "awk.y" +{ + yyval.nodeval = append_right(yyvsp[-2].nodeval, + node( yyvsp[0].nodeval, Node_expression_list, (NODE *)NULL)); + yyerrok; + ; + break;} +case 82: +#line 638 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 83: +#line 640 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 84: +#line 642 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 85: +#line 644 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 86: +#line 649 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 87: +#line 651 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 88: +#line 656 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_expression_list, (NODE *)NULL); ; + break;} +case 89: +#line 658 "awk.y" +{ + yyval.nodeval = append_right(yyvsp[-2].nodeval, + node( yyvsp[0].nodeval, Node_expression_list, (NODE *)NULL)); + yyerrok; + ; + break;} +case 90: +#line 664 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 91: +#line 666 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 92: +#line 668 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 93: +#line 670 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 94: +#line 675 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 95: +#line 677 "awk.y" +{ yyval.nodeval = node (variable(yyvsp[0].sval), Node_in_array, yyvsp[-3].nodeval); ; + break;} +case 96: +#line 679 "awk.y" +{ + yyval.nodeval = node (yyvsp[0].nodeval, Node_K_getline, + node (yyvsp[-3].nodeval, Node_redirect_pipein, (NODE *)NULL)); + ; + break;} +case 97: +#line 684 "awk.y" +{ + yyval.nodeval = node (yyvsp[-1].nodeval, Node_K_getline, yyvsp[0].nodeval); + ; + break;} +case 98: +#line 688 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_and, yyvsp[0].nodeval); ; + break;} +case 99: +#line 690 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_or, yyvsp[0].nodeval); ; + break;} +case 100: +#line 692 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 101: +#line 694 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 102: +#line 696 "awk.y" +{ yyval.nodeval = node (variable(yyvsp[0].sval), Node_in_array, yyvsp[-2].nodeval); ; + break;} +case 103: +#line 698 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 104: +#line 700 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_less, yyvsp[0].nodeval); ; + break;} +case 105: +#line 702 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_greater, yyvsp[0].nodeval); ; + break;} +case 106: +#line 704 "awk.y" +{ yyval.nodeval = node(yyvsp[-4].nodeval, Node_cond_exp, node(yyvsp[-2].nodeval, Node_if_branches, yyvsp[0].nodeval));; + break;} +case 107: +#line 706 "awk.y" +{ yyval.nodeval = node (yyvsp[-1].nodeval, Node_concat, yyvsp[0].nodeval); ; + break;} +case 108: +#line 708 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 109: +#line 713 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 110: +#line 715 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_and, yyvsp[0].nodeval); ; + break;} +case 111: +#line 717 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_or, yyvsp[0].nodeval); ; + break;} +case 112: +#line 719 "awk.y" +{ + yyval.nodeval = node (yyvsp[-1].nodeval, Node_K_getline, yyvsp[0].nodeval); + ; + break;} +case 113: +#line 723 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 114: +#line 725 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 115: +#line 727 "awk.y" +{ yyval.nodeval = node (variable(yyvsp[0].sval), Node_in_array, yyvsp[-2].nodeval); ; + break;} +case 116: +#line 729 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ; + break;} +case 117: +#line 731 "awk.y" +{ yyval.nodeval = node(yyvsp[-4].nodeval, Node_cond_exp, node(yyvsp[-2].nodeval, Node_if_branches, yyvsp[0].nodeval));; + break;} +case 118: +#line 733 "awk.y" +{ yyval.nodeval = node (yyvsp[-1].nodeval, Node_concat, yyvsp[0].nodeval); ; + break;} +case 119: +#line 735 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 120: +#line 740 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_not,(NODE *) NULL); ; + break;} +case 121: +#line 742 "awk.y" +{ yyval.nodeval = yyvsp[-1].nodeval; ; + break;} +case 122: +#line 744 "awk.y" +{ yyval.nodeval = snode (yyvsp[-1].nodeval, Node_builtin, yyvsp[-3].ptrval); ; + break;} +case 123: +#line 746 "awk.y" +{ yyval.nodeval = snode ((NODE *)NULL, Node_builtin, yyvsp[0].ptrval); ; + break;} +case 124: +#line 748 "awk.y" +{ yyval.nodeval = node(yyvsp[-1].nodeval, yyvsp[-5].nodetypeval, yyvsp[-3].nodeval); ; + break;} +case 125: +#line 750 "awk.y" +{ yyval.nodeval = node(yyvsp[-1].nodeval, yyvsp[-5].nodetypeval, yyvsp[-3].nodeval); ; + break;} +case 126: +#line 752 "awk.y" +{ yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-5].nodetypeval, yyvsp[-1].nodeval); ; + break;} +case 127: +#line 754 "awk.y" +{ yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-5].nodetypeval, yyvsp[-1].nodeval); ; + break;} +case 128: +#line 756 "awk.y" +{ + yyval.nodeval = node (yyvsp[-1].nodeval, Node_func_call, make_string(yyvsp[-3].sval, strlen(yyvsp[-3].sval))); + ; + break;} +case 129: +#line 760 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_preincrement, (NODE *)NULL); ; + break;} +case 130: +#line 762 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_predecrement, (NODE *)NULL); ; + break;} +case 131: +#line 764 "awk.y" +{ yyval.nodeval = node (yyvsp[-1].nodeval, Node_postincrement, (NODE *)NULL); ; + break;} +case 132: +#line 766 "awk.y" +{ yyval.nodeval = node (yyvsp[-1].nodeval, Node_postdecrement, (NODE *)NULL); ; + break;} +case 133: +#line 768 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 134: +#line 770 "awk.y" +{ yyval.nodeval = make_number (yyvsp[0].fval); ; + break;} +case 135: +#line 772 "awk.y" +{ yyval.nodeval = make_string (yyvsp[0].sval, -1); ; + break;} +case 136: +#line 776 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_exp, yyvsp[0].nodeval); ; + break;} +case 137: +#line 778 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_times, yyvsp[0].nodeval); ; + break;} +case 138: +#line 780 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_quotient, yyvsp[0].nodeval); ; + break;} +case 139: +#line 782 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_mod, yyvsp[0].nodeval); ; + break;} +case 140: +#line 784 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_plus, yyvsp[0].nodeval); ; + break;} +case 141: +#line 786 "awk.y" +{ yyval.nodeval = node (yyvsp[-2].nodeval, Node_minus, yyvsp[0].nodeval); ; + break;} +case 142: +#line 788 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_unary_minus, (NODE *)NULL); ; + break;} +case 143: +#line 790 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 144: +#line 795 "awk.y" +{ yyval.nodeval = NULL; ; + break;} +case 145: +#line 797 "awk.y" +{ yyval.nodeval = yyvsp[0].nodeval; ; + break;} +case 146: +#line 802 "awk.y" +{ yyval.nodeval = variable (yyvsp[0].sval); ; + break;} +case 147: +#line 804 "awk.y" +{ yyval.nodeval = node (variable(yyvsp[-3].sval), Node_subscript, yyvsp[-1].nodeval); ; + break;} +case 148: +#line 806 "awk.y" +{ yyval.nodeval = node (yyvsp[0].nodeval, Node_field_spec, (NODE *)NULL); ; + break;} +case 150: +#line 814 "awk.y" +{ yyerrok; ; + break;} +case 151: +#line 818 "awk.y" +{ yyval.nodetypeval = Node_illegal; yyerrok; ; + break;} +case 154: +#line 827 "awk.y" +{ yyerrok; ; + break;} +case 155: +#line 830 "awk.y" +{ yyval.nodetypeval = Node_illegal; yyerrok; ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 408 "bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#ifdef YYDEBUG + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerr; + yyerror("parse error"); + } + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#ifdef YYDEBUG + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#ifdef YYDEBUG + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; +} +#line 833 "awk.y" + + +struct token { + char *operator; /* text to match */ + NODETYPE value; /* node type */ + int class; /* lexical class */ + short nostrict; /* ignore if in strict compatibility mode */ + NODE *(*ptr) (); /* function that implements this keyword */ +}; + +#ifndef NULL +#define NULL 0 +#endif + +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(); + +/* Special functions for debugging */ +#ifdef DEBUG +NODE *do_prvars(), *do_bp(); +#endif + +/* 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, 0, do_atan2 }, +#ifdef DEBUG + { "bp", Node_builtin, LEX_BUILTIN, 0, do_bp }, +#endif + { "break", Node_K_break, LEX_BREAK, 0, 0 }, + { "close", Node_builtin, LEX_BUILTIN, 0, do_close }, + { "continue", Node_K_continue, LEX_CONTINUE, 0, 0 }, + { "cos", Node_builtin, LEX_BUILTIN, 0, do_cos }, + { "delete", Node_K_delete, LEX_DELETE, 0, 0 }, + { "do", Node_K_do, LEX_DO, 0, 0 }, + { "else", Node_illegal, LEX_ELSE, 0, 0 }, + { "exit", Node_K_exit, LEX_EXIT, 0, 0 }, + { "exp", Node_builtin, LEX_BUILTIN, 0, do_exp }, + { "for", Node_K_for, LEX_FOR, 0, 0 }, + { "func", Node_K_function, LEX_FUNCTION, 0, 0 }, + { "function", Node_K_function, LEX_FUNCTION, 0, 0 }, + { "getline", Node_K_getline, LEX_GETLINE, 0, 0 }, + { "gsub", Node_gsub, LEX_SUB, 0, 0 }, + { "if", Node_K_if, LEX_IF, 0, 0 }, + { "in", Node_illegal, LEX_IN, 0, 0 }, + { "index", Node_builtin, LEX_BUILTIN, 0, do_index }, + { "int", Node_builtin, LEX_BUILTIN, 0, do_int }, + { "length", Node_builtin, LEX_BUILTIN, 0, do_length }, + { "log", Node_builtin, LEX_BUILTIN, 0, do_log }, + { "match", Node_K_match, LEX_MATCH, 0, 0 }, + { "next", Node_K_next, LEX_NEXT, 0, 0 }, + { "print", Node_K_print, LEX_PRINT, 0, 0 }, + { "printf", Node_K_printf, LEX_PRINTF, 0, 0 }, +#ifdef DEBUG + { "prvars", Node_builtin, LEX_BUILTIN, 0, do_prvars }, +#endif + { "rand", Node_builtin, LEX_BUILTIN, 0, do_rand }, + { "return", Node_K_return, LEX_RETURN, 0, 0 }, + { "sin", Node_builtin, LEX_BUILTIN, 0, do_sin }, + { "split", Node_builtin, LEX_BUILTIN, 0, do_split }, + { "sprintf", Node_builtin, LEX_BUILTIN, 0, do_sprintf }, + { "sqrt", Node_builtin, LEX_BUILTIN, 0, do_sqrt }, + { "srand", Node_builtin, LEX_BUILTIN, 0, do_srand }, + { "sub", Node_sub, LEX_SUB, 0, 0 }, + { "substr", Node_builtin, LEX_BUILTIN, 0, do_substr }, + { "system", Node_builtin, LEX_BUILTIN, 0, do_system }, + { "tolower", Node_builtin, LEX_BUILTIN, 1, do_tolower }, + { "toupper", Node_builtin, LEX_BUILTIN, 1, do_toupper }, + { "while", Node_K_while, LEX_WHILE, 0, 0 }, +}; + +/* VARARGS0 */ +static void +yyerror(va_alist) +va_dcl +{ + va_list args; + char *mesg; + char *a1; + register char *ptr, *beg; + static int list = 0; + char *scan; + + errcount++; + va_start(args); + mesg = va_arg(args, char *); + if (! list) + a1 = va_arg(args, char *); + va_end(args); + if (mesg || !list) { + /* Find the current line in the input file */ + if (!lexptr) { + beg = "(END OF FILE)"; + ptr = beg + 13; + } else { + if (*lexptr == '\n' && lexptr != lexptr_begin) + --lexptr; + for (beg = lexptr; beg != lexptr_begin && *beg != '\n'; --beg) + ; + /* NL isn't guaranteed */ + for (ptr = lexptr; *ptr && *ptr != '\n'; ptr++) + ; + if (beg != lexptr_begin) + beg++; + } + msg("syntax error near line %d:\n%.*s", lineno, ptr - beg, beg); + scan = beg; + while (scan <= lexptr) + if (*scan++ == '\t') + putc('\t', stderr); + else + putc(' ', stderr); + putc('^', stderr); + putc(' ', stderr); + if (mesg) { + vfprintf(stderr, mesg, args); + putc('\n', stderr); + exit(1); + } else { + if (a1) { + fputs("expecting: ", stderr); + fputs(a1, stderr); + list = 1; + return; + } + } + return; + } + if (a1) { + fputs(" or ", stderr); + fputs(a1, stderr); + putc('\n', stderr); + return; + } + putc('\n', stderr); + list = 0; +} + +/* + * Parse a C escape sequence. STRING_PTR points to a variable containing a + * pointer to the string to parse. That pointer is updated past the + * characters we use. The value of the escape sequence is returned. + * + * A negative value means the sequence \ newline was seen, which is supposed to + * be equivalent to nothing at all. + * + * If \ is followed by a null character, we return a negative value and leave + * the string pointer pointing at the null character. + * + * If \ is followed by 000, we return 0 and leave the string pointer after the + * zeros. A value of 0 does not mean end of string. + */ + +static int +parse_escape(string_ptr) +char **string_ptr; +{ + register int c = *(*string_ptr)++; + register int i; + + switch (c) { + case 'a': + if (strict) + goto def; + else + return BELL; + case 'b': + return '\b'; + case 'f': + return '\f'; + case 'n': + return '\n'; + case 'r': + return '\r'; + case 't': + return '\t'; + case 'v': + if (strict) + goto def; + else + return '\v'; + case '\n': + return -2; + case 0: + (*string_ptr)--; + return 0; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + register int i = c - '0'; + register int count = 0; + + while (++count < 3) { + if ((c = *(*string_ptr)++) >= '0' && c <= '7') { + i *= 8; + i += c - '0'; + } else { + (*string_ptr)--; + break; + } + } + return i; + } + case 'x': + if (strict) + goto def; + + i = 0; + while (1) { + if (isxdigit((c = *(*string_ptr)++))) { + if (isdigit(c)) + i += c - '0'; + else if (isupper(c)) + i += c - 'A' + 10; + else + i += c - 'a' + 10; + } else { + (*string_ptr)--; + break; + } + } + return i; + default: + def: + return c; + } +} + +/* + * Read the input and turn it into tokens. Input is now read from a file + * instead of from malloc'ed memory. The main program takes a program + * passed as a command line argument and writes it to a temp file. Otherwise + * the file name is made available in an external variable. + */ + +static int +yylex() +{ + register int c; + register int namelen; + register char *tokstart; + char *tokkey; + static did_newline = 0; /* the grammar insists that actions end + * with newlines. This was easier than + * hacking the grammar. */ + int seen_e = 0; /* These are for numbers */ + int seen_point = 0; + extern char **sourcefile; + extern int tempsource, numfiles; + static int file_opened = 0; + static FILE *fin; + static char cbuf[BUFSIZ]; + int low, mid, high; +#ifdef DEBUG + extern int debugging; +#endif + + if (! file_opened) { + file_opened = 1; +#ifdef DEBUG + if (debugging) { + int i; + + for (i = 0; i <= numfiles; i++) + fprintf (stderr, "sourcefile[%d] = %s\n", i, + sourcefile[i]); + } +#endif + nextfile: + if ((fin = pathopen (sourcefile[++curinfile])) == NULL) + fatal("cannot open `%s' for reading (%s)", + sourcefile[curinfile], + sys_errlist[errno]); + *(lexptr = cbuf) = '\0'; + /* + * immediately unlink the tempfile so that it will + * go away cleanly if we bomb. + */ + if (tempsource && curinfile == 0) + (void) unlink (sourcefile[curinfile]); + } + +retry: + if (! *lexptr) + if (fgets (cbuf, sizeof cbuf, fin) == NULL) { + if (fin != NULL) + fclose (fin); /* be neat and clean */ + if (curinfile < numfiles) + goto nextfile; + return 0; + } else + lexptr = lexptr_begin = cbuf; + + if (want_regexp) { + want_regexp = 0; + + /* + * there is a potential bug if a regexp is followed by an + * equal sign: "/foo/=bar" would result in assign_quotient + * being returned as the next token. Nothing is done about + * it since it is not valid awk, but maybe something should + * be done anyway. + */ + + tokstart = lexptr; + while (c = *lexptr++) { + switch (c) { + case '\\': + if (*lexptr++ == '\0') { + yyerror("unterminated regexp ends with \\"); + return ERROR; + } else if (lexptr[-1] == '\n') + goto retry; + break; + case '/': /* end of the regexp */ + lexptr--; + yylval.sval = tokstart; + return REGEXP; + case '\n': + lineno++; + case '\0': + lexptr--; /* so error messages work */ + yyerror("unterminated regexp"); + return ERROR; + } + } + } + + if (*lexptr == '\n') { + lexptr++; + lineno++; + return NEWLINE; + } + + while (*lexptr == ' ' || *lexptr == '\t') + lexptr++; + + tokstart = lexptr; + + switch (c = *lexptr++) { + case 0: + return 0; + + case '\n': + lineno++; + return NEWLINE; + + case '#': /* it's a comment */ + while (*lexptr != '\n' && *lexptr != '\0') + lexptr++; + goto retry; + + case '\\': + if (*lexptr == '\n') { + lineno++; + lexptr++; + goto retry; + } else + break; + case ')': + case ']': + case '(': + case '[': + case '$': + case ';': + case ':': + case '?': + + /* + * set node type to ILLEGAL because the action should set it + * to the right thing + */ + yylval.nodetypeval = Node_illegal; + return c; + + case '{': + case ',': + yylval.nodetypeval = Node_illegal; + return c; + + case '*': + if (*lexptr == '=') { + yylval.nodetypeval = Node_assign_times; + lexptr++; + return ASSIGNOP; + } else if (*lexptr == '*') { /* make ** and **= aliases + * for ^ and ^= */ + if (lexptr[1] == '=') { + yylval.nodetypeval = Node_assign_exp; + lexptr += 2; + return ASSIGNOP; + } else { + yylval.nodetypeval = Node_illegal; + lexptr++; + return '^'; + } + } + yylval.nodetypeval = Node_illegal; + return c; + + case '/': + if (*lexptr == '=') { + yylval.nodetypeval = Node_assign_quotient; + lexptr++; + return ASSIGNOP; + } + yylval.nodetypeval = Node_illegal; + return c; + + case '%': + if (*lexptr == '=') { + yylval.nodetypeval = Node_assign_mod; + lexptr++; + return ASSIGNOP; + } + yylval.nodetypeval = Node_illegal; + return c; + + case '^': + if (*lexptr == '=') { + yylval.nodetypeval = Node_assign_exp; + lexptr++; + return ASSIGNOP; + } + yylval.nodetypeval = Node_illegal; + return c; + + case '+': + if (*lexptr == '=') { + yylval.nodetypeval = Node_assign_plus; + lexptr++; + return ASSIGNOP; + } + if (*lexptr == '+') { + yylval.nodetypeval = Node_illegal; + lexptr++; + return INCREMENT; + } + yylval.nodetypeval = Node_illegal; + return c; + + case '!': + if (*lexptr == '=') { + yylval.nodetypeval = Node_notequal; + lexptr++; + return RELOP; + } + if (*lexptr == '~') { + yylval.nodetypeval = Node_nomatch; + lexptr++; + return MATCHOP; + } + yylval.nodetypeval = Node_illegal; + return c; + + case '<': + if (*lexptr == '=') { + yylval.nodetypeval = Node_leq; + lexptr++; + return RELOP; + } + yylval.nodetypeval = Node_less; + return c; + + case '=': + if (*lexptr == '=') { + yylval.nodetypeval = Node_equal; + lexptr++; + return RELOP; + } + yylval.nodetypeval = Node_assign; + return ASSIGNOP; + + case '>': + if (*lexptr == '=') { + yylval.nodetypeval = Node_geq; + lexptr++; + return RELOP; + } else if (*lexptr == '>') { + yylval.nodetypeval = Node_redirect_append; + lexptr++; + return APPEND_OP; + } + yylval.nodetypeval = Node_greater; + return c; + + case '~': + yylval.nodetypeval = Node_match; + return MATCHOP; + + case '}': + /* + * Added did newline stuff. Easier than + * hacking the grammar + */ + if (did_newline) { + did_newline = 0; + return c; + } + did_newline++; + --lexptr; + return NEWLINE; + + case '"': + while (*lexptr != '\0') { + switch (*lexptr++) { + case '\\': + if (*lexptr++ != '\0') + break; + /* fall through */ + case '\n': + yyerror("unterminated string"); + return ERROR; + case '\"': + /* Skip the doublequote */ + yylval.sval = tokstart + 1; + return YSTRING; + } + } + return ERROR; + + case '-': + if (*lexptr == '=') { + yylval.nodetypeval = Node_assign_minus; + lexptr++; + return ASSIGNOP; + } + if (*lexptr == '-') { + yylval.nodetypeval = Node_illegal; + lexptr++; + return DECREMENT; + } + + /* + * It looks like space tab comma and newline are the legal + * places for a UMINUS. Have we missed any? + */ + if ((! isdigit(*lexptr) && *lexptr != '.') || + (lexptr > lexptr_begin + 1 && + ! index(" \t,\n", lexptr[-2]))) { + + /* + * set node type to ILLEGAL because the action should + * set it to the right thing + */ + yylval.nodetypeval = Node_illegal; + return c; + } + /* FALL through into number code */ + 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 */ + if (c == '-') + namelen = 1; + else + namelen = 0; + for (; (c = tokstart[namelen]) != '\0'; namelen++) { + switch (c) { + case '.': + if (seen_point) + goto got_number; + ++seen_point; + break; + case 'e': + case 'E': + if (seen_e) + goto got_number; + ++seen_e; + if (tokstart[namelen + 1] == '-' || + tokstart[namelen + 1] == '+') + namelen++; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + break; + default: + goto got_number; + } + } + +got_number: + lexptr = tokstart + namelen; + yylval.fval = atof(tokstart); + return NUMBER; + + case '&': + if (*lexptr == '&') { + yylval.nodetypeval = Node_and; + while (c = *++lexptr) { + if (c == '#') + while ((c = *++lexptr) != '\n' + && c != '\0') + ; + if (c == '\n') + lineno++; + else if (!isspace(c)) + break; + } + return LEX_AND; + } + return ERROR; + + case '|': + if (*lexptr == '|') { + yylval.nodetypeval = Node_or; + while (c = *++lexptr) { + if (c == '#') + while ((c = *++lexptr) != '\n' + && c != '\0') + ; + if (c == '\n') + lineno++; + else if (!isspace(c)) + break; + } + return LEX_OR; + } + yylval.nodetypeval = Node_illegal; + return c; + } + + if (c != '_' && !isalpha(c)) { + yyerror("Invalid char '%c' in expression\n", c); + return ERROR; + } + + /* it's some type of name-type-thing. Find its length */ + for (namelen = 0; is_identchar(tokstart[namelen]); namelen++) + /* null */ ; + emalloc(tokkey, char *, namelen+1, "yylex"); + (void) strncpy (tokkey, tokstart, namelen); + tokkey[namelen] = '\0'; + + /* 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; + + compare: + c = *tokstart - tokentab[mid].operator[0]; + i = c ? c : strcmp (tokkey, tokentab[mid].operator); + + if (i < 0) { /* token < mid */ + high = mid - 1; + } else if (i > 0) { /* token > mid */ + low = mid + 1; + } else { + lexptr = tokstart + namelen; + if (strict && tokentab[mid].nostrict) + break; + if (tokentab[mid].class == LEX_BUILTIN) + yylval.ptrval = tokentab[mid].ptr; + else + yylval.nodetypeval = tokentab[mid].value; + return tokentab[mid].class; + } + } + + /* It's a name. See how long it is. */ + yylval.sval = tokkey; + lexptr = tokstart + namelen; + if (*lexptr == '(') + return FUNC_CALL; + else + return NAME; +} + +#ifndef DEFPATH +#ifdef MSDOS +#define DEFPATH "." +#define ENVSEP ';' +#else +#define DEFPATH ".:/usr/lib/awk:/usr/local/lib/awk" +#define ENVSEP ':' +#endif +#endif + +static FILE * +pathopen (file) +char *file; +{ + static char *savepath = DEFPATH; + static int first = 1; + char *awkpath, *cp; + char trypath[BUFSIZ]; + FILE *fp; + extern int debugging; + + if (strcmp (file, "-") == 0) + return (stdin); + + if (strict) + return (fopen (file, "r")); + + if (first) { + first = 0; + if ((awkpath = getenv ("AWKPATH")) != NULL && *awkpath) + savepath = awkpath; /* used for restarting */ +#ifdef MSDOS + else if ((awkpath = getenv ("INIT")) != NULL && *awkpath) + savepath = awkpath; /* MSC 5.1 users may prefer */ + /* to use INIT */ +#endif + } + awkpath = savepath; + + /* some kind of path name, no search */ +#ifndef MSDOS + if (index (file, '/') != NULL) +#else + if (index (file, '/') != NULL || index (file, '\\') != NULL + || index (file, ':') != NULL) +#endif + return (fdopen(devopen (file, "r"), "r")); + + do { + /* this should take into account limits on size of trypath */ + for (cp = trypath; *awkpath && *awkpath != ENVSEP; ) + *cp++ = *awkpath++; + *cp++ = '/'; + *cp = '\0'; /* clear left over junk */ + strcat (cp, file); + if ((fp = fdopen(devopen (trypath, "r"), "r")) != NULL) + return (fp); + + /* no luck, keep going */ + awkpath++; /* skip colon */ + } while (*awkpath); + return (NULL); +} + +static NODE * +node_common(op) +NODETYPE op; +{ + register NODE *r; + extern int numfiles; + extern int tempsource; + extern char **sourcefile; + + r = newnode(op); + r->source_line = lineno; + if (numfiles > 1 && !tempsource) + r->source_file = sourcefile[curinfile]; + else + r->source_file = NULL; + return r; +} + +/* + * This allocates a node with defined lnode and rnode. + * This should only be used by yyparse+co while reading in the program + */ +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 + * Otherwise like node() + */ +static NODE * +snode(subn, op, procp) +NODETYPE op; +NODE *(*procp) (); +NODE *subn; +{ + register NODE *r; + + r = node_common(op); + r->subnode = subn; + r->proc = procp; + 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; + + r = newnode(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"); + n = newnode(Node_illegal); + r->init = init; + r->cond = cond; + r->incr = incr; + n->sub.nodep.r.hd = r; + return n; +} + +/* + * Install a name in the hash table specified, even if it is already there. + * Name stops with first non alphanumeric. Caller must check against + * redefinition if that is desired. + */ +NODE * +install(table, name, value) +NODE **table; +char *name; +NODE *value; +{ + register NODE *hp; + register int len, bucket; + register char *p; + + len = 0; + p = name; + while (is_identchar(*p)) + p++; + len = p - name; + + hp = newnode(Node_hashnode); + bucket = hashf(name, len, HASHSIZE); + hp->hnext = table[bucket]; + table[bucket] = hp; + hp->hlength = len; + hp->hvalue = value; + emalloc(hp->hname, char *, len + 1, "install"); + bcopy(name, hp->hname, len); + hp->hname[len] = '\0'; + hp->hvalue->varname = hp->hname; + return hp->hvalue; +} + +/* + * find the most recent hash node for name name (ending with first + * non-identifier char) installed by install + */ +NODE * +lookup(table, name) +NODE **table; +char *name; +{ + register char *bp; + register NODE *bucket; + register int len; + + for (bp = name; is_identchar(*bp); bp++) + ; + len = bp - name; + bucket = table[hashf(name, len, HASHSIZE)]; + while (bucket) { + if (bucket->hlength == len && STREQN(bucket->hname, name, len)) + return bucket->hvalue; + bucket = bucket->hnext; + } + return NULL; +} + +#define HASHSTEP(old, c) ((old << 1) + c) +#define MAKE_POS(v) (v & ~0x80000000) /* make number positive */ + +/* + * return hash function on name. + */ +static int +hashf(name, len, hashsize) +register char *name; +register int len; +int hashsize; +{ + register int r = 0; + + while (len--) + r = HASHSTEP(r, *name++); + + r = MAKE_POS(r) % hashsize; + return r; +} + +/* + * Add new to the rightmost branch of LIST. This uses n^2 time, but doesn't + * get used enough to make optimizing worth it. . . + */ +/* You don't believe me? Profile it yourself! */ +static NODE * +append_right(list, new) +NODE *list, *new; + +{ + register NODE *oldlist; + + oldlist = list; + while (list->rnode != NULL) + list = list->rnode; + 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(variables, params->param); + if (r != NULL) { + fatal("function name `%s' previously defined", params->param); + } else + (void) install(variables, params->param, + node(params, Node_func, def)); +} + +static void +pop_var(np, freeit) +NODE *np; +int freeit; +{ + register char *bp; + register NODE *bucket, **save; + register int len; + char *name; + + name = np->param; + for (bp = name; is_identchar(*bp); bp++) + ; + len = bp - name; + save = &(variables[hashf(name, len, HASHSIZE)]); + for (bucket = *save; bucket; bucket = bucket->hnext) { + if (len == bucket->hlength && STREQN(bucket->hname, name, len)) { + *save = bucket->hnext; + freenode(bucket); + free(bucket->hname); + 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; + + r = newnode(Node_param_list); + r->param = name; + r->rnode = NULL; + r->param_cnt = param_counter++; + return (install(variables, name, r)); +} + +/* Name points to a variable name. Make sure its in the symbol table */ +NODE * +variable(name) +char *name; +{ + register NODE *r; + + if ((r = lookup(variables, name)) == NULL) + r = install(variables, name, + node(Nnull_string, Node_var, (NODE *) NULL)); + return r; +} |