home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / gnuawk.zip / awktab.c < prev    next >
C/C++ Source or Header  |  1997-05-11  |  120KB  |  3,935 lines
  1.  
  2. /*  A Bison parser, made from ./awk.y
  3.  by  GNU Bison version 1.25
  4.   */
  5.  
  6. #define YYBISON 1  /* Identify Bison output.  */
  7.  
  8. #define    FUNC_CALL    258
  9. #define    NAME    259
  10. #define    REGEXP    260
  11. #define    ERROR    261
  12. #define    YNUMBER    262
  13. #define    YSTRING    263
  14. #define    RELOP    264
  15. #define    APPEND_OP    265
  16. #define    ASSIGNOP    266
  17. #define    MATCHOP    267
  18. #define    NEWLINE    268
  19. #define    CONCAT_OP    269
  20. #define    LEX_BEGIN    270
  21. #define    LEX_END    271
  22. #define    LEX_IF    272
  23. #define    LEX_ELSE    273
  24. #define    LEX_RETURN    274
  25. #define    LEX_DELETE    275
  26. #define    LEX_WHILE    276
  27. #define    LEX_DO    277
  28. #define    LEX_FOR    278
  29. #define    LEX_BREAK    279
  30. #define    LEX_CONTINUE    280
  31. #define    LEX_PRINT    281
  32. #define    LEX_PRINTF    282
  33. #define    LEX_NEXT    283
  34. #define    LEX_EXIT    284
  35. #define    LEX_FUNCTION    285
  36. #define    LEX_GETLINE    286
  37. #define    LEX_NEXTFILE    287
  38. #define    LEX_IN    288
  39. #define    LEX_AND    289
  40. #define    LEX_OR    290
  41. #define    INCREMENT    291
  42. #define    DECREMENT    292
  43. #define    LEX_BUILTIN    293
  44. #define    LEX_LENGTH    294
  45. #define    UNARY    295
  46.  
  47. #line 26 "./awk.y"
  48.  
  49. #ifdef DEBUG
  50. #define YYDEBUG 12
  51. #endif
  52.  
  53. #include "awk.h"
  54.  
  55. #define CAN_FREE    TRUE
  56. #define DONT_FREE    FALSE
  57.  
  58. #if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
  59. static void yyerror(const char *m, ...) ;
  60. #else
  61. static void yyerror(); /* va_alist */
  62. #endif
  63. static char *get_src_buf P((void));
  64. static int yylex P((void));
  65. static NODE *node_common P((NODETYPE op));
  66. static NODE *snode P((NODE *subn, NODETYPE op, int sindex));
  67. static NODE *mkrangenode P((NODE *cpair));
  68. static NODE *make_for_loop P((NODE *init, NODE *cond, NODE *incr));
  69. static NODE *append_right P((NODE *list, NODE *new));
  70. static void func_install P((NODE *params, NODE *def));
  71. static void pop_var P((NODE *np, int freeit));
  72. static void pop_params P((NODE *params));
  73. static NODE *make_param P((char *name));
  74. static NODE *mk_rexp P((NODE *exp));
  75. static int dup_parms P((NODE *func));
  76. static void param_sanity P((NODE *arglist));
  77. static int isnoeffect P((NODETYPE t));
  78. static int isassignable P((NODE *n));
  79.  
  80. enum defref { FUNC_DEFINE, FUNC_USE };
  81. static void func_use P((char *name, enum defref how));
  82. static void check_funcs P((void));
  83.  
  84. static int want_assign;        /* lexical scanning kludge */
  85. static int want_regexp;        /* lexical scanning kludge */
  86. static int can_return;        /* lexical scanning kludge */
  87. static int io_allowed = TRUE;    /* lexical scanning kludge */
  88. static char *lexptr;        /* pointer to next char during parsing */
  89. static char *lexend;
  90. static char *lexptr_begin;    /* keep track of where we were for error msgs */
  91. static char *lexeme;        /* beginning of lexeme for debugging */
  92. static char *thisline = NULL;
  93. #define YYDEBUG_LEXER_TEXT (lexeme)
  94. static int param_counter;
  95. static char *tokstart = NULL;
  96. static char *tok = NULL;
  97. static char *tokend;
  98.  
  99. #define HASHSIZE    1021    /* this constant only used here */
  100. NODE *variables[HASHSIZE];
  101.  
  102. extern char *source;
  103. extern int sourceline;
  104. extern struct src *srcfiles;
  105. extern int numfiles;
  106. extern int errcount;
  107. extern NODE *begin_block;
  108. extern NODE *end_block;
  109.  
  110. #line 89 "./awk.y"
  111. typedef union {
  112.     long lval;
  113.     AWKNUM fval;
  114.     NODE *nodeval;
  115.     NODETYPE nodetypeval;
  116.     char *sval;
  117.     NODE *(*ptrval)();
  118. } YYSTYPE;
  119. #include <stdio.h>
  120.  
  121. #ifndef __cplusplus
  122. #ifndef __STDC__
  123. #define const
  124. #endif
  125. #endif
  126.  
  127.  
  128.  
  129. #define    YYFINAL        312
  130. #define    YYFLAG        -32768
  131. #define    YYNTBASE    62
  132.  
  133. #define YYTRANSLATE(x) ((unsigned)(x) <= 295 ? yytranslate[x] : 107)
  134.  
  135. static const char yytranslate[] = {     0,
  136.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  137.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  138.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  139.      2,     2,    51,     2,     2,    54,    50,     2,     2,    55,
  140.     56,    48,    46,    42,    47,     2,    49,     2,     2,     2,
  141.      2,     2,     2,     2,     2,     2,     2,    41,    61,    43,
  142.      2,    44,    40,     2,     2,     2,     2,     2,     2,     2,
  143.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  144.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  145.     57,     2,    58,    53,     2,     2,     2,     2,     2,     2,
  146.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  147.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  148.      2,     2,    59,    45,    60,     2,     2,     2,     2,     2,
  149.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  150.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  151.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  152.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  153.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  154.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  155.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  156.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  157.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  158.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  159.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  160.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  161.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  162.      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
  163.     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  164.     26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
  165.     36,    37,    38,    39,    52
  166. };
  167.  
  168. #if YYDEBUG != 0
  169. static const short yyprhs[] = {     0,
  170.      0,     4,     6,     9,    11,    14,    15,    16,    20,    21,
  171.     25,    28,    31,    34,    36,    39,    42,    44,    46,    48,
  172.     50,    52,    53,    61,    66,    71,    73,    77,    78,    83,
  173.     89,    94,    96,    99,   101,   104,   106,   109,   112,   115,
  174.    119,   121,   128,   137,   146,   157,   167,   170,   173,   180,
  175.    185,   189,   192,   196,   197,   202,   209,   213,   216,   218,
  176.    220,   227,   237,   239,   242,   243,   245,   246,   249,   250,
  177.    253,   256,   259,   260,   262,   264,   268,   270,   273,   277,
  178.    278,   280,   281,   283,   285,   289,   291,   294,   298,   302,
  179.    303,   305,   307,   311,   313,   316,   320,   324,   325,   330,
  180.    336,   341,   345,   349,   353,   357,   359,   362,   366,   370,
  181.    374,   378,   384,   386,   389,   390,   395,   399,   403,   407,
  182.    409,   412,   416,   420,   424,   430,   432,   435,   437,   441,
  183.    445,   449,   453,   457,   461,   464,   467,   470,   474,   479,
  184.    484,   486,   491,   493,   496,   499,   501,   503,   506,   509,
  185.    510,   512,   514,   519,   522,   525,   528,   530,   531,   533,
  186.    535
  187. };
  188.  
  189. static const short yyrhs[] = {    83,
  190.     63,    83,     0,    64,     0,    63,    64,     0,     1,     0,
  191.     63,     1,     0,     0,     0,    15,    65,    75,     0,     0,
  192.     16,    66,    75,     0,    15,    77,     0,    16,    77,     0,
  193.     72,    75,     0,    75,     0,    72,    77,     0,    69,    71,
  194.      0,     4,     0,     3,     0,    68,     0,    38,     0,    39,
  195.      0,     0,    30,    70,    67,    55,    86,   103,    83,     0,
  196.    101,    76,   102,   104,     0,   101,   102,   104,    83,     0,
  197.     93,     0,    93,    42,    93,     0,     0,    49,    74,     5,
  198.     49,     0,   101,    76,   102,   104,    83,     0,   101,   102,
  199.    104,    83,     0,    78,     0,    76,    78,     0,     1,     0,
  200.     76,     1,     0,    82,     0,   105,    83,     0,   105,    83,
  201.      0,   101,   102,     0,   101,    76,   102,     0,    81,     0,
  202.     21,    55,    93,   103,    83,    78,     0,    22,    83,    78,
  203.     21,    55,    93,   103,    83,     0,    23,    55,     4,    33,
  204.      4,   103,    83,    78,     0,    23,    55,    88,   105,    93,
  205.    105,    88,   103,    83,    78,     0,    23,    55,    88,   105,
  206.    105,    88,   103,    83,    78,     0,    24,    77,     0,    25,
  207.     77,     0,    80,    55,    92,   103,    85,    77,     0,    80,
  208.     89,    85,    77,     0,    28,    88,    77,     0,    32,    77,
  209.      0,    29,    88,    77,     0,     0,    19,    79,    88,    77,
  210.      0,    20,     4,    57,    92,    58,    77,     0,    20,     4,
  211.     77,     0,    93,    77,     0,    26,     0,    27,     0,    17,
  212.     55,    93,   103,    83,    78,     0,    17,    55,    93,   103,
  213.     83,    78,    18,    83,    78,     0,    13,     0,    82,    13,
  214.      0,     0,    82,     0,     0,    43,    97,     0,     0,    44,
  215.     93,     0,    10,    93,     0,    45,    93,     0,     0,    87,
  216.      0,     4,     0,    87,   106,     4,     0,     1,     0,    87,
  217.      1,     0,    87,   106,     1,     0,     0,    93,     0,     0,
  218.     90,     0,    95,     0,    90,   106,    95,     0,     1,     0,
  219.     90,     1,     0,    90,     1,    95,     0,    90,   106,     1,
  220.      0,     0,    92,     0,    93,     0,    92,   106,    93,     0,
  221.      1,     0,    92,     1,     0,    92,     1,    93,     0,    92,
  222.    106,     1,     0,     0,   100,    11,    94,    93,     0,    55,
  223.     92,   103,    33,     4,     0,    93,    45,    31,    99,     0,
  224.     31,    99,    84,     0,    93,    34,    93,     0,    93,    35,
  225.     93,     0,    93,    12,    93,     0,    73,     0,    51,    73,
  226.      0,    93,    33,     4,     0,    93,     9,    93,     0,    93,
  227.     43,    93,     0,    93,    44,    93,     0,    93,    40,    93,
  228.     41,    93,     0,    97,     0,    93,    97,     0,     0,   100,
  229.     11,    96,    95,     0,    95,    34,    95,     0,    95,    35,
  230.     95,     0,    31,    99,    84,     0,    73,     0,    51,    73,
  231.      0,    95,    12,    95,     0,    95,    33,     4,     0,    95,
  232.      9,    95,     0,    95,    40,    95,    41,    95,     0,    97,
  233.      0,    95,    97,     0,    98,     0,    97,    53,    97,     0,
  234.     97,    48,    97,     0,    97,    49,    97,     0,    97,    50,
  235.     97,     0,    97,    46,    97,     0,    97,    47,    97,     0,
  236.    100,    36,     0,   100,    37,     0,    51,    97,     0,    55,
  237.     93,   103,     0,    38,    55,    91,   103,     0,    39,    55,
  238.     91,   103,     0,    39,     0,     3,    55,    91,   103,     0,
  239.    100,     0,    36,   100,     0,    37,   100,     0,     7,     0,
  240.      8,     0,    47,    97,     0,    46,    97,     0,     0,   100,
  241.      0,     4,     0,     4,    57,    92,    58,     0,    54,    98,
  242.      0,    59,    83,     0,    60,    83,     0,    56,     0,     0,
  243.    105,     0,    61,     0,    42,    83,     0
  244. };
  245.  
  246. #endif
  247.  
  248. #if YYDEBUG != 0
  249. static const short yyrline[] = { 0,
  250.    150,   158,   166,   182,   183,   184,   188,   190,   204,   206,
  251.    220,   226,   232,   234,   236,   249,   258,   260,   262,   272,
  252.    273,   277,   281,   296,   301,   310,   312,   321,   323,   341,
  253.    343,   348,   354,   362,   364,   369,   370,   374,   376,   378,
  254.    380,   382,   384,   386,   392,   396,   401,   404,   407,   409,
  255.    429,   468,   487,   489,   494,   496,   498,   512,   517,   519,
  256.    524,   529,   536,   538,   542,   543,   547,   549,   554,   556,
  257.    558,   560,   565,   567,   572,   574,   576,   578,   580,   586,
  258.    588,   593,   595,   600,   602,   608,   610,   612,   614,   619,
  259.    621,   626,   628,   634,   636,   638,   640,   645,   648,   653,
  260.    655,   660,   666,   668,   670,   676,   686,   694,   696,   702,
  261.    704,   706,   708,   710,   715,   718,   719,   721,   723,   729,
  262.    731,   733,   735,   737,   739,   741,   743,   748,   750,   752,
  263.    754,   756,   758,   760,   762,   764,   769,   771,   773,   776,
  264.    778,   786,   793,   794,   796,   798,   800,   803,   811,   822,
  265.    824,   829,   831,   839,   844,   848,   852,   856,   857,   861,
  266.    864
  267. };
  268. #endif
  269.  
  270.  
  271. #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
  272.  
  273. static const char * const yytname[] = {   "$","error","$undefined.","FUNC_CALL",
  274. "NAME","REGEXP","ERROR","YNUMBER","YSTRING","RELOP","APPEND_OP","ASSIGNOP","MATCHOP",
  275. "NEWLINE","CONCAT_OP","LEX_BEGIN","LEX_END","LEX_IF","LEX_ELSE","LEX_RETURN",
  276. "LEX_DELETE","LEX_WHILE","LEX_DO","LEX_FOR","LEX_BREAK","LEX_CONTINUE","LEX_PRINT",
  277. "LEX_PRINTF","LEX_NEXT","LEX_EXIT","LEX_FUNCTION","LEX_GETLINE","LEX_NEXTFILE",
  278. "LEX_IN","LEX_AND","LEX_OR","INCREMENT","DECREMENT","LEX_BUILTIN","LEX_LENGTH",
  279. "'?'","':'","','","'<'","'>'","'|'","'+'","'-'","'*'","'/'","'%'","'!'","UNARY",
  280. "'^'","'$'","'('","')'","'['","']'","'{'","'}'","';'","start","program","rule",
  281. "@1","@2","func_name","lex_builtin","function_prologue","@3","function_body",
  282. "pattern","regexp","@4","action","statements","statement_term","statement","@5",
  283. "print","if_statement","nls","opt_nls","input_redir","output_redir","opt_param_list",
  284. "param_list","opt_exp","opt_rexpression_list","rexpression_list","opt_expression_list",
  285. "expression_list","exp","@6","rexp","@7","simp_exp","non_post_simp_exp","opt_variable",
  286. "variable","l_brace","r_brace","r_paren","opt_semi","semi","comma", NULL
  287. };
  288. #endif
  289.  
  290. static const short yyr1[] = {     0,
  291.     62,    63,    63,    63,    63,    63,    65,    64,    66,    64,
  292.     64,    64,    64,    64,    64,    64,    67,    67,    67,    68,
  293.     68,    70,    69,    71,    71,    72,    72,    74,    73,    75,
  294.     75,    76,    76,    76,    76,    77,    77,    78,    78,    78,
  295.     78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
  296.     78,    78,    78,    79,    78,    78,    78,    78,    80,    80,
  297.     81,    81,    82,    82,    83,    83,    84,    84,    85,    85,
  298.     85,    85,    86,    86,    87,    87,    87,    87,    87,    88,
  299.     88,    89,    89,    90,    90,    90,    90,    90,    90,    91,
  300.     91,    92,    92,    92,    92,    92,    92,    94,    93,    93,
  301.     93,    93,    93,    93,    93,    93,    93,    93,    93,    93,
  302.     93,    93,    93,    93,    96,    95,    95,    95,    95,    95,
  303.     95,    95,    95,    95,    95,    95,    95,    97,    97,    97,
  304.     97,    97,    97,    97,    97,    97,    98,    98,    98,    98,
  305.     98,    98,    98,    98,    98,    98,    98,    98,    98,    99,
  306.     99,   100,   100,   100,   101,   102,   103,   104,   104,   105,
  307.    106
  308. };
  309.  
  310. static const short yyr2[] = {     0,
  311.      3,     1,     2,     1,     2,     0,     0,     3,     0,     3,
  312.      2,     2,     2,     1,     2,     2,     1,     1,     1,     1,
  313.      1,     0,     7,     4,     4,     1,     3,     0,     4,     5,
  314.      4,     1,     2,     1,     2,     1,     2,     2,     2,     3,
  315.      1,     6,     8,     8,    10,     9,     2,     2,     6,     4,
  316.      3,     2,     3,     0,     4,     6,     3,     2,     1,     1,
  317.      6,     9,     1,     2,     0,     1,     0,     2,     0,     2,
  318.      2,     2,     0,     1,     1,     3,     1,     2,     3,     0,
  319.      1,     0,     1,     1,     3,     1,     2,     3,     3,     0,
  320.      1,     1,     3,     1,     2,     3,     3,     0,     4,     5,
  321.      4,     3,     3,     3,     3,     1,     2,     3,     3,     3,
  322.      3,     5,     1,     2,     0,     4,     3,     3,     3,     1,
  323.      2,     3,     3,     3,     5,     1,     2,     1,     3,     3,
  324.      3,     3,     3,     3,     2,     2,     2,     3,     4,     4,
  325.      1,     4,     1,     2,     2,     1,     1,     2,     2,     0,
  326.      1,     1,     4,     2,     2,     2,     1,     0,     1,     1,
  327.      2
  328. };
  329.  
  330. static const short yydefact[] = {    65,
  331.     63,    66,     0,    64,     4,     0,   152,   146,   147,     7,
  332.      9,    22,   150,     0,     0,     0,   141,     0,     0,    28,
  333.      0,     0,     0,    65,     0,     2,     0,     0,   106,    14,
  334.     26,   113,   128,   143,     0,     0,     0,   160,     0,    11,
  335.     36,    65,     0,    12,     0,    67,   151,   144,   145,     0,
  336.      0,     0,     0,   149,   143,   148,     0,   107,   137,   154,
  337.    143,    94,     0,    92,   155,     5,     3,     1,    16,     0,
  338.     13,    15,     0,     0,     0,     0,     0,     0,     0,     0,
  339.      0,     0,   114,     0,     0,     0,     0,     0,     0,    98,
  340.    135,   136,    34,     0,    54,     0,     0,    65,     0,     0,
  341.      0,    59,    60,    80,    80,     0,    65,     0,    32,     0,
  342.     41,     0,     0,   158,    65,     0,     0,    92,     0,     8,
  343.     37,    10,    18,    17,    20,    21,     0,    19,     0,   102,
  344.      0,     0,     0,     0,    95,    65,   157,     0,     0,   138,
  345.      0,   158,   109,   105,   108,   103,   104,     0,    27,   110,
  346.    111,   150,   133,   134,   130,   131,   132,   129,     0,     0,
  347.     80,     0,     0,     0,    80,    47,    48,     0,    81,     0,
  348.     52,   156,    35,    33,   158,    86,   150,     0,     0,   120,
  349.     69,     0,    84,   126,   143,    58,     0,    39,    65,   159,
  350.     38,   142,   153,     0,    68,   139,   140,    29,    96,   161,
  351.      0,    97,    93,   158,    65,     0,   101,    99,     0,     0,
  352.      0,    57,     0,     0,   152,     0,    51,    53,    65,    67,
  353.    121,     0,     0,     0,     0,     0,    87,     0,     0,     0,
  354.      0,     0,     0,     0,   127,   115,    40,    31,    77,    75,
  355.      0,     0,   100,    24,    25,   112,    65,    55,     0,    65,
  356.      0,     0,     0,    30,   119,    69,    71,    70,    72,    50,
  357.     88,    89,    85,   124,   122,   123,   117,   118,     0,     0,
  358.     65,    78,     0,     0,     0,     0,     0,     0,     0,    80,
  359.      0,     0,   116,    23,    79,    76,    61,    56,    42,     0,
  360.     65,    80,     0,    49,   125,    65,    65,     0,     0,    65,
  361.      0,    43,    44,    65,     0,    62,     0,    46,    45,     0,
  362.      0,     0
  363. };
  364.  
  365. static const short yydefgoto[] = {   310,
  366.     25,    26,    39,    43,   127,   128,    27,    45,    69,    28,
  367.     29,    57,    30,   108,    40,   109,   161,   110,   111,     2,
  368.      3,   130,   226,   241,   242,   168,   181,   182,   116,   117,
  369.    112,   159,   183,   270,    32,    33,    46,    34,   113,   114,
  370.    140,   189,    42,   139
  371. };
  372.  
  373. static const short yypact[] = {    -6,
  374. -32768,     0,   875,-32768,-32768,   -40,   -38,-32768,-32768,    -7,
  375.     -7,-32768,    10,    10,    10,   -31,   -26,  1735,  1735,-32768,
  376.   1715,  1735,  1131,    -6,   932,-32768,   -24,    72,-32768,-32768,
  377.   1304,   205,-32768,     5,   709,  1110,  1131,-32768,   -24,-32768,
  378.      0,    -6,   -24,-32768,    85,     3,-32768,-32768,-32768,  1110,
  379.   1110,  1735,  1620,     8,   106,     8,    81,-32768,     8,-32768,
  380. -32768,-32768,    37,  1250,-32768,-32768,-32768,-32768,-32768,   709,
  381. -32768,-32768,  1620,  1620,    90,  1620,  1620,  1620,  1620,  1620,
  382.   1620,    65,   205,  1735,  1735,  1735,  1735,  1735,  1735,-32768,
  383. -32768,-32768,-32768,    50,-32768,   111,    70,    -6,    93,    -7,
  384.     -7,-32768,-32768,  1620,  1620,    -7,    -6,   758,-32768,   819,
  385. -32768,  1040,   709,   100,    -6,    99,    55,  1402,     9,-32768,
  386. -32768,-32768,-32768,-32768,-32768,-32768,   109,-32768,  1735,-32768,
  387.     99,    99,  1250,   119,  1620,    -6,-32768,   133,  1180,-32768,
  388.    758,   100,  1327,   794,-32768,  1515,  1451,  1353,  1402,  1327,
  389.   1327,    10,   125,   125,     8,     8,     8,     8,  1620,  1620,
  390.   1620,    42,  1620,   981,  1657,-32768,-32768,    -7,  1402,    -7,
  391. -32768,-32768,-32768,-32768,   100,-32768,    10,  1715,  1131,-32768,
  392.     96,    39,  1538,   205,   117,-32768,   758,-32768,    -6,-32768,
  393. -32768,-32768,-32768,     7,   205,-32768,-32768,-32768,  1402,-32768,
  394.    166,-32768,  1402,   100,    -6,  1620,-32768,  1402,  1250,    -7,
  395.   1131,-32768,  1250,   151,   -12,   100,-32768,-32768,    -6,     3,
  396. -32768,    37,  1620,  1620,  1620,    -7,  1678,  1201,  1678,  1678,
  397.    181,  1678,  1678,  1678,   205,-32768,-32768,-32768,-32768,-32768,
  398.     99,    56,-32768,-32768,-32768,  1402,    -6,-32768,    11,    -6,
  399.    131,   183,  1061,-32768,-32768,    96,  1402,  1402,  1402,-32768,
  400.   1538,-32768,  1538,   635,    83,-32768,  1599,  1579,  1474,  1678,
  401.     -6,-32768,   103,   981,    -7,   981,  1620,    99,   623,  1620,
  402.     -7,  1678,  1538,-32768,-32768,-32768,   170,-32768,-32768,  1250,
  403.     -6,  1620,    99,-32768,  1538,    -6,    -6,   981,    99,    -6,
  404.    981,-32768,-32768,    -6,   981,-32768,   981,-32768,-32768,   190,
  405.    191,-32768
  406. };
  407.  
  408. static const short yypgoto[] = {-32768,
  409. -32768,   167,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  410.    211,-32768,   107,   -53,   315,  -105,-32768,-32768,-32768,   199,
  411.     97,   -22,   -62,-32768,-32768,  -103,-32768,-32768,    94,   -14,
  412.     -3,-32768,  -202,-32768,   318,   177,  -134,    95,   124,   -69,
  413.    407,  -138,   420,  -177
  414. };
  415.  
  416.  
  417. #define    YYLAST        1790
  418.  
  419.  
  420. static const short yytable[] = {    31,
  421.    142,   170,   174,   205,   228,     1,     1,   239,    63,   135,
  422.    240,   135,     4,     7,    36,    90,   141,   207,    37,    64,
  423.    252,    31,   119,    50,   261,   263,   264,   265,    51,   267,
  424.    268,   269,   118,   118,    24,   174,   219,   135,   175,   227,
  425.     91,    92,   220,   188,    37,   129,   118,   118,   -83,   133,
  426.    136,   -83,   136,    38,     1,   135,   272,   210,   214,   187,
  427.     89,   216,   -73,    22,   273,   244,   193,   283,   275,   143,
  428.    144,   204,   146,   147,   148,   149,   150,   151,   136,   295,
  429.    136,   174,   -83,   -83,     1,   134,     7,   123,   124,     8,
  430.      9,   229,   137,   145,-32768,   152,   136,   136,   211,   -83,
  431.    169,   169,    38,   285,   160,   223,   286,    47,    48,    49,
  432.    -91,   -74,    55,    55,   162,    55,    61,   237,    14,    15,
  433.     65,    68,   125,   126,   163,    55,    35,   236,    18,    19,
  434.     24,   199,    38,    52,    71,   203,    22,    53,   121,   224,
  435.    225,    91,    92,   131,   132,   120,    55,   165,    35,   122,
  436.     70,    35,    91,    92,   137,   208,   209,   169,    55,   213,
  437.     38,   169,    35,   194,   222,   201,    35,   198,   287,   243,
  438.    289,   251,    86,    87,    88,    64,   293,    89,    55,    55,
  439.     55,    55,    55,    55,   266,   277,   278,   296,   299,   311,
  440.    312,    67,   303,   281,   164,   306,   249,   255,    60,   308,
  441.      0,   309,   246,   172,   185,     0,    55,   118,    41,    41,
  442.      0,   191,    55,     0,     0,     0,     0,     0,     0,   257,
  443.    258,   259,     0,    55,     0,     0,    41,    55,     0,     0,
  444.      0,    58,   200,     0,     0,     0,     0,    55,    55,     0,
  445.     55,    55,    55,    55,    55,    55,    47,     0,     0,   279,
  446.     84,    85,    86,    87,    88,     0,     0,    89,     0,     0,
  447.      0,     0,     0,    55,     0,     0,     0,     0,     0,     0,
  448.      0,    47,    55,   290,     0,     0,   169,    55,     0,     0,
  449.      0,     0,     0,     0,     0,   238,     0,     0,   169,     0,
  450.      0,     0,     0,    55,     0,     0,     0,    55,    41,    41,
  451.      0,   245,    55,    55,    41,     0,     0,    55,     0,     0,
  452.     41,     0,     0,     0,     0,   254,     0,     0,     0,     0,
  453.    180,   185,   185,   185,   185,    44,   185,   185,   185,     0,
  454.      0,     0,     0,     0,     0,    54,    56,     0,    59,     0,
  455.     55,     0,    72,   274,     0,     0,   276,     0,    83,     0,
  456.      0,    55,    55,    55,     0,    55,     0,    55,    55,    55,
  457.     41,    55,    55,    55,   185,     0,    41,   284,    41,    59,
  458.      0,     0,     0,    55,     0,     0,   185,    55,     0,     0,
  459.      0,    83,     0,     0,    55,     0,     0,   298,   221,    55,
  460.      0,     0,   301,   302,     0,     0,   305,     0,     0,     0,
  461.    307,   153,   154,   155,   156,   157,   158,     0,    41,     0,
  462.      0,     0,     0,     0,   166,   167,     0,     0,     0,     0,
  463.    171,     0,     0,     0,    41,     0,   186,   184,     0,    83,
  464.      0,     0,     0,     0,     0,    83,     0,   180,   180,   180,
  465.    180,     0,   180,   180,   180,     0,   195,     0,     0,     0,
  466.     83,     0,     0,     0,   115,     0,     0,     0,     0,     0,
  467.     83,    83,     0,    83,    83,    83,    83,    83,    83,   138,
  468.      0,     0,     0,    41,     0,     0,   212,     0,     0,    41,
  469.    180,     0,   217,     0,   218,     0,    83,     0,     0,   115,
  470.      0,     0,   180,     0,     0,    59,     0,     0,     0,     0,
  471.    235,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  472.      0,     0,     0,     0,     0,     0,    83,     0,     0,     0,
  473.     83,     0,   192,     0,   248,    83,    83,   115,     0,     0,
  474.     83,     0,   115,   190,     0,     0,     0,   196,   197,     0,
  475.    260,     0,     0,     0,   184,   184,   184,   184,     0,   184,
  476.    184,   184,     0,     0,     0,     0,     0,     0,     0,     0,
  477.    115,   190,     0,    83,     0,     0,     0,     0,     0,     0,
  478.      0,     0,     0,     0,    83,    83,    83,     0,   235,     0,
  479.    235,   235,   235,   115,   235,   235,   235,   184,     0,   288,
  480.      0,     0,     0,     0,   190,   294,    83,     0,     0,   184,
  481.    235,     0,     0,     0,     0,     0,   115,    83,     0,     0,
  482.      0,     0,   235,     0,     0,   247,     0,     0,     0,   250,
  483.      0,     0,     0,   190,     0,     6,     7,     0,   256,     8,
  484.      9,    73,     0,     0,    74,   253,     0,     0,     7,     0,
  485.      0,     8,     9,-32768,     0,     0,     0,   271,     0,     0,
  486.      0,     0,     0,     0,     0,    75,    76,    77,    14,    15,
  487.     16,    17,    78,     0,     0,    80,    81,    82,    18,    19,
  488.     14,    15,   280,    52,     0,     0,    22,    53,     0,     0,
  489.     18,    19,     0,    38,   291,    52,     0,     0,    22,    53,
  490.      0,     0,     0,   115,     0,   115,   297,     0,   292,   300,
  491.      0,     0,     0,     0,     0,   304,     0,     0,     0,    93,
  492.      0,     6,     7,     0,     0,     8,     9,   115,     0,     0,
  493.    115,     0,     0,     0,   115,    94,   115,    95,    96,    97,
  494.     98,    99,   100,   101,   102,   103,   104,   105,     0,    13,
  495.    106,     0,     0,     0,    14,    15,    16,    17,     0,     0,
  496.      0,     0,     0,     0,    18,    19,     0,    20,   173,    21,
  497.      6,     7,    22,    23,     8,     9,     0,    24,   107,    38,
  498.      0,     0,     0,     0,    94,     0,    95,    96,    97,    98,
  499.     99,   100,   101,   102,   103,   104,   105,     0,    13,   106,
  500.      0,     0,     0,    14,    15,    16,    17,     7,     0,     0,
  501.      8,     9,    73,    18,    19,-32768,    20,     0,    21,     0,
  502.      0,    22,    23,     0,     0,     0,    24,   107,    38,   176,
  503.      0,     6,     7,     0,     0,     8,     9,     0,   -82,    14,
  504.     15,   -82,     0,     0,     0,     0,    80,    81,    82,    18,
  505.     19,     0,     0,     0,    52,     0,     0,    22,    53,   177,
  506.      0,     0,     0,     0,    14,    15,    16,    17,     0,     0,
  507.      0,     0,   -82,   -82,    18,    19,     0,    20,     0,   178,
  508.      0,     0,    22,   179,    -6,     5,     0,     6,     7,   -82,
  509.      0,     8,     9,     0,     0,     0,     0,    -6,     0,    10,
  510.     11,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  511.      0,     0,     0,     0,    12,    13,     0,     0,     0,     0,
  512.     14,    15,    16,    17,     0,     0,     0,     0,     0,     0,
  513.     18,    19,     0,    20,     0,    21,     0,     0,    22,    23,
  514.      0,   -65,    66,    24,     6,     7,     0,     0,     8,     9,
  515.      0,     0,     0,     0,     1,     0,    10,    11,     0,     0,
  516.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  517.      0,    12,    13,     0,     0,     0,     0,    14,    15,    16,
  518.     17,     0,     0,     0,     0,     0,     0,    18,    19,     0,
  519.     20,     0,    21,     6,     7,    22,    23,     8,     9,     0,
  520.     24,     0,     0,     0,     0,     0,     0,    94,     0,    95,
  521.     96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
  522.      0,    13,   106,     0,     0,     0,    14,    15,    16,    17,
  523.      0,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  524.      0,    21,     0,     0,    22,    23,     0,     0,     0,    24,
  525.      0,    38,     6,     7,     0,     0,     8,     9,    73,     0,
  526.      0,    74,     1,     0,     0,     0,     0,     0,     0,     0,
  527.      0,     0,     0,     6,     7,     0,     0,     8,     9,     0,
  528.      0,     0,    75,    76,    77,    14,    15,    16,    17,    78,
  529.      0,     0,    80,    81,    82,    18,    19,     0,     0,     0,
  530.     52,    13,     0,    22,    53,     0,    14,    15,    16,    17,
  531.     38,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  532.     62,    21,     6,     7,    22,    23,     8,     9,     0,     0,
  533.      0,    38,     0,     0,     0,     0,     0,     0,     0,     0,
  534.      0,    62,     0,     6,     7,     0,     0,     8,     9,     0,
  535.     13,     0,     0,     0,     0,    14,    15,    16,    17,     0,
  536.      0,     0,     0,     0,     0,    18,    19,     0,    20,     0,
  537.     21,    13,     0,    22,    23,   -90,    14,    15,    16,    17,
  538.      0,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  539.    202,    21,     6,     7,    22,    23,     8,     9,     0,     0,
  540.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  541.      0,   262,     0,     6,     7,     0,     0,     8,     9,     0,
  542.     13,     0,     0,     0,     0,    14,    15,    16,    17,     0,
  543.      0,     0,     0,     0,     0,    18,    19,     0,    20,     0,
  544.     21,   177,     0,    22,    23,     0,    14,    15,    16,    17,
  545.      0,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  546.      0,   178,     6,     7,    22,    53,     8,     9,    73,     0,
  547.      0,    74,     0,     0,     0,     0,     0,     0,     0,     0,
  548.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  549.      0,     0,    75,    76,    77,    14,    15,    16,    17,    78,
  550.      0,     0,    80,    81,    82,    18,    19,     0,     0,     0,
  551.     52,     0,     0,    22,    53,   137,     6,     7,     0,     0,
  552.      8,     9,    73,     0,     0,    74,     0,     0,     0,     0,
  553.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  554.      7,     0,     0,     8,     9,-32768,    75,    76,    77,    14,
  555.     15,    16,    17,    78,     0,    79,    80,    81,    82,    18,
  556.     19,     0,     0,     0,    52,     6,     7,    22,    53,     8,
  557.      9,    73,    14,    15,    74,     0,     0,     0,     0,-32768,
  558. -32768,-32768,    18,    19,     0,     0,     0,    52,     0,     0,
  559.     22,    53,     0,     0,     0,    75,    76,    77,    14,    15,
  560.     16,    17,    78,   206,     0,    80,    81,    82,    18,    19,
  561.      0,     0,     0,    52,     6,     7,    22,    53,     8,     9,
  562.     73,     0,     0,    74,     0,     0,     0,     0,     0,     0,
  563.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  564.      0,     0,     0,     0,    75,    76,    77,    14,    15,    16,
  565.     17,    78,     0,     0,    80,    81,    82,    18,    19,     0,
  566.      0,     0,    52,     6,     7,    22,    53,     8,     9,    73,
  567.      0,     0,    74,     0,     0,     0,     0,     0,     0,     0,
  568.      0,     0,     0,     0,     0,     0,     6,     7,     0,     0,
  569.      8,     9,   229,    75,    76,   230,    14,    15,    16,    17,
  570.      0,     0,     0,    80,    81,    82,    18,    19,     0,     0,
  571.      0,    52,     0,     0,    22,    53,   231,   232,   233,    14,
  572.     15,    16,    17,   234,   282,     0,     0,     6,     7,    18,
  573.     19,     8,     9,    73,    52,     0,    74,    22,    53,     0,
  574.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  575.      6,     7,     0,     0,     8,     9,   229,    75,     0,   230,
  576.     14,    15,    16,    17,     0,     0,     0,    80,    81,    82,
  577.     18,    19,     0,     0,     0,    52,     0,     0,    22,    53,
  578.    231,   232,   233,    14,    15,    16,    17,   234,     0,     0,
  579.      0,     6,     7,    18,    19,     8,     9,   229,    52,     0,
  580.    230,    22,    53,     0,     0,     0,     0,     0,     0,     0,
  581.      0,     6,     7,     0,     0,     8,     9,   229,     0,     0,
  582.    230,   231,   232,     0,    14,    15,    16,    17,     0,     0,
  583.      0,     0,     6,     7,    18,    19,     8,     9,     0,    52,
  584.      0,   231,    22,    53,    14,    15,    16,    17,     0,     0,
  585.      0,     0,     0,     0,    18,    19,     0,     0,     0,    52,
  586.     13,     0,    22,    53,     0,    14,    15,    16,    17,     6,
  587.    215,     0,     0,     8,     9,    18,    19,     0,    20,     0,
  588.     21,     0,     0,    22,    23,     0,     0,     0,     0,     0,
  589.      6,     7,     0,     0,     8,     9,     0,    13,     0,     0,
  590.      0,     0,    14,    15,    16,    17,     0,     0,     0,     0,
  591.      0,     0,    18,    19,     0,    20,     0,    21,   177,     0,
  592.     22,    23,     0,    14,    15,    16,    17,     6,     7,     0,
  593.      0,     8,     9,    18,    19,     0,    20,     0,   178,     0,
  594.      0,    22,    53,     0,     0,     0,     0,     6,     7,     0,
  595.      0,     8,     9,     0,     0,     0,     0,     0,     0,     0,
  596.     14,    15,    16,    17,     0,     0,     0,     0,     0,     0,
  597.     18,    19,     0,    20,     0,    52,     0,     0,    22,    53,
  598.     14,    15,    16,    17,     0,     0,     0,     0,     0,     0,
  599.     18,    19,     0,     0,     0,    52,     0,     0,    22,    53
  600. };
  601.  
  602. static const short yycheck[] = {     3,
  603.     70,   105,   108,   142,   182,    13,    13,     1,    23,     1,
  604.      4,     1,    13,     4,    55,    11,    70,   152,    57,    23,
  605.     33,    25,    37,    55,   227,   228,   229,   230,    55,   232,
  606.    233,   234,    36,    37,    59,   141,   175,     1,   108,     1,
  607.     36,    37,   177,   113,    57,    43,    50,    51,    10,    53,
  608.     42,    13,    42,    61,    13,     1,     1,   161,   164,   113,
  609.     53,   165,    56,    54,   242,   204,    58,   270,    58,    73,
  610.     74,   141,    76,    77,    78,    79,    80,    81,    42,   282,
  611.     42,   187,    44,    45,    13,     5,     4,     3,     4,     7,
  612.      8,     9,    56,     4,    12,    31,    42,    42,    57,    61,
  613.    104,   105,    61,     1,    55,    10,     4,    13,    14,    15,
  614.     56,    56,    18,    19,     4,    21,    22,   187,    36,    37,
  615.     24,    25,    38,    39,    55,    31,     3,    11,    46,    47,
  616.     59,   135,    61,    51,    28,   139,    54,    55,    42,    44,
  617.     45,    36,    37,    50,    51,    39,    52,    55,    25,    43,
  618.     27,    28,    36,    37,    56,   159,   160,   161,    64,   163,
  619.     61,   165,    39,    55,   179,    33,    43,    49,   274,     4,
  620.    276,    21,    48,    49,    50,   179,   280,    53,    84,    85,
  621.     86,    87,    88,    89,     4,    55,     4,    18,   292,     0,
  622.      0,    25,   298,   256,    98,   301,   211,   220,    22,   305,
  623.     -1,   307,   206,   107,   110,    -1,   112,   211,    10,    11,
  624.     -1,   115,   118,    -1,    -1,    -1,    -1,    -1,    -1,   223,
  625.    224,   225,    -1,   129,    -1,    -1,    28,   133,    -1,    -1,
  626.     -1,    21,   136,    -1,    -1,    -1,    -1,   143,   144,    -1,
  627.    146,   147,   148,   149,   150,   151,   152,    -1,    -1,   253,
  628.     46,    47,    48,    49,    50,    -1,    -1,    53,    -1,    -1,
  629.     -1,    -1,    -1,   169,    -1,    -1,    -1,    -1,    -1,    -1,
  630.     -1,   177,   178,   277,    -1,    -1,   280,   183,    -1,    -1,
  631.     -1,    -1,    -1,    -1,    -1,   189,    -1,    -1,   292,    -1,
  632.     -1,    -1,    -1,   199,    -1,    -1,    -1,   203,   100,   101,
  633.     -1,   205,   208,   209,   106,    -1,    -1,   213,    -1,    -1,
  634.    112,    -1,    -1,    -1,    -1,   219,    -1,    -1,    -1,    -1,
  635.    110,   227,   228,   229,   230,    11,   232,   233,   234,    -1,
  636.     -1,    -1,    -1,    -1,    -1,    18,    19,    -1,    21,    -1,
  637.    246,    -1,    28,   247,    -1,    -1,   250,    -1,    31,    -1,
  638.     -1,   257,   258,   259,    -1,   261,    -1,   263,   264,   265,
  639.    162,   267,   268,   269,   270,    -1,   168,   271,   170,    52,
  640.     -1,    -1,    -1,   279,    -1,    -1,   282,   283,    -1,    -1,
  641.     -1,    64,    -1,    -1,   290,    -1,    -1,   291,   178,   295,
  642.     -1,    -1,   296,   297,    -1,    -1,   300,    -1,    -1,    -1,
  643.    304,    84,    85,    86,    87,    88,    89,    -1,   210,    -1,
  644.     -1,    -1,    -1,    -1,   100,   101,    -1,    -1,    -1,    -1,
  645.    106,    -1,    -1,    -1,   226,    -1,   112,   110,    -1,   112,
  646.     -1,    -1,    -1,    -1,    -1,   118,    -1,   227,   228,   229,
  647.    230,    -1,   232,   233,   234,    -1,   129,    -1,    -1,    -1,
  648.    133,    -1,    -1,    -1,    35,    -1,    -1,    -1,    -1,    -1,
  649.    143,   144,    -1,   146,   147,   148,   149,   150,   151,    63,
  650.     -1,    -1,    -1,   275,    -1,    -1,   162,    -1,    -1,   281,
  651.    270,    -1,   168,    -1,   170,    -1,   169,    -1,    -1,    70,
  652.     -1,    -1,   282,    -1,    -1,   178,    -1,    -1,    -1,    -1,
  653.    183,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  654.     -1,    -1,    -1,    -1,    -1,    -1,   199,    -1,    -1,    -1,
  655.    203,    -1,   116,    -1,   210,   208,   209,   108,    -1,    -1,
  656.    213,    -1,   113,   114,    -1,    -1,    -1,   131,   132,    -1,
  657.    226,    -1,    -1,    -1,   227,   228,   229,   230,    -1,   232,
  658.    233,   234,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  659.    141,   142,    -1,   246,    -1,    -1,    -1,    -1,    -1,    -1,
  660.     -1,    -1,    -1,    -1,   257,   258,   259,    -1,   261,    -1,
  661.    263,   264,   265,   164,   267,   268,   269,   270,    -1,   275,
  662.     -1,    -1,    -1,    -1,   175,   281,   279,    -1,    -1,   282,
  663.    283,    -1,    -1,    -1,    -1,    -1,   187,   290,    -1,    -1,
  664.     -1,    -1,   295,    -1,    -1,   209,    -1,    -1,    -1,   213,
  665.     -1,    -1,    -1,   204,    -1,     3,     4,    -1,   222,     7,
  666.      8,     9,    -1,    -1,    12,   216,    -1,    -1,     4,    -1,
  667.     -1,     7,     8,     9,    -1,    -1,    -1,   241,    -1,    -1,
  668.     -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
  669.     38,    39,    40,    -1,    -1,    43,    44,    45,    46,    47,
  670.     36,    37,   253,    51,    -1,    -1,    54,    55,    -1,    -1,
  671.     46,    47,    -1,    61,   278,    51,    -1,    -1,    54,    55,
  672.     -1,    -1,    -1,   274,    -1,   276,   290,    -1,   279,   293,
  673.     -1,    -1,    -1,    -1,    -1,   299,    -1,    -1,    -1,     1,
  674.     -1,     3,     4,    -1,    -1,     7,     8,   298,    -1,    -1,
  675.    301,    -1,    -1,    -1,   305,    17,   307,    19,    20,    21,
  676.     22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
  677.     32,    -1,    -1,    -1,    36,    37,    38,    39,    -1,    -1,
  678.     -1,    -1,    -1,    -1,    46,    47,    -1,    49,     1,    51,
  679.      3,     4,    54,    55,     7,     8,    -1,    59,    60,    61,
  680.     -1,    -1,    -1,    -1,    17,    -1,    19,    20,    21,    22,
  681.     23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
  682.     -1,    -1,    -1,    36,    37,    38,    39,     4,    -1,    -1,
  683.      7,     8,     9,    46,    47,    12,    49,    -1,    51,    -1,
  684.     -1,    54,    55,    -1,    -1,    -1,    59,    60,    61,     1,
  685.     -1,     3,     4,    -1,    -1,     7,     8,    -1,    10,    36,
  686.     37,    13,    -1,    -1,    -1,    -1,    43,    44,    45,    46,
  687.     47,    -1,    -1,    -1,    51,    -1,    -1,    54,    55,    31,
  688.     -1,    -1,    -1,    -1,    36,    37,    38,    39,    -1,    -1,
  689.     -1,    -1,    44,    45,    46,    47,    -1,    49,    -1,    51,
  690.     -1,    -1,    54,    55,     0,     1,    -1,     3,     4,    61,
  691.     -1,     7,     8,    -1,    -1,    -1,    -1,    13,    -1,    15,
  692.     16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  693.     -1,    -1,    -1,    -1,    30,    31,    -1,    -1,    -1,    -1,
  694.     36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,
  695.     46,    47,    -1,    49,    -1,    51,    -1,    -1,    54,    55,
  696.     -1,     0,     1,    59,     3,     4,    -1,    -1,     7,     8,
  697.     -1,    -1,    -1,    -1,    13,    -1,    15,    16,    -1,    -1,
  698.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  699.     -1,    30,    31,    -1,    -1,    -1,    -1,    36,    37,    38,
  700.     39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,
  701.     49,    -1,    51,     3,     4,    54,    55,     7,     8,    -1,
  702.     59,    -1,    -1,    -1,    -1,    -1,    -1,    17,    -1,    19,
  703.     20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
  704.     -1,    31,    32,    -1,    -1,    -1,    36,    37,    38,    39,
  705.     -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  706.     -1,    51,    -1,    -1,    54,    55,    -1,    -1,    -1,    59,
  707.     -1,    61,     3,     4,    -1,    -1,     7,     8,     9,    -1,
  708.     -1,    12,    13,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  709.     -1,    -1,    -1,     3,     4,    -1,    -1,     7,     8,    -1,
  710.     -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
  711.     -1,    -1,    43,    44,    45,    46,    47,    -1,    -1,    -1,
  712.     51,    31,    -1,    54,    55,    -1,    36,    37,    38,    39,
  713.     61,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  714.      1,    51,     3,     4,    54,    55,     7,     8,    -1,    -1,
  715.     -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  716.     -1,     1,    -1,     3,     4,    -1,    -1,     7,     8,    -1,
  717.     31,    -1,    -1,    -1,    -1,    36,    37,    38,    39,    -1,
  718.     -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,    -1,
  719.     51,    31,    -1,    54,    55,    56,    36,    37,    38,    39,
  720.     -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  721.      1,    51,     3,     4,    54,    55,     7,     8,    -1,    -1,
  722.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  723.     -1,     1,    -1,     3,     4,    -1,    -1,     7,     8,    -1,
  724.     31,    -1,    -1,    -1,    -1,    36,    37,    38,    39,    -1,
  725.     -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,    -1,
  726.     51,    31,    -1,    54,    55,    -1,    36,    37,    38,    39,
  727.     -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  728.     -1,    51,     3,     4,    54,    55,     7,     8,     9,    -1,
  729.     -1,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  730.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  731.     -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
  732.     -1,    -1,    43,    44,    45,    46,    47,    -1,    -1,    -1,
  733.     51,    -1,    -1,    54,    55,    56,     3,     4,    -1,    -1,
  734.      7,     8,     9,    -1,    -1,    12,    -1,    -1,    -1,    -1,
  735.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  736.      4,    -1,    -1,     7,     8,     9,    33,    34,    35,    36,
  737.     37,    38,    39,    40,    -1,    42,    43,    44,    45,    46,
  738.     47,    -1,    -1,    -1,    51,     3,     4,    54,    55,     7,
  739.      8,     9,    36,    37,    12,    -1,    -1,    -1,    -1,    43,
  740.     44,    45,    46,    47,    -1,    -1,    -1,    51,    -1,    -1,
  741.     54,    55,    -1,    -1,    -1,    33,    34,    35,    36,    37,
  742.     38,    39,    40,    41,    -1,    43,    44,    45,    46,    47,
  743.     -1,    -1,    -1,    51,     3,     4,    54,    55,     7,     8,
  744.      9,    -1,    -1,    12,    -1,    -1,    -1,    -1,    -1,    -1,
  745.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  746.     -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,    38,
  747.     39,    40,    -1,    -1,    43,    44,    45,    46,    47,    -1,
  748.     -1,    -1,    51,     3,     4,    54,    55,     7,     8,     9,
  749.     -1,    -1,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  750.     -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,    -1,
  751.      7,     8,     9,    33,    34,    12,    36,    37,    38,    39,
  752.     -1,    -1,    -1,    43,    44,    45,    46,    47,    -1,    -1,
  753.     -1,    51,    -1,    -1,    54,    55,    33,    34,    35,    36,
  754.     37,    38,    39,    40,    41,    -1,    -1,     3,     4,    46,
  755.     47,     7,     8,     9,    51,    -1,    12,    54,    55,    -1,
  756.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  757.      3,     4,    -1,    -1,     7,     8,     9,    33,    -1,    12,
  758.     36,    37,    38,    39,    -1,    -1,    -1,    43,    44,    45,
  759.     46,    47,    -1,    -1,    -1,    51,    -1,    -1,    54,    55,
  760.     33,    34,    35,    36,    37,    38,    39,    40,    -1,    -1,
  761.     -1,     3,     4,    46,    47,     7,     8,     9,    51,    -1,
  762.     12,    54,    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  763.     -1,     3,     4,    -1,    -1,     7,     8,     9,    -1,    -1,
  764.     12,    33,    34,    -1,    36,    37,    38,    39,    -1,    -1,
  765.     -1,    -1,     3,     4,    46,    47,     7,     8,    -1,    51,
  766.     -1,    33,    54,    55,    36,    37,    38,    39,    -1,    -1,
  767.     -1,    -1,    -1,    -1,    46,    47,    -1,    -1,    -1,    51,
  768.     31,    -1,    54,    55,    -1,    36,    37,    38,    39,     3,
  769.      4,    -1,    -1,     7,     8,    46,    47,    -1,    49,    -1,
  770.     51,    -1,    -1,    54,    55,    -1,    -1,    -1,    -1,    -1,
  771.      3,     4,    -1,    -1,     7,     8,    -1,    31,    -1,    -1,
  772.     -1,    -1,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
  773.     -1,    -1,    46,    47,    -1,    49,    -1,    51,    31,    -1,
  774.     54,    55,    -1,    36,    37,    38,    39,     3,     4,    -1,
  775.     -1,     7,     8,    46,    47,    -1,    49,    -1,    51,    -1,
  776.     -1,    54,    55,    -1,    -1,    -1,    -1,     3,     4,    -1,
  777.     -1,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  778.     36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,
  779.     46,    47,    -1,    49,    -1,    51,    -1,    -1,    54,    55,
  780.     36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,
  781.     46,    47,    -1,    -1,    -1,    51,    -1,    -1,    54,    55
  782. };
  783. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  784. #line 3 "/usr/local/share/bison.simple"
  785.  
  786. /* Skeleton output parser for bison,
  787.    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
  788.  
  789.    This program is free software; you can redistribute it and/or modify
  790.    it under the terms of the GNU General Public License as published by
  791.    the Free Software Foundation; either version 2, or (at your option)
  792.    any later version.
  793.  
  794.    This program is distributed in the hope that it will be useful,
  795.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  796.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  797.    GNU General Public License for more details.
  798.  
  799.    You should have received a copy of the GNU General Public License
  800.    along with this program; if not, write to the Free Software
  801.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  802.  
  803. /* As a special exception, when this file is copied by Bison into a
  804.    Bison output file, you may use that output file without restriction.
  805.    This special exception was added by the Free Software Foundation
  806.    in version 1.24 of Bison.  */
  807.  
  808. #ifndef alloca
  809. #ifdef __GNUC__
  810. #define alloca __builtin_alloca
  811. #else /* not GNU C.  */
  812. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
  813. #include <alloca.h>
  814. #else /* not sparc */
  815. #if defined (MSDOS) && !defined (__TURBOC__)
  816. #include <malloc.h>
  817. #else /* not MSDOS, or __TURBOC__ */
  818. #if defined(_AIX)
  819. #include <malloc.h>
  820.  #pragma alloca
  821. #else /* not MSDOS, __TURBOC__, or _AIX */
  822. #ifdef __hpux
  823. #ifdef __cplusplus
  824. extern "C" {
  825. void *alloca (unsigned int);
  826. };
  827. #else /* not __cplusplus */
  828. void *alloca ();
  829. #endif /* not __cplusplus */
  830. #endif /* __hpux */
  831. #endif /* not _AIX */
  832. #endif /* not MSDOS, or __TURBOC__ */
  833. #endif /* not sparc.  */
  834. #endif /* not GNU C.  */
  835. #endif /* alloca not defined.  */
  836.  
  837. /* This is the parser code that is written into each bison parser
  838.   when the %semantic_parser declaration is not specified in the grammar.
  839.   It was written by Richard Stallman by simplifying the hairy parser
  840.   used when %semantic_parser is specified.  */
  841.  
  842. /* Note: there must be only one dollar sign in this file.
  843.    It is replaced by the list of actions, each action
  844.    as one case of the switch.  */
  845.  
  846. #define yyerrok        (yyerrstatus = 0)
  847. #define yyclearin    (yychar = YYEMPTY)
  848. #define YYEMPTY        -2
  849. #define YYEOF        0
  850. #define YYACCEPT    return(0)
  851. #define YYABORT     return(1)
  852. #define YYERROR        goto yyerrlab1
  853. /* Like YYERROR except do call yyerror.
  854.    This remains here temporarily to ease the
  855.    transition to the new meaning of YYERROR, for GCC.
  856.    Once GCC version 2 has supplanted version 1, this can go.  */
  857. #define YYFAIL        goto yyerrlab
  858. #define YYRECOVERING()  (!!yyerrstatus)
  859. #define YYBACKUP(token, value) \
  860. do                                \
  861.   if (yychar == YYEMPTY && yylen == 1)                \
  862.     { yychar = (token), yylval = (value);            \
  863.       yychar1 = YYTRANSLATE (yychar);                \
  864.       YYPOPSTACK;                        \
  865.       goto yybackup;                        \
  866.     }                                \
  867.   else                                \
  868.     { yyerror ("syntax error: cannot back up"); YYERROR; }    \
  869. while (0)
  870.  
  871. #define YYTERROR    1
  872. #define YYERRCODE    256
  873.  
  874. #ifndef YYPURE
  875. #define YYLEX        yylex()
  876. #endif
  877.  
  878. #ifdef YYPURE
  879. #ifdef YYLSP_NEEDED
  880. #ifdef YYLEX_PARAM
  881. #define YYLEX        yylex(&yylval, &yylloc, YYLEX_PARAM)
  882. #else
  883. #define YYLEX        yylex(&yylval, &yylloc)
  884. #endif
  885. #else /* not YYLSP_NEEDED */
  886. #ifdef YYLEX_PARAM
  887. #define YYLEX        yylex(&yylval, YYLEX_PARAM)
  888. #else
  889. #define YYLEX        yylex(&yylval)
  890. #endif
  891. #endif /* not YYLSP_NEEDED */
  892. #endif
  893.  
  894. /* If nonreentrant, generate the variables here */
  895.  
  896. #ifndef YYPURE
  897.  
  898. int    yychar;            /*  the lookahead symbol        */
  899. YYSTYPE    yylval;            /*  the semantic value of the        */
  900.                 /*  lookahead symbol            */
  901.  
  902. #ifdef YYLSP_NEEDED
  903. YYLTYPE yylloc;            /*  location data for the lookahead    */
  904.                 /*  symbol                */
  905. #endif
  906.  
  907. int yynerrs;            /*  number of parse errors so far       */
  908. #endif  /* not YYPURE */
  909.  
  910. #if YYDEBUG != 0
  911. int yydebug;            /*  nonzero means print parse trace    */
  912. /* Since this is uninitialized, it does not stop multiple parsers
  913.    from coexisting.  */
  914. #endif
  915.  
  916. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  917.  
  918. #ifndef    YYINITDEPTH
  919. #define YYINITDEPTH 200
  920. #endif
  921.  
  922. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  923.     (effective only if the built-in stack extension method is used).  */
  924.  
  925. #if YYMAXDEPTH == 0
  926. #undef YYMAXDEPTH
  927. #endif
  928.  
  929. #ifndef YYMAXDEPTH
  930. #define YYMAXDEPTH 10000
  931. #endif
  932.  
  933. /* Prevent warning if -Wstrict-prototypes.  */
  934. #ifdef __GNUC__
  935. int yyparse (void);
  936. #endif
  937.  
  938. #if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
  939. #define __yy_memcpy(TO,FROM,COUNT)    __builtin_memcpy(TO,FROM,COUNT)
  940. #else                /* not GNU C or C++ */
  941. #ifndef __cplusplus
  942.  
  943. /* This is the most reliable way to avoid incompatibilities
  944.    in available built-in functions on various systems.  */
  945. static void
  946. __yy_memcpy (to, from, count)
  947.      char *to;
  948.      char *from;
  949.      int count;
  950. {
  951.   register char *f = from;
  952.   register char *t = to;
  953.   register int i = count;
  954.  
  955.   while (i-- > 0)
  956.     *t++ = *f++;
  957. }
  958.  
  959. #else /* __cplusplus */
  960.  
  961. /* This is the most reliable way to avoid incompatibilities
  962.    in available built-in functions on various systems.  */
  963. static void
  964. __yy_memcpy (char *to, char *from, int count)
  965. {
  966.   register char *f = from;
  967.   register char *t = to;
  968.   register int i = count;
  969.  
  970.   while (i-- > 0)
  971.     *t++ = *f++;
  972. }
  973.  
  974. #endif
  975. #endif
  976.  
  977. #line 196 "/usr/local/share/bison.simple"
  978.  
  979. /* The user can define YYPARSE_PARAM as the name of an argument to be passed
  980.    into yyparse.  The argument should have type void *.
  981.    It should actually point to an object.
  982.    Grammar actions can access the variable by casting it
  983.    to the proper pointer type.  */
  984.  
  985. #ifdef YYPARSE_PARAM
  986. #ifdef __cplusplus
  987. #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
  988. #define YYPARSE_PARAM_DECL
  989. #else /* not __cplusplus */
  990. #define YYPARSE_PARAM_ARG YYPARSE_PARAM
  991. #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
  992. #endif /* not __cplusplus */
  993. #else /* not YYPARSE_PARAM */
  994. #define YYPARSE_PARAM_ARG
  995. #define YYPARSE_PARAM_DECL
  996. #endif /* not YYPARSE_PARAM */
  997.  
  998. int
  999. yyparse(YYPARSE_PARAM_ARG)
  1000.      YYPARSE_PARAM_DECL
  1001. {
  1002.   register int yystate;
  1003.   register int yyn;
  1004.   register short *yyssp;
  1005.   register YYSTYPE *yyvsp;
  1006.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  1007.   int yychar1 = 0;        /*  lookahead token as an internal (translated) token number */
  1008.  
  1009.   short    yyssa[YYINITDEPTH];    /*  the state stack            */
  1010.   YYSTYPE yyvsa[YYINITDEPTH];    /*  the semantic value stack        */
  1011.  
  1012.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  1013.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  1014.  
  1015. #ifdef YYLSP_NEEDED
  1016.   YYLTYPE yylsa[YYINITDEPTH];    /*  the location stack            */
  1017.   YYLTYPE *yyls = yylsa;
  1018.   YYLTYPE *yylsp;
  1019.  
  1020. #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
  1021. #else
  1022. #define YYPOPSTACK   (yyvsp--, yyssp--)
  1023. #endif
  1024.  
  1025.   int yystacksize = YYINITDEPTH;
  1026.  
  1027. #ifdef YYPURE
  1028.   int yychar;
  1029.   YYSTYPE yylval;
  1030.   int yynerrs;
  1031. #ifdef YYLSP_NEEDED
  1032.   YYLTYPE yylloc;
  1033. #endif
  1034. #endif
  1035.  
  1036.   YYSTYPE yyval;        /*  the variable used to return        */
  1037.                 /*  semantic values from the action    */
  1038.                 /*  routines                */
  1039.  
  1040.   int yylen;
  1041.  
  1042. #if YYDEBUG != 0
  1043.   if (yydebug)
  1044.     fprintf(stderr, "Starting parse\n");
  1045. #endif
  1046.  
  1047.   yystate = 0;
  1048.   yyerrstatus = 0;
  1049.   yynerrs = 0;
  1050.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  1051.  
  1052.   /* Initialize stack pointers.
  1053.      Waste one element of value and location stack
  1054.      so that they stay on the same level as the state stack.
  1055.      The wasted elements are never initialized.  */
  1056.  
  1057.   yyssp = yyss - 1;
  1058.   yyvsp = yyvs;
  1059. #ifdef YYLSP_NEEDED
  1060.   yylsp = yyls;
  1061. #endif
  1062.  
  1063. /* Push a new state, which is found in  yystate  .  */
  1064. /* In all cases, when you get here, the value and location stacks
  1065.    have just been pushed. so pushing a state here evens the stacks.  */
  1066. yynewstate:
  1067.  
  1068.   *++yyssp = yystate;
  1069.  
  1070.   if (yyssp >= yyss + yystacksize - 1)
  1071.     {
  1072.       /* Give user a chance to reallocate the stack */
  1073.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  1074.       YYSTYPE *yyvs1 = yyvs;
  1075.       short *yyss1 = yyss;
  1076. #ifdef YYLSP_NEEDED
  1077.       YYLTYPE *yyls1 = yyls;
  1078. #endif
  1079.  
  1080.       /* Get the current used size of the three stacks, in elements.  */
  1081.       int size = yyssp - yyss + 1;
  1082.  
  1083. #ifdef yyoverflow
  1084.       /* Each stack pointer address is followed by the size of
  1085.      the data in use in that stack, in bytes.  */
  1086. #ifdef YYLSP_NEEDED
  1087.       /* This used to be a conditional around just the two extra args,
  1088.      but that might be undefined if yyoverflow is a macro.  */
  1089.       yyoverflow("parser stack overflow",
  1090.          &yyss1, size * sizeof (*yyssp),
  1091.          &yyvs1, size * sizeof (*yyvsp),
  1092.          &yyls1, size * sizeof (*yylsp),
  1093.          &yystacksize);
  1094. #else
  1095.       yyoverflow("parser stack overflow",
  1096.          &yyss1, size * sizeof (*yyssp),
  1097.          &yyvs1, size * sizeof (*yyvsp),
  1098.          &yystacksize);
  1099. #endif
  1100.  
  1101.       yyss = yyss1; yyvs = yyvs1;
  1102. #ifdef YYLSP_NEEDED
  1103.       yyls = yyls1;
  1104. #endif
  1105. #else /* no yyoverflow */
  1106.       /* Extend the stack our own way.  */
  1107.       if (yystacksize >= YYMAXDEPTH)
  1108.     {
  1109.       yyerror("parser stack overflow");
  1110.       return 2;
  1111.     }
  1112.       yystacksize *= 2;
  1113.       if (yystacksize > YYMAXDEPTH)
  1114.     yystacksize = YYMAXDEPTH;
  1115.       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
  1116.       __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
  1117.       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
  1118.       __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
  1119. #ifdef YYLSP_NEEDED
  1120.       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
  1121.       __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
  1122. #endif
  1123. #endif /* no yyoverflow */
  1124.  
  1125.       yyssp = yyss + size - 1;
  1126.       yyvsp = yyvs + size - 1;
  1127. #ifdef YYLSP_NEEDED
  1128.       yylsp = yyls + size - 1;
  1129. #endif
  1130.  
  1131. #if YYDEBUG != 0
  1132.       if (yydebug)
  1133.     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
  1134. #endif
  1135.  
  1136.       if (yyssp >= yyss + yystacksize - 1)
  1137.     YYABORT;
  1138.     }
  1139.  
  1140. #if YYDEBUG != 0
  1141.   if (yydebug)
  1142.     fprintf(stderr, "Entering state %d\n", yystate);
  1143. #endif
  1144.  
  1145.   goto yybackup;
  1146.  yybackup:
  1147.  
  1148. /* Do appropriate processing given the current state.  */
  1149. /* Read a lookahead token if we need one and don't already have one.  */
  1150. /* yyresume: */
  1151.  
  1152.   /* First try to decide what to do without reference to lookahead token.  */
  1153.  
  1154.   yyn = yypact[yystate];
  1155.   if (yyn == YYFLAG)
  1156.     goto yydefault;
  1157.  
  1158.   /* Not known => get a lookahead token if don't already have one.  */
  1159.  
  1160.   /* yychar is either YYEMPTY or YYEOF
  1161.      or a valid token in external form.  */
  1162.  
  1163.   if (yychar == YYEMPTY)
  1164.     {
  1165. #if YYDEBUG != 0
  1166.       if (yydebug)
  1167.     fprintf(stderr, "Reading a token: ");
  1168. #endif
  1169.       yychar = YYLEX;
  1170.     }
  1171.  
  1172.   /* Convert token to internal form (in yychar1) for indexing tables with */
  1173.  
  1174.   if (yychar <= 0)        /* This means end of input. */
  1175.     {
  1176.       yychar1 = 0;
  1177.       yychar = YYEOF;        /* Don't call YYLEX any more */
  1178.  
  1179. #if YYDEBUG != 0
  1180.       if (yydebug)
  1181.     fprintf(stderr, "Now at end of input.\n");
  1182. #endif
  1183.     }
  1184.   else
  1185.     {
  1186.       yychar1 = YYTRANSLATE(yychar);
  1187.  
  1188. #if YYDEBUG != 0
  1189.       if (yydebug)
  1190.     {
  1191.       fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
  1192.       /* Give the individual parser a way to print the precise meaning
  1193.          of a token, for further debugging info.  */
  1194. #ifdef YYPRINT
  1195.       YYPRINT (stderr, yychar, yylval);
  1196. #endif
  1197.       fprintf (stderr, ")\n");
  1198.     }
  1199. #endif
  1200.     }
  1201.  
  1202.   yyn += yychar1;
  1203.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  1204.     goto yydefault;
  1205.  
  1206.   yyn = yytable[yyn];
  1207.  
  1208.   /* yyn is what to do for this token type in this state.
  1209.      Negative => reduce, -yyn is rule number.
  1210.      Positive => shift, yyn is new state.
  1211.        New state is final state => don't bother to shift,
  1212.        just return success.
  1213.      0, or most negative number => error.  */
  1214.  
  1215.   if (yyn < 0)
  1216.     {
  1217.       if (yyn == YYFLAG)
  1218.     goto yyerrlab;
  1219.       yyn = -yyn;
  1220.       goto yyreduce;
  1221.     }
  1222.   else if (yyn == 0)
  1223.     goto yyerrlab;
  1224.  
  1225.   if (yyn == YYFINAL)
  1226.     YYACCEPT;
  1227.  
  1228.   /* Shift the lookahead token.  */
  1229.  
  1230. #if YYDEBUG != 0
  1231.   if (yydebug)
  1232.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  1233. #endif
  1234.  
  1235.   /* Discard the token being shifted unless it is eof.  */
  1236.   if (yychar != YYEOF)
  1237.     yychar = YYEMPTY;
  1238.  
  1239.   *++yyvsp = yylval;
  1240. #ifdef YYLSP_NEEDED
  1241.   *++yylsp = yylloc;
  1242. #endif
  1243.  
  1244.   /* count tokens shifted since error; after three, turn off error status.  */
  1245.   if (yyerrstatus) yyerrstatus--;
  1246.  
  1247.   yystate = yyn;
  1248.   goto yynewstate;
  1249.  
  1250. /* Do the default action for the current state.  */
  1251. yydefault:
  1252.  
  1253.   yyn = yydefact[yystate];
  1254.   if (yyn == 0)
  1255.     goto yyerrlab;
  1256.  
  1257. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  1258. yyreduce:
  1259.   yylen = yyr2[yyn];
  1260.   if (yylen > 0)
  1261.     yyval = yyvsp[1-yylen]; /* implement default value of the action */
  1262.  
  1263. #if YYDEBUG != 0
  1264.   if (yydebug)
  1265.     {
  1266.       int i;
  1267.  
  1268.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  1269.            yyn, yyrline[yyn]);
  1270.  
  1271.       /* Print the symbols being reduced, and their result.  */
  1272.       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
  1273.     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
  1274.       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
  1275.     }
  1276. #endif
  1277.  
  1278.  
  1279.   switch (yyn) {
  1280.  
  1281. case 1:
  1282. #line 151 "./awk.y"
  1283. {
  1284.             expression_value = yyvsp[-1].nodeval;
  1285.             check_funcs();
  1286.         ;
  1287.     break;}
  1288. case 2:
  1289. #line 159 "./awk.y"
  1290. { 
  1291.             if (yyvsp[0].nodeval != NULL)
  1292.                 yyval.nodeval = yyvsp[0].nodeval;
  1293.             else
  1294.                 yyval.nodeval = NULL;
  1295.             yyerrok;
  1296.         ;
  1297.     break;}
  1298. case 3:
  1299. #line 168 "./awk.y"
  1300. {
  1301.             if (yyvsp[0].nodeval == NULL)
  1302.                 yyval.nodeval = yyvsp[-1].nodeval;
  1303.             else if (yyvsp[-1].nodeval == NULL)
  1304.                 yyval.nodeval = yyvsp[0].nodeval;
  1305.             else {
  1306.                 if (yyvsp[-1].nodeval->type != Node_rule_list)
  1307.                     yyvsp[-1].nodeval = node(yyvsp[-1].nodeval, Node_rule_list,
  1308.                         (NODE*) NULL);
  1309.                 yyval.nodeval = append_right(yyvsp[-1].nodeval,
  1310.                    node(yyvsp[0].nodeval, Node_rule_list, (NODE *) NULL));
  1311.             }
  1312.             yyerrok;
  1313.         ;
  1314.     break;}
  1315. case 4:
  1316. #line 182 "./awk.y"
  1317. { yyval.nodeval = NULL; ;
  1318.     break;}
  1319. case 5:
  1320. #line 183 "./awk.y"
  1321. { yyval.nodeval = NULL; ;
  1322.     break;}
  1323. case 6:
  1324. #line 184 "./awk.y"
  1325. { yyval.nodeval = NULL; ;
  1326.     break;}
  1327. case 7:
  1328. #line 188 "./awk.y"
  1329. { io_allowed = FALSE; ;
  1330.     break;}
  1331. case 8:
  1332. #line 190 "./awk.y"
  1333. {
  1334.         if (begin_block != NULL) {
  1335.             if (begin_block->type != Node_rule_list)
  1336.                 begin_block = node(begin_block, Node_rule_list,
  1337.                     (NODE *) NULL);
  1338.             (void) append_right(begin_block, node(
  1339.                 node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval),
  1340.                 Node_rule_list, (NODE *) NULL) );
  1341.         } else
  1342.             begin_block = node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval);
  1343.         yyval.nodeval = NULL;
  1344.         io_allowed = TRUE;
  1345.         yyerrok;
  1346.       ;
  1347.     break;}
  1348. case 9:
  1349. #line 204 "./awk.y"
  1350. { io_allowed = FALSE; ;
  1351.     break;}
  1352. case 10:
  1353. #line 206 "./awk.y"
  1354. {
  1355.         if (end_block != NULL) {
  1356.             if (end_block->type != Node_rule_list)
  1357.                 end_block = node(end_block, Node_rule_list,
  1358.                     (NODE *) NULL);
  1359.             (void) append_right (end_block, node(
  1360.                 node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval),
  1361.                 Node_rule_list, (NODE *) NULL));
  1362.         } else
  1363.             end_block = node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval);
  1364.         yyval.nodeval = NULL;
  1365.         io_allowed = TRUE;
  1366.         yyerrok;
  1367.       ;
  1368.     break;}
  1369. case 11:
  1370. #line 221 "./awk.y"
  1371. {
  1372.         warning("BEGIN blocks must have an action part");
  1373.         errcount++;
  1374.         yyerrok;
  1375.       ;
  1376.     break;}
  1377. case 12:
  1378. #line 227 "./awk.y"
  1379. {
  1380.         warning("END blocks must have an action part");
  1381.         errcount++;
  1382.         yyerrok;
  1383.       ;
  1384.     break;}
  1385. case 13:
  1386. #line 233 "./awk.y"
  1387. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_rule_node, yyvsp[0].nodeval); yyerrok; ;
  1388.     break;}
  1389. case 14:
  1390. #line 235 "./awk.y"
  1391. { yyval.nodeval = node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval); yyerrok; ;
  1392.     break;}
  1393. case 15:
  1394. #line 237 "./awk.y"
  1395. {
  1396.           yyval.nodeval = node(yyvsp[-1].nodeval,
  1397.                  Node_rule_node,
  1398.                  node(node(node(make_number(0.0),
  1399.                         Node_field_spec,
  1400.                         (NODE *) NULL),
  1401.                     Node_expression_list,
  1402.                     (NODE *) NULL),
  1403.                   Node_K_print,
  1404.                   (NODE *) NULL));
  1405.           yyerrok;
  1406.         ;
  1407.     break;}
  1408. case 16:
  1409. #line 250 "./awk.y"
  1410. {
  1411.             func_install(yyvsp[-1].nodeval, yyvsp[0].nodeval);
  1412.             yyval.nodeval = NULL;
  1413.             yyerrok;
  1414.         ;
  1415.     break;}
  1416. case 17:
  1417. #line 259 "./awk.y"
  1418. { yyval.sval = yyvsp[0].sval; ;
  1419.     break;}
  1420. case 18:
  1421. #line 261 "./awk.y"
  1422. { yyval.sval = yyvsp[0].sval; ;
  1423.     break;}
  1424. case 19:
  1425. #line 263 "./awk.y"
  1426. {
  1427.         yyerror("%s() is a built-in function, it cannot be redefined",
  1428.             tokstart);
  1429.         errcount++;
  1430.         /* yyerrok; */
  1431.       ;
  1432.     break;}
  1433. case 22:
  1434. #line 278 "./awk.y"
  1435. {
  1436.             param_counter = 0;
  1437.         ;
  1438.     break;}
  1439. case 23:
  1440. #line 282 "./awk.y"
  1441. {
  1442.             NODE *t;
  1443.  
  1444.             t = make_param(yyvsp[-4].sval);
  1445.             t->flags |= FUNC;
  1446.             yyval.nodeval = append_right(t, yyvsp[-2].nodeval);
  1447.             can_return = TRUE;
  1448.             /* check for duplicate parameter names */
  1449.             if (dup_parms(yyval.nodeval))
  1450.                 errcount++;
  1451.         ;
  1452.     break;}
  1453. case 24:
  1454. #line 297 "./awk.y"
  1455. {
  1456.         yyval.nodeval = yyvsp[-2].nodeval;
  1457.         can_return = FALSE;
  1458.       ;
  1459.     break;}
  1460. case 25:
  1461. #line 302 "./awk.y"
  1462. {
  1463.         yyval.nodeval = node((NODE *) NULL, Node_K_return, (NODE *) NULL);
  1464.         can_return = FALSE;
  1465.       ;
  1466.     break;}
  1467. case 26:
  1468. #line 311 "./awk.y"
  1469. { yyval.nodeval = yyvsp[0].nodeval; ;
  1470.     break;}
  1471. case 27:
  1472. #line 313 "./awk.y"
  1473. { yyval.nodeval = mkrangenode(node(yyvsp[-2].nodeval, Node_cond_pair, yyvsp[0].nodeval)); ;
  1474.     break;}
  1475. case 28:
  1476. #line 322 "./awk.y"
  1477. { ++want_regexp; ;
  1478.     break;}
  1479. case 29:
  1480. #line 324 "./awk.y"
  1481. {
  1482.           NODE *n;
  1483.           size_t len;
  1484.  
  1485.           getnode(n);
  1486.           n->type = Node_regex;
  1487.           len = strlen(yyvsp[-1].sval);
  1488.           n->re_exp = make_string(yyvsp[-1].sval, len);
  1489.           n->re_reg = make_regexp(yyvsp[-1].sval, len, FALSE, TRUE);
  1490.           n->re_text = NULL;
  1491.           n->re_flags = CONST;
  1492.           n->re_cnt = 1;
  1493.           yyval.nodeval = n;
  1494.         ;
  1495.     break;}
  1496. case 30:
  1497. #line 342 "./awk.y"
  1498. { yyval.nodeval = yyvsp[-3].nodeval; ;
  1499.     break;}
  1500. case 31:
  1501. #line 344 "./awk.y"
  1502. { yyval.nodeval = NULL; ;
  1503.     break;}
  1504. case 32:
  1505. #line 349 "./awk.y"
  1506. {
  1507.             yyval.nodeval = yyvsp[0].nodeval;
  1508.             if (do_lint && isnoeffect(yyval.nodeval->type))
  1509.                 warning("statement may have no effect");
  1510.         ;
  1511.     break;}
  1512. case 33:
  1513. #line 355 "./awk.y"
  1514. {
  1515.             if (yyvsp[-1].nodeval == NULL || yyvsp[-1].nodeval->type != Node_statement_list)
  1516.                 yyvsp[-1].nodeval = node(yyvsp[-1].nodeval, Node_statement_list, (NODE *) NULL);
  1517.                 yyval.nodeval = append_right(yyvsp[-1].nodeval,
  1518.                 node(yyvsp[0].nodeval, Node_statement_list, (NODE *)   NULL));
  1519.                 yyerrok;
  1520.         ;
  1521.     break;}
  1522. case 34:
  1523. #line 363 "./awk.y"
  1524. { yyval.nodeval = NULL; ;
  1525.     break;}
  1526. case 35:
  1527. #line 365 "./awk.y"
  1528. { yyval.nodeval = NULL; ;
  1529.     break;}
  1530. case 38:
  1531. #line 375 "./awk.y"
  1532. { yyval.nodeval = NULL; ;
  1533.     break;}
  1534. case 39:
  1535. #line 377 "./awk.y"
  1536. { yyval.nodeval = NULL; ;
  1537.     break;}
  1538. case 40:
  1539. #line 379 "./awk.y"
  1540. { yyval.nodeval = yyvsp[-1].nodeval; ;
  1541.     break;}
  1542. case 41:
  1543. #line 381 "./awk.y"
  1544. { yyval.nodeval = yyvsp[0].nodeval; ;
  1545.     break;}
  1546. case 42:
  1547. #line 383 "./awk.y"
  1548. { yyval.nodeval = node(yyvsp[-3].nodeval, Node_K_while, yyvsp[0].nodeval); ;
  1549.     break;}
  1550. case 43:
  1551. #line 385 "./awk.y"
  1552. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_K_do, yyvsp[-5].nodeval); ;
  1553.     break;}
  1554. case 44:
  1555. #line 387 "./awk.y"
  1556. {
  1557.         yyval.nodeval = node(yyvsp[0].nodeval, Node_K_arrayfor,
  1558.             make_for_loop(variable(yyvsp[-5].sval, CAN_FREE, Node_var),
  1559.             (NODE *) NULL, variable(yyvsp[-3].sval, CAN_FREE, Node_var_array)));
  1560.       ;
  1561.     break;}
  1562. case 45:
  1563. #line 393 "./awk.y"
  1564. {
  1565.         yyval.nodeval = node(yyvsp[0].nodeval, Node_K_for, (NODE *) make_for_loop(yyvsp[-7].nodeval, yyvsp[-5].nodeval, yyvsp[-3].nodeval));
  1566.       ;
  1567.     break;}
  1568. case 46:
  1569. #line 397 "./awk.y"
  1570. {
  1571.         yyval.nodeval = node(yyvsp[0].nodeval, Node_K_for,
  1572.             (NODE *) make_for_loop(yyvsp[-6].nodeval, (NODE *) NULL, yyvsp[-3].nodeval));
  1573.       ;
  1574.     break;}
  1575. case 47:
  1576. #line 403 "./awk.y"
  1577. { yyval.nodeval = node((NODE *) NULL, Node_K_break, (NODE *) NULL); ;
  1578.     break;}
  1579. case 48:
  1580. #line 406 "./awk.y"
  1581. { yyval.nodeval = node((NODE *) NULL, Node_K_continue, (NODE *) NULL); ;
  1582.     break;}
  1583. case 49:
  1584. #line 408 "./awk.y"
  1585. { yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-5].nodetypeval, yyvsp[-1].nodeval); ;
  1586.     break;}
  1587. case 50:
  1588. #line 410 "./awk.y"
  1589. {
  1590.             if (yyvsp[-3].nodetypeval == Node_K_print && yyvsp[-2].nodeval == NULL) {
  1591.                 static int warned = FALSE;
  1592.  
  1593.                 yyvsp[-2].nodeval = node(node(make_number(0.0),
  1594.                            Node_field_spec,
  1595.                            (NODE *) NULL),
  1596.                       Node_expression_list,
  1597.                       (NODE *) NULL);
  1598.  
  1599.                 if (do_lint && ! io_allowed && ! warned) {
  1600.                     warned = TRUE;
  1601.                     warning(
  1602.     "plain `print' in BEGIN or END rule should probably be `print \"\"'");
  1603.                 }
  1604.             }
  1605.  
  1606.             yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-3].nodetypeval, yyvsp[-1].nodeval);
  1607.         ;
  1608.     break;}
  1609. case 51:
  1610. #line 430 "./awk.y"
  1611. { NODETYPE type;
  1612.  
  1613.           if (yyvsp[-1].nodeval) {
  1614.             if (yyvsp[-1].nodeval == lookup("file")) {
  1615.                 static int warned = FALSE;
  1616.  
  1617.                 if (! warned) {
  1618.                     warned = TRUE;
  1619.                     warning("`next file' is obsolete; use `nextfile'");
  1620.                 }
  1621.                 if (do_lint)
  1622.                     warning("`next file' is a gawk extension");
  1623.                 if (do_traditional) {
  1624.                     /*
  1625.                      * can't use yyerror, since may have overshot
  1626.                      * the source line
  1627.                      */
  1628.                     errcount++;
  1629.                     error("`next file' is a gawk extension");
  1630.                 }
  1631.                 if (! io_allowed) {
  1632.                     /* same thing */
  1633.                     errcount++;
  1634.                     error("`next file' used in BEGIN or END action");
  1635.                 }
  1636.                 type = Node_K_nextfile;
  1637.             } else {
  1638.                 errcount++;
  1639.                 error("illegal expression after `next'");
  1640.                 type = Node_K_next;    /* sanity */
  1641.             }
  1642.           } else {
  1643.             if (! io_allowed)
  1644.                 yyerror("`next' used in BEGIN or END action");
  1645.             type = Node_K_next;
  1646.           }
  1647.           yyval.nodeval = node((NODE *) NULL, type, (NODE *) NULL);
  1648.         ;
  1649.     break;}
  1650. case 52:
  1651. #line 469 "./awk.y"
  1652. {
  1653.           if (do_lint)
  1654.             warning("`nextfile' is a gawk extension");
  1655.           if (do_traditional) {
  1656.             /*
  1657.              * can't use yyerror, since may have overshot
  1658.              * the source line
  1659.              */
  1660.             errcount++;
  1661.             error("`nextfile' is a gawk extension");
  1662.           }
  1663.           if (! io_allowed) {
  1664.             /* same thing */
  1665.             errcount++;
  1666.             error("`nextfile' used in BEGIN or END action");
  1667.           }
  1668.           yyval.nodeval = node((NODE *) NULL, Node_K_nextfile, (NODE *) NULL);
  1669.         ;
  1670.     break;}
  1671. case 53:
  1672. #line 488 "./awk.y"
  1673. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_exit, (NODE *) NULL); ;
  1674.     break;}
  1675. case 54:
  1676. #line 490 "./awk.y"
  1677. {
  1678.           if (! can_return)
  1679.             yyerror("`return' used outside function context");
  1680.         ;
  1681.     break;}
  1682. case 55:
  1683. #line 495 "./awk.y"
  1684. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_return, (NODE *) NULL); ;
  1685.     break;}
  1686. case 56:
  1687. #line 497 "./awk.y"
  1688. { yyval.nodeval = node(variable(yyvsp[-4].sval, CAN_FREE, Node_var_array), Node_K_delete, yyvsp[-2].nodeval); ;
  1689.     break;}
  1690. case 57:
  1691. #line 499 "./awk.y"
  1692. {
  1693.           if (do_lint)
  1694.             warning("`delete array' is a gawk extension");
  1695.           if (do_traditional) {
  1696.             /*
  1697.              * can't use yyerror, since may have overshot
  1698.              * the source line
  1699.              */
  1700.             errcount++;
  1701.             error("`delete array' is a gawk extension");
  1702.           }
  1703.           yyval.nodeval = node(variable(yyvsp[-1].sval, CAN_FREE, Node_var_array), Node_K_delete, (NODE *) NULL);
  1704.         ;
  1705.     break;}
  1706. case 58:
  1707. #line 513 "./awk.y"
  1708. { yyval.nodeval = yyvsp[-1].nodeval; ;
  1709.     break;}
  1710. case 59:
  1711. #line 518 "./awk.y"
  1712. { yyval.nodetypeval = yyvsp[0].nodetypeval; ;
  1713.     break;}
  1714. case 60:
  1715. #line 520 "./awk.y"
  1716. { yyval.nodetypeval = yyvsp[0].nodetypeval; ;
  1717.     break;}
  1718. case 61:
  1719. #line 525 "./awk.y"
  1720. {
  1721.         yyval.nodeval = node(yyvsp[-3].nodeval, Node_K_if, 
  1722.             node(yyvsp[0].nodeval, Node_if_branches, (NODE *) NULL));
  1723.       ;
  1724.     break;}
  1725. case 62:
  1726. #line 531 "./awk.y"
  1727. { yyval.nodeval = node(yyvsp[-6].nodeval, Node_K_if,
  1728.                 node(yyvsp[-3].nodeval, Node_if_branches, yyvsp[0].nodeval)); ;
  1729.     break;}
  1730. case 63:
  1731. #line 537 "./awk.y"
  1732. { want_assign = FALSE; ;
  1733.     break;}
  1734. case 67:
  1735. #line 548 "./awk.y"
  1736. { yyval.nodeval = NULL; ;
  1737.     break;}
  1738. case 68:
  1739. #line 550 "./awk.y"
  1740. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_input, (NODE *) NULL); ;
  1741.     break;}
  1742. case 69:
  1743. #line 555 "./awk.y"
  1744. { yyval.nodeval = NULL; ;
  1745.     break;}
  1746. case 70:
  1747. #line 557 "./awk.y"
  1748. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_output, (NODE *) NULL); ;
  1749.     break;}
  1750. case 71:
  1751. #line 559 "./awk.y"
  1752. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_append, (NODE *) NULL); ;
  1753.     break;}
  1754. case 72:
  1755. #line 561 "./awk.y"
  1756. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_pipe, (NODE *) NULL); ;
  1757.     break;}
  1758. case 73:
  1759. #line 566 "./awk.y"
  1760. { yyval.nodeval = NULL; ;
  1761.     break;}
  1762. case 74:
  1763. #line 568 "./awk.y"
  1764. { yyval.nodeval = yyvsp[0].nodeval; ;
  1765.     break;}
  1766. case 75:
  1767. #line 573 "./awk.y"
  1768. { yyval.nodeval = make_param(yyvsp[0].sval); ;
  1769.     break;}
  1770. case 76:
  1771. #line 575 "./awk.y"
  1772. { yyval.nodeval = append_right(yyvsp[-2].nodeval, make_param(yyvsp[0].sval)); yyerrok; ;
  1773.     break;}
  1774. case 77:
  1775. #line 577 "./awk.y"
  1776. { yyval.nodeval = NULL; ;
  1777.     break;}
  1778. case 78:
  1779. #line 579 "./awk.y"
  1780. { yyval.nodeval = NULL; ;
  1781.     break;}
  1782. case 79:
  1783. #line 581 "./awk.y"
  1784. { yyval.nodeval = NULL; ;
  1785.     break;}
  1786. case 80:
  1787. #line 587 "./awk.y"
  1788. { yyval.nodeval = NULL; ;
  1789.     break;}
  1790. case 81:
  1791. #line 589 "./awk.y"
  1792. { yyval.nodeval = yyvsp[0].nodeval; ;
  1793.     break;}
  1794. case 82:
  1795. #line 594 "./awk.y"
  1796. { yyval.nodeval = NULL; ;
  1797.     break;}
  1798. case 83:
  1799. #line 596 "./awk.y"
  1800. { yyval.nodeval = yyvsp[0].nodeval; ;
  1801.     break;}
  1802. case 84:
  1803. #line 601 "./awk.y"
  1804. { yyval.nodeval = node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL); ;
  1805.     break;}
  1806. case 85:
  1807. #line 603 "./awk.y"
  1808. {
  1809.         yyval.nodeval = append_right(yyvsp[-2].nodeval,
  1810.             node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL));
  1811.         yyerrok;
  1812.       ;
  1813.     break;}
  1814. case 86:
  1815. #line 609 "./awk.y"
  1816. { yyval.nodeval = NULL; ;
  1817.     break;}
  1818. case 87:
  1819. #line 611 "./awk.y"
  1820. { yyval.nodeval = NULL; ;
  1821.     break;}
  1822. case 88:
  1823. #line 613 "./awk.y"
  1824. { yyval.nodeval = NULL; ;
  1825.     break;}
  1826. case 89:
  1827. #line 615 "./awk.y"
  1828. { yyval.nodeval = NULL; ;
  1829.     break;}
  1830. case 90:
  1831. #line 620 "./awk.y"
  1832. { yyval.nodeval = NULL; ;
  1833.     break;}
  1834. case 91:
  1835. #line 622 "./awk.y"
  1836. { yyval.nodeval = yyvsp[0].nodeval; ;
  1837.     break;}
  1838. case 92:
  1839. #line 627 "./awk.y"
  1840. { yyval.nodeval = node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL); ;
  1841.     break;}
  1842. case 93:
  1843. #line 629 "./awk.y"
  1844. {
  1845.             yyval.nodeval = append_right(yyvsp[-2].nodeval,
  1846.                 node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL));
  1847.             yyerrok;
  1848.         ;
  1849.     break;}
  1850. case 94:
  1851. #line 635 "./awk.y"
  1852. { yyval.nodeval = NULL; ;
  1853.     break;}
  1854. case 95:
  1855. #line 637 "./awk.y"
  1856. { yyval.nodeval = NULL; ;
  1857.     break;}
  1858. case 96:
  1859. #line 639 "./awk.y"
  1860. { yyval.nodeval = NULL; ;
  1861.     break;}
  1862. case 97:
  1863. #line 641 "./awk.y"
  1864. { yyval.nodeval = NULL; ;
  1865.     break;}
  1866. case 98:
  1867. #line 646 "./awk.y"
  1868. { want_assign = FALSE; ;
  1869.     break;}
  1870. case 99:
  1871. #line 648 "./awk.y"
  1872. {
  1873.           if (do_lint && yyvsp[0].nodeval->type == Node_regex)
  1874.             warning("Regular expression on left of assignment.");
  1875.           yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-2].nodetypeval, yyvsp[0].nodeval);
  1876.         ;
  1877.     break;}
  1878. case 100:
  1879. #line 654 "./awk.y"
  1880. { yyval.nodeval = node(variable(yyvsp[0].sval, CAN_FREE, Node_var_array), Node_in_array, yyvsp[-3].nodeval); ;
  1881.     break;}
  1882. case 101:
  1883. #line 656 "./awk.y"
  1884. {
  1885.           yyval.nodeval = node(yyvsp[0].nodeval, Node_K_getline,
  1886.              node(yyvsp[-3].nodeval, Node_redirect_pipein, (NODE *) NULL));
  1887.         ;
  1888.     break;}
  1889. case 102:
  1890. #line 661 "./awk.y"
  1891. {
  1892.           if (do_lint && ! io_allowed && yyvsp[0].nodeval == NULL)
  1893.             warning("non-redirected getline undefined inside BEGIN or END action");
  1894.           yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_getline, yyvsp[0].nodeval);
  1895.         ;
  1896.     break;}
  1897. case 103:
  1898. #line 667 "./awk.y"
  1899. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_and, yyvsp[0].nodeval); ;
  1900.     break;}
  1901. case 104:
  1902. #line 669 "./awk.y"
  1903. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_or, yyvsp[0].nodeval); ;
  1904.     break;}
  1905. case 105:
  1906. #line 671 "./awk.y"
  1907. {
  1908.           if (yyvsp[-2].nodeval->type == Node_regex)
  1909.             warning("Regular expression on left of MATCH operator.");
  1910.           yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, mk_rexp(yyvsp[0].nodeval));
  1911.         ;
  1912.     break;}
  1913. case 106:
  1914. #line 677 "./awk.y"
  1915. {
  1916.           yyval.nodeval = yyvsp[0].nodeval;
  1917.           if (do_lint && tokstart[0] == '*') {
  1918.             /* possible C comment */
  1919.             int n = strlen(tokstart) - 1;
  1920.             if (tokstart[n] == '*')
  1921.                 warning("regexp looks like a C comment, but is not");
  1922.           }
  1923.         ;
  1924.     break;}
  1925. case 107:
  1926. #line 687 "./awk.y"
  1927. {
  1928.           yyval.nodeval = node(node(make_number(0.0),
  1929.                  Node_field_spec,
  1930.                  (NODE *) NULL),
  1931.                     Node_nomatch,
  1932.                 yyvsp[0].nodeval);
  1933.         ;
  1934.     break;}
  1935. case 108:
  1936. #line 695 "./awk.y"
  1937. { yyval.nodeval = node(variable(yyvsp[0].sval, CAN_FREE, Node_var_array), Node_in_array, yyvsp[-2].nodeval); ;
  1938.     break;}
  1939. case 109:
  1940. #line 697 "./awk.y"
  1941. {
  1942.           if (do_lint && yyvsp[0].nodeval->type == Node_regex)
  1943.             warning("Regular expression on left of comparison.");
  1944.           yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval);
  1945.         ;
  1946.     break;}
  1947. case 110:
  1948. #line 703 "./awk.y"
  1949. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_less, yyvsp[0].nodeval); ;
  1950.     break;}
  1951. case 111:
  1952. #line 705 "./awk.y"
  1953. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_greater, yyvsp[0].nodeval); ;
  1954.     break;}
  1955. case 112:
  1956. #line 707 "./awk.y"
  1957. { yyval.nodeval = node(yyvsp[-4].nodeval, Node_cond_exp, node(yyvsp[-2].nodeval, Node_if_branches, yyvsp[0].nodeval));;
  1958.     break;}
  1959. case 113:
  1960. #line 709 "./awk.y"
  1961. { yyval.nodeval = yyvsp[0].nodeval; ;
  1962.     break;}
  1963. case 114:
  1964. #line 711 "./awk.y"
  1965. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_concat, yyvsp[0].nodeval); ;
  1966.     break;}
  1967. case 115:
  1968. #line 716 "./awk.y"
  1969. { want_assign = FALSE; ;
  1970.     break;}
  1971. case 116:
  1972. #line 718 "./awk.y"
  1973. { yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-2].nodetypeval, yyvsp[0].nodeval); ;
  1974.     break;}
  1975. case 117:
  1976. #line 720 "./awk.y"
  1977. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_and, yyvsp[0].nodeval); ;
  1978.     break;}
  1979. case 118:
  1980. #line 722 "./awk.y"
  1981. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_or, yyvsp[0].nodeval); ;
  1982.     break;}
  1983. case 119:
  1984. #line 724 "./awk.y"
  1985. {
  1986.           if (do_lint && ! io_allowed && yyvsp[0].nodeval == NULL)
  1987.             warning("non-redirected getline undefined inside BEGIN or END action");
  1988.           yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_getline, yyvsp[0].nodeval);
  1989.         ;
  1990.     break;}
  1991. case 120:
  1992. #line 730 "./awk.y"
  1993. { yyval.nodeval = yyvsp[0].nodeval; ;
  1994.     break;}
  1995. case 121:
  1996. #line 732 "./awk.y"
  1997. { yyval.nodeval = node((NODE *) NULL, Node_nomatch, yyvsp[0].nodeval); ;
  1998.     break;}
  1999. case 122:
  2000. #line 734 "./awk.y"
  2001. { yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, mk_rexp(yyvsp[0].nodeval)); ;
  2002.     break;}
  2003. case 123:
  2004. #line 736 "./awk.y"
  2005. { yyval.nodeval = node(variable(yyvsp[0].sval, CAN_FREE, Node_var_array), Node_in_array, yyvsp[-2].nodeval); ;
  2006.     break;}
  2007. case 124:
  2008. #line 738 "./awk.y"
  2009. { yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ;
  2010.     break;}
  2011. case 125:
  2012. #line 740 "./awk.y"
  2013. { yyval.nodeval = node(yyvsp[-4].nodeval, Node_cond_exp, node(yyvsp[-2].nodeval, Node_if_branches, yyvsp[0].nodeval));;
  2014.     break;}
  2015. case 126:
  2016. #line 742 "./awk.y"
  2017. { yyval.nodeval = yyvsp[0].nodeval; ;
  2018.     break;}
  2019. case 127:
  2020. #line 744 "./awk.y"
  2021. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_concat, yyvsp[0].nodeval); ;
  2022.     break;}
  2023. case 129:
  2024. #line 751 "./awk.y"
  2025. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_exp, yyvsp[0].nodeval); ;
  2026.     break;}
  2027. case 130:
  2028. #line 753 "./awk.y"
  2029. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_times, yyvsp[0].nodeval); ;
  2030.     break;}
  2031. case 131:
  2032. #line 755 "./awk.y"
  2033. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_quotient, yyvsp[0].nodeval); ;
  2034.     break;}
  2035. case 132:
  2036. #line 757 "./awk.y"
  2037. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_mod, yyvsp[0].nodeval); ;
  2038.     break;}
  2039. case 133:
  2040. #line 759 "./awk.y"
  2041. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_plus, yyvsp[0].nodeval); ;
  2042.     break;}
  2043. case 134:
  2044. #line 761 "./awk.y"
  2045. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_minus, yyvsp[0].nodeval); ;
  2046.     break;}
  2047. case 135:
  2048. #line 763 "./awk.y"
  2049. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_postincrement, (NODE *) NULL); ;
  2050.     break;}
  2051. case 136:
  2052. #line 765 "./awk.y"
  2053. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_postdecrement, (NODE *) NULL); ;
  2054.     break;}
  2055. case 137:
  2056. #line 770 "./awk.y"
  2057. { yyval.nodeval = node(yyvsp[0].nodeval, Node_not, (NODE *) NULL); ;
  2058.     break;}
  2059. case 138:
  2060. #line 772 "./awk.y"
  2061. { yyval.nodeval = yyvsp[-1].nodeval; ;
  2062.     break;}
  2063. case 139:
  2064. #line 775 "./awk.y"
  2065. { yyval.nodeval = snode(yyvsp[-1].nodeval, Node_builtin, (int) yyvsp[-3].lval); ;
  2066.     break;}
  2067. case 140:
  2068. #line 777 "./awk.y"
  2069. { yyval.nodeval = snode(yyvsp[-1].nodeval, Node_builtin, (int) yyvsp[-3].lval); ;
  2070.     break;}
  2071. case 141:
  2072. #line 779 "./awk.y"
  2073. {
  2074.         if (do_lint)
  2075.             warning("call of `length' without parentheses is not portable");
  2076.         yyval.nodeval = snode((NODE *) NULL, Node_builtin, (int) yyvsp[0].lval);
  2077.         if (do_posix)
  2078.             warning("call of `length' without parentheses is deprecated by POSIX");
  2079.       ;
  2080.     break;}
  2081. case 142:
  2082. #line 787 "./awk.y"
  2083. {
  2084.         yyval.nodeval = node(yyvsp[-1].nodeval, Node_func_call, make_string(yyvsp[-3].sval, strlen(yyvsp[-3].sval)));
  2085.         func_use(yyvsp[-3].sval, FUNC_USE);
  2086.         param_sanity(yyvsp[-1].nodeval);
  2087.         free(yyvsp[-3].sval);
  2088.       ;
  2089.     break;}
  2090. case 144:
  2091. #line 795 "./awk.y"
  2092. { yyval.nodeval = node(yyvsp[0].nodeval, Node_preincrement, (NODE *) NULL); ;
  2093.     break;}
  2094. case 145:
  2095. #line 797 "./awk.y"
  2096. { yyval.nodeval = node(yyvsp[0].nodeval, Node_predecrement, (NODE *) NULL); ;
  2097.     break;}
  2098. case 146:
  2099. #line 799 "./awk.y"
  2100. { yyval.nodeval = yyvsp[0].nodeval; ;
  2101.     break;}
  2102. case 147:
  2103. #line 801 "./awk.y"
  2104. { yyval.nodeval = yyvsp[0].nodeval; ;
  2105.     break;}
  2106. case 148:
  2107. #line 804 "./awk.y"
  2108. {
  2109.           if (yyvsp[0].nodeval->type == Node_val) {
  2110.             yyvsp[0].nodeval->numbr = -(force_number(yyvsp[0].nodeval));
  2111.             yyval.nodeval = yyvsp[0].nodeval;
  2112.           } else
  2113.             yyval.nodeval = node(yyvsp[0].nodeval, Node_unary_minus, (NODE *) NULL);
  2114.         ;
  2115.     break;}
  2116. case 149:
  2117. #line 812 "./awk.y"
  2118. {
  2119.           /*
  2120.            * was: $$ = $2
  2121.            * POSIX semantics: force a conversion to numeric type
  2122.            */
  2123.           yyval.nodeval = node (make_number(0.0), Node_plus, yyvsp[0].nodeval);
  2124.         ;
  2125.     break;}
  2126. case 150:
  2127. #line 823 "./awk.y"
  2128. { yyval.nodeval = NULL; ;
  2129.     break;}
  2130. case 151:
  2131. #line 825 "./awk.y"
  2132. { yyval.nodeval = yyvsp[0].nodeval; ;
  2133.     break;}
  2134. case 152:
  2135. #line 830 "./awk.y"
  2136. { yyval.nodeval = variable(yyvsp[0].sval, CAN_FREE, Node_var); ;
  2137.     break;}
  2138. case 153:
  2139. #line 832 "./awk.y"
  2140. {
  2141.         if (yyvsp[-1].nodeval->rnode == NULL) {
  2142.             yyval.nodeval = node(variable(yyvsp[-3].sval, CAN_FREE, Node_var_array), Node_subscript, yyvsp[-1].nodeval->lnode);
  2143.             freenode(yyvsp[-1].nodeval);
  2144.         } else
  2145.             yyval.nodeval = node(variable(yyvsp[-3].sval, CAN_FREE, Node_var_array), Node_subscript, yyvsp[-1].nodeval);
  2146.         ;
  2147.     break;}
  2148. case 154:
  2149. #line 840 "./awk.y"
  2150. { yyval.nodeval = node(yyvsp[0].nodeval, Node_field_spec, (NODE *) NULL); ;
  2151.     break;}
  2152. case 156:
  2153. #line 848 "./awk.y"
  2154. { yyerrok; ;
  2155.     break;}
  2156. case 157:
  2157. #line 852 "./awk.y"
  2158. { yyerrok; ;
  2159.     break;}
  2160. case 160:
  2161. #line 861 "./awk.y"
  2162. { yyerrok; want_assign = FALSE; ;
  2163.     break;}
  2164. case 161:
  2165. #line 864 "./awk.y"
  2166. { yyerrok; ;
  2167.     break;}
  2168. }
  2169.    /* the action file gets copied in in place of this dollarsign */
  2170. #line 498 "/usr/local/share/bison.simple"
  2171.  
  2172.   yyvsp -= yylen;
  2173.   yyssp -= yylen;
  2174. #ifdef YYLSP_NEEDED
  2175.   yylsp -= yylen;
  2176. #endif
  2177.  
  2178. #if YYDEBUG != 0
  2179.   if (yydebug)
  2180.     {
  2181.       short *ssp1 = yyss - 1;
  2182.       fprintf (stderr, "state stack now");
  2183.       while (ssp1 != yyssp)
  2184.     fprintf (stderr, " %d", *++ssp1);
  2185.       fprintf (stderr, "\n");
  2186.     }
  2187. #endif
  2188.  
  2189.   *++yyvsp = yyval;
  2190.  
  2191. #ifdef YYLSP_NEEDED
  2192.   yylsp++;
  2193.   if (yylen == 0)
  2194.     {
  2195.       yylsp->first_line = yylloc.first_line;
  2196.       yylsp->first_column = yylloc.first_column;
  2197.       yylsp->last_line = (yylsp-1)->last_line;
  2198.       yylsp->last_column = (yylsp-1)->last_column;
  2199.       yylsp->text = 0;
  2200.     }
  2201.   else
  2202.     {
  2203.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  2204.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  2205.     }
  2206. #endif
  2207.  
  2208.   /* Now "shift" the result of the reduction.
  2209.      Determine what state that goes to,
  2210.      based on the state we popped back to
  2211.      and the rule number reduced by.  */
  2212.  
  2213.   yyn = yyr1[yyn];
  2214.  
  2215.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  2216.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  2217.     yystate = yytable[yystate];
  2218.   else
  2219.     yystate = yydefgoto[yyn - YYNTBASE];
  2220.  
  2221.   goto yynewstate;
  2222.  
  2223. yyerrlab:   /* here on detecting error */
  2224.  
  2225.   if (! yyerrstatus)
  2226.     /* If not already recovering from an error, report this error.  */
  2227.     {
  2228.       ++yynerrs;
  2229.  
  2230. #ifdef YYERROR_VERBOSE
  2231.       yyn = yypact[yystate];
  2232.  
  2233.       if (yyn > YYFLAG && yyn < YYLAST)
  2234.     {
  2235.       int size = 0;
  2236.       char *msg;
  2237.       int x, count;
  2238.  
  2239.       count = 0;
  2240.       /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
  2241.       for (x = (yyn < 0 ? -yyn : 0);
  2242.            x < (sizeof(yytname) / sizeof(char *)); x++)
  2243.         if (yycheck[x + yyn] == x)
  2244.           size += strlen(yytname[x]) + 15, count++;
  2245.       msg = (char *) malloc(size + 15);
  2246.       if (msg != 0)
  2247.         {
  2248.           strcpy(msg, "parse error");
  2249.  
  2250.           if (count < 5)
  2251.         {
  2252.           count = 0;
  2253.           for (x = (yyn < 0 ? -yyn : 0);
  2254.                x < (sizeof(yytname) / sizeof(char *)); x++)
  2255.             if (yycheck[x + yyn] == x)
  2256.               {
  2257.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  2258.             strcat(msg, yytname[x]);
  2259.             strcat(msg, "'");
  2260.             count++;
  2261.               }
  2262.         }
  2263.           yyerror(msg);
  2264.           free(msg);
  2265.         }
  2266.       else
  2267.         yyerror ("parse error; also virtual memory exceeded");
  2268.     }
  2269.       else
  2270. #endif /* YYERROR_VERBOSE */
  2271.     yyerror("parse error");
  2272.     }
  2273.  
  2274.   goto yyerrlab1;
  2275. yyerrlab1:   /* here on error raised explicitly by an action */
  2276.  
  2277.   if (yyerrstatus == 3)
  2278.     {
  2279.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  2280.  
  2281.       /* return failure if at end of input */
  2282.       if (yychar == YYEOF)
  2283.     YYABORT;
  2284.  
  2285. #if YYDEBUG != 0
  2286.       if (yydebug)
  2287.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  2288. #endif
  2289.  
  2290.       yychar = YYEMPTY;
  2291.     }
  2292.  
  2293.   /* Else will try to reuse lookahead token
  2294.      after shifting the error token.  */
  2295.  
  2296.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  2297.  
  2298.   goto yyerrhandle;
  2299.  
  2300. yyerrdefault:  /* current state does not do anything special for the error token. */
  2301.  
  2302. #if 0
  2303.   /* This is wrong; only states that explicitly want error tokens
  2304.      should shift them.  */
  2305.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  2306.   if (yyn) goto yydefault;
  2307. #endif
  2308.  
  2309. yyerrpop:   /* pop the current state because it cannot handle the error token */
  2310.  
  2311.   if (yyssp == yyss) YYABORT;
  2312.   yyvsp--;
  2313.   yystate = *--yyssp;
  2314. #ifdef YYLSP_NEEDED
  2315.   yylsp--;
  2316. #endif
  2317.  
  2318. #if YYDEBUG != 0
  2319.   if (yydebug)
  2320.     {
  2321.       short *ssp1 = yyss - 1;
  2322.       fprintf (stderr, "Error: state stack now");
  2323.       while (ssp1 != yyssp)
  2324.     fprintf (stderr, " %d", *++ssp1);
  2325.       fprintf (stderr, "\n");
  2326.     }
  2327. #endif
  2328.  
  2329. yyerrhandle:
  2330.  
  2331.   yyn = yypact[yystate];
  2332.   if (yyn == YYFLAG)
  2333.     goto yyerrdefault;
  2334.  
  2335.   yyn += YYTERROR;
  2336.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  2337.     goto yyerrdefault;
  2338.  
  2339.   yyn = yytable[yyn];
  2340.   if (yyn < 0)
  2341.     {
  2342.       if (yyn == YYFLAG)
  2343.     goto yyerrpop;
  2344.       yyn = -yyn;
  2345.       goto yyreduce;
  2346.     }
  2347.   else if (yyn == 0)
  2348.     goto yyerrpop;
  2349.  
  2350.   if (yyn == YYFINAL)
  2351.     YYACCEPT;
  2352.  
  2353. #if YYDEBUG != 0
  2354.   if (yydebug)
  2355.     fprintf(stderr, "Shifting error token, ");
  2356. #endif
  2357.  
  2358.   *++yyvsp = yylval;
  2359. #ifdef YYLSP_NEEDED
  2360.   *++yylsp = yylloc;
  2361. #endif
  2362.  
  2363.   yystate = yyn;
  2364.   goto yynewstate;
  2365. }
  2366. #line 867 "./awk.y"
  2367.  
  2368.  
  2369. struct token {
  2370.     const char *operator;        /* text to match */
  2371.     NODETYPE value;        /* node type */
  2372.     int class;        /* lexical class */
  2373.     unsigned flags;        /* # of args. allowed and compatability */
  2374. #    define    ARGS    0xFF    /* 0, 1, 2, 3 args allowed (any combination */
  2375. #    define    A(n)    (1<<(n))
  2376. #    define    VERSION    0xFF00    /* old awk is zero */
  2377. #    define    NOT_OLD        0x0100    /* feature not in old awk */
  2378. #    define    NOT_POSIX    0x0200    /* feature not in POSIX */
  2379. #    define    GAWKX        0x0400    /* gawk extension */
  2380. #    define    RESX        0x0800    /* Bell Labs Research extension */
  2381.     NODE *(*ptr)();        /* function that implements this keyword */
  2382. };
  2383.  
  2384. extern NODE
  2385.     *do_exp(),    *do_getline(),    *do_index(),    *do_length(),
  2386.     *do_sqrt(),    *do_log(),    *do_sprintf(),    *do_substr(),
  2387.     *do_split(),    *do_system(),    *do_int(),    *do_close(),
  2388.     *do_atan2(),    *do_sin(),    *do_cos(),    *do_rand(),
  2389.     *do_srand(),    *do_match(),    *do_tolower(),    *do_toupper(),
  2390.     *do_sub(),    *do_gsub(),    *do_strftime(),    *do_systime(),
  2391.     *do_fflush();
  2392.  
  2393. /* Tokentab is sorted ascii ascending order, so it can be binary searched. */
  2394.  
  2395. static struct token tokentab[] = {
  2396. {"BEGIN",    Node_illegal,     LEX_BEGIN,    0,        0},
  2397. {"END",        Node_illegal,     LEX_END,    0,        0},
  2398. #ifdef BITOPS
  2399. {"and",        Node_builtin,    LEX_BUILTIN,    GAWKX|A(2),    do_and},
  2400. #endif /* BITOPS */
  2401. {"atan2",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2),    do_atan2},
  2402. {"break",    Node_K_break,     LEX_BREAK,    0,        0},
  2403. {"close",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_close},
  2404. #ifdef BITOPS
  2405. {"compl",    Node_builtin,    LEX_BUILTIN,    GAWKX|A(1),    do_compl},
  2406. #endif /* BITOPS */
  2407. {"continue",    Node_K_continue, LEX_CONTINUE,    0,        0},
  2408. {"cos",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_cos},
  2409. {"delete",    Node_K_delete,     LEX_DELETE,    NOT_OLD,    0},
  2410. {"do",        Node_K_do,     LEX_DO,    NOT_OLD,    0},
  2411. {"else",    Node_illegal,     LEX_ELSE,    0,        0},
  2412. {"exit",    Node_K_exit,     LEX_EXIT,    0,        0},
  2413. {"exp",        Node_builtin,     LEX_BUILTIN,    A(1),        do_exp},
  2414. {"fflush",    Node_builtin,     LEX_BUILTIN,    RESX|A(0)|A(1), do_fflush},
  2415. {"for",        Node_K_for,     LEX_FOR,    0,        0},
  2416. {"func",    Node_K_function, LEX_FUNCTION,    NOT_POSIX|NOT_OLD,    0},
  2417. {"function",    Node_K_function, LEX_FUNCTION,    NOT_OLD,    0},
  2418. {"gensub",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(3)|A(4), do_gensub},
  2419. {"getline",    Node_K_getline,     LEX_GETLINE,    NOT_OLD,    0},
  2420. {"gsub",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2)|A(3), do_gsub},
  2421. {"if",        Node_K_if,     LEX_IF,    0,        0},
  2422. {"in",        Node_illegal,     LEX_IN,    0,        0},
  2423. {"index",    Node_builtin,     LEX_BUILTIN,    A(2),        do_index},
  2424. {"int",        Node_builtin,     LEX_BUILTIN,    A(1),        do_int},
  2425. {"length",    Node_builtin,     LEX_LENGTH,    A(0)|A(1),    do_length},
  2426. {"log",        Node_builtin,     LEX_BUILTIN,    A(1),        do_log},
  2427. #ifdef BITOPS
  2428. {"lshift",    Node_builtin,    LEX_BUILTIN,    GAWKX|A(2),    do_lshift},
  2429. #endif /* BITOPS */
  2430. {"match",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2),    do_match},
  2431. {"next",    Node_K_next,     LEX_NEXT,    0,        0},
  2432. {"nextfile",    Node_K_nextfile, LEX_NEXTFILE,    GAWKX,        0},
  2433. #ifdef BITOPS
  2434. {"or",        Node_builtin,    LEX_BUILTIN,    GAWKX|A(2),    do_or},
  2435. #endif /* BITOPS */
  2436. {"print",    Node_K_print,     LEX_PRINT,    0,        0},
  2437. {"printf",    Node_K_printf,     LEX_PRINTF,    0,        0},
  2438. {"rand",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(0),    do_rand},
  2439. {"return",    Node_K_return,     LEX_RETURN,    NOT_OLD,    0},
  2440. #ifdef BITOPS
  2441. {"rshift",    Node_builtin,    LEX_BUILTIN,    GAWKX|A(2),    do_rshift},
  2442. #endif /* BITOPS */
  2443. {"sin",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_sin},
  2444. {"split",    Node_builtin,     LEX_BUILTIN,    A(2)|A(3),    do_split},
  2445. {"sprintf",    Node_builtin,     LEX_BUILTIN,    0,        do_sprintf},
  2446. {"sqrt",    Node_builtin,     LEX_BUILTIN,    A(1),        do_sqrt},
  2447. {"srand",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(0)|A(1), do_srand},
  2448. {"strftime",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(0)|A(1)|A(2), do_strftime},
  2449. #ifdef BITOPS
  2450. {"strtonum",    Node_builtin,    LEX_BUILTIN,    GAWKX|A(1),    do_strtonum},
  2451. #endif /* BITOPS */
  2452. {"sub",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2)|A(3), do_sub},
  2453. {"substr",    Node_builtin,     LEX_BUILTIN,    A(2)|A(3),    do_substr},
  2454. {"system",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_system},
  2455. {"systime",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(0),    do_systime},
  2456. {"tolower",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_tolower},
  2457. {"toupper",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_toupper},
  2458. {"while",    Node_K_while,     LEX_WHILE,    0,        0},
  2459. #ifdef BITOPS
  2460. {"xor",        Node_builtin,    LEX_BUILTIN,    GAWKX|A(2),    do_xor},
  2461. #endif /* BITOPS */
  2462. };
  2463.  
  2464. /* yyerror --- print a syntax error message, show where */
  2465.  
  2466. #if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
  2467. static void
  2468. yyerror(const char *m, ...)
  2469. #else
  2470. /* VARARGS0 */
  2471. static void
  2472. yyerror(va_alist)
  2473. va_dcl
  2474. #endif
  2475. {
  2476.     va_list args;
  2477.     const char *mesg = NULL;
  2478.     register char *bp, *cp;
  2479.     char *scan;
  2480.     char buf[120];
  2481.     static char end_of_file_line[] = "(END OF FILE)";
  2482.  
  2483.     errcount++;
  2484.     /* Find the current line in the input file */
  2485.     if (lexptr && lexeme) {
  2486.         if (thisline == NULL) {
  2487.             cp = lexeme;
  2488.             if (*cp == '\n') {
  2489.                 cp--;
  2490.                 mesg = "unexpected newline";
  2491.             }
  2492.             for (; cp != lexptr_begin && *cp != '\n'; --cp)
  2493.                 continue;
  2494.             if (*cp == '\n')
  2495.                 cp++;
  2496.             thisline = cp;
  2497.         }
  2498.         /* NL isn't guaranteed */
  2499.         bp = lexeme;
  2500.         while (bp < lexend && *bp && *bp != '\n')
  2501.             bp++;
  2502.     } else {
  2503.         thisline = end_of_file_line;
  2504.         bp = thisline + strlen(thisline);
  2505.     }
  2506.     msg("%.*s", (int) (bp - thisline), thisline);
  2507.     bp = buf;
  2508.     cp = buf + sizeof(buf) - 24;    /* 24 more than longest msg. input */
  2509.     if (lexptr != NULL) {
  2510.         scan = thisline;
  2511.         while (bp < cp && scan < lexeme)
  2512.             if (*scan++ == '\t')
  2513.                 *bp++ = '\t';
  2514.             else
  2515.                 *bp++ = ' ';
  2516.         *bp++ = '^';
  2517.         *bp++ = ' ';
  2518.     }
  2519. #if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
  2520.     va_start(args, m);
  2521.     if (mesg == NULL)
  2522.         mesg = m;
  2523. #else
  2524.     va_start(args);
  2525.     if (mesg == NULL)
  2526.         mesg = va_arg(args, char *);
  2527. #endif
  2528.     strcpy(bp, mesg);
  2529.     err("", buf, args);
  2530.     va_end(args);
  2531. }
  2532.  
  2533. /* get_src_buf --- read the next buffer of source program */
  2534.  
  2535. static char *
  2536. get_src_buf()
  2537. {
  2538.     static int samefile = FALSE;
  2539.     static int nextfile = 0;
  2540.     static char *buf = NULL;
  2541.     static int fd;
  2542.     int n;
  2543.     register char *scan;
  2544.     static int len = 0;
  2545.     static int did_newline = FALSE;
  2546.     int newfile;
  2547.     struct stat sbuf;
  2548.  
  2549. #    define    SLOP    128    /* enough space to hold most source lines */
  2550.  
  2551. again:
  2552.     newfile = FALSE;
  2553.     if (nextfile > numfiles)
  2554.         return NULL;
  2555.  
  2556.     if (srcfiles[nextfile].stype == CMDLINE) {
  2557.         if (len == 0) {
  2558.             len = strlen(srcfiles[nextfile].val);
  2559.             if (len == 0) {
  2560.                 /*
  2561.                  * Yet Another Special case:
  2562.                  *    gawk '' /path/name
  2563.                  * Sigh.
  2564.                  */
  2565.                 static int warned = FALSE;
  2566.  
  2567.                 if (do_lint && ! warned) {
  2568.                     warned = TRUE;
  2569.                     warning("empty program text on command line");
  2570.                 }
  2571.                 ++nextfile;
  2572.                 goto again;
  2573.             }
  2574.             sourceline = 1;
  2575.             lexptr = lexptr_begin = srcfiles[nextfile].val;
  2576.             lexend = lexptr + len;
  2577.         } else if (! did_newline && *(lexptr-1) != '\n') {
  2578.             /*
  2579.              * The following goop is to ensure that the source
  2580.              * ends with a newline and that the entire current
  2581.              * line is available for error messages.
  2582.              */
  2583.             int offset;
  2584.  
  2585.             did_newline = TRUE;
  2586.             offset = lexptr - lexeme;
  2587.             for (scan = lexeme; scan > lexptr_begin; scan--)
  2588.                 if (*scan == '\n') {
  2589.                     scan++;
  2590.                     break;
  2591.                 }
  2592.             len = lexptr - scan;
  2593.             emalloc(buf, char *, len+1, "get_src_buf");
  2594.             memcpy(buf, scan, len);
  2595.             thisline = buf;
  2596.             lexptr = buf + len;
  2597.             *lexptr = '\n';
  2598.             lexeme = lexptr - offset;
  2599.             lexptr_begin = buf;
  2600.             lexend = lexptr + 1;
  2601.         } else {
  2602.             len = 0;
  2603.             lexeme = lexptr = lexptr_begin = NULL;
  2604.         }
  2605.         if (lexptr == NULL && ++nextfile <= numfiles)
  2606.             goto again;
  2607.         return lexptr;
  2608.     }
  2609.     if (! samefile) {
  2610.         source = srcfiles[nextfile].val;
  2611.         if (source == NULL) {
  2612.             if (buf != NULL) {
  2613.                 free(buf);
  2614.                 buf = NULL;
  2615.             }
  2616.             len = 0;
  2617.             return lexeme = lexptr = lexptr_begin = NULL;
  2618.         }
  2619.         fd = pathopen(source);
  2620.         if (fd <= INVALID_HANDLE) {
  2621.             char *in;
  2622.  
  2623.             /* suppress file name and line no. in error mesg */
  2624.             in = source;
  2625.             source = NULL;
  2626.             fatal("can't open source file \"%s\" for reading (%s)",
  2627.                 in, strerror(errno));
  2628.         }
  2629.         len = optimal_bufsize(fd, & sbuf);
  2630.         newfile = TRUE;
  2631.         if (buf != NULL)
  2632.             free(buf);
  2633.         emalloc(buf, char *, len + SLOP, "get_src_buf");
  2634.         lexptr_begin = buf + SLOP;
  2635.         samefile = TRUE;
  2636.         sourceline = 1;
  2637.     } else {
  2638.         /*
  2639.          * Here, we retain the current source line (up to length SLOP)
  2640.          * in the beginning of the buffer that was overallocated above
  2641.          */
  2642.         int offset;
  2643.         int linelen;
  2644.  
  2645.         offset = lexptr - lexeme;
  2646.         for (scan = lexeme; scan > lexptr_begin; scan--)
  2647.             if (*scan == '\n') {
  2648.                 scan++;
  2649.                 break;
  2650.             }
  2651.         linelen = lexptr - scan;
  2652.         if (linelen > SLOP)
  2653.             linelen = SLOP;
  2654.         thisline = buf + SLOP - linelen;
  2655.         memcpy(thisline, scan, linelen);
  2656.         lexeme = buf + SLOP - offset;
  2657.         lexptr_begin = thisline;
  2658.     }
  2659.     n = read(fd, buf + SLOP, len);
  2660.     if (n == -1)
  2661.         fatal("can't read sourcefile \"%s\" (%s)",
  2662.             source, strerror(errno));
  2663.     if (n == 0) {
  2664.         if (newfile) {
  2665.             static int warned = FALSE;
  2666.  
  2667.             if (do_lint && ! warned) {
  2668.                 warned = TRUE;
  2669.                 warning("source file `%s' is empty", source);
  2670.             }
  2671.         }
  2672.         close(fd);
  2673.         samefile = FALSE;
  2674.         nextfile++;
  2675.         if (lexeme)
  2676.             *lexeme = '\0';
  2677.         len = 0;
  2678.         goto again;
  2679.     }
  2680.     lexptr = buf + SLOP;
  2681.     lexend = lexptr + n;
  2682.     return buf;
  2683. }
  2684.  
  2685. /* tokadd --- add a character to the token buffer */
  2686.  
  2687. #define    tokadd(x) (*tok++ = (x), tok == tokend ? tokexpand() : tok)
  2688.  
  2689. /* tokexpand --- grow the token buffer */
  2690.  
  2691. char *
  2692. tokexpand()
  2693. {
  2694.     static int toksize = 60;
  2695.     int tokoffset;
  2696.  
  2697.     tokoffset = tok - tokstart;
  2698.     toksize *= 2;
  2699.     if (tokstart != NULL)
  2700.         erealloc(tokstart, char *, toksize, "tokexpand");
  2701.     else
  2702.         emalloc(tokstart, char *, toksize, "tokexpand");
  2703.     tokend = tokstart + toksize;
  2704.     tok = tokstart + tokoffset;
  2705.     return tok;
  2706. }
  2707.  
  2708. /* nextc --- get the next input character */
  2709.  
  2710. #if DEBUG
  2711. int
  2712. nextc()
  2713. {
  2714.     int c;
  2715.  
  2716.     if (lexptr && lexptr < lexend)
  2717.         c = *lexptr++;
  2718.     else if (get_src_buf())
  2719.         c = *lexptr++;
  2720.     else
  2721.         c = EOF;
  2722.  
  2723.     return c;
  2724. }
  2725. #else
  2726. #define    nextc()    ((lexptr && lexptr < lexend) ? \
  2727.             *lexptr++ : \
  2728.             (get_src_buf() ? *lexptr++ : EOF) \
  2729.         )
  2730. #endif
  2731.  
  2732. /* pushback --- push a character back on the input */
  2733.  
  2734. #define pushback() (lexptr && lexptr > lexptr_begin ? lexptr-- : lexptr)
  2735.  
  2736. /* allow_newline --- allow newline after &&, ||, ? and : */
  2737.  
  2738. static void
  2739. allow_newline()
  2740. {
  2741.     int c;
  2742.  
  2743.     for (;;) {
  2744.         c = nextc();
  2745.         if (c == EOF)
  2746.             break;
  2747.         if (c == '#') {
  2748.             while ((c = nextc()) != '\n' && c != EOF)
  2749.                 continue;
  2750.             if (c == EOF)
  2751.                 break;
  2752.         }
  2753.         if (c == '\n')
  2754.             sourceline++;
  2755.         if (! isspace(c)) {
  2756.             pushback();
  2757.             break;
  2758.         }
  2759.     }
  2760. }
  2761.  
  2762. /* yylex --- Read the input and turn it into tokens. */
  2763.  
  2764. static int
  2765. yylex()
  2766. {
  2767.     register int c, c1;
  2768.     int seen_e = FALSE;        /* These are for numbers */
  2769.     int seen_point = FALSE;
  2770.     int esc_seen;        /* for literal strings */
  2771.     int low, mid, high;
  2772.     static int did_newline = FALSE;
  2773.     char *tokkey;
  2774.     static int lasttok = 0, eof_warned = FALSE;
  2775.     int inhex = FALSE;
  2776.  
  2777.     if (nextc() == EOF) {
  2778.         if (lasttok != NEWLINE) {
  2779.             lasttok = NEWLINE;
  2780.             if (do_lint && ! eof_warned) {
  2781.                 warning("source file does not end in newline");
  2782.                 eof_warned = TRUE;
  2783.             }
  2784.             return NEWLINE;    /* fake it */
  2785.         }
  2786.         return 0;
  2787.     }
  2788.     pushback();
  2789. #ifdef OS2
  2790.     /*
  2791.      * added for OS/2's extproc feature of cmd.exe
  2792.      * (like #! in BSD sh)
  2793.      */
  2794.     if (strncasecmp(lexptr, "extproc ", 8) == 0) {
  2795.         while (*lexptr && *lexptr != '\n')
  2796.             lexptr++;
  2797.     }
  2798. #endif
  2799.     lexeme = lexptr;
  2800.     thisline = NULL;
  2801.     if (want_regexp) {
  2802.         int in_brack = 0;    /* count brackets, [[:alnum:]] allowed */
  2803.         /*
  2804.          * Counting brackets is non-trivial. [[] is ok,
  2805.          * and so is [\]], with a point being that /[/]/ as a regexp
  2806.          * constant has to work.
  2807.          *
  2808.          * Do not count [ or ] if either one is preceded by a \.
  2809.          * A `[' should be counted if
  2810.          *  a) it is the first one so far (in_brack == 0)
  2811.          *  b) it is the `[' in `[:'
  2812.          * A ']' should be counted if not preceded by a \, since
  2813.          * it is either closing `:]' or just a plain list.
  2814.          * According to POSIX, []] is how you put a ] into a set.
  2815.          * Try to handle that too.
  2816.          *
  2817.          * The code for \ handles \[ and \].
  2818.          */
  2819.  
  2820.         want_regexp = FALSE;
  2821.         tok = tokstart;
  2822.         for (;;) {
  2823.             c = nextc();
  2824.             switch (c) {
  2825.             case '[':
  2826.                 /* one day check for `.' and `=' too */
  2827.                 if ((c1 = nextc()) == ':' || in_brack == 0)
  2828.                     in_brack++;
  2829.                 pushback();
  2830.                 break;
  2831.             case ']':
  2832.                 if (tokstart[0] == '['
  2833.                     && (tok == tokstart + 1
  2834.                     || (tok == tokstart + 2
  2835.                         && tokstart[1] == '^')))
  2836.                     /* do nothing */;
  2837.                 else
  2838.                     in_brack--;
  2839.                 break;
  2840.             case '\\':
  2841.                 if ((c = nextc()) == EOF) {
  2842.                     yyerror("unterminated regexp ends with \\ at end of file");
  2843.                     return lasttok = REGEXP; /* kludge */
  2844.                 } else if (c == '\n') {
  2845.                     sourceline++;
  2846.                     continue;
  2847.                 } else {
  2848.                     tokadd('\\');
  2849.                     tokadd(c);
  2850.                     continue;
  2851.                 }
  2852.                 break;
  2853.             case '/':    /* end of the regexp */
  2854.                 if (in_brack > 0)
  2855.                     break;
  2856.  
  2857.                 pushback();
  2858.                 tokadd('\0');
  2859.                 yylval.sval = tokstart;
  2860.                 return lasttok = REGEXP;
  2861.             case '\n':
  2862.                 pushback();
  2863.                 yyerror("unterminated regexp");
  2864.                 return lasttok = REGEXP;    /* kludge */
  2865.             case EOF:
  2866.                 yyerror("unterminated regexp at end of file");
  2867.                 return lasttok = REGEXP;    /* kludge */
  2868.             }
  2869.             tokadd(c);
  2870.         }
  2871.     }
  2872. retry:
  2873.     while ((c = nextc()) == ' ' || c == '\t')
  2874.         continue;
  2875.  
  2876.     lexeme = lexptr ? lexptr - 1 : lexptr;
  2877.     thisline = NULL;
  2878.     tok = tokstart;
  2879.     yylval.nodetypeval = Node_illegal;
  2880.  
  2881.     switch (c) {
  2882.     case EOF:
  2883.         if (lasttok != NEWLINE) {
  2884.             lasttok = NEWLINE;
  2885.             if (do_lint && ! eof_warned) {
  2886.                 warning("source file does not end in newline");
  2887.                 eof_warned = TRUE;
  2888.             }
  2889.             return NEWLINE;    /* fake it */
  2890.         }
  2891.         return 0;
  2892.  
  2893.     case '\n':
  2894.         sourceline++;
  2895.         return lasttok = NEWLINE;
  2896.  
  2897.     case '#':        /* it's a comment */
  2898.         while ((c = nextc()) != '\n') {
  2899.             if (c == EOF) {
  2900.                 if (lasttok != NEWLINE) {
  2901.                     lasttok = NEWLINE;
  2902.                     if (do_lint && ! eof_warned) {
  2903.                         warning(
  2904.                 "source file does not end in newline");
  2905.                         eof_warned = TRUE;
  2906.                     }
  2907.                     return NEWLINE;    /* fake it */
  2908.                 }
  2909.                 return 0;
  2910.             }
  2911.         }
  2912.         sourceline++;
  2913.         return lasttok = NEWLINE;
  2914.  
  2915.     case '\\':
  2916. #ifdef RELAXED_CONTINUATION
  2917.         /*
  2918.          * This code puports to allow comments and/or whitespace
  2919.          * after the `\' at the end of a line used for continuation.
  2920.          * Use it at your own risk. We think it's a bad idea, which
  2921.          * is why it's not on by default.
  2922.          */
  2923.         if (! do_traditional) {
  2924.             /* strip trailing white-space and/or comment */
  2925.             while ((c = nextc()) == ' ' || c == '\t')
  2926.                 continue;
  2927.             if (c == '#') {
  2928.                 if (do_lint)
  2929.                     warning(
  2930.         "use of `\\ #...' line continuation is not portable");
  2931.                 while ((c = nextc()) != '\n')
  2932.                     if (c == EOF)
  2933.                         break;
  2934.             }
  2935.             pushback();
  2936.         }
  2937. #endif /* RELAXED_CONTINUATION */
  2938.         if (nextc() == '\n') {
  2939.             sourceline++;
  2940.             goto retry;
  2941.         } else {
  2942.             yyerror("backslash not last character on line");
  2943.             exit(1);
  2944.         }
  2945.         break;
  2946.  
  2947.     case '$':
  2948.         want_assign = TRUE;
  2949.         return lasttok = '$';
  2950.  
  2951.     case ':':
  2952.     case '?':
  2953.         allow_newline();
  2954.         /* fall through */
  2955.     case ')':
  2956.     case ']':
  2957.     case '(':    
  2958.     case '[':
  2959.     case ';':
  2960.     case '{':
  2961.     case ',':
  2962.         return lasttok = c;
  2963.  
  2964.     case '*':
  2965.         if ((c = nextc()) == '=') {
  2966.             yylval.nodetypeval = Node_assign_times;
  2967.             return lasttok = ASSIGNOP;
  2968.         } else if (do_posix) {
  2969.             pushback();
  2970.             return lasttok = '*';
  2971.         } else if (c == '*') {
  2972.             /* make ** and **= aliases for ^ and ^= */
  2973.             static int did_warn_op = FALSE, did_warn_assgn = FALSE;
  2974.  
  2975.             if (nextc() == '=') {
  2976.                 if (do_lint && ! did_warn_assgn) {
  2977.                     did_warn_assgn = TRUE;
  2978.                     warning("**= is not allowed by POSIX");
  2979.                     warning("operator `**=' is not supported in old awk");
  2980.                 }
  2981.                 yylval.nodetypeval = Node_assign_exp;
  2982.                 return ASSIGNOP;
  2983.             } else {
  2984.                 pushback();
  2985.                 if (do_lint && ! did_warn_op) {
  2986.                     did_warn_op = TRUE;
  2987.                     warning("** is not allowed by POSIX");
  2988.                     warning("operator `**' is not supported in old awk");
  2989.                 }
  2990.                 return lasttok = '^';
  2991.             }
  2992.         }
  2993.         pushback();
  2994.         return lasttok = '*';
  2995.  
  2996.     case '/':
  2997.         if (want_assign) {
  2998.             if (nextc() == '=') {
  2999.                 yylval.nodetypeval = Node_assign_quotient;
  3000.                 return lasttok = ASSIGNOP;
  3001.             }
  3002.             pushback();
  3003.         }
  3004.         return lasttok = '/';
  3005.  
  3006.     case '%':
  3007.         if (nextc() == '=') {
  3008.             yylval.nodetypeval = Node_assign_mod;
  3009.             return lasttok = ASSIGNOP;
  3010.         }
  3011.         pushback();
  3012.         return lasttok = '%';
  3013.  
  3014.     case '^':
  3015.     {
  3016.         static int did_warn_op = FALSE, did_warn_assgn = FALSE;
  3017.  
  3018.         if (nextc() == '=') {
  3019.             if (do_lint && ! did_warn_assgn) {
  3020.                 did_warn_assgn = TRUE;
  3021.                 warning("operator `^=' is not supported in old awk");
  3022.             }
  3023.             yylval.nodetypeval = Node_assign_exp;
  3024.             return lasttok = ASSIGNOP;
  3025.         }
  3026.         pushback();
  3027.         if (do_lint && ! did_warn_op) {
  3028.             did_warn_op = TRUE;
  3029.             warning("operator `^' is not supported in old awk");
  3030.         }
  3031.         return lasttok = '^';
  3032.     }
  3033.  
  3034.     case '+':
  3035.         if ((c = nextc()) == '=') {
  3036.             yylval.nodetypeval = Node_assign_plus;
  3037.             return lasttok = ASSIGNOP;
  3038.         }
  3039.         if (c == '+')
  3040.             return lasttok = INCREMENT;
  3041.         pushback();
  3042.         return lasttok = '+';
  3043.  
  3044.     case '!':
  3045.         if ((c = nextc()) == '=') {
  3046.             yylval.nodetypeval = Node_notequal;
  3047.             return lasttok = RELOP;
  3048.         }
  3049.         if (c == '~') {
  3050.             yylval.nodetypeval = Node_nomatch;
  3051.             want_assign = FALSE;
  3052.             return lasttok = MATCHOP;
  3053.         }
  3054.         pushback();
  3055.         return lasttok = '!';
  3056.  
  3057.     case '<':
  3058.         if (nextc() == '=') {
  3059.             yylval.nodetypeval = Node_leq;
  3060.             return lasttok = RELOP;
  3061.         }
  3062.         yylval.nodetypeval = Node_less;
  3063.         pushback();
  3064.         return lasttok = '<';
  3065.  
  3066.     case '=':
  3067.         if (nextc() == '=') {
  3068.             yylval.nodetypeval = Node_equal;
  3069.             return lasttok = RELOP;
  3070.         }
  3071.         yylval.nodetypeval = Node_assign;
  3072.         pushback();
  3073.         return lasttok = ASSIGNOP;
  3074.  
  3075.     case '>':
  3076.         if ((c = nextc()) == '=') {
  3077.             yylval.nodetypeval = Node_geq;
  3078.             return lasttok = RELOP;
  3079.         } else if (c == '>') {
  3080.             yylval.nodetypeval = Node_redirect_append;
  3081.             return lasttok = APPEND_OP;
  3082.         }
  3083.         yylval.nodetypeval = Node_greater;
  3084.         pushback();
  3085.         return lasttok = '>';
  3086.  
  3087.     case '~':
  3088.         yylval.nodetypeval = Node_match;
  3089.         want_assign = FALSE;
  3090.         return lasttok = MATCHOP;
  3091.  
  3092.     case '}':
  3093.         /*
  3094.          * Added did newline stuff.  Easier than
  3095.          * hacking the grammar.
  3096.          */
  3097.         if (did_newline) {
  3098.             did_newline = FALSE;
  3099.             return lasttok = c;
  3100.         }
  3101.         did_newline++;
  3102.         --lexptr;    /* pick up } next time */
  3103.         return lasttok = NEWLINE;
  3104.  
  3105.     case '"':
  3106.         esc_seen = FALSE;
  3107.         while ((c = nextc()) != '"') {
  3108.             if (c == '\n') {
  3109.                 pushback();
  3110.                 yyerror("unterminated string");
  3111.                 exit(1);
  3112.             }
  3113.             if (c == '\\') {
  3114.                 c = nextc();
  3115.                 if (c == '\n') {
  3116.                     sourceline++;
  3117.                     continue;
  3118.                 }
  3119.                 esc_seen = TRUE;
  3120.                 tokadd('\\');
  3121.             }
  3122.             if (c == EOF) {
  3123.                 pushback();
  3124.                 yyerror("unterminated string");
  3125.                 exit(1);
  3126.             }
  3127.             tokadd(c);
  3128.         }
  3129.         yylval.nodeval = make_str_node(tokstart,
  3130.                     tok - tokstart, esc_seen ? SCAN : 0);
  3131.         yylval.nodeval->flags |= PERM;
  3132.         return lasttok = YSTRING;
  3133.  
  3134.     case '-':
  3135.         if ((c = nextc()) == '=') {
  3136.             yylval.nodetypeval = Node_assign_minus;
  3137.             return lasttok = ASSIGNOP;
  3138.         }
  3139.         if (c == '-')
  3140.             return lasttok = DECREMENT;
  3141.         pushback();
  3142.         return lasttok = '-';
  3143.  
  3144.     case '.':
  3145.         c = nextc();
  3146.         pushback();
  3147.         if (! isdigit(c))
  3148.             return lasttok = '.';
  3149.         else
  3150.             c = '.';
  3151.         /* FALL THROUGH */
  3152.     case '0':
  3153.     case '1':
  3154.     case '2':
  3155.     case '3':
  3156.     case '4':
  3157.     case '5':
  3158.     case '6':
  3159.     case '7':
  3160.     case '8':
  3161.     case '9':
  3162.         /* It's a number */
  3163.         for (;;) {
  3164.             int gotnumber = FALSE;
  3165.  
  3166.             tokadd(c);
  3167.             switch (c) {
  3168. #ifdef BITOPS
  3169.             case 'x':
  3170.             case 'X':
  3171.                 if (do_traditional)
  3172.                     goto done;
  3173.                 if (tok == tokstart + 2)
  3174.                     inhex = TRUE;
  3175.                 break;
  3176. #endif /* BITOTS */
  3177.             case '.':
  3178.                 if (seen_point) {
  3179.                     gotnumber = TRUE;
  3180.                     break;
  3181.                 }
  3182.                 seen_point = TRUE;
  3183.                 break;
  3184.             case 'e':
  3185.             case 'E':
  3186.                 if (inhex)
  3187.                     break;
  3188.                 if (seen_e) {
  3189.                     gotnumber = TRUE;
  3190.                     break;
  3191.                 }
  3192.                 seen_e = TRUE;
  3193.                 if ((c = nextc()) == '-' || c == '+')
  3194.                     tokadd(c);
  3195.                 else
  3196.                     pushback();
  3197.                 break;
  3198. #ifdef BITOPS
  3199.             case 'a':
  3200.             case 'A':
  3201.             case 'b':
  3202.             case 'B':
  3203.             case 'c':
  3204.             case 'C':
  3205.             case 'D':
  3206.             case 'd':
  3207.             case 'f':
  3208.             case 'F':
  3209.                 if (do_traditional || ! inhex)
  3210.                     goto done;
  3211.                 /* fall through */
  3212. #endif
  3213.             case '0':
  3214.             case '1':
  3215.             case '2':
  3216.             case '3':
  3217.             case '4':
  3218.             case '5':
  3219.             case '6':
  3220.             case '7':
  3221.             case '8':
  3222.             case '9':
  3223.                 break;
  3224.             default:
  3225.             done:
  3226.                 gotnumber = TRUE;
  3227.             }
  3228.             if (gotnumber)
  3229.                 break;
  3230.             c = nextc();
  3231.         }
  3232.         if (c != EOF)
  3233.             pushback();
  3234.         else if (do_lint && ! eof_warned) {
  3235.             warning("source file does not end in newline");
  3236.             eof_warned = TRUE;
  3237.         }
  3238.         tokadd('\0');
  3239. #ifdef BITOPS
  3240.         if (! do_traditional && isnondecimal(tokstart))
  3241.             yylval.nodeval = make_number(nondec2awknum(tokstart, strlen(tokstart)));
  3242.         else
  3243. #endif /* BITOPS */
  3244.         yylval.nodeval = make_number(atof(tokstart));
  3245.         yylval.nodeval->flags |= PERM;
  3246.         return lasttok = YNUMBER;
  3247.  
  3248.     case '&':
  3249.         if ((c = nextc()) == '&') {
  3250.             yylval.nodetypeval = Node_and;
  3251.             allow_newline();
  3252.             want_assign = FALSE;
  3253.             return lasttok = LEX_AND;
  3254.         }
  3255.         pushback();
  3256.         return lasttok = '&';
  3257.  
  3258.     case '|':
  3259.         if ((c = nextc()) == '|') {
  3260.             yylval.nodetypeval = Node_or;
  3261.             allow_newline();
  3262.             want_assign = FALSE;
  3263.             return lasttok = LEX_OR;
  3264.         }
  3265.         pushback();
  3266.         return lasttok = '|';
  3267.     }
  3268.  
  3269.     if (c != '_' && ! isalpha(c)) {
  3270.         yyerror("Invalid char '%c' in expression\n", c);
  3271.         exit(1);
  3272.     }
  3273.  
  3274.     /* it's some type of name-type-thing.  Find its length. */
  3275.     tok = tokstart;
  3276.     while (is_identchar(c)) {
  3277.         tokadd(c);
  3278.         c = nextc();
  3279.     }
  3280.     tokadd('\0');
  3281.     emalloc(tokkey, char *, tok - tokstart, "yylex");
  3282.     memcpy(tokkey, tokstart, tok - tokstart);
  3283.     if (c != EOF)
  3284.         pushback();
  3285.     else if (do_lint && ! eof_warned) {
  3286.         warning("source file does not end in newline");
  3287.         eof_warned = TRUE;
  3288.     }
  3289.  
  3290.     /* See if it is a special token. */
  3291.     low = 0;
  3292.     high = (sizeof(tokentab) / sizeof(tokentab[0])) - 1;
  3293.     while (low <= high) {
  3294.         int i;
  3295.  
  3296.         mid = (low + high) / 2;
  3297.         c = *tokstart - tokentab[mid].operator[0];
  3298.         i = c ? c : strcmp(tokstart, tokentab[mid].operator);
  3299.  
  3300.         if (i < 0)        /* token < mid */
  3301.             high = mid - 1;
  3302.         else if (i > 0)        /* token > mid */
  3303.             low = mid + 1;
  3304.         else {
  3305.             if (do_lint) {
  3306.                 if (tokentab[mid].flags & GAWKX)
  3307.                     warning("%s() is a gawk extension",
  3308.                         tokentab[mid].operator);
  3309.                 if (tokentab[mid].flags & RESX)
  3310.                     warning("%s() is a Bell Labs extension",
  3311.                         tokentab[mid].operator);
  3312.                 if (tokentab[mid].flags & NOT_POSIX)
  3313.                     warning("POSIX does not allow %s",
  3314.                         tokentab[mid].operator);
  3315.             }
  3316.             if (do_lint_old && (tokentab[mid].flags & NOT_OLD))
  3317.                 warning("%s is not supported in old awk",
  3318.                         tokentab[mid].operator);
  3319.             if ((do_traditional && (tokentab[mid].flags & GAWKX))
  3320.                 || (do_posix && (tokentab[mid].flags & NOT_POSIX)))
  3321.                 break;
  3322.             if (tokentab[mid].class == LEX_BUILTIN
  3323.                 || tokentab[mid].class == LEX_LENGTH
  3324.                )
  3325.                 yylval.lval = mid;
  3326.             else
  3327.                 yylval.nodetypeval = tokentab[mid].value;
  3328.  
  3329.             free(tokkey);
  3330.             return lasttok = tokentab[mid].class;
  3331.         }
  3332.     }
  3333.  
  3334.     yylval.sval = tokkey;
  3335.     if (*lexptr == '(')
  3336.         return lasttok = FUNC_CALL;
  3337.     else {
  3338.         want_assign = TRUE;
  3339.         return lasttok = NAME;
  3340.     }
  3341. }
  3342.  
  3343. /* node_common --- common code for allocating a new node */
  3344.  
  3345. static NODE *
  3346. node_common(op)
  3347. NODETYPE op;
  3348. {
  3349.     register NODE *r;
  3350.  
  3351.     getnode(r);
  3352.     r->type = op;
  3353.     r->flags = MALLOC;
  3354.     /* if lookahead is NL, lineno is 1 too high */
  3355.     if (lexeme && *lexeme == '\n')
  3356.         r->source_line = sourceline - 1;
  3357.     else
  3358.         r->source_line = sourceline;
  3359.     r->source_file = source;
  3360.     return r;
  3361. }
  3362.  
  3363. /* node --- allocates a node with defined lnode and rnode. */
  3364.  
  3365. NODE *
  3366. node(left, op, right)
  3367. NODE *left, *right;
  3368. NODETYPE op;
  3369. {
  3370.     register NODE *r;
  3371.  
  3372.     r = node_common(op);
  3373.     r->lnode = left;
  3374.     r->rnode = right;
  3375.     return r;
  3376. }
  3377.  
  3378. /* snode ---    allocate a node with defined subnode and proc for builtin
  3379.         functions. Checks for arg. count and supplies defaults where
  3380.         possible. */
  3381.  
  3382. static NODE *
  3383. snode(subn, op, idx)
  3384. NODETYPE op;
  3385. int idx;
  3386. NODE *subn;
  3387. {
  3388.     register NODE *r;
  3389.     register NODE *n;
  3390.     int nexp = 0;
  3391.     int args_allowed;
  3392.  
  3393.     r = node_common(op);
  3394.  
  3395.     /* traverse expression list to see how many args. given */
  3396.     for (n = subn; n != NULL; n = n->rnode) {
  3397.         nexp++;
  3398.         if (nexp > 3)
  3399.             break;
  3400.     }
  3401.  
  3402.     /* check against how many args. are allowed for this builtin */
  3403.     args_allowed = tokentab[idx].flags & ARGS;
  3404.     if (args_allowed && (args_allowed & A(nexp)) == 0)
  3405.         fatal("%s() cannot have %d argument%c",
  3406.             tokentab[idx].operator, nexp, nexp == 1 ? ' ' : 's');
  3407.  
  3408.     r->proc = tokentab[idx].ptr;
  3409.  
  3410.     /* special case processing for a few builtins */
  3411.     /*
  3412.      * FIXME: go through these to make sure that everything done
  3413.      *      here is really right. Move anything that's not into
  3414.      *      the corresponding routine.
  3415.      */
  3416.     if (nexp == 0 && r->proc == do_length) {
  3417.         subn = node(node(make_number(0.0), Node_field_spec, (NODE *) NULL),
  3418.                     Node_expression_list,
  3419.                 (NODE *) NULL);
  3420.     } else if (r->proc == do_match) {
  3421.         if (subn->rnode->lnode->type != Node_regex)
  3422.             subn->rnode->lnode = mk_rexp(subn->rnode->lnode);
  3423.     } else if (r->proc == do_sub || r->proc == do_gsub) {
  3424.         if (subn->lnode->type != Node_regex)
  3425.             subn->lnode = mk_rexp(subn->lnode);
  3426.         if (nexp == 2)
  3427.             append_right(subn, node(node(make_number(0.0),
  3428.                              Node_field_spec,
  3429.                              (NODE *) NULL),
  3430.                             Node_expression_list,
  3431.                         (NODE *) NULL));
  3432.         else if (subn->rnode->rnode->lnode->type == Node_val) {
  3433.             if (do_lint)
  3434.                 warning("string literal as last arg of substitute");
  3435.         } else if (! isassignable(subn->rnode->rnode->lnode))
  3436.             yyerror("%s third parameter is not a changeable object",
  3437.                 r->proc == do_sub ? "sub" : "gsub");
  3438.     } else if (r->proc == do_gensub) {
  3439.         if (subn->lnode->type != Node_regex)
  3440.             subn->lnode = mk_rexp(subn->lnode);
  3441.         if (nexp == 3)
  3442.             append_right(subn, node(node(make_number(0.0),
  3443.                              Node_field_spec,
  3444.                              (NODE *) NULL),
  3445.                             Node_expression_list,
  3446.                         (NODE *) NULL));
  3447.     } else if (r->proc == do_split) {
  3448.         if (nexp == 2)
  3449.             append_right(subn,
  3450.                 node(FS_node, Node_expression_list, (NODE *) NULL));
  3451.         n = subn->rnode->rnode->lnode;
  3452.         if (n->type != Node_regex)
  3453.             subn->rnode->rnode->lnode = mk_rexp(n);
  3454.         if (nexp == 2)
  3455.             subn->rnode->rnode->lnode->re_flags |= FS_DFLT;
  3456.     }
  3457.  
  3458.     r->subnode = subn;
  3459.     return r;
  3460. }
  3461.  
  3462. /*
  3463.  * mkrangenode:
  3464.  * This allocates a Node_line_range node with defined condpair and
  3465.  * zeroes the trigger word to avoid the temptation of assuming that calling
  3466.  * 'node( foo, Node_line_range, 0)' will properly initialize 'triggered'. 
  3467.  * Otherwise like node().
  3468.  */
  3469.  
  3470. static NODE *
  3471. mkrangenode(cpair)
  3472. NODE *cpair;
  3473. {
  3474.     register NODE *r;
  3475.  
  3476.     getnode(r);
  3477.     r->type = Node_line_range;
  3478.     r->condpair = cpair;
  3479.     r->triggered = FALSE;
  3480.     return r;
  3481. }
  3482.  
  3483. /* make_for_loop --- build a for loop */
  3484.  
  3485. static NODE *
  3486. make_for_loop(init, cond, incr)
  3487. NODE *init, *cond, *incr;
  3488. {
  3489.     register FOR_LOOP_HEADER *r;
  3490.     NODE *n;
  3491.  
  3492.     emalloc(r, FOR_LOOP_HEADER *, sizeof(FOR_LOOP_HEADER), "make_for_loop");
  3493.     getnode(n);
  3494.     n->type = Node_illegal;
  3495.     r->init = init;
  3496.     r->cond = cond;
  3497.     r->incr = incr;
  3498.     n->sub.nodep.r.hd = r;
  3499.     return n;
  3500. }
  3501.  
  3502. /* dup_parms --- return TRUE if there are duplicate parameters */
  3503.  
  3504. static int
  3505. dup_parms(func)
  3506. NODE *func;
  3507. {
  3508.     register NODE *np;
  3509.     char *fname, **names;
  3510.     int count, i, j, dups;
  3511.     NODE *params;
  3512.  
  3513.     if (func == NULL)    /* error earlier */
  3514.         return TRUE;
  3515.  
  3516.     fname = func->param;
  3517.     count = func->param_cnt;
  3518.     params = func->rnode;
  3519.  
  3520.     if (count == 0)        /* no args, no problem */
  3521.         return FALSE;
  3522.  
  3523.     if (params == NULL)    /* error earlier */
  3524.         return TRUE;
  3525.  
  3526.     emalloc(names, char **, count * sizeof(char *), "dup_parms");
  3527.  
  3528.     i = 0;
  3529.     for (np = params; np != NULL; np = np->rnode) {
  3530.         if (np->param == NULL) { /* error earlier, give up, go home */
  3531.             free(names);
  3532.             return TRUE;
  3533.         }
  3534.         names[i++] = np->param;
  3535.     }
  3536.  
  3537.     dups = 0;
  3538.     for (i = 1; i < count; i++) {
  3539.         for (j = 0; j < i; j++) {
  3540.             if (strcmp(names[i], names[j]) == 0) {
  3541.                 dups++;
  3542.                 error(
  3543.     "function `%s': parameter #%d, `%s', duplicates parameter #%d",
  3544.                     fname, i+1, names[j], j+1);
  3545.             }
  3546.         }
  3547.     }
  3548.  
  3549.     free(names);
  3550.     return (dups > 0 ? TRUE : FALSE);
  3551. }
  3552.  
  3553. /*
  3554.  * install:
  3555.  * Install a name in the symbol table, even if it is already there.
  3556.  * Caller must check against redefinition if that is desired. 
  3557.  */
  3558.  
  3559. NODE *
  3560. install(name, value)
  3561. char *name;
  3562. NODE *value;
  3563. {
  3564.     register NODE *hp;
  3565.     register size_t len;
  3566.     register int bucket;
  3567.  
  3568.     len = strlen(name);
  3569.     bucket = hash(name, len, (unsigned long) HASHSIZE);
  3570.     getnode(hp);
  3571.     hp->type = Node_hashnode;
  3572.     hp->hnext = variables[bucket];
  3573.     variables[bucket] = hp;
  3574.     hp->hlength = len;
  3575.     hp->hvalue = value;
  3576.     hp->hname = name;
  3577.     hp->hvalue->vname = name;
  3578.     return hp->hvalue;
  3579. }
  3580.  
  3581. /* lookup --- find the most recent hash node for name installed by install */
  3582.  
  3583. NODE *
  3584. lookup(name)
  3585. const char *name;
  3586. {
  3587.     register NODE *bucket;
  3588.     register size_t len;
  3589.  
  3590.     len = strlen(name);
  3591.     for (bucket = variables[hash(name, len, (unsigned long) HASHSIZE)];
  3592.             bucket != NULL; bucket = bucket->hnext)
  3593.         if (bucket->hlength == len && STREQN(bucket->hname, name, len))
  3594.             return bucket->hvalue;
  3595.  
  3596.     return NULL;
  3597. }
  3598.  
  3599. /*
  3600.  * append_right:
  3601.  * Add new to the rightmost branch of LIST.  This uses n^2 time, so we make
  3602.  * a simple attempt at optimizing it.
  3603.  */
  3604.  
  3605. static NODE *
  3606. append_right(list, new)
  3607. NODE *list, *new;
  3608. {
  3609.     register NODE *oldlist;
  3610.     static NODE *savefront = NULL, *savetail = NULL;
  3611.  
  3612.     oldlist = list;
  3613.     if (savefront == oldlist) {
  3614.         savetail = savetail->rnode = new;
  3615.         return oldlist;
  3616.     } else
  3617.         savefront = oldlist;
  3618.     while (list->rnode != NULL)
  3619.         list = list->rnode;
  3620.     savetail = list->rnode = new;
  3621.     return oldlist;
  3622. }
  3623.  
  3624. /*
  3625.  * func_install:
  3626.  * check if name is already installed;  if so, it had better have Null value,
  3627.  * in which case def is added as the value. Otherwise, install name with def
  3628.  * as value. 
  3629.  */
  3630.  
  3631. static void
  3632. func_install(params, def)
  3633. NODE *params;
  3634. NODE *def;
  3635. {
  3636.     NODE *r;
  3637.  
  3638.     pop_params(params->rnode);
  3639.     pop_var(params, FALSE);
  3640.     r = lookup(params->param);
  3641.     if (r != NULL) {
  3642.         fatal("function name `%s' previously defined", params->param);
  3643.     } else
  3644.         (void) install(params->param, node(params, Node_func, def));
  3645.  
  3646.     func_use(params->param, FUNC_DEFINE);
  3647. }
  3648.  
  3649. /* pop_var --- remove a variable from the symbol table */
  3650.  
  3651. static void
  3652. pop_var(np, freeit)
  3653. NODE *np;
  3654. int freeit;
  3655. {
  3656.     register NODE *bucket, **save;
  3657.     register size_t len;
  3658.     char *name;
  3659.  
  3660.     name = np->param;
  3661.     len = strlen(name);
  3662.     save = &(variables[hash(name, len, (unsigned long) HASHSIZE)]);
  3663.     for (bucket = *save; bucket != NULL; bucket = bucket->hnext) {
  3664.         if (len == bucket->hlength && STREQN(bucket->hname, name, len)) {
  3665.             *save = bucket->hnext;
  3666.             freenode(bucket);
  3667.             if (freeit)
  3668.                 free(np->param);
  3669.             return;
  3670.         }
  3671.         save = &(bucket->hnext);
  3672.     }
  3673. }
  3674.  
  3675. /* pop_params --- remove list of function parameters from symbol table */
  3676.  
  3677. /*
  3678.  * pop parameters out of the symbol table. do this in reverse order to
  3679.  * avoid reading freed memory if there were duplicated parameters.
  3680.  */
  3681. static void
  3682. pop_params(params)
  3683. NODE *params;
  3684. {
  3685.     if (params == NULL)
  3686.         return;
  3687.     pop_params(params->rnode);
  3688.     pop_var(params, TRUE);
  3689. }
  3690.  
  3691. /* make_param --- make NAME into a function parameter */
  3692.  
  3693. static NODE *
  3694. make_param(name)
  3695. char *name;
  3696. {
  3697.     NODE *r;
  3698.  
  3699.     getnode(r);
  3700.     r->type = Node_param_list;
  3701.     r->rnode = NULL;
  3702.     r->param = name;
  3703.     r->param_cnt = param_counter++;
  3704.     return (install(name, r));
  3705. }
  3706.  
  3707. static struct fdesc {
  3708.     char *name;
  3709.     short used;
  3710.     short defined;
  3711.     struct fdesc *next;
  3712. } *ftable[HASHSIZE];
  3713.  
  3714. /* func_use --- track uses and definitions of functions */
  3715.  
  3716. static void
  3717. func_use(name, how)
  3718. char *name;
  3719. enum defref how;
  3720. {
  3721.     struct fdesc *fp;
  3722.     int len;
  3723.     int ind;
  3724.  
  3725.     len = strlen(name);
  3726.     ind = hash(name, len, HASHSIZE);
  3727.  
  3728.     for (fp = ftable[ind]; fp != NULL; fp = fp->next) {
  3729.         if (strcmp(fp->name, name) == 0) {
  3730.             if (how == FUNC_DEFINE)
  3731.                 fp->defined++;
  3732.             else
  3733.                 fp->used++;
  3734.             return;
  3735.         }
  3736.     }
  3737.  
  3738.     /* not in the table, fall through to allocate a new one */
  3739.  
  3740.     emalloc(fp, struct fdesc *, sizeof(struct fdesc), "func_use");
  3741.     memset(fp, '\0', sizeof(struct fdesc));
  3742.     emalloc(fp->name, char *, len + 1, "func_use");
  3743.     strcpy(fp->name, name);
  3744.     if (how == FUNC_DEFINE)
  3745.         fp->defined++;
  3746.     else
  3747.         fp->used++;
  3748.     fp->next = ftable[ind];
  3749.     ftable[ind] = fp;
  3750. }
  3751.  
  3752. /* check_funcs --- verify functions that are called but not defined */
  3753.  
  3754. static void
  3755. check_funcs()
  3756. {
  3757.     struct fdesc *fp, *next;
  3758.     int i;
  3759.  
  3760.     for (i = 0; i < HASHSIZE; i++) {
  3761.         for (fp = ftable[i]; fp != NULL; fp = fp->next) {
  3762. #ifdef REALLYMEAN
  3763.             /* making this the default breaks old code. sigh. */
  3764.             if (fp->defined == 0) {
  3765.                 error(
  3766.         "function `%s' called but never defined", fp->name);
  3767.                 errcount++;
  3768.             }
  3769. #else
  3770.             if (do_lint && fp->defined == 0)
  3771.                 warning(
  3772.         "function `%s' called but never defined", fp->name);
  3773. #endif
  3774.             if (do_lint && fp->used == 0) {
  3775.                 warning("function `%s' defined but never called",
  3776.                     fp->name);
  3777.             }
  3778.         }
  3779.     }
  3780.  
  3781.     /* now let's free all the memory */
  3782.     for (i = 0; i < HASHSIZE; i++) {
  3783.         for (fp = ftable[i]; fp != NULL; fp = next) {
  3784.             next = fp->next;
  3785.             free(fp->name);
  3786.             free(fp);
  3787.         }
  3788.     }
  3789. }
  3790.  
  3791. /* param_sanity --- look for parameters that are regexp constants */
  3792.  
  3793. static void
  3794. param_sanity(arglist)
  3795. NODE *arglist;
  3796. {
  3797.     NODE *argp, *arg;
  3798.     int i;
  3799.  
  3800.     for (i = 1, argp = arglist; argp != NULL; argp = argp->rnode, i++) {
  3801.         arg = argp->lnode;
  3802.         if (arg->type == Node_regex)
  3803.             warning("regexp constant for parameter #%d yields boolean value", i);
  3804.     }
  3805. }
  3806.  
  3807. /* variable --- make sure NAME is in the symbol table */
  3808.  
  3809. NODE *
  3810. variable(name, can_free, type)
  3811. char *name;
  3812. int can_free;
  3813. NODETYPE type;
  3814. {
  3815.     register NODE *r;
  3816.     static int env_loaded = FALSE;
  3817.  
  3818.     if (! env_loaded && STREQ(name, "ENVIRON")) {
  3819.         load_environ();
  3820.         env_loaded = TRUE;
  3821.     }
  3822.     if ((r = lookup(name)) == NULL)
  3823.         r = install(name, node(Nnull_string, type, (NODE *) NULL));
  3824.     else if (can_free)
  3825.         free(name);
  3826.     return r;
  3827. }
  3828.  
  3829. /* mk_rexp --- make a regular expression constant */
  3830.  
  3831. static NODE *
  3832. mk_rexp(exp)
  3833. NODE *exp;
  3834. {
  3835.     NODE *n;
  3836.  
  3837.     if (exp->type == Node_regex)
  3838.         return exp;
  3839.  
  3840.     getnode(n);
  3841.     n->type = Node_regex;
  3842.     n->re_exp = exp;
  3843.     n->re_text = NULL;
  3844.     n->re_reg = NULL;
  3845.     n->re_flags = 0;
  3846.     n->re_cnt = 1;
  3847.     return n;
  3848. }
  3849.  
  3850. /* isnoeffect --- when used as a statement, has no side effects */
  3851.  
  3852. /*
  3853.  * To be completely general, we should recursively walk the parse
  3854.  * tree, to make sure that all the subexpressions also have no effect.
  3855.  * Instead, we just weaken the actual warning that's printed, up above
  3856.  * in the grammar.
  3857.  */
  3858.  
  3859. static int
  3860. isnoeffect(type)
  3861. NODETYPE type;
  3862. {
  3863.     switch (type) {
  3864.     case Node_times:
  3865.     case Node_quotient:
  3866.     case Node_mod:
  3867.     case Node_plus:
  3868.     case Node_minus:
  3869.     case Node_subscript:
  3870.     case Node_concat:
  3871.     case Node_exp:
  3872.     case Node_unary_minus:
  3873.     case Node_field_spec:
  3874.     case Node_and:
  3875.     case Node_or:
  3876.     case Node_equal:
  3877.     case Node_notequal:
  3878.     case Node_less:
  3879.     case Node_greater:
  3880.     case Node_leq:
  3881.     case Node_geq:
  3882.     case Node_match:
  3883.     case Node_nomatch:
  3884.     case Node_not:
  3885.     case Node_val:
  3886.     case Node_in_array:
  3887.     case Node_NF:
  3888.     case Node_NR:
  3889.     case Node_FNR:
  3890.     case Node_FS:
  3891.     case Node_RS:
  3892.     case Node_FIELDWIDTHS:
  3893.     case Node_IGNORECASE:
  3894.     case Node_OFS:
  3895.     case Node_ORS:
  3896.     case Node_OFMT:
  3897.     case Node_CONVFMT:
  3898.         return TRUE;
  3899.     default:
  3900.         break;    /* keeps gcc -Wall happy */
  3901.     }
  3902.  
  3903.     return FALSE;
  3904. }
  3905.  
  3906. /* isassignable --- can this node be assigned to? */
  3907.  
  3908. static int
  3909. isassignable(n)
  3910. register NODE *n;
  3911. {
  3912.     switch (n->type) {
  3913.     case Node_var:
  3914.     case Node_FIELDWIDTHS:
  3915.     case Node_RS:
  3916.     case Node_FS:
  3917.     case Node_FNR:
  3918.     case Node_NR:
  3919.     case Node_NF:
  3920.     case Node_IGNORECASE:
  3921.     case Node_OFMT:
  3922.     case Node_CONVFMT:
  3923.     case Node_ORS:
  3924.     case Node_OFS:
  3925.     case Node_field_spec:
  3926.     case Node_subscript:
  3927.         return TRUE;
  3928.     case Node_param_list:
  3929.         return ((n->flags & FUNC) == 0);  /* ok if not func name */
  3930.     default:
  3931.         break;    /* keeps gcc -Wall happy */
  3932.     }
  3933.     return FALSE;
  3934. }
  3935.