This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
[perl #123286] Lone C-style for in a block
authorFather Chrysostomos <sprout@cpan.org>
Wed, 26 Nov 2014 02:08:13 +0000 (18:08 -0800)
committerFather Chrysostomos <sprout@cpan.org>
Wed, 26 Nov 2014 04:11:05 +0000 (20:11 -0800)
A block in perl usually consists of an enter/leave pair plus the con-
tents of the block:

  leave
     enter
     nextstate
     whatever

But if the contents of the block are simple enough to forego the
full block structure, a simple scope op is used, which is not
even executed:

  scope
    ex-nextstate
    whatever

If there is a real nextstate op anywhere in the block, it resets the
stack to whatever it was at block entry, based on the value on the
context stack placed there by the enter op.  That’s why we can never
have scope+nextstate (we have ex-nextstate, or a former nextstate op
that is not executed).

A for-loop (for(init; cond; cont) { ... }) executes the init section
first, and then an unstack op, which is like nextstate in that it
resets the stack based on what the context stack says is the base off-
set for this block.

If we have an unstack op, we can’t use scope, just as we can’t use it
with nextstate.  But we *were* nonetheless using scope in this case.

Hence, map { for(...;...;...) {...} } ... caused the for-loop to reset
the stack to the beginning of map’s own arguments.  So the for-loop
would stomp on them.

We can see the same bug with ‘for’ clobbering an outer list:

$ perl5.20.1 -le 'print 1..3, do{for(0;0;){}}, 4..6;'
0456

perly.act
perly.h
perly.tab
perly.y
t/cmd/for.t

index f0a55ff..22a5fe2 100644 (file)
--- a/perly.act
+++ b/perly.act
@@ -360,13 +360,14 @@ case 2:
                                      newOP(OP_UNSTACK, OPf_SPECIAL),
                                      forop));
                          }
+                         PL_hints |= HINT_BLOCK_SCOPE;
                          (yyval.opval) = block_end((ps[(3) - (13)].val.ival), forop);
                          parser->copline = (line_t)(ps[(1) - (13)].val.ival);
                        ;}
     break;
 
   case 44:
-#line 377 "perly.y"
+#line 378 "perly.y"
     {
                          (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)));
                          parser->copline = (line_t)(ps[(1) - (9)].val.ival);
@@ -374,7 +375,7 @@ case 2:
     break;
 
   case 45:
