home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 333_01 / awktab.c < prev    next >
C/C++ Source or Header  |  1989-04-22  |  47KB  |  1,671 lines
  1. /*
  2.  * Created by CSD YACC (IBM PC) from "AWKTAB.Y" */
  3.  
  4. /* #line 31 "AWKTAB.Y" */
  5. #define YYDEBUG 12
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <stdarg.h>
  10. #include <string.h>
  11. #include "awk.h"
  12.  
  13. STATIC int      NEAR PASCAL     yylex(void);
  14. STATIC int      NEAR PASCAL     parse_escape(char **string_ptr);
  15.  
  16.  
  17. /* The following variable is used for a very sickening thing.  The awk      */
  18. /* language uses white space as the string concatenation operator, but      */
  19. /* having a white space token that would have to appear everywhere in all */
  20. /* the grammar rules would be unbearable.  It turns out we can return      */
  21. /* CONCAT_OP exactly when there really is one, just from knowing what      */
  22. /* kinds of other tokens it can appear between (namely, constants,      */
  23. /* variables, or close parentheses).  This is because concatenation has   */
  24. /* the lowest priority of all operators.  want_concat_token is used to      */
  25. /* remember that something that could be the left side of a concat has      */
  26. /* just been returned.    If anyone knows a cleaner way to do this (don't   */
  27. /* look at the Un*x code to find one, though), please suggest it.      */
  28.  
  29. static int          want_concat_token;
  30.  
  31. /* Two more horrible kludges.  The same comment applies to these two too  */
  32.  
  33. static int          want_regexp     = 0; /* lexical scanning kludge   */
  34.  
  35. int              lineno = 1;         /* JF for error msgs      */
  36.  
  37. /* During parsing of a gAWK program, the pointer to the next character      */
  38. /* is in this variable.                           */
  39.  
  40. char             *lexptr;
  41. char             *lexptr_begin;
  42.  
  43.  
  44. /* #line 71 "AWKTAB.Y" */
  45. typedef union 
  46. {
  47.     long      lval;
  48.     AWKNUM      fval;
  49.     NODE     *nodeval;
  50.     int       nodetypeval;
  51.     char     *sval;
  52.     NODE    *(PASCAL *ptrval)(NODE *);
  53. } YYSTYPE;
  54. #define NAME 257
  55. #define REGEXP 258
  56. #define YSTRING 259
  57. #define ERROR 260
  58. #define INCDEC 261
  59. #define NUMBER 262
  60. #define ASSIGNOP 263
  61. #define MATCHOP 264
  62. #define NEWLINE 265
  63. #define CONCAT_OP 266
  64. #define LEX_BEGIN 267
  65. #define LEX_END 268
  66. #define LEX_IF 269
  67. #define LEX_ELSE 270
  68. #define LEX_WHILE 271
  69. #define LEX_FOR 272
  70. #define LEX_BREAK 273
  71. #define LEX_CONTINUE 274
  72. #define LEX_DELETE 275
  73. #define LEX_PRINT 276
  74. #define LEX_PRINTF 277
  75. #define LEX_NEXT 278
  76. #define LEX_EXIT 279
  77. #define RELOP_EQ 280
  78. #define RELOP_GEQ 281
  79. #define RELOP_LEQ 282
  80. #define RELOP_NEQ 283
  81. #define REDIR_APPEND 284
  82. #define LEX_IN 285
  83. #define LEX_AND 286
  84. #define LEX_OR 287
  85. #define INCREMENT 288
  86. #define DECREMENT 289
  87. #define LEX_BUILTIN 290
  88. #define LEX_MATCH_FUNC 291
  89. #define LEX_SUB_FUNC 292
  90. #define LEX_SPLIT_FUNC 293
  91. #define LEX_GETLINE 294
  92. #define UNARY 295
  93. #define yyclearin yychar = -1
  94. #define yyerrok yyerrflag = 0
  95. #ifndef YYMAXDEPTH
  96. #define YYMAXDEPTH 150
  97. #endif
  98. YYSTYPE yylval;         /*CSD & DECUS LEX */
  99. YYSTYPE yyval;          /*CSD & DECUS LEX */
  100. #define YYERRCODE 256
  101.  
  102. /* #line 713 "AWKTAB.Y" */
  103.  
  104.  
  105.  
  106. struct token
  107. {
  108.     char      *operator;
  109.     int        value;
  110.     int        class;
  111.     NODE     *(PASCAL *ptr)(NODE *);
  112. };
  113.  
  114.  
  115.  
  116. /* Tokentab is sorted ascii ascending order, so it can be binary searched. */
  117. /* DO NOT enter table entries out of order lest search can't find them.    */
  118.  
  119. static struct token tokentab[] =
  120. {
  121.     { "BEGIN",       NODE_ILLEGAL,       LEX_BEGIN,       NULL        },
  122.     { "END",       NODE_ILLEGAL,       LEX_END,       NULL        },
  123.     { "atan2",       NODE_BUILTIN,       LEX_BUILTIN,    do_atan2    },
  124. #ifndef FAST
  125.     { "bp",       NODE_BUILTIN,       LEX_BUILTIN,    do_bp       },
  126. #endif
  127.     { "break",       NODE_K_BREAK,       LEX_BREAK,       NULL        },
  128.     { "close",       NODE_BUILTIN,       LEX_BUILTIN,    do_close    },
  129.     { "continue",  NODE_K_CONTINUE,       LEX_CONTINUE,   NULL        },
  130.     { "cos",       NODE_BUILTIN,       LEX_BUILTIN,    do_cos      },
  131.     { "delete",    NODE_K_DELETE,       LEX_DELETE,       NULL        },
  132.     { "else",       NODE_ILLEGAL,       LEX_ELSE,       NULL        },
  133.     { "exit",       NODE_K_EXIT,        LEX_EXIT,       NULL        },
  134.     { "exp",       NODE_BUILTIN,       LEX_BUILTIN,    do_exp      },
  135.     { "for",       NODE_K_FOR,           LEX_FOR,       NULL        },
  136.     { "getline",   NODE_BUILTIN,       LEX_GETLINE,    do_getline  },
  137.     { "gsub",       NODE_BUILTIN,       LEX_SUB_FUNC,   do_gsub     },
  138.     { "if",       NODE_K_IF,           LEX_IF,       NULL        },
  139.     { "in",       NODE_ILLEGAL,       LEX_IN,       NULL        },
  140.     { "index",       NODE_BUILTIN,       LEX_BUILTIN,    do_index    },
  141.     { "int",       NODE_BUILTIN,       LEX_BUILTIN,    do_int      },
  142.     { "length",    NODE_BUILTIN,       LEX_BUILTIN,    do_length   },
  143.     { "log",       NODE_BUILTIN,       LEX_BUILTIN,    do_log      },
  144.     { "lower",       NODE_BUILTIN,       LEX_BUILTIN,    do_lower    },
  145.     { "match",       NODE_BUILTIN,       LEX_MATCH_FUNC, do_match    },
  146.     { "next",       NODE_K_NEXT,        LEX_NEXT,       NULL        },
  147.     { "print",       NODE_K_PRINT,       LEX_PRINT,       NULL        },
  148.     { "printf",    NODE_K_PRINTF,       LEX_PRINTF,       NULL        },
  149. #ifndef FAST
  150.     { "prvars",    NODE_BUILTIN,       LEX_BUILTIN,    do_prvars   },
  151. #endif
  152.     { "rand",       NODE_BUILTIN,       LEX_BUILTIN,    do_rand     },
  153.     { "reverse",   NODE_BUILTIN,       LEX_BUILTIN,    do_reverse  },
  154.     { "sin",       NODE_BUILTIN,       LEX_BUILTIN,    do_sin      },
  155.     { "split",       NODE_BUILTIN,       LEX_SPLIT_FUNC, do_split    },
  156.     { "sprintf",   NODE_BUILTIN,       LEX_BUILTIN,    do_sprintf  },
  157.     { "sqrt",       NODE_BUILTIN,       LEX_BUILTIN,    do_sqrt     },
  158.     { "srand",       NODE_BUILTIN,       LEX_BUILTIN,    do_srand    },
  159.     { "sub",       NODE_BUILTIN,       LEX_SUB_FUNC,   do_sub      },
  160.     { "substr",    NODE_BUILTIN,       LEX_BUILTIN,    do_substr   },
  161.     { "system",    NODE_BUILTIN,       LEX_BUILTIN,    do_system   },
  162.     { "upper",       NODE_BUILTIN,       LEX_BUILTIN,    do_upper    },
  163.     { "while",       NODE_K_WHILE,       LEX_WHILE,       NULL        }
  164. };
  165.  
  166. /* Read one token, getting characters through lexptr.  */
  167.  
  168. STATIC int NEAR PASCAL yylex(void)
  169. {
  170.     register int         c;
  171.     register int         namelen;
  172.     register char        *tokstart;
  173.     static   int         last_tok_1  = 0;
  174.     static   int         last_tok_2  = 0;
  175.     static   int         did_newline = 0; /* JF the grammar insists that */
  176.                           /* actions end with newlines.  */
  177.     auto     int         do_concat;
  178.     auto     int         seen_e = 0;      /* These are for numbers         */
  179.     auto     int         seen_point = 0;
  180.     auto     int         next_tab;
  181.  
  182. retry:
  183.     if(!lexptr)
  184.     return(0);
  185.  
  186.     if (want_regexp)
  187.     {
  188.     /* there is a potential bug if a regexp is followed by an equal     */
  189.     /* sign: "/foo/=bar" would result in assign_quotient being returned */
  190.     /* as the next token.  Nothing is done about it since it is not     */
  191.     /* valid awk, but maybe something should be done anyway.        */
  192.     want_regexp = 0;
  193.  
  194.     tokstart = lexptr;
  195.     while (c = *lexptr++)
  196.     {
  197.         switch (c)
  198.         {
  199.         case '\\':
  200.             if (*lexptr++ == EOS)
  201.             {
  202.             yyerror ("unterminated regexp ends with \\");
  203.             return(ERROR);
  204.             }
  205.             break;
  206.         case '/':          /* end of the regexp */
  207.             lexptr--;
  208.             yylval.sval = tokstart;
  209.             return(REGEXP);
  210.         case '\n':
  211.         case EOS:
  212.             yyerror("unterminated regexp");
  213.             return(ERROR);
  214.         }
  215.     }
  216.     }
  217.     do_concat          = want_concat_token;
  218.     want_concat_token = 0;
  219.  
  220.     if (*lexptr == EOS)
  221.     {
  222.     lexptr = NULL;
  223.     return(NEWLINE);
  224.     }
  225.  
  226.     /* if lexptr is at white space between two terminal tokens or parens,  */
  227.     /* it is a concatenation operator.                       */
  228.     if (do_concat && (*lexptr == ' ' || *lexptr == '\t'))
  229.     {
  230.     while (*lexptr == ' ' || *lexptr == '\t')
  231.         lexptr++;
  232.     if (isalnum(*lexptr) || *lexptr == '\"' || *lexptr == '('
  233.                  || *lexptr == '.'    || *lexptr == '$')
  234.         return(CONCAT_OP);
  235.     }
  236.  
  237.     while (*lexptr == ' ' || *lexptr == '\t')
  238.     lexptr++;
  239.  
  240.     tokstart   = lexptr;          /* JF */
  241.     last_tok_1 = last_tok_2;
  242.     last_tok_2 = *lexptr;
  243.  
  244.     switch (c = *lexptr++)
  245.     {
  246.     case 0:
  247.         return(0);
  248.     case '\n':
  249.         ++lineno;
  250.         if (',' == last_tok_1)     /* BW: allow lines to be continued */
  251.         goto retry;         /*    at a comma            */
  252.         return(NEWLINE);
  253.     case '#':              /* it's a comment */
  254.         while (*lexptr != '\n' && *lexptr != EOS)
  255.         lexptr++;
  256.         goto retry;
  257.     case '\\':
  258.         if (*lexptr == '\n')
  259.         {
  260.         ++lexptr;
  261.         ++lineno;
  262.         goto retry;
  263.         }
  264.         break;
  265.     case ')':
  266.     case ']':
  267.         ++want_concat_token;         /* intentional fall thru */
  268.     case '(':         /* JF these were above, but I don't see why */
  269.     case '[':         /* they should turn on concat. . . &         */
  270.     case '{':
  271.     case ',':         /* JF */
  272.     case '$':
  273.     case ';':
  274.     case '?':
  275.     case ':':
  276.         /* set node type to ILLEGAL because the action should set it to */
  277.         /* the right thing                            */
  278.         yylval.nodetypeval = NODE_ILLEGAL;
  279.         return(c);
  280.     case '^':                   /* added by BW 12-12-88 */
  281.         if (*lexptr == '=')
  282.         {
  283.         yylval.nodetypeval = NODE_ASSIGN_EXPONENTIAL;
  284.         ++lexptr;
  285.         return(ASSIGNOP);
  286.         }
  287.         yylval.nodetypeval = NODE_ILLEGAL;
  288.         return(c);
  289.     case '*':
  290.         if (*lexptr == '=')
  291.         {
  292.         yylval.nodetypeval = NODE_ASSIGN_TIMES;
  293.         ++lexptr;
  294.         return(ASSIGNOP);
  295.         }
  296.         yylval.nodetypeval = NODE_ILLEGAL;
  297.         return(c);
  298.     case '/':
  299.         if (*lexptr == '=')
  300.         {
  301.         yylval.nodetypeval = NODE_ASSIGN_QUOTIENT;
  302.         ++lexptr;
  303.         return(ASSIGNOP);
  304.         }
  305.         yylval.nodetypeval = NODE_ILLEGAL;
  306.         return(c);
  307.     case '%':
  308.         if (*lexptr == '=')
  309.         {
  310.         yylval.nodetypeval = NODE_ASSIGN_MOD;
  311.         ++lexptr;
  312.         return(ASSIGNOP);
  313.         }
  314.         yylval.nodetypeval = NODE_ILLEGAL;
  315.         return(c);
  316.     case '+':
  317.         if (*lexptr == '=')
  318.         {
  319.         yylval.nodetypeval = NODE_ASSIGN_PLUS;
  320.         ++lexptr;
  321.         return(ASSIGNOP);
  322.         }
  323.         if (*lexptr == '+')
  324.         {
  325.         yylval.nodetypeval = NODE_ILLEGAL;
  326.         ++lexptr;
  327.         return(INCREMENT);
  328.         }
  329.         yylval.nodetypeval = NODE_ILLEGAL;
  330.         return(c);
  331.     case '!':
  332.         if (*lexptr == '=')
  333.         {
  334.         yylval.nodetypeval = NODE_ILLEGAL;
  335.         ++lexptr;
  336.         return(RELOP_NEQ);
  337.         }
  338.         if (*lexptr == '~')
  339.         {
  340.         yylval.nodetypeval = NODE_NOMATCH;
  341.         ++lexptr;
  342.         return(MATCHOP);
  343.         }
  344.         yylval.nodetypeval = NODE_ILLEGAL;
  345.         return(c);
  346.     case '<':
  347.         yylval.nodetypeval = NODE_ILLEGAL;
  348.         if (*lexptr == '=')
  349.         {
  350.         ++lexptr;
  351.         return(RELOP_LEQ);
  352.         }
  353.         return(c);
  354.     case '=':
  355.         if (*lexptr == '=')
  356.         {
  357.         yylval.nodetypeval = NODE_ILLEGAL;
  358.         ++lexptr;
  359.         return(RELOP_EQ);
  360.         }
  361.         yylval.nodetypeval = NODE_ASSIGN;
  362.         return(ASSIGNOP);
  363.     case '>':
  364.         yylval.nodetypeval = NODE_ILLEGAL;
  365.         if ('>' == *lexptr)
  366.         {
  367.         ++lexptr;
  368.         return(REDIR_APPEND);
  369.         }
  370.         if (*lexptr == '=')
  371.         {
  372.         ++lexptr;
  373.         return(RELOP_GEQ);
  374.         }
  375.         return(c);
  376.     case '~':
  377.         yylval.nodetypeval = NODE_MATCH;
  378.         return(MATCHOP);
  379.     case '}':
  380.         if (did_newline)
  381.         {
  382.         did_newline = 0;
  383.         return(c);
  384.         }
  385.         ++did_newline;
  386.         --lexptr;
  387.         return(NEWLINE);
  388.     case '"':
  389.         while (*lexptr != EOS)
  390.         {
  391.         switch (*lexptr++)
  392.         {
  393.             case '\\':
  394.             if (*lexptr++ != EOS)
  395.                 break;
  396.                             /* fall through */
  397.             case '\n':
  398.             yyerror("unterminated string");
  399.             return(ERROR);
  400.             case '\"':
  401.             yylval.sval = tokstart + 1;
  402.             ++want_concat_token;
  403.             return(YSTRING);
  404.         }
  405.         }
  406.         return(ERROR);        /* JF this was one level up, wrong? */
  407.     case '-':
  408.         if (*lexptr == '=')
  409.         {
  410.         yylval.nodetypeval = NODE_ASSIGN_MINUS;
  411.         ++lexptr;
  412.         return(ASSIGNOP);
  413.         }
  414.         if (*lexptr == '-')
  415.         {
  416.         yylval.nodetypeval = NODE_ILLEGAL;
  417.         ++lexptr;
  418.         return(DECREMENT);
  419.         }
  420.  
  421.         /* JF I think space tab comma and newline are the legal places  */
  422.         /* for a UMINUS.  Have I missed any?                */
  423.         if ((!isdigit(*lexptr) && *lexptr!='.')
  424.                    ||
  425.         (lexptr > lexptr_begin + 1 &&  !index(" \t,\n",lexptr[-2])))
  426.         {
  427.         /* set node type to ILLEGAL because the action should set   */
  428.         /* it to the right thing                    */
  429.         yylval.nodetypeval = NODE_ILLEGAL;
  430.         return(c);
  431.         }
  432.                        /* FALL through into number code */
  433.     case '0':
  434.     case '1':
  435.     case '2':
  436.     case '3':
  437.     case '4':
  438.     case '5':
  439.     case '6':
  440.     case '7':
  441.     case '8':
  442.     case '9':
  443.     case '.':
  444.         namelen = ('-' == c) ? 1 : 0;
  445.         for (; (c = tokstart[namelen]) != EOS; namelen++)
  446.         {
  447.         switch (c)
  448.         {
  449.             case '.':
  450.             if (seen_point)
  451.                 goto got_number;
  452.             ++seen_point;
  453.             break;
  454.             case 'e':
  455.             case 'E':
  456.             if (seen_e)
  457.                 goto got_number;
  458.             ++seen_e;
  459.             if (tokstart[namelen+1] == '-'
  460.                       ||
  461.                 tokstart[namelen+1] == '+')
  462.                 namelen++;
  463.             break;
  464.             default:
  465.             if (c < '0' || c > '9')
  466.                 goto got_number;
  467.             break;
  468.         }
  469.         }
  470.  
  471. got_number:
  472.         lexptr = tokstart + namelen;
  473.         c        = *lexptr;            /* BW: some versions of  */
  474.         *lexptr    = EOS;               /*      atof() are very   */
  475.         yylval.fval = (AWKNUM) atof(tokstart);  /*       picky about what  */
  476.         *lexptr    = c;                /*       follows a number. */
  477.         ++want_concat_token;
  478.         return(NUMBER);
  479.  
  480.     case '&':
  481.         if (*lexptr == '&')
  482.         {
  483.         yylval.nodetypeval = NODE_AND;
  484.         ++lexptr;
  485.         return(LEX_AND);
  486.         }
  487.         return(ERROR);
  488.     case '|':
  489.         if (*lexptr == '|')
  490.         {
  491.         yylval.nodetypeval = NODE_OR;
  492.         ++lexptr;
  493.         return(LEX_OR);
  494.         }
  495.         return(ERROR);
  496.     }
  497.  
  498.     if (!isalpha(c))
  499.     {
  500.     yyerror("Invalid char '%c' in expression\n", c);
  501.     return(ERROR);
  502.     }
  503.  
  504.     /* its some type of name-type-thing.  Find its length */
  505.     for (namelen = 0; is_identchar(tokstart[namelen]); namelen++)
  506.     ;
  507.  
  508.     /* See if it is a special token.  binary search added by BW */
  509.     {
  510.     register int        x;
  511.     auto     char        tok1;
  512.     auto     int        l = 0, r = MAXDIM(tokentab) - 1;
  513.  
  514.     do
  515.     {
  516.         x = (l + r) / 2;
  517.         tok1 = tokentab[x].operator[0];
  518.         if (tok1 == *tokstart)
  519.         {
  520.         tok1 = memcmp(tokstart, tokentab[x].operator, namelen);
  521.         if (0 == tok1 && EOS == tokentab[x].operator[namelen])
  522.             break;
  523.         if (tok1 > 0)
  524.             l = x + 1;
  525.         else
  526.             r = x - 1;
  527.         }
  528.         else
  529.         {
  530.         if (*tokstart < tok1)
  531.             r = x - 1;
  532.         else
  533.             l = x + 1;
  534.         }
  535.     } while (l <= r);
  536.     if (l <= r)
  537.     {
  538.         lexptr = tokstart + namelen;
  539.         if (NODE_BUILTIN == tokentab[x].value)
  540.         yylval.ptrval = tokentab[x].ptr;
  541.         else
  542.         yylval.nodetypeval = tokentab[x].value;
  543.         return(tokentab[x].class);
  544.     }
  545.     }
  546.  
  547.     /* It's a name.  See how long it is.  */
  548.     yylval.sval = tokstart;
  549.     lexptr = tokstart+namelen;
  550.     ++want_concat_token;
  551.     return(NAME);
  552. }
  553.  
  554.  
  555. void yyerror(char *mesg, ...)
  556. {
  557.     register char     *ptr, *beg;
  558.     auto     va_list      ap;
  559.     auto     int      colno = 0;
  560.     auto     int      i, next_tab;
  561.  
  562.     /* Find the current line in the input file */
  563.     if (!lexptr)
  564.     {
  565.     beg   = "(END OF FILE)";
  566.     ptr   = beg + strlen(beg);
  567.     }
  568.     else
  569.     {
  570.     if (*lexptr == '\n' && lexptr != lexptr_begin)
  571.         --lexptr;
  572.     for (beg = lexptr; beg != lexptr_begin && *beg != '\n'; --beg)
  573.         ;
  574.     for (ptr = lexptr; *ptr && *ptr != '\n'; ptr++)
  575.         ;
  576.     if (beg != lexptr_begin)
  577.         ++beg;
  578.     i = 0;
  579.     while (beg + i <= lexptr)
  580.     {
  581.         if ('\t' == beg[i])
  582.         {
  583.         next_tab = colno % TABSTOPS;
  584.         colno    += (next_tab ? next_tab : TABSTOPS);
  585.         }
  586.         else
  587.         ++colno;
  588.         ++i;
  589.     }
  590.     }
  591.  
  592.     fprintf(stderr, "\n'%.*s'\n", ptr - beg, beg);
  593.     fprintf(stderr, "%*s\n", colno + 1, "^");
  594.  
  595.     /* figure out line number, etc. later */
  596.     va_start(ap, mesg);
  597.     vfprintf(stderr, mesg, ap);
  598.     va_end(ap);
  599.     fprintf(stderr, " near line %d column %d\n", lineno, colno);
  600.     exit(1);
  601. }
  602.  
  603.  
  604. /* Parse a C escape sequence.  STRING_PTR points to a variable
  605.    containing a pointer to the string to parse.  That pointer
  606.    is updated past the characters we use.  The value of the
  607.    escape sequence is returned.
  608.  
  609.    A negative value means the sequence \ newline was seen,
  610.    which is supposed to be equivalent to nothing at all.
  611.  
  612.    If \ is followed by a null character, we return a negative
  613.    value and leave the string pointer pointing at the null character.
  614.  
  615.    If \ is followed by 000, we return 0 and leave the string pointer
  616.    after the zeros.  A value of 0 does not mean end of string.  */
  617.  
  618. STATIC int NEAR PASCAL parse_escape(char **string_ptr)
  619. {
  620.     register int      c = *(*string_ptr)++;
  621.  
  622.     switch (c)
  623.     {
  624.     case 'a':
  625.         return('\a');
  626.     case 'b':
  627.         return('\b');
  628.     case 'e':
  629.         return(033);
  630.     case 'f':
  631.         return('\f');
  632.     case 'n':
  633.         return('\n');
  634.     case 'r':
  635.         return('\r');
  636.     case 't':
  637.         return('\t');
  638.     case 'v':
  639.         return('\v');
  640.     case '\n':
  641.         return(-2);
  642.     case 0:
  643.         (*string_ptr)--;
  644.         return(0);
  645.     case '^':
  646.         c = *(*string_ptr)++;
  647.         if (c == '\\')
  648.         c = parse_escape(string_ptr);
  649.         if (c == '?')
  650.         return(0177);
  651.         return((c & 0200) | (c & 037));
  652.     case '0':
  653.     case '1':
  654.     case '2':
  655.     case '3':
  656.     case '4':
  657.     case '5':
  658.     case '6':
  659.     case '7':
  660.         {
  661.         register int      i = c - '0';
  662.         register int      count = 0;
  663.  
  664.         while (++count < 3)
  665.         {
  666.             if ((c = *(*string_ptr)++) >= '0' && c <= '7')
  667.             {
  668.             i *= 8;
  669.             i += c - '0';
  670.             }
  671.             else
  672.             {
  673.             (*string_ptr)--;
  674.             break;
  675.             }
  676.         }
  677.         return(i);
  678.         }
  679.     default:
  680.         return(c);
  681.     }
  682. }
  683.  
  684. short yyexca[] =
  685. {
  686. -1, 1,
  687.     0, -1,
  688.     -2, 0,
  689. -1, 3,
  690.     0, 1,
  691.     -2, 5,
  692.  
  693. };
  694. #define YYNPROD            108
  695. #define YYLAST        1044
  696.  
  697. short yyact[] =
  698. {
  699.   10,  57,  33,  23, 204, 171, 198,  11, 159, 224,
  700.  127,  35,  14,  81,  21,  75,  74, 111, 110, 146,
  701.  212,  63,   4,  32,  35, 154,  58,  59,  35,  72,
  702.   96, 171, 214,  23, 179, 155, 129, 109,  10,  31,
  703.    2,  23,  35,  46, 146,  11,  81,  23,  44,  47,
  704.   14,  48,  21,  45,  23, 177,  43,  68,  21,  81,
  705.   68,  63, 186,  21,  13, 146,  50,  66,  49,  23,
  706.  130, 195, 193, 137,  81,  81,  46,  10, 225, 185,
  707.   23,  44, 138, 221,  11,  81,  45, 165, 220,  14,
  708.  113,  21, 181, 136, 180, 208,  81,  82, 206, 134,
  709.   43,  35, 133, 205, 132,  23,  86,  81, 131,  80,
  710.  157, 143,  81, 108, 142,  10,  71,  70,  23,  35,
  711.   69,  65,  11,  62,  42,  23, 114,  14, 113,  21,
  712.  184,  10,  16,  43,  23, 100, 106,   5,  11,  30,
  713.    6,  29,   3,  14,   1,  21,   0,   0,   0,   0,
  714.    0,   0,   0,   0,  10,   0, 170,  23,   0,   0,
  715.    0,  11,   0,   0,   0,   0,  14, 113,  21, 139,
  716.   10,   0,   0,  23,   0,   0,   0,  11,  10, 163,
  717.  203,  23,  14,   0,  21,  11, 168, 169,   0,   0,
  718.   14,   0,  21,   0,  10,   0, 187,  23, 160,   0,
  719.  161,  11,   0,   0,   0,   0,  14,   0,  21,   0,
  720.    0,   0,   0,   0,   0,   0,  10,   0,   0,  23,
  721.    0,   0,   0, 151,  22, 145,  20, 172,  14,  19,
  722.   21,   0, 111, 110,  33,  34, 125,   0, 115, 116,
  723.  117, 118, 123, 119, 120, 121, 122,  33,  34,   0,
  724.  145,  33,  34, 172,  22,  17,  18,  24,  27,  28,
  725.   26,  25,  22,   0,  20,  33,  34,  19,  22,   0,
  726.   41, 145,  40,   0, 125,  22, 115, 116, 117, 118,
  727.  123, 119, 120, 121, 122,   0,  51,  52,  53,  54,
  728.   22, 213, 191,  17,  18,  24,  27,  28,  26,  25,
  729.  219,  22,   0,  20,  46,   0,  19, 174, 183,  44,
  730.   47, 182,  48, 125,  45, 115, 116, 117, 118, 123,
  731.  119, 120, 121, 122,  33,  34,  22,  50, 189,  49,
  732.    0,   0,  17,  18,  24,  27,  28,  26,  25,  22,
  733.    0,  20,  33,  34,  19,   0,  22,   4, 101,   7,
  734.    8,   0,   0,   0,   0,  22,   0,  20,   0,   0,
  735.   19,  43, 215, 216,   0,   7,   8,   0,   0,   0,
  736.   17,  18,  24,  27,  28,  26,  25,   0,  22,   0,
  737.   20,   0,   0,  19,   0,   0,  17,  18,  24,  27,
  738.   28,  26,  25,   0,  22,   0,  20,   0,   0,  19,
  739.    0,   0,  22,   0,  20,   0,   0,  19, 112,  17,
  740.   18,  24,  27,  28,  26,  25,   0,   0, 166,   0,
  741.   20,   0,  84,  19,   0,  17,  18,  24,  27,  28,
  742.   26,  25,   0,  17,  18,  24,  27,  28,  26,  25,
  743.   22,   0,  20,   0,  73,  19,   0,   0,   0,  17,
  744.   18,  24,  27,  28,  26,  25,  10,   0,   0,  23,
  745.    0,   0,   0, 149,   0,   0,   0,   0,  14,   0,
  746.   21,  17,  18,  24,  27,  28,  26,  25,  46,   0,
  747.    0,   0, 210,  44,  47,   0,  48,   0,  45,   0,
  748.    0,   0, 144,   0,   0,   0,   0,   0,   0,   0,
  749.   46,  50,   0,  49, 196,  44,  47,  46,  48,   0,
  750.   45,   0,  44,  47, 135,  48,   0,  45, 140,   0,
  751.    0,   0,   0,  50,   0,  49,  37,   0,   0,   0,
  752.   50,  41,  49,  40,   0,  43,   0,   0,   0,   0,
  753.    0,   0,   0,   0,   0,   0,  46,  51,  52,  53,
  754.   54,  44,  47,   0,  48,  46,  45,  43, 141,  83,
  755.   44,  47,   0,  48,  43,  45,   0, 126,   0,  50,
  756.    0,  49, 140,   0,   0,   0,  46,   0,  50,   0,
  757.   49,  44,  47,  46,  48,   0,  45,   0,  44,  47,
  758.   97,  48,  99,  45,   0,   0, 103, 105, 107,  50,
  759.    0,  49,   0,  43,   0,   0,  50,   0,  49,   0,
  760.  211, 147,  43,   0, 152, 153,   0, 156, 218,   0,
  761.   56,   0,   0,   9,   9,   0,   0,   0,   0, 200,
  762.  201,  36,  38,  43,   0, 230, 231, 232, 233,   0,
  763.   43,   0,   0, 209,   0,   0, 148, 150,   0,   0,
  764.    0,   0,   0,  76,  77,  78,   0,   0,   0,   0,
  765.    0,   0,   0, 188,   0, 226, 227, 194,   0, 228,
  766.  229,   0,   0,   0,   0,   0, 173,   0, 175,   0,
  767.   22,   0,  20,   0,   0,  19,   0,   0,   0, 207,
  768.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  769.    0, 217,   0,   0, 197,  41,   0,  40, 222, 223,
  770.    0,  17,  18,  24,  27,  28,  26,  25,   0,   0,
  771.    0,  51,  52,  53,  54,   0,   0,  41,   0,  40,
  772.    0,   0,   0,   0,  41,   0,  40,   0,   0,   0,
  773.    0,   0,   0,  51,  52,  53,  54,   0,   0,   0,
  774.   51,  52,  53,  54,   0,   0,   0,   0,   0,   0,
  775.    0,   0,  15, 164,   0,   0,   0,   0,   0,   0,
  776.   38,   0,  38,  41,   0,  40,   0,   0, 178,   0,
  777.   60,  61,  41,   0,  40,   0,   0,   0,  67,  51,
  778.   52,  53,  54,   0,   0,   0,   0,   0,  51,  52,
  779.   53,  54,   0,  41,  87,  40,   0, 202,   0,   0,
  780.   41,   0,   0,   0,   0,   0,   0,   0,   0,  51,
  781.   52,  53,  54,   0,   0,   0,  51,  52,  53,  54,
  782.  124, 102,   0,  12,  12,   0,   0,   0,   0,   0,
  783.    0,  12,  39,   0,   0,  55,   0,   0,   0,   0,
  784.    0,   0,   0,   0,  64,   0,   0,   0,   0,   0,
  785.    0,   0,   0,  12,  12,  12,  79,   0,   0,   0,
  786.    0,  85,   0,  88,  89,  90,  91,  92,  93,  94,
  787.    0,   0,   0,   0,   0,   0,   0,   0,  95,   0,
  788.    0,   0,   0,   0,  98,   0,  98,   0,   0,   0,
  789.   98, 104,  98,   0,   0,   0,   0,   0,   0,   0,
  790.    0,   0, 128,   0,   0,   0,   0,   0,   0,   0,
  791.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  792.    0,   0,   0,   0, 190, 192,   0,   0,   0,   0,
  793.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  794.   98,  98,   0,   0,   0,   0,   0, 158,   0,   0,
  795.    0,   0,   0,   0, 128,   0,   0,   0, 162,   0,
  796.    0,   0,   0,  12, 167,   0,   0,   0,   0,   0,
  797.   39,   0,  39,   0,   0, 176,   0,   0,  12,   0,
  798.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  799.    0,   0,   0,   0,   0,   0,   0,   0,  98,   0,
  800.    0,   0,   0, 199,   0,   0,   0,  12,   0,   0,
  801.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  802.    0,   0,   0,   0, 167,   0,   0,   0,   0,   0,
  803.    0,   0,   0, 167
  804. };
  805.  
  806. short yypact[] =
  807. {
  808. -1000,-1000,  82,  98,-1000,-1000, -84,-1000,-1000, -21,
  809.  145, 145, 539,-1000, 145,-262,-1000,  18,  18,-1000,
  810. -1000,-1000, -30, 145,  81,  -3,  80,  77,  76,-1000,
  811. -236,-250, 145, 145, 145, 145,-1000,  68,  56, 518,
  812.  137,  11, 145, 145, 145, 145, 145, 145, 145,-1000,
  813. -1000,-1000,-1000,-1000,-1000, -38, -52, 145,-1000,-1000,
  814. -1000,-1000,-228, 145, -38, 145,-1000,   0,  89, 145,
  815.  145, 145,-1000, -33,-1000,-1000, -52,-1000,-284, 509,
  816. -256, 145,-1000,-1000,-221, 546,-1000,-1000, 539, -38,
  817.  -38, -38, -38,  39,  39, 539,  23,  15, 539,  63,
  818. -1000,-1000,-1000,  58, 470,  52,  29,  41,-243,  44,
  819. -1000,-1000,-1000,-250,-1000,  74,  71, -40, -40, 423,
  820.  183, -40, -15,-222,   6,  70, 145,-277, 539,-1000,
  821. -1000,-1000,-1000, 145,-1000,  16,-1000, 145,-1000,-1000,
  822. -1000, -33, 145, 161,-1000,-1000,-1000,-1000, -31, 145,
  823.  -31, 145,-1000,-1000, 145, -36,-1000, 145, 539,-223,
  824.   53,  51, 267,   5,  38,   3, -70, 539,-243,-243,
  825.  -40,  69,  33,  31, -40,  30, 463, 145, -35,-1000,
  826. -1000,-1000, 145,-1000,-250,-250, 121,-281,-1000,-1000,
  827. -1000,-1000,-1000,-256,-1000,-256, -40,   2,-250, 441,
  828. -248, -33, -39, 145,-225, -57, -57,-1000, -40, -33,
  829. -1000,-1000, 145,  47,  42, -40, -40,-1000,-261,  37,
  830. -250,-250,-1000,-1000,-250,-250, -33, -33, -33, -33,
  831. -1000,-1000,-1000,-1000
  832. };
  833.  
  834. short yypgo[] =
  835. {
  836.    0, 830, 144, 142, 137, 140, 620,  64, 139, 762,
  837.   67, 156, 526, 132,  37, 408, 126,  87, 444, 124,
  838.   40, 492, 123, 103,  98
  839. };
  840. short yyr1[]={
  841.  
  842.    0,   2,   3,   3,   4,   5,   5,   5,   5,   5,
  843.    6,   6,   6,   6,   6,   6,   6,   6,   6,   6,
  844.    8,   8,  14,  14,  21,  21,  22,   7,  19,  19,
  845.   19,  19,  19,  19,  18,  18,  18,  18,  18,  15,
  846.   15,  15,  15,  15,  15,  15,  15,  15,  23,  15,
  847.   15,  24,  15,  15,  15,  15,  15,  15,  16,  16,
  848.   20,  20,  11,  11,  11,  11,  11,  10,  10,  10,
  849.    9,   9,   9,  17,  17,  12,  12,  12,   1,   1,
  850.    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
  851.    1,   1,   1,   1,   1,   1,   1,  13,  13,  13,
  852.   13,  13,  13,  13,  13,  13,  13,  13 };
  853. short yyr2[]={
  854.  
  855.    0,   2,   1,   2,   4,   0,   1,   1,   1,   3,
  856.    2,   6,   4,   3,   3,   3,   1,   3,   3,   3,
  857.    0,   4,   1,   2,   2,   2,   0,   4,   1,   1,
  858.    1,   1,   1,   1,   0,   1,   1,   2,   2,   5,
  859.    1,   6,  10,   9,   9,   2,   2,   4,   0,   7,
  860.    4,   0,   7,   2,   2,   5,   6,   2,   6,   9,
  861.    0,   2,   0,   2,   2,   2,   2,   0,   2,   2,
  862.    1,   4,   2,   0,   1,   0,   1,   3,   2,   3,
  863.    1,   3,   2,   2,   2,   2,   1,   1,   1,   3,
  864.    3,   3,   3,   3,   3,   3,   5,   4,   1,   2,
  865.    3,   4,   6,   6,   4,   8,   6,   4 };
  866. short yychk[]={
  867.  
  868. -1000,  -2, -20,  -3, 265,  -4,  -5, 267, 268,  -6,
  869.   33,  40,  -1,  -7,  45,  -9, -13, 288, 289, 262,
  870.  259,  47, 257,  36, 290, 294, 293, 291, 292,  -4,
  871.   -8, 123,  44, 286, 287,  63,  -6, -12,  -6,  -1,
  872.  266, 264, -19,  94,  42,  47,  37,  43,  45,  62,
  873.   60, 280, 281, 282, 283,  -1,  -6, 263, 288, 289,
  874.   -9,  -9, -22,  91,  -1,  40, -10,  -9,  60,  40,
  875.   40,  40, 265, -18, 266, 265,  -6,  -6,  -6,  -1,
  876.   41,  44,  41,  41, 285,  -1,  -7,  -9,  -1,  -1,
  877.   -1,  -1,  -1,  -1,  -1,  -1, 258, -12,  -1, -12,
  878.  -10, 259,  -9, -12,  -1, -12,  -7, -12, -20, -14,
  879.  266, 265, -15, 123, -16, 271, 272, 273, 274, 276,
  880.  277, 278, 279, 275,  -1, 269,  58, 266,  -1, 257,
  881.   47,  93,  41,  44,  41,  44,  41,  44,  41, 125,
  882.  -15, -18,  40,  40, -21, 265,  59, -21, -12,  40,
  883.  -12,  40, -21, -21,  40, 257, -21,  40,  -1, 285,
  884.   -7,  -7,  -1, -14,  -6, -17, 257,  -1, -20, -20,
  885.  -11,  62, 284, -12, -11, -12,  -1,  91,  -6, 257,
  886.   41,  41,  44,  41, 125,  41,  59, 266, -21, 259,
  887.   -9, 259,  -9,  41, -21,  41,  41, -12,  41,  -1,
  888.  -18, -18,  -6,  59, 285, -23, -24, -21,  93, -18,
  889.   41, -15,  59, -17, 257, -11, -11, -21, -15, -17,
  890.   41,  41, -21, -21, 270,  41, -18, -18, -18, -18,
  891.  -15, -15, -15, -15 };
  892. short yydef[]={
  893.  
  894.   60,  -2,   5,  -2,  61,   2,  20,   6,   7,   8,
  895.    0,  75,   0,  16,   0,  86,  80,   0,   0,  87,
  896.   88,  26,  70,   0,  98,  67,   0,   0,   0,   3,
  897.    0,  34,   0,   0,   0,   0,  10,   0,   0,  76,
  898.    0,   0,   0,   0,   0,   0,   0,   0,   0,  28,
  899.   29,  30,  31,  32,  33,  78,   0,   0,  84,  85,
  900.   82,  83,   0,  75,  72,  75,  99,  67,   0,  75,
  901.   75,  75,  60,   0,  35,  36,   9,  13,  14,   0,
  902.    0,   0,  15,  81,   0,  95,  17,  18,  19,  89,
  903.   90,  91,  92,  93,  94,  79,   0,   0,  76,   0,
  904.  100,  68,  69,   0,  76,   0,  16,   0,   4,   0,
  905.   37,  38,  22,  34,  40,   0,   0,   0,   0,  75,
  906.   75,   0,   0,   0,   0,   0,   0,   0,  77,  12,
  907.   27,  71,  97,   0, 101,   0, 104,   0, 107,  21,
  908.   23,   0,   0,  73,  45,  60,  60,  46,  62,  75,
  909.   62,  75,  53,  54,   0,   0,  57,   0,  96,   0,
  910.   16,   0,   0,   0,   0,   0,  70,  74,  24,  25,
  911.    0,   0,   0,   0,   0,   0,   0,  75,   0,  11,
  912.  102, 103,   0, 106,  34,  34,   0,   0,  47,  63,
  913.   64,  65,  66,  48,  50,  51,   0,   0,  34,   0,
  914.   39,   0,   0,  73,   0,  62,  62,  55,   0,   0,
  915.  105,  41,  73,   0,   0,   0,   0,  56,  58,   0,
  916.   34,  34,  49,  52,  34,  34,   0,   0,   0,   0,
  917.   43,  44,  59,  42 };
  918. /*
  919.   TITLE:     YACC - Yet Another Compilier-Compilier
  920.   VERSION:     1.0 for IBM-PC
  921.   DATE:      JAN 28, 1985
  922.   DESCRIPTION:     LALR(1) Parser Generator. From UNIX
  923. */
  924.  
  925. #define YYFLAG              -1000
  926. #define YYERROR           goto yyerrlab
  927. #define YYACCEPT          return(0)
  928. #define YYABORT           return(1)
  929.  
  930. /*      parser for yacc output  */
  931.  
  932. int              yydebug = 0;        /* 1 for debugging           */
  933. YYSTYPE           yyv[YYMAXDEPTH];  /* where the values are stored */
  934. int              yychar = -1;        /* current input token number  */
  935. int              yynerrs = 0;        /* number of errors        */
  936. short              yyerrflag = 0;    /* error recovery flag       */
  937.  
  938. int yyparse(void)
  939. {
  940.  
  941.     short           yys[YYMAXDEPTH];
  942.     short           yyj, yym;
  943.     register YYSTYPE *yypvt;
  944.     register short  yystate, *yyps, yyn;
  945.     register YYSTYPE *yypv;
  946.     register short *yyxi;
  947.  
  948.     yystate = 0;
  949.     yychar = -1;
  950.     yynerrs = 0;
  951.     yyerrflag = 0;
  952.     yyps = &yys[-1];
  953.     yypv = &yyv[-1];
  954.  
  955. yystack:            /* put a state and value onto the stack */
  956.     if (yydebug)
  957.     printf("state %d\n", yystate);
  958.     if (++yyps > &yys[YYMAXDEPTH])
  959.     {
  960.     yyerror("yacc stack overflow");
  961.     return(1);
  962.     }
  963.     *yyps = yystate;
  964.     ++yypv;
  965. #ifdef UNION
  966.     yyunion(yypv, &yyval);
  967. #else
  968.     *yypv = yyval;
  969. #endif
  970.  
  971. yynewstate:
  972.     yyn = yypact[yystate];
  973.  
  974.     if (yyn <= YYFLAG)
  975.     goto yydefault;        /* simple state */
  976.  
  977.     if (yychar < 0)
  978.     {
  979.     if ((yychar = yylex()) < 0)
  980.         yychar = 0;
  981.     if (yydebug)
  982.         printf("LEX token %d [%c]\n", yychar,
  983.            yychar >= ' ' && yychar <= 'z' ? yychar : ' ');
  984.     }
  985.     if ((yyn += yychar) < 0 || yyn >= YYLAST)
  986.     goto yydefault;
  987.  
  988.     if (yychk[yyn = yyact[yyn]] == yychar)
  989.     {
  990.     /* valid shift */
  991.     yychar = -1;
  992. #ifdef UNION
  993.     yyunion(&yyval, &yylval);
  994. #else
  995.     yyval = yylval;
  996. #endif
  997.     yystate = yyn;
  998.     if (yyerrflag > 0)
  999.         --yyerrflag;
  1000.     goto yystack;
  1001.     }
  1002. yydefault:
  1003.     /* default state action */
  1004.  
  1005.     if ((yyn = yydef[yystate]) == -2)
  1006.     {
  1007.     if (yychar < 0)
  1008.     {
  1009.         if ((yychar = yylex()) < 0)
  1010.         yychar = 0;
  1011.         if (yydebug)
  1012.         printf("LEX token %d [%c]\n", yychar,
  1013.                yychar >= ' ' && yychar <= 'z' ? yychar : ' ');
  1014.     }
  1015.     /* look through exception table */
  1016.  
  1017.     for (yyxi = yyexca; (*yyxi != (-1)) || (yyxi[1] != yystate); yyxi += 2);    /* VOID */
  1018.  
  1019.     for (yyxi += 2; *yyxi >= 0; yyxi += 2)
  1020.     {
  1021.         if (*yyxi == yychar)
  1022.         break;
  1023.     }
  1024.     if ((yyn = yyxi[1]) < 0)
  1025.         return (0);        /* accept */
  1026.     }
  1027.  
  1028.     if (yyn == 0)
  1029.     {
  1030.     /* error */
  1031.     /* error ... attempt to resume parsing */
  1032.  
  1033.     switch (yyerrflag)
  1034.     {
  1035.  
  1036.     case 0:        /* brand new error */
  1037.  
  1038.         yyerror("syntax error");
  1039. yyerrlab:
  1040.         ++yynerrs;
  1041.  
  1042.     case 1:
  1043.     case 2:        /* incompletely recovered error ... try again */
  1044.  
  1045.         yyerrflag = 3;
  1046.  
  1047.         /* find a state where "error" is a legal shift action */
  1048.  
  1049.         while (yyps >= yys)
  1050.         {
  1051.         yyn = yypact[*yyps] + YYERRCODE;
  1052.         if (yyn >= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE)
  1053.         {
  1054.             yystate = yyact[yyn];    /* simulate a shift of
  1055.                          * "error" */
  1056.             goto yystack;
  1057.         }
  1058.         yyn = yypact[*yyps];
  1059.  
  1060.         /* the current yyps has no shift onn "error", pop stack */
  1061.  
  1062.         if (yydebug)
  1063.             printf("error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1]);
  1064.         --yyps;
  1065.         --yypv;
  1066.         }
  1067.  
  1068.         /* there is no state on the stack with an error shift ... abort */
  1069.  
  1070. yyabort:
  1071.         return(1);
  1072.  
  1073.     case 3:        /* no shift yet; clobber input char */
  1074.  
  1075.         if (yydebug)
  1076.         printf("error recovery discards char %d\n", yychar);
  1077.  
  1078.         if (yychar == 0)
  1079.         goto yyabort;    /* don't discard EOF, quit */
  1080.         yychar = -1;
  1081.         goto yynewstate;    /* try again in the same state */
  1082.  
  1083.     }
  1084.  
  1085.     }
  1086.  
  1087.     /* reduction by production yyn */
  1088.  
  1089.     if (yydebug)
  1090.     printf("reduce %d\n", yyn);
  1091.     yyps -= yyr2[yyn];
  1092.     yypvt = yypv;
  1093.     yypv -= yyr2[yyn];
  1094. #ifdef UNION
  1095.     yyunion(&yyval, &yypv[1]);
  1096. #else
  1097.     yyval = yypv[1];
  1098. #endif
  1099.     yym = yyn;
  1100.     /* consult goto table to find next state */
  1101.     yyn = yyr1[yyn];
  1102.     yyj = yypgo[yyn] + *yyps + 1;
  1103.     if (yyj >= YYLAST || yychk[yystate = yyact[yyj]] != -yyn)
  1104.     yystate = yyact[yypgo[yyn]];
  1105.     switch (yym)
  1106.     {
  1107.     
  1108. case 1:
  1109. /* #line 116 "AWKTAB.Y" */
  1110. {
  1111.           expression_value = yypvt[-0].nodeval;
  1112.       } break;
  1113. case 2:
  1114. /* #line 123 "AWKTAB.Y" */
  1115. {
  1116.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_RULE_LIST, NULL);
  1117.       } break;
  1118. case 3:
  1119. /* #line 128 "AWKTAB.Y" */
  1120. {           /* cons the rule onto the tail of list */
  1121.           yyval.nodeval = append_right(yypvt[-1].nodeval, node(yypvt[-0].nodeval, NODE_RULE_LIST, NULL));
  1122.       } break;
  1123. case 4:
  1124. /* #line 134 "AWKTAB.Y" */
  1125. {
  1126.           yyval.nodeval = node(yypvt[-3].nodeval, NODE_RULE_NODE, yypvt[-2].nodeval);
  1127.       } break;
  1128. case 5:
  1129. /* #line 141 "AWKTAB.Y" */
  1130. {
  1131.           yyval.nodeval = NULL;
  1132.       } break;
  1133. case 6:
  1134. /* #line 146 "AWKTAB.Y" */
  1135. {
  1136.           yyval.nodeval = node(NULL, NODE_K_BEGIN, NULL);
  1137.       } break;
  1138. case 7:
  1139. /* #line 151 "AWKTAB.Y" */
  1140. {
  1141.           yyval.nodeval = node(NULL, NODE_K_END, NULL);
  1142.       } break;
  1143. case 8:
  1144. /* #line 155 "AWKTAB.Y" */
  1145. {
  1146.           yyval.nodeval = yypvt[-0].nodeval;
  1147.       } break;
  1148. case 9:
  1149. /* #line 160 "AWKTAB.Y" */
  1150. {
  1151.           yyval.nodeval = mkrangenode(node(yypvt[-2].nodeval, NODE_COND_PAIR, yypvt[-0].nodeval));
  1152.       } break;
  1153. case 10:
  1154. /* #line 168 "AWKTAB.Y" */
  1155. {
  1156.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_NOT, NULL);
  1157.       } break;
  1158. case 11:
  1159. /* #line 173 "AWKTAB.Y" */
  1160. {
  1161.           yyval.nodeval = node(variable(yypvt[-0].sval), NODE_MEMBER_COND, yypvt[-4].nodeval);
  1162.       } break;
  1163. case 12:
  1164. /* #line 178 "AWKTAB.Y" */
  1165. {
  1166.           yyval.nodeval = node(variable(yypvt[-0].sval), NODE_MEMBER_COND, yypvt[-3].nodeval);
  1167.       } break;
  1168. case 13:
  1169. /* #line 183 "AWKTAB.Y" */
  1170. {
  1171.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_AND, yypvt[-0].nodeval);
  1172.       } break;
  1173. case 14:
  1174. /* #line 188 "AWKTAB.Y" */
  1175. {
  1176.           yyval.nodeval = node (yypvt[-2].nodeval, NODE_OR, yypvt[-0].nodeval);
  1177.       } break;
  1178. case 15:
  1179. /* #line 193 "AWKTAB.Y" */
  1180. {
  1181.           yyval.nodeval = yypvt[-1].nodeval;
  1182.           want_concat_token = 0;
  1183.       } break;
  1184. case 16:
  1185. /* #line 199 "AWKTAB.Y" */
  1186. {
  1187.           yyval.nodeval = yypvt[-0].nodeval;
  1188.       } break;
  1189. case 17:
  1190. /* #line 204 "AWKTAB.Y" */
  1191. {
  1192.           yyval.nodeval = node(yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval);
  1193.       } break;
  1194. case 18:
  1195. /* #line 209 "AWKTAB.Y" */
  1196. {
  1197.           yyval.nodeval = node(yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval);
  1198.       } break;
  1199. case 19:
  1200. /* #line 214 "AWKTAB.Y" */
  1201. {
  1202.           yyval.nodeval = node(yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval);
  1203.       } break;
  1204. case 20:
  1205. /* #line 220 "AWKTAB.Y" */
  1206. {
  1207.           yyval.nodeval = NULL;
  1208.       } break;
  1209. case 21:
  1210. /* #line 225 "AWKTAB.Y" */
  1211. {
  1212.           yyval.nodeval = yypvt[-1].nodeval;
  1213.       } break;
  1214. case 22:
  1215. /* #line 233 "AWKTAB.Y" */
  1216. {
  1217.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_STATEMENT_LIST, NULL);
  1218.       } break;
  1219. case 23:
  1220. /* #line 238 "AWKTAB.Y" */
  1221. {
  1222.           yyval.nodeval = append_right(yypvt[-1].nodeval, node(yypvt[-0].nodeval, NODE_STATEMENT_LIST, NULL));
  1223.       } break;
  1224. case 24:
  1225. /* #line 245 "AWKTAB.Y" */
  1226. {
  1227.           yyval.nodetypeval = NODE_ILLEGAL;
  1228.       } break;
  1229. case 25:
  1230. /* #line 250 "AWKTAB.Y" */
  1231. {
  1232.           yyval.nodetypeval = NODE_ILLEGAL;
  1233.       } break;
  1234. case 26:
  1235. /* #line 256 "AWKTAB.Y" */
  1236. {
  1237.           ++want_regexp;
  1238.       } break;
  1239. case 27:
  1240. /* #line 260 "AWKTAB.Y" */
  1241. {
  1242.           want_regexp = 0;
  1243.           yyval.nodeval = node(NULL, NODE_REGEXP, (NODE *) make_regexp(yypvt[-1].sval));
  1244.       } break;
  1245. case 28:
  1246. /* #line 266 "AWKTAB.Y" */
  1247. {
  1248.           yyval.nodetypeval = NODE_GREATER;
  1249.       } break;
  1250. case 29:
  1251. /* #line 270 "AWKTAB.Y" */
  1252. {
  1253.           yyval.nodetypeval = NODE_LESS;
  1254.       } break;
  1255. case 30:
  1256. /* #line 274 "AWKTAB.Y" */
  1257. {
  1258.           yyval.nodetypeval = NODE_EQUAL;
  1259.       } break;
  1260. case 31:
  1261. /* #line 278 "AWKTAB.Y" */
  1262. {
  1263.           yyval.nodetypeval = NODE_GEQ;
  1264.       } break;
  1265. case 32:
  1266. /* #line 282 "AWKTAB.Y" */
  1267. {
  1268.           yyval.nodetypeval = NODE_LEQ;
  1269.       } break;
  1270. case 33:
  1271. /* #line 286 "AWKTAB.Y" */
  1272. {
  1273.           yyval.nodetypeval = NODE_NOTEQUAL;
  1274.       } break;
  1275. case 34:
  1276. /* #line 293 "AWKTAB.Y" */
  1277. {
  1278.           yyval.nodetypeval = NODE_ILLEGAL;
  1279.       } break;
  1280. case 39:
  1281. /* #line 305 "AWKTAB.Y" */
  1282. {
  1283.           yyval.nodeval = yypvt[-2].nodeval;
  1284.       } break;
  1285. case 40:
  1286. /* #line 310 "AWKTAB.Y" */
  1287. {
  1288.           yyval.nodeval = yypvt[-0].nodeval;
  1289.       } break;
  1290. case 41:
  1291. /* #line 315 "AWKTAB.Y" */
  1292. {
  1293.           yyval.nodeval = node(yypvt[-3].nodeval, NODE_K_WHILE, yypvt[-0].nodeval);
  1294.       } break;
  1295. case 42:
  1296. /* #line 320 "AWKTAB.Y" */
  1297. {
  1298.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_K_FOR, (NODE *) make_for_loop(yypvt[-7].nodeval, yypvt[-5].nodeval, yypvt[-3].nodeval));
  1299.       } break;
  1300. case 43:
  1301. /* #line 325 "AWKTAB.Y" */
  1302. {
  1303.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_K_FOR,
  1304.             (NODE *) make_for_loop(yypvt[-6].nodeval, NULL, yypvt[-3].nodeval));
  1305.       } break;
  1306. case 44:
  1307. /* #line 331 "AWKTAB.Y" */
  1308. {
  1309.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_K_ARRAYFOR,
  1310.             (NODE *) make_for_loop(variable(yypvt[-6].sval),
  1311.                            NULL, variable(yypvt[-3].sval)));
  1312.       } break;
  1313. case 45:
  1314. /* #line 339 "AWKTAB.Y" */
  1315. {
  1316.           yyval.nodeval = node(NULL, NODE_K_BREAK, NULL);
  1317.       } break;
  1318. case 46:
  1319. /* #line 345 "AWKTAB.Y" */
  1320. {
  1321.           yyval.nodeval = node(NULL, NODE_K_CONTINUE, NULL);
  1322.       } break;
  1323. case 47:
  1324. /* #line 350 "AWKTAB.Y" */
  1325. {
  1326.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_K_PRINT, yypvt[-1].nodeval);
  1327.       } break;
  1328. case 48:
  1329. /* #line 355 "AWKTAB.Y" */
  1330. {
  1331.           want_concat_token = FALSE;
  1332.       } break;
  1333. case 49:
  1334. /* #line 359 "AWKTAB.Y" */
  1335. {
  1336.           yyval.nodeval = node(yypvt[-4].nodeval, NODE_K_PRINT, yypvt[-1].nodeval);
  1337.       } break;
  1338. case 50:
  1339. /* #line 364 "AWKTAB.Y" */
  1340. {
  1341.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_K_PRINTF, yypvt[-1].nodeval);
  1342.       } break;
  1343. case 51:
  1344. /* #line 369 "AWKTAB.Y" */
  1345. {
  1346.           want_concat_token = FALSE;
  1347.       } break;
  1348. case 52:
  1349. /* #line 373 "AWKTAB.Y" */
  1350. {
  1351.           yyval.nodeval = node(yypvt[-4].nodeval, NODE_K_PRINTF, yypvt[-1].nodeval);
  1352.       } break;
  1353. case 53:
  1354. /* #line 378 "AWKTAB.Y" */
  1355. {
  1356.           yyval.nodeval = node(NULL, NODE_K_NEXT, NULL);
  1357.       } break;
  1358. case 54:
  1359. /* #line 383 "AWKTAB.Y" */
  1360. {
  1361.           yyval.nodeval = node(NULL, NODE_K_EXIT, NULL);
  1362.       } break;
  1363. case 55:
  1364. /* #line 388 "AWKTAB.Y" */
  1365. {
  1366.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_K_EXIT, NULL);
  1367.       } break;
  1368. case 56:
  1369. /* #line 393 "AWKTAB.Y" */
  1370. {
  1371.           yyval.nodeval = node(variable(yypvt[-4].sval), NODE_K_DELETE, yypvt[-2].nodeval);
  1372.       } break;
  1373. case 57:
  1374. /* #line 398 "AWKTAB.Y" */
  1375. {
  1376.           yyval.nodeval = yypvt[-1].nodeval;
  1377.       } break;
  1378. case 58:
  1379. /* #line 406 "AWKTAB.Y" */
  1380. {
  1381.           yyval.nodeval = node(yypvt[-3].nodeval, NODE_K_IF,
  1382.             node(yypvt[-0].nodeval, NODE_IF_BRANCHES, NULL));
  1383.       } break;
  1384. case 59:
  1385. /* #line 413 "AWKTAB.Y" */
  1386. {
  1387.           yyval.nodeval = node(yypvt[-6].nodeval, NODE_K_IF,
  1388.             node(yypvt[-3].nodeval, NODE_IF_BRANCHES, yypvt[-0].nodeval));
  1389.       } break;
  1390. case 61:
  1391. /* #line 422 "AWKTAB.Y" */
  1392. {
  1393.           yyval.nodetypeval = NODE_ILLEGAL;
  1394.       } break;
  1395. case 62:
  1396. /* #line 429 "AWKTAB.Y" */
  1397. {
  1398.           yyval.nodeval = NULL;
  1399.       } break;
  1400. case 63:
  1401. /* #line 434 "AWKTAB.Y" */
  1402. {
  1403.           yyval.nodeval = node(make_string(yypvt[-0].sval, -1), NODE_REDIRECT_OUTPUT, NULL);
  1404.       } break;
  1405. case 64:
  1406. /* #line 438 "AWKTAB.Y" */
  1407. {
  1408.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_REDIRECT_OUTPUT, NULL);
  1409.       } break;
  1410. case 65:
  1411. /* #line 442 "AWKTAB.Y" */
  1412. {
  1413.           yyval.nodeval = node(make_string(yypvt[-0].sval, -1), NODE_REDIRECT_APPEND, NULL);
  1414.       } break;
  1415. case 66:
  1416. /* #line 446 "AWKTAB.Y" */
  1417. {
  1418.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_REDIRECT_APPEND, NULL);
  1419.       } break;
  1420. case 67:
  1421. /* #line 453 "AWKTAB.Y" */
  1422. {
  1423.           yyval.nodeval = NULL;
  1424.       } break;
  1425. case 68:
  1426. /* #line 458 "AWKTAB.Y" */
  1427. {
  1428.           yyval.nodeval = node(make_string(yypvt[-0].sval, -1), NODE_REDIRECT_INPUT, NULL);
  1429.       } break;
  1430. case 69:
  1431. /* #line 462 "AWKTAB.Y" */
  1432. {
  1433.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_REDIRECT_INPUT, NULL);
  1434.       } break;
  1435. case 70:
  1436. /* #line 469 "AWKTAB.Y" */
  1437. {
  1438.           yyval.nodeval = variable(yypvt[-0].sval);
  1439.       } break;
  1440. case 71:
  1441. /* #line 474 "AWKTAB.Y" */
  1442. {
  1443.           yyval.nodeval = node(variable(yypvt[-3].sval), NODE_SUBSCRIPT, yypvt[-1].nodeval);
  1444.       } break;
  1445. case 72:
  1446. /* #line 479 "AWKTAB.Y" */
  1447. {
  1448.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_FIELD_SPEC, NULL);
  1449.       } break;
  1450. case 73:
  1451. /* #line 487 "AWKTAB.Y" */
  1452. {
  1453.           yyval.nodeval = NULL;
  1454.       } break;
  1455. case 74:
  1456. /* #line 492 "AWKTAB.Y" */
  1457. {
  1458.           yyval.nodeval = yypvt[-0].nodeval;
  1459.       } break;
  1460. case 75:
  1461. /* #line 499 "AWKTAB.Y" */
  1462. {
  1463.           yyval.nodeval = NULL;
  1464.       } break;
  1465. case 76:
  1466. /* #line 504 "AWKTAB.Y" */
  1467. {
  1468.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_EXPRESSION_LIST, NULL);
  1469.       } break;
  1470. case 77:
  1471. /* #line 509 "AWKTAB.Y" */
  1472. {
  1473.           yyval.nodeval = append_right(yypvt[-2].nodeval, node(yypvt[-0].nodeval, NODE_EXPRESSION_LIST, NULL));
  1474.       } break;
  1475. case 78:
  1476. /* #line 515 "AWKTAB.Y" */
  1477. {
  1478.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_UNARY_MINUS, NULL);
  1479.       } break;
  1480. case 79:
  1481. /* #line 520 "AWKTAB.Y" */
  1482. {
  1483.           yyval.nodeval = node(yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval);
  1484.       } break;
  1485. case 81:
  1486. /* #line 527 "AWKTAB.Y" */
  1487. {
  1488.           yyval.nodeval = yypvt[-1].nodeval;
  1489.       } break;
  1490. case 82:
  1491. /* #line 532 "AWKTAB.Y" */
  1492. {
  1493.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_PREINCREMENT, NULL);
  1494.       } break;
  1495. case 83:
  1496. /* #line 537 "AWKTAB.Y" */
  1497. {
  1498.           yyval.nodeval = node(yypvt[-0].nodeval, NODE_PREDECREMENT, NULL);
  1499.       } break;
  1500. case 84:
  1501. /* #line 542 "AWKTAB.Y" */
  1502. {
  1503.           yyval.nodeval = node(yypvt[-1].nodeval, NODE_POSTINCREMENT, NULL);
  1504.       } break;
  1505. case 85:
  1506. /* #line 547 "AWKTAB.Y" */
  1507. {
  1508.           yyval.nodeval = node(yypvt[-1].nodeval, NODE_POSTDECREMENT, NULL);
  1509.       } break;
  1510. case 86:
  1511. /* #line 552 "AWKTAB.Y" */
  1512. {
  1513.           yyval.nodeval = yypvt[-0].nodeval;
  1514.       } break;
  1515. case 87:
  1516. /* #line 557 "AWKTAB.Y" */
  1517. {
  1518.           yyval.nodeval = make_number(yypvt[-0].fval);
  1519.       } break;
  1520. case 88:
  1521. /* #line 562 "AWKTAB.Y" */
  1522. {
  1523.           yyval.nodeval = make_string(yypvt[-0].sval, -1);
  1524.       } break;
  1525. case 89:
  1526. /* #line 568 "AWKTAB.Y" */
  1527. {
  1528.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_EXPONENTIAL, yypvt[-0].nodeval);
  1529.       } break;
  1530. case 90:
  1531. /* #line 573 "AWKTAB.Y" */
  1532. {
  1533.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_TIMES, yypvt[-0].nodeval);
  1534.       } break;
  1535. case 91:
  1536. /* #line 578 "AWKTAB.Y" */
  1537. {
  1538.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_QUOTIENT, yypvt[-0].nodeval);
  1539.       } break;
  1540. case 92:
  1541. /* #line 583 "AWKTAB.Y" */
  1542. {
  1543.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_MOD, yypvt[-0].nodeval);
  1544.       } break;
  1545. case 93:
  1546. /* #line 588 "AWKTAB.Y" */
  1547. {
  1548.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_PLUS, yypvt[-0].nodeval);
  1549.       } break;
  1550. case 94:
  1551. /* #line 593 "AWKTAB.Y" */
  1552. {
  1553.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_MINUS, yypvt[-0].nodeval);
  1554.       } break;
  1555. case 95:
  1556. /* #line 599 "AWKTAB.Y" */
  1557. {
  1558.           yyval.nodeval = node(yypvt[-2].nodeval, NODE_CONCAT, yypvt[-0].nodeval);
  1559.       } break;
  1560. case 96:
  1561. /* #line 604 "AWKTAB.Y" */
  1562. {
  1563.           yyval.nodeval = node(yypvt[-4].nodeval, NODE_CONDEXP,
  1564.             node(yypvt[-2].nodeval, NODE_CONDEXP_BRANCHES, yypvt[-0].nodeval));
  1565.       } break;
  1566. case 97:
  1567. /* #line 611 "AWKTAB.Y" */
  1568. {
  1569.           yyval.nodeval = snode(yypvt[-1].nodeval, NODE_BUILTIN, yypvt[-3].ptrval);
  1570.       } break;
  1571. case 98:
  1572. /* #line 616 "AWKTAB.Y" */
  1573. {
  1574.           yyval.nodeval = snode(NULL, NODE_BUILTIN, yypvt[-0].ptrval);
  1575.       } break;
  1576. case 99:
  1577. /* #line 621 "AWKTAB.Y" */
  1578. {
  1579.           auto     NODE    *tmp;
  1580.  
  1581.           tmp = node(NULL, NODE_GETLINE, yypvt[-0].nodeval);
  1582.           yyval.nodeval  = snode(tmp, NODE_BUILTIN, yypvt[-1].ptrval);
  1583.       } break;
  1584. case 100:
  1585. /* #line 629 "AWKTAB.Y" */
  1586. {
  1587.           auto     NODE    *tmp;
  1588.  
  1589.           tmp = node(yypvt[-1].nodeval, NODE_GETLINE, yypvt[-0].nodeval);
  1590.           yyval.nodeval  = snode(tmp, NODE_BUILTIN, yypvt[-2].ptrval);
  1591.       } break;
  1592. case 101:
  1593. /* #line 637 "AWKTAB.Y" */
  1594. {
  1595.           auto     int    num;
  1596.  
  1597.           num = count_arguments(yypvt[-1].nodeval);
  1598.           if (num < 2 || num > 3)
  1599.           yyerror("Invalid number of arguments for function");
  1600.           yyval.nodeval = snode(yypvt[-1].nodeval, NODE_BUILTIN, yypvt[-3].ptrval);
  1601.       } break;
  1602. case 102:
  1603. /* #line 647 "AWKTAB.Y" */
  1604. {
  1605.           auto     NODE    *tmp;
  1606.  
  1607.           tmp = node(yypvt[-1].nodeval, NODE_EXPRESSION_LIST, NULL);
  1608.           tmp = append_right(yypvt[-3].nodeval, tmp);
  1609.           if (count_arguments(yypvt[-3].nodeval) != 3)
  1610.           yyerror("Invalid number of arguments for function");
  1611.           yyval.nodeval  = snode(yypvt[-3].nodeval, NODE_BUILTIN, yypvt[-5].ptrval);
  1612.       } break;
  1613. case 103:
  1614. /* #line 658 "AWKTAB.Y" */
  1615. {
  1616.           auto     NODE    *tmp;
  1617.  
  1618.           tmp = node(yypvt[-1].nodeval, NODE_EXPRESSION_LIST, NULL);
  1619.           tmp = node(yypvt[-3].nodeval, NODE_EXPRESSION_LIST, tmp);
  1620.           yyval.nodeval  = snode(tmp, NODE_BUILTIN, yypvt[-5].ptrval);
  1621.       } break;
  1622. case 104:
  1623. /* #line 667 "AWKTAB.Y" */
  1624. {
  1625.           if (count_arguments(yypvt[-1].nodeval) != 2)
  1626.           yyerror("Invalid number of arguments for function");
  1627.           yyval.nodeval = snode(yypvt[-1].nodeval, NODE_BUILTIN, yypvt[-3].ptrval);
  1628.       } break;
  1629. case 105:
  1630. /* #line 674 "AWKTAB.Y" */
  1631. {
  1632.           auto     NODE     *tmp;
  1633.  
  1634.           tmp = node(yypvt[-1].nodeval, NODE_EXPRESSION_LIST, NULL);
  1635.           tmp = node(yypvt[-3].nodeval, NODE_EXPRESSION_LIST, tmp);
  1636.           tmp = node(yypvt[-5].nodeval, NODE_EXPRESSION_LIST, tmp);
  1637.           yyval.nodeval  = snode(tmp, NODE_BUILTIN, yypvt[-7].ptrval);
  1638.       } break;
  1639. case 106:
  1640. /* #line 684 "AWKTAB.Y" */
  1641. {
  1642.           auto     NODE     *tmp;
  1643.  
  1644.           tmp = make_number((AWKNUM) 0.0);
  1645.           tmp = node(tmp, NODE_FIELD_SPEC, NULL);
  1646.           tmp = node(tmp, NODE_EXPRESSION_LIST, NULL);
  1647.           tmp = node(yypvt[-1].nodeval,  NODE_EXPRESSION_LIST, tmp);
  1648.           tmp = node(yypvt[-3].nodeval,  NODE_EXPRESSION_LIST, tmp);
  1649.           yyval.nodeval  = snode(tmp, NODE_BUILTIN, yypvt[-5].ptrval);
  1650.       } break;
  1651. case 107:
  1652. /* #line 696 "AWKTAB.Y" */
  1653. {
  1654.           auto     int    num;
  1655.           auto     NODE    *tmp;
  1656.  
  1657.           num = count_arguments(yypvt[-1].nodeval);
  1658.           if (num < 2 || num > 3)
  1659.           yyerror("Invalid number of arguments for function");
  1660.           if (num == 2)
  1661.           {
  1662.           tmp = make_number((AWKNUM) 0.0);
  1663.           tmp = node(tmp, NODE_FIELD_SPEC, NULL);
  1664.           append_right(yypvt[-1].nodeval, node(tmp, NODE_EXPRESSION_LIST, NULL));
  1665.           }
  1666.           yyval.nodeval  = snode(yypvt[-1].nodeval, NODE_BUILTIN, yypvt[-3].ptrval);
  1667.       } break;/* End of actions */
  1668.     }
  1669.     goto yystack;        /* stack new state and value */
  1670. }
  1671.