perly.act

   1 /* -*- buffer-read-only: t -*-
   2    !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
   3    This file is built by regen_perly.pl from perly.y.
   4    Any changes made here will be lost!
   5  */
   6
   7 case 2:
   8 #line 115 "perly.y"
   9     {
  10                           parser->expect = XSTATE;
  11                         ;}
  12     break;
  13
  14   case 3:
  15 #line 119 "perly.y"
  16     {
  17                           newPROG(block_end((ps[(3) - (4)].val.ival),(ps[(4) - (4)].val.opval)));
  18                           PL_compiling.cop_seq = 0;
  19                           (yyval.ival) = 0;
  20                         ;}
  21     break;
  22
  23   case 4:
  24 #line 125 "perly.y"
  25     {
  26                           parser->expect = XTERM;
  27                         ;}
  28     break;
  29
  30   case 5:
  31 #line 129 "perly.y"
  32     {
  33                           PL_eval_root = (ps[(3) - (3)].val.opval);
  34                           (yyval.ival) = 0;
  35                         ;}
  36     break;
  37
  38   case 6:
  39 #line 134 "perly.y"
  40     {
  41                           parser->expect = XBLOCK;
  42                         ;}
  43     break;
  44
  45   case 7:
  46 #line 138 "perly.y"
  47     {
  48                           PL_pad_reset_pending = TRUE;
  49                           PL_eval_root = (ps[(3) - (3)].val.opval);
  50                           (yyval.ival) = 0;
  51                           yyunlex();
  52                           parser->yychar = YYEOF;
  53                         ;}
  54     break;
  55
  56   case 8:
  57 #line 146 "perly.y"
  58     {
  59                           parser->expect = XSTATE;
  60                         ;}
  61     break;
  62
  63   case 9:
  64 #line 150 "perly.y"
  65     {
  66                           PL_pad_reset_pending = TRUE;
  67                           PL_eval_root = (ps[(3) - (3)].val.opval);
  68                           (yyval.ival) = 0;
  69                           yyunlex();
  70                           parser->yychar = YYEOF;
  71                         ;}
  72     break;
  73
  74   case 10:
  75 #line 158 "perly.y"
  76     {
  77                           parser->expect = XSTATE;
  78                         ;}
  79     break;
  80
  81   case 11:
  82 #line 162 "perly.y"
  83     {
  84                           PL_pad_reset_pending = TRUE;
  85                           PL_eval_root = (ps[(3) - (3)].val.opval);
  86                           (yyval.ival) = 0;
  87                           yyunlex();
  88                           parser->yychar = YYEOF;
  89                         ;}
  90     break;
  91
  92   case 12:
  93 #line 170 "perly.y"
  94     {
  95                           parser->expect = XSTATE;
  96                         ;}
  97     break;
  98
  99   case 13:
 100 #line 174 "perly.y"
 101     {
 102                           PL_eval_root = (ps[(3) - (3)].val.opval);
 103                           (yyval.ival) = 0;
 104                         ;}
 105     break;
 106
 107   case 14:
 108 #line 182 "perly.y"
 109     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
 110                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
 111                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
 112                         ;}
 113     break;
 114
 115   case 15:
 116 #line 190 "perly.y"
 117     { if (parser->copline > (line_t)(ps[(1) - (7)].val.ival))
 118                               parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 119                           (yyval.opval) = block_end((ps[(2) - (7)].val.ival), (ps[(5) - (7)].val.opval));
 120                         ;}
 121     break;
 122
 123   case 16:
 124 #line 197 "perly.y"
 125     { (yyval.ival) = block_start(TRUE); ;}
 126     break;
 127
 128   case 17:
 129 #line 201 "perly.y"
 130     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
 131                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
 132                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
 133                         ;}
 134     break;
 135
 136   case 18:
 137 #line 208 "perly.y"
 138     { (yyval.ival) = block_start(FALSE); ;}
 139     break;
 140
 141   case 19:
 142 #line 213 "perly.y"
 143     { (yyval.opval) = (OP*)NULL; ;}
 144     break;
 145
 146   case 20:
 147 #line 215 "perly.y"
 148     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
 149                             PL_pad_reset_pending = TRUE;
 150                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
 151                                 PL_hints |= HINT_BLOCK_SCOPE;
 152                         ;}
 153     break;
 154
 155   case 21:
 156 #line 224 "perly.y"
 157     { (yyval.opval) = (OP*)NULL; ;}
 158     break;
 159
 160   case 22:
 161 #line 226 "perly.y"
 162     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
 163                             PL_pad_reset_pending = TRUE;
 164                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
 165                                 PL_hints |= HINT_BLOCK_SCOPE;
 166                         ;}
 167     break;
 168
 169   case 23:
 170 #line 235 "perly.y"
 171     {
 172                           (yyval.opval) = (ps[(1) - (1)].val.opval) ? newSTATEOP(0, NULL, (ps[(1) - (1)].val.opval)) : NULL;
 173                         ;}
 174     break;
 175
 176   case 24:
 177 #line 239 "perly.y"
 178     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 179     break;
 180
 181   case 25:
 182 #line 243 "perly.y"
 183     {
 184                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
 185                         ;}
 186     break;
 187
 188   case 26:
 189 #line 247 "perly.y"
 190     {
 191                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
 192                         ;}
 193     break;
 194
 195   case 27:
 196 #line 254 "perly.y"
 197     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 198     break;
 199
 200   case 28:
 201 #line 256 "perly.y"
 202     {
 203                           CV *fmtcv = PL_compcv;
 204                           newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
 205                           (yyval.opval) = (OP*)NULL;
 206                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
 207                               SvREFCNT_inc_simple_void(fmtcv);
 208                               pad_add_anon(fmtcv, OP_NULL);
 209                           }
 210                         ;}
 211     break;
 212
 213   case 29:
 214 #line 266 "perly.y"
 215     {
 216                           if ((ps[(2) - (3)].val.opval)->op_type == OP_CONST) {
 217                             const char *const name =
 218                                 SvPV_nolen_const(((SVOP*)(ps[(2) - (3)].val.opval))->op_sv);
 219                             if (strEQ(name, "BEGIN") || strEQ(name, "END")
 220                               || strEQ(name, "INIT") || strEQ(name, "CHECK")
 221                               || strEQ(name, "UNITCHECK"))
 222                               CvSPECIAL_on(PL_compcv);
 223                           }
 224                           else
 225                           /* State subs inside anonymous subs need to be
 226                              clonable themselves. */
 227                           if (CvANON(CvOUTSIDE(PL_compcv))
 228                            || CvCLONE(CvOUTSIDE(PL_compcv))
 229                            || !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
 230                                                 CvOUTSIDE(PL_compcv)
 231                                              ))[(ps[(2) - (3)].val.opval)->op_targ]))
 232                               CvCLONE_on(PL_compcv);
 233                           parser->in_my = 0;
 234                           parser->in_my_stash = NULL;
 235                         ;}
 236     break;
 237
 238   case 30:
 239 #line 288 "perly.y"
 240     {
 241                           SvREFCNT_inc_simple_void(PL_compcv);
 242                           (ps[(2) - (7)].val.opval)->op_type == OP_CONST
 243                               ? newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
 244                               : newMYSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
 245                           ;
 246                           (yyval.opval) = (OP*)NULL;
 247                           intro_my();
 248                         ;}
 249     break;
 250
 251   case 31:
 252 #line 298 "perly.y"
 253     {
 254                           package((ps[(3) - (4)].val.opval));
 255                           if ((ps[(2) - (4)].val.opval))
 256                               package_version((ps[(2) - (4)].val.opval));
 257                           (yyval.opval) = (OP*)NULL;
 258                         ;}
 259     break;
 260
 261   case 32:
 262 #line 305 "perly.y"
 263     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
 264     break;
 265
 266   case 33:
 267 #line 307 "perly.y"
 268     {
 269                           SvREFCNT_inc_simple_void(PL_compcv);
 270                           utilize((ps[(1) - (7)].val.ival), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
 271                           (yyval.opval) = (OP*)NULL;
 272                         ;}
 273     break;
 274
 275   case 34:
 276 #line 313 "perly.y"
 277     {
 278                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 279                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 280                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 281                         ;}
 282     break;
 283
 284   case 35:
 285 #line 319 "perly.y"
 286     {
 287                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 288                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 289                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 290                         ;}
 291     break;
 292
 293   case 36:
 294 #line 325 "perly.y"
 295     {
 296                           const PADOFFSET offset = pad_findmy_pvs("$_", 0);
 297                           (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
 298                                   newGIVENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)),
 299                                     offset == NOT_IN_PAD
 300                                     || PAD_COMPNAME_FLAGS_isOUR(offset)
 301                                       ? 0
 302                                       : offset));
 303                           parser->copline = (line_t)(ps[(1) - (6)].val.ival);
 304                         ;}
 305     break;
 306
 307   case 37:
 308 #line 336 "perly.y"
 309     { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); ;}
 310     break;
 311
 312   case 38:
 313 #line 338 "perly.y"
 314     { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); ;}
 315     break;
 316
 317   case 39:
 318 #line 340 "perly.y"
 319     {
 320                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
 321                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 322                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
 323                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
 324                         ;}
 325     break;
 326
 327   case 40:
 328 #line 347 "perly.y"
 329     {
 330                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
 331                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 332                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
 333                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
 334                         ;}
 335     break;
 336
 337   case 41:
 338 #line 354 "perly.y"
 339     { parser->expect = XTERM; ;}
 340     break;
 341
 342   case 42:
 343 #line 356 "perly.y"
 344     { parser->expect = XTERM; ;}
 345     break;
 346
 347   case 43:
 348 #line 359 "perly.y"
 349     {
 350                           OP *initop = (ps[(4) - (13)].val.opval);
 351                           OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 352                                       scalar((ps[(7) - (13)].val.opval)), (ps[(13) - (13)].val.opval), (ps[(11) - (13)].val.opval), (ps[(10) - (13)].val.ival));
 353                           if (initop) {
 354                               forop = op_prepend_elem(OP_LINESEQ, initop,
 355                                   op_append_elem(OP_LINESEQ,
 356                                       newOP(OP_UNSTACK, OPf_SPECIAL),
 357                                       forop));
 358                           }
 359                           (yyval.opval) = block_end((ps[(3) - (13)].val.ival), forop);
 360                           parser->copline = (line_t)(ps[(1) - (13)].val.ival);
 361                         ;}
 362     break;
 363
 364   case 44:
 365 #line 373 "perly.y"
 366     {
 367                           (yyval.opval) = block_end((ps[(3) - (9)].val.ival), newFOROP(0, (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
 368                           parser->copline = (line_t)(ps[(1) - (9)].val.ival);
 369                         ;}
 370     break;
 371
 372   case 45:
 373 #line 378 "perly.y"
 374     {
 375                           (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
 376                                       op_lvalue((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
 377                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
 378                         ;}
 379     break;
 380
 381   case 46:
 382 #line 384 "perly.y"
 383     { parser->in_my = 0; (yyval.opval) = my((ps[(5) - (5)].val.opval)); ;}
 384     break;
 385
 386   case 47:
 387 #line 386 "perly.y"
 388     {
 389                           (yyval.opval) = block_end(
 390                                 (ps[(4) - (11)].val.ival),
 391                                 newFOROP(0,
 392                                          op_lvalue(
 393                                             newUNOP(OP_REFGEN, 0,
 394                                                     (ps[(6) - (11)].val.opval)),
 395                                             OP_ENTERLOOP),
 396                                          (ps[(8) - (11)].val.opval), (ps[(10) - (11)].val.opval), (ps[(11) - (11)].val.opval))
 397                           );
 398                           parser->copline = (line_t)(ps[(1) - (11)].val.ival);
 399                         ;}
 400     break;
 401
 402   case 48:
 403 #line 399 "perly.y"
 404     {
 405                           (yyval.opval) = block_end((ps[(5) - (9)].val.ival), newFOROP(
 406                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
 407                                                      (ps[(3) - (9)].val.opval)),
 408                                              OP_ENTERLOOP), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
 409                           parser->copline = (line_t)(ps[(1) - (9)].val.ival);
 410                         ;}
 411     break;
 412
 413   case 49:
 414 #line 407 "perly.y"
 415     {
 416                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 417                                   newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
 418                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 419                         ;}
 420     break;
 421
 422   case 50:
 423 #line 413 "perly.y"
 424     {
 425                           /* a block is a loop that happens once */
 426                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 427                                   (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), 0);
 428                         ;}
 429     break;
 430
 431   case 51:
 432 #line 419 "perly.y"
 433     {
 434                           package((ps[(3) - (5)].val.opval));
 435                           if ((ps[(2) - (5)].val.opval)) {
 436                               package_version((ps[(2) - (5)].val.opval));
 437                           }
 438                         ;}
 439     break;
 440
 441   case 52:
 442 #line 426 "perly.y"
 443     {
 444                           /* a block is a loop that happens once */
 445                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 446                                   (OP*)NULL, block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval)), (OP*)NULL, 0);
 447                           if (parser->copline > (line_t)(ps[(4) - (8)].val.ival))
 448                               parser->copline = (line_t)(ps[(4) - (8)].val.ival);
 449                         ;}
 450     break;
 451
 452   case 53:
 453 #line 434 "perly.y"
 454     {
 455                           (yyval.opval) = (ps[(1) - (2)].val.opval);
 456                         ;}
 457     break;
 458
 459   case 54:
 460 #line 438 "perly.y"
 461     {
 462                           (yyval.opval) = (OP*)NULL;
 463                           parser->copline = NOLINE;
 464                         ;}
 465     break;
 466
 467   case 55:
 468 #line 446 "perly.y"
 469     { OP *list;
 470                           if ((ps[(2) - (2)].val.opval)) {
 471                               OP *term = (ps[(2) - (2)].val.opval);
 472                               list = op_append_elem(OP_LIST, (ps[(1) - (2)].val.opval), term);
 473                           }
 474                           else {
 475                               list = (ps[(1) - (2)].val.opval);
 476                           }
 477                           if (parser->copline == NOLINE)
 478                                parser->copline = CopLINE(PL_curcop)-1;
 479                           else parser->copline--;
 480                           (yyval.opval) = newSTATEOP(0, NULL,
 481                                           op_convert_list(OP_FORMLINE, 0, list));
 482                         ;}
 483     break;
 484
 485   case 56:
 486 #line 463 "perly.y"
 487     { (yyval.opval) = NULL; ;}
 488     break;
 489
 490   case 57:
 491 #line 465 "perly.y"
 492     { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); ;}
 493     break;
 494
 495   case 58:
 496 #line 470 "perly.y"
 497     { (yyval.opval) = (OP*)NULL; ;}
 498     break;
 499
 500   case 59:
 501 #line 472 "perly.y"
 502     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 503     break;
 504
 505   case 60:
 506 #line 474 "perly.y"
 507     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
 508     break;
 509
 510   case 61:
 511 #line 476 "perly.y"
 512     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
 513     break;
 514
 515   case 62:
 516 #line 478 "perly.y"
 517     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval)); ;}
 518     break;
 519
 520   case 63:
 521 #line 480 "perly.y"
 522     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
 523     break;
 524
 525   case 64:
 526 #line 482 "perly.y"
 527     { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
 528                           parser->copline = (line_t)(ps[(2) - (3)].val.ival); ;}
 529     break;
 530
 531   case 65:
 532 #line 485 "perly.y"
 533     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); ;}
 534     break;
 535
 536   case 66:
 537 #line 490 "perly.y"
 538     { (yyval.opval) = (OP*)NULL; ;}
 539     break;
 540
 541   case 67:
 542 #line 492 "perly.y"
 543     {
 544                           ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
 545                           (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
 546                         ;}
 547     break;
 548
 549   case 68:
 550 #line 497 "perly.y"
 551     { parser->copline = (line_t)(ps[(1) - (6)].val.ival);
 552                             (yyval.opval) = newCONDOP(0,
 553                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)),
 554                                 op_scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
 555                           PL_hints |= HINT_BLOCK_SCOPE;
 556                         ;}
 557     break;
 558
 559   case 69:
 560 #line 507 "perly.y"
 561     { (yyval.opval) = (OP*)NULL; ;}
 562     break;
 563
 564   case 70:
 565 #line 509 "perly.y"
 566     { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); ;}
 567     break;
 568
 569   case 71:
 570 #line 514 "perly.y"
 571     { (yyval.ival) = (PL_min_intro_pending &&
 572                             PL_max_intro_pending >=  PL_min_intro_pending);
 573                           intro_my(); ;}
 574     break;
 575
 576   case 72:
 577 #line 520 "perly.y"
 578     { (yyval.opval) = (OP*)NULL; ;}
 579     break;
 580
 581   case 74:
 582 #line 526 "perly.y"
 583     { YYSTYPE tmplval;
 584                           (void)scan_num("1", &tmplval);
 585                           (yyval.opval) = tmplval.opval; ;}
 586     break;
 587
 588   case 76:
 589 #line 534 "perly.y"
 590     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
 591     break;
 592
 593   case 77:
 594 #line 539 "perly.y"
 595     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 596     break;
 597
 598   case 78:
 599 #line 543 "perly.y"
 600     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 601     break;
 602
 603   case 79:
 604 #line 547 "perly.y"
 605     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 606     break;
 607
 608   case 80:
 609 #line 550 "perly.y"
 610     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 611     break;
 612
 613   case 81:
 614 #line 551 "perly.y"
 615     { (yyval.opval) = (OP*)NULL; ;}
 616     break;
 617
 618   case 82:
 619 #line 555 "perly.y"
 620     { (yyval.ival) = start_subparse(FALSE, 0);
 621                             SAVEFREESV(PL_compcv); ;}
 622     break;
 623
 624   case 83:
 625 #line 561 "perly.y"
 626     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
 627                             SAVEFREESV(PL_compcv); ;}
 628     break;
 629
 630   case 84:
 631 #line 566 "perly.y"
 632     { (yyval.ival) = start_subparse(TRUE, 0);
 633                             SAVEFREESV(PL_compcv); ;}
 634     break;
 635
 636   case 87:
 637 #line 577 "perly.y"
 638     { (yyval.opval) = (OP*)NULL; ;}
 639     break;
 640
 641   case 89:
 642 #line 583 "perly.y"
 643     { (yyval.opval) = (OP*)NULL; ;}
 644     break;
 645
 646   case 90:
 647 #line 585 "perly.y"
 648     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
 649     break;
 650
 651   case 91:
 652 #line 587 "perly.y"
 653     { (yyval.opval) = (OP*)NULL; ;}
 654     break;
 655
 656   case 92:
 657 #line 592 "perly.y"
 658     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
 659     break;
 660
 661   case 93:
 662 #line 594 "perly.y"
 663     { (yyval.opval) = (OP*)NULL; ;}
 664     break;
 665
 666   case 94:
 667 #line 598 "perly.y"
 668     { (yyval.opval) = (OP*)NULL; ;}
 669     break;
 670
 671   case 95:
 672 #line 600 "perly.y"
 673     {
 674                           if (!FEATURE_SIGNATURES_IS_ENABLED)
 675                             Perl_croak(aTHX_ "Experimental "
 676                                 "subroutine signatures not enabled");
 677                           Perl_ck_warner_d(aTHX_
 678                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
 679                                 "The signatures feature is experimental");
 680                           (yyval.opval) = parse_subsignature();
 681                         ;}
 682     break;
 683
 684   case 96:
 685 #line 610 "perly.y"
 686     {
 687                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(2) - (3)].val.opval),
 688                                 newSTATEOP(0, NULL, sawparens(newNULLLIST())));
 689                           parser->expect = XBLOCK;
 690                         ;}
 691     break;
 692
 693   case 97:
 694 #line 619 "perly.y"
 695     {
 696                           if (parser->copline > (line_t)(ps[(3) - (5)].val.ival))
 697                               parser->copline = (line_t)(ps[(3) - (5)].val.ival);
 698                           (yyval.opval) = block_end((ps[(1) - (5)].val.ival),
 699                                 op_append_list(OP_LINESEQ, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)));
 700                         ;}
 701     break;
 702
 703   case 98:
 704 #line 628 "perly.y"
 705     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 706     break;
 707
 708   case 99:
 709 #line 629 "perly.y"
 710     { (yyval.opval) = (OP*)NULL; ;}
 711     break;
 712
 713   case 100:
 714 #line 634 "perly.y"
 715     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 716     break;
 717
 718   case 101:
 719 #line 636 "perly.y"
 720     { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 721     break;
 722
 723   case 102:
 724 #line 638 "perly.y"
 725     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 726     break;
 727
 728   case 104:
 729 #line 644 "perly.y"
 730     { (yyval.opval) = (ps[(1) - (2)].val.opval); ;}
 731     break;
 732
 733   case 105:
 734 #line 646 "perly.y"
 735     {
 736                           OP* term = (ps[(3) - (3)].val.opval);
 737                           (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
 738                         ;}
 739     break;
 740
 741   case 107:
 742 #line 655 "perly.y"
 743     { (yyval.opval) = op_convert_list((ps[(1) - (3)].val.ival), OPf_STACKED,
 744                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (3)].val.ival),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
 745                         ;}
 746     break;
 747
 748   case 108:
 749 #line 659 "perly.y"
 750     { (yyval.opval) = op_convert_list((ps[(1) - (5)].val.ival), OPf_STACKED,
 751                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (5)].val.ival),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
 752                         ;}
 753     break;
 754
 755   case 109:
 756 #line 663 "perly.y"
 757     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
 758                                 op_append_elem(OP_LIST,
 759                                     op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
 760                                     newMETHOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
 761                         ;}
 762     break;
 763
 764   case 110:
 765 #line 669 "perly.y"
 766     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
 767                                 op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
 768                                     newMETHOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
 769                         ;}
 770     break;
 771
 772   case 111:
 773 #line 674 "perly.y"
 774     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
 775                                 op_append_elem(OP_LIST,
 776                                     op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
 777                                     newMETHOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
 778                         ;}
 779     break;
 780
 781   case 112:
 782 #line 680 "perly.y"
 783     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
 784                                 op_append_elem(OP_LIST,
 785                                     op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
 786                                     newMETHOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
 787                         ;}
 788     break;
 789
 790   case 113:
 791 #line 686 "perly.y"
 792     { (yyval.opval) = op_convert_list((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
 793     break;
 794
 795   case 114:
 796 #line 688 "perly.y"
 797     { (yyval.opval) = op_convert_list((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
 798     break;
 799
 800   case 115:
 801 #line 690 "perly.y"
 802     { SvREFCNT_inc_simple_void(PL_compcv);
 803                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
 804     break;
 805
 806   case 116:
 807 #line 693 "perly.y"
 808     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 809                                  op_append_elem(OP_LIST,
 810                                    op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
 811                         ;}
 812     break;
 813
 814   case 119:
 815 #line 708 "perly.y"
 816     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval))); ;}
 817     break;
 818
 819   case 120:
 820 #line 710 "perly.y"
 821     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
 822                         ;}
 823     break;
 824
 825   case 121:
 826 #line 713 "perly.y"
 827     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 828                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
 829                                         scalar((ps[(4) - (5)].val.opval)));
 830                         ;}
 831     break;
 832
 833   case 122:
 834 #line 718 "perly.y"
 835     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 836                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
 837                                         scalar((ps[(3) - (4)].val.opval)));
 838                         ;}
 839     break;
 840
 841   case 123:
 842 #line 723 "perly.y"
 843     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
 844                         ;}
 845     break;
 846
 847   case 124:
 848 #line 726 "perly.y"
 849     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 850                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
 851                                         jmaybe((ps[(4) - (6)].val.opval))); ;}
 852     break;
 853
 854   case 125:
 855 #line 730 "perly.y"
 856     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 857                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
 858                                         jmaybe((ps[(3) - (5)].val.opval))); ;}
 859     break;
 860
 861   case 126:
 862 #line 734 "perly.y"
 863     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 864                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); ;}
 865     break;
 866
 867   case 127:
 868 #line 737 "perly.y"
 869     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 870                                    op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
 871                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval))))); ;}
 872     break;
 873
 874   case 128:
 875 #line 742 "perly.y"
 876     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 877                                    op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
 878                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval))))); ;}
 879     break;
 880
 881   case 129:
 882 #line 746 "perly.y"
 883     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 884                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); ;}
 885     break;
 886
 887   case 130:
 888 #line 749 "perly.y"
 889     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); ;}
 890     break;
 891
 892   case 131:
 893 #line 751 "perly.y"
 894     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); ;}
 895     break;
 896
 897   case 132:
 898 #line 753 "perly.y"
 899     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); ;}
 900     break;
 901
 902   case 133:
 903 #line 758 "perly.y"
 904     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); ;}
 905     break;
 906
 907   case 134:
 908 #line 760 "perly.y"
 909     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 910     break;
 911
 912   case 135:
 913 #line 762 "perly.y"
 914     {   if ((ps[(2) - (3)].val.ival) != OP_REPEAT)
 915                                 scalar((ps[(1) - (3)].val.opval));
 916                             (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
 917                         ;}
 918     break;
 919
 920   case 136:
 921 #line 767 "perly.y"
 922     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 923     break;
 924
 925   case 137:
 926 #line 769 "perly.y"
 927     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 928     break;
 929
 930   case 138:
 931 #line 771 "perly.y"
 932     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 933     break;
 934
 935   case 139:
 936 #line 773 "perly.y"
 937     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 938     break;
 939
 940   case 140:
 941 #line 775 "perly.y"
 942     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 943     break;
 944
 945   case 141:
 946 #line 777 "perly.y"
 947     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 948     break;
 949
 950   case 142:
 951 #line 779 "perly.y"
 952     { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
 953     break;
 954
 955   case 143:
 956 #line 781 "perly.y"
 957     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 958     break;
 959
 960   case 144:
 961 #line 783 "perly.y"
 962     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 963     break;
 964
 965   case 145:
 966 #line 785 "perly.y"
 967     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 968     break;
 969
 970   case 146:
 971 #line 787 "perly.y"
 972     { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
 973     break;
 974
 975   case 147:
 976 #line 792 "perly.y"
 977     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); ;}
 978     break;
 979
 980   case 148:
 981 #line 794 "perly.y"
 982     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
 983     break;
 984
 985   case 149:
 986 #line 797 "perly.y"
 987     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
 988     break;
 989
 990   case 150:
 991 #line 799 "perly.y"
 992     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
 993     break;
 994
 995   case 151:
 996 #line 801 "perly.y"
 997     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
 998                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); ;}
 999     break;
