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