perly.act

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