-#line 382 "perly.y"
+#line 383 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
                                      op_lvalue((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
@@ -383,12 +384,12 @@ case 2:
     break;
 
   case 46:
-#line 388 "perly.y"
+#line 389 "perly.y"
     { parser->in_my = 0; (yyval.opval) = my((ps[(5) - (5)].val.opval)); ;}
     break;
 
   case 47:
-#line 390 "perly.y"
+#line 391 "perly.y"
     {
                          (yyval.opval) = block_end(
                                (ps[(4) - (11)].val.ival),
@@ -404,7 +405,7 @@ case 2:
     break;
 
   case 48:
-#line 403 "perly.y"
+#line 404 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(5) - (9)].val.ival), newFOROP(
                                0, op_lvalue(newUNOP(OP_REFGEN, 0,
@@ -415,7 +416,7 @@ case 2:
     break;
 
   case 49:
-#line 411 "perly.y"
+#line 412 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
                                  newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
@@ -424,7 +425,7 @@ case 2:
     break;
 
   case 50:
-#line 417 "perly.y"
+#line 418 "perly.y"
     {
                          /* a block is a loop that happens once */
                          (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
@@ -433,7 +434,7 @@ case 2:
     break;
 
   case 51:
-#line 423 "perly.y"
+#line 424 "perly.y"
     {
                          package((ps[(3) - (5)].val.opval));
                          if ((ps[(2) - (5)].val.opval)) {
@@ -443,7 +444,7 @@ case 2:
     break;
 
   case 52:
-#line 430 "perly.y"
+#line 431 "perly.y"
     {
                          /* a block is a loop that happens once */
                          (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
@@ -454,14 +455,14 @@ case 2:
     break;
 
   case 53:
-#line 438 "perly.y"
+#line 439 "perly.y"
     {
                          (yyval.opval) = (ps[(1) - (2)].val.opval);
                        ;}
     break;
 
   case 54:
-#line 442 "perly.y"
+#line 443 "perly.y"
     {
                          (yyval.opval) = (OP*)NULL;
                          parser->copline = NOLINE;
@@ -469,7 +470,7 @@ case 2:
     break;
 
   case 55:
-#line 450 "perly.y"
+#line 451 "perly.y"
     { OP *list;
                          if ((ps[(2) - (2)].val.opval)) {
                              OP *term = (ps[(2) - (2)].val.opval);
@@ -487,63 +488,63 @@ case 2:
     break;
 
   case 56:
-#line 467 "perly.y"
+#line 468 "perly.y"
     { (yyval.opval) = NULL; ;}
     break;
 
   case 57:
-#line 469 "perly.y"
+#line 470 "perly.y"
     { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); ;}
     break;
 
   case 58:
-#line 474 "perly.y"
+#line 475 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 59:
-#line 476 "perly.y"
+#line 477 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 60:
-#line 478 "perly.y"
+#line 479 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 61:
-#line 480 "perly.y"
+#line 481 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 62:
-#line 482 "perly.y"
+#line 483 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 63:
-#line 484 "perly.y"
+#line 485 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 64:
-#line 486 "perly.y"
+#line 487 "perly.y"
     { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
                          parser->copline = (line_t)(ps[(2) - (3)].val.ival); ;}
     break;
 
   case 65:
-#line 489 "perly.y"
+#line 490 "perly.y"
     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); ;}
     break;
 
   case 66:
-#line 494 "perly.y"
+#line 495 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 67:
-#line 496 "perly.y"
+#line 497 "perly.y"
     {
                          ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
                          (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
@@ -551,7 +552,7 @@ case 2:
     break;
 
   case 68:
-#line 501 "perly.y"
+#line 502 "perly.y"
     { parser->copline = (line_t)(ps[(1) - (6)].val.ival);
                            (yyval.opval) = newCONDOP(0,
                                newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)),
@@ -561,119 +562,119 @@ case 2:
     break;
 
   case 69:
-#line 511 "perly.y"
+#line 512 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 70:
-#line 513 "perly.y"
+#line 514 "perly.y"
     { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 71:
-#line 518 "perly.y"
+#line 519 "perly.y"
     { (yyval.ival) = (PL_min_intro_pending &&
                            PL_max_intro_pending >=  PL_min_intro_pending);
                          intro_my(); ;}
     break;
 
   case 72:
-#line 524 "perly.y"
+#line 525 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 74:
-#line 530 "perly.y"
+#line 531 "perly.y"
     { YYSTYPE tmplval;
                          (void)scan_num("1", &tmplval);
                          (yyval.opval) = tmplval.opval; ;}
     break;
 
   case 76:
-#line 538 "perly.y"
+#line 539 "perly.y"
     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 77:
-#line 543 "perly.y"
+#line 544 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 78:
-#line 547 "perly.y"
+#line 548 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 79:
-#line 551 "perly.y"
+#line 552 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 80:
-#line 554 "perly.y"
+#line 555 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 81:
-#line 555 "perly.y"
+#line 556 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 82:
-#line 559 "perly.y"
+#line 560 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 83:
-#line 565 "perly.y"
+#line 566 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 84:
-#line 570 "perly.y"
+#line 571 "perly.y"
     { (yyval.ival) = start_subparse(TRUE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 87:
-#line 581 "perly.y"
+#line 582 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 89:
-#line 587 "perly.y"
+#line 588 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 90:
-#line 589 "perly.y"
+#line 590 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
     break;
 
   case 91:
-#line 591 "perly.y"
+#line 592 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 92:
-#line 596 "perly.y"
+#line 597 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
     break;
 
   case 93:
-#line 598 "perly.y"
+#line 599 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 94:
-#line 602 "perly.y"
+#line 603 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 95:
-#line 604 "perly.y"
+#line 605 "perly.y"
     {
                          if (!FEATURE_SIGNATURES_IS_ENABLED)
                            Perl_croak(aTHX_ "Experimental "
@@ -686,7 +687,7 @@ case 2:
     break;
 
   case 96:
-#line 614 "perly.y"
+#line 615 "perly.y"
     {
                          (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(2) - (3)].val.opval),
                                newSTATEOP(0, NULL, sawparens(newNULLLIST())));
@@ -695,7 +696,7 @@ case 2:
     break;
 
   case 97:
-#line 623 "perly.y"
+#line 624 "perly.y"
     {
                          if (parser->copline > (line_t)(ps[(3) - (5)].val.ival))
                              parser->copline = (line_t)(ps[(3) - (5)].val.ival);
@@ -705,37 +706,37 @@ case 2:
     break;
 
   case 98:
-#line 632 "perly.y"
+#line 633 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 99:
-#line 633 "perly.y"
+#line 634 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 100:
-#line 638 "perly.y"
+#line 639 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 101:
-#line 640 "perly.y"
+#line 641 "perly.y"
     { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 102:
-#line 642 "perly.y"
+#line 643 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 104:
-#line 648 "perly.y"
+#line 649 "perly.y"
     { (yyval.opval) = (ps[(1) - (2)].val.opval); ;}
     break;
 
   case 105:
-#line 650 "perly.y"
+#line 651 "perly.y"
     { 
                          OP* term = (ps[(3) - (3)].val.opval);
                          (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
@@ -743,21 +744,21 @@ case 2:
     break;
 
   case 107:
-#line 659 "perly.y"
+#line 660 "perly.y"
     { (yyval.opval) = op_convert_list((ps[(1) - (3)].val.ival), OPf_STACKED,
                                op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (3)].val.ival),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
                        ;}
     break;
 
   case 108:
-#line 663 "perly.y"
+#line 664 "perly.y"
     { (yyval.opval) = op_convert_list((ps[(1) - (5)].val.ival), OPf_STACKED,
                                op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (5)].val.ival),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
                        ;}
     break;
 
   case 109:
-#line 667 "perly.y"
+#line 668 "perly.y"
     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
@@ -766,7 +767,7 @@ case 2:
     break;
 
   case 110:
-#line 673 "perly.y"
+#line 674 "perly.y"
     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
                                    newMETHOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
@@ -774,7 +775,7 @@ case 2:
     break;
 
   case 111:
-#line 678 "perly.y"
+#line 679 "perly.y"
     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
@@ -783,7 +784,7 @@ case 2:
     break;
 
   case 112:
-#line 684 "perly.y"
+#line 685 "perly.y"
     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
@@ -792,23 +793,23 @@ case 2:
     break;
 
   case 113:
-#line 690 "perly.y"
+#line 691 "perly.y"
     { (yyval.opval) = op_convert_list((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 114:
-#line 692 "perly.y"
+#line 693 "perly.y"
     { (yyval.opval) = op_convert_list((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
     break;
 
   case 115:
-#line 694 "perly.y"
+#line 695 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
                          (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 116:
-#line 697 "perly.y"
+#line 698 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                 op_append_elem(OP_LIST,
                                   op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
@@ -816,18 +817,18 @@ case 2:
     break;
 
   case 119:
-#line 712 "perly.y"
+#line 713 "perly.y"
     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval))); ;}
     break;
 
   case 120:
-#line 714 "perly.y"
+#line 715 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
                        ;}
     break;
 
   case 121:
-#line 717 "perly.y"
+#line 718 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
                                        scalar((ps[(4) - (5)].val.opval)));
@@ -835,7 +836,7 @@ case 2:
     break;
 
   case 122:
-#line 722 "perly.y"
+#line 723 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
                                        scalar((ps[(3) - (4)].val.opval)));
@@ -843,78 +844,78 @@ case 2:
     break;
 
   case 123:
-#line 727 "perly.y"
+#line 728 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
                        ;}
     break;
 
   case 124:
-#line 730 "perly.y"
+#line 731 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(4) - (6)].val.opval))); ;}
     break;
 
   case 125:
-#line 734 "perly.y"
+#line 735 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(3) - (5)].val.opval))); ;}
     break;
 
   case 126:
-#line 738 "perly.y"
+#line 739 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); ;}
     break;
 
   case 127:
-#line 741 "perly.y"
+#line 742 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
                                       newCVREF(0, scalar((ps[(1) - (5)].val.opval))))); ;}
     break;
 
   case 128:
-#line 746 "perly.y"
+#line 747 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
                                               newCVREF(0, scalar((ps[(1) - (4)].val.opval))))); ;}
     break;
 
   case 129:
-#line 750 "perly.y"
+#line 751 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); ;}
     break;
 
   case 130:
-#line 753 "perly.y"
+#line 754 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); ;}
     break;
 
   case 131:
-#line 755 "perly.y"
+#line 756 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); ;}
     break;
 
   case 132:
-#line 757 "perly.y"
+#line 758 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); ;}
     break;
 
   case 133:
-#line 762 "perly.y"
+#line 763 "perly.y"
     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 134:
-#line 764 "perly.y"
+#line 765 "perly.y"
     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 135:
-#line 766 "perly.y"
+#line 767 "perly.y"
     {   if ((ps[(2) - (3)].val.ival) != OP_REPEAT)
                                scalar((ps[(1) - (3)].val.opval));
                            (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
@@ -922,94 +923,94 @@ case 2:
     break;
 
   case 136:
-#line 771 "perly.y"
+#line 772 "perly.y"
     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 137:
-#line 773 "perly.y"
+#line 774 "perly.y"
     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 138:
-#line 775 "perly.y"
+#line 776 "perly.y"
     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 139:
-#line 777 "perly.y"
+#line 778 "perly.y"
     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 140:
-#line 779 "perly.y"
+#line 780 "perly.y"
     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 141:
-#line 781 "perly.y"
+#line 782 "perly.y"
     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 142:
-#line 783 "perly.y"
+#line 784 "perly.y"
     { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
   case 143:
-#line 785 "perly.y"
+#line 786 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 144:
-#line 787 "perly.y"
+#line 788 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 145:
-#line 789 "perly.y"
+#line 790 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 146:
-#line 791 "perly.y"
+#line 792 "perly.y"
     { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 147:
-#line 796 "perly.y"
+#line 797 "perly.y"
     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 148:
-#line 798 "perly.y"
+#line 799 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
     break;
 
   case 149:
-#line 801 "perly.y"
+#line 802 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 150:
-#line 803 "perly.y"
+#line 804 "perly.y"
     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 151:
-#line 805 "perly.y"
+#line 806 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
                                        op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); ;}
     break;
 
   case 152:
-#line 808 "perly.y"
+#line 809 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
                                        op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));;}
     break;
 
   case 153:
-#line 811 "perly.y"
+#line 812 "perly.y"
     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
                                       op_append_elem(
                                        OP_LIST,
@@ -1023,120 +1024,120 @@ case 2:
     break;
 
   case 154:
-#line 822 "perly.y"
+#line 823 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREINC, 0,
                                        op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); ;}
     break;
 
   case 155:
-#line 825 "perly.y"
+#line 826 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
                                        op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); ;}
     break;
 
   case 156:
-#line 832 "perly.y"
+#line 833 "perly.y"
     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); ;}
     break;
 
   case 157:
-#line 834 "perly.y"
+#line 835 "perly.y"
     { (yyval.opval) = newANONLIST((OP*)NULL);;}
     break;
 
   case 158:
-#line 836 "perly.y"
+#line 837 "perly.y"
     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); ;}
     break;
 
   case 159:
-#line 838 "perly.y"
+#line 839 "perly.y"
     { (yyval.opval) = newANONHASH((OP*)NULL); ;}
     break;
 
   case 160:
-#line 840 "perly.y"
+#line 841 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
                          (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
     break;
 
   case 161:
-#line 847 "perly.y"
+#line 848 "perly.y"
     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));;}
     break;
 
   case 162:
-#line 849 "perly.y"
+#line 850 "perly.y"
     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));;}
     break;
 
   case 167:
