perly.act

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