stop passing line numbers into op constructor functions

Remove the line number parameter from newWHILEOP() and newFOROP()
functions.  Instead, the line number for the impending COP is set by
parser code after constructing the ops.  (In fact the parser was doing
this anyway in most cases.)  This brings newWHILEOP() and newFOROP()
in line with the other op constructors, in that they do not concern
themselves with COPs.

diff --git a/embed.fnc b/embed.fnc
index 9f992c1..5dce84b 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -780,8 +780,7 @@ Ap  |OP*    |newFORM        |I32 floor|NULLOK OP* o|NULLOK OP* block
 #else
 Ap     |void   |newFORM        |I32 floor|NULLOK OP* o|NULLOK OP* block
 #endif
-Apda   |OP*    |newFOROP       |I32 flags|line_t forline \
-                               |NULLOK OP* sv|NN OP* expr|NULLOK OP* block|NULLOK OP* cont
+Apda   |OP*    |newFOROP       |I32 flags|NULLOK OP* sv|NN OP* expr|NULLOK OP* block|NULLOK OP* cont
 Apda   |OP*    |newGIVENOP     |NN OP* cond|NN OP* block|PADOFFSET defsv_off
 Apda   |OP*    |newLOGOP       |I32 optype|I32 flags|NN OP *first|NN OP *other
 Apda   |OP*    |newLOOPEX      |I32 type|NN OP* label
@@ -837,7 +836,7 @@ Apda        |SV*    |newSV_type     |const svtype type
 Apda   |OP*    |newUNOP        |I32 type|I32 flags|NULLOK OP* first
 Apda   |OP*    |newWHENOP      |NULLOK OP* cond|NN OP* block
 Apda   |OP*    |newWHILEOP     |I32 flags|I32 debuggable|NULLOK LOOP* loop \
-                               |I32 whileline|NULLOK OP* expr|NULLOK OP* block|NULLOK OP* cont \
+                               |NULLOK OP* expr|NULLOK OP* block|NULLOK OP* cont \
                                |I32 has_my
 Apd    |CV*    |rv2cv_op_cv    |NN OP *cvop|U32 flags
 Apd    |OP*    |ck_entersub_args_list|NN OP *entersubop

diff --git a/embed.h b/embed.h
index a7093f6..4f836c4 100644 (file)
--- a/embed.h
+++ b/embed.h
@@ -311,7 +311,7 @@
 #define newCONDOP(a,b,c,d)     Perl_newCONDOP(aTHX_ a,b,c,d)
 #define newCONSTSUB(a,b,c)     Perl_newCONSTSUB(aTHX_ a,b,c)
 #define newCVREF(a,b)          Perl_newCVREF(aTHX_ a,b)
-#define newFOROP(a,b,c,d,e,f)  Perl_newFOROP(aTHX_ a,b,c,d,e,f)
+#define newFOROP(a,b,c,d,e)    Perl_newFOROP(aTHX_ a,b,c,d,e)
 #define newGIVENOP(a,b,c)      Perl_newGIVENOP(aTHX_ a,b,c)
 #define newGVOP(a,b,c)         Perl_newGVOP(aTHX_ a,b,c)
 #define newGVREF(a,b)          Perl_newGVREF(aTHX_ a,b)
@@ -353,7 +353,7 @@
 #define newSVuv(a)             Perl_newSVuv(aTHX_ a)
 #define newUNOP(a,b,c)         Perl_newUNOP(aTHX_ a,b,c)
 #define newWHENOP(a,b)         Perl_newWHENOP(aTHX_ a,b)
-#define newWHILEOP(a,b,c,d,e,f,g,h)    Perl_newWHILEOP(aTHX_ a,b,c,d,e,f,g,h)
+#define newWHILEOP(a,b,c,d,e,f,g)      Perl_newWHILEOP(aTHX_ a,b,c,d,e,f,g)
 #define newXS(a,b,c)           Perl_newXS(aTHX_ a,b,c)
 #define newXS_flags(a,b,c,d,e) Perl_newXS_flags(aTHX_ a,b,c,d,e)
 #define new_collate(a)         Perl_new_collate(aTHX_ a)

diff --git a/ext/XS-APItest/APItest.xs b/ext/XS-APItest/APItest.xs
index 0ff2ed1..99c96d9 100644 (file)
--- a/ext/XS-APItest/APItest.xs
+++ b/ext/XS-APItest/APItest.xs
@@ -741,12 +741,8 @@ static OP *THX_parse_keyword_swaptwostmts(pTHX)
 #define parse_keyword_looprest() THX_parse_keyword_looprest(aTHX)
 static OP *THX_parse_keyword_looprest(pTHX)
 {
-    I32 condline;
-    OP *body;
-    condline = CopLINE(PL_curcop);
-    body = parse_stmtseq(0);
-    return newWHILEOP(0, 1, NULL, condline, newSVOP(OP_CONST, 0, &PL_sv_yes),
-                       body, NULL, 1);
+    return newWHILEOP(0, 1, NULL, newSVOP(OP_CONST, 0, &PL_sv_yes),
+                       parse_stmtseq(0), NULL, 1);
 }
 
 #define parse_keyword_scopelessblock() THX_parse_keyword_scopelessblock(aTHX)