-#line 857 "perly.y"
+#line 858 "perly.y"
     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
     break;
 
   case 168:
-#line 859 "perly.y"
+#line 860 "perly.y"
     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); ;}
     break;
 
   case 169:
-#line 861 "perly.y"
+#line 862 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 170:
-#line 863 "perly.y"
+#line 864 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
     break;
 
   case 171:
-#line 865 "perly.y"
+#line 866 "perly.y"
     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
     break;
 
   case 172:
-#line 867 "perly.y"
+#line 868 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 173:
-#line 869 "perly.y"
+#line 870 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST()); ;}
     break;
 
   case 174:
-#line 871 "perly.y"
+#line 872 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 175:
-#line 873 "perly.y"
+#line 874 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 176:
-#line 875 "perly.y"
+#line 876 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 177:
-#line 877 "perly.y"
+#line 878 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 178:
-#line 879 "perly.y"
+#line 880 "perly.y"
     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
     break;
 
   case 179:
-#line 881 "perly.y"
+#line 882 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 180:
-#line 883 "perly.y"
+#line 884 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_ASLICE, 0,
@@ -1149,7 +1150,7 @@ case 2:
     break;
 
   case 181:
-#line 893 "perly.y"
+#line 894 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_KVASLICE, 0,
@@ -1162,7 +1163,7 @@ case 2:
     break;
 
   case 182:
