perly.act

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