1000
1001   case 152:
1002 #line 804 "perly.y"
1003     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1004                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));;}
1005     break;
1006
1007   case 153:
1008 #line 807 "perly.y"
1009     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1010                                        op_append_elem(
1011                                         OP_LIST,
1012                                         newSVREF(scalar(
1013                                             newSVOP(OP_CONST,0,
1014                                                     newSVpvs("\""))
1015                                         )),
1016                                         (ps[(1) - (2)].val.opval)
1017                                        ));
1018                         ;}
1019     break;
1020
1021   case 154:
1022 #line 818 "perly.y"
1023     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1024                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); ;}
1025     break;
1026
1027   case 155:
1028 #line 821 "perly.y"
1029     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1030                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); ;}
1031     break;
1032
1033   case 156:
1034 #line 828 "perly.y"
1035     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); ;}
1036     break;
1037
1038   case 157:
1039 #line 830 "perly.y"
1040     { (yyval.opval) = newANONLIST((OP*)NULL);;}
1041     break;
1042
1043   case 158:
1044 #line 832 "perly.y"
1045     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); ;}
1046     break;
1047
1048   case 159:
1049 #line 834 "perly.y"
1050     { (yyval.opval) = newANONHASH((OP*)NULL); ;}
1051     break;
1052
1053   case 160:
1054 #line 836 "perly.y"
1055     { SvREFCNT_inc_simple_void(PL_compcv);
1056                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1057     break;
1058
1059   case 161:
1060 #line 843 "perly.y"
1061     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));;}
1062     break;
1063
1064   case 162:
1065 #line 845 "perly.y"
1066     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));;}
1067     break;
1068
1069   case 167:
1070 #line 853 "perly.y"
1071     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1072     break;
1073
1074   case 168:
1075 #line 855 "perly.y"
1076     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); ;}
1077     break;
1078
1079   case 169:
1080 #line 857 "perly.y"
1081     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1082     break;
1083
1084   case 170:
1085 #line 859 "perly.y"
1086     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1087     break;
1088
1089   case 171:
1090 #line 861 "perly.y"
1091     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1092     break;
1093
1094   case 172:
1095 #line 863 "perly.y"
1096     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1097     break;
1098
1099   case 173:
1100 #line 865 "perly.y"
1101     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1102     break;
1103
1104   case 174:
1105 #line 867 "perly.y"
1106     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1107     break;
1108
1109   case 175:
1110 #line 869 "perly.y"
1111     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1112     break;
1113
1114   case 176:
1115 #line 871 "perly.y"
1116     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1117     break;
1118
1119   case 177:
1120 #line 873 "perly.y"
1121     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1122     break;
1123
1124   case 178:
1125 #line 875 "perly.y"
1126     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1127     break;
1128
1129   case 179:
1130 #line 877 "perly.y"
1131     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1132     break;
1133
1134   case 180:
1135 #line 879 "perly.y"
1136     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1137                                 newOP(OP_PUSHMARK, 0),
1138                                     newLISTOP(OP_ASLICE, 0,
1139                                         list((ps[(3) - (4)].val.opval)),
1140                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1141                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1142                               (yyval.opval)->op_private |=
1143                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1144                         ;}
1145     break;
1146
1147   case 181:
1148 #line 889 "perly.y"
1149     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1150                                 newOP(OP_PUSHMARK, 0),
1151                                     newLISTOP(OP_KVASLICE, 0,
1152                                         list((ps[(3) - (4)].val.opval)),
1153                                         ref(oopsAV((ps[(1) - (4)].val.opval)), OP_KVASLICE)));
1154                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1155                               (yyval.opval)->op_private |=
1156                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1157                         ;}
1158     break;
1159
1160   case 182:
1161 #line 899 "perly.y"
1162     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1163                                 newOP(OP_PUSHMARK, 0),
1164                                     newLISTOP(OP_HSLICE, 0,
1165                                         list((ps[(3) - (5)].val.opval)),
1166                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1167                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1168                               (yyval.opval)->op_private |=
1169                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1170                         ;}
1171     break;
1172
1173   case 183:
1174 #line 909 "perly.y"
1175     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1176                                 newOP(OP_PUSHMARK, 0),
1177                                     newLISTOP(OP_KVHSLICE, 0,
1178                                         list((ps[(3) - (5)].val.opval)),
1179                                         ref((ps[(1) - (5)].val.opval), OP_KVHSLICE)));
1180                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1181                               (yyval.opval)->op_private |=
1182                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1183                         ;}
1184     break;
1185
1186   case 184:
1187 #line 919 "perly.y"
1188     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1189     break;
1190
1191   case 185:
1192 #line 921 "perly.y"
1193     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1194     break;
1195
1196   case 186:
1197 #line 923 "perly.y"
1198     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1199                         ;}
1200     break;
1201
1202   case 187:
1203 #line 926 "perly.y"
1204     {
1205                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1206                                 op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1207                         ;}
1208     break;
1209
1210   case 188:
1211 #line 931 "perly.y"
1212     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1213                             op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1214                         ;}
1215     break;
1216
1217   case 189:
1218 #line 935 "perly.y"
1219     { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); ;}
1220     break;
1221
1222   case 190:
1223 #line 937 "perly.y"
1224     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1225     break;
1226
1227   case 191:
1228 #line 939 "perly.y"
1229     { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); ;}
1230     break;
1231
1232   case 192:
1233 #line 941 "perly.y"
1234     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1235                                        scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); ;}
1236     break;
1237
1238   case 193:
1239 #line 944 "perly.y"
1240     { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); ;}
1241     break;
1242
1243   case 194:
1244 #line 946 "perly.y"
1245     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), OPf_SPECIAL);
1246                             PL_hints |= HINT_BLOCK_SCOPE; ;}
1247     break;
1248
1249   case 195:
1250 #line 949 "perly.y"
1251     { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1252     break;
1253
1254   case 196:
1255 #line 951 "perly.y"
1256     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
1257     break;
1258
1259   case 197:
1260 #line 953 "perly.y"
1261     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1262     break;
1263
1264   case 198:
1265 #line 955 "perly.y"
1266     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1267     break;
1268
1269   case 199:
1270 #line 957 "perly.y"
1271     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1272     break;
1273
1274   case 200:
1275 #line 959 "perly.y"
1276     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); ;}
1277     break;
1278
1279   case 201:
1280 #line 961 "perly.y"
1281     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); ;}
1282     break;
1283
1284   case 202:
1285 #line 963 "perly.y"
1286     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1287     break;
1288
1289   case 203:
1290 #line 965 "perly.y"
1291     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1292                             op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1293     break;
1294
1295   case 204:
1296 #line 968 "perly.y"
1297     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1298     break;
1299
1300   case 205:
1301 #line 970 "perly.y"
1302     { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);;}
1303     break;
1304
1305   case 206:
1306 #line 972 "perly.y"
1307     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1308     break;
1309
1310   case 207:
1311 #line 974 "perly.y"
1312     { (yyval.opval) = (ps[(1) - (3)].val.opval); ;}
1313     break;
1314
1315   case 208:
1316 #line 976 "perly.y"
1317     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1318     break;
1319
1320   case 209:
1321 #line 978 "perly.y"
1322     { (yyval.opval) = ((ps[(1) - (3)].val.ival) == OP_NOT)
1323                           ? newUNOP((ps[(1) - (3)].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1324                           : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); ;}
1325     break;
1326
1327   case 210:
1328 #line 982 "perly.y"
1329     { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
1330     break;
1331
1332   case 211:
1333 #line 984 "perly.y"
1334     {
1335                             if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
1336                                 && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
1337                                 && (((PMOP*)(ps[(1) - (1)].val.opval))->op_pmflags & PMf_HAS_CV))
1338                             {
1339                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1340                                 SAVEFREESV(PL_compcv);
1341                             } else
1342                                 (yyval.ival) = 0;
1343                         ;}
1344     break;
1345
1346   case 212:
1347 #line 995 "perly.y"
1348     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); ;}
1349     break;
1350
1351   case 215:
1352 #line 999 "perly.y"
1353     {
1354                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1355                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1356                         ;}
1357     break;
1358
1359   case 217:
1360 #line 1008 "perly.y"
1361     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); ;}
1362     break;
1363
1364   case 218:
1365 #line 1010 "perly.y"
1366     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1367     break;
1368
1369   case 219:
1370 #line 1015 "perly.y"
1371     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1372     break;
1373
1374   case 220:
1375 #line 1017 "perly.y"
1376     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1377     break;
1378
1379   case 221:
1380 #line 1020 "perly.y"
1381     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1382     break;
1383
1384   case 222:
1385 #line 1022 "perly.y"
1386     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1387     break;
1388
1389   case 223:
1390 #line 1024 "perly.y"
1391     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1392     break;
1393
1394   case 224:
1395 #line 1029 "perly.y"
1396     { (yyval.opval) = (OP*)NULL; ;}
1397     break;
1398
1399   case 225:
1400 #line 1031 "perly.y"
1401     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1402     break;
1403
1404   case 226:
1405 #line 1035 "perly.y"
1406     { (yyval.opval) = (OP*)NULL; ;}
1407     break;
1408
1409   case 227:
1410 #line 1037 "perly.y"
1411     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1412     break;
1413
1414   case 228:
1415 #line 1043 "perly.y"
1416     { parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1417     break;
1418
1419   case 234:
1420 #line 1056 "perly.y"
1421     { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1422     break;
1423
1424   case 235:
1425 #line 1060 "perly.y"
1426     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); ;}
1427     break;
1428
1429   case 236:
1430 #line 1064 "perly.y"
1431     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1432                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1433                         ;}
1434     break;
1435
1436   case 237:
1437 #line 1070 "perly.y"
1438     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1439                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1440                         ;}
1441     break;
1442
1443   case 238:
1444 #line 1076 "perly.y"
1445     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); ;}
1446     break;
1447
1448   case 239:
1449 #line 1078 "perly.y"
1450     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1451     break;
1452
1453   case 240:
1454 #line 1082 "perly.y"
1455     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); ;}
1456     break;
1457
1458   case 242:
1459 #line 1087 "perly.y"
1460     { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); ;}
1461     break;
1462
1463   case 244:
1464 #line 1092 "perly.y"
1465     { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); ;}
1466     break;
1467
1468   case 246:
1469 #line 1097 "perly.y"
1470     { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); ;}
1471     break;
1472
1473   case 247:
1474 #line 1102 "perly.y"
1475     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1476     break;
1477
1478   case 248:
1479 #line 1104 "perly.y"
1480     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1481     break;
1482
1483   case 249:
1484 #line 1106 "perly.y"
1485     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
1486     break;
1487
1488   case 250:
1489 #line 1109 "perly.y"
1490     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1491     break;
1492
1493
1494 /* Line 1267 of yacc.c.  */
1495
1496       default: break;
1497
1498
1499 /* Generated from:
1500  * aa8cc2f0979e92f76ac0fbc21000e975a6a443beed009e907eddb57f3d8dbe6a perly.y
1501  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
1502  * ex: set ro: */