-#line 903 "perly.y"
+#line 904 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_HSLICE, 0,
@@ -1175,7 +1176,7 @@ case 2:
     break;
 
   case 183:
-#line 913 "perly.y"
+#line 914 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_KVHSLICE, 0,
@@ -1188,23 +1189,23 @@ case 2:
     break;
 
   case 184:
-#line 923 "perly.y"
+#line 924 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 185:
-#line 925 "perly.y"
+#line 926 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 186:
-#line 927 "perly.y"
+#line 928 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
                        ;}
     break;
 
   case 187:
-#line 930 "perly.y"
+#line 931 "perly.y"
     {
                          (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
@@ -1212,129 +1213,129 @@ case 2:
     break;
 
   case 188:
-#line 935 "perly.y"
+#line 936 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                            op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
                        ;}
     break;
 
   case 189:
-#line 939 "perly.y"
+#line 940 "perly.y"
     { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
   case 190:
-#line 941 "perly.y"
+#line 942 "perly.y"
     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
   case 191:
-#line 943 "perly.y"
+#line 944 "perly.y"
     { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
   case 192:
-#line 945 "perly.y"
+#line 946 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
                                       scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); ;}
     break;
 
   case 193:
-#line 948 "perly.y"
+#line 949 "perly.y"
     { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); ;}
     break;
 
   case 194:
