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