perly.act

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