-#line 950 "perly.y"
+#line 951 "perly.y"
     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), OPf_SPECIAL);
                            PL_hints |= HINT_BLOCK_SCOPE; ;}
     break;
 
   case 195:
-#line 953 "perly.y"
+#line 954 "perly.y"
     { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 196:
-#line 955 "perly.y"
+#line 956 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 197:
-#line 957 "perly.y"
+#line 958 "perly.y"
     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
     break;
 
   case 198:
-#line 959 "perly.y"
+#line 960 "perly.y"
     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 199:
-#line 961 "perly.y"
+#line 962 "perly.y"
     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 200:
-#line 963 "perly.y"
+#line 964 "perly.y"
     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); ;}
     break;
 
   case 201:
-#line 965 "perly.y"
+#line 966 "perly.y"
     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 202:
-#line 967 "perly.y"
+#line 968 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 203:
-#line 969 "perly.y"
+#line 970 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                            op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
     break;
 
   case 204:
-#line 972 "perly.y"
+#line 973 "perly.y"
     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
     break;
 
   case 205:
-#line 974 "perly.y"
+#line 975 "perly.y"
     { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);;}
     break;
 
   case 206:
-#line 976 "perly.y"
+#line 977 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 207:
-#line 978 "perly.y"
+#line 979 "perly.y"
     { (yyval.opval) = (ps[(1) - (3)].val.opval); ;}
     break;
 
   case 208:
