LXR perl/perly.act

   1case 2:
   2#line 142 "perly.y"
   3    { (yyval.ival) = (ps[(1) - (2)].val.ival); newPROG(block_end((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval))); ;}
   4    break;
   5
   6  case 3:
   7#line 147 "perly.y"
   8    { if (PL_parser->copline > (line_t)IVAL((ps[(1) - (4)].val.i_tkval)))
   9                              PL_parser->copline = (line_t)IVAL((ps[(1) - (4)].val.i_tkval));
  10                          (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
  11                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
  12                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
  13                        ;}
  14    break;
  15
  16  case 4:
  17#line 156 "perly.y"
  18    { (yyval.ival) = block_start(TRUE); ;}
  19    break;
  20
  21  case 5:
  22#line 160 "perly.y"
  23    { (yyval.ival) = (I32) allocmy("$_"); ;}
  24    break;
  25
  26  case 6:
  27#line 164 "perly.y"
  28    {
  29                    PL_parser->expect = XSTATE; (yyval.ival) = block_start(TRUE);
  30                ;}
  31    break;
  32
  33  case 7:
  34#line 171 "perly.y"
  35    { if (PL_parser->copline > (line_t)IVAL((ps[(1) - (4)].val.i_tkval)))
  36                              PL_parser->copline = (line_t)IVAL((ps[(1) - (4)].val.i_tkval));
  37                          (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
  38                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
  39                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
  40                        ;}
  41    break;
  42
  43  case 8:
  44#line 180 "perly.y"
  45    { (yyval.ival) = block_start(FALSE); ;}
  46    break;
  47
  48  case 9:
  49#line 185 "perly.y"
  50    { (yyval.opval) = (OP*)NULL; ;}
  51    break;
  52
  53  case 10:
  54#line 187 "perly.y"
  55    {
  56                        (yyval.opval) = IF_MAD(
  57                                append_list(OP_LINESEQ,
  58                                    (LISTOP*)(ps[(1) - (2)].val.opval), (LISTOP*)(ps[(2) - (2)].val.opval)),
  59                                (ps[(1) - (2)].val.opval));
  60                        ;}
  61    break;
  62
  63  case 11:
  64#line 194 "perly.y"
  65    {   (yyval.opval) = append_list(OP_LINESEQ,
  66                                (LISTOP*)(ps[(1) - (2)].val.opval), (LISTOP*)(ps[(2) - (2)].val.opval));
  67                            PL_pad_reset_pending = TRUE;
  68                            if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
  69                                PL_hints |= HINT_BLOCK_SCOPE;
  70                        ;}
  71    break;
  72
  73  case 12:
  74#line 204 "perly.y"
  75    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval));
  76                          TOKEN_GETMAD((ps[(1) - (2)].val.p_tkval),((LISTOP*)(yyval.opval))->op_first,'L'); ;}
  77    break;
  78
  79  case 14:
  80#line 208 "perly.y"
  81    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
  82    break;
  83
  84  case 15:
  85#line 210 "perly.y"
  86    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval)); ;}
  87    break;
  88
  89  case 16:
  90#line 212 "perly.y"
  91    {
  92                          if (PVAL((ps[(1) - (2)].val.p_tkval))) {
  93                              (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), newOP(OP_NULL, 0));
  94                              TOKEN_GETMAD((ps[(1) - (2)].val.p_tkval),(yyval.opval),'L');
  95                              TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),((LISTOP*)(yyval.opval))->op_first,';');
  96                          }
  97                          else {
  98                              (yyval.opval) = IF_MAD(
  99                                        newOP(OP_NULL, 0),
 100                                        (OP*)NULL);
 101                              PL_parser->copline = NOLINE;
 102                              TOKEN_FREE((ps[(1) - (2)].val.p_tkval));
 103                              TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),';');
 104                          }
 105                          PL_parser->expect = XSTATE;
 106                        ;}
 107    break;
 108
 109  case 17:
 110#line 229 "perly.y"
 111    {
 112                          (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (3)].val.p_tkval)), (ps[(2) - (3)].val.opval));
 113                          PL_parser->expect = XSTATE;
 114                          DO_MAD({
 115                              /* sideff might already have a nexstate */
 116                              OP* op = ((LISTOP*)(yyval.opval))->op_first;
 117                              if (op) {
 118                                  while (op->op_sibling &&
 119                                     op->op_sibling->op_type == OP_NEXTSTATE)
 120                                        op = op->op_sibling;
 121                                  token_getmad((ps[(1) - (3)].val.p_tkval),op,'L');
 122                                  token_getmad((ps[(3) - (3)].val.i_tkval),op,';');
 123                              }
 124                          })
 125                        ;}
 126    break;
 127
 128  case 18:
 129#line 248 "perly.y"
 130    { (yyval.opval) = (OP*)NULL; ;}
 131    break;
 132
 133  case 19:
 134#line 250 "perly.y"
 135    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 136    break;
 137
 138  case 20:
 139#line 252 "perly.y"
 140    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
 141                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
 142                        ;}
 143    break;
 144
 145  case 21:
 146#line 256 "perly.y"
 147    { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
 148                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
 149                        ;}
 150    break;
 151
 152  case 22:
 153#line 260 "perly.y"
 154    { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval));
 155                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
 156                        ;}
 157    break;
 158
 159  case 23:
 160#line 264 "perly.y"
 161    { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
 162                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
 163                        ;}
 164    break;
 165
 166  case 24:
 167#line 268 "perly.y"
 168    { (yyval.opval) = newFOROP(0, NULL, (line_t)IVAL((ps[(2) - (3)].val.i_tkval)),
 169                                        (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
 170                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),((LISTOP*)(yyval.opval))->op_first->op_sibling,'w');
 171                        ;}
 172    break;
 173
 174  case 25:
 175#line 276 "perly.y"
 176    { (yyval.opval) = (OP*)NULL; ;}
 177    break;
 178
 179  case 26:
 180#line 278 "perly.y"
 181    { ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS; (yyval.opval) = scope((ps[(2) - (2)].val.opval));
 182                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
 183                        ;}
 184    break;
 185
 186  case 27:
 187#line 282 "perly.y"
 188    { PL_parser->copline = (line_t)IVAL((ps[(1) - (6)].val.i_tkval));
 189                            (yyval.opval) = newCONDOP(0, newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)), scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
 190                            PL_hints |= HINT_BLOCK_SCOPE;
 191                          TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'I');
 192                          TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'(');
 193                          TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),')');
 194                        ;}
 195    break;
 196
 197  case 28:
 198#line 293 "perly.y"
 199    { PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
 200                            (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 201                                   newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 202                          TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
 203                          TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
 204                          TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
 205                        ;}
 206    break;
 207
 208  case 29:
 209#line 301 "perly.y"
 210    { PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
 211                            (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 212                                   newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 213                          TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
 214                          TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
 215                          TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
 216                        ;}
 217    break;
 218
 219  case 30:
 220#line 312 "perly.y"
 221    { (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
 222                newWHENOP((ps[(4) - (6)].val.opval), scope((ps[(6) - (6)].val.opval)))); ;}
 223    break;
 224
 225  case 31:
 226#line 315 "perly.y"
 227    { (yyval.opval) = newWHENOP(0, scope((ps[(2) - (2)].val.opval))); ;}
 228    break;
 229
 230  case 32:
 231#line 320 "perly.y"
 232    { (yyval.opval) = (OP*)NULL; ;}
 233    break;
 234
 235  case 33:
 236#line 322 "perly.y"
 237    { (yyval.opval) = scope((ps[(2) - (2)].val.opval));
 238                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
 239                        ;}
 240    break;
 241
 242  case 34:
 243#line 329 "perly.y"
 244    { OP *innerop;
 245                          PL_parser->copline = (line_t)(ps[(2) - (9)].val.i_tkval);
 246                            (yyval.opval) = block_end((ps[(4) - (9)].val.ival),
 247                                   newSTATEOP(0, PVAL((ps[(1) - (9)].val.p_tkval)),
 248                                     innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 249                                                IVAL((ps[(2) - (9)].val.i_tkval)), (ps[(5) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval), (ps[(7) - (9)].val.ival))));
 250                          TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),innerop,'L');
 251                          TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),innerop,'W');
 252                          TOKEN_GETMAD((ps[(3) - (9)].val.i_tkval),innerop,'(');
 253                          TOKEN_GETMAD((ps[(6) - (9)].val.i_tkval),innerop,')');
 254                        ;}
 255    break;
 256
 257  case 35:
 258#line 342 "perly.y"
 259    { OP *innerop;
 260                          PL_parser->copline = (line_t)(ps[(2) - (9)].val.i_tkval);
 261                            (yyval.opval) = block_end((ps[(4) - (9)].val.ival),
 262                                   newSTATEOP(0, PVAL((ps[(1) - (9)].val.p_tkval)),
 263                                     innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 264                                                IVAL((ps[(2) - (9)].val.i_tkval)), (ps[(5) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval), (ps[(7) - (9)].val.ival))));
 265                          TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),innerop,'L');
 266                          TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),innerop,'W');
 267                          TOKEN_GETMAD((ps[(3) - (9)].val.i_tkval),innerop,'(');
 268                          TOKEN_GETMAD((ps[(6) - (9)].val.i_tkval),innerop,')');
 269                        ;}
 270    break;
 271
 272  case 36:
 273#line 354 "perly.y"
 274    { OP *innerop;
 275                          (yyval.opval) = block_end((ps[(4) - (10)].val.ival),
 276                             innerop = newFOROP(0, PVAL((ps[(1) - (10)].val.p_tkval)), (line_t)IVAL((ps[(2) - (10)].val.i_tkval)),
 277                                            (ps[(5) - (10)].val.opval), (ps[(7) - (10)].val.opval), (ps[(9) - (10)].val.opval), (ps[(10) - (10)].val.opval)));
 278                          TOKEN_GETMAD((ps[(1) - (10)].val.p_tkval),((LISTOP*)innerop)->op_first,'L');
 279                          TOKEN_GETMAD((ps[(2) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
 280                          TOKEN_GETMAD((ps[(3) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'d');
 281                          TOKEN_GETMAD((ps[(6) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
 282                          TOKEN_GETMAD((ps[(8) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
 283                        ;}
 284    break;
 285
 286  case 37:
 287#line 365 "perly.y"
 288    { OP *innerop;
 289                          (yyval.opval) = block_end((ps[(5) - (9)].val.ival),
 290                             innerop = newFOROP(0, PVAL((ps[(1) - (9)].val.p_tkval)), (line_t)IVAL((ps[(2) - (9)].val.i_tkval)),
 291                                    mod((ps[(3) - (9)].val.opval), OP_ENTERLOOP), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
 292                          TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),((LISTOP*)innerop)->op_first,'L');
 293                          TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
 294                          TOKEN_GETMAD((ps[(4) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
 295                          TOKEN_GETMAD((ps[(7) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
 296                        ;}
 297    break;
 298
 299  case 38:
 300#line 375 "perly.y"
 301    { OP *innerop;
 302                          (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
 303                             innerop = newFOROP(0, PVAL((ps[(1) - (8)].val.p_tkval)), (line_t)IVAL((ps[(2) - (8)].val.i_tkval)),
 304                                                    (OP*)NULL, (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
 305                          TOKEN_GETMAD((ps[(1) - (8)].val.p_tkval),((LISTOP*)innerop)->op_first,'L');
 306                          TOKEN_GETMAD((ps[(2) - (8)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
 307                          TOKEN_GETMAD((ps[(3) - (8)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
 308                          TOKEN_GETMAD((ps[(6) - (8)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
 309                        ;}
 310    break;
 311
 312  case 39:
 313#line 387 "perly.y"
 314    { OP *forop;
 315                          PL_parser->copline = (line_t)IVAL((ps[(2) - (12)].val.i_tkval));
 316                          forop = newSTATEOP(0, PVAL((ps[(1) - (12)].val.p_tkval)),
 317                                            newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 318                                                IVAL((ps[(2) - (12)].val.i_tkval)), scalar((ps[(7) - (12)].val.opval)),
 319                                                (ps[(12) - (12)].val.opval), (ps[(10) - (12)].val.opval), (ps[(9) - (12)].val.ival)));
 320#ifdef MAD
 321                          forop = newUNOP(OP_NULL, 0, append_elem(OP_LINESEQ,
 322                                newSTATEOP(0,
 323                                           CopLABEL_alloc(((ps[(1) - (12)].val.p_tkval))->tk_lval.pval),
 324                                           ((ps[(5) - (12)].val.opval) ? (ps[(5) - (12)].val.opval) : newOP(OP_NULL, 0)) ),
 325                                forop));
 326
 327                          token_getmad((ps[(2) - (12)].val.i_tkval),forop,'3');
 328                          token_getmad((ps[(3) - (12)].val.i_tkval),forop,'(');
 329                          token_getmad((ps[(6) - (12)].val.i_tkval),forop,'1');
 330                          token_getmad((ps[(8) - (12)].val.i_tkval),forop,'2');
 331                          token_getmad((ps[(11) - (12)].val.i_tkval),forop,')');
 332                          token_getmad((ps[(1) - (12)].val.p_tkval),forop,'L');
 333#else
 334                          if ((ps[(5) - (12)].val.opval)) {
 335                                forop = append_elem(OP_LINESEQ,
 336                                        newSTATEOP(0, CopLABEL_alloc((ps[(1) - (12)].val.p_tkval)), (ps[(5) - (12)].val.opval)),
 337                                        forop);
 338                          }
 339
 340
 341#endif
 342                          (yyval.opval) = block_end((ps[(4) - (12)].val.ival), forop); ;}
 343    break;
 344
 345  case 40:
 346#line 417 "perly.y"
 347    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (3)].val.p_tkval)),
 348                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 349                                            NOLINE, (OP*)NULL, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval), 0));
 350                          TOKEN_GETMAD((ps[(1) - (3)].val.p_tkval),((LISTOP*)(yyval.opval))->op_first,'L'); ;}
 351    break;
 352
 353  case 41:
 354#line 425 "perly.y"
 355    { PL_parser->copline = (line_t) (ps[(2) - (8)].val.i_tkval);
 356                            (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
 357                                newSTATEOP(0, PVAL((ps[(1) - (8)].val.p_tkval)),
 358                                    newGIVENOP((ps[(6) - (8)].val.opval), scope((ps[(8) - (8)].val.opval)),
 359                                        (PADOFFSET) (ps[(5) - (8)].val.ival)) )); ;}
 360    break;
 361
 362  case 42:
 363#line 434 "perly.y"
 364    { (yyval.ival) = (PL_min_intro_pending &&
 365                            PL_max_intro_pending >=  PL_min_intro_pending);
 366                          intro_my(); ;}
 367    break;
 368
 369  case 43:
 370#line 440 "perly.y"
 371    { (yyval.opval) = (OP*)NULL; ;}
 372    break;
 373
 374  case 45:
 375#line 446 "perly.y"
 376    { YYSTYPE tmplval;
 377                          (void)scan_num("1", &tmplval);
 378                          (yyval.opval) = tmplval.opval; ;}
 379    break;
 380
 381  case 47:
 382#line 454 "perly.y"
 383    { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
 384    break;
 385
 386  case 48:
 387#line 459 "perly.y"
 388    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 389    break;
 390
 391  case 49:
 392#line 463 "perly.y"
 393    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 394    break;
 395
 396  case 50:
 397#line 467 "perly.y"
 398    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
 399    break;
 400
 401  case 51:
 402#line 472 "perly.y"
 403    {
 404#ifdef MAD
 405                          YYSTYPE tmplval;
 406                          tmplval.pval = NULL;
 407                          (yyval.p_tkval) = newTOKEN(OP_NULL, tmplval, 0);
 408#else
 409                          (yyval.p_tkval) = NULL;
 410#endif
 411                        ;}
 412    break;
 413
 414  case 53:
 415#line 486 "perly.y"
 416    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 417    break;
 418
 419  case 54:
 420#line 488 "perly.y"
 421    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 422    break;
 423
 424  case 55:
 425#line 490 "perly.y"
 426    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 427    break;
 428
 429  case 56:
 430#line 492 "perly.y"
 431    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 432    break;
 433
 434  case 57:
 435#line 494 "perly.y"
 436    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 437    break;
 438
 439  case 58:
 440#line 499 "perly.y"
 441    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 442    break;
 443
 444  case 59:
 445#line 503 "perly.y"
 446    { (yyval.opval) = newOP(OP_NULL,0);
 447                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'p');
 448                        ;}
 449    break;
 450
 451  case 60:
 452#line 509 "perly.y"
 453    { SvREFCNT_inc_simple_void(PL_compcv);
 454#ifdef MAD
 455                          (yyval.opval) = newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
 456                          prepend_madprops((ps[(1) - (4)].val.i_tkval)->tk_mad, (yyval.opval), 'F');
 457                          (ps[(1) - (4)].val.i_tkval)->tk_mad = 0;
 458                          token_free((ps[(1) - (4)].val.i_tkval));
 459#else
 460                          newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
 461                          (yyval.opval) = (OP*)NULL;
 462#endif
 463                        ;}
 464    break;
 465
 466  case 61:
 467#line 522 "perly.y"
 468    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 469    break;
 470
 471  case 62:
 472#line 523 "perly.y"
 473    { (yyval.opval) = (OP*)NULL; ;}
 474    break;
 475
 476  case 63:
 477#line 528 "perly.y"
 478    { SvREFCNT_inc_simple_void(PL_compcv);
 479#ifdef MAD
 480                          (yyval.opval) = newMYSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
 481                          token_getmad((ps[(1) - (6)].val.i_tkval),(yyval.opval),'d');
 482#else
 483                          newMYSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
 484                          (yyval.opval) = (OP*)NULL;
 485#endif
 486                        ;}
 487    break;
 488
 489  case 64:
 490#line 541 "perly.y"
 491    { SvREFCNT_inc_simple_void(PL_compcv);
 492#ifdef MAD
 493                          {
 494                              OP* o = newSVOP(OP_ANONCODE, 0,
 495                                (SV*)newATTRSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval)));
 496                              (yyval.opval) = newOP(OP_NULL,0);
 497                              op_getmad(o,(yyval.opval),'&');
 498                              op_getmad((ps[(3) - (6)].val.opval),(yyval.opval),'n');
 499                              op_getmad((ps[(4) - (6)].val.opval),(yyval.opval),'s');
 500                              op_getmad((ps[(5) - (6)].val.opval),(yyval.opval),'a');
 501                              token_getmad((ps[(1) - (6)].val.i_tkval),(yyval.opval),'d');
 502                              append_madprops((ps[(6) - (6)].val.opval)->op_madprop, (yyval.opval), 0);
 503                              (ps[(6) - (6)].val.opval)->op_madprop = 0;
 504                            }
 505#else
 506                          newATTRSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
 507                          (yyval.opval) = (OP*)NULL;
 508#endif
 509                        ;}
 510    break;
 511
 512  case 65:
 513#line 563 "perly.y"
 514    { (yyval.ival) = start_subparse(FALSE, 0);
 515                            SAVEFREESV(PL_compcv); ;}
 516    break;
 517
 518  case 66:
 519#line 569 "perly.y"
 520    { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
 521                            SAVEFREESV(PL_compcv); ;}
 522    break;
 523
 524  case 67:
 525#line 574 "perly.y"
 526    { (yyval.ival) = start_subparse(TRUE, 0);
 527                            SAVEFREESV(PL_compcv); ;}
 528    break;
 529
 530  case 68:
 531#line 579 "perly.y"
 532    { const char *const name = SvPV_nolen_const(((SVOP*)(ps[(1) - (1)].val.opval))->op_sv);
 533                          if (strEQ(name, "BEGIN") || strEQ(name, "END")
 534                              || strEQ(name, "INIT") || strEQ(name, "CHECK")
 535                              || strEQ(name, "UNITCHECK"))
 536                              CvSPECIAL_on(PL_compcv);
 537                          (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 538    break;
 539
 540  case 69:
 541#line 589 "perly.y"
 542    { (yyval.opval) = (OP*)NULL; ;}
 543    break;
 544
 545  case 71:
 546#line 595 "perly.y"
 547    { (yyval.opval) = (OP*)NULL; ;}
 548    break;
 549
 550  case 72:
 551#line 597 "perly.y"
 552    { (yyval.opval) = (ps[(2) - (2)].val.opval);
 553                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
 554                        ;}
 555    break;
 556
 557  case 73:
 558#line 601 "perly.y"
 559    { (yyval.opval) = IF_MAD(
 560                                    newOP(OP_NULL, 0),
 561                                    (OP*)NULL
 562                                );
 563                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),':');
 564                        ;}
 565    break;
 566
 567  case 74:
 568#line 611 "perly.y"
 569    { (yyval.opval) = (ps[(2) - (2)].val.opval);
 570                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
 571                        ;}
 572    break;
 573
 574  case 75:
 575#line 615 "perly.y"
 576    { (yyval.opval) = IF_MAD(
 577                                    newOP(OP_NULL, 0),
 578                                    (OP*)NULL
 579                                );
 580                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),':');
 581                        ;}
 582    break;
 583
 584  case 76:
 585#line 624 "perly.y"
 586    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 587    break;
 588
 589  case 77:
 590#line 625 "perly.y"
 591    { (yyval.opval) = IF_MAD(
 592                                    newOP(OP_NULL,0),
 593                                    (OP*)NULL
 594                                );
 595                          PL_parser->expect = XSTATE;
 596                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),';');
 597                        ;}
 598    break;
 599
 600  case 78:
 601#line 635 "perly.y"
 602    {
 603#ifdef MAD
 604                          (yyval.opval) = package((ps[(2) - (3)].val.opval));
 605                          token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
 606                          token_getmad((ps[(3) - (3)].val.i_tkval),(yyval.opval),';');
 607#else
 608                          package((ps[(2) - (3)].val.opval));
 609                          (yyval.opval) = (OP*)NULL;
 610#endif
 611                        ;}
 612    break;
 613
 614  case 79:
 615#line 648 "perly.y"
 616    { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
 617    break;
 618
 619  case 80:
 620#line 650 "perly.y"
 621    { SvREFCNT_inc_simple_void(PL_compcv);
 622#ifdef MAD
 623                          (yyval.opval) = utilize(IVAL((ps[(1) - (7)].val.i_tkval)), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
 624                          token_getmad((ps[(1) - (7)].val.i_tkval),(yyval.opval),'o');
 625                          token_getmad((ps[(7) - (7)].val.i_tkval),(yyval.opval),';');
 626                          if (PL_parser->rsfp_filters &&
 627                                      AvFILLp(PL_parser->rsfp_filters) >= 0)
 628                              append_madprops(newMADPROP('!', MAD_PV, "", 0), (yyval.opval), 0);
 629#else
 630                          utilize(IVAL((ps[(1) - (7)].val.i_tkval)), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
 631                          (yyval.opval) = (OP*)NULL;
 632#endif
 633                        ;}
 634    break;
 635
 636  case 81:
 637#line 667 "perly.y"
 638    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 639                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 640                        ;}
 641    break;
 642
 643  case 82:
 644#line 671 "perly.y"
 645    { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 646                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 647                        ;}
 648    break;
 649
 650  case 83:
 651#line 675 "perly.y"
 652    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 653                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 654                        ;}
 655    break;
 656
 657  case 85:
 658#line 683 "perly.y"
 659    {
 660#ifdef MAD
 661                          OP* op = newNULLLIST();
 662                          token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
 663                          (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
 664#else
 665                          (yyval.opval) = (ps[(1) - (2)].val.opval);
 666#endif
 667                        ;}
 668    break;
 669
 670  case 86:
 671#line 693 "perly.y"
 672    { 
 673                          OP* term = (ps[(3) - (3)].val.opval);
 674                          DO_MAD(
 675                              term = newUNOP(OP_NULL, 0, term);
 676                              token_getmad((ps[(2) - (3)].val.i_tkval),term,',');
 677                          )
 678                          (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
 679                        ;}
 680    break;
 681
 682  case 88:
 683#line 706 "perly.y"
 684    { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
 685                                prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
 686                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
 687                        ;}
 688    break;
 689
 690  case 89:
 691#line 711 "perly.y"
 692    { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
 693                                prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
 694                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
 695                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'(');
 696                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 697                        ;}
 698    break;
 699
 700  case 90:
 701#line 718 "perly.y"
 702    { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 703                                append_elem(OP_LIST,
 704                                    prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
 705                                    newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
 706                          TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'A');
 707                          TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'(');
 708                          TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),')');
 709                        ;}
 710    break;
 711
 712  case 91:
 713#line 727 "perly.y"
 714    { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 715                                append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
 716                                    newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
 717                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'A');
 718                        ;}
 719    break;
 720
 721  case 92:
 722#line 733 "perly.y"
 723    { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 724                                append_elem(OP_LIST,
 725                                    prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
 726                                    newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
 727                        ;}
 728    break;
 729
 730  case 93:
 731#line 739 "perly.y"
 732    { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 733                                append_elem(OP_LIST,
 734                                    prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
 735                                    newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
 736                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
 737                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 738                        ;}
 739    break;
 740
 741  case 94:
 742#line 747 "perly.y"
 743    { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
 744                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
 745                        ;}
 746    break;
 747
 748  case 95:
 749#line 751 "perly.y"
 750    { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
 751                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
 752                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
 753                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 754                        ;}
 755    break;
 756
 757  case 96:
 758#line 757 "perly.y"
 759    { SvREFCNT_inc_simple_void(PL_compcv);
 760                          (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
 761    break;
 762
 763  case 97:
 764#line 760 "perly.y"
 765    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 766                                 append_elem(OP_LIST,
 767                                   prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
 768                        ;}
 769    break;
 770
 771  case 100:
 772#line 775 "perly.y"
 773    { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
 774                            PL_parser->expect = XOPERATOR;
 775                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 776                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 777                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 778                        ;}
 779    break;
 780
 781  case 101:
 782#line 782 "perly.y"
 783    { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
 784                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
 785                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
 786                        ;}
 787    break;
 788
 789  case 102:
 790#line 787 "perly.y"
 791    { (yyval.opval) = newBINOP(OP_AELEM, 0,
 792                                        ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
 793                                        scalar((ps[(4) - (5)].val.opval)));
 794                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
 795                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
 796                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
 797                        ;}
 798    break;
 799
 800  case 103:
 801#line 795 "perly.y"
 802    { (yyval.opval) = newBINOP(OP_AELEM, 0,
 803                                        ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
 804                                        scalar((ps[(3) - (4)].val.opval)));
 805                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
 806                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
 807                        ;}
 808    break;
 809
 810  case 104:
 811#line 802 "perly.y"
 812    { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
 813                            PL_parser->expect = XOPERATOR;
 814                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 815                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 816                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 817                        ;}
 818    break;
 819
 820  case 105:
 821#line 809 "perly.y"
 822    { (yyval.opval) = newBINOP(OP_HELEM, 0,
 823                                        ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
 824                                        jmaybe((ps[(4) - (6)].val.opval)));
 825                            PL_parser->expect = XOPERATOR;
 826                          TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'a');
 827                          TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),'{');
 828                          TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),';');
 829                          TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),'}');
 830                        ;}
 831    break;
 832
 833  case 106:
 834#line 819 "perly.y"
 835    { (yyval.opval) = newBINOP(OP_HELEM, 0,
 836                                        ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
 837                                        jmaybe((ps[(3) - (5)].val.opval)));
 838                            PL_parser->expect = XOPERATOR;
 839                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 840                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 841                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 842                        ;}
 843    break;
 844
 845  case 107:
 846#line 828 "perly.y"
 847    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 848                                   newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
 849                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
 850                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
 851                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 852                        ;}
 853    break;
 854
 855  case 108:
 856#line 835 "perly.y"
 857    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 858                                   append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
 859                                       newCVREF(0, scalar((ps[(1) - (5)].val.opval)))));
 860                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
 861                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
 862                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 863                        ;}
 864    break;
 865
 866  case 109:
 867#line 844 "perly.y"
 868    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 869                                   append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
 870                                               newCVREF(0, scalar((ps[(1) - (4)].val.opval)))));
 871                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
 872                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 873                        ;}
 874    break;
 875
 876  case 110:
 877#line 851 "perly.y"
 878    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 879                                   newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
 880                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
 881                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
 882                        ;}
 883    break;
 884
 885  case 111:
 886#line 857 "perly.y"
 887    { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
 888                          TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
 889                          TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
 890                          TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'[');
 891                          TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),']');
 892                        ;}
 893    break;
 894
 895  case 112:
 896#line 864 "perly.y"
 897    { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL);
 898                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
 899                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
 900                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
 901                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
 902                        ;}
 903    break;
 904
 905  case 113:
 906#line 874 "perly.y"
 907    { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
 908                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 909                        ;}
 910    break;
 911
 912  case 114:
 913#line 878 "perly.y"
 914    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 915                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 916                        ;}
 917    break;
 918
 919  case 115:
 920#line 882 "perly.y"
 921    {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
 922                                scalar((ps[(1) - (3)].val.opval));
 923                            (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
 924                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 925                        ;}
 926    break;
 927
 928  case 116:
 929#line 888 "perly.y"
 930    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 931                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 932                        ;}
 933    break;
 934
 935  case 117:
 936#line 892 "perly.y"
 937    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 938                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 939                        ;}
 940    break;
 941
 942  case 118:
 943#line 896 "perly.y"
 944    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 945                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 946                        ;}
 947    break;
 948
 949  case 119:
 950#line 900 "perly.y"
 951    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 952                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 953                        ;}
 954    break;
 955
 956  case 120:
 957#line 904 "perly.y"
 958    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 959                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 960                        ;}
 961    break;
 962
 963  case 121:
 964#line 908 "perly.y"
 965    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 966                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 967                        ;}
 968    break;
 969
 970  case 122:
 971#line 912 "perly.y"
 972    {
 973                          (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 974                          DO_MAD({
 975                              UNOP *op;
 976                              op = (UNOP*)(yyval.opval);
 977                              op = (UNOP*)op->op_first; /* get to flop */
 978                              op = (UNOP*)op->op_first; /* get to flip */
 979                              op = (UNOP*)op->op_first; /* get to range */
 980                              token_getmad((ps[(2) - (3)].val.i_tkval),(OP*)op,'o');
 981                            })
 982                        ;}
 983    break;
 984
 985  case 123:
 986#line 924 "perly.y"
 987    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 988                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 989                        ;}
 990    break;
 991
 992  case 124:
 993#line 928 "perly.y"
 994    { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 995                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 996                        ;}
 997    break;
 998
 999  case 125:
