perly.act

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