perly.act

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