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