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     { STRLEN n_a; const char *name = SvPV_const(((SVOP*)yyvsp[0].opval)->op_sv,n_a);
 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 494 "perly.y"
 559     { yyval.opval = newASSIGNOP(OPf_STACKED, yyvsp[-2].opval, yyvsp[-1].ival, yyvsp[0].opval); ;}
 560     break;
 561
 562   case 105:
 563 #line 496 "perly.y"
 564     { yyval.opval = newBINOP(yyvsp[-1].ival, 0, scalar(yyvsp[-2].opval), scalar(yyvsp[0].opval)); ;}
 565     break;
 566
 567   case 106:
 568 #line 498 "perly.y"
 569     {   if (yyvsp[-1].ival != OP_REPEAT)
 570                                 scalar(yyvsp[-2].opval);
 571                             yyval.opval = newBINOP(yyvsp[-1].ival, 0, yyvsp[-2].opval, scalar(yyvsp[0].opval)); ;}
 572     break;
 573
 574   case 107:
 575 #line 502 "perly.y"
 576     { yyval.opval = newBINOP(yyvsp[-1].ival, 0, scalar(yyvsp[-2].opval), scalar(yyvsp[0].opval)); ;}
 577     break;
 578
 579   case 108:
 580 #line 504 "perly.y"
 581     { yyval.opval = newBINOP(yyvsp[-1].ival, 0, scalar(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 = newRANGE(yyvsp[-1].ival, scalar(yyvsp[-2].opval), scalar(yyvsp[0].opval));;}
 607     break;
 608
 609   case 114:
 610 #line 516 "perly.y"
 611     { yyval.opval = newLOGOP(OP_AND, 0, yyvsp[-2].opval, yyvsp[0].opval); ;}
 612     break;
 613
 614   case 115:
 615 #line 518 "perly.y"
 616     { yyval.opval = newLOGOP(OP_OR, 0, yyvsp[-2].opval, yyvsp[0].opval); ;}
 617     break;
 618
 619   case 116:
 620 #line 520 "perly.y"
 621     { yyval.opval = newLOGOP(OP_DOR, 0, yyvsp[-2].opval, yyvsp[0].opval); ;}
 622     break;
 623
 624   case 117:
 625 #line 522 "perly.y"
 626     { yyval.opval = bind_match(yyvsp[-1].ival, yyvsp[-2].opval, yyvsp[0].opval); ;}
 627     break;
 628
 629   case 118:
 630 #line 527 "perly.y"
 631     { yyval.opval = newUNOP(OP_NEGATE, 0, scalar(yyvsp[0].opval)); ;}
 632     break;
 633
 634   case 119:
 635 #line 529 "perly.y"
 636     { yyval.opval = yyvsp[0].opval; ;}
 637     break;
 638
 639   case 120:
 640 #line 531 "perly.y"
 641     { yyval.opval = newUNOP(OP_NOT, 0, scalar(yyvsp[0].opval)); ;}
 642     break;
 643
 644   case 121:
 645 #line 533 "perly.y"
 646     { yyval.opval = newUNOP(OP_COMPLEMENT, 0, scalar(yyvsp[0].opval));;}
 647     break;
 648
 649   case 122:
 650 #line 535 "perly.y"
 651     { yyval.opval = newUNOP(OP_POSTINC, 0,
 652                                         mod(scalar(yyvsp[-1].opval), OP_POSTINC)); ;}
 653     break;
 654
 655   case 123:
 656 #line 538 "perly.y"
 657     { yyval.opval = newUNOP(OP_POSTDEC, 0,
 658                                         mod(scalar(yyvsp[-1].opval), OP_POSTDEC)); ;}
 659     break;
 660
 661   case 124:
 662 #line 541 "perly.y"
 663     { yyval.opval = newUNOP(OP_PREINC, 0,
 664                                         mod(scalar(yyvsp[0].opval), OP_PREINC)); ;}
 665     break;
 666
 667   case 125:
 668 #line 544 "perly.y"
 669     { yyval.opval = newUNOP(OP_PREDEC, 0,
 670                                         mod(scalar(yyvsp[0].opval), OP_PREDEC)); ;}
 671     break;
 672
 673   case 126:
 674 #line 551 "perly.y"
 675     { yyval.opval = newANONLIST(yyvsp[-1].opval); ;}
 676     break;
 677
 678   case 127:
 679 #line 553 "perly.y"
 680     { yyval.opval = newANONLIST(Nullop); ;}
 681     break;
 682
 683   case 128:
 684 #line 555 "perly.y"
 685     { yyval.opval = newANONHASH(yyvsp[-2].opval); ;}
 686     break;
 687
 688   case 129:
 689 #line 557 "perly.y"
 690     { yyval.opval = newANONHASH(Nullop); ;}
 691     break;
 692
 693   case 130:
 694 #line 559 "perly.y"
 695     { yyval.opval = newANONATTRSUB(yyvsp[-3].ival, yyvsp[-2].opval, yyvsp[-1].opval, yyvsp[0].opval); ;}
 696     break;
 697
 698   case 131:
 699 #line 565 "perly.y"
 700     { yyval.opval = dofile(yyvsp[0].opval); ;}
 701     break;
 702
 703   case 132:
 704 #line 567 "perly.y"
 705     { yyval.opval = newUNOP(OP_NULL, OPf_SPECIAL, scope(yyvsp[0].opval)); ;}
 706     break;
 707
 708   case 133:
 709 #line 569 "perly.y"
 710     { yyval.opval = newUNOP(OP_ENTERSUB,
 711                             OPf_SPECIAL|OPf_STACKED,
 712                             prepend_elem(OP_LIST,
 713                                 scalar(newCVREF(
 714                                     (OPpENTERSUB_AMPER<<8),
 715                                     scalar(yyvsp[-2].opval)
 716                                 )),Nullop)); dep();;}
 717     break;
 718
 719   case 134:
 720 #line 577 "perly.y"
 721     { yyval.opval = newUNOP(OP_ENTERSUB,
 722                             OPf_SPECIAL|OPf_STACKED,
 723                             append_elem(OP_LIST,
 724                                 yyvsp[-1].opval,
 725                                 scalar(newCVREF(
 726                                     (OPpENTERSUB_AMPER<<8),
 727                                     scalar(yyvsp[-3].opval)
 728                                 )))); dep();;}
 729     break;
 730
 731   case 135:
 732 #line 586 "perly.y"
 733     { yyval.opval = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
 734                             prepend_elem(OP_LIST,
 735                                 scalar(newCVREF(0,scalar(yyvsp[-2].opval))), Nullop)); dep();;}
 736     break;
 737
 738   case 136:
 739 #line 590 "perly.y"
 740     { yyval.opval = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
 741                             prepend_elem(OP_LIST,
 742                                 yyvsp[-1].opval,
 743                                 scalar(newCVREF(0,scalar(yyvsp[-3].opval))))); dep();;}
 744     break;
 745
 746   case 141:
 747 #line 602 "perly.y"
 748     { yyval.opval = newCONDOP(0, yyvsp[-4].opval, yyvsp[-2].opval, yyvsp[0].opval); ;}
 749     break;
 750
 751   case 142:
 752 #line 604 "perly.y"
 753     { yyval.opval = newUNOP(OP_REFGEN, 0, mod(yyvsp[0].opval,OP_REFGEN)); ;}
 754     break;
 755
 756   case 143:
 757 #line 606 "perly.y"
 758     { yyval.opval = yyvsp[0].opval; ;}
 759     break;
 760
 761   case 144:
 762 #line 608 "perly.y"
 763     { yyval.opval = localize(yyvsp[0].opval,yyvsp[-1].ival); ;}
 764     break;
 765
 766   case 145:
 767 #line 610 "perly.y"
 768     { yyval.opval = sawparens(yyvsp[-1].opval); ;}
 769     break;
 770
 771   case 146:
 772 #line 612 "perly.y"
 773     { yyval.opval = sawparens(newNULLLIST()); ;}
 774     break;
 775
 776   case 147:
 777 #line 614 "perly.y"
 778     { yyval.opval = yyvsp[0].opval; ;}
 779     break;
 780
 781   case 148:
 782 #line 616 "perly.y"
 783     { yyval.opval = yyvsp[0].opval; ;}
 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 = newUNOP(OP_AV2ARYLEN, 0, ref(yyvsp[0].opval, OP_AV2ARYLEN));;}
 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 = newSLICEOP(0, yyvsp[-1].opval, yyvsp[-4].opval); ;}
 809     break;
 810
 811   case 154:
 812 #line 628 "perly.y"
 813     { yyval.opval = newSLICEOP(0, yyvsp[-1].opval, Nullop); ;}
 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 = newUNOP(OP_ENTERSUB, OPf_STACKED,
 896                             append_elem(OP_LIST, yyvsp[0].opval, scalar(yyvsp[-1].opval))); ;}
 897     break;
 898
 899   case 169:
 900 #line 671 "perly.y"
 901     { yyval.opval = newOP(yyvsp[0].ival, 0); ;}
 902     break;
 903
 904   case 170:
 905 #line 673 "perly.y"
 906     { yyval.opval = newOP(yyvsp[-2].ival, 0); ;}
 907     break;
 908
 909   case 171:
 910 #line 675 "perly.y"
 911     { yyval.opval = newUNOP(OP_ENTERSUB, OPf_STACKED,
 912                                 scalar(yyvsp[0].opval)); ;}
 913     break;
 914
 915   case 172:
 916 #line 678 "perly.y"
 917     { yyval.opval = yyvsp[-2].ival == OP_NOT ? newUNOP(yyvsp[-2].ival, 0, newSVOP(OP_CONST, 0, newSViv(0)))
 918                                             : newOP(yyvsp[-2].ival, OPf_SPECIAL); ;}
 919     break;
 920
 921   case 173:
 922 #line 681 "perly.y"
 923     { yyval.opval = newUNOP(yyvsp[-3].ival, 0, yyvsp[-1].opval); ;}
 924     break;
 925
 926   case 174:
 927 #line 683 "perly.y"
 928     { yyval.opval = pmruntime(yyvsp[-3].opval, yyvsp[-1].opval, 1); ;}
 929     break;
 930
 931   case 177:
 932 #line 690 "perly.y"
 933     { yyval.opval = my_attrs(yyvsp[-1].opval,yyvsp[0].opval); ;}
 934     break;
 935
 936   case 178:
 937 #line 692 "perly.y"
 938     { yyval.opval = localize(yyvsp[0].opval,yyvsp[-1].ival); ;}
 939     break;
 940
 941   case 179:
 942 #line 697 "perly.y"
 943     { yyval.opval = sawparens(yyvsp[-1].opval); ;}
 944     break;
 945
 946   case 180:
 947 #line 699 "perly.y"
 948     { yyval.opval = sawparens(newNULLLIST()); ;}
 949     break;
 950
 951   case 181:
 952 #line 701 "perly.y"
 953     { yyval.opval = yyvsp[0].opval; ;}
 954     break;
 955
 956   case 182:
 957 #line 703 "perly.y"
 958     { yyval.opval = yyvsp[0].opval; ;}
 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 710 "perly.y"
 968     { yyval.opval = Nullop; ;}
 969     break;
 970
 971   case 185:
 972 #line 712 "perly.y"
 973     { yyval.opval = yyvsp[0].opval; ;}
 974     break;
 975
 976   case 186:
 977 #line 716 "perly.y"
 978     { yyval.opval = Nullop; ;}
 979     break;
 980
 981   case 187:
 982 #line 718 "perly.y"
 983     { yyval.opval = yyvsp[0].opval; ;}
 984     break;
 985
 986   case 188:
 987 #line 720 "perly.y"
 988     { yyval.opval = yyvsp[-1].opval; ;}
 989     break;
 990
 991   case 189:
 992 #line 726 "perly.y"
 993     { PL_in_my = 0; yyval.opval = my(yyvsp[0].opval); ;}
 994     break;
 995
 996   case 190:
 997 #line 730 "perly.y"
 998     { yyval.opval = newCVREF(yyvsp[-1].ival,yyvsp[0].opval); ;}
 999     break;
