perly.c.yacc

   1 extern char *malloc(), *realloc();
   2
   3 # line 39 "perly.y"
   4 #include "EXTERN.h"
   5 #include "perl.h"
   6
   7 /*SUPPRESS 530*/
   8 /*SUPPRESS 593*/
   9 /*SUPPRESS 595*/
  10
  11
  12 # line 50 "perly.y"
  13 typedef union  {
  14     I32 ival;
  15     char *pval;
  16     OP *opval;
  17     GV *gvval;
  18 } YYSTYPE;
  19 # define WORD 257
  20 # define METHOD 258
  21 # define THING 259
  22 # define PMFUNC 260
  23 # define PRIVATEREF 261
  24 # define LABEL 262
  25 # define FORMAT 263
  26 # define SUB 264
  27 # define PACKAGE 265
  28 # define WHILE 266
  29 # define UNTIL 267
  30 # define IF 268
  31 # define UNLESS 269
  32 # define ELSE 270
  33 # define ELSIF 271
  34 # define CONTINUE 272
  35 # define FOR 273
  36 # define LOOPEX 274
  37 # define DOTDOT 275
  38 # define FUNC0 276
  39 # define FUNC1 277
  40 # define FUNC 278
  41 # define RELOP 279
  42 # define EQOP 280
  43 # define MULOP 281
  44 # define ADDOP 282
  45 # define DOLSHARP 283
  46 # define DO 284
  47 # define LOCAL 285
  48 # define DELETE 286
  49 # define HASHBRACK 287
  50 # define LSTOP 288
  51 # define OROR 289
  52 # define ANDAND 290
  53 # define BITOROP 291
  54 # define BITANDOP 292
  55 # define UNIOP 293
  56 # define SHIFTOP 294
  57 # define MATCHOP 295
  58 # define ARROW 296
  59 # define UMINUS 297
  60 # define REFGEN 298
  61 # define POWOP 299
  62 # define PREINC 300
  63 # define PREDEC 301
  64 # define POSTINC 302
  65 # define POSTDEC 303
  66 #define yyclearin yychar = -1
  67 #define yyerrok yyerrflag = 0
  68 extern int yychar;
  69 extern int yyerrflag;
  70 #ifndef YYMAXDEPTH
  71 #define YYMAXDEPTH 150
  72 #endif
  73 YYSTYPE yylval, yyval;
  74 # define YYERRCODE 256
  75
  76 # line 573 "perly.y"
  77  /* PROGRAM */
  78 int yyexca[] ={
  79 -1, 1,
  80         0, -1,
  81         -2, 0,
  82 -1, 3,
  83         0, 2,
  84         -2, 39,
  85 -1, 21,
  86         296, 146,
  87         -2, 25,
  88 -1, 40,
  89         41, 98,
  90         266, 98,
  91         267, 98,
  92         268, 98,
  93         269, 98,
  94         275, 98,
  95         279, 98,
  96         280, 98,
  97         281, 98,
  98         282, 98,
  99         44, 98,
 100         61, 98,
 101         63, 98,
 102         58, 98,
 103         289, 98,
 104         290, 98,
 105         291, 98,
 106         292, 98,
 107         294, 98,
 108         295, 98,
 109         296, 98,
 110         299, 98,
 111         302, 98,
 112         303, 98,
 113         59, 98,
 114         93, 98,
 115         -2, 145,
 116 -1, 54,
 117         41, 134,
 118         266, 134,
 119         267, 134,
 120         268, 134,
 121         269, 134,
 122         275, 134,
 123         279, 134,
 124         280, 134,
 125         281, 134,
 126         282, 134,
 127         44, 134,
 128         61, 134,
 129         63, 134,
 130         58, 134,
 131         289, 134,
 132         290, 134,
 133         291, 134,
 134         292, 134,
 135         294, 134,
 136         295, 134,
 137         296, 134,
 138         299, 134,
 139         302, 134,
 140         303, 134,
 141         59, 134,
 142         93, 134,
 143         -2, 144,
 144 -1, 78,
 145         59, 35,
 146         -2, 0,
 147 -1, 114,
 148         302, 0,
 149         303, 0,
 150         -2, 89,
 151 -1, 115,
 152         302, 0,
 153         303, 0,
 154         -2, 90,
 155 -1, 194,
 156         279, 0,
 157         -2, 72,
 158 -1, 195,
 159         280, 0,
 160         -2, 73,
 161 -1, 196,
 162         275, 0,
 163         -2, 76,
 164 -1, 312,
 165         41, 35,
 166         -2, 0,
 167         };
 168 # define YYNPROD 154
 169 # define YYLAST 2319
 170 int yyact[]={
 171
 172    109,   106,   107,   164,    92,   104,   231,   105,   150,    92,
 173     21,   241,    68,   106,   107,   152,   230,    80,    25,    74,
 174     76,   242,   243,    82,    84,    56,    26,    93,    94,   326,
 175     31,   319,   134,    56,    58,    61,    69,    37,   157,    57,
 176     30,   104,    29,   317,   300,    92,   117,   119,   121,   131,
 177    246,   135,   299,    93,    94,    93,    16,   298,    79,   125,
 178    264,    59,    14,    11,    12,    13,    95,   104,   154,   104,
 179    155,    92,   212,    92,    71,   159,   123,   161,    83,    81,
 180     75,   166,   158,   168,   160,   170,    26,   163,    38,   270,
 181    167,   126,   169,   200,   171,   172,   173,   174,   217,   260,
 182     73,   205,   222,   312,   239,   156,    31,    89,   124,    56,
 183     58,    61,    26,    37,    89,    57,    30,     3,    29,    89,
 184     26,    89,    89,    32,    72,   201,    89,   329,   100,   101,
 185     93,    94,   213,   214,   215,   216,   327,    59,   220,   100,
 186    101,    93,    94,    95,   104,   322,    89,   225,    92,    99,
 187     98,    97,    96,   123,    95,   104,   318,   316,   306,    92,
 188     67,    26,    26,    26,    38,    89,   280,   233,   297,    31,
 189    294,   237,    56,    58,    61,   267,    37,   290,    57,    30,
 190    320,    29,   245,    26,   223,   124,    89,    14,    11,    12,
 191     13,   100,   101,    93,    94,   265,    26,   282,   256,    32,
 192     59,   301,    98,    97,    96,   221,    95,   104,   176,   257,
 193    258,    92,   206,   100,   261,    93,    94,    89,   234,   162,
 194    236,   151,   100,   101,    93,    94,   269,    38,    95,   104,
 195    273,   275,   295,    92,   283,    96,   284,    95,   104,   286,
 196    139,   288,    92,   289,   204,   291,   141,   202,   158,   138,
 197     66,   137,    89,    24,    54,    65,    46,    53,    66,    26,
 198    199,   208,    32,    18,    19,    22,    23,   268,   129,   296,
 199     20,    49,    70,    51,    52,    63,   149,    89,   287,   302,
 200     60,    48,    36,    45,    39,    62,   310,   209,   325,    56,
 201     50,    89,   266,   203,     8,    33,     7,    34,    35,   314,
 202    313,   204,   211,   315,   202,   276,   244,    56,    89,    89,
 203     31,   128,     2,    56,    58,    61,   324,    37,   274,    57,
 204     30,    25,    29,     9,   240,   165,   328,    89,   330,    24,
 205     54,    65,    46,    53,    66,    17,    87,    88,    85,    86,
 206    331,    59,   308,   309,    56,   311,    55,    49,    78,    51,
 207     52,    63,   235,    47,    41,    89,    60,    48,    36,    45,
 208     39,    62,    44,    42,    43,    15,    50,    10,    38,   323,
 209      5,    33,   210,    34,    35,    31,   207,    90,    56,    58,
 210     61,     6,    37,   272,    57,    30,     4,    29,     1,   100,
 211    101,    93,    94,    54,    65,    46,    53,    66,     0,     0,
 212     26,    97,    96,    32,    95,   104,    59,     0,     0,    92,
 213     49,     0,    51,    52,    63,     0,     0,     0,    28,    60,
 214     48,    36,    45,    39,    62,   227,     0,     0,   229,    50,
 215    232,     0,   152,    38,    33,    31,    34,    35,    56,    58,
 216     61,     0,    37,     0,    57,    30,     0,    29,   108,   110,
 217    111,   112,   113,   114,   115,     0,     0,   238,    64,     0,
 218      0,   263,     0,     0,     0,    26,    59,     0,    32,    87,
 219     88,    85,    86,     0,     0,     0,     0,     0,     0,     0,
 220      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 221      0,     0,    31,    38,     0,    56,    58,    61,     0,    37,
 222      0,    57,    30,     0,    29,   279,     0,   281,     0,     0,
 223      0,     0,     0,     0,   271,   140,   143,   144,   145,   146,
 224    147,   148,     0,    59,   153,    26,     0,     0,    32,     0,
 225      0,   285,     0,   293,    54,    65,    46,    53,    66,     0,
 226      0,     0,     0,     0,     0,     0,   277,     0,     0,   278,
 227     38,    49,   262,    51,    52,    63,     0,     0,     0,   307,
 228     60,    48,    36,    45,    39,    62,    91,   303,   103,   304,
 229     50,     0,     0,     0,     0,    33,     0,    34,    35,     0,
 230      0,     0,    26,     0,     0,    32,     0,     0,     0,     0,
 231      0,     0,     0,     0,     0,     0,     0,     0,     0,    54,
 232     65,    46,    53,    66,     0,     0,     0,     0,     0,     0,
 233    228,     0,     0,     0,     0,     0,    49,     0,    51,    52,
 234     63,     0,     0,     0,     0,    60,    48,    36,    45,    39,
 235     62,     0,     0,     0,     0,    50,     0,     0,     0,     0,
 236     33,    31,    34,    35,    56,    58,    61,    40,    37,   259,
 237     57,    30,     0,    29,     0,     0,     0,     0,     0,    54,
 238     65,    46,    53,    66,     0,     0,     0,     0,    77,     0,
 239      0,     0,    59,     0,     0,     0,    49,     0,    51,    52,
 240     63,     0,     0,     0,     0,    60,    48,    36,    45,    39,
 241     62,     0,     0,   127,     0,    50,   133,     0,     0,    38,
 242     33,     0,    34,    35,   142,   142,   142,   142,   142,   142,
 243      0,     0,     0,   142,     0,     0,    54,    65,    46,    53,
 244     66,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 245      0,    26,     0,    49,    32,    51,    52,    63,     0,   103,
 246      0,     0,    60,    48,    36,    45,    39,    62,     0,     0,
 247      0,     0,    50,     0,     0,     0,     0,    33,    31,    34,
 248     35,    56,    58,    61,     0,    37,   224,    57,    30,     0,
 249     29,     0,     0,     0,     0,     0,   218,     0,     0,     0,
 250    102,     0,     0,     0,   100,   101,    93,    94,     0,    59,
 251      0,     0,     0,     0,    99,    98,    97,    96,     0,    95,
 252    104,     0,     0,     0,    92,     0,     0,     0,     0,     0,
 253      0,     0,     0,     0,    31,     0,    38,    56,    58,    61,
 254      0,    37,   219,    57,    30,     0,    29,     0,     0,     0,
 255      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 256      0,     0,     0,     0,     0,    59,     0,     0,    26,     0,
 257      0,    32,     0,     0,     0,     0,     0,     0,     0,     0,
 258      0,     0,     0,     0,     0,    54,    65,    46,    53,    66,
 259      0,    31,    38,     0,    56,    58,    61,     0,    37,     0,
 260     57,    30,    49,    29,    51,    52,    63,     0,     0,     0,
 261      0,    60,    48,    36,    45,    39,    62,     0,     0,   192,
 262      0,    50,    59,     0,    26,     0,    33,    32,    34,    35,
 263      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 264      0,     0,     0,     0,     0,     0,     0,     0,     0,    38,
 265      0,    31,     0,     0,    56,    58,    61,     0,    37,     0,
 266     57,    30,     0,    29,     0,     0,     0,     0,     0,     0,
 267      0,   102,     0,     0,   321,   100,   101,    93,    94,   190,
 268      0,    26,    59,     0,    32,    99,    98,    97,    96,     0,
 269     95,   104,     0,     0,    91,    92,   103,     0,     0,     0,
 270      0,     0,    54,    65,    46,    53,    66,     0,     0,    38,
 271      0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
 272      0,    51,    52,    63,     0,     0,     0,     0,    60,    48,
 273     36,    45,    39,    62,     0,     0,     0,   255,    50,     0,
 274     91,    26,   103,    33,    32,    34,    35,     0,     0,     0,
 275      0,     0,     0,     0,     0,     0,     0,     0,    54,    65,
 276     46,    53,    66,     0,    31,     0,     0,    56,    58,    61,
 277      0,    37,     0,    57,    30,    49,    29,    51,    52,    63,
 278      0,     0,     0,     0,    60,    48,    36,    45,    39,    62,
 279      0,     0,   188,     0,    50,    59,     0,     0,     0,    33,
 280      0,    34,    35,     0,     0,     0,     0,     0,     0,     0,
 281      0,     0,     0,     0,     0,    54,    65,    46,    53,    66,
 282      0,     0,    38,     0,     0,     0,     0,     0,     0,     0,
 283      0,     0,    49,     0,    51,    52,    63,    91,     0,   103,
 284      0,    60,    48,    36,    45,    39,    62,     0,     0,     0,
 285      0,    50,     0,     0,    26,     0,    33,    32,    34,    35,
 286      0,     0,    31,     0,     0,    56,    58,    61,     0,    37,
 287      0,    57,    30,     0,    29,    54,    65,    46,    53,    66,
 288      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 289    186,     0,    49,    59,    51,    52,    63,     0,     0,     0,
 290      0,    60,    48,    36,    45,    39,    62,     0,   102,     0,
 291      0,    50,   100,   101,    93,    94,    33,     0,    34,    35,
 292     38,     0,    99,    98,    97,    96,     0,    95,   104,     0,
 293      0,     0,    92,     0,     0,    31,     0,     0,    56,    58,
 294     61,     0,    37,     0,    57,    30,     0,    29,     0,     0,
 295      0,     0,    26,     0,   102,    32,     0,     0,   100,   101,
 296     93,    94,     0,   184,     0,     0,    59,     0,    99,    98,
 297     97,    96,     0,    95,   104,     0,     0,     0,    92,     0,
 298      0,     0,     0,     0,     0,     0,     0,     0,    54,    65,
 299     46,    53,    66,    38,     0,     0,     0,     0,     0,     0,
 300      0,     0,     0,     0,     0,    49,     0,    51,    52,    63,
 301      0,     0,     0,     0,    60,    48,    36,    45,    39,    62,
 302      0,     0,     0,     0,    50,    26,     0,     0,    32,    33,
 303      0,    34,    35,    31,     0,     0,    56,    58,    61,     0,
 304     37,     0,    57,    30,     0,    29,     0,     0,     0,     0,
 305      0,   102,     0,     0,     0,   100,   101,    93,    94,     0,
 306      0,   182,     0,     0,    59,    99,    98,    97,    96,     0,
 307     95,   104,     0,     0,     0,    92,     0,     0,     0,     0,
 308      0,     0,     0,     0,     0,     0,    54,    65,    46,    53,
 309     66,    38,     0,     0,     0,     0,     0,     0,     0,     0,
 310      0,     0,     0,    49,     0,    51,    52,    63,     0,     0,
 311      0,     0,    60,    48,    36,    45,    39,    62,     0,     0,
 312      0,     0,    50,    26,     0,     0,    32,    33,     0,    34,
 313     35,     0,     0,     0,     0,     0,    31,     0,     0,    56,
 314     58,    61,     0,    37,     0,    57,    30,     0,    29,     0,
 315      0,     0,     0,     0,     0,     0,     0,     0,     0,    54,
 316     65,    46,    53,    66,   180,     0,     0,    59,     0,     0,
 317      0,     0,     0,     0,     0,     0,    49,     0,    51,    52,
 318     63,     0,     0,     0,     0,    60,    48,    36,    45,    39,
 319     62,     0,     0,     0,    38,    50,     0,     0,     0,     0,
 320     33,     0,    34,    35,    31,     0,     0,    56,    58,    61,
 321      0,    37,     0,    57,    30,     0,    29,     0,     0,     0,
 322      0,     0,     0,     0,     0,     0,    26,     0,     0,    32,
 323      0,     0,   178,     0,     0,    59,     0,     0,     0,     0,
 324      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 325      0,     0,     0,     0,     0,     0,     0,    54,    65,    46,
 326     53,    66,    38,     0,     0,     0,     0,     0,     0,     0,
 327      0,     0,     0,     0,    49,     0,    51,    52,    63,     0,
 328      0,     0,     0,    60,    48,    36,    45,    39,    62,     0,
 329      0,     0,     0,    50,    26,     0,     0,    32,    33,     0,
 330     34,    35,     0,     0,     0,     0,     0,    31,     0,     0,
 331     56,    58,    61,     0,    37,     0,    57,    30,     0,    29,
 332      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 333      0,     0,     0,   122,     0,     0,     0,     0,    59,     0,
 334      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 335      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 336     54,    65,    46,    53,    66,    38,     0,     0,     0,     0,
 337      0,     0,     0,     0,     0,     0,     0,    49,     0,    51,
 338     52,    63,     0,     0,     0,     0,    60,    48,    36,    45,
 339     39,    62,     0,     0,     0,     0,    50,    26,     0,     0,
 340     32,    33,    31,    34,    35,    56,    58,    61,     0,    37,
 341      0,    57,    30,     0,    29,     0,     0,     0,     0,     0,
 342      0,     0,     0,     0,     0,     0,     0,     0,    54,    65,
 343     46,    53,    66,    59,     0,     0,     0,     0,     0,     0,
 344      0,     0,     0,     0,     0,    49,     0,    51,    52,    63,
 345      0,     0,     0,     0,    60,    48,    36,    45,    39,    62,
 346     38,     0,   120,     0,    50,     0,     0,     0,     0,    33,
 347      0,    34,    35,     0,     0,     0,     0,     0,    31,     0,
 348      0,    56,    58,    61,     0,    37,   118,    57,    30,     0,
 349     29,     0,    26,     0,     0,    32,     0,     0,     0,     0,
 350      0,     0,     0,     0,     0,     0,     0,     0,     0,    59,
 351      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 352      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 353      0,    54,    65,    46,    53,    66,    38,     0,     0,     0,
 354      0,     0,     0,     0,     0,     0,     0,     0,    49,     0,
 355     51,    52,    63,     0,     0,     0,     0,    60,    48,    36,
 356     45,    39,    62,     0,     0,     0,     0,    50,    26,     0,
 357      0,    32,    33,    31,    34,    35,    56,    58,    61,     0,
 358     37,     0,    57,    30,     0,    29,     0,     0,     0,     0,
 359      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 360      0,     0,     0,     0,    59,     0,     0,     0,     0,     0,
 361      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 362      0,     0,     0,     0,     0,     0,    54,    65,    46,    53,
 363     66,    38,     0,     0,     0,     0,     0,     0,     0,     0,
 364      0,     0,     0,    49,     0,    51,    52,    63,     0,     0,
 365      0,     0,    60,    48,    36,    45,    39,    62,     0,     0,
 366      0,     0,    50,    26,     0,     0,    32,    33,    31,    34,
 367     35,    56,    58,    61,     0,    37,     0,    57,    30,     0,
 368     29,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 369      0,     0,     0,     0,     0,     0,     0,     0,     0,    59,
 370      0,     0,    54,    65,    46,    53,    66,     0,     0,     0,
 371      0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
 372      0,    51,    52,    63,     0,     0,    38,     0,    60,    48,
 373     36,    45,    39,    62,     0,     0,     0,     0,    50,     0,
 374      0,     0,     0,    33,     0,    34,    35,     0,     0,     0,
 375      0,     0,     0,     0,     0,     0,     0,     0,    26,    27,
 376      0,    32,     0,     0,     0,     0,     0,     0,     0,     0,
 377      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 378      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 379      0,     0,     0,     0,     0,     0,   116,    54,    65,    46,
 380     53,    66,     0,     0,     0,     0,     0,     0,   130,     0,
 381    136,     0,     0,     0,    49,     0,    51,    52,    63,     0,
 382      0,     0,     0,    60,    48,    36,    45,    39,    62,     0,
 383      0,     0,     0,    50,     0,     0,     0,     0,    33,     0,
 384     34,    35,     0,     0,     0,     0,     0,     0,     0,   175,
 385      0,   177,   179,   181,   183,   185,   187,   189,   191,   193,
 386    194,   195,   196,   197,   198,     0,     0,     0,     0,     0,
 387      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 388      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 389      0,     0,   132,    65,    46,    53,    66,     0,     0,   226,
 390      0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
 391      0,    51,    52,    63,     0,     0,     0,     0,    60,    48,
 392     36,    45,    39,    62,     0,     0,     0,     0,    50,     0,
 393      0,     0,     0,    33,     0,    34,    35,     0,   247,     0,
 394    248,     0,   249,     0,   250,     0,   251,     0,   252,     0,
 395    253,     0,   254,     0,     0,     0,     0,     0,     0,     0,
 396      0,     0,   175,     0,     0,     0,   175,     0,     0,   175,
 397      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 398      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 399      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 400      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 401      0,     0,     0,     0,     0,   292,     0,     0,     0,     0,
 402      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 403      0,     0,     0,     0,     0,     0,     0,     0,   305 };
 404 int yypact[]={
 405
 406  -1000, -1000, -1000,  -200, -1000, -1000, -1000, -1000, -1000,    -3,
 407  -1000,   -97,  -221,    15, -1000, -1000, -1000,    65,    60,    40,
 408    308,  -255,    39,    38, -1000,    70, -1000,  1056,  -289,  1820,
 409   1820,  1820,  1820,  1820,  1820,  1820,  1820,  1725,  1649,  1554,
 410    -15, -1000, -1000,   -32, -1000,   271, -1000,   228,  1915,  -225,
 411   1820,   211,   209,   200, -1000, -1000,   -11,   -11,   -11,   -11,
 412    -11,   -11,  1820,   181,  -281,   -11, -1000,   -37, -1000,   -37,
 413     46, -1000, -1000,  1820,   -37,  1820,   -37,   179,    73, -1000,
 414    -37,  1820,   -37,  1820,   -37,  1820,  1820,  1820,  1820,  1820,
 415  -1000,  1820,  1451,  1383,  1280,  1182,  1109,  1011,   898,   838,
 416   1820,  1820,  1820,  1820,  1820,     2, -1000, -1000,  -301, -1000,
 417   -301,  -301,  -301,  -301, -1000, -1000,  -228,   260,    10,   168,
 418  -1000,   243,   -53,  1820,  1820,  1820,  1820,   -25,   253,   781,
 419   -228, -1000,   165,    62, -1000, -1000,  -228,   143,   725,  1820,
 420  -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,   136, -1000,
 421     78,  1820,  -272,  1820, -1000, -1000, -1000,   126,    78,  -255,
 422    311,  -255,  1820,   203,    45, -1000, -1000,   283,  -249,   265,
 423   -249,    78,    78,    78,    78,  1056,   -75,  1056,  1820,  -295,
 424   1820,  -290,  1820,  -226,  1820,  -254,  1820,  -151,  1820,   -57,
 425   1820,   110,  1820,   -88,  -228,   -66,  -140,   959,  -295,   158,
 426   1820,  1820,   608,     8, -1000,  1820,   459, -1000, -1000,   402,
 427  -1000,   -65, -1000,   102,   233,    82,   208,  1820,   -34, -1000,
 428    260,   342,   277, -1000, -1000,   264,   505, -1000,   136,   125,
 429   1820,   157, -1000,   -37, -1000,   -37, -1000,   260,   -37,  1820,
 430    -37, -1000,   -37,   137,   -37, -1000, -1000,  1056,  1056,  1056,
 431   1056,  1056,  1056,  1056,  1056,  1820,  1820,    77,   173, -1000,
 432   1820,    75, -1000,   -68, -1000, -1000,   -73, -1000,   -81,   142,
 433   1820, -1000, -1000,   260, -1000,   260, -1000, -1000,  1820,   117,
 434  -1000, -1000,  1820,  -255,  -255,   -37,  -255,    44,  -249, -1000,
 435   1820,  -249,   676,   116, -1000,   -82,    63, -1000, -1000, -1000,
 436  -1000,   -94,   121, -1000, -1000,   913, -1000,   104, -1000, -1000,
 437   -255, -1000,    73, -1000,   247, -1000, -1000, -1000, -1000, -1000,
 438    -96, -1000, -1000, -1000,    95,   -37,    86,   -37,  -249, -1000,
 439  -1000, -1000 };
 440 int yypgo[]={
 441
 442      0,   388,   386,   381,   377,   293,   376,   372,     0,   117,
 443    370,   367,   365,     3,    11,     8,  2039,   418,   647,   364,
 444    363,   362,   354,   353,   325,   276,   458,    38,   346,   323,
 445     58,   312,   296,   294 };
 446 int yyr1[]={
 447
 448      0,    31,     1,     8,     4,     9,     9,     9,    10,    10,
 449     10,    10,    24,    24,    24,    24,    24,    24,    14,    14,
 450     14,    12,    12,    12,    12,    30,    30,    11,    11,    11,
 451     11,    11,    11,    11,    11,    13,    13,    27,    27,    29,
 452     29,     2,     2,     2,     3,     3,    32,    33,    33,    15,
 453     15,    28,    28,    28,    28,    28,    28,    28,    28,    16,
 454     16,    16,    16,    16,    16,    16,    16,    16,    16,    16,
 455     16,    16,    16,    16,    16,    16,    16,    16,    16,    16,
 456     16,    16,    17,    17,    17,    17,    17,    17,    17,    17,
 457     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 458     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 459     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 460     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
 461     17,    17,    17,    17,    17,    17,    25,    25,    23,    18,
 462     19,    20,    21,    22,    26,    26,    26,    26,     5,     5,
 463      6,     6,     7,     7 };
 464 int yyr2[]={
 465
 466      0,     1,     5,     9,     1,     1,     5,     5,     5,     2,
 467      5,     7,     3,     3,     7,     7,     7,     7,     1,     5,
 468     13,    13,    13,     9,     9,     1,     5,    15,    15,    11,
 469     11,    17,    15,    21,     7,     1,     2,     1,     2,     1,
 470      2,     3,     3,     3,     7,     5,     7,     7,     5,     7,
 471      2,     7,    11,     9,    13,    13,     7,     5,     9,     7,
 472      9,     9,     9,     9,     9,     9,     9,     9,     7,     7,
 473      7,     7,     7,     7,     7,     7,     7,     7,     7,    11,
 474      7,     3,     5,     5,     5,     5,     5,     5,     5,     5,
 475      5,     5,     7,     5,     7,     5,     7,     7,     3,     3,
 476      9,    11,     3,     3,     3,    11,    13,    13,    11,     9,
 477     11,    13,    17,     3,     3,     7,     9,     5,     5,     9,
 478     11,     9,    11,     3,     5,     3,     5,     5,     3,     7,
 479      7,     9,     9,    13,     2,     2,     1,     3,     5,     5,
 480      5,     5,     5,     5,     3,     3,     3,     3,     5,     3,
 481      5,     3,     7,     5 };
 482 int yychk[]={
 483
 484  -1000,    -1,   -31,    -9,    -2,   -10,    -3,   -32,   -33,   -29,
 485    -11,   263,   264,   265,   262,   -12,    59,   -24,   266,   267,
 486    273,    -8,   268,   269,   256,   -15,   123,   -16,   -17,    45,
 487     43,    33,   126,   298,   300,   301,   285,    40,    91,   287,
 488    -18,   -22,   -20,   -19,   -21,   286,   259,   -23,   284,   274,
 489    293,   276,   277,   260,   257,   -28,    36,    42,    37,    64,
 490    283,    38,   288,   278,   -26,   258,   261,   257,    -8,   257,
 491    257,    59,    59,    40,    -8,    40,    -8,   -18,    40,   -30,
 492    272,    40,    -8,    40,    -8,   268,   269,   266,   267,    44,
 493     -4,    61,   299,   281,   282,   294,   292,   291,   290,   289,
 494    279,   280,   275,    63,   295,   296,   302,   303,   -17,    -8,
 495    -17,   -17,   -17,   -17,   -17,   -17,   -16,   -15,    41,   -15,
 496     93,   -15,    59,    91,   123,    91,   123,   -18,    40,    40,
 497    -16,    -8,   257,   -18,   257,    -8,   -16,    40,    40,    40,
 498    -26,   257,   -18,   -26,   -26,   -26,   -26,   -26,   -26,   -25,
 499    -15,    40,   296,   -26,    -8,    -8,    59,   -27,   -15,    -8,
 500    -15,    -8,    40,   -15,   -13,   -24,    -8,   -15,    -8,   -15,
 501     -8,   -15,   -15,   -15,   -15,   -16,    -9,   -16,    61,   -16,
 502     61,   -16,    61,   -16,    61,   -16,    61,   -16,    61,   -16,
 503     61,   -16,    61,   -16,   -16,   -16,   -16,   -16,   -16,   258,
 504     91,   123,    44,    -5,    41,    91,    44,    -6,    93,    44,
 505     -7,    59,   125,   -15,   -15,   -15,   -15,   123,   -18,    41,
 506    -15,    40,    40,    41,    41,   -15,   -16,   -25,   -26,   -25,
 507    288,   278,   -25,    41,   -30,    41,   -30,   -15,    -5,    59,
 508     41,   -14,   270,   271,    41,   -14,   125,   -16,   -16,   -16,
 509    -16,   -16,   -16,   -16,   -16,    58,    40,   -15,   -15,    41,
 510     91,   -15,    93,    59,   125,    93,    59,    93,    59,   -15,
 511    123,    -5,    41,   -15,    41,   -15,    41,    41,    44,   -25,
 512     41,   -25,    40,    -8,    -8,    -5,    -8,   -27,    -8,    -8,
 513     40,    -8,   -16,   -25,    93,    59,   -15,    93,   125,   125,
 514    125,    59,   -15,    -5,    -5,   -16,    41,   -25,   -30,   -30,
 515     -8,   -30,    59,   -14,   -15,   -14,    41,   125,    93,   125,
 516     59,    41,    41,   -30,   -13,    41,   125,    41,    -8,    41,
 517     -8,   -14 };
 518 int yydef[]={
 519
 520      1,    -2,     5,    -2,     6,     7,    41,    42,    43,     0,
 521      9,     0,     0,     0,    40,     8,    10,     0,     0,     0,
 522      0,    -2,     0,     0,    12,    13,     4,    50,    81,     0,
 523      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 524     -2,    99,   102,   103,   104,     0,   113,   114,     0,   123,
 525    125,   128,     0,     0,    -2,   135,     0,     0,     0,     0,
 526      0,     0,   136,     0,     0,     0,   147,     0,    45,     0,
 527      0,    48,    11,    37,     0,     0,     0,     0,    -2,    34,
 528      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 529      5,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 530      0,     0,     0,     0,     0,     0,    87,    88,    82,   146,
 531     83,    84,    85,    86,    -2,    -2,    91,     0,    93,     0,
 532     95,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 533    117,   118,   134,    98,   124,   126,   127,     0,     0,     0,
 534    139,   144,   145,   143,   141,   140,   142,   138,   136,    57,
 535    137,   136,     0,   136,    44,    46,    47,     0,    38,    25,
 536      0,    25,     0,    13,     0,    36,    26,     0,    18,     0,
 537     18,    14,    15,    16,    17,    49,    39,    59,     0,    68,
 538      0,    69,     0,    70,     0,    71,     0,    74,     0,    75,
 539      0,    77,     0,    78,    -2,    -2,    -2,     0,    80,     0,
 540      0,     0,     0,    92,   149,     0,     0,    94,   151,     0,
 541     96,     0,    97,     0,     0,     0,     0,     0,     0,   115,
 542      0,     0,     0,   129,   130,     0,     0,    51,   136,     0,
 543    136,     0,    56,     0,    29,     0,    30,     0,     0,    37,
 544      0,    23,     0,     0,     0,    24,     3,    60,    61,    62,
 545     63,    64,    65,    66,    67,     0,   136,     0,     0,   148,
 546      0,     0,   150,     0,   153,   100,     0,   109,     0,     0,
 547      0,   116,   119,     0,   121,     0,   131,   132,     0,     0,
 548     58,    53,   136,    25,    25,     0,    25,     0,    18,    19,
 549      0,    18,    79,     0,   101,     0,     0,   108,   152,   105,
 550    110,     0,     0,   120,   122,     0,    52,     0,    27,    28,
 551     25,    32,    -2,    21,     0,    22,    55,   106,   107,   111,
 552      0,   133,    54,    31,     0,     0,     0,     0,    18,   112,
 553     33,    20 };
 554 typedef struct { char *t_name; int t_val; } yytoktype;
 555 #ifndef YYDEBUG
 556 #       define YYDEBUG  0       /* don't allow debugging */
 557 #endif
 558
 559 #if YYDEBUG
 560
 561 yytoktype yytoks[] =
 562 {
 563         "{",    123,
 564         ")",    41,
 565         "WORD", 257,
 566         "METHOD",       258,
 567         "THING",        259,
 568         "PMFUNC",       260,
 569         "PRIVATEREF",   261,
 570         "LABEL",        262,
 571         "FORMAT",       263,
 572         "SUB",  264,
 573         "PACKAGE",      265,
 574         "WHILE",        266,
 575         "UNTIL",        267,
 576         "IF",   268,
 577         "UNLESS",       269,
 578         "ELSE", 270,
 579         "ELSIF",        271,
 580         "CONTINUE",     272,
 581         "FOR",  273,
 582         "LOOPEX",       274,
 583         "DOTDOT",       275,
 584         "FUNC0",        276,
 585         "FUNC1",        277,
 586         "FUNC", 278,
 587         "RELOP",        279,
 588         "EQOP", 280,
 589         "MULOP",        281,
 590         "ADDOP",        282,
 591         "DOLSHARP",     283,
 592         "DO",   284,
 593         "LOCAL",        285,
 594         "DELETE",       286,
 595         "HASHBRACK",    287,
 596         "LSTOP",        288,
 597         ",",    44,
 598         "=",    61,
 599         "?",    63,
 600         ":",    58,
 601         "OROR", 289,
 602         "ANDAND",       290,
 603         "BITOROP",      291,
 604         "BITANDOP",     292,
 605         "UNIOP",        293,
 606         "SHIFTOP",      294,
 607         "MATCHOP",      295,
 608         "ARROW",        296,
 609         "!",    33,
 610         "~",    126,
 611         "UMINUS",       297,
 612         "REFGEN",       298,
 613         "POWOP",        299,
 614         "PREINC",       300,
 615         "PREDEC",       301,
 616         "POSTINC",      302,
 617         "POSTDEC",      303,
 618         "(",    40,
 619         "-unknown-",    -1      /* ends search */
 620 };
 621
 622 char * yyreds[] =
 623 {
 624         "-no such reduction-",
 625         "prog : /* empty */",
 626         "prog : lineseq",
 627         "block : '{' remember lineseq '}'",
 628         "remember : /* empty */",
 629         "lineseq : /* empty */",
 630         "lineseq : lineseq decl",
 631         "lineseq : lineseq line",
 632         "line : label cond",
 633         "line : loop",
 634         "line : label ';'",
 635         "line : label sideff ';'",
 636         "sideff : error",
 637         "sideff : expr",
 638         "sideff : expr IF expr",
 639         "sideff : expr UNLESS expr",
 640         "sideff : expr WHILE expr",
 641         "sideff : expr UNTIL expr",
 642         "else : /* empty */",
 643         "else : ELSE block",
 644         "else : ELSIF '(' expr ')' block else",
 645         "cond : IF '(' expr ')' block else",
 646         "cond : UNLESS '(' expr ')' block else",
 647         "cond : IF block block else",
 648         "cond : UNLESS block block else",
 649         "cont : /* empty */",
 650         "cont : CONTINUE block",
 651         "loop : label WHILE '(' texpr ')' block cont",
 652         "loop : label UNTIL '(' expr ')' block cont",
 653         "loop : label WHILE block block cont",
 654         "loop : label UNTIL block block cont",
 655         "loop : label FOR scalar '(' expr crp block cont",
 656         "loop : label FOR '(' expr crp block cont",
 657         "loop : label FOR '(' nexpr ';' texpr ';' nexpr ')' block",
 658         "loop : label block cont",
 659         "nexpr : /* empty */",
 660         "nexpr : sideff",
 661         "texpr : /* empty */",
 662         "texpr : expr",
 663         "label : /* empty */",
 664         "label : LABEL",
 665         "decl : format",
 666         "decl : subrout",
 667         "decl : package",
 668         "format : FORMAT WORD block",
 669         "format : FORMAT block",
 670         "subrout : SUB WORD block",
 671         "package : PACKAGE WORD ';'",
 672         "package : PACKAGE ';'",
 673         "expr : expr ',' sexpr",
 674         "expr : sexpr",
 675         "listop : LSTOP indirob listexpr",
 676         "listop : FUNC '(' indirob listexpr ')'",
 677         "listop : indirob ARROW LSTOP listexpr",
 678         "listop : indirob ARROW FUNC '(' listexpr ')'",
 679         "listop : term ARROW METHOD '(' listexpr ')'",
 680         "listop : METHOD indirob listexpr",
 681         "listop : LSTOP listexpr",
 682         "listop : FUNC '(' listexpr ')'",
 683         "sexpr : sexpr '=' sexpr",
 684         "sexpr : sexpr POWOP '=' sexpr",
 685         "sexpr : sexpr MULOP '=' sexpr",
 686         "sexpr : sexpr ADDOP '=' sexpr",
 687         "sexpr : sexpr SHIFTOP '=' sexpr",
 688         "sexpr : sexpr BITANDOP '=' sexpr",
 689         "sexpr : sexpr BITOROP '=' sexpr",
 690         "sexpr : sexpr ANDAND '=' sexpr",
 691         "sexpr : sexpr OROR '=' sexpr",
 692         "sexpr : sexpr POWOP sexpr",
 693         "sexpr : sexpr MULOP sexpr",
 694         "sexpr : sexpr ADDOP sexpr",
 695         "sexpr : sexpr SHIFTOP sexpr",
 696         "sexpr : sexpr RELOP sexpr",
 697         "sexpr : sexpr EQOP sexpr",
 698         "sexpr : sexpr BITANDOP sexpr",
 699         "sexpr : sexpr BITOROP sexpr",
 700         "sexpr : sexpr DOTDOT sexpr",
 701         "sexpr : sexpr ANDAND sexpr",
 702         "sexpr : sexpr OROR sexpr",
 703         "sexpr : sexpr '?' sexpr ':' sexpr",
 704         "sexpr : sexpr MATCHOP sexpr",
 705         "sexpr : term",
 706         "term : '-' term",
 707         "term : '+' term",
 708         "term : '!' term",
 709         "term : '~' term",
 710         "term : REFGEN term",
 711         "term : term POSTINC",
 712         "term : term POSTDEC",
 713         "term : PREINC term",
 714         "term : PREDEC term",
 715         "term : LOCAL sexpr",
 716         "term : '(' expr crp",
 717         "term : '(' ')'",
 718         "term : '[' expr crb",
 719         "term : '[' ']'",
 720         "term : HASHBRACK expr crhb",
 721         "term : HASHBRACK ';' '}'",
 722         "term : scalar",
 723         "term : star",
 724         "term : scalar '[' expr ']'",
 725         "term : term ARROW '[' expr ']'",
 726         "term : hsh",
 727         "term : ary",
 728         "term : arylen",
 729         "term : scalar '{' expr ';' '}'",
 730         "term : term ARROW '{' expr ';' '}'",
 731         "term : '(' expr crp '[' expr ']'",
 732         "term : '(' ')' '[' expr ']'",
 733         "term : ary '[' expr ']'",
 734         "term : ary '{' expr ';' '}'",
 735         "term : DELETE scalar '{' expr ';' '}'",
 736         "term : DELETE '(' scalar '{' expr ';' '}' ')'",
 737         "term : THING",
 738         "term : amper",
 739         "term : amper '(' ')'",
 740         "term : amper '(' expr crp",
 741         "term : DO sexpr",
 742         "term : DO block",
 743         "term : DO WORD '(' ')'",
 744         "term : DO WORD '(' expr crp",
 745         "term : DO scalar '(' ')'",
 746         "term : DO scalar '(' expr crp",
 747         "term : LOOPEX",
 748         "term : LOOPEX WORD",
 749         "term : UNIOP",
 750         "term : UNIOP block",
 751         "term : UNIOP sexpr",
 752         "term : FUNC0",
 753         "term : FUNC0 '(' ')'",
 754         "term : FUNC1 '(' ')'",
 755         "term : FUNC1 '(' expr ')'",
 756         "term : PMFUNC '(' sexpr ')'",
 757         "term : PMFUNC '(' sexpr ',' sexpr ')'",
 758         "term : WORD",
 759         "term : listop",
 760         "listexpr : /* empty */",
 761         "listexpr : expr",
 762         "amper : '&' indirob",
 763         "scalar : '$' indirob",
 764         "ary : '@' indirob",
 765         "hsh : '%' indirob",
 766         "arylen : DOLSHARP indirob",
 767         "star : '*' indirob",
 768         "indirob : WORD",
 769         "indirob : scalar",
 770         "indirob : block",
 771         "indirob : PRIVATEREF",
 772         "crp : ',' ')'",
 773         "crp : ')'",
 774         "crb : ',' ']'",
 775         "crb : ']'",
 776         "crhb : ',' ';' '}'",
 777         "crhb : ';' '}'",
 778 };
 779 #endif /* YYDEBUG */
 780 #line 1 "/usr/lib/yaccpar"
 781 /*      @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10   */
 782
 783 /*
 784 ** Skeleton parser driver for yacc output
 785 */
 786
 787 /*
 788 ** yacc user known macros and defines
 789 */
 790 #define YYERROR         goto yyerrlab
 791 #define YYACCEPT        { free(yys); free(yyv); return(0); }
 792 #define YYABORT         { free(yys); free(yyv); return(1); }
 793 #define YYBACKUP( newtoken, newvalue )\
 794 {\
 795         if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
 796         {\
 797                 yyerror( "syntax error - cannot backup" );\
 798                 goto yyerrlab;\
 799         }\
 800         yychar = newtoken;\
 801         yystate = *yyps;\
 802         yylval = newvalue;\
 803         goto yynewstate;\
 804 }
 805 #define YYRECOVERING()  (!!yyerrflag)
 806 #ifndef YYDEBUG
 807 #       define YYDEBUG  1       /* make debugging available */
 808 #endif
 809
 810 /*
 811 ** user known globals
 812 */
 813 int yydebug;                    /* set to 1 to get debugging */
 814
 815 /*
 816 ** driver internal defines
 817 */
 818 #define YYFLAG          (-1000)
 819
 820 /*
 821 ** static variables used by the parser
 822 */
 823 static YYSTYPE *yyv;                    /* value stack */
 824 static int *yys;                        /* state stack */
 825
 826 static YYSTYPE *yypv;                   /* top of value stack */
 827 static int *yyps;                       /* top of state stack */
 828
 829 static int yystate;                     /* current state */
 830 static int yytmp;                       /* extra var (lasts between blocks) */
 831
 832 int yynerrs;                    /* number of errors */
 833
 834 int yyerrflag;                  /* error recovery flag */
 835 int yychar;                     /* current input token number */
 836
 837
 838 /*
 839 ** yyparse - return 0 if worked, 1 if syntax error not recovered from
 840 */
 841 int
 842 yyparse()
 843 {
 844         register YYSTYPE *yypvt;        /* top of value stack for $vars */
 845         unsigned yymaxdepth = YYMAXDEPTH;
 846
 847         /*
 848         ** Initialize externals - yyparse may be called more than once
 849         */
 850         yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
 851         yys = (int*)malloc(yymaxdepth*sizeof(int));
 852         if (!yyv || !yys)
 853         {
 854                 yyerror( "out of memory" );
 855                 return(1);
 856         }
 857         yypv = &yyv[-1];
 858         yyps = &yys[-1];
 859         yystate = 0;
 860         yytmp = 0;
 861         yynerrs = 0;
 862         yyerrflag = 0;
 863         yychar = -1;
 864
 865         goto yystack;
 866         {
 867                 register YYSTYPE *yy_pv;        /* top of value stack */
 868                 register int *yy_ps;            /* top of state stack */
 869                 register int yy_state;          /* current state */
 870                 register int  yy_n;             /* internal state number info */
 871
 872                 /*
 873                 ** get globals into registers.
 874                 ** branch to here only if YYBACKUP was called.
 875                 */
 876         yynewstate:
 877                 yy_pv = yypv;
 878                 yy_ps = yyps;
 879                 yy_state = yystate;
 880                 goto yy_newstate;
 881
 882                 /*
 883                 ** get globals into registers.
 884                 ** either we just started, or we just finished a reduction
 885                 */
 886         yystack:
 887                 yy_pv = yypv;
 888                 yy_ps = yyps;
 889                 yy_state = yystate;
 890
 891                 /*
 892                 ** top of for (;;) loop while no reductions done
 893                 */
 894         yy_stack:
 895                 /*
 896                 ** put a state and value onto the stacks
 897                 */
 898 #if YYDEBUG
 899                 /*
 900                 ** if debugging, look up token value in list of value vs.
 901                 ** name pairs.  0 and negative (-1) are special values.
 902                 ** Note: linear search is used since time is not a real
 903                 ** consideration while debugging.
 904                 */
 905                 if ( yydebug )
 906                 {
 907                         register int yy_i;
 908
 909                         (void)printf( "State %d, token ", yy_state );
 910                         if ( yychar == 0 )
 911                                 (void)printf( "end-of-file\n" );
 912                         else if ( yychar < 0 )
 913                                 (void)printf( "-none-\n" );
 914                         else
 915                         {
 916                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
 917                                         yy_i++ )
 918                                 {
 919                                         if ( yytoks[yy_i].t_val == yychar )
 920                                                 break;
 921                                 }
 922                                 (void)printf( "%s\n", yytoks[yy_i].t_name );
 923                         }
 924                 }
 925 #endif /* YYDEBUG */
 926                 if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
 927                 {
 928                         /*
 929                         ** reallocate and recover.  Note that pointers
 930                         ** have to be reset, or bad things will happen
 931                         */
 932                         int yyps_index = (yy_ps - yys);
 933                         int yypv_index = (yy_pv - yyv);
 934                         int yypvt_index = (yypvt - yyv);
 935                         yymaxdepth += YYMAXDEPTH;
 936                         yyv = (YYSTYPE*)realloc((char*)yyv,
 937                                 yymaxdepth * sizeof(YYSTYPE));
 938                         yys = (int*)realloc((char*)yys,
 939                                 yymaxdepth * sizeof(int));
 940                         if (!yyv || !yys)
 941                         {
 942                                 yyerror( "yacc stack overflow" );
 943                                 return(1);
 944                         }
 945                         yy_ps = yys + yyps_index;
 946                         yy_pv = yyv + yypv_index;
 947                         yypvt = yyv + yypvt_index;
 948                 }
 949                 *yy_ps = yy_state;
 950                 *++yy_pv = yyval;
 951
 952                 /*
 953                 ** we have a new state - find out what to do
 954                 */
 955         yy_newstate:
 956                 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
 957                         goto yydefault;         /* simple state */
 958 #if YYDEBUG
 959                 /*
 960                 ** if debugging, need to mark whether new token grabbed
 961                 */
 962                 yytmp = yychar < 0;
 963 #endif
 964                 if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
 965                         yychar = 0;             /* reached EOF */
 966 #if YYDEBUG
 967                 if ( yydebug && yytmp )
 968                 {
 969                         register int yy_i;
 970
 971                         (void)printf( " *** Received token " );
 972                         if ( yychar == 0 )
 973                                 (void)printf( "end-of-file\n" );
 974                         else if ( yychar < 0 )
 975                                 (void)printf( "-none-\n" );
 976                         else
 977                         {
 978                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
 979                                         yy_i++ )
 980                                 {
 981                                         if ( yytoks[yy_i].t_val == yychar )
 982                                                 break;
 983                                 }
 984                                 (void)printf( "%s\n", yytoks[yy_i].t_name );
 985                         }
 986                 }
 987 #endif /* YYDEBUG */
 988                 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
 989                         goto yydefault;
 990                 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )  /*valid shift*/
 991                 {
 992                         yychar = -1;
 993                         yyval = yylval;
 994                         yy_state = yy_n;
 995                         if ( yyerrflag > 0 )
 996                                 yyerrflag--;
 997                         goto yy_stack;
 998                 }
 999