@@ -794,12 +790,8 @@ static OP *THX_parse_keyword_stmtsasexpr(pTHX)
 #define parse_keyword_loopblock() THX_parse_keyword_loopblock(aTHX)
 static OP *THX_parse_keyword_loopblock(pTHX)
 {
-    I32 condline;
-    OP *body;
-    condline = CopLINE(PL_curcop);
-    body = parse_block(0);
-    return newWHILEOP(0, 1, NULL, condline, newSVOP(OP_CONST, 0, &PL_sv_yes),
-                       body, NULL, 1);
+    return newWHILEOP(0, 1, NULL, newSVOP(OP_CONST, 0, &PL_sv_yes),
+                       parse_block(0), NULL, 1);
 }
 
 #define parse_keyword_blockasexpr() THX_parse_keyword_blockasexpr(aTHX)

diff --git a/op.c b/op.c
index c082921..21f8e97 100644 (file)
--- a/op.c
+++ b/op.c
@@ -5301,7 +5301,7 @@ Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
 }
 
 /*
-=for apidoc Am|OP *|newWHILEOP|I32 flags|I32 debuggable|LOOP *loop|I32 whileline|OP *expr|OP *block|OP *cont|I32 has_my
+=for apidoc Am|OP *|newWHILEOP|I32 flags|I32 debuggable|LOOP *loop|OP *expr|OP *block|OP *cont|I32 has_my
 
 Constructs, checks, and returns an op tree expressing a C<while> loop.
 This is a heavyweight loop, with structure that allows exiting the loop
@@ -5318,16 +5318,15 @@ I<flags> gives the eight bits of C<op_flags> for the C<leaveloop>
 op and, shifted up eight bits, the eight bits of C<op_private> for
 the C<leaveloop> op, except that (in both cases) some bits will be set
 automatically.  I<debuggable> is currently unused and should always be 1.
-I<whileline> is the line number that should be attributed to the loop's
-controlling expression.  I<has_my> can be supplied as true to force the
+I<has_my> can be supplied as true to force the
 loop body to be enclosed in its own scope.
 
 =cut
 */
 
 OP *
-Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, I32
-whileline, OP *expr, OP *block, OP *cont, I32 has_my)
+Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop,
+       OP *expr, OP *block, OP *cont, I32 has_my)
 {
     dVAR;
     OP *redo;
@@ -5389,7 +5388,6 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
     redo = LINKLIST(listop);
 
     if (expr) {
-       PL_parser->copline = (line_t)whileline;
        scalar(listop);
        o = new_logop(OP_AND, 0, &expr, &listop);
        if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) {
@@ -5429,7 +5427,7 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
 }
 
 /*
-=for apidoc Am|OP *|newFOROP|I32 flags|line_t forline|OP *sv|OP *expr|OP *block|OP *cont
+=for apidoc Am|OP *|newFOROP|I32 flags|OP *sv|OP *expr|OP *block|OP *cont
 
 Constructs, checks, and returns an op tree expressing a C<foreach>
 loop (iteration through a list of values).  This is a heavyweight loop,
@@ -5446,14 +5444,13 @@ op tree.
 I<flags> gives the eight bits of C<op_flags> for the C<leaveloop>
 op and, shifted up eight bits, the eight bits of C<op_private> for
 the C<leaveloop> op, except that (in both cases) some bits will be set
-automatically.  I<forline> is the line number that should be attributed
-to the loop's list expression.
+automatically.
 
 =cut
 */
 
 OP *
-Perl_newFOROP(pTHX_ I32 flags, line_t forline, OP *sv, OP *expr, OP *block, OP *cont)
+Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont)
 {
     dVAR;
     LOOP *loop;
@@ -5571,7 +5568,7 @@ Perl_newFOROP(pTHX_ I32 flags, line_t forline, OP *sv, OP *expr, OP *block, OP *
     loop = (LOOP*)PerlMemShared_realloc(loop, sizeof(LOOP));
 #endif
     loop->op_targ = padoff;
-    wop = newWHILEOP(flags, 1, loop, forline, newOP(OP_ITER, 0), block, cont, 0);
+    wop = newWHILEOP(flags, 1, loop, newOP(OP_ITER, 0), block, cont, 0);
     if (madsv)
        op_getmad(madsv, (OP*)loop, 'v');
     return wop;

diff --git a/perly.act b/perly.act
index 81fbcf3..50e525b 100644 (file)
--- a/perly.act
+++ b/perly.act
@@ -288,7 +288,7 @@ case 2:
     {
                          (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
                                  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                     IVAL((ps[(1) - (8)].val.i_tkval)), (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
+                                     (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
                          TOKEN_GETMAD((ps[(1) - (8)].val.i_tkval),(yyval.opval),'W');
                          TOKEN_GETMAD((ps[(2) - (8)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(5) - (8)].val.i_tkval),(yyval.opval),')');
@@ -300,8 +300,8 @@ case 2:
 #line 375 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
-                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                     IVAL((ps[(1) - (8)].val.i_tkval)), (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
+                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
+                                     (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
                          TOKEN_GETMAD((ps[(1) - (8)].val.i_tkval),(yyval.opval),'W');
                          TOKEN_GETMAD((ps[(2) - (8)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(5) - (8)].val.i_tkval),(yyval.opval),')');
@@ -314,7 +314,7 @@ case 2:
     {
                          OP *initop = IF_MAD((ps[(4) - (11)].val.opval) ? (ps[(4) - (11)].val.opval) : newOP(OP_NULL, 0), (ps[(4) - (11)].val.opval));
                          OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                     IVAL((ps[(1) - (11)].val.i_tkval)), scalar((ps[(6) - (11)].val.opval)), (ps[(11) - (11)].val.opval), (ps[(9) - (11)].val.opval), (ps[(8) - (11)].val.ival));
+                                     scalar((ps[(6) - (11)].val.opval)), (ps[(11) - (11)].val.opval), (ps[(9) - (11)].val.opval), (ps[(8) - (11)].val.ival));
                          if (initop) {
                              forop = op_prepend_elem(OP_LINESEQ, initop,
                                  op_append_elem(OP_LINESEQ,
@@ -335,9 +335,7 @@ case 2:
   case 35:
 #line 406 "perly.y"
     {
-                         (yyval.opval) = block_end((ps[(3) - (9)].val.ival),
-                                 newFOROP(0, (line_t)IVAL((ps[(1) - (9)].val.i_tkval)),
-                                     (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
+                         (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)));
                          TOKEN_GETMAD((ps[(1) - (9)].val.i_tkval),(yyval.opval),'W');
                          TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),(yyval.opval),'d');
                          TOKEN_GETMAD((ps[(5) - (9)].val.i_tkval),(yyval.opval),'(');
@@ -347,10 +345,9 @@ case 2:
     break;
 
   case 36:
-#line 417 "perly.y"
+#line 415 "perly.y"
     {
-                         (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
-                                 newFOROP(0, (line_t)IVAL((ps[(1) - (8)].val.i_tkval)),
+                         (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
                                      mod((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (8)].val.i_tkval),(yyval.opval),'W');
                          TOKEN_GETMAD((ps[(3) - (8)].val.i_tkval),(yyval.opval),'(');
@@ -360,11 +357,10 @@ case 2:
     break;
 
   case 37:
-#line 427 "perly.y"
+#line 424 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
-                                 newFOROP(0, (line_t)IVAL((ps[(1) - (7)].val.i_tkval)),
-                                     (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
+                                 newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'W');
                          TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
@@ -373,16 +369,17 @@ case 2:
     break;
 
   case 38:
-#line 437 "perly.y"
+#line 433 "perly.y"
     {
                          /* a block is a loop that happens once */
                          (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                 NOLINE, (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), 0);
+                                 (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), 0);
+                         PL_parser->copline = NOLINE;
                        ;}
     break;
 
   case 39:
-#line 443 "perly.y"
+#line 440 "perly.y"
     {
                          int save_3_latefree = (ps[(3) - (5)].val.opval)->op_latefree;
                          (ps[(3) - (5)].val.opval)->op_latefree = 1;
@@ -398,10 +395,10 @@ case 2:
     break;
 
   case 40:
-#line 456 "perly.y"
+#line 453 "perly.y"
     {
                          /* a block is a loop that happens once */
-                         (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL, NOLINE,
+                         (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                  (OP*)NULL, block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval)), (OP*)NULL, 0);
                          op_free((ps[(3) - (8)].val.opval));
                          if ((ps[(2) - (8)].val.opval))
@@ -414,7 +411,7 @@ case 2:
     break;
 
   case 41:
-#line 469 "perly.y"
+#line 466 "perly.y"
     {
                          PL_parser->expect = XSTATE;
                          (yyval.opval) = (ps[(1) - (2)].val.opval);
@@ -423,7 +420,7 @@ case 2:
     break;
 
   case 42:
-#line 475 "perly.y"
+#line 472 "perly.y"
     {
                          PL_parser->expect = XSTATE;
                          (yyval.opval) = IF_MAD(newOP(OP_NULL, 0), (OP*)NULL);
@@ -433,70 +430,70 @@ case 2:
     break;
 
   case 43:
-#line 485 "perly.y"
+#line 482 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 44:
-#line 487 "perly.y"
+#line 484 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 45:
-#line 489 "perly.y"
+#line 486 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                        ;}
     break;
 
   case 46:
-#line 493 "perly.y"
+#line 490 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                        ;}
     break;
 
   case 47:
-#line 497 "perly.y"
+#line 494 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
                        ;}
     break;
 
   case 48:
-#line 501 "perly.y"
+#line 498 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
                        ;}
     break;
 
   case 49:
-#line 505 "perly.y"
-    { (yyval.opval) = newFOROP(0, (line_t)IVAL((ps[(2) - (3)].val.i_tkval)),
-                                       (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
+#line 502 "perly.y"
+    { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
+                         PL_parser->copline = (line_t)IVAL((ps[(2) - (3)].val.i_tkval));
                        ;}
     break;
 
   case 50:
-#line 510 "perly.y"
+#line 507 "perly.y"
     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), scope((ps[(1) - (3)].val.opval))); ;}
     break;
 
   case 51:
-#line 515 "perly.y"
+#line 512 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 52:
-#line 517 "perly.y"
+#line 514 "perly.y"
     { ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS; (yyval.opval) = scope((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 53:
-#line 521 "perly.y"
+#line 518 "perly.y"
     { PL_parser->copline = (line_t)IVAL((ps[(1) - (6)].val.i_tkval));
                            (yyval.opval) = newCONDOP(0, newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)), scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
                            PL_hints |= HINT_BLOCK_SCOPE;
@@ -507,58 +504,58 @@ case 2:
     break;
 
   case 54:
-#line 532 "perly.y"
+#line 529 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 55:
-#line 534 "perly.y"
+#line 531 "perly.y"
     { (yyval.opval) = scope((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 56:
-#line 541 "perly.y"
+#line 538 "perly.y"
     { (yyval.ival) = (PL_min_intro_pending &&
                            PL_max_intro_pending >=  PL_min_intro_pending);
                          intro_my(); ;}
     break;
 
   case 57:
-#line 547 "perly.y"
+#line 544 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 59:
-#line 553 "perly.y"
+#line 550 "perly.y"
     { YYSTYPE tmplval;
                          (void)scan_num("1", &tmplval);
                          (yyval.opval) = tmplval.opval; ;}
     break;
 
   case 61:
-#line 561 "perly.y"
+#line 558 "perly.y"
     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 62:
-#line 566 "perly.y"
+#line 563 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 63:
-#line 570 "perly.y"
+#line 567 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 64:
-#line 574 "perly.y"
+#line 571 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 65:
-#line 579 "perly.y"
+#line 576 "perly.y"
     {
 #ifdef MAD
                          YYSTYPE tmplval;
@@ -571,35 +568,35 @@ case 2:
     break;
 
   case 67:
-#line 591 "perly.y"
+#line 588 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 68:
-#line 592 "perly.y"
+#line 589 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 69:
-#line 596 "perly.y"
+#line 593 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 70:
-#line 602 "perly.y"
+#line 599 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 71:
-#line 607 "perly.y"
+#line 604 "perly.y"
     { (yyval.ival) = start_subparse(TRUE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 72:
-#line 612 "perly.y"
+#line 609 "perly.y"
     { const char *const name = SvPV_nolen_const(((SVOP*)(ps[(1) - (1)].val.opval))->op_sv);
                          if (strEQ(name, "BEGIN") || strEQ(name, "END")
                              || strEQ(name, "INIT") || strEQ(name, "CHECK")
@@ -609,24 +606,24 @@ case 2:
     break;
 
   case 73:
-#line 622 "perly.y"
+#line 619 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 75:
-#line 628 "perly.y"
+#line 625 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 76:
-#line 630 "perly.y"
+#line 627 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
   case 77:
-#line 634 "perly.y"
+#line 631 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -636,14 +633,14 @@ case 2:
     break;
 
   case 78:
-#line 644 "perly.y"
+#line 641 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
   case 79:
-#line 648 "perly.y"
+#line 645 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -653,12 +650,12 @@ case 2:
     break;
 
   case 80:
-#line 657 "perly.y"
+#line 654 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 81:
-#line 658 "perly.y"
+#line 655 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL,0),
                                    (OP*)NULL
@@ -669,28 +666,28 @@ case 2:
     break;
 
   case 82:
-#line 669 "perly.y"
+#line 666 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 83:
-#line 673 "perly.y"
+#line 670 "perly.y"
     { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 84:
-#line 677 "perly.y"
+#line 674 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 86:
-#line 685 "perly.y"
+#line 682 "perly.y"
     {
 #ifdef MAD
                          OP* op = newNULLLIST();
@@ -703,7 +700,7 @@ case 2:
     break;
 
   case 87:
-#line 695 "perly.y"
+#line 692 "perly.y"
     { 
                          OP* term = (ps[(3) - (3)].val.opval);
                          DO_MAD(
@@ -715,7 +712,7 @@ case 2:
     break;
 
   case 89:
-#line 708 "perly.y"
+#line 705 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
                                op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
@@ -723,7 +720,7 @@ case 2:
     break;
 
   case 90:
-#line 713 "perly.y"
+#line 710 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
                                op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
@@ -733,7 +730,7 @@ case 2:
     break;
 
   case 91:
-#line 720 "perly.y"
+#line 717 "perly.y"
     { (yyval.opval) = convert(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)),
@@ -745,7 +742,7 @@ case 2:
     break;
 
   case 92:
-#line 729 "perly.y"
+#line 726 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
                                    newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
@@ -754,7 +751,7 @@ case 2:
     break;
 
   case 93:
-#line 735 "perly.y"
+#line 732 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
@@ -763,7 +760,7 @@ case 2:
     break;
 
   case 94:
-#line 741 "perly.y"
+#line 738 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
@@ -774,14 +771,14 @@ case 2:
     break;
 
   case 95:
-#line 749 "perly.y"
+#line 746 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 96:
-#line 753 "perly.y"
+#line 750 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
@@ -790,13 +787,13 @@ case 2:
     break;
 
   case 97:
-#line 759 "perly.y"
+#line 756 "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 98:
-#line 762 "perly.y"
+#line 759 "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)));
@@ -804,7 +801,7 @@ case 2:
     break;
 
   case 101:
-#line 777 "perly.y"
+#line 774 "perly.y"
     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
                            PL_parser->expect = XOPERATOR;
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
@@ -814,7 +811,7 @@ case 2:
     break;
 
   case 102:
-#line 784 "perly.y"
+#line 781 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
@@ -822,7 +819,7 @@ case 2:
     break;
 
   case 103:
-#line 789 "perly.y"
+#line 786 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
                                        scalar((ps[(4) - (5)].val.opval)));
@@ -833,7 +830,7 @@ case 2:
     break;
 
   case 104:
-#line 797 "perly.y"
+#line 794 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
                                        scalar((ps[(3) - (4)].val.opval)));
@@ -843,7 +840,7 @@ case 2:
     break;
 
   case 105:
-#line 804 "perly.y"
+#line 801 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
                            PL_parser->expect = XOPERATOR;
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
@@ -853,7 +850,7 @@ case 2:
     break;
 
   case 106:
-#line 811 "perly.y"
+#line 808 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(4) - (6)].val.opval)));
@@ -866,7 +863,7 @@ case 2:
     break;
 
   case 107:
-#line 821 "perly.y"
+#line 818 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(3) - (5)].val.opval)));
@@ -878,7 +875,7 @@ case 2:
     break;
 
   case 108:
-#line 830 "perly.y"
+#line 827 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
@@ -888,7 +885,7 @@ case 2:
     break;
 
   case 109:
-#line 837 "perly.y"
+#line 834 "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)))));
@@ -899,7 +896,7 @@ case 2:
     break;
 
   case 110:
-#line 846 "perly.y"
+#line 843 "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)))));
@@ -909,7 +906,7 @@ case 2:
     break;
 
   case 111:
-#line 853 "perly.y"
+#line 850 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
@@ -918,7 +915,7 @@ case 2:
     break;
 
   case 112:
-#line 859 "perly.y"
+#line 856 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
@@ -928,7 +925,7 @@ case 2:
     break;
 
   case 113:
-#line 866 "perly.y"
+#line 863 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
@@ -936,7 +933,7 @@ case 2:
     break;
 
   case 114:
-#line 871 "perly.y"
+#line 868 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
@@ -946,21 +943,21 @@ case 2:
     break;
 
   case 115:
-#line 881 "perly.y"
+#line 878 "perly.y"
     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 116:
-#line 885 "perly.y"
+#line 882 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 117:
-#line 889 "perly.y"
+#line 886 "perly.y"
     {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
                                scalar((ps[(1) - (3)].val.opval));
                            (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
@@ -969,49 +966,49 @@ case 2:
     break;
 
   case 118:
-#line 895 "perly.y"
+#line 892 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 119:
-#line 899 "perly.y"
+#line 896 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 120:
-#line 903 "perly.y"
+#line 900 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 121:
-#line 907 "perly.y"
+#line 904 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 122:
-#line 911 "perly.y"
+#line 908 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 123:
-#line 915 "perly.y"
+#line 912 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 124:
-#line 919 "perly.y"
+#line 916 "perly.y"
     {
                          (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          DO_MAD({
@@ -1026,28 +1023,28 @@ case 2:
     break;
 
   case 125:
-#line 931 "perly.y"
+#line 928 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 126:
-#line 935 "perly.y"
+#line 932 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 127:
-#line 939 "perly.y"
+#line 936 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 128:
-#line 943 "perly.y"
+#line 940 "perly.y"
     { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
                                ((yyval.opval)->op_type == OP_NOT
@@ -1057,14 +1054,14 @@ case 2:
     break;
 
   case 129:
-#line 953 "perly.y"
+#line 950 "perly.y"
     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 130:
-#line 957 "perly.y"
+#line 954 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
                                    (ps[(2) - (2)].val.opval)
@@ -1074,21 +1071,21 @@ case 2:
     break;
 
   case 131:
-#line 964 "perly.y"
+#line 961 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 132:
-#line 968 "perly.y"
+#line 965 "perly.y"
     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 133:
-#line 972 "perly.y"
+#line 969 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
                                        mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1096,7 +1093,7 @@ case 2:
     break;
 
   case 134:
-#line 977 "perly.y"
+#line 974 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
                                        mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1104,7 +1101,7 @@ case 2:
     break;
 
   case 135:
-#line 982 "perly.y"
+#line 979 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREINC, 0,
                                        mod(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1112,7 +1109,7 @@ case 2:
     break;
 
   case 136:
-#line 987 "perly.y"
+#line 984 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
                                        mod(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1120,7 +1117,7 @@ case 2:
     break;
 
   case 137:
-#line 996 "perly.y"
+#line 993 "perly.y"
     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
@@ -1128,7 +1125,7 @@ case 2:
     break;
 
   case 138:
-#line 1001 "perly.y"
+#line 998 "perly.y"
     { (yyval.opval) = newANONLIST((OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
@@ -1136,7 +1133,7 @@ case 2:
     break;
 
   case 139:
-#line 1006 "perly.y"
+#line 1003 "perly.y"
     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
@@ -1145,7 +1142,7 @@ case 2:
     break;
 
   case 140:
-#line 1012 "perly.y"
+#line 1009 "perly.y"
     { (yyval.opval) = newANONHASH((OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
@@ -1154,7 +1151,7 @@ case 2:
     break;
 
   case 141:
-#line 1018 "perly.y"
+#line 1015 "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));
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
@@ -1164,21 +1161,21 @@ case 2:
     break;
 
   case 142:
-#line 1029 "perly.y"
+#line 1026 "perly.y"
     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 143:
-#line 1033 "perly.y"
+#line 1030 "perly.y"
     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, scope((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
                        ;}
     break;
 
   case 144:
-#line 1037 "perly.y"
+#line 1034 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
@@ -1193,7 +1190,7 @@ case 2:
     break;
 
   case 145:
-#line 1049 "perly.y"
+#line 1046 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
                            op_append_elem(OP_LIST,
@@ -1209,7 +1206,7 @@ case 2:
     break;
 
   case 146:
-#line 1062 "perly.y"
+#line 1059 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
                                scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), (OP*)NULL)); dep();
@@ -1220,7 +1217,7 @@ case 2:
     break;
 
   case 147:
-#line 1070 "perly.y"
+#line 1067 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
                                (ps[(4) - (5)].val.opval),
@@ -1232,7 +1229,7 @@ case 2:
     break;
 
   case 152:
-#line 1086 "perly.y"
+#line 1083 "perly.y"
     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
@@ -1240,26 +1237,26 @@ case 2:
     break;
 
   case 153:
-#line 1091 "perly.y"
+#line 1088 "perly.y"
     { (yyval.opval) = newUNOP(OP_REFGEN, 0, mod((ps[(2) - (2)].val.opval),OP_REFGEN));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 154:
-#line 1095 "perly.y"
+#line 1092 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 155:
-#line 1097 "perly.y"
+#line 1094 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
                        ;}
     break;
 
   case 156:
-#line 1101 "perly.y"
+#line 1098 "perly.y"
     { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1267,12 +1264,12 @@ case 2:
     break;
 
   case 157:
-#line 1106 "perly.y"
+#line 1103 "perly.y"
     { (yyval.opval) = IF_MAD(newUNOP(OP_NULL,0,(ps[(1) - (1)].val.opval)), (ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 158:
-#line 1108 "perly.y"
+#line 1105 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST());
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
@@ -1280,37 +1277,37 @@ case 2:
     break;
 
   case 159:
-#line 1113 "perly.y"
+#line 1110 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 160:
-#line 1115 "perly.y"
+#line 1112 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 161:
-#line 1117 "perly.y"
+#line 1114 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 162:
-#line 1119 "perly.y"
+#line 1116 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 163:
-#line 1121 "perly.y"
+#line 1118 "perly.y"
     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
     break;
 
   case 164:
-#line 1123 "perly.y"
+#line 1120 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 165:
-#line 1125 "perly.y"
+#line 1122 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_ASLICE, 0,
@@ -1322,7 +1319,7 @@ case 2:
     break;
 
   case 166:
-#line 1134 "perly.y"
+#line 1131 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_HSLICE, 0,
@@ -1336,17 +1333,17 @@ case 2:
     break;
 
   case 167:
-#line 1145 "perly.y"
+#line 1142 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 168:
-#line 1147 "perly.y"
+#line 1144 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 169:
-#line 1149 "perly.y"
+#line 1146 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1354,7 +1351,7 @@ case 2:
     break;
 
   case 170:
-#line 1154 "perly.y"
+#line 1151 "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))));
@@ -1370,7 +1367,7 @@ case 2:
     break;
 
   case 171:
-#line 1167 "perly.y"
+#line 1164 "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))));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
@@ -1378,7 +1375,7 @@ case 2:
     break;
 
   case 172:
-#line 1172 "perly.y"
+#line 1169 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
                            PL_hints |= HINT_BLOCK_SCOPE;
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
@@ -1386,74 +1383,74 @@ case 2:
     break;
 
   case 173:
-#line 1177 "perly.y"
+#line 1174 "perly.y"
     { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 174:
-#line 1181 "perly.y"
+#line 1178 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 175:
-#line 1185 "perly.y"
+#line 1182 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 176:
-#line 1189 "perly.y"
+#line 1186 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 177:
-#line 1193 "perly.y"
+#line 1190 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 178:
-#line 1197 "perly.y"
+#line 1194 "perly.y"
     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 179:
-#line 1201 "perly.y"
+#line 1198 "perly.y"
     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 180:
-#line 1205 "perly.y"
+#line 1202 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 181:
-#line 1207 "perly.y"
+#line 1204 "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 182:
-#line 1210 "perly.y"
+#line 1207 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 183:
-#line 1214 "perly.y"
+#line 1211 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
@@ -1462,13 +1459,13 @@ case 2:
     break;
 
   case 184:
-#line 1220 "perly.y"
+#line 1217 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 185:
-#line 1223 "perly.y"
+#line 1220 "perly.y"
     { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
                            ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
                            : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
@@ -1480,7 +1477,7 @@ case 2:
     break;
 
   case 186:
-#line 1232 "perly.y"
+#line 1229 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
@@ -1489,7 +1486,7 @@ case 2:
     break;
 
   case 187:
-#line 1238 "perly.y"
+#line 1235 "perly.y"
     { (yyval.opval) = pmruntime((ps[(1) - (4)].val.opval), (ps[(3) - (4)].val.opval), 1);
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
@@ -1497,7 +1494,7 @@ case 2:
     break;
 
   case 190:
-#line 1245 "perly.y"
+#line 1242 "perly.y"
     {
                          (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
                                newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
@@ -1506,7 +1503,7 @@ case 2:
     break;
 
   case 192:
-#line 1255 "perly.y"
+#line 1252 "perly.y"
     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
                          DO_MAD(
                              token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
@@ -1517,14 +1514,14 @@ case 2:
     break;
 
   case 193:
-#line 1263 "perly.y"
+#line 1260 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
                        ;}
     break;
 
   case 194:
-#line 1270 "perly.y"
+#line 1267 "perly.y"
     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1532,7 +1529,7 @@ case 2:
     break;
 
   case 195:
-#line 1275 "perly.y"
+#line 1272 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST());
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
@@ -1540,119 +1537,119 @@ case 2:
     break;
 
   case 196:
-#line 1280 "perly.y"
+#line 1277 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 197:
-#line 1282 "perly.y"
+#line 1279 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 198:
-#line 1284 "perly.y"
+#line 1281 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 199:
-#line 1289 "perly.y"
+#line 1286 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 200:
-#line 1291 "perly.y"
+#line 1288 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 201:
-#line 1295 "perly.y"
+#line 1292 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 202:
-#line 1297 "perly.y"
+#line 1294 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 203:
-#line 1301 "perly.y"
+#line 1298 "perly.y"
     { (yyval.i_tkval) = (ps[(1) - (1)].val.i_tkval); ;}
     break;
 
   case 204:
-#line 1303 "perly.y"
+#line 1300 "perly.y"
     { munge_qwlist_to_paren_list((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 205:
-#line 1305 "perly.y"
+#line 1302 "perly.y"
     { (yyval.i_tkval) = (ps[(3) - (3)].val.i_tkval); ;}
     break;
 
   case 206:
-#line 1311 "perly.y"
+#line 1308 "perly.y"
     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 207:
-#line 1315 "perly.y"
+#line 1312 "perly.y"
     { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
                        ;}
     break;
 
   case 208:
-#line 1321 "perly.y"
+#line 1318 "perly.y"
     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
                        ;}
     break;
 
   case 209:
-#line 1327 "perly.y"
+#line 1324 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
                        ;}
     break;
 
   case 210:
-#line 1333 "perly.y"
+#line 1330 "perly.y"
     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
                        ;}
     break;
 
   case 211:
-#line 1339 "perly.y"
+#line 1336 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
                        ;}
     break;
 
   case 212:
-#line 1345 "perly.y"
+#line 1342 "perly.y"
     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
                        ;}
     break;
 
   case 213:
-#line 1352 "perly.y"
+#line 1349 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 214:
-#line 1354 "perly.y"
+#line 1351 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 215:
-#line 1356 "perly.y"
+#line 1353 "perly.y"
     { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 216:
-#line 1359 "perly.y"
+#line 1356 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 

diff --git a/perly.tab b/perly.tab
index bd6e118..c8b8f8b 100644 (file)
--- a/perly.tab
+++ b/perly.tab
@@ -172,25 +172,25 @@ static const yytype_uint16 yyrline[] =
        0,   142,   142,   145,   144,   157,   156,   169,   168,   180,
      186,   196,   200,   204,   210,   220,   225,   226,   235,   248,
      250,   255,   273,   294,   306,   322,   321,   338,   346,   354,
-     360,   362,   364,   374,   384,   405,   416,   426,   436,   443,
-     442,   468,   474,   484,   486,   488,   492,   496,   500,   504,
-     509,   515,   516,   520,   532,   533,   541,   547,   548,   553,
-     556,   560,   565,   569,   573,   579,   588,   591,   592,   596,
-     602,   607,   612,   622,   623,   628,   629,   633,   643,   647,
-     657,   658,   668,   672,   676,   680,   684,   694,   703,   707,
-     712,   719,   728,   734,   740,   748,   752,   759,   758,   769,
-     770,   774,   783,   788,   796,   803,   810,   820,   829,   836,
-     845,   852,   858,   865,   870,   880,   884,   888,   894,   898,
-     902,   906,   910,   914,   918,   930,   934,   938,   942,   952,
-     956,   963,   967,   971,   976,   981,   986,   995,  1000,  1005,
-    1011,  1017,  1028,  1032,  1036,  1048,  1061,  1069,  1081,  1082,
-    1083,  1084,  1085,  1090,  1094,  1096,  1100,  1105,  1107,  1112,
-    1114,  1116,  1118,  1120,  1122,  1124,  1133,  1144,  1146,  1148,
-    1153,  1166,  1171,  1176,  1180,  1184,  1188,  1192,  1196,  1200,
-    1204,  1206,  1209,  1213,  1219,  1222,  1231,  1237,  1242,  1243,
-    1244,  1250,  1254,  1262,  1269,  1274,  1279,  1281,  1283,  1288,
-    1290,  1295,  1296,  1300,  1303,  1302,  1310,  1314,  1320,  1326,
-    1332,  1338,  1344,  1351,  1353,  1355,  1358
+     360,   362,   364,   374,   384,   405,   414,   423,   432,   440,
+     439,   465,   471,   481,   483,   485,   489,   493,   497,   501,
+     506,   512,   513,   517,   529,   530,   538,   544,   545,   550,
+     553,   557,   562,   566,   570,   576,   585,   588,   589,   593,
+     599,   604,   609,   619,   620,   625,   626,   630,   640,   644,
+     654,   655,   665,   669,   673,   677,   681,   691,   700,   704,
+     709,   716,   725,   731,   737,   745,   749,   756,   755,   766,
+     767,   771,   780,   785,   793,   800,   807,   817,   826,   833,
+     842,   849,   855,   862,   867,   877,   881,   885,   891,   895,
+     899,   903,   907,   911,   915,   927,   931,   935,   939,   949,
+     953,   960,   964,   968,   973,   978,   983,   992,   997,  1002,
+    1008,  1014,  1025,  1029,  1033,  1045,  1058,  1066,  1078,  1079,
+    1080,  1081,  1082,  1087,  1091,  1093,  1097,  1102,  1104,  1109,
+    1111,  1113,  1115,  1117,  1119,  1121,  1130,  1141,  1143,  1145,
+    1150,  1163,  1168,  1173,  1177,  1181,  1185,  1189,  1193,  1197,
+    1201,  1203,  1206,  1210,  1216,  1219,  1228,  1234,  1239,  1240,
+    1241,  1247,  1251,  1259,  1266,  1271,  1276,  1278,  1280,  1285,
+    1287,  1292,  1293,  1297,  1300,  1299,  1307,  1311,  1317,  1323,
+    1329,  1335,  1341,  1348,  1350,  1352,  1355
 };
 #endif
 

diff --git a/perly.y b/perly.y
index 29fb93a..3f6879e 100644 (file)
--- a/perly.y
+++ b/perly.y
@@ -365,7 +365,7 @@ barestmt:   PLUGSTMT
                        {
                          $$ = block_end($3,
                                  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                     IVAL($1), $4, $7, $8, $6));
+                                     $4, $7, $8, $6));
                          TOKEN_GETMAD($1,$$,'W');
                          TOKEN_GETMAD($2,$$,'(');
                          TOKEN_GETMAD($5,$$,')');
@@ -374,8 +374,8 @@ barestmt:   PLUGSTMT
        |       UNTIL lpar_or_qw remember iexpr ')' mintro mblock cont
                        {
                          $$ = block_end($3,
-                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                     IVAL($1), $4, $7, $8, $6));
+                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
+                                     $4, $7, $8, $6));
                          TOKEN_GETMAD($1,$$,'W');
                          TOKEN_GETMAD($2,$$,'(');
                          TOKEN_GETMAD($5,$$,')');
@@ -386,7 +386,7 @@ barestmt:   PLUGSTMT
                        {
                          OP *initop = IF_MAD($4 ? $4 : newOP(OP_NULL, 0), $4);
                          OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                     IVAL($1), scalar($6), $11, $9, $8);
+                                     scalar($6), $11, $9, $8);
                          if (initop) {
                              forop = op_prepend_elem(OP_LINESEQ, initop,
                                  op_append_elem(OP_LINESEQ,
@@ -404,9 +404,7 @@ barestmt:   PLUGSTMT
                        }
        |       FOR MY remember my_scalar lpar_or_qw mexpr ')' mblock cont
                        {
-                         $$ = block_end($3,
-                                 newFOROP(0, (line_t)IVAL($1),
-                                     $4, $6, $8, $9));
+                         $$ = block_end($3, newFOROP(0, $4, $6, $8, $9));
                          TOKEN_GETMAD($1,$$,'W');
                          TOKEN_GETMAD($2,$$,'d');
                          TOKEN_GETMAD($5,$$,'(');
@@ -415,8 +413,7 @@ barestmt:   PLUGSTMT
                        }
        |       FOR scalar lpar_or_qw remember mexpr ')' mblock cont
                        {
-                         $$ = block_end($4,
-                                 newFOROP(0, (line_t)IVAL($1),
+                         $$ = block_end($4, newFOROP(0,
                                      mod($2, OP_ENTERLOOP), $5, $7, $8));
                          TOKEN_GETMAD($1,$$,'W');
                          TOKEN_GETMAD($3,$$,'(');
@@ -426,8 +423,7 @@ barestmt:   PLUGSTMT
        |       FOR lpar_or_qw remember mexpr ')' mblock cont
                        {
                          $$ = block_end($3,
-                                 newFOROP(0, (line_t)IVAL($1),
-                                     (OP*)NULL, $4, $6, $7));
+                                 newFOROP(0, (OP*)NULL, $4, $6, $7));
                          TOKEN_GETMAD($1,$$,'W');
                          TOKEN_GETMAD($2,$$,'(');
                          TOKEN_GETMAD($5,$$,')');
@@ -437,7 +433,8 @@ barestmt:   PLUGSTMT
                        {
                          /* a block is a loop that happens once */
                          $$ = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                 NOLINE, (OP*)NULL, $1, $2, 0);
+                                 (OP*)NULL, $1, $2, 0);
+                         PL_parser->copline = NOLINE;
                        }
        |       PACKAGE WORD WORD '{' remember
                        {
@@ -455,7 +452,7 @@ barestmt:   PLUGSTMT
                stmtseq '}'
                        {
                          /* a block is a loop that happens once */
-                         $$ = newWHILEOP(0, 1, (LOOP*)(OP*)NULL, NOLINE,
+                         $$ = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                  (OP*)NULL, block_end($5, $7), (OP*)NULL, 0);
                          op_free($3);
                          if ($2)
@@ -502,9 +499,9 @@ sideff      :       error
                          TOKEN_GETMAD($2,$$,'w');
                        }
        |       expr FOR expr
-                       { $$ = newFOROP(0, (line_t)IVAL($2),
-                                       (OP*)NULL, $3, $1, (OP*)NULL);
+                       { $$ = newFOROP(0, (OP*)NULL, $3, $1, (OP*)NULL);
                          TOKEN_GETMAD($2,$$,'w');
+                         PL_parser->copline = (line_t)IVAL($2);
                        }
        |       expr WHEN expr
                        { $$ = newWHENOP($3, scope($1)); }

diff --git a/proto.h b/proto.h
index bd572be..37f4703 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -2378,10 +2378,10 @@ PERL_CALLCONV OP*       Perl_newCVREF(pTHX_ I32 flags, OP* o)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV OP*      Perl_newFOROP(pTHX_ I32 flags, line_t forline, OP* sv, OP* expr, OP* block, OP* cont)
+PERL_CALLCONV OP*      Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont)
                        __attribute__malloc__
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_4);
+                       __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_NEWFOROP      \
        assert(expr)
 
@@ -2595,7 +2595,7 @@ PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block)
 #define PERL_ARGS_ASSERT_NEWWHENOP     \
        assert(block)
 
-PERL_CALLCONV OP*      Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, I32 whileline, OP* expr, OP* block, OP* cont, I32 has_my)
+PERL_CALLCONV OP*      Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, OP* expr, OP* block, OP* cont, I32 has_my)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;