x2p/a2p.c

   1 extern char *malloc(), *realloc();
   2
   3 # line 2 "a2p.y"
   4 /* $RCSfile: a2p.y,v $$Revision: 4.0.1.2 $$Date: 92/06/08 16:13:03 $
   5  *
   6  *    Copyright (c) 1991, Larry Wall
   7  *
   8  *    You may distribute under the terms of either the GNU General Public
   9  *    License or the Artistic License, as specified in the README file.
  10  *
  11  * $Log:        a2p.y,v $
  12  * Revision 4.0.1.2  92/06/08  16:13:03  lwall
  13  * patch20: in a2p, getline should allow variable to be array element
  14  *
  15  * Revision 4.0.1.1  91/06/07  12:12:41  lwall
  16  * patch4: new copyright notice
  17  *
  18  * Revision 4.0  91/03/20  01:57:21  lwall
  19  * 4.0 baseline.
  20  *
  21  */
  22
  23 #include "INTERN.h"
  24 #include "a2p.h"
  25
  26 int root;
  27 int begins = Nullop;
  28 int ends = Nullop;
  29
  30 # define BEGIN 257
  31 # define END 258
  32 # define REGEX 259
  33 # define SEMINEW 260
  34 # define NEWLINE 261
  35 # define COMMENT 262
  36 # define FUN1 263
  37 # define FUNN 264
  38 # define GRGR 265
  39 # define PRINT 266
  40 # define PRINTF 267
  41 # define SPRINTF 268
  42 # define SPLIT 269
  43 # define IF 270
  44 # define ELSE 271
  45 # define WHILE 272
  46 # define FOR 273
  47 # define IN 274
  48 # define EXIT 275
  49 # define NEXT 276
  50 # define BREAK 277
  51 # define CONTINUE 278
  52 # define RET 279
  53 # define GETLINE 280
  54 # define DO 281
  55 # define SUB 282
  56 # define GSUB 283
  57 # define MATCH 284
  58 # define FUNCTION 285
  59 # define USERFUN 286
  60 # define DELETE 287
  61 # define ASGNOP 288
  62 # define OROR 289
  63 # define ANDAND 290
  64 # define NUMBER 291
  65 # define VAR 292
  66 # define SUBSTR 293
  67 # define INDEX 294
  68 # define MATCHOP 295
  69 # define RELOP 296
  70 # define OR 297
  71 # define STRING 298
  72 # define UMINUS 299
  73 # define NOT 300
  74 # define INCR 301
  75 # define DECR 302
  76 # define FIELD 303
  77 # define VFIELD 304
  78 #define yyclearin yychar = -1
  79 #define yyerrok yyerrflag = 0
  80 extern int yychar;
  81 extern int yyerrflag;
  82 #ifndef YYMAXDEPTH
  83 #define YYMAXDEPTH 150
  84 #endif
  85 #ifndef YYSTYPE
  86 #define YYSTYPE int
  87 #endif
  88 YYSTYPE yylval, yyval;
  89 # define YYERRCODE 256
  90
  91 # line 402 "a2p.y"
  92
  93 #include "a2py.c"
  94 int yyexca[] ={
  95 -1, 1,
  96         0, -1,
  97         -2, 0,
  98         };
  99 # define YYNPROD 137
 100 # define YYLAST 3142
 101 int yyact[]={
 102
 103     63,    44,   156,    32,    50,    31,   222,    73,    74,    75,
 104    210,    53,    45,    46,   124,    49,    86,   307,   104,   158,
 105     74,    75,    52,    54,    53,   302,   126,   271,   306,   265,
 106    106,   107,   270,   245,    51,   157,   269,    21,    56,    92,
 107      2,   131,    55,    20,    48,    72,    19,    90,    69,   132,
 108     47,   196,   241,   102,   100,   272,   195,   193,   109,   110,
 109    111,   112,   253,    76,    79,   252,    72,   139,    15,    77,
 110    237,    68,    78,   311,   236,   160,    66,    64,   309,    65,
 111    293,    67,   187,   174,   255,   139,   198,   184,   183,   130,
 112     68,    80,   179,   129,     5,    66,    64,    71,    65,   128,
 113     67,    68,   286,   214,   199,   212,    66,   211,   105,   103,
 114     99,    67,    98,    97,    96,    95,    71,   108,    94,    89,
 115     88,   152,    87,     4,   153,    10,     9,   200,    69,    14,
 116    177,   178,   239,   140,    13,     3,   136,   137,   127,     1,
 117      0,     0,     0,   185,   186,     0,    72,    69,   151,     0,
 118      0,   154,     0,     0,     0,     0,     0,     0,    69,     0,
 119      0,     0,     0,   204,   205,    72,     0,   106,   107,     0,
 120      0,     0,     0,     0,   175,   176,    72,   213,     0,   215,
 121     76,     0,   140,     0,     0,     0,    77,     0,     0,    78,
 122      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 123      0,     0,     0,   230,   231,   232,   233,   234,   235,     0,
 124    206,   207,     0,     0,     0,     0,   244,     0,     0,     0,
 125    159,   106,   107,    34,    35,     0,   162,   163,    37,    39,
 126    170,     0,   171,   173,   248,   166,   165,   164,   167,   168,
 127     33,   172,    42,    43,    41,   161,    36,   169,    44,    18,
 128    247,    27,    44,    38,    40,    54,    53,   249,    28,    45,
 129     46,    29,    30,    45,    46,    54,    53,    54,    53,     0,
 130    282,    18,    18,   238,   284,   285,   242,   243,   289,   290,
 131     54,    53,   240,    91,    54,    53,     0,   299,   300,    54,
 132     53,     0,   304,     0,     0,     6,     7,     8,    18,     0,
 133      0,   298,     0,   113,   114,   115,   116,    63,    70,    18,
 134     32,   310,    31,   313,   312,   315,   314,   316,     0,    18,
 135      0,     0,   303,     0,   247,     0,   158,    70,   201,   202,
 136    203,     0,   133,   135,    91,    91,   308,   287,   247,   141,
 137    143,   144,   145,   146,   147,   149,    91,     0,     0,    91,
 138      0,   301,     0,     0,     0,    18,    18,     0,     0,     0,
 139     63,     0,     0,    32,     0,    31,     0,     0,     0,     0,
 140      0,     0,     0,     0,     0,     0,     0,     0,   181,   158,
 141      0,     0,     0,     0,     0,     0,     0,     0,   141,     0,
 142    174,     0,   305,     0,     0,     0,     0,     0,     0,     0,
 143      0,     0,     0,     0,     0,     0,     0,     0,    91,    91,
 144     63,     0,   208,    32,   209,    31,     0,     0,     0,     0,
 145      0,     0,     0,     0,     0,     0,     0,     0,     0,   158,
 146      0,   219,   220,     0,   221,     0,   223,   225,   226,   227,
 147    228,   229,     0,   174,     0,   274,     0,     0,     0,     0,
 148      0,     0,     0,     0,     0,     0,     0,    18,    18,     0,
 149    246,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 150      0,     0,    63,     0,     0,    32,     0,    31,     0,     0,
 151      0,     0,   266,     0,     0,     0,   267,   268,     0,     0,
 152      0,   158,     0,   174,     0,   217,   275,     0,   276,     0,
 153      0,     0,     0,     0,   278,     0,   279,     0,   280,     0,
 154    281,     0,     0,     0,     0,     0,     0,     0,    18,     0,
 155      0,     0,     0,     0,     0,     0,     0,   159,     0,     0,
 156     34,    35,    18,   162,   163,    37,    39,   170,     0,   171,
 157    173,     0,   166,   165,   164,   167,   168,    33,   172,    42,
 158     43,    41,     0,    36,   169,   174,     0,   216,    27,    44,
 159     38,    40,     0,     0,     0,    28,     0,     0,    29,    30,
 160     45,    46,    63,     0,     0,    32,     0,    31,     0,     0,
 161    159,     0,     0,    34,    35,     0,   162,   163,    37,    39,
 162    170,     0,   171,   173,     0,   166,   165,   164,   167,   168,
 163     33,   172,    42,    43,    41,     0,    36,   169,     0,     0,
 164      0,    27,    44,    38,    40,     0,     0,     0,    28,     0,
 165      0,    29,    30,    45,    46,     0,    25,     0,     0,    32,
 166    159,    31,     0,    34,    35,     0,   162,   163,    37,    39,
 167    170,     0,   171,   173,     0,   166,   165,   164,   167,   168,
 168     33,   172,    42,    43,    41,     0,    36,   169,     0,     0,
 169      0,    27,    44,    38,    40,     0,     0,     0,    28,     0,
 170      0,    29,    30,    45,    46,    63,     0,     0,    32,     0,
 171     31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 172      0,     0,   159,     0,   158,    34,    35,     0,   162,   163,
 173     37,    39,   170,     0,   171,   173,     0,   166,   165,   164,
 174    167,   168,    33,   172,    42,    43,    41,     0,    36,   169,
 175      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 176     28,     0,     0,    29,    30,    45,    46,    63,     0,     0,
 177     32,     0,    31,     0,     0,     0,     0,     0,     0,     0,
 178      0,     0,     0,     0,     0,     0,   158,     0,   174,     0,
 179    197,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 180      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 181      0,     0,    63,     0,     0,    32,   138,    31,     0,     0,
 182      0,     0,     0,     0,     0,    34,    35,     0,   162,   163,
 183     37,    39,    59,     0,    58,     0,     0,   166,   165,   164,
 184    167,   168,    33,     0,    42,    43,    41,     0,    36,   169,
 185    174,     0,   155,    27,    44,    38,    40,     0,     0,     0,
 186     28,     0,     0,    29,    30,    45,    46,     0,     0,     0,
 187      0,     0,     0,     0,     0,    24,     0,   106,   107,    34,
 188     35,     0,     0,     0,    37,    39,     0,     0,     0,     0,
 189      0,     0,     0,     0,     0,     0,    33,     0,    42,    43,
 190     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 191     40,     0,     0,     0,    28,     0,    26,    29,    30,    45,
 192     46,     0,     0,     0,     0,   159,     0,     0,    34,    35,
 193      0,   162,   163,    37,    39,   170,     0,   171,   173,     0,
 194    166,   165,   164,   167,   168,    33,   172,    42,    43,    41,
 195     63,    36,   169,    32,     0,    31,    27,    44,    38,    40,
 196      0,     0,     0,    28,     0,     0,    29,    30,    45,    46,
 197     59,     0,    58,     0,     0,     0,     0,     0,     0,     0,
 198      0,     0,     0,     0,     0,     0,     0,   159,     0,     0,
 199     34,    35,     0,   162,   163,    37,    39,   170,     0,   171,
 200    173,     0,   166,   165,   164,   167,   168,    33,   172,    42,
 201     43,    41,     0,    36,   169,    23,     0,     0,    27,    44,
 202     38,    40,     0,     0,     0,    28,     0,     0,    29,    30,
 203     45,    46,     0,     0,    62,    34,    35,     0,     0,     0,
 204     37,    39,     0,     0,     0,    81,    82,    62,    62,    85,
 205      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 206      0,     0,    62,    27,    44,    38,    40,    60,    57,     0,
 207     28,     0,     0,    29,    30,    45,    46,     0,     0,     0,
 208     62,    62,    62,    62,    62,    62,    25,    62,     0,    32,
 209      0,    31,     0,     0,     0,     0,     0,     0,     0,     0,
 210      0,     0,     0,     0,     0,     0,     0,    62,     0,     0,
 211      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 212      0,     0,     0,     0,     0,     0,     0,     0,     0,    62,
 213     62,    62,    62,     0,     0,     0,     0,     0,     0,     0,
 214      0,     0,   180,     0,     0,     0,     0,     0,     0,    62,
 215     63,    62,     0,    32,     0,    31,     0,    62,     0,    62,
 216     62,    62,    62,    62,     0,    62,     0,     0,     0,    12,
 217      0,     0,     0,    34,    35,     0,     0,    62,    37,    39,
 218      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 219     33,     0,    42,    43,    41,    62,    36,    62,     0,     0,
 220      0,    27,    44,    38,    40,    60,    57,     0,    28,     0,
 221      0,    29,    30,    45,    46,     0,     0,     0,     0,     0,
 222      0,     0,     0,     0,    62,    62,     0,     0,     0,     0,
 223      0,     0,     0,     0,     0,    62,    62,    62,     0,    62,
 224      0,    62,    62,    62,    62,    62,     0,     0,     0,     0,
 225      0,     0,     0,    22,     0,     0,     0,     0,     0,     0,
 226      0,     0,    62,     0,     0,     0,     0,     0,     0,     0,
 227      0,     0,    61,     0,     0,     0,     0,     0,     0,     0,
 228      0,     0,    62,    62,    62,    83,    84,     0,     0,     0,
 229      0,    62,    62,     0,    62,    62,    62,    62,     0,     0,
 230    101,     0,     0,    16,    17,    24,     0,     0,     0,    34,
 231     35,     0,     0,     0,    37,    39,     0,     0,   118,   119,
 232    120,   121,   122,   123,     0,   125,    33,     0,    42,    43,
 233     41,    11,    36,     0,     0,     0,     0,    27,    44,    38,
 234     40,     0,     0,     0,    28,    61,    26,    29,    30,    45,
 235     46,     0,    25,     0,     0,    32,     0,    31,     0,     0,
 236      0,     0,     0,     0,     0,     0,     0,    61,    61,    61,
 237     61,   288,     0,    34,    35,     0,     0,     0,    37,    39,
 238      0,     0,     0,     0,     0,     0,     0,    61,     0,    61,
 239     33,     0,    42,    43,    41,    61,    36,    61,    61,    61,
 240     61,    61,    25,    61,     0,    32,     0,    31,    28,     0,
 241      0,    29,    30,    45,    46,    61,     0,     0,     0,     0,
 242      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 243      0,     0,     0,   218,     0,    61,     0,     0,     0,     0,
 244      0,     0,     0,     0,    63,   263,     0,    32,   264,    31,
 245      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 246      0,     0,    61,    61,     0,     0,     0,     0,     0,     0,
 247      0,     0,     0,    61,    61,    61,     0,    61,     0,    61,
 248     61,    61,    61,    61,     0,     0,    63,   261,     0,    32,
 249    262,    31,     0,     0,     0,     0,     0,     0,     0,     0,
 250     61,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 251      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 252     61,    61,    61,     0,     0,     0,     0,     0,     0,    61,
 253     61,     0,    61,    61,    61,    61,    63,   259,     0,    32,
 254    260,    31,     0,     0,     0,     0,     0,     0,     0,     0,
 255      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 256      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 257      0,    24,     0,     0,     0,    34,    35,     0,     0,     0,
 258     37,    39,    63,   257,     0,    32,   258,    31,     0,     0,
 259      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 260      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 261     28,     0,    26,    29,    30,    45,    46,     0,     0,     0,
 262      0,    24,     0,     0,     0,    34,    35,     0,     0,     0,
 263     37,    39,    63,   251,     0,    32,   250,    31,     0,     0,
 264      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 265      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 266     28,     0,    26,    29,    30,    45,    46,    34,    35,     0,
 267      0,     0,    37,    39,     0,     0,    63,     0,     0,    32,
 268      0,    31,     0,     0,    33,     0,    42,    43,    41,     0,
 269     36,     0,     0,     0,     0,    27,    44,    38,    40,     0,
 270      0,     0,    28,     0,     0,    29,    30,    45,    46,    34,
 271     35,     0,     0,     0,    37,    39,     0,     0,     0,     0,
 272      0,     0,   142,     0,     0,    32,    33,    31,    42,    43,
 273     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 274     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 275     46,     0,     0,     0,     0,     0,     0,     0,     0,    34,
 276     35,     0,     0,     0,    37,    39,    63,   297,     0,    32,
 277      0,    31,     0,     0,     0,     0,    33,     0,    42,    43,
 278     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 279     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 280     46,     0,     0,     0,     0,    34,    35,     0,     0,     0,
 281     37,    39,    63,   296,     0,    32,     0,    31,     0,     0,
 282      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 283      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 284     28,     0,     0,    29,    30,    45,    46,     0,     0,     0,
 285      0,     0,     0,     0,     0,    34,    35,     0,     0,     0,
 286     37,    39,    63,   295,     0,    32,     0,    31,     0,     0,
 287      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 288      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 289     28,     0,     0,    29,    30,    45,    46,   106,   107,    34,
 290     35,     0,     0,     0,    37,    39,    63,   294,     0,    32,
 291      0,    31,     0,     0,     0,     0,    33,     0,    42,    43,
 292     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 293     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 294     46,    24,     0,     0,     0,    34,    35,     0,     0,     0,
 295     37,    39,    63,   292,     0,    32,     0,    31,     0,     0,
 296      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 297      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 298     28,     0,    26,    29,    30,    45,    46,     0,     0,    34,
 299     35,     0,     0,     0,    37,    39,    63,   291,     0,    32,
 300      0,    31,     0,     0,     0,     0,    33,     0,    42,    43,
 301     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 302     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 303     46,     0,     0,     0,     0,    34,    35,     0,     0,    63,
 304     37,    39,    32,     0,    31,     0,     0,     0,     0,     0,
 305      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 306      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 307     28,     0,     0,    29,    30,    45,    46,     0,     0,     0,
 308      0,     0,     0,     0,     0,    34,    35,     0,     0,     0,
 309     37,    39,   283,    63,     0,     0,    32,     0,    31,     0,
 310      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 311      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 312     28,     0,     0,    29,    30,    45,    46,     0,     0,    34,
 313     35,     0,     0,     0,    37,    39,    63,   273,     0,    32,
 314      0,    31,     0,     0,     0,     0,    33,     0,    42,    43,
 315     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 316     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 317     46,     0,     0,     0,     0,    34,    35,     0,     0,     0,
 318     37,    39,    63,   256,     0,    32,     0,    31,     0,     0,
 319      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 320      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 321     28,     0,     0,    29,    30,    45,    46,     0,     0,    34,
 322     35,     0,     0,     0,    37,    39,    63,   254,     0,    32,
 323      0,    31,     0,     0,     0,     0,    33,     0,    42,    43,
 324     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 325     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 326     46,     0,    34,    35,     0,     0,     0,    37,    39,     0,
 327      0,     0,    63,     0,     0,    32,     0,    31,     0,    33,
 328      0,    42,    43,    41,     0,    36,     0,     0,     0,     0,
 329     27,    44,    38,    40,     0,     0,     0,    28,     0,     0,
 330     29,    30,    45,    46,     0,     0,     0,     0,     0,     0,
 331      0,     0,   277,     0,     0,    63,    34,    35,    32,   194,
 332     31,    37,    39,     0,     0,     0,     0,     0,     0,     0,
 333      0,     0,     0,    33,     0,    42,    43,    41,     0,    36,
 334      0,     0,     0,     0,    27,    44,    38,    40,     0,     0,
 335      0,    28,     0,     0,    29,    30,    45,    46,    63,    34,
 336     35,    32,   192,    31,    37,    39,     0,     0,     0,     0,
 337      0,     0,     0,     0,     0,     0,    33,     0,    42,    43,
 338     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 339     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 340     46,     0,     0,     0,    63,    34,    35,    32,   191,    31,
 341     37,    39,     0,     0,     0,     0,     0,     0,     0,     0,
 342      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 343      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 344     28,     0,     0,    29,    30,    45,    46,     0,    63,    34,
 345     35,    32,   190,    31,    37,    39,     0,     0,     0,     0,
 346      0,     0,     0,     0,     0,     0,    33,     0,    42,    43,
 347     41,     0,    36,     0,     0,     0,     0,    27,    44,    38,
 348     40,     0,     0,     0,    28,     0,     0,    29,    30,    45,
 349     46,   224,     0,     0,    63,    34,    35,    32,   189,    31,
 350     37,    39,     0,     0,     0,     0,     0,     0,     0,     0,
 351      0,     0,    33,     0,    42,    43,    41,     0,    36,     0,
 352      0,     0,     0,    27,    44,    38,    40,     0,     0,     0,
 353     28,     0,     0,    29,    30,    45,    46,    63,    34,    35,
 354     32,   188,    31,    37,    39,     0,     0,     0,     0,     0,
 355      0,     0,     0,     0,     0,    33,     0,    42,    43,    41,
 356      0,    36,     0,     0,     0,     0,    27,    44,    38,    40,
 357      0,     0,     0,    28,     0,     0,    29,    30,    45,    46,
 358      0,    34,    35,     0,     0,     0,    37,    39,    63,   182,
 359      0,    32,     0,    31,     0,     0,     0,     0,    33,     0,
 360     42,    43,    41,     0,    36,     0,     0,     0,     0,    27,
 361     44,    38,    40,     0,     0,     0,    28,     0,     0,    29,
 362     30,    45,    46,     0,     0,     0,     0,    34,    35,     0,
 363      0,     0,    37,    39,    63,     0,     0,    32,     0,    31,
 364      0,     0,     0,     0,    33,     0,    42,    43,    41,     0,
 365     36,     0,     0,     0,     0,    27,    44,    38,    40,     0,
 366      0,     0,    28,     0,     0,    29,    30,    45,    46,     0,
 367      0,    34,    35,     0,     0,     0,    37,    39,     0,     0,
 368     63,     0,     0,    32,     0,    31,     0,     0,    33,     0,
 369     42,    43,    41,     0,    36,     0,     0,     0,     0,    27,
 370     44,    38,    40,     0,     0,     0,    28,     0,     0,    29,
 371     30,    45,    46,     0,     0,     0,     0,    34,    35,     0,
 372      0,     0,    37,    39,    63,     0,     0,    32,   138,    31,
 373      0,     0,     0,     0,    33,     0,    42,    43,    41,     0,
 374     36,     0,     0,     0,     0,    27,    44,    38,    40,     0,
 375      0,     0,    28,     0,     0,    29,    30,    45,    46,     0,
 376     34,    35,     0,     0,     0,    37,    39,    63,   134,     0,
 377     32,     0,    31,     0,     0,     0,     0,    33,     0,    42,
 378     43,    41,     0,    36,     0,     0,     0,     0,    27,    44,
 379     38,    40,     0,     0,     0,    28,     0,     0,    29,    30,
 380     45,    46,     0,     0,     0,     0,     0,     0,     0,     0,
 381      0,    34,    35,     0,     0,    63,    37,    39,    32,     0,
 382     31,     0,     0,     0,     0,     0,     0,     0,    33,     0,
 383     42,    43,    41,     0,    36,     0,     0,     0,     0,    27,
 384     44,    38,    40,     0,     0,     0,    28,     0,     0,    29,
 385     30,    45,    46,   150,     0,     0,     0,    34,    35,     0,
 386      0,    63,    37,    39,    32,     0,    31,     0,     0,     0,
 387      0,     0,     0,     0,    33,     0,    42,    43,    41,     0,
 388     36,     0,     0,     0,     0,    27,    44,    38,    40,     0,
 389      0,     0,    28,     0,     0,    29,    30,    45,    46,   148,
 390      0,     0,     0,    34,    35,     0,     0,    93,    37,    39,
 391     32,     0,    31,     0,     0,     0,     0,     0,     0,     0,
 392     33,     0,    42,    43,    41,     0,    36,     0,     0,     0,
 393      0,    27,    44,    38,    40,     0,     0,     0,    28,     0,
 394      0,    29,    30,    45,    46,     0,     0,    34,    35,     0,
 395      0,     0,    37,    39,     0,     0,     0,     0,     0,     0,
 396      0,     0,     0,     0,    33,     0,    42,    43,    41,     0,
 397     36,     0,     0,     0,     0,    27,    44,    38,    40,     0,
 398      0,     0,    28,     0,     0,    29,    30,    45,    46,     0,
 399     34,    35,     0,     0,     0,    37,    39,     0,     0,     0,
 400      0,     0,     0,     0,     0,     0,     0,    33,     0,    42,
 401     43,    41,     0,    36,     0,     0,     0,     0,    27,    44,
 402     38,    40,     0,     0,     0,    28,     0,     0,    29,    30,
 403     45,    46,     0,     0,   117,     0,     0,     0,    34,    35,
 404      0,     0,     0,    37,    39,     0,     0,     0,     0,     0,
 405      0,     0,     0,     0,     0,    33,     0,    42,    43,    41,
 406      0,    36,     0,     0,     0,     0,    27,    44,    38,    40,
 407      0,     0,     0,    28,     0,     0,    29,    30,    45,    46,
 408      0,     0,     0,     0,    34,    35,     0,     0,     0,    37,
 409     39,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 410      0,    33,     0,    42,    43,    41,     0,    36,     0,     0,
 411      0,     0,    27,    44,    38,    40,     0,     0,     0,    28,
 412      0,     0,    29,    30,    45,    46,     0,     0,     0,     0,
 413     34,    35,     0,     0,     0,    37,    39,     0,     0,     0,
 414      0,     0,     0,     0,     0,     0,     0,    33,     0,    42,
 415     43,    41,     0,    36,     0,     0,     0,     0,    27,    44,
 416     38,    40,     0,     0,     0,    28,     0,     0,    29,    30,
 417     45,    46 };
 418 int yypact[]={
 419
 420  -1000, -1000,    35,  1016, -1000, -1000, -1000, -1000, -1000, -1000,
 421    -79,  -271, -1000, -1000,  -227,   -22,   -81,   -85,   880, -1000,
 422  -1000, -1000,    53,  -281, -1000,  1332,  1332, -1000, -1000,  -291,
 423   -291,  2791,  2791,   -44,    82,    80,    79,  2837,    78,    75,
 424     74,    73,    72,    70,   -37, -1000,  2791,    35, -1000,    69,
 425   -231, -1000,  1332, -1000, -1000, -1000, -1000,  2791,  2791,  2791,
 426   2745,    53,  -293,  1332,  2791,  2791,  2791,  2791,  2791,  2791,
 427   -278,  2791,  -254,  1332, -1000, -1000,    58,    52,    48,     0,
 428  -1000, -1000, -1000,   -46,   -46,   -11,  2791,  2697,  2837,  2837,
 429  -1000,  2654,    23,  1652,  2791,  2791,  2791,  2791,  2610,  2564,
 430   2837,   -67,  -231,  2837,   697, -1000, -1000, -1000,  -266,   586,
 431    586,  -231,  -231,  1080,  1080,  1080,  1080, -1000,    64,    64,
 432    -46,   -46,   -46,   -46, -1000,    34,  -291,  -266, -1000, -1000,
 433  -1000, -1000,  2791,  1080, -1000,  2518,    47,    46, -1000, -1000,
 434     41,   742,  1652,  2467,  2424,  2378,  2334,  2288,    13,  2245,
 435     12,   -42,   635,    45, -1000, -1000, -1000,    68, -1000, -1000,
 436  -1000,  2791,  2837,  2837, -1000, -1000,  2791, -1000,  2791,  -282,
 437     67,    65, -1000,    63, -1000, -1000,  -279,   432,   370,  2791,
 438  -1000,  1080, -1000, -1000, -1000,  1606,  1606, -1000,  2791,  -286,
 439   2791,  2202,  2791,  2791,  2791,  2791, -1000, -1000, -1000, -1000,
 440  -1000, -1000, -1000, -1000,  -231,  -231,     8,     8,  2791,  2791,
 441    -39,  1332,  1332,   -40,   532,  -231, -1000, -1000,    53,  2791,
 442   2791,  1562,    21,  2156,    43,  2112,  1512,  1466,  1416,  1374,
 443    -94,  -231,  -231,  -231,  -231,  -231,  2791, -1000, -1000, -1000,
 444   2791,  2791,    -5,    -9,  -245,    -4,  2066, -1000,   320,    35,
 445   2791, -1000,  2023, -1000, -1000, -1000, -1000, -1000,  2791, -1000,
 446   2791, -1000,  2791, -1000,  2791, -1000,  2791,  2791,  1969, -1000,
 447  -1000,    62,  1282, -1000, -1000,  1926,  1882,    39,  1836,  1792,
 448   1742,  1696,  -231, -1000,   -40,   -40,  1332,   -34,   532,   -40,
 449   -231, -1000, -1000, -1000, -1000, -1000, -1000, -1000,   267,  -243,
 450  -1000,   -24,   532,    37, -1000, -1000, -1000, -1000,    32, -1000,
 451    -40, -1000,   -40, -1000,   -40, -1000, -1000 };
 452 int yypgo[]={
 453
 454      0,   139,    40,   135,   134,     4,    18,   129,   126,   125,
 455    124,    47,    64,   245,    46,    43,    37,  1223,   985,    39,
 456    123,   108,   104,     2,    35,    75,    33,    74 };
 457 int yyr1[]={
 458
 459      0,     1,     4,     7,     7,     3,     3,     8,     8,     8,
 460      8,     8,     8,    10,     9,     9,    12,    12,    12,    12,
 461     16,    16,    16,    16,    15,    15,    15,    15,    14,    14,
 462     14,    14,    13,    13,    13,    17,    17,    17,    17,    17,
 463     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 464     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 465     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 466     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 467     17,    18,    18,    18,    18,    11,    11,    11,    19,    19,
 468     19,     2,     2,    20,    20,    20,    20,     5,     5,    21,
 469     21,    22,    22,    22,    22,     6,     6,    23,    23,    23,
 470     23,    26,    26,    24,    24,    24,    24,    24,    24,    24,
 471     24,    24,    24,    24,    24,    24,    27,    27,    27,    25,
 472     25,    25,    25,    25,    25,    25,    25 };
 473 int yyr2[]={
 474
 475      0,     5,    13,    11,     5,     7,     1,     3,    11,    21,
 476      9,     2,     2,     3,     3,     7,     2,     2,     2,     2,
 477      7,     9,     9,     5,     7,     7,     7,     7,     7,     7,
 478      3,     7,     3,     5,     7,     3,     3,     3,     7,     7,
 479      7,     7,     7,     7,     7,    11,     5,     5,     5,     5,
 480      5,     5,     7,     3,     5,     7,     9,     7,     9,     3,
 481      7,     9,     9,     9,     5,    17,    13,    17,    17,    13,
 482     13,    13,    13,    13,    13,    13,    13,    17,    17,    17,
 483     17,     3,     9,     3,     5,     2,     2,     1,     9,     9,
 484      7,     5,     1,     3,     3,     3,     3,     5,     1,     3,
 485      3,     5,     5,     5,     5,     5,     1,     7,     5,     5,
 486      2,     2,     1,     2,     9,     5,     9,     5,     3,     3,
 487      3,     5,     3,     3,     5,    11,     3,     3,     3,    13,
 488     19,    13,    15,    21,    19,    13,    11 };
 489 int yychk[]={
 490
 491  -1000,    -1,    -2,    -3,   -20,    59,   260,   261,   262,    -8,
 492     -9,   285,   123,    -4,    -7,   -12,   257,   258,   -13,   -14,
 493    -15,   -16,   -17,   -18,   259,    40,   300,   291,   298,   301,
 494    302,    45,    43,   280,   263,   264,   286,   268,   293,   269,
 495    294,   284,   282,   283,   292,   303,   304,    -2,   123,   286,
 496     -5,   261,    44,   290,   289,   123,   123,   296,    62,    60,
 497    295,   -17,   -18,    40,    43,    45,    42,    47,    37,    94,
 498    274,    63,   112,   288,   301,   302,   -16,   -15,   -14,   -12,
 499    -12,   -18,   -18,   -17,   -17,   -18,    60,    40,    40,    40,
 500    -11,   -13,   -19,    40,    40,    40,    40,    40,    40,    40,
 501     91,   -17,    -5,    40,    -6,   -21,   261,   262,   -12,    -5,
 502     -5,    -5,    -5,   -13,   -13,   -13,   -13,   259,   -17,   -17,
 503    -17,   -17,   -17,   -17,   292,   -17,   280,   -12,    41,    41,
 504     41,    41,    60,   -13,    41,   -13,   -11,   -11,    44,    44,
 505    -19,   -13,    40,   -13,   -13,   -13,   -13,   -13,   259,   -13,
 506    259,   -11,    -6,   -10,   -11,   125,   -23,   -24,    59,   260,
 507    -25,   -13,   266,   267,   277,   276,   275,   278,   279,   287,
 508    270,   272,   281,   273,   123,   -12,   -12,    -6,    -6,    58,
 509    -18,   -13,    41,    41,    41,    -5,    -5,    41,    44,    44,
 510     44,    44,    44,    44,    44,    44,    93,   125,    41,   -22,
 511     59,   260,   261,   262,    -5,    -5,   -11,   -11,   -13,   -13,
 512    292,    40,    40,    -5,    40,    -5,   125,   125,   -17,   -13,
 513    -13,   -13,   292,   -13,   259,   -13,   -13,   -13,   -13,   -13,
 514     -5,    -5,    -5,    -5,    -5,    -5,   -27,    62,   265,   124,
 515    -27,    91,   -12,   -12,   -23,   -26,   -13,   -24,    -6,    -2,
 516     44,    41,    44,    41,    41,    41,    41,    41,    44,    41,
 517     44,    41,    44,    41,    44,   123,   -13,   -13,   -13,    41,
 518     41,   272,    59,    41,   125,   -13,   -13,   259,   -13,   -13,
 519    -13,   -13,    -5,    93,    -5,    -5,    40,   -12,    59,    -5,
 520     -5,    41,    41,    41,    41,    41,    41,    41,    -6,   -23,
 521    -23,   -12,    59,   -26,   -23,   125,   271,    41,   -26,    41,
 522     -5,    41,    -5,   -23,    -5,   -23,   -23 };
 523 int yydef[]={
 524
 525     92,    -2,     6,     1,    91,    93,    94,    95,    96,    92,
 526      7,     0,    98,    11,    12,    14,     0,     0,    16,    17,
 527     18,    19,    32,    35,    30,     0,     0,    36,    37,     0,
 528      0,     0,     0,    53,    59,     0,     0,    87,     0,     0,
 529      0,     0,     0,     0,    81,    83,     0,     5,    98,     0,
 530    106,     4,     0,    98,    98,    98,    98,     0,     0,     0,
 531      0,    33,    35,     0,     0,     0,     0,     0,     0,     0,
 532      0,     0,     0,     0,    46,    47,    19,    18,    17,     0,
 533     23,    48,    49,    50,    51,    54,     0,     0,    87,    87,
 534     64,    85,    86,     0,     0,     0,     0,     0,     0,     0,
 535     87,    84,   106,    87,     0,    97,    99,   100,    15,     0,
 536      0,   106,   106,    24,    25,    26,    28,    29,    38,    39,
 537     40,    41,    42,    43,    44,     0,    57,    34,    20,    27,
 538     31,    52,     0,    55,    60,     0,     0,     0,    98,    98,
 539      0,    16,     0,     0,     0,     0,     0,     0,     0,     0,
 540      0,     0,     0,     0,    13,    10,   105,     0,    98,    98,
 541    110,   113,    87,    87,   118,   119,   120,   122,   123,     0,
 542      0,     0,    98,     0,    98,    21,    22,     0,     0,     0,
 543     58,    56,    61,    62,    63,     0,     0,    90,     0,     0,
 544      0,     0,     0,     0,     0,     0,    82,     8,    98,    98,
 545     98,    98,    98,    98,   108,   109,   115,   117,   121,   124,
 546      0,     0,     0,     0,   112,   106,    92,     3,    45,    88,
 547     89,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 548      0,   107,   101,   102,   103,   104,     0,   126,   127,   128,
 549      0,     0,     0,     0,     0,     0,   113,   111,     0,     2,
 550      0,    66,     0,    69,    70,    71,    72,    73,     0,    74,
 551      0,    75,     0,    76,     0,    98,   114,   116,     0,    98,
 552     98,     0,     0,    98,    98,     0,     0,     0,     0,     0,
 553      0,     0,   106,   125,     0,     0,     0,     0,   112,     0,
 554    136,    65,    67,    68,    77,    78,    79,    80,     0,   129,
 555    131,     0,   112,     0,   135,     9,    98,   132,     0,    98,
 556      0,    98,     0,   130,     0,   134,   133 };
 557 typedef struct { char *t_name; int t_val; } yytoktype;
 558 #ifndef YYDEBUG
 559 #       define YYDEBUG  0       /* don't allow debugging */
 560 #endif
 561
 562 #if YYDEBUG
 563
 564 yytoktype yytoks[] =
 565 {
 566         "BEGIN",        257,
 567         "END",  258,
 568         "REGEX",        259,
 569         "SEMINEW",      260,
 570         "NEWLINE",      261,
 571         "COMMENT",      262,
 572         "FUN1", 263,
 573         "FUNN", 264,
 574         "GRGR", 265,
 575         "PRINT",        266,
 576         "PRINTF",       267,
 577         "SPRINTF",      268,
 578         "SPLIT",        269,
 579         "IF",   270,
 580         "ELSE", 271,
 581         "WHILE",        272,
 582         "FOR",  273,
 583         "IN",   274,
 584         "EXIT", 275,
 585         "NEXT", 276,
 586         "BREAK",        277,
 587         "CONTINUE",     278,
 588         "RET",  279,
 589         "GETLINE",      280,
 590         "DO",   281,
 591         "SUB",  282,
 592         "GSUB", 283,
 593         "MATCH",        284,
 594         "FUNCTION",     285,
 595         "USERFUN",      286,
 596         "DELETE",       287,
 597         "ASGNOP",       288,
 598         "?",    63,
 599         ":",    58,
 600         "OROR", 289,
 601         "ANDAND",       290,
 602         "NUMBER",       291,
 603         "VAR",  292,
 604         "SUBSTR",       293,
 605         "INDEX",        294,
 606         "MATCHOP",      295,
 607         "RELOP",        296,
 608         "<",    60,
 609         ">",    62,
 610         "OR",   297,
 611         "STRING",       298,
 612         "+",    43,
 613         "-",    45,
 614         "*",    42,
 615         "/",    47,
 616         "%",    37,
 617         "UMINUS",       299,
 618         "NOT",  300,
 619         "^",    94,
 620         "INCR", 301,
 621         "DECR", 302,
 622         "FIELD",        303,
 623         "VFIELD",       304,
 624         "-unknown-",    -1      /* ends search */
 625 };
 626
 627 char * yyreds[] =
 628 {
 629         "-no such reduction-",
 630         "program : junk hunks",
 631         "begin : BEGIN '{' maybe states '}' junk",
 632         "end : END '{' maybe states '}'",
 633         "end : end NEWLINE",
 634         "hunks : hunks hunk junk",
 635         "hunks : /* empty */",
 636         "hunk : patpat",
 637         "hunk : patpat '{' maybe states '}'",
 638         "hunk : FUNCTION USERFUN '(' arg_list ')' maybe '{' maybe states '}'",
 639         "hunk : '{' maybe states '}'",
 640         "hunk : begin",
 641         "hunk : end",
 642         "arg_list : expr_list",
 643         "patpat : cond",
 644         "patpat : cond ',' cond",
 645         "cond : expr",
 646         "cond : match",
 647         "cond : rel",
 648         "cond : compound_cond",
 649         "compound_cond : '(' compound_cond ')'",
 650         "compound_cond : cond ANDAND maybe cond",
 651         "compound_cond : cond OROR maybe cond",
 652         "compound_cond : NOT cond",
 653         "rel : expr RELOP expr",
 654         "rel : expr '>' expr",
 655         "rel : expr '<' expr",
 656         "rel : '(' rel ')'",
 657         "match : expr MATCHOP expr",
 658         "match : expr MATCHOP REGEX",
 659         "match : REGEX",
 660         "match : '(' match ')'",
 661         "expr : term",
 662         "expr : expr term",
 663         "expr : variable ASGNOP cond",
 664         "term : variable",
 665         "term : NUMBER",
 666         "term : STRING",
 667         "term : term '+' term",
 668         "term : term '-' term",
 669         "term : term '*' term",
 670         "term : term '/' term",
 671         "term : term '%' term",
 672         "term : term '^' term",
 673         "term : term IN VAR",
 674         "term : term '?' term ':' term",
 675         "term : variable INCR",
 676         "term : variable DECR",
 677         "term : INCR variable",
 678         "term : DECR variable",
 679         "term : '-' term",
 680         "term : '+' term",
 681         "term : '(' cond ')'",
 682         "term : GETLINE",
 683         "term : GETLINE variable",
 684         "term : GETLINE '<' expr",
 685         "term : GETLINE variable '<' expr",
 686         "term : term 'p' GETLINE",
 687         "term : term 'p' GETLINE variable",
 688         "term : FUN1",
 689         "term : FUN1 '(' ')'",
 690         "term : FUN1 '(' expr ')'",
 691         "term : FUNN '(' expr_list ')'",
 692         "term : USERFUN '(' expr_list ')'",
 693         "term : SPRINTF expr_list",
 694         "term : SUBSTR '(' expr ',' expr ',' expr ')'",
 695         "term : SUBSTR '(' expr ',' expr ')'",
 696         "term : SPLIT '(' expr ',' VAR ',' expr ')'",
 697         "term : SPLIT '(' expr ',' VAR ',' REGEX ')'",
 698         "term : SPLIT '(' expr ',' VAR ')'",
 699         "term : INDEX '(' expr ',' expr ')'",
 700         "term : MATCH '(' expr ',' REGEX ')'",
 701         "term : MATCH '(' expr ',' expr ')'",
 702         "term : SUB '(' expr ',' expr ')'",
 703         "term : SUB '(' REGEX ',' expr ')'",
 704         "term : GSUB '(' expr ',' expr ')'",
 705         "term : GSUB '(' REGEX ',' expr ')'",
 706         "term : SUB '(' expr ',' expr ',' expr ')'",
 707         "term : SUB '(' REGEX ',' expr ',' expr ')'",
 708         "term : GSUB '(' expr ',' expr ',' expr ')'",
 709         "term : GSUB '(' REGEX ',' expr ',' expr ')'",
 710         "variable : VAR",
 711         "variable : VAR '[' expr_list ']'",
 712         "variable : FIELD",
 713         "variable : VFIELD term",
 714         "expr_list : expr",
 715         "expr_list : clist",
 716         "expr_list : /* empty */",
 717         "clist : expr ',' maybe expr",
 718         "clist : clist ',' maybe expr",
 719         "clist : '(' clist ')'",
 720         "junk : junk hunksep",
 721         "junk : /* empty */",
 722         "hunksep : ';'",
 723         "hunksep : SEMINEW",
 724         "hunksep : NEWLINE",
 725         "hunksep : COMMENT",
 726         "maybe : maybe nlstuff",
 727         "maybe : /* empty */",
 728         "nlstuff : NEWLINE",
 729         "nlstuff : COMMENT",
 730         "separator : ';' maybe",
 731         "separator : SEMINEW maybe",
 732         "separator : NEWLINE maybe",
 733         "separator : COMMENT maybe",
 734         "states : states statement",
 735         "states : /* empty */",
 736         "statement : simple separator maybe",
 737         "statement : ';' maybe",
 738         "statement : SEMINEW maybe",
 739         "statement : compound",
 740         "simpnull : simple",
 741         "simpnull : /* empty */",
 742         "simple : expr",
 743         "simple : PRINT expr_list redir expr",
 744         "simple : PRINT expr_list",
 745         "simple : PRINTF expr_list redir expr",
 746         "simple : PRINTF expr_list",
 747         "simple : BREAK",
 748         "simple : NEXT",
 749         "simple : EXIT",
 750         "simple : EXIT expr",
 751         "simple : CONTINUE",
 752         "simple : RET",
 753         "simple : RET expr",
 754         "simple : DELETE VAR '[' expr ']'",
 755         "redir : '>'",
 756         "redir : GRGR",
 757         "redir : '|'",
 758         "compound : IF '(' cond ')' maybe statement",
 759         "compound : IF '(' cond ')' maybe statement ELSE maybe statement",
 760         "compound : WHILE '(' cond ')' maybe statement",
 761         "compound : DO maybe statement WHILE '(' cond ')'",
 762         "compound : FOR '(' simpnull ';' cond ';' simpnull ')' maybe statement",
 763         "compound : FOR '(' simpnull ';' ';' simpnull ')' maybe statement",
 764         "compound : FOR '(' expr ')' maybe statement",
 765         "compound : '{' maybe states '}' maybe",
 766 };
 767 #endif /* YYDEBUG */
 768 #line 1 "/usr/lib/yaccpar"
 769 /*      @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10   */
 770
 771 /*
 772 ** Skeleton parser driver for yacc output
 773 */
 774
 775 /*
 776 ** yacc user known macros and defines
 777 */
 778 #define YYERROR         goto yyerrlab
 779 #define YYACCEPT        { free(yys); free(yyv); return(0); }
 780 #define YYABORT         { free(yys); free(yyv); return(1); }
 781 #define YYBACKUP( newtoken, newvalue )\
 782 {\
 783         if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
 784         {\
 785                 yyerror( "syntax error - cannot backup" );\
 786                 goto yyerrlab;\
 787         }\
 788         yychar = newtoken;\
 789         yystate = *yyps;\
 790         yylval = newvalue;\
 791         goto yynewstate;\
 792 }
 793 #define YYRECOVERING()  (!!yyerrflag)
 794 #ifndef YYDEBUG
 795 #       define YYDEBUG  1       /* make debugging available */
 796 #endif
 797
 798 /*
 799 ** user known globals
 800 */
 801 int yydebug;                    /* set to 1 to get debugging */
 802
 803 /*
 804 ** driver internal defines
 805 */
 806 #define YYFLAG          (-1000)
 807
 808 /*
 809 ** static variables used by the parser
 810 */
 811 static YYSTYPE *yyv;                    /* value stack */
 812 static int *yys;                        /* state stack */
 813
 814 static YYSTYPE *yypv;                   /* top of value stack */
 815 static int *yyps;                       /* top of state stack */
 816
 817 static int yystate;                     /* current state */
 818 static int yytmp;                       /* extra var (lasts between blocks) */
 819
 820 int yynerrs;                    /* number of errors */
 821
 822 int yyerrflag;                  /* error recovery flag */
 823 int yychar;                     /* current input token number */
 824
 825
 826 /*
 827 ** yyparse - return 0 if worked, 1 if syntax error not recovered from
 828 */
 829 int
 830 yyparse()
 831 {
 832         register YYSTYPE *yypvt;        /* top of value stack for $vars */
 833         unsigned yymaxdepth = YYMAXDEPTH;
 834
 835         /*
 836         ** Initialize externals - yyparse may be called more than once
 837         */
 838         yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
 839         yys = (int*)malloc(yymaxdepth*sizeof(int));
 840         if (!yyv || !yys)
 841         {
 842                 yyerror( "out of memory" );
 843                 return(1);
 844         }
 845         yypv = &yyv[-1];
 846         yyps = &yys[-1];
 847         yystate = 0;
 848         yytmp = 0;
 849         yynerrs = 0;
 850         yyerrflag = 0;
 851         yychar = -1;
 852
 853         goto yystack;
 854         {
 855                 register YYSTYPE *yy_pv;        /* top of value stack */
 856                 register int *yy_ps;            /* top of state stack */
 857                 register int yy_state;          /* current state */
 858                 register int  yy_n;             /* internal state number info */
 859
 860                 /*
 861                 ** get globals into registers.
 862                 ** branch to here only if YYBACKUP was called.
 863                 */
 864         yynewstate:
 865                 yy_pv = yypv;
 866                 yy_ps = yyps;
 867                 yy_state = yystate;
 868                 goto yy_newstate;
 869
 870                 /*
 871                 ** get globals into registers.
 872                 ** either we just started, or we just finished a reduction
 873                 */
 874         yystack:
 875                 yy_pv = yypv;
 876                 yy_ps = yyps;
 877                 yy_state = yystate;
 878
 879                 /*
 880                 ** top of for (;;) loop while no reductions done
 881                 */
 882         yy_stack:
 883                 /*
 884                 ** put a state and value onto the stacks
 885                 */
 886 #if YYDEBUG
 887                 /*
 888                 ** if debugging, look up token value in list of value vs.
 889                 ** name pairs.  0 and negative (-1) are special values.
 890                 ** Note: linear search is used since time is not a real
 891                 ** consideration while debugging.
 892                 */
 893                 if ( yydebug )
 894                 {
 895                         register int yy_i;
 896
 897                         (void)printf( "State %d, token ", yy_state );
 898                         if ( yychar == 0 )
 899                                 (void)printf( "end-of-file\n" );
 900                         else if ( yychar < 0 )
 901                                 (void)printf( "-none-\n" );
 902                         else
 903                         {
 904                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
 905                                         yy_i++ )
 906                                 {
 907                                         if ( yytoks[yy_i].t_val == yychar )
 908                                                 break;
 909                                 }
 910                                 (void)printf( "%s\n", yytoks[yy_i].t_name );
 911                         }
 912                 }
 913 #endif /* YYDEBUG */
 914                 if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
 915                 {
 916                         /*
 917                         ** reallocate and recover.  Note that pointers
 918                         ** have to be reset, or bad things will happen
 919                         */
 920                         int yyps_index = (yy_ps - yys);
 921                         int yypv_index = (yy_pv - yyv);
 922                         int yypvt_index = (yypvt - yyv);
 923                         yymaxdepth += YYMAXDEPTH;
 924                         yyv = (YYSTYPE*)realloc((char*)yyv,
 925                                 yymaxdepth * sizeof(YYSTYPE));
 926                         yys = (int*)realloc((char*)yys,
 927                                 yymaxdepth * sizeof(int));
 928                         if (!yyv || !yys)
 929                         {
 930                                 yyerror( "yacc stack overflow" );
 931                                 return(1);
 932                         }
 933                         yy_ps = yys + yyps_index;
 934                         yy_pv = yyv + yypv_index;
 935                         yypvt = yyv + yypvt_index;
 936                 }
 937                 *yy_ps = yy_state;
 938                 *++yy_pv = yyval;
 939
 940                 /*
 941                 ** we have a new state - find out what to do
 942                 */
 943         yy_newstate:
 944                 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
 945                         goto yydefault;         /* simple state */
 946 #if YYDEBUG
 947                 /*
 948                 ** if debugging, need to mark whether new token grabbed
 949                 */
 950                 yytmp = yychar < 0;
 951 #endif
 952                 if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
 953                         yychar = 0;             /* reached EOF */
 954 #if YYDEBUG
 955                 if ( yydebug && yytmp )
 956                 {
 957                         register int yy_i;
 958
 959                         (void)printf( "Received token " );
 960                         if ( yychar == 0 )
 961                                 (void)printf( "end-of-file\n" );
 962                         else if ( yychar < 0 )
 963                                 (void)printf( "-none-\n" );
 964                         else
 965                         {
 966                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
 967                                         yy_i++ )
 968                                 {
 969                                         if ( yytoks[yy_i].t_val == yychar )
 970                                                 break;
 971                                 }
 972                                 (void)printf( "%s\n", yytoks[yy_i].t_name );
 973                         }
 974                 }
 975 #endif /* YYDEBUG */
 976                 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
 977                         goto yydefault;
 978                 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )  /*valid shift*/
 979                 {
 980                         yychar = -1;
 981                         yyval = yylval;
 982                         yy_state = yy_n;
 983                         if ( yyerrflag > 0 )
 984                                 yyerrflag--;
 985                         goto yy_stack;
 986                 }
 987
 988         yydefault:
 989                 if ( ( yy_n = yydef[ yy_state ] ) == -2 )
 990                 {
 991 #if YYDEBUG
 992                         yytmp = yychar < 0;
 993 #endif
 994                         if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
 995                                 yychar = 0;             /* reached EOF */
 996 #if YYDEBUG
 997                         if ( yydebug && yytmp )
 998                         {
 999                                 register int yy_i;
1000
1001                                 (void)printf( "Received token " );
1002                                 if ( yychar == 0 )
1003                                         (void)printf( "end-of-file\n" );
1004                                 else if ( yychar < 0 )
1005                                         (void)printf( "-none-\n" );
1006                                 else
1007                                 {
1008                                         for ( yy_i = 0;
1009                                                 yytoks[yy_i].t_val >= 0;
1010                                                 yy_i++ )
1011                                         {
1012                                                 if ( yytoks[yy_i].t_val
1013                                                         == yychar )
1014                                                 {
1015                                                         break;
1016                                                 }
1017                                         }
1018                                         (void)printf( "%s\n", yytoks[yy_i].t_name );
1019                                 }
1020                         }
1021 #endif /* YYDEBUG */
1022                         /*
1023                         ** look through exception table
1024                         */
1025                         {
1026                                 register int *yyxi = yyexca;
1027
1028                                 while ( ( *yyxi != -1 ) ||
1029                                         ( yyxi[1] != yy_state ) )
1030                                 {
1031                                         yyxi += 2;
1032                                 }
1033                                 while ( ( *(yyxi += 2) >= 0 ) &&
1034                                         ( *yyxi != yychar ) )
1035                                         ;
1036                                 if ( ( yy_n = yyxi[1] ) < 0 )
1037                                         YYACCEPT;
1038                         }
1039                 }
1040
1041                 /*
1042                 ** check for syntax error
1043                 */
1044                 if ( yy_n == 0 )        /* have an error */
1045                 {
1046                         /* no worry about speed here! */
1047                         switch ( yyerrflag )
1048                         {
1049                         case 0:         /* new error */
1050                                 yyerror( "syntax error" );
1051                                 goto skip_init;
1052                         yyerrlab:
1053                                 /*
1054                                 ** get globals into registers.
1055                                 ** we have a user generated syntax type error
1056                                 */
1057                                 yy_pv = yypv;
1058                                 yy_ps = yyps;
1059                                 yy_state = yystate;
1060                                 yynerrs++;
1061                         skip_init:
1062                         case 1:
1063                         case 2:         /* incompletely recovered error */
1064                                         /* try again... */
1065                                 yyerrflag = 3;
1066                                 /*
1067                                 ** find state where "error" is a legal
1068                                 ** shift action
1069                                 */
1070                                 while ( yy_ps >= yys )
1071                                 {
1072                                         yy_n = yypact[ *yy_ps ] + YYERRCODE;
1073                                         if ( yy_n >= 0 && yy_n < YYLAST &&
1074                                                 yychk[yyact[yy_n]] == YYERRCODE)                                        {
1075                                                 /*
1076                                                 ** simulate shift of "error"
1077                                                 */
1078                                                 yy_state = yyact[ yy_n ];
1079                                                 goto yy_stack;
1080                                         }
1081                                         /*
1082                                         ** current state has no shift on
1083                                         ** "error", pop stack
1084                                         */
1085 #if YYDEBUG
1086 #       define _POP_ "Error recovery pops state %d, uncovers state %d\n"
1087                                         if ( yydebug )
1088                                                 (void)printf( _POP_, *yy_ps,
1089                                                         yy_ps[-1] );
1090 #       undef _POP_
1091 #endif
1092                                         yy_ps--;
1093                                         yy_pv--;
1094                                 }
1095                                 /*
1096                                 ** there is no state on stack with "error" as
1097                                 ** a valid shift.  give up.
1098                                 */
1099                                 YYABORT;
1100                         case 3:         /* no shift yet; eat a token */
1101 #if YYDEBUG
1102                                 /*
1103                                 ** if debugging, look up token in list of
1104                                 ** pairs.  0 and negative shouldn't occur,
1105                                 ** but since timing doesn't matter when
1106                                 ** debugging, it doesn't hurt to leave the
1107                                 ** tests here.
1108                                 */
1109                                 if ( yydebug )
1110                                 {
1111                                         register int yy_i;
1112
1113                                         (void)printf( "Error recovery discards " );
1114                                         if ( yychar == 0 )
1115                                                 (void)printf( "token end-of-file\n" );
1116                                         else if ( yychar < 0 )
1117                                                 (void)printf( "token -none-\n" );
1118                                         else
1119                                         {
1120                                                 for ( yy_i = 0;
1121                                                         yytoks[yy_i].t_val >= 0;
1122                                                         yy_i++ )
1123                                                 {
1124                                                         if ( yytoks[yy_i].t_val
1125                                                                 == yychar )
1126                                                         {
1127                                                                 break;
1128                                                         }
1129                                                 }
1130                                                 (void)printf( "token %s\n",
1131                                                         yytoks[yy_i].t_name );
1132                                         }
1133                                 }
1134 #endif /* YYDEBUG */
1135                                 if ( yychar == 0 )      /* reached EOF. quit */
1136                                         YYABORT;
1137                                 yychar = -1;
1138                                 goto yy_newstate;
1139                         }
1140                 }/* end if ( yy_n == 0 ) */
1141                 /*
1142                 ** reduction by production yy_n
1143                 ** put stack tops, etc. so things right after switch
1144                 */
1145 #if YYDEBUG
1146                 /*
1147                 ** if debugging, print the string that is the user's
1148                 ** specification of the reduction which is just about
1149                 ** to be done.
1150                 */
1151                 if ( yydebug )
1152                         (void)printf( "Reduce by (%d) \"%s\"\n",
1153                                 yy_n, yyreds[ yy_n ] );
1154 #endif
1155                 yytmp = yy_n;                   /* value to switch over */
1156                 yypvt = yy_pv;                  /* $vars top of value stack */
1157                 /*
1158                 ** Look in goto table for next state
1159                 ** Sorry about using yy_state here as temporary
1160                 ** register variable, but why not, if it works...
1161                 ** If yyr2[ yy_n ] doesn't have the low order bit
1162                 ** set, then there is no action to be done for
1163                 ** this reduction.  So, no saving & unsaving of
1164                 ** registers done.  The only difference between the
1165                 ** code just after the if and the body of the if is
1166                 ** the goto yy_stack in the body.  This way the test
1167                 ** can be made before the choice of what to do is needed.
1168                 */
1169                 {
1170                         /* length of production doubled with extra bit */
1171                         register int yy_len = yyr2[ yy_n ];
1172
1173                         if ( !( yy_len & 01 ) )
1174                         {
1175                                 yy_len >>= 1;
1176                                 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
1177                                 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
1178                                         *( yy_ps -= yy_len ) + 1;
1179                                 if ( yy_state >= YYLAST ||
1180                                         yychk[ yy_state =
1181                                         yyact[ yy_state ] ] != -yy_n )
1182                                 {
1183                                         yy_state = yyact[ yypgo[ yy_n ] ];
1184                                 }
1185                                 goto yy_stack;
1186                         }
1187                         yy_len >>= 1;
1188                         yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
1189                         yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
1190                                 *( yy_ps -= yy_len ) + 1;
1191                         if ( yy_state >= YYLAST ||
1192                                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
1193                         {
1194                                 yy_state = yyact[ yypgo[ yy_n ] ];
1195                         }
1196                 }
1197                                         /* save until reenter driver code */
1198                 yystate = yy_state;
1199                 yyps = yy_ps;
1200                 yypv = yy_pv;
1201         }
1202         /*
1203         ** code supplied by user is placed in this switch
1204         */
1205         switch( yytmp )
1206         {
1207
1208 case 1:
1209 # line 60 "a2p.y"
1210 { root = oper4(OPROG,yypvt[-1],begins,yypvt[-0],ends); } break;
1211 case 2:
1212 # line 64 "a2p.y"
1213 { begins = oper4(OJUNK,begins,yypvt[-3],yypvt[-2],yypvt[-0]); in_begin = FALSE;
1214                     yyval = Nullop; } break;
1215 case 3:
1216 # line 69 "a2p.y"
1217 { ends = oper3(OJUNK,ends,yypvt[-2],yypvt[-1]); yyval = Nullop; } break;
1218 case 4:
1219 # line 71 "a2p.y"
1220 { yyval = yypvt[-1]; } break;
1221 case 5:
1222 # line 75 "a2p.y"
1223 { yyval = oper3(OHUNKS,yypvt[-2],yypvt[-1],yypvt[-0]); } break;
1224 case 6:
1225 # line 77 "a2p.y"
1226 { yyval = Nullop; } break;
1227 case 7:
1228 # line 81 "a2p.y"
1229 { yyval = oper1(OHUNK,yypvt[-0]); need_entire = TRUE; } break;
1230 case 8:
1231 # line 83 "a2p.y"
1232 { yyval = oper2(OHUNK,yypvt[-4],oper2(OJUNK,yypvt[-2],yypvt[-1])); } break;
1233 case 9:
1234 # line 85 "a2p.y"
1235 { fixfargs(yypvt[-8],yypvt[-6],0); yyval = oper5(OUSERDEF,yypvt[-8],yypvt[-6],yypvt[-4],yypvt[-2],yypvt[-1]); } break;
1236 case 10:
1237 # line 87 "a2p.y"
1238 { yyval = oper2(OHUNK,Nullop,oper2(OJUNK,yypvt[-2],yypvt[-1])); } break;
1239 case 13:
1240 # line 93 "a2p.y"
1241 { yyval = rememberargs(yyval); } break;
1242 case 14:
1243 # line 97 "a2p.y"
1244 { yyval = oper1(OPAT,yypvt[-0]); } break;
1245 case 15:
1246 # line 99 "a2p.y"
1247 { yyval = oper2(ORANGE,yypvt[-2],yypvt[-0]); } break;
1248 case 20:
1249 # line 110 "a2p.y"
1250 { yyval = oper1(OCPAREN,yypvt[-1]); } break;
1251 case 21:
1252 # line 112 "a2p.y"
1253 { yyval = oper3(OCANDAND,yypvt[-3],yypvt[-1],yypvt[-0]); } break;
1254 case 22:
1255 # line 114 "a2p.y"
1256 { yyval = oper3(OCOROR,yypvt[-3],yypvt[-1],yypvt[-0]); } break;
1257 case 23:
1258 # line 116 "a2p.y"
1259 { yyval = oper1(OCNOT,yypvt[-0]); } break;
1260 case 24:
1261 # line 120 "a2p.y"
1262 { yyval = oper3(ORELOP,yypvt[-1],yypvt[-2],yypvt[-0]); } break;
1263 case 25:
1264 # line 122 "a2p.y"
1265 { yyval = oper3(ORELOP,string(">",1),yypvt[-2],yypvt[-0]); } break;
1266 case 26:
1267 # line 124 "a2p.y"
1268 { yyval = oper3(ORELOP,string("<",1),yypvt[-2],yypvt[-0]); } break;
1269 case 27:
1270 # line 126 "a2p.y"
1271 { yyval = oper1(ORPAREN,yypvt[-1]); } break;
1272 case 28:
1273 # line 130 "a2p.y"
1274 { yyval = oper3(OMATCHOP,yypvt[-1],yypvt[-2],yypvt[-0]); } break;
1275 case 29:
1276 # line 132 "a2p.y"
1277 { yyval = oper3(OMATCHOP,yypvt[-1],yypvt[-2],oper1(OREGEX,yypvt[-0])); } break;
1278 case 30:
1279 # line 134 "a2p.y"
1280 { yyval = oper1(OREGEX,yypvt[-0]); } break;
1281 case 31:
1282 # line 136 "a2p.y"
1283 { yyval = oper1(OMPAREN,yypvt[-1]); } break;
1284 case 32:
1285 # line 140 "a2p.y"
1286 { yyval = yypvt[-0]; } break;
1287 case 33:
1288 # line 142 "a2p.y"
1289 { yyval = oper2(OCONCAT,yypvt[-1],yypvt[-0]); } break;
1290 case 34:
1291 # line 144 "a2p.y"
1292 { yyval = oper3(OASSIGN,yypvt[-1],yypvt[-2],yypvt[-0]);
1293                         if ((ops[yypvt[-2]].ival & 255) == OFLD)
1294                             lval_field = TRUE;
1295                         if ((ops[yypvt[-2]].ival & 255) == OVFLD)
1296                             lval_field = TRUE;
1297                 } break;
1298 case 35:
1299 # line 153 "a2p.y"
1300 { yyval = yypvt[-0]; } break;
1301 case 36:
1302 # line 155 "a2p.y"
1303 { yyval = oper1(ONUM,yypvt[-0]); } break;
1304 case 37:
1305 # line 157 "a2p.y"
1306 { yyval = oper1(OSTR,yypvt[-0]); } break;
1307 case 38:
1308 # line 159 "a2p.y"
1309 { yyval = oper2(OADD,yypvt[-2],yypvt[-0]); } break;
1310 case 39:
1311 # line 161 "a2p.y"
1312 { yyval = oper2(OSUBTRACT,yypvt[-2],yypvt[-0]); } break;
1313 case 40:
1314 # line 163 "a2p.y"
1315 { yyval = oper2(OMULT,yypvt[-2],yypvt[-0]); } break;
1316 case 41:
1317 # line 165 "a2p.y"
1318 { yyval = oper2(ODIV,yypvt[-2],yypvt[-0]); } break;
1319 case 42:
1320 # line 167 "a2p.y"
1321 { yyval = oper2(OMOD,yypvt[-2],yypvt[-0]); } break;
1322 case 43:
1323 # line 169 "a2p.y"
1324 { yyval = oper2(OPOW,yypvt[-2],yypvt[-0]); } break;
1325 case 44:
1326 # line 171 "a2p.y"
1327 { yyval = oper2(ODEFINED,aryrefarg(yypvt[-0]),yypvt[-2]); } break;
1328 case 45:
1329 # line 173 "a2p.y"
1330 { yyval = oper3(OCOND,yypvt[-4],yypvt[-2],yypvt[-0]); } break;
1331 case 46:
1332 # line 175 "a2p.y"
1333 { yyval = oper1(OPOSTINCR,yypvt[-1]); } break;
1334 case 47:
1335 # line 177 "a2p.y"
1336 { yyval = oper1(OPOSTDECR,yypvt[-1]); } break;
1337 case 48:
1338 # line 179 "a2p.y"
1339 { yyval = oper1(OPREINCR,yypvt[-0]); } break;
1340 case 49:
1341 # line 181 "a2p.y"
1342 { yyval = oper1(OPREDECR,yypvt[-0]); } break;
1343 case 50:
1344 # line 183 "a2p.y"
1345 { yyval = oper1(OUMINUS,yypvt[-0]); } break;
1346 case 51:
1347 # line 185 "a2p.y"
1348 { yyval = oper1(OUPLUS,yypvt[-0]); } break;
1349 case 52:
1350 # line 187 "a2p.y"
1351 { yyval = oper1(OPAREN,yypvt[-1]); } break;
1352 case 53:
1353 # line 189 "a2p.y"
1354 { yyval = oper0(OGETLINE); } break;
1355 case 54:
1356 # line 191 "a2p.y"
1357 { yyval = oper1(OGETLINE,yypvt[-0]); } break;
1358 case 55:
1359 # line 193 "a2p.y"
1360 { yyval = oper3(OGETLINE,Nullop,string("<",1),yypvt[-0]);
1361                     if (ops[yypvt[-0]].ival != OSTR + (1<<8)) do_fancy_opens = TRUE; } break;
1362 case 56:
1363 # line 196 "a2p.y"
1364 { yyval = oper3(OGETLINE,yypvt[-2],string("<",1),yypvt[-0]);
1365                     if (ops[yypvt[-0]].ival != OSTR + (1<<8)) do_fancy_opens = TRUE; } break;
1366 case 57:
1367 # line 199 "a2p.y"
1368 { yyval = oper3(OGETLINE,Nullop,string("|",1),yypvt[-2]);
1369                     if (ops[yypvt[-2]].ival != OSTR + (1<<8)) do_fancy_opens = TRUE; } break;
1370 case 58:
1371 # line 202 "a2p.y"
1372 { yyval = oper3(OGETLINE,yypvt[-0],string("|",1),yypvt[-3]);
1373                     if (ops[yypvt[-3]].ival != OSTR + (1<<8)) do_fancy_opens = TRUE; } break;
1374 case 59:
1375 # line 205 "a2p.y"
1376 { yyval = oper0(yypvt[-0]); need_entire = do_chop = TRUE; } break;
1377 case 60:
1378 # line 207 "a2p.y"
1379 { yyval = oper1(yypvt[-2],Nullop); need_entire = do_chop = TRUE; } break;
1380 case 61:
1381 # line 209 "a2p.y"
1382 { yyval = oper1(yypvt[-3],yypvt[-1]); } break;
1383 case 62:
1384 # line 211 "a2p.y"
1385 { yyval = oper1(yypvt[-3],yypvt[-1]); } break;
1386 case 63:
1387 # line 213 "a2p.y"
1388 { yyval = oper2(OUSERFUN,yypvt[-3],yypvt[-1]); } break;
1389 case 64:
1390 # line 215 "a2p.y"
1391 { yyval = oper1(OSPRINTF,yypvt[-0]); } break;
1392 case 65:
1393 # line 217 "a2p.y"
1394 { yyval = oper3(OSUBSTR,yypvt[-5],yypvt[-3],yypvt[-1]); } break;
1395 case 66:
1396 # line 219 "a2p.y"
1397 { yyval = oper2(OSUBSTR,yypvt[-3],yypvt[-1]); } break;
1398 case 67:
1399 # line 221 "a2p.y"
1400 { yyval = oper3(OSPLIT,yypvt[-5],aryrefarg(numary(yypvt[-3])),yypvt[-1]); } break;
1401 case 68:
1402 # line 223 "a2p.y"
1403 { yyval = oper3(OSPLIT,yypvt[-5],aryrefarg(numary(yypvt[-3])),oper1(OREGEX,yypvt[-1]));} break;
1404 case 69:
1405 # line 225 "a2p.y"
1406 { yyval = oper2(OSPLIT,yypvt[-3],aryrefarg(numary(yypvt[-1]))); } break;
1407 case 70:
1408 # line 227 "a2p.y"
1409 { yyval = oper2(OINDEX,yypvt[-3],yypvt[-1]); } break;
1410 case 71:
1411 # line 229 "a2p.y"
1412 { yyval = oper2(OMATCH,yypvt[-3],oper1(OREGEX,yypvt[-1])); } break;
1413 case 72:
1414 # line 231 "a2p.y"
1415 { yyval = oper2(OMATCH,yypvt[-3],yypvt[-1]); } break;
1416 case 73:
1417 # line 233 "a2p.y"
1418 { yyval = oper2(OSUB,yypvt[-3],yypvt[-1]); } break;
1419 case 74:
1420 # line 235 "a2p.y"
1421 { yyval = oper2(OSUB,oper1(OREGEX,yypvt[-3]),yypvt[-1]); } break;
1422 case 75:
1423 # line 237 "a2p.y"
1424 { yyval = oper2(OGSUB,yypvt[-3],yypvt[-1]); } break;
1425 case 76:
1426 # line 239 "a2p.y"
1427 { yyval = oper2(OGSUB,oper1(OREGEX,yypvt[-3]),yypvt[-1]); } break;
1428 case 77:
1429 # line 241 "a2p.y"
1430 { yyval = oper3(OSUB,yypvt[-5],yypvt[-3],yypvt[-1]); } break;
1431 case 78:
1432 # line 243 "a2p.y"
1433 { yyval = oper3(OSUB,oper1(OREGEX,yypvt[-5]),yypvt[-3],yypvt[-1]); } break;
1434 case 79:
1435 # line 245 "a2p.y"
1436 { yyval = oper3(OGSUB,yypvt[-5],yypvt[-3],yypvt[-1]); } break;
1437 case 80:
1438 # line 247 "a2p.y"
1439 { yyval = oper3(OGSUB,oper1(OREGEX,yypvt[-5]),yypvt[-3],yypvt[-1]); } break;
1440 case 81:
1441 # line 251 "a2p.y"
1442 { yyval = oper1(OVAR,yypvt[-0]); } break;
1443 case 82:
1444 # line 253 "a2p.y"
1445 { yyval = oper2(OVAR,aryrefarg(yypvt[-3]),yypvt[-1]); } break;
1446 case 83:
1447 # line 255 "a2p.y"
1448 { yyval = oper1(OFLD,yypvt[-0]); } break;
1449 case 84:
1450 # line 257 "a2p.y"
1451 { yyval = oper1(OVFLD,yypvt[-0]); } break;
1452 case 87:
1453 # line 264 "a2p.y"
1454 { yyval = Nullop; } break;
1455 case 88:
1456 # line 268 "a2p.y"
1457 { yyval = oper3(OCOMMA,yypvt[-3],yypvt[-1],yypvt[-0]); } break;
1458 case 89:
1459 # line 270 "a2p.y"
1460 { yyval = oper3(OCOMMA,yypvt[-3],yypvt[-1],yypvt[-0]); } break;
1461 case 90:
1462 # line 272 "a2p.y"
1463 { yyval = yypvt[-1]; } break;
1464 case 91:
1465 # line 276 "a2p.y"
1466 { yyval = oper2(OJUNK,yypvt[-1],yypvt[-0]); } break;
1467 case 92:
1468 # line 278 "a2p.y"
1469 { yyval = Nullop; } break;
1470 case 93:
1471 # line 282 "a2p.y"
1472 { yyval = oper2(OJUNK,oper0(OSEMICOLON),oper0(ONEWLINE)); } break;
1473 case 94:
1474 # line 284 "a2p.y"
1475 { yyval = oper2(OJUNK,oper0(OSEMICOLON),oper0(ONEWLINE)); } break;
1476 case 95:
1477 # line 286 "a2p.y"
1478 { yyval = oper0(ONEWLINE); } break;
1479 case 96:
1480 # line 288 "a2p.y"
1481 { yyval = oper1(OCOMMENT,yypvt[-0]); } break;
1482 case 97:
1483 # line 292 "a2p.y"
1484 { yyval = oper2(OJUNK,yypvt[-1],yypvt[-0]); } break;
1485 case 98:
1486 # line 294 "a2p.y"
1487 { yyval = Nullop; } break;
1488 case 99:
1489 # line 298 "a2p.y"
1490 { yyval = oper0(ONEWLINE); } break;
1491 case 100:
1492 # line 300 "a2p.y"
1493 { yyval = oper1(OCOMMENT,yypvt[-0]); } break;
1494 case 101:
1495 # line 305 "a2p.y"
1496 { yyval = oper2(OJUNK,oper0(OSEMICOLON),yypvt[-0]); } break;
1497 case 102:
1498 # line 307 "a2p.y"
1499 { yyval = oper2(OJUNK,oper0(OSNEWLINE),yypvt[-0]); } break;
1500 case 103:
1501 # line 309 "a2p.y"
1502 { yyval = oper2(OJUNK,oper0(OSNEWLINE),yypvt[-0]); } break;
1503 case 104:
1504 # line 311 "a2p.y"
1505 { yyval = oper2(OJUNK,oper1(OSCOMMENT,yypvt[-1]),yypvt[-0]); } break;
1506 case 105:
1507 # line 315 "a2p.y"
1508 { yyval = oper2(OSTATES,yypvt[-1],yypvt[-0]); } break;
1509 case 106:
1510 # line 317 "a2p.y"
1511 { yyval = Nullop; } break;
1512 case 107:
1513 # line 322 "a2p.y"
1514 { yyval = oper2(OJUNK,oper2(OSTATE,yypvt[-2],yypvt[-1]),yypvt[-0]); } break;
1515 case 108:
1516 # line 324 "a2p.y"
1517 { yyval = oper2(OSTATE,Nullop,oper2(OJUNK,oper0(OSEMICOLON),yypvt[-0])); } break;
1518 case 109:
1519 # line 326 "a2p.y"
1520 { yyval = oper2(OSTATE,Nullop,oper2(OJUNK,oper0(OSNEWLINE),yypvt[-0])); } break;
1521 case 112:
1522 # line 332 "a2p.y"
1523 { yyval = Nullop; } break;
1524 case 114:
1525 # line 338 "a2p.y"
1526 { yyval = oper3(OPRINT,yypvt[-2],yypvt[-1],yypvt[-0]);
1527                     do_opens = TRUE;
1528                     saw_ORS = saw_OFS = TRUE;
1529                     if (!yypvt[-2]) need_entire = TRUE;
1530                     if (ops[yypvt[-0]].ival != OSTR + (1<<8)) do_fancy_opens = TRUE; } break;
1531 case 115:
1532 # line 344 "a2p.y"
1533 { yyval = oper1(OPRINT,yypvt[-0]);
1534                     if (!yypvt[-0]) need_entire = TRUE;
1535                     saw_ORS = saw_OFS = TRUE;
1536                 } break;
1537 case 116:
1538 # line 349 "a2p.y"
1539 { yyval = oper3(OPRINTF,yypvt[-2],yypvt[-1],yypvt[-0]);
1540                     do_opens = TRUE;
1541                     if (!yypvt[-2]) need_entire = TRUE;
1542                     if (ops[yypvt[-0]].ival != OSTR + (1<<8)) do_fancy_opens = TRUE; } break;
1543 case 117:
1544 # line 354 "a2p.y"
1545 { yyval = oper1(OPRINTF,yypvt[-0]);
1546                     if (!yypvt[-0]) need_entire = TRUE;
1547                 } break;
1548 case 118:
1549 # line 358 "a2p.y"
1550 { yyval = oper0(OBREAK); } break;
1551 case 119:
1552 # line 360 "a2p.y"
1553 { yyval = oper0(ONEXT); } break;
1554 case 120:
1555 # line 362 "a2p.y"
1556 { yyval = oper0(OEXIT); } break;
1557 case 121:
1558 # line 364 "a2p.y"
1559 { yyval = oper1(OEXIT,yypvt[-0]); } break;
1560 case 122:
1561 # line 366 "a2p.y"
1562 { yyval = oper0(OCONTINUE); } break;
1563 case 123:
1564 # line 368 "a2p.y"
1565 { yyval = oper0(ORETURN); } break;
1566 case 124:
1567 # line 370 "a2p.y"
1568 { yyval = oper1(ORETURN,yypvt[-0]); } break;
1569 case 125:
1570 # line 372 "a2p.y"
1571 { yyval = oper2(ODELETE,aryrefarg(yypvt[-3]),yypvt[-1]); } break;
1572 case 126:
1573 # line 376 "a2p.y"
1574 { yyval = oper1(OREDIR,string(">",1)); } break;
1575 case 127:
1576 # line 378 "a2p.y"
1577 { yyval = oper1(OREDIR,string(">>",2)); } break;
1578 case 128:
1579 # line 380 "a2p.y"
1580 { yyval = oper1(OREDIR,string("|",1)); } break;
1581 case 129:
1582 # line 385 "a2p.y"
1583 { yyval = oper2(OIF,yypvt[-3],bl(yypvt[-0],yypvt[-1])); } break;
1584 case 130:
1585 # line 387 "a2p.y"
1586 { yyval = oper3(OIF,yypvt[-6],bl(yypvt[-3],yypvt[-4]),bl(yypvt[-0],yypvt[-1])); } break;
1587 case 131:
1588 # line 389 "a2p.y"
1589 { yyval = oper2(OWHILE,yypvt[-3],bl(yypvt[-0],yypvt[-1])); } break;
1590 case 132:
1591 # line 391 "a2p.y"
1592 { yyval = oper2(ODO,bl(yypvt[-4],yypvt[-5]),yypvt[-1]); } break;
1593 case 133:
1594 # line 393 "a2p.y"
1595 { yyval = oper4(OFOR,yypvt[-7],yypvt[-5],yypvt[-3],bl(yypvt[-0],yypvt[-1])); } break;
1596 case 134:
1597 # line 395 "a2p.y"
1598 { yyval = oper4(OFOR,yypvt[-6],string("",0),yypvt[-3],bl(yypvt[-0],yypvt[-1])); } break;
1599 case 135:
1600 # line 397 "a2p.y"
1601 { yyval = oper2(OFORIN,yypvt[-3],bl(yypvt[-0],yypvt[-1])); } break;
1602 case 136:
1603 # line 399 "a2p.y"
1604 { yyval = oper3(OBLOCK,oper2(OJUNK,yypvt[-3],yypvt[-2]),Nullop,yypvt[-0]); } break;
1605         }
1606         goto yystack;           /* reset registers in driver code */
1607 }