Edit

IABSD.fr/src/gnu/usr.bin/perl/perly.act

Branch :

  • Show log

    Commit

  • Author : afresh1
    Date : 2023-02-15 01:36:12
    Hash : eac174f2
    Message : Fix merge issues, remove excess files - match perl-5.36.0 dist OK bluhm@ a good time naddy@

  • gnu/usr.bin/perl/perly.act
  • /* -*- buffer-read-only: t -*-
       !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
       This file is built by regen_perly.pl from perly.y.
       Any changes made here will be lost!
     */
    
    case 2:
    #line 140 "perly.y"
                            {
    			  parser->expect = XSTATE;
                              (yyval.ival) = 0;
    			}
    
        break;
    
      case 3:
    #line 145 "perly.y"
                            {
    			  newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
    			  PL_compiling.cop_seq = 0;
    			  (yyval.ival) = 0;
    			}
    
        break;
    
      case 4:
    #line 151 "perly.y"
                            {
    			  parser->expect = XTERM;
                              (yyval.ival) = 0;
    			}
    
        break;
    
      case 5:
    #line 156 "perly.y"
                            {
    			  PL_eval_root = (ps[0].val.opval);
    			  (yyval.ival) = 0;
    			}
    
        break;
    
      case 6:
    #line 161 "perly.y"
                            {
    			  parser->expect = XBLOCK;
                              (yyval.ival) = 0;
    			}
    
        break;
    
      case 7:
    #line 166 "perly.y"
                            {
    			  PL_pad_reset_pending = TRUE;
    			  PL_eval_root = (ps[0].val.opval);
    			  (yyval.ival) = 0;
    			  yyunlex();
    			  parser->yychar = yytoken = YYEOF;
    			}
    
        break;
    
      case 8:
    #line 174 "perly.y"
                            {
    			  parser->expect = XSTATE;
                              (yyval.ival) = 0;
    			}
    
        break;
    
      case 9:
    #line 179 "perly.y"
                            {
    			  PL_pad_reset_pending = TRUE;
    			  PL_eval_root = (ps[0].val.opval);
    			  (yyval.ival) = 0;
    			  yyunlex();
    			  parser->yychar = yytoken = YYEOF;
    			}
    
        break;
    
      case 10:
    #line 187 "perly.y"
                            {
    			  parser->expect = XSTATE;
                              (yyval.ival) = 0;
    			}
    
        break;
    
      case 11:
    #line 192 "perly.y"
                            {
    			  PL_pad_reset_pending = TRUE;
    			  PL_eval_root = (ps[0].val.opval);
    			  (yyval.ival) = 0;
    			  yyunlex();
    			  parser->yychar = yytoken = YYEOF;
    			}
    
        break;
    
      case 12:
    #line 200 "perly.y"
                            {
    			  parser->expect = XSTATE;
                              (yyval.ival) = 0;
    			}
    
        break;
    
      case 13:
    #line 205 "perly.y"
                            {
    			  PL_eval_root = (ps[0].val.opval);
    			  (yyval.ival) = 0;
    			}
    
        break;
    
      case 14:
    #line 210 "perly.y"
                            {
    			  parser->expect = XSTATE;
    			  (yyval.ival) = 0;
    			}
    
        break;
    
      case 15:
    #line 215 "perly.y"
                            {
    			  PL_eval_root = (ps[0].val.opval);
    			  (yyval.ival) = 0;
    			}
    
        break;
    
      case 16:
    #line 223 "perly.y"
                            { if (parser->copline > (line_t)(ps[-3].val.ival))
    			      parser->copline = (line_t)(ps[-3].val.ival);
    			  (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
    			}
    
        break;
    
      case 17:
    #line 230 "perly.y"
                                    { (yyval.opval) = NULL; }
    
        break;
    
      case 18:
    #line 235 "perly.y"
                            { if (parser->copline > (line_t)(ps[-6].val.ival))
    			      parser->copline = (line_t)(ps[-6].val.ival);
    			  (yyval.opval) = block_end((ps[-5].val.ival), (ps[-2].val.opval));
    			}
    
        break;
    
      case 19:
    #line 242 "perly.y"
                            { (yyval.ival) = block_start(TRUE);
    			  parser->parsed_sub = 0; }
    
        break;
    
      case 20:
    #line 247 "perly.y"
                            { if (parser->copline > (line_t)(ps[-3].val.ival))
    			      parser->copline = (line_t)(ps[-3].val.ival);
    			  (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
    			}
    
        break;
    
      case 21:
    #line 254 "perly.y"
                            { (yyval.ival) = block_start(FALSE);
    			  parser->parsed_sub = 0; }
    
        break;
    
      case 23:
    #line 262 "perly.y"
                            {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
    			    PL_pad_reset_pending = TRUE;
    			    if ((ps[-1].val.opval) && (ps[0].val.opval))
    				PL_hints |= HINT_BLOCK_SCOPE;
    			}
    
        break;
    
      case 25:
    #line 273 "perly.y"
                            {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
    			    PL_pad_reset_pending = TRUE;
    			    if ((ps[-1].val.opval) && (ps[0].val.opval))
    				PL_hints |= HINT_BLOCK_SCOPE;
    			}
    
        break;
    
      case 26:
    #line 282 "perly.y"
                            {
    			  (yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0, NULL, (ps[0].val.opval)) : NULL;
    			}
    
        break;
    
      case 27:
    #line 286 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 28:
    #line 290 "perly.y"
                            {
                              SV *label = cSVOPx_sv((ps[-1].val.opval));
    			  (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
                                                savepv(SvPVX_const(label)), (ps[0].val.opval));
                              op_free((ps[-1].val.opval));
    			}
    
        break;
    
      case 29:
    #line 297 "perly.y"
                            {
                              SV *label = cSVOPx_sv((ps[-1].val.opval));
    			  (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
                                                savepv(SvPVX_const(label)), (ps[0].val.opval));
                              op_free((ps[-1].val.opval));
    			}
    
        break;
    
      case 30:
    #line 307 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 31:
    #line 309 "perly.y"
                            {
    			  CV *fmtcv = PL_compcv;
    			  newFORM((ps[-2].val.ival), (ps[-1].val.opval), (ps[0].val.opval));
    			  (yyval.opval) = NULL;
    			  if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
    			      pad_add_weakref(fmtcv);
    			  }
    			  parser->parsed_sub = 1;
    			}
    
        break;
    
      case 32:
    #line 321 "perly.y"
                            {
                              init_named_cv(PL_compcv, (ps[-1].val.opval));
    			  parser->in_my = 0;
    			  parser->in_my_stash = NULL;
    			}
    
        break;
    
      case 33:
    #line 327 "perly.y"
                            {
    			  SvREFCNT_inc_simple_void(PL_compcv);
    			  (ps[-5].val.opval)->op_type == OP_CONST
    			      ? newATTRSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
    			      : newMYSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
    			  ;
    			  (yyval.opval) = NULL;
    			  intro_my();
    			  parser->parsed_sub = 1;
    			}
    
        break;
    
      case 34:
    #line 342 "perly.y"
                            {
                              init_named_cv(PL_compcv, (ps[-1].val.opval));
    			  parser->in_my = 0;
    			  parser->in_my_stash = NULL;
    			}
    
        break;
    
      case 35:
    #line 348 "perly.y"
                            {
    			  SvREFCNT_inc_simple_void(PL_compcv);
    			  (ps[-4].val.opval)->op_type == OP_CONST
    			      ? newATTRSUB((ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
    			      : newMYSUB(  (ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
    			  ;
    			  (yyval.opval) = NULL;
    			  intro_my();
    			  parser->parsed_sub = 1;
    			}
    
        break;
    
      case 36:
    #line 359 "perly.y"
                            {
    			  package((ps[-1].val.opval));
    			  if ((ps[-2].val.opval))
    			      package_version((ps[-2].val.opval));
    			  (yyval.opval) = NULL;
    			}
    
        break;
    
      case 37:
    #line 366 "perly.y"
                            { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
    
        break;
    
      case 38:
    #line 368 "perly.y"
                            {
    			  SvREFCNT_inc_simple_void(PL_compcv);
    			  utilize((ps[-6].val.ival), (ps[-5].val.ival), (ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
    			  parser->parsed_sub = 1;
    			  (yyval.opval) = NULL;
    			}
    
        break;
    
      case 39:
    #line 375 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-4].val.ival),
    			      newCONDOP(0, (ps[-3].val.opval), op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
    			  parser->copline = (line_t)(ps[-6].val.ival);
    			}
    
        break;
    
      case 40:
    #line 381 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-4].val.ival),
                                  newCONDOP(0, (ps[-3].val.opval), (ps[0].val.opval), op_scope((ps[-1].val.opval))));
    			  parser->copline = (line_t)(ps[-6].val.ival);
    			}
    
        break;
    
      case 41:
    #line 387 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-3].val.ival), newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
    			  parser->copline = (line_t)(ps[-5].val.ival);
    			}
    
        break;
    
      case 42:
    #line 392 "perly.y"
                            { (yyval.opval) = block_end((ps[-3].val.ival), newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
    
        break;
    
      case 43:
    #line 394 "perly.y"
                            { (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
    
        break;
    
      case 44:
    #line 396 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-5].val.ival),
    				  newWHILEOP(0, 1, NULL,
    				      (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
    			  parser->copline = (line_t)(ps[-7].val.ival);
    			}
    
        break;
    
      case 45:
    #line 403 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-5].val.ival),
    				  newWHILEOP(0, 1, NULL,
    				      (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
    			  parser->copline = (line_t)(ps[-7].val.ival);
    			}
    
        break;
    
      case 46:
    #line 410 "perly.y"
                            { parser->expect = XTERM; }
    
        break;
    
      case 47:
    #line 412 "perly.y"
                            { parser->expect = XTERM; }
    
        break;
    
      case 48:
    #line 415 "perly.y"
                            {
    			  OP *initop = (ps[-9].val.opval);
    			  OP *forop = newWHILEOP(0, 1, NULL,
    				      scalar((ps[-6].val.opval)), (ps[0].val.opval), (ps[-2].val.opval), (ps[-3].val.ival));
    			  if (initop) {
    			      forop = op_prepend_elem(OP_LINESEQ, initop,
    				  op_append_elem(OP_LINESEQ,
    				      newOP(OP_UNSTACK, OPf_SPECIAL),
    				      forop));
    			  }
    			  PL_hints |= HINT_BLOCK_SCOPE;
    			  (yyval.opval) = block_end((ps[-10].val.ival), forop);
    			  parser->copline = (line_t)(ps[-12].val.ival);
    			}
    
        break;
    
      case 49:
    #line 430 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-6].val.ival), newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
    			  parser->copline = (line_t)(ps[-8].val.ival);
    			}
    
        break;
    
      case 50:
    #line 435 "perly.y"
                            {
                              if ((ps[-6].val.opval)->op_type == OP_PADSV)
                                /* degenerate case of 1 var: for my ($x) ....
                                   Flag it so it can be special-cased in newFOROP */
                                    (ps[-6].val.opval)->op_flags |= OPf_PARENS;
    			  (yyval.opval) = block_end((ps[-8].val.ival), newFOROP(0, (ps[-6].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
    			  parser->copline = (line_t)(ps[-10].val.ival);
    			}
    
        break;
    
      case 51:
    #line 444 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(0,
    				      op_lvalue((ps[-6].val.opval), OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
    			  parser->copline = (line_t)(ps[-7].val.ival);
    			}
    
        break;
    
      case 52:
    #line 450 "perly.y"
                            { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
    
        break;
    
      case 53:
    #line 452 "perly.y"
                            {
    			  (yyval.opval) = block_end(
    				(ps[-7].val.ival),
    				newFOROP(0,
    					 op_lvalue(
    					    newUNOP(OP_REFGEN, 0,
    						    (ps[-5].val.opval)),
    					    OP_ENTERLOOP),
    					 (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
    			  );
    			  parser->copline = (line_t)(ps[-9].val.ival);
    			}
    
        break;
    
      case 54:
    #line 465 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
    				0, op_lvalue(newUNOP(OP_REFGEN, 0,
    						     (ps[-6].val.opval)),
    					     OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
    			  parser->copline = (line_t)(ps[-8].val.ival);
    			}
    
        break;
    
      case 55:
    #line 473 "perly.y"
                            {
    			  (yyval.opval) = block_end((ps[-4].val.ival),
    				  newFOROP(0, NULL, (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
    			  parser->copline = (line_t)(ps[-6].val.ival);
    			}
    
        break;
    
      case 56:
    #line 479 "perly.y"
                            { parser->in_my = 1; }
    
        break;
    
      case 57:
    #line 481 "perly.y"
                            { parser->in_my = 0; intro_my(); }
    
        break;
    
      case 58:
    #line 483 "perly.y"
                            {
    			  (yyval.opval) = newTRYCATCHOP(0,
    				  (ps[-9].val.opval), (ps[-4].val.opval), block_end((ps[-5].val.ival), op_scope((ps[-1].val.opval))));
    			  if((ps[0].val.opval))
    			      (yyval.opval) = op_wrap_finally((yyval.opval), (ps[0].val.opval));
    			  parser->copline = (line_t)(ps[-10].val.ival);
    			}
    
        break;
    
      case 59:
    #line 491 "perly.y"
                            {
    			  /* a block is a loop that happens once */
    			  (yyval.opval) = newWHILEOP(0, 1, NULL,
    				  NULL, (ps[-1].val.opval), (ps[0].val.opval), 0);
    			}
    
        break;
    
      case 60:
    #line 497 "perly.y"
                            {
    			  package((ps[-2].val.opval));
    			  if ((ps[-3].val.opval)) {
    			      package_version((ps[-3].val.opval));
    			  }
    			}
    
        break;
    
      case 61:
    #line 504 "perly.y"
                            {
    			  /* a block is a loop that happens once */
    			  (yyval.opval) = newWHILEOP(0, 1, NULL,
    				  NULL, block_end((ps[-3].val.ival), (ps[-1].val.opval)), NULL, 0);
    			  if (parser->copline > (line_t)(ps[-4].val.ival))
    			      parser->copline = (line_t)(ps[-4].val.ival);
    			}
    
        break;
    
      case 62:
    #line 512 "perly.y"
                            {
    			  (yyval.opval) = (ps[-1].val.opval);
    			}
    
        break;
    
      case 63:
    #line 516 "perly.y"
                            {
    			  (yyval.opval) = newDEFEROP(0, op_scope((ps[0].val.opval)));
    			}
    
        break;
    
      case 64:
    #line 520 "perly.y"
                            {
    			  (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
    				newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
    			}
    
        break;
    
      case 65:
    #line 525 "perly.y"
                            {
    			  (yyval.opval) = NULL;
    			  parser->copline = NOLINE;
    			}
    
        break;
    
      case 66:
    #line 533 "perly.y"
                            { OP *list;
    			  if ((ps[0].val.opval)) {
    			      OP *term = (ps[0].val.opval);
    			      list = op_append_elem(OP_LIST, (ps[-1].val.opval), term);
    			  }
    			  else {
    			      list = (ps[-1].val.opval);
    			  }
    			  if (parser->copline == NOLINE)
    			       parser->copline = CopLINE(PL_curcop)-1;
    			  else parser->copline--;
    			  (yyval.opval) = newSTATEOP(0, NULL,
    					  op_convert_list(OP_FORMLINE, 0, list));
    			}
    
        break;
    
      case 68:
    #line 552 "perly.y"
                            { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
    
        break;
    
      case 70:
    #line 560 "perly.y"
                            { (yyval.opval) = NULL; }
    
        break;
    
      case 71:
    #line 562 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 72:
    #line 564 "perly.y"
                            { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
    
        break;
    
      case 73:
    #line 566 "perly.y"
                            { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
    
        break;
    
      case 74:
    #line 568 "perly.y"
                            { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
    
        break;
    
      case 75:
    #line 570 "perly.y"
                            { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
    
        break;
    
      case 76:
    #line 572 "perly.y"
                            { (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
    			  parser->copline = (line_t)(ps[-1].val.ival); }
    
        break;
    
      case 77:
    #line 575 "perly.y"
                            { (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
    
        break;
    
      case 79:
    #line 582 "perly.y"
                            {
    			  ((ps[0].val.opval))->op_flags |= OPf_PARENS;
    			  (yyval.opval) = op_scope((ps[0].val.opval));
    			}
    
        break;
    
      case 80:
    #line 587 "perly.y"
                            { parser->copline = (line_t)(ps[-5].val.ival);
    			    (yyval.opval) = newCONDOP(0,
    				newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
    				op_scope((ps[-1].val.opval)), (ps[0].val.opval));
    			  PL_hints |= HINT_BLOCK_SCOPE;
    			}
    
        break;
    
      case 82:
    #line 599 "perly.y"
                            { (yyval.opval) = op_scope((ps[0].val.opval)); }
    
        break;
    
      case 83:
    #line 604 "perly.y"
                            { (yyval.opval) = NULL; }
    
        break;
    
      case 84:
    #line 606 "perly.y"
                            { (yyval.opval) = op_scope((ps[0].val.opval)); }
    
        break;
    
      case 85:
    #line 611 "perly.y"
                            { (yyval.ival) = (PL_min_intro_pending &&
    			    PL_max_intro_pending >=  PL_min_intro_pending);
    			  intro_my(); }
    
        break;
    
      case 88:
    #line 623 "perly.y"
                            { YYSTYPE tmplval;
    			  (void)scan_num("1", &tmplval);
    			  (yyval.opval) = tmplval.opval; }
    
        break;
    
      case 90:
    #line 631 "perly.y"
                            { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
    
        break;
    
      case 91:
    #line 636 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); intro_my(); }
    
        break;
    
      case 92:
    #line 640 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); intro_my(); }
    
        break;
    
      case 93:
    #line 643 "perly.y"
                                    { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 95:
    #line 648 "perly.y"
                            { (yyval.ival) = start_subparse(FALSE, 0);
    			    SAVEFREESV(PL_compcv); }
    
        break;
    
      case 96:
    #line 654 "perly.y"
                            { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
    			    SAVEFREESV(PL_compcv); }
    
        break;
    
      case 97:
    #line 659 "perly.y"
                            { (yyval.ival) = start_subparse(TRUE, 0);
    			    SAVEFREESV(PL_compcv); }
    
        break;
    
      case 103:
    #line 678 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 104:
    #line 680 "perly.y"
                            { (yyval.opval) = NULL; }
    
        break;
    
      case 105:
    #line 685 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 106:
    #line 687 "perly.y"
                            { (yyval.opval) = NULL; }
    
        break;
    
      case 107:
    #line 698 "perly.y"
                            { parser->in_my = 0; (yyval.opval) = NULL; }
    
        break;
    
      case 108:
    #line 700 "perly.y"
                            { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 109:
    #line 705 "perly.y"
                            { (yyval.ival) = '@'; }
    
        break;
    
      case 110:
    #line 707 "perly.y"
                            { (yyval.ival) = '%'; }
    
        break;
    
      case 111:
    #line 711 "perly.y"
                            {
                                I32 sigil   = (ps[-2].val.ival);
                                OP *var     = (ps[-1].val.opval);
                                OP *defexpr = (ps[0].val.opval);
    
                                if (parser->sig_slurpy)
                                    yyerror("Multiple slurpy parameters not allowed");
                                parser->sig_slurpy = (char)sigil;
    
                                if (defexpr)
                                    yyerror("A slurpy parameter may not have "
                                            "a default value");
    
                                (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
                            }
    
        break;
    
      case 113:
    #line 732 "perly.y"
                            { (yyval.opval) = newOP(OP_NULL, 0); }
    
        break;
    
      case 114:
    #line 734 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 115:
    #line 740 "perly.y"
                            {
                                OP *var     = (ps[-1].val.opval);
                                OP *defexpr = (ps[0].val.opval);
    
                                if (parser->sig_slurpy)
                                    yyerror("Slurpy parameter not last");
    
                                parser->sig_elems++;
    
                                if (defexpr) {
                                    parser->sig_optelems++;
    
                                    if (   defexpr->op_type == OP_NULL
                                        && !(defexpr->op_flags & OPf_KIDS))
                                    {
                                        /* handle '$=' special case */
                                        if (var)
                                            yyerror("Optional parameter "
                                                        "lacks default expression");
                                        op_free(defexpr);
                                    }
                                    else { 
                                        /* a normal '=default' expression */ 
                                        OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
                                                            defexpr,
                                                            LINKLIST(defexpr));
                                        /* re-purpose op_targ to hold @_ index */
                                        defop->op_targ =
                                            (PADOFFSET)(parser->sig_elems - 1);
    
                                        if (var) {
                                            var->op_flags |= OPf_STACKED;
                                            (void)op_sibling_splice(var,
                                                            NULL, 0, defop);
                                            scalar(defop);
                                        }
                                        else
                                            var = newUNOP(OP_NULL, 0, defop);
    
                                        LINKLIST(var);
                                        /* NB: normally the first child of a
                                         * logop is executed before the logop,
                                         * and it pushes a boolean result
                                         * ready for the logop. For ARGDEFELEM,
                                         * the op itself does the boolean
                                         * calculation, so set the first op to
                                         * it instead.
                                         */
                                        var->op_next = defop;
                                        defexpr->op_next = var;
                                    }
                                }
                                else {
                                    if (parser->sig_optelems)
                                        yyerror("Mandatory parameter "
                                                "follows optional parameter");
                                }
    
                                (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
                            }
    
        break;
    
      case 116:
    #line 805 "perly.y"
                            { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 117:
    #line 807 "perly.y"
                            { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 118:
    #line 813 "perly.y"
                            { (yyval.opval) = (ps[-1].val.opval); }
    
        break;
    
      case 119:
    #line 815 "perly.y"
                            {
    			  (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
    			}
    
        break;
    
      case 120:
    #line 819 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 125:
    #line 836 "perly.y"
                            { (yyval.opval) = (ps[-1].val.opval); }
    
        break;
    
      case 126:
    #line 839 "perly.y"
                            {
                                ENTER;
                                SAVEIV(parser->sig_elems);
                                SAVEIV(parser->sig_optelems);
                                SAVEI8(parser->sig_slurpy);
                                parser->sig_elems    = 0;
                                parser->sig_optelems = 0;
                                parser->sig_slurpy   = 0;
                                parser->in_my        = KEY_sigvar;
                            }
    
        break;
    
      case 127:
    #line 850 "perly.y"
                            {
                                OP            *sigops = (ps[0].val.opval);
                                struct op_argcheck_aux *aux;
                                OP            *check;
    
    			    if (!FEATURE_SIGNATURES_IS_ENABLED)
    			        Perl_croak(aTHX_ "Experimental "
                                        "subroutine signatures not enabled");
    
                                /* We shouldn't get here otherwise */
                                aux = (struct op_argcheck_aux*)
                                        PerlMemShared_malloc(
                                            sizeof(struct op_argcheck_aux));
                                aux->params     = parser->sig_elems;
                                aux->opt_params = parser->sig_optelems;
                                aux->slurpy     = parser->sig_slurpy;
                                check = newUNOP_AUX(OP_ARGCHECK, 0, NULL,
                                                (UNOP_AUX_item *)aux);
                                sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
                                sigops = op_prepend_elem(OP_LINESEQ,
                                                    newSTATEOP(0, NULL, NULL),
                                                    sigops);
                                /* a nextstate at the end handles context
                                 * correctly for an empty sub body */
                                sigops = op_append_elem(OP_LINESEQ,
                                                    sigops,
                                                    newSTATEOP(0, NULL, NULL));
                                /* wrap the list of arg ops in a NULL aux op.
                                  This serves two purposes. First, it makes
                                  the arg list a separate subtree from the
                                  body of the sub, and secondly the null op
                                  may in future be upgraded to an OP_SIGNATURE
                                  when implemented. For now leave it as
                                  ex-argcheck */
                                (yyval.opval) = newUNOP_AUX(OP_ARGCHECK, 0, sigops, NULL);
                                op_null((yyval.opval));
    
    			    CvSIGNATURE_on(PL_compcv);
    
                                parser->in_my = 0;
                                /* tell the toker that attrributes can follow
                                 * this sig, but only so that the toker
                                 * can skip through any (illegal) trailing
                                 * attribute text then give a useful error
                                 * message about "attributes before sig",
                                 * rather than falling over ina mess at
                                 * unrecognised syntax.
                                 */
                                parser->expect = XATTRBLOCK;
                                parser->sig_seen = TRUE;
                                LEAVE;
    			}
    
        break;
    
      case 129:
    #line 907 "perly.y"
                                    { (yyval.opval) = NULL; }
    
        break;
    
      case 130:
    #line 913 "perly.y"
                            {
    			  if (parser->copline > (line_t)(ps[-2].val.ival))
    			      parser->copline = (line_t)(ps[-2].val.ival);
    			  (yyval.opval) = block_end((ps[-3].val.ival), (ps[-1].val.opval));
    			}
    
        break;
    
      case 132:
    #line 925 "perly.y"
                                       { (yyval.opval) = NULL; }
    
        break;
    
      case 133:
    #line 930 "perly.y"
                            {
    			  if (parser->copline > (line_t)(ps[-2].val.ival))
    			      parser->copline = (line_t)(ps[-2].val.ival);
    			  (yyval.opval) = block_end((ps[-4].val.ival),
    				op_append_list(OP_LINESEQ, (ps[-3].val.opval), (ps[-1].val.opval)));
     			}
    
        break;
    
      case 134:
    #line 941 "perly.y"
                            { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 135:
    #line 943 "perly.y"
                            { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 137:
    #line 949 "perly.y"
                            { (yyval.opval) = (ps[-1].val.opval); }
    
        break;
    
      case 138:
    #line 951 "perly.y"
                            {
    			  OP* term = (ps[0].val.opval);
    			  (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
    			}
    
        break;
    
      case 140:
    #line 960 "perly.y"
                            { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
    				op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
    			}
    
        break;
    
      case 141:
    #line 964 "perly.y"
                            { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
    				op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
    			}
    
        break;
    
      case 142:
    #line 968 "perly.y"
                            { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
    				op_append_elem(OP_LIST,
    				    op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
    				    newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
    			}
    
        break;
    
      case 143:
    #line 974 "perly.y"
                            { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
    				op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
    				    newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
    			}
    
        break;
    
      case 144:
    #line 979 "perly.y"
                            { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
    				op_append_elem(OP_LIST,
    				    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
    				    newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
    			}
    
        break;
    
      case 145:
    #line 985 "perly.y"
                            { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
    				op_append_elem(OP_LIST,
    				    op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
    				    newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
    			}
    
        break;
    
      case 146:
    #line 991 "perly.y"
                            { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
    
        break;
    
      case 147:
    #line 993 "perly.y"
                            { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
    
        break;
    
      case 148:
    #line 995 "perly.y"
                            { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
    
        break;
    
      case 149:
    #line 997 "perly.y"
                            { SvREFCNT_inc_simple_void(PL_compcv);
    			  (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
    
        break;
    
      case 150:
    #line 1000 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    				 op_append_elem(OP_LIST,
    				   op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
    			}
    
        break;
    
      case 153:
    #line 1015 "perly.y"
                            { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
    
        break;
    
      case 154:
    #line 1017 "perly.y"
                            { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
    			}
    
        break;
    
      case 155:
    #line 1020 "perly.y"
                            { (yyval.opval) = newBINOP(OP_AELEM, 0,
    					ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
    					scalar((ps[-1].val.opval)));
    			}
    
        break;
    
      case 156:
    #line 1025 "perly.y"
                            { (yyval.opval) = newBINOP(OP_AELEM, 0,
    					ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
    					scalar((ps[-1].val.opval)));
    			}
    
        break;
    
      case 157:
    #line 1030 "perly.y"
                            { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
    			}
    
        break;
    
      case 158:
    #line 1033 "perly.y"
                            { (yyval.opval) = newBINOP(OP_HELEM, 0,
    					ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
    					jmaybe((ps[-2].val.opval))); }
    
        break;
    
      case 159:
    #line 1037 "perly.y"
                            { (yyval.opval) = newBINOP(OP_HELEM, 0,
    					ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
    					jmaybe((ps[-2].val.opval))); }
    
        break;
    
      case 160:
    #line 1041 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    				   newCVREF(0, scalar((ps[-3].val.opval))));
    			  if (parser->expect == XBLOCK)
    			      parser->expect = XOPERATOR;
    			}
    
        break;
    
      case 161:
    #line 1047 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    				   op_append_elem(OP_LIST, (ps[-1].val.opval),
    				       newCVREF(0, scalar((ps[-4].val.opval)))));
    			  if (parser->expect == XBLOCK)
    			      parser->expect = XOPERATOR;
    			}
    
        break;
    
      case 162:
    #line 1055 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    				   op_append_elem(OP_LIST, (ps[-1].val.opval),
    					       newCVREF(0, scalar((ps[-3].val.opval)))));
    			  if (parser->expect == XBLOCK)
    			      parser->expect = XOPERATOR;
    			}
    
        break;
    
      case 163:
    #line 1062 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    				   newCVREF(0, scalar((ps[-2].val.opval))));
    			  if (parser->expect == XBLOCK)
    			      parser->expect = XOPERATOR;
    			}
    
        break;
    
      case 164:
    #line 1068 "perly.y"
                            { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
    
        break;
    
      case 165:
    #line 1070 "perly.y"
                            { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
    
        break;
    
      case 166:
    #line 1072 "perly.y"
                            { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
    
        break;
    
      case 167:
    #line 1077 "perly.y"
                            { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
    
        break;
    
      case 168:
    #line 1079 "perly.y"
                            { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 169:
    #line 1081 "perly.y"
                            {   if ((ps[-1].val.ival) != OP_REPEAT)
    				scalar((ps[-2].val.opval));
    			    (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
    			}
    
        break;
    
      case 170:
    #line 1086 "perly.y"
                            { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 171:
    #line 1088 "perly.y"
                            { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 172:
    #line 1090 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 173:
    #line 1092 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 174:
    #line 1094 "perly.y"
                            { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 175:
    #line 1096 "perly.y"
                            { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 176:
    #line 1098 "perly.y"
                            { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 177:
    #line 1100 "perly.y"
                            { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 178:
    #line 1102 "perly.y"
                            { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 179:
    #line 1104 "perly.y"
                            { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 180:
    #line 1106 "perly.y"
                            { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 181:
    #line 1110 "perly.y"
                            { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
    
        break;
    
      case 182:
    #line 1112 "perly.y"
                            { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 183:
    #line 1114 "perly.y"
                            { yyerror("syntax error"); YYERROR; }
    
        break;
    
      case 184:
    #line 1116 "perly.y"
                            { yyerror("syntax error"); YYERROR; }
    
        break;
    
      case 185:
    #line 1120 "perly.y"
                            { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 186:
    #line 1122 "perly.y"
                            { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 187:
    #line 1126 "perly.y"
                            { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
    
        break;
    
      case 188:
    #line 1128 "perly.y"
                            { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
    
        break;
    
      case 189:
    #line 1130 "perly.y"
                            { yyerror("syntax error"); YYERROR; }
    
        break;
    
      case 190:
    #line 1132 "perly.y"
                            { yyerror("syntax error"); YYERROR; }
    
        break;
    
      case 191:
    #line 1136 "perly.y"
                            { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 192:
    #line 1138 "perly.y"
                            { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 193:
    #line 1143 "perly.y"
                            { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
    
        break;
    
      case 194:
    #line 1145 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 195:
    #line 1148 "perly.y"
                            { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
    
        break;
    
      case 196:
    #line 1150 "perly.y"
                            { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
    
        break;
    
      case 197:
    #line 1152 "perly.y"
                            { (yyval.opval) = newUNOP(OP_POSTINC, 0,
    					op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
    
        break;
    
      case 198:
    #line 1155 "perly.y"
                            { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
    					op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
    
        break;
    
      case 199:
    #line 1158 "perly.y"
                            { (yyval.opval) = op_convert_list(OP_JOIN, 0,
    				       op_append_elem(
    					OP_LIST,
    					newSVREF(scalar(
    					    newSVOP(OP_CONST,0,
    						    newSVpvs("\""))
    					)),
    					(ps[-1].val.opval)
    				       ));
    			}
    
        break;
    
      case 200:
    #line 1169 "perly.y"
                            { (yyval.opval) = newUNOP(OP_PREINC, 0,
    					op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
    
        break;
    
      case 201:
    #line 1172 "perly.y"
                            { (yyval.opval) = newUNOP(OP_PREDEC, 0,
    					op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
    
        break;
    
      case 202:
    #line 1180 "perly.y"
                            { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
    
        break;
    
      case 203:
    #line 1182 "perly.y"
                            { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
    
        break;
    
      case 204:
    #line 1184 "perly.y"
                            { SvREFCNT_inc_simple_void(PL_compcv);
    			  (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 205:
    #line 1187 "perly.y"
                            { SvREFCNT_inc_simple_void(PL_compcv);
    			  (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 206:
    #line 1193 "perly.y"
                            { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
    
        break;
    
      case 207:
    #line 1195 "perly.y"
                            { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
    
        break;
    
      case 212:
    #line 1203 "perly.y"
                            { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
    
        break;
    
      case 213:
    #line 1205 "perly.y"
                            { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
    
        break;
    
      case 214:
    #line 1207 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 215:
    #line 1209 "perly.y"
                            { (yyval.opval) = localize((ps[0].val.opval),0); }
    
        break;
    
      case 216:
    #line 1211 "perly.y"
                            { (yyval.opval) = sawparens((ps[-1].val.opval)); }
    
        break;
    
      case 217:
    #line 1213 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 218:
    #line 1215 "perly.y"
                            { (yyval.opval) = sawparens(newNULLLIST()); }
    
        break;
    
      case 219:
    #line 1217 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 220:
    #line 1219 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 221:
    #line 1221 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 222:
    #line 1223 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 223:
    #line 1225 "perly.y"
                            { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
    
        break;
    
      case 224:
    #line 1227 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 225:
    #line 1229 "perly.y"
                            { (yyval.opval) = op_prepend_elem(OP_ASLICE,
    				newOP(OP_PUSHMARK, 0),
    				    newLISTOP(OP_ASLICE, 0,
    					list((ps[-1].val.opval)),
    					ref((ps[-3].val.opval), OP_ASLICE)));
    			  if ((yyval.opval) && (ps[-3].val.opval))
    			      (yyval.opval)->op_private |=
    				  (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
    			}
    
        break;
    
      case 226:
    #line 1239 "perly.y"
                            { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
    				newOP(OP_PUSHMARK, 0),
    				    newLISTOP(OP_KVASLICE, 0,
    					list((ps[-1].val.opval)),
    					ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
    			  if ((yyval.opval) && (ps[-3].val.opval))
    			      (yyval.opval)->op_private |=
    				  (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
    			}
    
        break;
    
      case 227:
    #line 1249 "perly.y"
                            { (yyval.opval) = op_prepend_elem(OP_HSLICE,
    				newOP(OP_PUSHMARK, 0),
    				    newLISTOP(OP_HSLICE, 0,
    					list((ps[-2].val.opval)),
    					ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
    			  if ((yyval.opval) && (ps[-4].val.opval))
    			      (yyval.opval)->op_private |=
    				  (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
    			}
    
        break;
    
      case 228:
    #line 1259 "perly.y"
                            { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
    				newOP(OP_PUSHMARK, 0),
    				    newLISTOP(OP_KVHSLICE, 0,
    					list((ps[-2].val.opval)),
    					ref((ps[-4].val.opval), OP_KVHSLICE)));
    			  if ((yyval.opval) && (ps[-4].val.opval))
    			      (yyval.opval)->op_private |=
    				  (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
    			}
    
        break;
    
      case 229:
    #line 1269 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 230:
    #line 1271 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
    
        break;
    
      case 231:
    #line 1273 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
    			}
    
        break;
    
      case 232:
    #line 1276 "perly.y"
                            {
    			  (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    				op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
    			}
    
        break;
    
      case 233:
    #line 1281 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    			    op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
    			}
    
        break;
    
      case 234:
    #line 1285 "perly.y"
                            { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
    
        break;
    
      case 235:
    #line 1287 "perly.y"
                            { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
    
        break;
    
      case 236:
    #line 1289 "perly.y"
                            { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
    
        break;
    
      case 237:
    #line 1291 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
    				       scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
    
        break;
    
      case 238:
    #line 1294 "perly.y"
                            { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
    
        break;
    
      case 239:
    #line 1296 "perly.y"
                            { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
    			    PL_hints |= HINT_BLOCK_SCOPE; }
    
        break;
    
      case 240:
    #line 1299 "perly.y"
                            { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
    
        break;
    
      case 241:
    #line 1301 "perly.y"
                            { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
    
        break;
    
      case 242:
    #line 1303 "perly.y"
                            { (yyval.opval) = newOP((ps[0].val.ival), 0); }
    
        break;
    
      case 243:
    #line 1305 "perly.y"
                            { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
    
        break;
    
      case 244:
    #line 1307 "perly.y"
                            { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
    
        break;
    
      case 245:
    #line 1309 "perly.y"
                            { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
    
        break;
    
      case 246:
    #line 1311 "perly.y"
                            { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
    
        break;
    
      case 247:
    #line 1313 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
    
        break;
    
      case 248:
    #line 1315 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
    			    op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
    
        break;
    
      case 249:
    #line 1318 "perly.y"
                            { (yyval.opval) = newOP((ps[0].val.ival), 0); }
    
        break;
    
      case 250:
    #line 1320 "perly.y"
                            { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
    
        break;
    
      case 251:
    #line 1322 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 252:
    #line 1324 "perly.y"
                            { (yyval.opval) = (ps[-2].val.opval); }
    
        break;
    
      case 253:
    #line 1326 "perly.y"
                            { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
    
        break;
    
      case 254:
    #line 1328 "perly.y"
                            { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
                              ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
                              : newOP((ps[-2].val.ival), OPf_SPECIAL); }
    
        break;
    
      case 255:
    #line 1332 "perly.y"
                            { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
    
        break;
    
      case 256:
    #line 1334 "perly.y"
                            {
    			    if (   (ps[0].val.opval)->op_type != OP_TRANS
    			        && (ps[0].val.opval)->op_type != OP_TRANSR
    				&& (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
    			    {
    				(yyval.ival) = start_subparse(FALSE, CVf_ANON);
    				SAVEFREESV(PL_compcv);
    			    } else
    				(yyval.ival) = 0;
    			}
    
        break;
    
      case 257:
    #line 1345 "perly.y"
                            { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
    
        break;
    
      case 261:
    #line 1354 "perly.y"
                            { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
    
        break;
    
      case 262:
    #line 1356 "perly.y"
                            { (yyval.opval) = localize((ps[0].val.opval),1); }
    
        break;
    
      case 263:
    #line 1358 "perly.y"
                            { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
    
        break;
    
      case 264:
    #line 1360 "perly.y"
                            { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
    
        break;
    
      case 265:
    #line 1365 "perly.y"
                            { (yyval.opval) = sawparens((ps[-1].val.opval)); }
    
        break;
    
      case 266:
    #line 1367 "perly.y"
                            { (yyval.opval) = sawparens(newNULLLIST()); }
    
        break;
    
      case 267:
    #line 1370 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 268:
    #line 1372 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 269:
    #line 1374 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 275:
    #line 1390 "perly.y"
                                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 276:
    #line 1396 "perly.y"
                            { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
    
        break;
    
      case 277:
    #line 1401 "perly.y"
                            { (yyval.opval) = (ps[-1].val.opval); }
    
        break;
    
      case 278:
    #line 1403 "perly.y"
                            {
    			  (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), (ps[0].val.opval));
    			}
    
        break;
    
      case 280:
    #line 1410 "perly.y"
                            { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
      case 288:
    #line 1427 "perly.y"
                            { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
    
        break;
    
      case 289:
    #line 1431 "perly.y"
                            { (yyval.opval) = newSVREF((ps[0].val.opval)); }
    
        break;
    
      case 290:
    #line 1435 "perly.y"
                            { (yyval.opval) = newAVREF((ps[0].val.opval));
    			  if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
    			}
    
        break;
    
      case 291:
    #line 1441 "perly.y"
                            { (yyval.opval) = newHVREF((ps[0].val.opval));
    			  if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
    			}
    
        break;
    
      case 292:
    #line 1447 "perly.y"
                            { (yyval.opval) = newAVREF((ps[0].val.opval)); }
    
        break;
    
      case 293:
    #line 1449 "perly.y"
                            { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
    
        break;
    
      case 294:
    #line 1453 "perly.y"
                            { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
    
        break;
    
      case 296:
    #line 1458 "perly.y"
                            { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
    
        break;
    
      case 298:
    #line 1463 "perly.y"
                            { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
    
        break;
    
      case 300:
    #line 1468 "perly.y"
                            { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
    
        break;
    
      case 301:
    #line 1473 "perly.y"
                            { (yyval.opval) = scalar((ps[0].val.opval)); }
    
        break;
    
      case 302:
    #line 1475 "perly.y"
                            { (yyval.opval) = scalar((ps[0].val.opval)); }
    
        break;
    
      case 303:
    #line 1477 "perly.y"
                            { (yyval.opval) = op_scope((ps[0].val.opval)); }
    
        break;
    
      case 304:
    #line 1480 "perly.y"
                            { (yyval.opval) = (ps[0].val.opval); }
    
        break;
    
    
    
    
          default: break;
        
    
    /* Generated from:
     * 0caf1eb1cc4750131dc71e3a22ead383ed9a123dec61ccd23408ff13441fafde perly.y
     * acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
     * ex: set ro: */