perly.act

   1 case 2:
   2 #line 100 "perly.y"
   3     { (yyval.ival) = (yyvsp[-1].ival); newPROG(block_end((yyvsp[-1].ival),(yyvsp[0].opval))); ;}
   4     break;
   5
   6   case 3:
   7 #line 105 "perly.y"
   8     { if (PL_copline > (line_t)(yyvsp[-3].ival))
   9                               PL_copline = (line_t)(yyvsp[-3].ival);
  10                           (yyval.opval) = block_end((yyvsp[-2].ival), (yyvsp[-1].opval)); ;}
  11     break;
  12
  13   case 4:
  14 #line 111 "perly.y"
  15     { (yyval.ival) = block_start(TRUE); ;}
  16     break;
  17
  18   case 5:
  19 #line 115 "perly.y"
  20     { (yyval.ival) = (I32) allocmy("$_"); ;}
  21     break;
  22
  23   case 6:
  24 #line 119 "perly.y"
  25     {
  26                     PL_expect = XSTATE; (yyval.ival) = block_start(TRUE);
  27                 ;}
  28     break;
  29
  30   case 7:
  31 #line 126 "perly.y"
  32     { if (PL_copline > (line_t)(yyvsp[-3].ival))
  33                               PL_copline = (line_t)(yyvsp[-3].ival);
  34                           (yyval.opval) = block_end((yyvsp[-2].ival), (yyvsp[-1].opval)); ;}
  35     break;
  36
  37   case 8:
  38 #line 132 "perly.y"
  39     { (yyval.ival) = block_start(FALSE); ;}
  40     break;
  41
  42   case 9:
  43 #line 136 "perly.y"
  44     { (yyval.ival) = PL_savestack_ix; ;}
  45     break;
  46
  47   case 10:
  48 #line 140 "perly.y"
  49     { (yyval.opval) = Nullop; ;}
  50     break;
  51
  52   case 11:
  53 #line 142 "perly.y"
  54     { (yyval.opval) = (yyvsp[-1].opval); ;}
  55     break;
  56
  57   case 12:
  58 #line 144 "perly.y"
  59     {   LEAVE_SCOPE((yyvsp[-1].ival));
  60                             (yyval.opval) = append_list(OP_LINESEQ,
  61                                 (LISTOP*)(yyvsp[-2].opval), (LISTOP*)(yyvsp[0].opval));
  62                             PL_pad_reset_pending = TRUE;
  63                             if ((yyvsp[-2].opval) && (yyvsp[0].opval)) PL_hints |= HINT_BLOCK_SCOPE; ;}
  64     break;
  65
  66   case 13:
  67 #line 153 "perly.y"
  68     { (yyval.opval) = newSTATEOP(0, (yyvsp[-1].pval), (yyvsp[0].opval)); ;}
  69     break;
  70
  71   case 15:
  72 #line 156 "perly.y"
  73     { (yyval.opval) = (yyvsp[0].opval); ;}
  74     break;
  75
  76   case 16:
  77 #line 158 "perly.y"
  78     { (yyval.opval) = newSTATEOP(0, (yyvsp[-1].pval), (yyvsp[0].opval)); ;}
  79     break;
  80
  81   case 17:
  82 #line 160 "perly.y"
  83     { if ((yyvsp[-1].pval) != Nullch) {
  84                               (yyval.opval) = newSTATEOP(0, (yyvsp[-1].pval), newOP(OP_NULL, 0));
  85                             }
  86                             else {
  87                               (yyval.opval) = Nullop;
  88                               PL_copline = NOLINE;
  89                             }
  90                             PL_expect = XSTATE; ;}
  91     break;
  92
  93   case 18:
  94 #line 169 "perly.y"
  95     { (yyval.opval) = newSTATEOP(0, (yyvsp[-2].pval), (yyvsp[-1].opval));
  96                           PL_expect = XSTATE; ;}
  97     break;
  98
  99   case 19:
 100 #line 175 "perly.y"
 101     { (yyval.opval) = Nullop; ;}
 102     break;
 103
 104   case 20:
 105 #line 177 "perly.y"
 106     { (yyval.opval) = (yyvsp[0].opval); ;}
 107     break;
 108
 109   case 21:
 110 #line 179 "perly.y"
 111     { (yyval.opval) = newLOGOP(OP_AND, 0, (yyvsp[0].opval), (yyvsp[-2].opval)); ;}
 112     break;
 113
 114   case 22:
 115 #line 181 "perly.y"
 116     { (yyval.opval) = newLOGOP(OP_OR, 0, (yyvsp[0].opval), (yyvsp[-2].opval)); ;}
 117     break;
 118
 119   case 23:
 120 #line 183 "perly.y"
 121     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((yyvsp[0].opval)), (yyvsp[-2].opval)); ;}
 122     break;
 123
 124   case 24:
 125 #line 185 "perly.y"
 126     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (yyvsp[0].opval), (yyvsp[-2].opval));;}
 127     break;
 128
 129   case 25:
 130 #line 187 "perly.y"
 131     { (yyval.opval) = newFOROP(0, Nullch, (line_t)(yyvsp[-1].ival),
 132                                         Nullop, (yyvsp[0].opval), (yyvsp[-2].opval), Nullop); ;}
 133     break;
 134
 135   case 26:
 136 #line 193 "perly.y"
 137     { (yyval.opval) = Nullop; ;}
 138     break;
 139
 140   case 27:
 141 #line 195 "perly.y"
 142     { ((yyvsp[0].opval))->op_flags |= OPf_PARENS; (yyval.opval) = scope((yyvsp[0].opval)); ;}
 143     break;
 144
 145   case 28:
 146 #line 197 "perly.y"
 147     { PL_copline = (line_t)(yyvsp[-5].ival);
 148                             (yyval.opval) = newCONDOP(0, (yyvsp[-3].opval), scope((yyvsp[-1].opval)), (yyvsp[0].opval));
 149                             PL_hints |= HINT_BLOCK_SCOPE; ;}
 150     break;
 151
 152   case 29:
 153 #line 204 "perly.y"
 154     { PL_copline = (line_t)(yyvsp[-6].ival);
 155                             (yyval.opval) = block_end((yyvsp[-4].ival),
 156                                    newCONDOP(0, (yyvsp[-3].opval), scope((yyvsp[-1].opval)), (yyvsp[0].opval))); ;}
 157     break;
 158
 159   case 30:
 160 #line 208 "perly.y"
 161     { PL_copline = (line_t)(yyvsp[-6].ival);
 162                             (yyval.opval) = block_end((yyvsp[-4].ival),
 163                                    newCONDOP(0, (yyvsp[-3].opval), scope((yyvsp[-1].opval)), (yyvsp[0].opval))); ;}
 164     break;
 165
 166   case 31:
 167 #line 215 "perly.y"
 168     { (yyval.opval) = block_end((yyvsp[-3].ival),
 169                 newWHENOP((yyvsp[-2].opval), scope((yyvsp[0].opval)))); ;}
 170     break;
 171
 172   case 32:
 173 #line 218 "perly.y"
 174     { (yyval.opval) = newWHENOP(0, scope((yyvsp[0].opval))); ;}
 175     break;
 176
 177   case 33:
 178 #line 223 "perly.y"
 179     { (yyval.opval) = Nullop; ;}
 180     break;
 181
 182   case 34:
 183 #line 225 "perly.y"
 184     { (yyval.opval) = scope((yyvsp[0].opval)); ;}
 185     break;
 186
 187   case 35:
 188 #line 230 "perly.y"
 189     { PL_copline = (line_t)(yyvsp[-7].ival);
 190                             (yyval.opval) = block_end((yyvsp[-5].ival),
 191                                    newSTATEOP(0, (yyvsp[-8].pval),
 192                                      newWHILEOP(0, 1, (LOOP*)Nullop,
 193                                                 (yyvsp[-7].ival), (yyvsp[-4].opval), (yyvsp[-1].opval), (yyvsp[0].opval), (yyvsp[-2].ival)))); ;}
 194     break;
 195
 196   case 36:
 197 #line 236 "perly.y"
 198     { PL_copline = (line_t)(yyvsp[-7].ival);
 199                             (yyval.opval) = block_end((yyvsp[-5].ival),
 200                                    newSTATEOP(0, (yyvsp[-8].pval),
 201                                      newWHILEOP(0, 1, (LOOP*)Nullop,
 202                                                 (yyvsp[-7].ival), (yyvsp[-4].opval), (yyvsp[-1].opval), (yyvsp[0].opval), (yyvsp[-2].ival)))); ;}
 203     break;
 204
 205   case 37:
 206 #line 242 "perly.y"
 207     { (yyval.opval) = block_end((yyvsp[-6].ival),
 208                                  newFOROP(0, (yyvsp[-9].pval), (line_t)(yyvsp[-8].ival), (yyvsp[-5].opval), (yyvsp[-3].opval), (yyvsp[-1].opval), (yyvsp[0].opval))); ;}
 209     break;
 210
 211   case 38:
 212 #line 245 "perly.y"
 213     { (yyval.opval) = block_end((yyvsp[-4].ival),
 214                                  newFOROP(0, (yyvsp[-8].pval), (line_t)(yyvsp[-7].ival), mod((yyvsp[-6].opval), OP_ENTERLOOP),
 215                                           (yyvsp[-3].opval), (yyvsp[-1].opval), (yyvsp[0].opval))); ;}
 216     break;
 217
 218   case 39:
 219 #line 249 "perly.y"
 220     { (yyval.opval) = block_end((yyvsp[-4].ival),
 221                                  newFOROP(0, (yyvsp[-7].pval), (line_t)(yyvsp[-6].ival), Nullop, (yyvsp[-3].opval), (yyvsp[-1].opval), (yyvsp[0].opval))); ;}
 222     break;
 223
 224   case 40:
 225 #line 254 "perly.y"
 226     { OP *forop;
 227                           PL_copline = (line_t)(yyvsp[-10].ival);
 228                           forop = newSTATEOP(0, (yyvsp[-11].pval),
 229                                             newWHILEOP(0, 1, (LOOP*)Nullop,
 230                                                 (yyvsp[-10].ival), scalar((yyvsp[-5].opval)),
 231                                                 (yyvsp[0].opval), (yyvsp[-2].opval), (yyvsp[-3].ival)));
 232                           if ((yyvsp[-7].opval)) {
 233                                 forop = append_elem(OP_LINESEQ,
 234                                         newSTATEOP(0, ((yyvsp[-11].pval)?savepv((yyvsp[-11].pval)):Nullch),
 235                                                    (yyvsp[-7].opval)),
 236                                         forop);
 237                           }
 238
 239                           (yyval.opval) = block_end((yyvsp[-8].ival), forop); ;}
 240     break;
 241
 242   case 41:
 243 #line 269 "perly.y"
 244     { (yyval.opval) = newSTATEOP(0, (yyvsp[-2].pval),
 245                                  newWHILEOP(0, 1, (LOOP*)Nullop,
 246                                             NOLINE, Nullop, (yyvsp[-1].opval), (yyvsp[0].opval), 0)); ;}
 247     break;
 248
 249   case 42:
 250 #line 276 "perly.y"
 251     { PL_copline = (line_t) (yyvsp[-6].ival);
 252                             (yyval.opval) = block_end((yyvsp[-4].ival),
 253                                 newSTATEOP(0, (yyvsp[-7].pval),
 254                                     newGIVENOP((yyvsp[-2].opval), scope((yyvsp[0].opval)),
 255                                         (PADOFFSET) (yyvsp[-3].ival)) )); ;}
 256     break;
 257
 258   case 43:
 259 #line 285 "perly.y"
 260     { (yyval.ival) = (PL_min_intro_pending &&
 261                             PL_max_intro_pending >=  PL_min_intro_pending);
 262                           intro_my(); ;}
 263     break;
 264
 265   case 44:
 266 #line 291 "perly.y"
 267     { (yyval.opval) = Nullop; ;}
 268     break;
 269
 270   case 46:
 271 #line 297 "perly.y"
 272     { (void)scan_num("1", &yylval); (yyval.opval) = yylval.opval; ;}
 273     break;
 274
 275   case 48:
 276 #line 303 "perly.y"
 277     { (yyval.opval) = invert(scalar((yyvsp[0].opval))); ;}
 278     break;
 279
 280   case 49:
 281 #line 308 "perly.y"
 282     { (yyval.opval) = (yyvsp[0].opval); intro_my(); ;}
 283     break;
 284
 285   case 50:
 286 #line 312 "perly.y"
 287     { (yyval.opval) = (yyvsp[0].opval); intro_my(); ;}
 288     break;
 289
 290   case 51:
 291 #line 316 "perly.y"
 292     { (yyval.opval) = (yyvsp[0].opval); intro_my(); ;}
 293     break;
 294
 295   case 52:
 296 #line 321 "perly.y"
 297     { (yyval.pval) = Nullch; ;}
 298     break;
 299
 300   case 54:
 301 #line 327 "perly.y"
 302     { (yyval.ival) = 0; ;}
 303     break;
 304
 305   case 55:
 306 #line 329 "perly.y"
 307     { (yyval.ival) = 0; ;}
 308     break;
 309
 310   case 56:
 311 #line 331 "perly.y"
 312     { (yyval.ival) = 0; ;}
 313     break;
 314
 315   case 57:
 316 #line 333 "perly.y"
 317     { (yyval.ival) = 0; ;}
 318     break;
 319
 320   case 58:
 321 #line 335 "perly.y"
 322     { (yyval.ival) = 0; ;}
 323     break;
 324
 325   case 59:
 326 #line 339 "perly.y"
 327     { newFORM((yyvsp[-2].ival), (yyvsp[-1].opval), (yyvsp[0].opval)); ;}
 328     break;
 329
 330   case 60:
 331 #line 342 "perly.y"
 332     { (yyval.opval) = (yyvsp[0].opval); ;}
 333     break;
 334
 335   case 61:
 336 #line 343 "perly.y"
 337     { (yyval.opval) = Nullop; ;}
 338     break;
 339
 340   case 62:
 341 #line 348 "perly.y"
 342     { newMYSUB((yyvsp[-4].ival), (yyvsp[-3].opval), (yyvsp[-2].opval), (yyvsp[-1].opval), (yyvsp[0].opval)); ;}
 343     break;
 344
 345   case 63:
 346 #line 353 "perly.y"
 347     { newATTRSUB((yyvsp[-4].ival), (yyvsp[-3].opval), (yyvsp[-2].opval), (yyvsp[-1].opval), (yyvsp[0].opval)); ;}
 348     break;
 349
 350   case 64:
 351 #line 357 "perly.y"
 352     { (yyval.ival) = start_subparse(FALSE, 0); ;}
 353     break;
 354
 355   case 65:
 356 #line 361 "perly.y"
 357     { (yyval.ival) = start_subparse(FALSE, CVf_ANON); ;}
 358     break;
 359
 360   case 66:
 361 #line 365 "perly.y"
 362     { (yyval.ival) = start_subparse(TRUE, 0); ;}
 363     break;
 364
 365   case 67:
 366 #line 369 "perly.y"
 367     { const char *const name = SvPV_nolen_const(((SVOP*)(yyvsp[0].opval))->op_sv);
 368                           if (strEQ(name, "BEGIN") || strEQ(name, "END")
 369                               || strEQ(name, "INIT") || strEQ(name, "CHECK"))
 370                               CvSPECIAL_on(PL_compcv);
 371                           (yyval.opval) = (yyvsp[0].opval); ;}
 372     break;
 373
 374   case 68:
 375 #line 378 "perly.y"
 376     { (yyval.opval) = Nullop; ;}
 377     break;
 378
 379   case 70:
 380 #line 384 "perly.y"
 381     { (yyval.opval) = Nullop; ;}
 382     break;
 383
 384   case 71:
 385 #line 386 "perly.y"
 386     { (yyval.opval) = (yyvsp[0].opval); ;}
 387     break;
 388
 389   case 72:
 390 #line 388 "perly.y"
 391     { (yyval.opval) = Nullop; ;}
 392     break;
 393
 394   case 73:
 395 #line 393 "perly.y"
 396     { (yyval.opval) = (yyvsp[0].opval); ;}
 397     break;
 398
 399   case 74:
 400 #line 395 "perly.y"
 401     { (yyval.opval) = Nullop; ;}
 402     break;
 403
 404   case 75:
 405 #line 399 "perly.y"
 406     { (yyval.opval) = (yyvsp[0].opval); ;}
 407     break;
 408
 409   case 76:
 410 #line 400 "perly.y"
 411     { (yyval.opval) = Nullop; PL_expect = XSTATE; ;}
 412     break;
 413
 414   case 77:
 415 #line 404 "perly.y"
 416     { package((yyvsp[-1].opval)); ;}
 417     break;
 418
 419   case 78:
 420 #line 408 "perly.y"
 421     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
 422     break;
 423
 424   case 79:
 425 #line 410 "perly.y"
 426     { utilize((yyvsp[-6].ival), (yyvsp[-5].ival), (yyvsp[-3].opval), (yyvsp[-2].opval), (yyvsp[-1].opval)); ;}
 427     break;
 428
 429   case 80:
 430 #line 415 "perly.y"
 431     { (yyval.opval) = newLOGOP(OP_AND, 0, (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 432     break;
 433
 434   case 81:
 435 #line 417 "perly.y"
 436     { (yyval.opval) = newLOGOP((yyvsp[-1].ival), 0, (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 437     break;
 438
 439   case 82:
 440 #line 419 "perly.y"
 441     { (yyval.opval) = newLOGOP(OP_DOR, 0, (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 442     break;
 443
 444   case 84:
 445 #line 425 "perly.y"
 446     { (yyval.opval) = (yyvsp[-1].opval); ;}
 447     break;
 448
 449   case 85:
 450 #line 427 "perly.y"
 451     { (yyval.opval) = append_elem(OP_LIST, (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 452     break;
 453
 454   case 87:
 455 #line 433 "perly.y"
 456     { (yyval.opval) = convert((yyvsp[-2].ival), OPf_STACKED,
 457                                 prepend_elem(OP_LIST, newGVREF((yyvsp[-2].ival),(yyvsp[-1].opval)), (yyvsp[0].opval)) ); ;}
 458     break;
 459
 460   case 88:
 461 #line 436 "perly.y"
 462     { (yyval.opval) = convert((yyvsp[-4].ival), OPf_STACKED,
 463                                 prepend_elem(OP_LIST, newGVREF((yyvsp[-4].ival),(yyvsp[-2].opval)), (yyvsp[-1].opval)) ); ;}
 464     break;
 465
 466   case 89:
 467 #line 439 "perly.y"
 468     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 469                                 append_elem(OP_LIST,
 470                                     prepend_elem(OP_LIST, scalar((yyvsp[-5].opval)), (yyvsp[-1].opval)),
 471                                     newUNOP(OP_METHOD, 0, (yyvsp[-3].opval)))); ;}
 472     break;
 473
 474   case 90:
 475 #line 444 "perly.y"
 476     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 477                                 append_elem(OP_LIST, scalar((yyvsp[-2].opval)),
 478                                     newUNOP(OP_METHOD, 0, (yyvsp[0].opval)))); ;}
 479     break;
 480
 481   case 91:
 482 #line 448 "perly.y"
 483     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 484                                 append_elem(OP_LIST,
 485                                     prepend_elem(OP_LIST, (yyvsp[-1].opval), (yyvsp[0].opval)),
 486                                     newUNOP(OP_METHOD, 0, (yyvsp[-2].opval)))); ;}
 487     break;
 488
 489   case 92:
 490 #line 453 "perly.y"
 491     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 492                                 append_elem(OP_LIST,
 493                                     prepend_elem(OP_LIST, (yyvsp[-3].opval), (yyvsp[-1].opval)),
 494                                     newUNOP(OP_METHOD, 0, (yyvsp[-4].opval)))); ;}
 495     break;
 496
 497   case 93:
 498 #line 458 "perly.y"
 499     { (yyval.opval) = convert((yyvsp[-1].ival), 0, (yyvsp[0].opval)); ;}
 500     break;
 501
 502   case 94:
 503 #line 460 "perly.y"
 504     { (yyval.opval) = convert((yyvsp[-3].ival), 0, (yyvsp[-1].opval)); ;}
 505     break;
 506
 507   case 95:
 508 #line 462 "perly.y"
 509     { (yyvsp[0].opval) = newANONATTRSUB((yyvsp[-1].ival), 0, Nullop, (yyvsp[0].opval)); ;}
 510     break;
 511
 512   case 96:
 513 #line 464 "perly.y"
 514     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 515                                  append_elem(OP_LIST,
 516                                    prepend_elem(OP_LIST, (yyvsp[-2].opval), (yyvsp[0].opval)), (yyvsp[-4].opval))); ;}
 517     break;
 518
 519   case 99:
 520 #line 478 "perly.y"
 521     { (yyval.opval) = newBINOP(OP_GELEM, 0, (yyvsp[-4].opval), scalar((yyvsp[-2].opval)));
 522                             PL_expect = XOPERATOR; ;}
 523     break;
 524
 525   case 100:
 526 #line 481 "perly.y"
 527     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((yyvsp[-3].opval)), scalar((yyvsp[-1].opval))); ;}
 528     break;
 529
 530   case 101:
 531 #line 483 "perly.y"
 532     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 533                                         ref(newAVREF((yyvsp[-4].opval)),OP_RV2AV),
 534                                         scalar((yyvsp[-1].opval)));;}
 535     break;
 536
 537   case 102:
 538 #line 487 "perly.y"
 539     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 540                                         ref(newAVREF((yyvsp[-3].opval)),OP_RV2AV),
 541                                         scalar((yyvsp[-1].opval)));;}
 542     break;
 543
 544   case 103:
 545 #line 491 "perly.y"
 546     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((yyvsp[-4].opval)), jmaybe((yyvsp[-2].opval)));
 547                             PL_expect = XOPERATOR; ;}
 548     break;
 549
 550   case 104:
 551 #line 494 "perly.y"
 552     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 553                                         ref(newHVREF((yyvsp[-5].opval)),OP_RV2HV),
 554                                         jmaybe((yyvsp[-2].opval)));
 555                             PL_expect = XOPERATOR; ;}
 556     break;
 557
 558   case 105:
 559 #line 499 "perly.y"
 560     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 561                                         ref(newHVREF((yyvsp[-4].opval)),OP_RV2HV),
 562                                         jmaybe((yyvsp[-2].opval)));
 563                             PL_expect = XOPERATOR; ;}
 564     break;
 565
 566   case 106:
 567 #line 504 "perly.y"
 568     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 569                                    newCVREF(0, scalar((yyvsp[-3].opval)))); ;}
 570     break;
 571
 572   case 107:
 573 #line 507 "perly.y"
 574     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 575                                    append_elem(OP_LIST, (yyvsp[-1].opval),
 576                                        newCVREF(0, scalar((yyvsp[-4].opval))))); ;}
 577     break;
 578
 579   case 108:
 580 #line 512 "perly.y"
 581     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 582                                    append_elem(OP_LIST, (yyvsp[-1].opval),
 583                                                newCVREF(0, scalar((yyvsp[-3].opval))))); ;}
 584     break;
 585
 586   case 109:
 587 #line 516 "perly.y"
 588     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 589                                    newCVREF(0, scalar((yyvsp[-2].opval)))); ;}
 590     break;
 591
 592   case 110:
 593 #line 519 "perly.y"
 594     { (yyval.opval) = newSLICEOP(0, (yyvsp[-1].opval), (yyvsp[-4].opval)); ;}
 595     break;
 596
 597   case 111:
 598 #line 521 "perly.y"
 599     { (yyval.opval) = newSLICEOP(0, (yyvsp[-1].opval), Nullop); ;}
 600     break;
 601
 602   case 112:
 603 #line 526 "perly.y"
 604     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (yyvsp[-2].opval), (yyvsp[-1].ival), (yyvsp[0].opval)); ;}
 605     break;
 606
 607   case 113:
 608 #line 528 "perly.y"
 609     { (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval))); ;}
 610     break;
 611
 612   case 114:
 613 #line 530 "perly.y"
 614     {   if ((yyvsp[-1].ival) != OP_REPEAT)
 615                                 scalar((yyvsp[-2].opval));
 616                             (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, (yyvsp[-2].opval), scalar((yyvsp[0].opval))); ;}
 617     break;
 618
 619   case 115:
 620 #line 534 "perly.y"
 621     { (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval))); ;}
 622     break;
 623
 624   case 116:
 625 #line 536 "perly.y"
 626     { (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval))); ;}
 627     break;
 628
 629   case 117:
 630 #line 538 "perly.y"
 631     { (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval))); ;}
 632     break;
 633
 634   case 118:
 635 #line 540 "perly.y"
 636     { (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval))); ;}
 637     break;
 638
 639   case 119:
 640 #line 542 "perly.y"
 641     { (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval))); ;}
 642     break;
 643
 644   case 120:
 645 #line 544 "perly.y"
 646     { (yyval.opval) = newBINOP((yyvsp[-1].ival), 0, scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval))); ;}
 647     break;
 648
 649   case 121:
 650 #line 546 "perly.y"
 651     { (yyval.opval) = newRANGE((yyvsp[-1].ival), scalar((yyvsp[-2].opval)), scalar((yyvsp[0].opval)));;}
 652     break;
 653
 654   case 122:
 655 #line 548 "perly.y"
 656     { (yyval.opval) = newLOGOP(OP_AND, 0, (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 657     break;
 658
 659   case 123:
 660 #line 550 "perly.y"
 661     { (yyval.opval) = newLOGOP(OP_OR, 0, (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 662     break;
 663
 664   case 124:
 665 #line 552 "perly.y"
 666     { (yyval.opval) = newLOGOP(OP_DOR, 0, (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 667     break;
 668
 669   case 125:
 670 #line 554 "perly.y"
 671     { (yyval.opval) = bind_match((yyvsp[-1].ival), (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 672     break;
 673
 674   case 126:
 675 #line 559 "perly.y"
 676     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((yyvsp[0].opval))); ;}
 677     break;
 678
 679   case 127:
 680 #line 561 "perly.y"
 681     { (yyval.opval) = (yyvsp[0].opval); ;}
 682     break;
 683
 684   case 128:
 685 #line 563 "perly.y"
 686     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((yyvsp[0].opval))); ;}
 687     break;
 688
 689   case 129:
 690 #line 565 "perly.y"
 691     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((yyvsp[0].opval)));;}
 692     break;
 693
 694   case 130:
 695 #line 567 "perly.y"
 696     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
 697                                         mod(scalar((yyvsp[-1].opval)), OP_POSTINC)); ;}
 698     break;
 699
 700   case 131:
 701 #line 570 "perly.y"
 702     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
 703                                         mod(scalar((yyvsp[-1].opval)), OP_POSTDEC)); ;}
 704     break;
 705
 706   case 132:
 707 #line 573 "perly.y"
 708     { (yyval.opval) = newUNOP(OP_PREINC, 0,
 709                                         mod(scalar((yyvsp[0].opval)), OP_PREINC)); ;}
 710     break;
 711
 712   case 133:
 713 #line 576 "perly.y"
 714     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
 715                                         mod(scalar((yyvsp[0].opval)), OP_PREDEC)); ;}
 716     break;
 717
 718   case 134:
 719 #line 583 "perly.y"
 720     { (yyval.opval) = newANONLIST((yyvsp[-1].opval)); ;}
 721     break;
 722
 723   case 135:
 724 #line 585 "perly.y"
 725     { (yyval.opval) = newANONLIST(Nullop); ;}
 726     break;
 727
 728   case 136:
 729 #line 587 "perly.y"
 730     { (yyval.opval) = newANONHASH((yyvsp[-2].opval)); ;}
 731     break;
 732
 733   case 137:
 734 #line 589 "perly.y"
 735     { (yyval.opval) = newANONHASH(Nullop); ;}
 736     break;
 737
 738   case 138:
 739 #line 591 "perly.y"
 740     { (yyval.opval) = newANONATTRSUB((yyvsp[-3].ival), (yyvsp[-2].opval), (yyvsp[-1].opval), (yyvsp[0].opval)); ;}
 741     break;
 742
 743   case 139:
 744 #line 597 "perly.y"
 745     { (yyval.opval) = dofile((yyvsp[0].opval), (yyvsp[-1].ival)); ;}
 746     break;
 747
 748   case 140:
 749 #line 599 "perly.y"
 750     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, scope((yyvsp[0].opval))); ;}
 751     break;
 752
 753   case 141:
 754 #line 601 "perly.y"
 755     { (yyval.opval) = newUNOP(OP_ENTERSUB,
 756                             OPf_SPECIAL|OPf_STACKED,
 757                             prepend_elem(OP_LIST,
 758                                 scalar(newCVREF(
 759                                     (OPpENTERSUB_AMPER<<8),
 760                                     scalar((yyvsp[-2].opval))
 761                                 )),Nullop)); dep();;}
 762     break;
 763
 764   case 142:
 765 #line 609 "perly.y"
 766     { (yyval.opval) = newUNOP(OP_ENTERSUB,
 767                             OPf_SPECIAL|OPf_STACKED,
 768                             append_elem(OP_LIST,
 769                                 (yyvsp[-1].opval),
 770                                 scalar(newCVREF(
 771                                     (OPpENTERSUB_AMPER<<8),
 772                                     scalar((yyvsp[-3].opval))
 773                                 )))); dep();;}
 774     break;
 775
 776   case 143:
 777 #line 618 "perly.y"
 778     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
 779                             prepend_elem(OP_LIST,
 780                                 scalar(newCVREF(0,scalar((yyvsp[-2].opval)))), Nullop)); dep();;}
 781     break;
 782
 783   case 144:
 784 #line 622 "perly.y"
 785     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
 786                             prepend_elem(OP_LIST,
 787                                 (yyvsp[-1].opval),
 788                                 scalar(newCVREF(0,scalar((yyvsp[-3].opval)))))); dep();;}
 789     break;
 790
 791   case 149:
 792 #line 634 "perly.y"
 793     { (yyval.opval) = newCONDOP(0, (yyvsp[-4].opval), (yyvsp[-2].opval), (yyvsp[0].opval)); ;}
 794     break;
 795
 796   case 150:
 797 #line 636 "perly.y"
 798     { (yyval.opval) = newUNOP(OP_REFGEN, 0, mod((yyvsp[0].opval),OP_REFGEN)); ;}
 799     break;
 800
 801   case 151:
 802 #line 638 "perly.y"
 803     { (yyval.opval) = (yyvsp[0].opval); ;}
 804     break;
 805
 806   case 152:
 807 #line 640 "perly.y"
 808     { (yyval.opval) = localize((yyvsp[0].opval),(yyvsp[-1].ival)); ;}
 809     break;
 810
 811   case 153:
 812 #line 642 "perly.y"
 813     { (yyval.opval) = sawparens((yyvsp[-1].opval)); ;}
 814     break;
 815
 816   case 154:
 817 #line 644 "perly.y"
 818     { (yyval.opval) = sawparens(newNULLLIST()); ;}
 819     break;
 820
 821   case 155:
 822 #line 646 "perly.y"
 823     { (yyval.opval) = (yyvsp[0].opval); ;}
 824     break;
 825
 826   case 156:
 827 #line 648 "perly.y"
 828     { (yyval.opval) = (yyvsp[0].opval); ;}
 829     break;
 830
 831   case 157:
 832 #line 650 "perly.y"
 833     { (yyval.opval) = (yyvsp[0].opval); ;}
 834     break;
 835
 836   case 158:
 837 #line 652 "perly.y"
 838     { (yyval.opval) = (yyvsp[0].opval); ;}
 839     break;
 840
 841   case 159:
 842 #line 654 "perly.y"
 843     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((yyvsp[0].opval), OP_AV2ARYLEN));;}
 844     break;
 845
 846   case 160:
 847 #line 656 "perly.y"
 848     { (yyval.opval) = (yyvsp[0].opval); ;}
 849     break;
 850
 851   case 161:
 852 #line 658 "perly.y"
 853     { (yyval.opval) = prepend_elem(OP_ASLICE,
 854                                 newOP(OP_PUSHMARK, 0),
 855                                     newLISTOP(OP_ASLICE, 0,
 856                                         list((yyvsp[-1].opval)),
 857                                         ref((yyvsp[-3].opval), OP_ASLICE))); ;}
 858     break;
 859
 860   case 162:
 861 #line 664 "perly.y"
 862     { (yyval.opval) = prepend_elem(OP_HSLICE,
 863                                 newOP(OP_PUSHMARK, 0),
 864                                     newLISTOP(OP_HSLICE, 0,
 865                                         list((yyvsp[-2].opval)),
 866                                         ref(oopsHV((yyvsp[-4].opval)), OP_HSLICE)));
 867                             PL_expect = XOPERATOR; ;}
 868     break;
 869
 870   case 163:
 871 #line 671 "perly.y"
 872     { (yyval.opval) = (yyvsp[0].opval); ;}
 873     break;
 874
 875   case 164:
 876 #line 673 "perly.y"
 877     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((yyvsp[0].opval))); ;}
 878     break;
 879
 880   case 165:
 881 #line 675 "perly.y"
 882     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((yyvsp[-2].opval))); ;}
 883     break;
 884
 885   case 166:
 886 #line 677 "perly.y"
 887     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 888                             append_elem(OP_LIST, (yyvsp[-1].opval), scalar((yyvsp[-3].opval)))); ;}
 889     break;
 890
 891   case 167:
 892 #line 680 "perly.y"
 893     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 894                             append_elem(OP_LIST, (yyvsp[0].opval), scalar((yyvsp[-1].opval)))); ;}
 895     break;
 896
 897   case 168:
 898 #line 683 "perly.y"
 899     { (yyval.opval) = newOP((yyvsp[0].ival), OPf_SPECIAL);
 900                             PL_hints |= HINT_BLOCK_SCOPE; ;}
 901     break;
 902
 903   case 169:
 904 #line 686 "perly.y"
 905     { (yyval.opval) = newLOOPEX((yyvsp[-1].ival),(yyvsp[0].opval)); ;}
 906     break;
 907
 908   case 170:
 909 #line 688 "perly.y"
 910     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((yyvsp[0].opval))); ;}
 911     break;
 912
 913   case 171:
 914 #line 690 "perly.y"
 915     { (yyval.opval) = newOP((yyvsp[0].ival), 0); ;}
 916     break;
 917
 918   case 172:
 919 #line 692 "perly.y"
 920     { (yyval.opval) = newUNOP((yyvsp[-1].ival), 0, (yyvsp[0].opval)); ;}
 921     break;
 922
 923   case 173:
 924 #line 694 "perly.y"
 925     { (yyval.opval) = newUNOP((yyvsp[-1].ival), 0, (yyvsp[0].opval)); ;}
 926     break;
 927
 928   case 174:
 929 #line 696 "perly.y"
 930     { (yyval.opval) = newOP(OP_REQUIRE, (yyvsp[0].ival) ? OPf_SPECIAL : 0); ;}
 931     break;
 932
 933   case 175:
 934 #line 698 "perly.y"
 935     { (yyval.opval) = newUNOP(OP_REQUIRE, (yyvsp[-1].ival) ? OPf_SPECIAL : 0, (yyvsp[0].opval)); ;}
 936     break;
 937
 938   case 176:
 939 #line 700 "perly.y"
 940     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 941                             append_elem(OP_LIST, (yyvsp[0].opval), scalar((yyvsp[-1].opval)))); ;}
 942     break;
 943
 944   case 177:
 945 #line 703 "perly.y"
 946     { (yyval.opval) = newOP((yyvsp[0].ival), 0); ;}
 947     break;
 948
 949   case 178:
 950 #line 705 "perly.y"
 951     { (yyval.opval) = newOP((yyvsp[-2].ival), 0); ;}
 952     break;
 953
 954   case 179:
 955 #line 707 "perly.y"
 956     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 957                                 scalar((yyvsp[0].opval))); ;}
 958     break;
 959
 960   case 180:
 961 #line 710 "perly.y"
 962     { (yyval.opval) = (yyvsp[-2].ival) == OP_NOT ? newUNOP((yyvsp[-2].ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
 963                                             : newOP((yyvsp[-2].ival), OPf_SPECIAL); ;}
 964     break;
 965
 966   case 181:
 967 #line 713 "perly.y"
 968     { (yyval.opval) = newUNOP((yyvsp[-3].ival), 0, (yyvsp[-1].opval)); ;}
 969     break;
 970
 971   case 182:
 972 #line 715 "perly.y"
 973     { (yyval.opval) = pmruntime((yyvsp[-3].opval), (yyvsp[-1].opval), 1); ;}
 974     break;
 975
 976   case 185:
 977 #line 722 "perly.y"
 978     { (yyval.opval) = my_attrs((yyvsp[-1].opval),(yyvsp[0].opval)); ;}
 979     break;
 980
 981   case 186:
 982 #line 724 "perly.y"
 983     { (yyval.opval) = localize((yyvsp[0].opval),(yyvsp[-1].ival)); ;}
 984     break;
 985
 986   case 187:
 987 #line 729 "perly.y"
 988     { (yyval.opval) = sawparens((yyvsp[-1].opval)); ;}
 989     break;
 990
 991   case 188:
 992 #line 731 "perly.y"
 993     { (yyval.opval) = sawparens(newNULLLIST()); ;}
 994     break;
 995
 996   case 189:
 997 #line 733 "perly.y"
 998     { (yyval.opval) = (yyvsp[0].opval); ;}
 999     break;
1000
1001   case 190:
1002 #line 735 "perly.y"
1003     { (yyval.opval) = (yyvsp[0].opval); ;}
1004     break;
1005
1006   case 191:
1007 #line 737 "perly.y"
1008     { (yyval.opval) = (yyvsp[0].opval); ;}
1009     break;
1010
1011   case 192:
1012 #line 742 "perly.y"
1013     { (yyval.opval) = Nullop; ;}
1014     break;
1015
1016   case 193:
1017 #line 744 "perly.y"
1018     { (yyval.opval) = (yyvsp[0].opval); ;}
1019     break;
1020
1021   case 194:
1022 #line 748 "perly.y"
1023     { (yyval.opval) = Nullop; ;}
1024     break;
1025
1026   case 195:
1027 #line 750 "perly.y"
1028     { (yyval.opval) = (yyvsp[0].opval); ;}
1029     break;
1030
1031   case 196:
1032 #line 752 "perly.y"
1033     { (yyval.opval) = (yyvsp[-1].opval); ;}
1034     break;
1035
1036   case 197:
1037 #line 758 "perly.y"
1038     { PL_in_my = 0; (yyval.opval) = my((yyvsp[0].opval)); ;}
1039     break;
1040
1041   case 198:
1042 #line 762 "perly.y"
1043     { (yyval.opval) = newCVREF((yyvsp[-1].ival),(yyvsp[0].opval)); ;}
1044     break;
1045
1046   case 199:
1047 #line 766 "perly.y"
1048     { (yyval.opval) = newSVREF((yyvsp[0].opval)); ;}
1049     break;
1050
1051   case 200:
1052 #line 770 "perly.y"
1053     { (yyval.opval) = newAVREF((yyvsp[0].opval)); ;}
1054     break;
1055
1056   case 201:
1057 #line 774 "perly.y"
1058     { (yyval.opval) = newHVREF((yyvsp[0].opval)); ;}
1059     break;
1060
1061   case 202:
1062 #line 778 "perly.y"
1063     { (yyval.opval) = newAVREF((yyvsp[0].opval)); ;}
1064     break;
1065
1066   case 203:
1067 #line 782 "perly.y"
1068     { (yyval.opval) = newGVREF(0,(yyvsp[0].opval)); ;}
1069     break;
1070
1071   case 204:
1072 #line 787 "perly.y"
1073     { (yyval.opval) = scalar((yyvsp[0].opval)); ;}
1074     break;
1075
1076   case 205:
1077 #line 789 "perly.y"
1078     { (yyval.opval) = scalar((yyvsp[0].opval));  ;}
1079     break;
1080
1081   case 206:
1082 #line 791 "perly.y"
1083     { (yyval.opval) = scope((yyvsp[0].opval)); ;}
1084     break;
1085
1086   case 207:
1087 #line 794 "perly.y"
1088     { (yyval.opval) = (yyvsp[0].opval); ;}
1089     break;
1090
1091
1092       default: break;
1093