1000#line 932 "perly.y"

1001    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1002                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1003                        ;}
1004    break;
1005
1006  case 126:
1007#line 936 "perly.y"
1008    { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1009                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
1010                                ((yyval.opval)->op_type == OP_NOT
1011                                    ? ((UNOP*)(yyval.opval))->op_first : (yyval.opval)),
1012                                '~');
1013                        ;}
1014    break;
1015
1016  case 127:
1017#line 946 "perly.y"
1018    { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
1019                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1020                        ;}
1021    break;
1022
1023  case 128:
1024#line 950 "perly.y"
1025    { (yyval.opval) = IF_MAD(
1026                                    newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
1027                                    (ps[(2) - (2)].val.opval)
1028                                );
1029                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'+');
1030                        ;}
1031    break;
1032
1033  case 129:
1034#line 957 "perly.y"
1035    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1036                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1037                        ;}
1038    break;
1039
1040  case 130:
1041#line 961 "perly.y"
1042    { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
1043                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1044                        ;}
1045    break;
1046
1047  case 131:
1048#line 965 "perly.y"
1049    { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1050                                        mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
1051                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1052                        ;}
1053    break;
1054
1055  case 132:
1056#line 970 "perly.y"
1057    { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1058                                        mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
1059                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1060                        ;}
1061    break;
1062
1063  case 133:
1064#line 975 "perly.y"
1065    { (yyval.opval) = newUNOP(OP_PREINC, 0,
1066                                        mod(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
1067                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1068                        ;}
1069    break;
1070
1071  case 134:
1072#line 980 "perly.y"
1073    { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1074                                        mod(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
1075                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1076                        ;}
1077    break;
1078
1079  case 135:
1080#line 989 "perly.y"
1081    { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
1082                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
1083                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
1084                        ;}
1085    break;
1086
1087  case 136:
1088#line 994 "perly.y"
1089    { (yyval.opval) = newANONLIST((OP*)NULL);
1090                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
1091                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
1092                        ;}
1093    break;
1094
1095  case 137:
1096#line 999 "perly.y"
1097    { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
1098                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
1099                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
1100                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
1101                        ;}
1102    break;
1103
1104  case 138:
1105#line 1005 "perly.y"
1106    { (yyval.opval) = newANONHASH((OP*)NULL);
1107                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
1108                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
1109                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),'}');
1110                        ;}
1111    break;
1112
1113  case 139:
1114#line 1011 "perly.y"
1115    { SvREFCNT_inc_simple_void(PL_compcv);
1116                          (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1117                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1118                          OP_GETMAD((ps[(3) - (5)].val.opval),(yyval.opval),'s');
1119                          OP_GETMAD((ps[(4) - (5)].val.opval),(yyval.opval),'a');
1120                        ;}
1121    break;
1122
1123  case 140:
1124#line 1022 "perly.y"
1125    { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
1126                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1127                        ;}
1128    break;
1129
1130  case 141:
1131#line 1026 "perly.y"
1132    { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, scope((ps[(2) - (2)].val.opval)));
1133                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
1134                        ;}
1135    break;
1136
1137  case 142:
1138#line 1030 "perly.y"
1139    { (yyval.opval) = newUNOP(OP_ENTERSUB,
1140                            OPf_SPECIAL|OPf_STACKED,
1141                            prepend_elem(OP_LIST,
1142                                scalar(newCVREF(
1143                                    (OPpENTERSUB_AMPER<<8),
1144                                    scalar((ps[(2) - (4)].val.opval))
1145                                )),(OP*)NULL)); dep();
1146                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1147                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1148                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1149                        ;}
1150    break;
1151
1152  case 143:
1153#line 1042 "perly.y"
1154    { (yyval.opval) = newUNOP(OP_ENTERSUB,
1155                            OPf_SPECIAL|OPf_STACKED,
1156                            append_elem(OP_LIST,
1157                                (ps[(4) - (5)].val.opval),
1158                                scalar(newCVREF(
1159                                    (OPpENTERSUB_AMPER<<8),
1160                                    scalar((ps[(2) - (5)].val.opval))
1161                                )))); dep();
1162                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1163                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1164                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1165                        ;}
1166    break;
1167
1168  case 144:
1169#line 1055 "perly.y"
1170    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1171                            prepend_elem(OP_LIST,
1172                                scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), (OP*)NULL)); dep();
1173                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1174                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1175                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1176                        ;}
1177    break;
1178
1179  case 145:
1180#line 1063 "perly.y"
1181    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1182                            prepend_elem(OP_LIST,
1183                                (ps[(4) - (5)].val.opval),
1184                                scalar(newCVREF(0,scalar((ps[(2) - (5)].val.opval)))))); dep();
1185                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1186                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1187                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1188                        ;}
1189    break;
1190
1191  case 150:
1192#line 1079 "perly.y"
1193    { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1194                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
1195                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
1196                        ;}
1197    break;
1198
1199  case 151:
1200#line 1084 "perly.y"
1201    { (yyval.opval) = newUNOP(OP_REFGEN, 0, mod((ps[(2) - (2)].val.opval),OP_REFGEN));
1202                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1203                        ;}
1204    break;
1205
1206  case 152:
1207#line 1088 "perly.y"
1208    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1209    break;
1210
1211  case 153:
1212#line 1090 "perly.y"
1213    { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1214                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
1215                        ;}
1216    break;
1217
1218  case 154:
1219#line 1094 "perly.y"
1220    { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
1221                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1222                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1223                        ;}
1224    break;
1225
1226  case 155:
1227#line 1099 "perly.y"
1228    { (yyval.opval) = sawparens(newNULLLIST());
1229                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1230                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1231                        ;}
1232    break;
1233
1234  case 156:
1235#line 1104 "perly.y"
1236    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1237    break;
1238
1239  case 157:
1240#line 1106 "perly.y"
1241    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1242    break;
1243
1244  case 158:
1245#line 1108 "perly.y"
1246    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1247    break;
1248
1249  case 159:
1250#line 1110 "perly.y"
1251    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1252    break;
1253
1254  case 160:
1255#line 1112 "perly.y"
1256    { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1257    break;
1258
1259  case 161:
1260#line 1114 "perly.y"
1261    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1262    break;
1263
1264  case 162:
1265#line 1116 "perly.y"
1266    { (yyval.opval) = prepend_elem(OP_ASLICE,
1267                                newOP(OP_PUSHMARK, 0),
1268                                    newLISTOP(OP_ASLICE, 0,
1269                                        list((ps[(3) - (4)].val.opval)),
1270                                        ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1271                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
1272                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
1273                        ;}
1274    break;
1275
1276  case 163:
1277#line 1125 "perly.y"
1278    { (yyval.opval) = prepend_elem(OP_HSLICE,
1279                                newOP(OP_PUSHMARK, 0),
1280                                    newLISTOP(OP_HSLICE, 0,
1281                                        list((ps[(3) - (5)].val.opval)),
1282                                        ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1283                            PL_parser->expect = XOPERATOR;
1284                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
1285                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
1286                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
1287                        ;}
1288    break;
1289
1290  case 164:
1291#line 1136 "perly.y"
1292    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1293    break;
1294
1295  case 165:
1296#line 1138 "perly.y"
1297    { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1298    break;
1299
1300  case 166:
1301#line 1140 "perly.y"
1302    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1303                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1304                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1305                        ;}
1306    break;
1307
1308  case 167:
1309#line 1145 "perly.y"
1310    {
1311                          (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1312                                append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1313                          DO_MAD({
1314                              OP* op = (yyval.opval);
1315                              if (op->op_type == OP_CONST) { /* defeat const fold */
1316                                op = (OP*)op->op_madprop->mad_val;
1317                              }
1318                              token_getmad((ps[(2) - (4)].val.i_tkval),op,'(');
1319                              token_getmad((ps[(4) - (4)].val.i_tkval),op,')');
1320                          })
1321                        ;}
1322    break;
1323
1324  case 168:
1325#line 1158 "perly.y"
1326    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1327                            append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1328                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1329                        ;}
1330    break;
1331
1332  case 169:
1333#line 1163 "perly.y"
1334    { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
1335                            PL_hints |= HINT_BLOCK_SCOPE;
1336                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1337                        ;}
1338    break;
1339
1340  case 170:
1341#line 1168 "perly.y"
1342    { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1343                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1344                        ;}
1345    break;
1346
1347  case 171:
1348#line 1172 "perly.y"
1349    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1350                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1351                        ;}
1352    break;
1353
1354  case 172:
1355#line 1176 "perly.y"
1356    { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1357                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1358                        ;}
1359    break;
1360
1361  case 173:
1362#line 1180 "perly.y"
1363    { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1364                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1365                        ;}
1366    break;
1367
1368  case 174:
1369#line 1184 "perly.y"
1370    { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1371                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1372                        ;}
1373    break;
1374
1375  case 175:
1376#line 1188 "perly.y"
1377    { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0);
1378                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1379                        ;}
1380    break;
1381
1382  case 176:
1383#line 1192 "perly.y"
1384    { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval));
1385                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1386                        ;}
1387    break;
1388
1389  case 177:
1390#line 1196 "perly.y"
1391    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1392    break;
1393
1394  case 178:
1395#line 1198 "perly.y"
1396    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1397                            append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1398    break;
1399
1400  case 179:
1401#line 1201 "perly.y"
1402    { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1403                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1404                        ;}
1405    break;
1406
1407  case 180:
1408#line 1205 "perly.y"
1409    { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
1410                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1411                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1412                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1413                        ;}
1414    break;
1415
1416  case 181:
1417#line 1211 "perly.y"
1418    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1419                                scalar((ps[(1) - (1)].val.opval))); ;}
1420    break;
1421
1422  case 182:
1423#line 1214 "perly.y"
1424    { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
1425                            ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1426                            : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
1427
1428                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1429                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1430                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1431                        ;}
1432    break;
1433
1434  case 183:
1435#line 1223 "perly.y"
1436    { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
1437                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1438                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1439                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1440                        ;}
1441    break;
1442
1443  case 184:
1444#line 1229 "perly.y"
1445    { (yyval.opval) = pmruntime((ps[(1) - (4)].val.opval), (ps[(3) - (4)].val.opval), 1);
1446                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1447                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1448                        ;}
1449    break;
1450
1451  case 187:
1452#line 1239 "perly.y"
1453    { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
1454                          DO_MAD(
1455                              token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
1456                              append_madprops((ps[(3) - (3)].val.opval)->op_madprop, (yyval.opval), 'a');
1457                              (ps[(3) - (3)].val.opval)->op_madprop = 0;
1458                          )
1459                        ;}
1460    break;
1461
1462  case 188:
1463#line 1247 "perly.y"
1464    { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1465                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
1466                        ;}
1467    break;
1468
1469  case 189:
1470#line 1254 "perly.y"
1471    { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
1472                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1473                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1474                        ;}
1475    break;
1476
1477  case 190:
1478#line 1259 "perly.y"
1479    { (yyval.opval) = sawparens(newNULLLIST());
1480                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1481                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1482                        ;}
1483    break;
1484
1485  case 191:
1486#line 1264 "perly.y"
1487    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1488    break;
1489
1490  case 192:
1491#line 1266 "perly.y"
1492    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1493    break;
1494
1495  case 193:
1496#line 1268 "perly.y"
1497    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1498    break;
1499
1500  case 194:
1501#line 1273 "perly.y"
1502    { (yyval.opval) = (OP*)NULL; ;}
1503    break;
1504
1505  case 195:
1506#line 1275 "perly.y"
1507    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1508    break;
1509
1510  case 196:
1511#line 1279 "perly.y"
1512    { (yyval.opval) = (OP*)NULL; ;}
1513    break;
1514
1515  case 197:
1516#line 1281 "perly.y"
1517    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1518    break;
1519
1520  case 198:
1521#line 1283 "perly.y"
1522    {
1523#ifdef MAD
1524                          OP* op = newNULLLIST();
1525                          token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
1526                          (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
1527#else
1528                          (yyval.opval) = (ps[(1) - (2)].val.opval);
1529#endif
1530
1531                        ;}
1532    break;
1533
1534  case 199:
1535#line 1298 "perly.y"
1536    { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1537    break;
1538
1539  case 200:
1540#line 1302 "perly.y"
1541    { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1542                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
1543                        ;}
1544    break;
1545
1546  case 201:
1547#line 1308 "perly.y"
1548    { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
1549                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
1550                        ;}
1551    break;
1552
1553  case 202:
1554#line 1314 "perly.y"
1555    { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1556                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
1557                        ;}
1558    break;
1559
1560  case 203:
1561#line 1320 "perly.y"
1562    { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1563                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
1564                        ;}
1565    break;
1566
1567  case 204:
1568#line 1326 "perly.y"
1569    { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1570                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
1571                        ;}
1572    break;
1573
1574  case 205:
1575#line 1332 "perly.y"
1576    { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
1577                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
1578                        ;}
1579    break;
1580
1581  case 206:
1582#line 1339 "perly.y"
1583    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1584    break;
1585
1586  case 207:
1587#line 1341 "perly.y"
1588    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1589    break;
1590
1591  case 208:
1592#line 1343 "perly.y"
1593    { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
1594    break;
1595
1596  case 209:
1597#line 1346 "perly.y"
1598    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1599    break;
1600
1601
1602/* Line 1267 of yacc.c.  */
1603
1604      default: break;
1605    
1606