1000
1001   case 191:
1002 #line 734 "perly.y"
1003     { yyval.opval = newSVREF(yyvsp[0].opval); ;}
1004     break;
1005
1006   case 192:
1007 #line 738 "perly.y"
1008     { yyval.opval = newAVREF(yyvsp[0].opval); ;}
1009     break;
1010
1011   case 193:
1012 #line 742 "perly.y"
1013     { yyval.opval = newHVREF(yyvsp[0].opval); ;}
1014     break;
1015
1016   case 194:
1017 #line 746 "perly.y"
1018     { yyval.opval = newAVREF(yyvsp[0].opval); ;}
1019     break;
1020
1021   case 195:
1022 #line 750 "perly.y"
1023     { yyval.opval = newGVREF(0,yyvsp[0].opval); ;}
1024     break;
1025
1026   case 196:
1027 #line 755 "perly.y"
1028     { yyval.opval = scalar(yyvsp[0].opval); ;}
1029     break;
1030
1031   case 197:
1032 #line 757 "perly.y"
1033     { yyval.opval = scalar(yyvsp[0].opval);  ;}
1034     break;
1035
1036   case 198:
1037 #line 759 "perly.y"
1038     { yyval.opval = scope(yyvsp[0].opval); ;}
1039     break;
1040
1041   case 199:
1042 #line 762 "perly.y"
1043     { yyval.opval = yyvsp[0].opval; ;}
1044     break;
1045
1046
1047