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