-#line 980 "perly.y"
+#line 981 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 209:
-#line 982 "perly.y"
+#line 983 "perly.y"
     { (yyval.opval) = ((ps[(1) - (3)].val.ival) == OP_NOT)
                           ? newUNOP((ps[(1) - (3)].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
                           : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); ;}
     break;
 
   case 210:
-#line 986 "perly.y"
+#line 987 "perly.y"
     { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
     break;
 
   case 211:
-#line 988 "perly.y"
+#line 989 "perly.y"
     {
                            if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
                                && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
@@ -1348,12 +1349,12 @@ case 2:
     break;
 
   case 212:
-#line 999 "perly.y"
+#line 1000 "perly.y"
     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); ;}
     break;
 
   case 215:
-#line 1003 "perly.y"
+#line 1004 "perly.y"
     {
                          (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
                                newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
@@ -1361,136 +1362,136 @@ case 2:
     break;
 
   case 217:
-#line 1012 "perly.y"
+#line 1013 "perly.y"
     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 218:
-#line 1014 "perly.y"
+#line 1015 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
     break;
 
   case 219:
-#line 1019 "perly.y"
+#line 1020 "perly.y"
     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
     break;
 
   case 220:
-#line 1021 "perly.y"
+#line 1022 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST()); ;}
     break;
 
   case 221:
-#line 1024 "perly.y"
+#line 1025 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 222:
-#line 1026 "perly.y"
+#line 1027 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 223:
-#line 1028 "perly.y"
+#line 1029 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 224:
-#line 1033 "perly.y"
+#line 1034 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 225:
-#line 1035 "perly.y"
+#line 1036 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 226:
-#line 1039 "perly.y"
+#line 1040 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 227:
-#line 1041 "perly.y"
+#line 1042 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 228:
-#line 1047 "perly.y"
+#line 1048 "perly.y"
     { parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 234:
-#line 1060 "perly.y"
+#line 1061 "perly.y"
     { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 235:
-#line 1064 "perly.y"
+#line 1065 "perly.y"
     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 236:
-#line 1068 "perly.y"
+#line 1069 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
                        ;}
     break;
 
   case 237:
-#line 1074 "perly.y"
+#line 1075 "perly.y"
     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
                          if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
                        ;}
     break;
 
   case 238:
-#line 1080 "perly.y"
+#line 1081 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 239:
-#line 1082 "perly.y"
+#line 1083 "perly.y"
     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
   case 240:
-#line 1086 "perly.y"
+#line 1087 "perly.y"
     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 242:
-#line 1091 "perly.y"
+#line 1092 "perly.y"
     { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 244:
-#line 1096 "perly.y"
+#line 1097 "perly.y"
     { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 246:
-#line 1101 "perly.y"
+#line 1102 "perly.y"
     { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 247:
-#line 1106 "perly.y"
+#line 1107 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 248:
-#line 1108 "perly.y"
+#line 1109 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 249:
-#line 1110 "perly.y"
+#line 1111 "perly.y"
     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 250:
-#line 1113 "perly.y"
+#line 1114 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
@@ -1501,6 +1502,6 @@ case 2:
     
 
 /* Generated from:
- * 20fd9dcde08a4a26833ba7bf337260d78986b6542a0f55c00d7a9245af45faf5 perly.y
+ * 7c925861de53b976298e1b6e79a731de2d11247fd3db73f423cba0fd8c2e1afe perly.y
  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
  * ex: set ro: */
diff --git a/perly.h b/perly.h
index a015b55..b458b23 100644 (file)
--- a/perly.h
+++ b/perly.h
@@ -256,6 +256,6 @@ typedef union YYSTYPE
 
 
 /* Generated from:
- * 20fd9dcde08a4a26833ba7bf337260d78986b6542a0f55c00d7a9245af45faf5 perly.y
+ * 7c925861de53b976298e1b6e79a731de2d11247fd3db73f423cba0fd8c2e1afe perly.y
  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
  * ex: set ro: */
index 0e3cc46..401c95c 100644 (file)
--- a/perly.tab
+++ b/perly.tab
@@ -195,28 +195,28 @@ static const yytype_uint16 yyrline[] =
      158,   157,   170,   169,   181,   189,   197,   201,   209,   215,
      216,   226,   227,   236,   240,   244,   248,   255,   257,   268,
      267,   300,   308,   307,   316,   322,   328,   339,   341,   343,
-     350,   358,   360,   357,   376,   381,   388,   387,   402,   410,
-     416,   423,   422,   437,   441,   449,   467,   468,   473,   475,
-     477,   479,   481,   483,   485,   488,   494,   495,   500,   511,
-     512,   518,   524,   525,   530,   533,   537,   542,   546,   550,
-     554,   555,   559,   565,   570,   575,   576,   581,   582,   587,
-     588,   590,   595,   597,   602,   604,   603,   622,   632,   633,
-     637,   639,   641,   643,   647,   649,   654,   658,   662,   666,
-     672,   677,   683,   689,   691,   694,   693,   704,   705,   709,
-     713,   716,   721,   726,   729,   733,   737,   740,   745,   749,
-     752,   754,   756,   761,   763,   765,   770,   772,   774,   776,
-     778,   780,   782,   784,   786,   788,   790,   795,   797,   800,
-     802,   804,   807,   810,   821,   824,   831,   833,   835,   837,
-     839,   846,   848,   852,   853,   854,   855,   856,   858,   860,
-     862,   864,   866,   868,   870,   872,   874,   876,   878,   880,
-     882,   892,   902,   912,   922,   924,   926,   929,   934,   938,
-     940,   942,   944,   947,   949,   952,   954,   956,   958,   960,
-     962,   964,   966,   968,   971,   973,   975,   977,   979,   981,
-     985,   988,   987,  1000,  1001,  1002,  1007,  1011,  1013,  1018,
-    1020,  1023,  1025,  1027,  1032,  1034,  1039,  1040,  1046,  1050,
-    1051,  1052,  1055,  1056,  1059,  1063,  1067,  1073,  1079,  1081,
-    1085,  1089,  1090,  1094,  1095,  1099,  1100,  1105,  1107,  1109,
-    1112
+     350,   358,   360,   357,   377,   382,   389,   388,   403,   411,
+     417,   424,   423,   438,   442,   450,   468,   469,   474,   476,
+     478,   480,   482,   484,   486,   489,   495,   496,   501,   512,
+     513,   519,   525,   526,   531,   534,   538,   543,   547,   551,
+     555,   556,   560,   566,   571,   576,   577,   582,   583,   588,
+     589,   591,   596,   598,   603,   605,   604,   623,   633,   634,
+     638,   640,   642,   644,   648,   650,   655,   659,   663,   667,
+     673,   678,   684,   690,   692,   695,   694,   705,   706,   710,
+     714,   717,   722,   727,   730,   734,   738,   741,   746,   750,
+     753,   755,   757,   762,   764,   766,   771,   773,   775,   777,
+     779,   781,   783,   785,   787,   789,   791,   796,   798,   801,
+     803,   805,   808,   811,   822,   825,   832,   834,   836,   838,
+     840,   847,   849,   853,   854,   855,   856,   857,   859,   861,
+     863,   865,   867,   869,   871,   873,   875,   877,   879,   881,
+     883,   893,   903,   913,   923,   925,   927,   930,   935,   939,
+     941,   943,   945,   948,   950,   953,   955,   957,   959,   961,
+     963,   965,   967,   969,   972,   974,   976,   978,   980,   982,
+     986,   989,   988,  1001,  1002,  1003,  1008,  1012,  1014,  1019,
+    1021,  1024,  1026,  1028,  1033,  1035,  1040,  1041,  1047,  1051,
+    1052,  1053,  1056,  1057,  1060,  1064,  1068,  1074,  1080,  1082,
+    1086,  1090,  1091,  1095,  1096,  1100,  1101,  1106,  1108,  1110,
+    1113
 };
 #endif
 
@@ -1140,6 +1140,6 @@ static const toketypes yy_type_tab[] =
 };
 
 /* Generated from:
- * 20fd9dcde08a4a26833ba7bf337260d78986b6542a0f55c00d7a9245af45faf5 perly.y
+ * 7c925861de53b976298e1b6e79a731de2d11247fd3db73f423cba0fd8c2e1afe perly.y
  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
  * ex: set ro: */
diff --git a/perly.y b/perly.y
index ece2904..6ba61ae 100644 (file)
--- a/perly.y
+++ b/perly.y
@@ -370,6 +370,7 @@ barestmt:   PLUGSTMT
                                      newOP(OP_UNSTACK, OPf_SPECIAL),
                                      forop));
                          }
+                         PL_hints |= HINT_BLOCK_SCOPE;
                          $$ = block_end($3, forop);
                          parser->copline = (line_t)$1;
                        }
index f53cecc..a1ce676 100644 (file)
@@ -1,6 +1,6 @@
 #!./perl
 
-print "1..15\n";
+print "1..16\n";
 
 for ($i = 0; $i <= 10; $i++) {
     $x[$i] = $i;
@@ -101,3 +101,8 @@ for ("${\''}") {
     print 'ok 15 - [perl \#78194] \$_ == \$_ inside for("$x"){...}',
           "\n";
 }
+
+# [perl #123286] Lone C-style for in a block messes up the stack
+@_ = (1..3, do {for(0;0;){}}, 4..6);
+print "not " unless "@_" eq '1 2 3 0 4 5 6';
+print "ok 16 - [perl #78194] Lone C-style for in a block\n";