1000         yydefault:
1001                 if ( ( yy_n = yydef[ yy_state ] ) == -2 )
1002                 {
1003 #if YYDEBUG
1004                         yytmp = yychar < 0;
1005 #endif
1006                         if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
1007                                 yychar = 0;             /* reached EOF */
1008 #if YYDEBUG
1009                         if ( yydebug && yytmp )
1010                         {
1011                                 register int yy_i;
1012
1013                                 (void)printf( " *** Received token " );
1014                                 if ( yychar == 0 )
1015                                         (void)printf( "end-of-file\n" );
1016                                 else if ( yychar < 0 )
1017                                         (void)printf( "-none-\n" );
1018                                 else
1019                                 {
1020                                         for ( yy_i = 0;
1021                                                 yytoks[yy_i].t_val >= 0;
1022                                                 yy_i++ )
1023                                         {
1024                                                 if ( yytoks[yy_i].t_val
1025                                                         == yychar )
1026                                                 {
1027                                                         break;
1028                                                 }
1029                                         }
1030                                         (void)printf( "%s\n", yytoks[yy_i].t_name );
1031                                 }
1032                         }
1033 #endif /* YYDEBUG */
1034                         /*
1035                         ** look through exception table
1036                         */
1037                         {
1038                                 register int *yyxi = yyexca;
1039
1040                                 while ( ( *yyxi != -1 ) ||
1041                                         ( yyxi[1] != yy_state ) )
1042                                 {
1043                                         yyxi += 2;
1044                                 }
1045                                 while ( ( *(yyxi += 2) >= 0 ) &&
1046                                         ( *yyxi != yychar ) )
1047                                         ;
1048                                 if ( ( yy_n = yyxi[1] ) < 0 )
1049                                         YYACCEPT;
1050                         }
1051                 }
1052
1053                 /*
1054                 ** check for syntax error
1055                 */
1056                 if ( yy_n == 0 )        /* have an error */
1057                 {
1058                         /* no worry about speed here! */
1059                         switch ( yyerrflag )
1060                         {
1061                         case 0:         /* new error */
1062                                 yyerror( "syntax error" );
1063                                 goto skip_init;
1064                         yyerrlab:
1065                                 /*
1066                                 ** get globals into registers.
1067                                 ** we have a user generated syntax type error
1068                                 */
1069                                 yy_pv = yypv;
1070                                 yy_ps = yyps;
1071                                 yy_state = yystate;
1072                                 yynerrs++;
1073                         skip_init:
1074                         case 1:
1075                         case 2:         /* incompletely recovered error */
1076                                         /* try again... */
1077                                 yyerrflag = 3;
1078                                 /*
1079                                 ** find state where "error" is a legal
1080                                 ** shift action
1081                                 */
1082                                 while ( yy_ps >= yys )
1083                                 {
1084                                         yy_n = yypact[ *yy_ps ] + YYERRCODE;
1085                                         if ( yy_n >= 0 && yy_n < YYLAST &&
1086                                                 yychk[yyact[yy_n]] == YYERRCODE)                                        {
1087                                                 /*
1088                                                 ** simulate shift of "error"
1089                                                 */
1090                                                 yy_state = yyact[ yy_n ];
1091                                                 goto yy_stack;
1092                                         }
1093                                         /*
1094                                         ** current state has no shift on
1095                                         ** "error", pop stack
1096                                         */
1097 #if YYDEBUG
1098 #       define _POP_ "Error recovery pops state %d, uncovers state %d\n"
1099                                         if ( yydebug )
1100                                                 (void)printf( _POP_, *yy_ps,
1101                                                         yy_ps[-1] );
1102 #       undef _POP_
1103 #endif
1104                                         yy_ps--;
1105                                         yy_pv--;
1106                                 }
1107                                 /*
1108                                 ** there is no state on stack with "error" as
1109                                 ** a valid shift.  give up.
1110                                 */
1111                                 YYABORT;
1112                         case 3:         /* no shift yet; eat a token */
1113 #if YYDEBUG
1114                                 /*
1115                                 ** if debugging, look up token in list of
1116                                 ** pairs.  0 and negative shouldn't occur,
1117                                 ** but since timing doesn't matter when
1118                                 ** debugging, it doesn't hurt to leave the
1119                                 ** tests here.
1120                                 */
1121                                 if ( yydebug )
1122                                 {
1123                                         register int yy_i;
1124
1125                                         (void)printf( "Error recovery discards " );
1126                                         if ( yychar == 0 )
1127                                                 (void)printf( "token end-of-file\n" );
1128                                         else if ( yychar < 0 )
1129                                                 (void)printf( "token -none-\n" );
1130                                         else
1131                                         {
1132                                                 for ( yy_i = 0;
1133                                                         yytoks[yy_i].t_val >= 0;
1134                                                         yy_i++ )
1135                                                 {
1136                                                         if ( yytoks[yy_i].t_val
1137                                                                 == yychar )
1138                                                         {
1139                                                                 break;
1140                                                         }
1141                                                 }
1142                                                 (void)printf( "token %s\n",
1143                                                         yytoks[yy_i].t_name );
1144                                         }
1145                                 }
1146 #endif /* YYDEBUG */
1147                                 if ( yychar == 0 )      /* reached EOF. quit */
1148                                         YYABORT;
1149                                 yychar = -1;
1150                                 goto yy_newstate;
1151                         }
1152                 }/* end if ( yy_n == 0 ) */
1153                 /*
1154                 ** reduction by production yy_n
1155                 ** put stack tops, etc. so things right after switch
1156                 */
1157 #if YYDEBUG
1158                 /*
1159                 ** if debugging, print the string that is the user's
1160                 ** specification of the reduction which is just about
1161                 ** to be done.
1162                 */
1163                 if ( yydebug )
1164                         (void)printf( "Reduce by (%d) \"%s\"\n",
1165                                 yy_n, yyreds[ yy_n ] );
1166 #endif
1167                 yytmp = yy_n;                   /* value to switch over */
1168                 yypvt = yy_pv;                  /* $vars top of value stack */
1169                 /*
1170                 ** Look in goto table for next state
1171                 ** Sorry about using yy_state here as temporary
1172                 ** register variable, but why not, if it works...
1173                 ** If yyr2[ yy_n ] doesn't have the low order bit
1174                 ** set, then there is no action to be done for
1175                 ** this reduction.  So, no saving & unsaving of
1176                 ** registers done.  The only difference between the
1177                 ** code just after the if and the body of the if is
1178                 ** the goto yy_stack in the body.  This way the test
1179                 ** can be made before the choice of what to do is needed.
1180                 */
1181                 {
1182                         /* length of production doubled with extra bit */
1183                         register int yy_len = yyr2[ yy_n ];
1184
1185                         if ( !( yy_len & 01 ) )
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 =
1193                                         yyact[ yy_state ] ] != -yy_n )
1194                                 {
1195                                         yy_state = yyact[ yypgo[ yy_n ] ];
1196                                 }
1197                                 goto yy_stack;
1198                         }
1199                         yy_len >>= 1;
1200                         yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
1201                         yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
1202                                 *( yy_ps -= yy_len ) + 1;
1203                         if ( yy_state >= YYLAST ||
1204                                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
1205                         {
1206                                 yy_state = yyact[ yypgo[ yy_n ] ];
1207                         }
1208                 }
1209                                         /* save until reenter driver code */
1210                 yystate = yy_state;
1211                 yyps = yy_ps;
1212                 yypv = yy_pv;
1213         }
1214         /*
1215         ** code supplied by user is placed in this switch
1216         */
1217         switch( yytmp )
1218         {
1219
1220 case 1:
1221 # line 100 "perly.y"
1222 {
1223 #if defined(YYDEBUG) && defined(DEBUGGING)
1224                     yydebug = (debug & 1);
1225 #endif
1226                     expect = XBLOCK;
1227                 } break;
1228 case 2:
1229 # line 107 "perly.y"
1230 {   if (in_eval) {
1231                                 eval_root = newUNOP(OP_LEAVEEVAL, 0, yypvt[-0].opval);
1232                                 eval_start = linklist(eval_root);
1233                                 eval_root->op_next = 0;
1234                                 peep(eval_start);
1235                             }
1236                             else
1237                                 main_root = block_head(yypvt[-0].opval, &main_start);
1238                         } break;
1239 case 3:
1240 # line 119 "perly.y"
1241 { yyval.opval = scalarseq(yypvt[-1].opval);
1242                           if (copline > (line_t)yypvt[-3].ival)
1243                               copline = yypvt[-3].ival;
1244                           leave_scope(yypvt[-2].ival);
1245                           pad_leavemy(comppadnamefill);
1246                           expect = XBLOCK; } break;
1247 case 4:
1248 # line 128 "perly.y"
1249 { yyval.ival = savestack_ix; SAVEINT(comppadnamefill); } break;
1250 case 5:
1251 # line 132 "perly.y"
1252 { yyval.opval = Nullop; } break;
1253 case 6:
1254 # line 134 "perly.y"
1255 { yyval.opval = yypvt[-1].opval; } break;
1256 case 7:
1257 # line 136 "perly.y"
1258 { yyval.opval = append_list(OP_LINESEQ, yypvt[-1].opval, yypvt[-0].opval); pad_reset(); } break;
1259 case 8:
1260 # line 140 "perly.y"
1261 { yyval.opval = newSTATEOP(0, yypvt[-1].pval, yypvt[-0].opval); } break;
1262 case 10:
1263 # line 143 "perly.y"
1264 { if (yypvt[-1].pval != Nullch) {
1265                               yyval.opval = newSTATEOP(0, yypvt[-1].pval, newOP(OP_NULL, 0));
1266                             }
1267                             else {
1268                               yyval.opval = Nullop;
1269                               copline = NOLINE;
1270                             }
1271                             expect = XBLOCK; } break;
1272 case 11:
1273 # line 152 "perly.y"
1274 { yyval.opval = newSTATEOP(0, yypvt[-2].pval, yypvt[-1].opval);
1275                           expect = XBLOCK; } break;
1276 case 12:
1277 # line 157 "perly.y"
1278 { yyval.opval = Nullop; } break;
1279 case 13:
1280 # line 159 "perly.y"
1281 { yyval.opval = yypvt[-0].opval; } break;
1282 case 14:
1283 # line 161 "perly.y"
1284 { yyval.opval = newLOGOP(OP_AND, 0, yypvt[-0].opval, yypvt[-2].opval); } break;
1285 case 15:
1286 # line 163 "perly.y"
1287 { yyval.opval = newLOGOP(OP_OR, 0, yypvt[-0].opval, yypvt[-2].opval); } break;
1288 case 16:
1289 # line 165 "perly.y"
1290 { yyval.opval = newLOOPOP(0, 1, scalar(yypvt[-0].opval), yypvt[-2].opval); } break;
1291 case 17:
1292 # line 167 "perly.y"
1293 { yyval.opval = newLOOPOP(0, 1, invert(scalar(yypvt[-0].opval)), yypvt[-2].opval);} break;
1294 case 18:
1295 # line 171 "perly.y"
1296 { yyval.opval = Nullop; } break;
1297 case 19:
1298 # line 173 "perly.y"
1299 { yyval.opval = scope(yypvt[-0].opval); } break;
1300 case 20:
1301 # line 175 "perly.y"
1302 { copline = yypvt[-5].ival;
1303                             yyval.opval = newCONDOP(0, yypvt[-3].opval, scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1304 case 21:
1305 # line 180 "perly.y"
1306 { copline = yypvt[-5].ival;
1307                             yyval.opval = newCONDOP(0, yypvt[-3].opval, scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1308 case 22:
1309 # line 183 "perly.y"
1310 { copline = yypvt[-5].ival;
1311                             yyval.opval = newCONDOP(0,
1312                                 invert(scalar(yypvt[-3].opval)), scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1313 case 23:
1314 # line 187 "perly.y"
1315 { copline = yypvt[-3].ival;
1316                             yyval.opval = newCONDOP(0, scope(yypvt[-2].opval), scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1317 case 24:
1318 # line 190 "perly.y"
1319 { copline = yypvt[-3].ival;
1320                             yyval.opval = newCONDOP(0, invert(scalar(scope(yypvt[-2].opval))),
1321                                                 scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1322 case 25:
1323 # line 196 "perly.y"
1324 { yyval.opval = Nullop; } break;
1325 case 26:
1326 # line 198 "perly.y"
1327 { yyval.opval = scope(yypvt[-0].opval); } break;
1328 case 27:
1329 # line 202 "perly.y"
1330 { copline = yypvt[-5].ival;
1331                             yyval.opval = newSTATEOP(0, yypvt[-6].pval,
1332                                     newWHILEOP(0, 1, Nullop, yypvt[-3].opval, yypvt[-1].opval, yypvt[-0].opval) ); } break;
1333 case 28:
1334 # line 206 "perly.y"
1335 { copline = yypvt[-5].ival;
1336                             yyval.opval = newSTATEOP(0, yypvt[-6].pval,
1337                                     newWHILEOP(0, 1, Nullop,
1338                                         invert(scalar(yypvt[-3].opval)), yypvt[-1].opval, yypvt[-0].opval) ); } break;
1339 case 29:
1340 # line 211 "perly.y"
1341 { copline = yypvt[-3].ival;
1342                             yyval.opval = newSTATEOP(0, yypvt[-4].pval,
1343                                     newWHILEOP(0, 1, Nullop,
1344                                         scope(yypvt[-2].opval), yypvt[-1].opval, yypvt[-0].opval) ); } break;
1345 case 30:
1346 # line 216 "perly.y"
1347 { copline = yypvt[-3].ival;
1348                             yyval.opval = newSTATEOP(0, yypvt[-4].pval,
1349                                     newWHILEOP(0, 1, Nullop,
1350                                         invert(scalar(scope(yypvt[-2].opval))), yypvt[-1].opval, yypvt[-0].opval)); } break;
1351 case 31:
1352 # line 221 "perly.y"
1353 { yyval.opval = newFOROP(0, yypvt[-7].pval, yypvt[-6].ival, ref(yypvt[-5].opval, OP_ENTERLOOP),
1354                                 yypvt[-3].opval, yypvt[-1].opval, yypvt[-0].opval); } break;
1355 case 32:
1356 # line 224 "perly.y"
1357 { yyval.opval = newFOROP(0, yypvt[-6].pval, yypvt[-5].ival, Nullop, yypvt[-3].opval, yypvt[-1].opval, yypvt[-0].opval); } break;
1358 case 33:
1359 # line 227 "perly.y"
1360 {  copline = yypvt[-8].ival;
1361                             yyval.opval = append_elem(OP_LINESEQ,
1362                                     newSTATEOP(0, yypvt[-9].pval, scalar(yypvt[-6].opval)),
1363                                     newSTATEOP(0, yypvt[-9].pval,
1364                                         newWHILEOP(0, 1, Nullop,
1365                                             scalar(yypvt[-4].opval), yypvt[-0].opval, scalar(yypvt[-2].opval)) )); } break;
1366 case 34:
1367 # line 234 "perly.y"
1368 { yyval.opval = newSTATEOP(0,
1369                                 yypvt[-2].pval, newWHILEOP(0, 1, Nullop, Nullop, yypvt[-1].opval, yypvt[-0].opval)); } break;
1370 case 35:
1371 # line 239 "perly.y"
1372 { yyval.opval = Nullop; } break;
1373 case 37:
1374 # line 244 "perly.y"
1375 { (void)scan_num("1"); yyval.opval = yylval.opval; } break;
1376 case 39:
1377 # line 249 "perly.y"
1378 { yyval.pval = Nullch; } break;
1379 case 41:
1380 # line 254 "perly.y"
1381 { yyval.ival = 0; } break;
1382 case 42:
1383 # line 256 "perly.y"
1384 { yyval.ival = 0; } break;
1385 case 43:
1386 # line 258 "perly.y"
1387 { yyval.ival = 0; } break;
1388 case 44:
1389 # line 262 "perly.y"
1390 { newFORM(yypvt[-2].ival, yypvt[-1].opval, yypvt[-0].opval); } break;
1391 case 45:
1392 # line 264 "perly.y"
1393 { newFORM(yypvt[-1].ival, Nullop, yypvt[-0].opval); } break;
1394 case 46:
1395 # line 268 "perly.y"
1396 { newSUB(yypvt[-2].ival, yypvt[-1].opval, yypvt[-0].opval); } break;
1397 case 47:
1398 # line 272 "perly.y"
1399 { package(yypvt[-1].opval); } break;
1400 case 48:
1401 # line 274 "perly.y"
1402 { package(Nullop); } break;
1403 case 49:
1404 # line 278 "perly.y"
1405 { yyval.opval = append_elem(OP_LIST, yypvt[-2].opval, yypvt[-0].opval); } break;
1406 case 51:
1407 # line 283 "perly.y"
1408 { yyval.opval = convert(yypvt[-2].ival, OPf_STACKED,
1409                                 prepend_elem(OP_LIST, newGVREF(yypvt[-1].opval), yypvt[-0].opval) ); } break;
1410 case 52:
1411 # line 286 "perly.y"
1412 { yyval.opval = convert(yypvt[-4].ival, OPf_STACKED,
1413                                 prepend_elem(OP_LIST, newGVREF(yypvt[-2].opval), yypvt[-1].opval) ); } break;
1414 case 53:
1415 # line 289 "perly.y"
1416 { yyval.opval = convert(yypvt[-1].ival, OPf_STACKED,
1417                                 prepend_elem(OP_LIST, newGVREF(yypvt[-3].opval), yypvt[-0].opval) ); } break;
1418 case 54:
1419 # line 292 "perly.y"
1420 { yyval.opval = convert(yypvt[-3].ival, OPf_STACKED,
1421                                 prepend_elem(OP_LIST, newGVREF(yypvt[-5].opval), yypvt[-1].opval) ); } break;
1422 case 55:
1423 # line 295 "perly.y"
1424 { yyval.opval = convert(OP_ENTERSUBR, OPf_STACKED|OPf_SPECIAL,
1425                                 prepend_elem(OP_LIST, newMETHOD(yypvt[-5].opval,yypvt[-3].opval), yypvt[-1].opval)); } break;
1426 case 56:
1427 # line 298 "perly.y"
1428 { yyval.opval = convert(OP_ENTERSUBR, OPf_STACKED|OPf_SPECIAL,
1429                                 prepend_elem(OP_LIST, newMETHOD(yypvt[-1].opval,yypvt[-2].opval), yypvt[-0].opval)); } break;
1430 case 57:
1431 # line 301 "perly.y"
1432 { yyval.opval = convert(yypvt[-1].ival, 0, yypvt[-0].opval); } break;
1433 case 58:
1434 # line 303 "perly.y"
1435 { yyval.opval = convert(yypvt[-3].ival, 0, yypvt[-1].opval); } break;
1436 case 59:
1437 # line 307 "perly.y"
1438 { yyval.opval = newASSIGNOP(OPf_STACKED, yypvt[-2].opval, yypvt[-0].opval); } break;
1439 case 60:
1440 # line 309 "perly.y"
1441 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1442                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1443 case 61:
1444 # line 312 "perly.y"
1445 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1446                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1447 case 62:
1448 # line 315 "perly.y"
1449 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1450                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval));} break;
1451 case 63:
1452 # line 318 "perly.y"
1453 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1454                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1455 case 64:
1456 # line 321 "perly.y"
1457 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1458                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1459 case 65:
1460 # line 324 "perly.y"
1461 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1462                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1463 case 66:
1464 # line 327 "perly.y"
1465 { yyval.opval = newLOGOP(OP_ANDASSIGN, 0,
1466                                 ref(scalar(yypvt[-3].opval), OP_ANDASSIGN),
1467                                 newUNOP(OP_SASSIGN, 0, scalar(yypvt[-0].opval))); } break;
1468 case 67:
1469 # line 331 "perly.y"
1470 { yyval.opval = newLOGOP(OP_ORASSIGN, 0,
1471                                 ref(scalar(yypvt[-3].opval), OP_ORASSIGN),
1472                                 newUNOP(OP_SASSIGN, 0, scalar(yypvt[-0].opval))); } break;
1473 case 68:
1474 # line 337 "perly.y"
1475 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1476 case 69:
1477 # line 339 "perly.y"
1478 {   if (yypvt[-1].ival != OP_REPEAT)
1479                                 scalar(yypvt[-2].opval);
1480                             yyval.opval = newBINOP(yypvt[-1].ival, 0, yypvt[-2].opval, scalar(yypvt[-0].opval)); } break;
1481 case 70:
1482 # line 343 "perly.y"
1483 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1484 case 71:
1485 # line 345 "perly.y"
1486 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1487 case 72:
1488 # line 347 "perly.y"
1489 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1490 case 73:
1491 # line 349 "perly.y"
1492 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1493 case 74:
1494 # line 351 "perly.y"
1495 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1496 case 75:
1497 # line 353 "perly.y"
1498 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1499 case 76:
1500 # line 355 "perly.y"
1501 { yyval.opval = newRANGE(yypvt[-1].ival, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval));} break;
1502 case 77:
1503 # line 357 "perly.y"
1504 { yyval.opval = newLOGOP(OP_AND, 0, yypvt[-2].opval, yypvt[-0].opval); } break;
1505 case 78:
1506 # line 359 "perly.y"
1507 { yyval.opval = newLOGOP(OP_OR, 0, yypvt[-2].opval, yypvt[-0].opval); } break;
1508 case 79:
1509 # line 361 "perly.y"
1510 { yyval.opval = newCONDOP(0, yypvt[-4].opval, yypvt[-2].opval, yypvt[-0].opval); } break;
1511 case 80:
1512 # line 363 "perly.y"
1513 { yyval.opval = bind_match(yypvt[-1].ival, yypvt[-2].opval, yypvt[-0].opval); } break;
1514 case 81:
1515 # line 365 "perly.y"
1516 { yyval.opval = yypvt[-0].opval; } break;
1517 case 82:
1518 # line 369 "perly.y"
1519 { yyval.opval = newUNOP(OP_NEGATE, 0, scalar(yypvt[-0].opval)); } break;
1520 case 83:
1521 # line 371 "perly.y"
1522 { yyval.opval = yypvt[-0].opval; } break;
1523 case 84:
1524 # line 373 "perly.y"
1525 { yyval.opval = newUNOP(OP_NOT, 0, scalar(yypvt[-0].opval)); } break;
1526 case 85:
1527 # line 375 "perly.y"
1528 { yyval.opval = newUNOP(OP_COMPLEMENT, 0, scalar(yypvt[-0].opval));} break;
1529 case 86:
1530 # line 377 "perly.y"
1531 { yyval.opval = newUNOP(OP_REFGEN, 0, ref(yypvt[-0].opval, OP_REFGEN)); } break;
1532 case 87:
1533 # line 379 "perly.y"
1534 { yyval.opval = newUNOP(OP_POSTINC, 0,
1535                                         ref(scalar(yypvt[-1].opval), OP_POSTINC)); } break;
1536 case 88:
1537 # line 382 "perly.y"
1538 { yyval.opval = newUNOP(OP_POSTDEC, 0,
1539                                         ref(scalar(yypvt[-1].opval), OP_POSTDEC)); } break;
1540 case 89:
1541 # line 385 "perly.y"
1542 { yyval.opval = newUNOP(OP_PREINC, 0,
1543                                         ref(scalar(yypvt[-0].opval), OP_PREINC)); } break;
1544 case 90:
1545 # line 388 "perly.y"
1546 { yyval.opval = newUNOP(OP_PREDEC, 0,
1547                                         ref(scalar(yypvt[-0].opval), OP_PREDEC)); } break;
1548 case 91:
1549 # line 391 "perly.y"
1550 { yyval.opval = localize(yypvt[-0].opval,yypvt[-1].ival); } break;
1551 case 92:
1552 # line 393 "perly.y"
1553 { yyval.opval = sawparens(yypvt[-1].opval); } break;
1554 case 93:
1555 # line 395 "perly.y"
1556 { yyval.opval = newNULLLIST(); } break;
1557 case 94:
1558 # line 397 "perly.y"
1559 { yyval.opval = newANONLIST(yypvt[-1].opval); } break;
1560 case 95:
1561 # line 399 "perly.y"
1562 { yyval.opval = newANONLIST(Nullop); } break;
1563 case 96:
1564 # line 401 "perly.y"
1565 { yyval.opval = newANONHASH(yypvt[-1].opval); } break;
1566 case 97:
1567 # line 403 "perly.y"
1568 { yyval.opval = newANONHASH(Nullop); } break;
1569 case 98:
1570 # line 405 "perly.y"
1571 { yyval.opval = yypvt[-0].opval; } break;
1572 case 99:
1573 # line 407 "perly.y"
1574 { yyval.opval = yypvt[-0].opval; } break;
1575 case 100:
1576 # line 409 "perly.y"
1577 { yyval.opval = newBINOP(OP_AELEM, 0, oopsAV(yypvt[-3].opval), scalar(yypvt[-1].opval)); } break;
1578 case 101:
1579 # line 411 "perly.y"
1580 { yyval.opval = newBINOP(OP_AELEM, 0,
1581                                         scalar(ref(newAVREF(yypvt[-4].opval),OP_RV2AV)),
1582                                         scalar(yypvt[-1].opval));} break;
1583 case 102:
1584 # line 415 "perly.y"
1585 { yyval.opval = yypvt[-0].opval; } break;
1586 case 103:
1587 # line 417 "perly.y"
1588 { yyval.opval = yypvt[-0].opval; } break;
1589 case 104:
1590 # line 419 "perly.y"
1591 { yyval.opval = newUNOP(OP_AV2ARYLEN, 0, ref(yypvt[-0].opval, OP_AV2ARYLEN));} break;
1592 case 105:
1593 # line 421 "perly.y"
1594 { yyval.opval = newBINOP(OP_HELEM, 0, oopsHV(yypvt[-4].opval), jmaybe(yypvt[-2].opval));
1595                             expect = XOPERATOR; } break;
1596 case 106:
1597 # line 424 "perly.y"
1598 { yyval.opval = newBINOP(OP_HELEM, 0,
1599                                         scalar(ref(newHVREF(yypvt[-5].opval),OP_RV2HV)),
1600                                         jmaybe(yypvt[-2].opval));
1601                             expect = XOPERATOR; } break;
1602 case 107:
1603 # line 429 "perly.y"
1604 { yyval.opval = newSLICEOP(0, yypvt[-1].opval, yypvt[-4].opval); } break;
1605 case 108:
1606 # line 431 "perly.y"
1607 { yyval.opval = newSLICEOP(0, yypvt[-1].opval, Nullop); } break;
1608 case 109:
1609 # line 433 "perly.y"
1610 { yyval.opval = prepend_elem(OP_ASLICE,
1611                                 newOP(OP_PUSHMARK, 0),
1612                                 list(
1613                                     newLISTOP(OP_ASLICE, 0,
1614                                         list(yypvt[-1].opval),
1615                                         ref(yypvt[-3].opval, OP_ASLICE)))); } break;
1616 case 110:
1617 # line 440 "perly.y"
1618 { yyval.opval = prepend_elem(OP_HSLICE,
1619                                 newOP(OP_PUSHMARK, 0),
1620                                 list(
1621                                     newLISTOP(OP_HSLICE, 0,
1622                                         list(yypvt[-2].opval),
1623                                         ref(oopsHV(yypvt[-4].opval), OP_HSLICE))));
1624                             expect = XOPERATOR; } break;
1625 case 111:
1626 # line 448 "perly.y"
1627 { yyval.opval = newBINOP(OP_DELETE, 0, oopsHV(yypvt[-4].opval), jmaybe(yypvt[-2].opval));
1628                             expect = XOPERATOR; } break;
1629 case 112:
1630 # line 451 "perly.y"
1631 { yyval.opval = newBINOP(OP_DELETE, 0, oopsHV(yypvt[-5].opval), jmaybe(yypvt[-3].opval));
1632                             expect = XOPERATOR; } break;
1633 case 113:
1634 # line 454 "perly.y"
1635 { yyval.opval = yypvt[-0].opval; } break;
1636 case 114:
1637 # line 456 "perly.y"
1638 { yyval.opval = newUNOP(OP_ENTERSUBR, 0,
1639                                 scalar(yypvt[-0].opval)); } break;
1640 case 115:
1641 # line 459 "perly.y"
1642 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_STACKED, scalar(yypvt[-2].opval)); } break;
1643 case 116:
1644 # line 461 "perly.y"
1645 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_STACKED,
1646                             list(prepend_elem(OP_LIST, scalar(yypvt[-3].opval), yypvt[-1].opval))); } break;
1647 case 117:
1648 # line 464 "perly.y"
1649 { yyval.opval = newUNOP(OP_DOFILE, 0, scalar(yypvt[-0].opval));
1650                           allgvs = TRUE;} break;
1651 case 118:
1652 # line 467 "perly.y"
1653 { yyval.opval = newUNOP(OP_NULL, OPf_SPECIAL, scope(yypvt[-0].opval)); } break;
1654 case 119:
1655 # line 469 "perly.y"
1656 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1657                             list(prepend_elem(OP_LIST,
1658                                 scalar(newCVREF(scalar(yypvt[-2].opval))), newNULLLIST()))); } break;
1659 case 120:
1660 # line 473 "perly.y"
1661 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1662                             list(prepend_elem(OP_LIST,
1663                                 scalar(newCVREF(scalar(yypvt[-3].opval))),
1664                                 yypvt[-1].opval))); } break;
1665 case 121:
1666 # line 478 "perly.y"
1667 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1668                             list(prepend_elem(OP_LIST,
1669                                 scalar(newCVREF(scalar(yypvt[-2].opval))), newNULLLIST())));} break;
1670 case 122:
1671 # line 482 "perly.y"
1672 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1673                             list(prepend_elem(OP_LIST,
1674                                 scalar(newCVREF(scalar(yypvt[-3].opval))),
1675                                 yypvt[-1].opval))); } break;
1676 case 123:
1677 # line 487 "perly.y"
1678 { yyval.opval = newOP(yypvt[-0].ival, OPf_SPECIAL); } break;
1679 case 124:
1680 # line 489 "perly.y"
1681 { yyval.opval = newPVOP(yypvt[-1].ival, 0,
1682                                 savestr(SvPVnx(((SVOP*)yypvt[-0].opval)->op_sv)));
1683                             op_free(yypvt[-0].opval); } break;
1684 case 125:
1685 # line 493 "perly.y"
1686 { yyval.opval = newOP(yypvt[-0].ival, 0); } break;
1687 case 126:
1688 # line 495 "perly.y"
1689 { yyval.opval = newUNOP(yypvt[-1].ival, 0, yypvt[-0].opval); } break;
1690 case 127:
1691 # line 497 "perly.y"
1692 { yyval.opval = newUNOP(yypvt[-1].ival, 0, yypvt[-0].opval); } break;
1693 case 128:
1694 # line 499 "perly.y"
1695 { yyval.opval = newOP(yypvt[-0].ival, 0); } break;
1696 case 129:
1697 # line 501 "perly.y"
1698 { yyval.opval = newOP(yypvt[-2].ival, 0); } break;
1699 case 130:
1700 # line 503 "perly.y"
1701 { yyval.opval = newOP(yypvt[-2].ival, OPf_SPECIAL); } break;
1702 case 131:
1703 # line 505 "perly.y"
1704 { yyval.opval = newUNOP(yypvt[-3].ival, 0, yypvt[-1].opval); } break;
1705 case 132:
1706 # line 507 "perly.y"
1707 { yyval.opval = pmruntime(yypvt[-3].opval, yypvt[-1].opval, Nullop); } break;
1708 case 133:
1709 # line 509 "perly.y"
1710 { yyval.opval = pmruntime(yypvt[-5].opval, yypvt[-3].opval, yypvt[-1].opval); } break;
1711 case 136:
1712 # line 515 "perly.y"
1713 { yyval.opval = newNULLLIST(); } break;
1714 case 137:
1715 # line 517 "perly.y"
1716 { yyval.opval = yypvt[-0].opval; } break;
1717 case 138:
1718 # line 521 "perly.y"
1719 { yyval.opval = newCVREF(yypvt[-0].opval); } break;
1720 case 139:
1721 # line 525 "perly.y"
1722 { yyval.opval = newSVREF(yypvt[-0].opval); } break;
1723 case 140:
1724 # line 529 "perly.y"
1725 { yyval.opval = newAVREF(yypvt[-0].opval); } break;
1726 case 141:
1727 # line 533 "perly.y"
1728 { yyval.opval = newHVREF(yypvt[-0].opval); } break;
1729 case 142:
1730 # line 537 "perly.y"
1731 { yyval.opval = newAVREF(yypvt[-0].opval); } break;
1732 case 143:
1733 # line 541 "perly.y"
1734 { yyval.opval = newGVREF(yypvt[-0].opval); } break;
1735 case 144:
1736 # line 545 "perly.y"
1737 { yyval.opval = scalar(yypvt[-0].opval); } break;
1738 case 145:
1739 # line 547 "perly.y"
1740 { yyval.opval = scalar(yypvt[-0].opval); } break;
1741 case 146:
1742 # line 549 "perly.y"
1743 { yyval.opval = scalar(scope(yypvt[-0].opval)); } break;
1744 case 147:
1745 # line 552 "perly.y"
1746 { yyval.opval = yypvt[-0].opval; } break;
1747 case 148:
1748 # line 556 "perly.y"
1749 { yyval.ival = 1; } break;
1750 case 149:
1751 # line 558 "perly.y"
1752 { yyval.ival = 0; } break;
1753 case 150:
1754 # line 562 "perly.y"
1755 { yyval.ival = 1; } break;
1756 case 151:
1757 # line 564 "perly.y"
1758 { yyval.ival = 0; } break;
1759 case 152:
1760 # line 568 "perly.y"
1761 { yyval.ival = 1; } break;
1762 case 153:
1763 # line 570 "perly.y"
1764 { yyval.ival = 0; } break;
1765         }
1766         goto yystack;           /* reset registers in driver code */
1767 }