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