perly.act

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