This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
refactor and regularise label/statement grammar
authorZefram <zefram@fysh.org>
Tue, 19 Oct 2010 20:16:11 +0000 (21:16 +0100)
committerFather Chrysostomos <sprout@cpan.org>
Mon, 25 Oct 2010 19:29:46 +0000 (12:29 -0700)
Refactoring of the grammar around statements.  New production <barestmt>
encompasses a statement without label.  It includes all statement types,
including declarations, with no unnecessary intermediate non-terminals.
It generates an op tree for the statement's content, with no leading
state op.  The <fullstmt> production has just one rule, consisting of
optional label followed by <barestmt>.  It puts a state op on the front
of the statement's content ops.

To support the regular statement op structure, the op sequence for for(;;)
loops no longer has a second state op between the initialisation and
the loop.  Instead, the unstack op type is slightly adapted to achieve
the stack clearing without a state op.

The newFOROP() constructor function no longer generates a state op,
that now being the job of the <fullstmt> production.  Consequently it
no longer takes a parameter stating what label is to go in the state op.
This brings it in line with the other op constructors.

13 files changed:
dist/B-Deparse/Deparse.pm
embed.fnc
embed.h
ext/B/t/f_map.t
ext/B/t/optree_samples.t
op.c
perly.act
perly.tab
perly.y
pp_ctl.c
pp_hot.c
proto.h
t/run/switchd.t

index 7ea5437..9bf6606 100644 (file)
@@ -23,7 +23,7 @@ use B qw(class main_root main_start main_cv svref_2object opnumber perlstring
         PMf_MULTILINE PMf_SINGLELINE PMf_FOLD PMf_EXTENDED),
         ($] < 5.009 ? 'PMf_SKIPWHITE' : 'RXf_SKIPWHITE'),
         ($] < 5.011 ? 'CVf_LOCKED' : ());
-$VERSION = 0.99;
+$VERSION = 1.00;
 use strict;
 use vars qw/$AUTOLOAD/;
 use warnings ();
@@ -958,14 +958,19 @@ sub is_for_loop {
     my $op = shift;
     # This OP might be almost anything, though it won't be a
     # nextstate. (It's the initialization, so in the canonical case it
-    # will be an sassign.) The sibling is a lineseq whose first child
-    # is a nextstate and whose second is a leaveloop.
+    # will be an sassign.) The sibling is (old style) a lineseq whose
+    # first child is a nextstate and whose second is a leaveloop, or
+    # (new style) an unstack whose sibling is a leaveloop.
     my $lseq = $op->sibling;
-    if (!is_state $op and !null($lseq) and $lseq->name eq "lineseq") {
+    return 0 unless !is_state($op) and !null($lseq);
+    if ($lseq->name eq "lineseq") {
        if ($lseq->first && !null($lseq->first) && is_state($lseq->first)
            && (my $sib = $lseq->first->sibling)) {
            return (!null($sib) && $sib->name eq "leaveloop");
        }
+    } elsif ($lseq->name eq "unstack" && ($lseq->flags & OPf_SPECIAL)) {
+       my $sib = $lseq->sibling;
+       return $sib && !null($sib) && $sib->name eq "leaveloop";
     }
     return 0;
 }
@@ -1215,7 +1220,8 @@ sub walk_lineseq {
            }
        }
        if (is_for_loop($kids[$i])) {
-           $callback->($expr . $self->for_loop($kids[$i], 0), $i++);
+           $callback->($expr . $self->for_loop($kids[$i], 0),
+               $i += $kids[$i]->sibling->name eq "unstack" ? 2 : 1);
            next;
        }
        $expr .= $self->deparse($kids[$i], (@kids != 1)/2);
@@ -2757,7 +2763,9 @@ sub for_loop {
     my $self = shift;
     my($op, $cx) = @_;
     my $init = $self->deparse($op, 1);
-    return $self->loop_common($op->sibling->first->sibling, $cx, $init);
+    my $s = $op->sibling;
+    my $ll = $s->name eq "unstack" ? $s->sibling : $s->first->sibling;
+    return $self->loop_common($ll, $cx, $init);
 }
 
 sub pp_leavetry {
index 5fd1227..9f992c1 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -780,7 +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|NULLOK char* label|line_t forline \
+Apda   |OP*    |newFOROP       |I32 flags|line_t forline \
                                |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
diff --git a/embed.h b/embed.h
index e14a0af..a7093f6 100644 (file)
--- a/embed.h
+++ b/embed.h
 #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,g)        Perl_newFOROP(aTHX_ a,b,c,d,e,f,g)
+#define newFOROP(a,b,c,d,e,f)  Perl_newFOROP(aTHX_ a,b,c,d,e,f)
 #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)
index 11877ef..e56afdf 100644 (file)
@@ -185,7 +185,7 @@ checkOptree(note   => q{},
 # p      <2> sassign vKS/2
 # q      <0> unstack s
 #            goto r
-# t  <2> leaveloop K/2
+# t  <2> leaveloop KP/2
 # u  <2> leaveloop K/2
 # v  <1> leavesub[1 ref] K/REFC,1
 EOT_EOT
@@ -218,7 +218,7 @@ EOT_EOT
 # p      <2> sassign vKS/2
 # q      <0> unstack s
 #            goto r
-# t  <2> leaveloop K/2
+# t  <2> leaveloop KP/2
 # u  <2> leaveloop K/2
 # v  <1> leavesub[1 ref] K/REFC,1
 EONT_EONT
index 2a78972..e61c970 100644 (file)
@@ -281,7 +281,6 @@ checkOptree ( name  => '-basic sub { print "foo $_" foreach (1..10) }',
 # g  <1> leavesub[1 ref] K/REFC,1 ->(end)
 # -     <@> lineseq KP ->g
 # 1        <;> nextstate(main 445 optree.t:167) v:>,<,% ->2
-# -        <0> null v ->-
 # f        <2> leaveloop K/2 ->g
 # 6           <{> enteriter(next->c last->f redo->7) lKS/8 ->d
 # -              <0> ex-pushmark s ->2
@@ -307,7 +306,6 @@ EOT_EOT
 # g  <1> leavesub[1 ref] K/REFC,1 ->(end)
 # -     <@> lineseq KP ->g
 # 1        <;> nextstate(main 446 optree_samples.t:192) v:>,<,% ->2
-# -        <0> null v ->-
 # f        <2> leaveloop K/2 ->g
 # 6           <{> enteriter(next->c last->f redo->7) lKS/8 ->d
 # -              <0> ex-pushmark s ->2
@@ -337,7 +335,7 @@ checkOptree ( name  => '-exec -e foreach (1..10) {print qq{foo $_}}',
              strip_open_hints => 1,
              expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 # 1  <0> enter 
-# 2  <;> nextstate(main 2 -e:1) v:>,<,%
+# 2  <;> nextstate(main 2 -e:1) v:>,<,%,{
 # 3  <0> pushmark s
 # 4  <$> const[IV 1] s
 # 5  <$> const[IV 10] s
@@ -357,7 +355,7 @@ checkOptree ( name  => '-exec -e foreach (1..10) {print qq{foo $_}}',
 # i  <@> leave[1 ref] vKP/REFC
 EOT_EOT
 # 1  <0> enter 
-# 2  <;> nextstate(main 2 -e:1) v:>,<,%
+# 2  <;> nextstate(main 2 -e:1) v:>,<,%,{
 # 3  <0> pushmark s
 # 4  <$> const(IV 1) s
 # 5  <$> const(IV 10) s
@@ -545,7 +543,7 @@ checkOptree ( name  => '%h=(); for $_(@a){$h{getkey($_)} = $_}',
 # n      <2> sassign vKS/2
 # o      <0> unstack s
 #            goto p
-# r  <2> leaveloop K/2
+# r  <2> leaveloop KP/2
 # s  <1> leavesub[1 ref] K/REFC,1
 EOT_EOT
 # 1  <;> nextstate(main 505 (eval 24):1) v
@@ -575,7 +573,7 @@ EOT_EOT
 # n      <2> sassign vKS/2
 # o      <0> unstack s
 #            goto p
-# r  <2> leaveloop K/2
+# r  <2> leaveloop KP/2
 # s  <1> leavesub[1 ref] K/REFC,1
 EONT_EONT
 
diff --git a/op.c b/op.c
index f616761..c082921 100644 (file)
--- a/op.c
+++ b/op.c
@@ -5429,7 +5429,7 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
 }
 
 /*
-=for apidoc Am|OP *|newFOROP|I32 flags|char *label|line_t forline|OP *sv|OP *expr|OP *block|OP *cont
+=for apidoc Am|OP *|newFOROP|I32 flags|line_t forline|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,
@@ -5447,16 +5447,13 @@ 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.  If I<label> is non-null, it supplies
-the name of a label to attach to the state op at the start of the loop;
-this function takes ownership of the memory pointed at by I<label>,
-and will free it.
+to the loop's list expression.
 
 =cut
 */
 
 OP *
-Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP *block, OP *cont)
+Perl_newFOROP(pTHX_ I32 flags, line_t forline, OP *sv, OP *expr, OP *block, OP *cont)
 {
     dVAR;
     LOOP *loop;
@@ -5577,8 +5574,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
     wop = newWHILEOP(flags, 1, loop, forline, newOP(OP_ITER, 0), block, cont, 0);
     if (madsv)
        op_getmad(madsv, (OP*)loop, 'v');
-    PL_parser->copline = forline;
-    return newSTATEOP(0, label, wop);
+    return wop;
 }
 
 /*
index 95817d5..81fbcf3 100644 (file)
--- a/perly.act
+++ b/perly.act
@@ -1,17 +1,17 @@
 case 2:
-#line 145 "perly.y"
+#line 143 "perly.y"
     { (yyval.ival) = (ps[(2) - (2)].val.ival); ;}
     break;
 
   case 3:
-#line 147 "perly.y"
+#line 145 "perly.y"
     {
                          parser->expect = XBLOCK;
                        ;}
     break;
 
   case 4:
-#line 151 "perly.y"
+#line 149 "perly.y"
     {
                          PL_pad_reset_pending = TRUE;
                          PL_eval_root = (ps[(3) - (3)].val.opval);
@@ -22,14 +22,14 @@ case 2:
     break;
 
   case 5:
-#line 159 "perly.y"
+#line 157 "perly.y"
     {
                          parser->expect = XSTATE;
                        ;}
     break;
 
   case 6:
-#line 163 "perly.y"
+#line 161 "perly.y"
     {
                          PL_pad_reset_pending = TRUE;
                          PL_eval_root = (ps[(3) - (3)].val.opval);
@@ -40,14 +40,14 @@ case 2:
     break;
 
   case 7:
-#line 171 "perly.y"
+#line 169 "perly.y"
     {
                          parser->expect = XSTATE;
                        ;}
     break;
 
   case 8:
-#line 175 "perly.y"
+#line 173 "perly.y"
     {
                          PL_eval_root = (ps[(3) - (3)].val.opval);
                          (yyval.ival) = 0;
@@ -55,12 +55,12 @@ case 2:
     break;
 
   case 9:
-#line 184 "perly.y"
+#line 182 "perly.y"
     { (yyval.ival) = (ps[(1) - (2)].val.ival); newPROG(block_end((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 10:
-#line 189 "perly.y"
+#line 187 "perly.y"
     { if (PL_parser->copline > (line_t)IVAL((ps[(1) - (4)].val.i_tkval)))
                              PL_parser->copline = (line_t)IVAL((ps[(1) - (4)].val.i_tkval));
                          (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
@@ -70,24 +70,24 @@ case 2:
     break;
 
   case 11:
-#line 198 "perly.y"
+#line 196 "perly.y"
     { (yyval.ival) = block_start(TRUE); ;}
     break;
 
   case 12:
-#line 202 "perly.y"
+#line 200 "perly.y"
     { (yyval.ival) = (I32) Perl_allocmy(aTHX_ STR_WITH_LEN("$_"), 0); ;}
     break;
 
   case 13:
-#line 206 "perly.y"
+#line 204 "perly.y"
     {
                    PL_parser->expect = XSTATE; (yyval.ival) = block_start(TRUE);
                ;}
     break;
 
   case 14:
-#line 213 "perly.y"
+#line 211 "perly.y"
     { if (PL_parser->copline > (line_t)IVAL((ps[(1) - (4)].val.i_tkval)))
                              PL_parser->copline = (line_t)IVAL((ps[(1) - (4)].val.i_tkval));
                          (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
@@ -97,17 +97,17 @@ case 2:
     break;
 
   case 15:
-#line 222 "perly.y"
+#line 220 "perly.y"
     { (yyval.ival) = block_start(FALSE); ;}
     break;
 
   case 16:
-#line 227 "perly.y"
+#line 225 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 17:
-#line 229 "perly.y"
+#line 227 "perly.y"
     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
                            PL_pad_reset_pending = TRUE;
                            if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
@@ -116,364 +116,449 @@ case 2:
     break;
 
   case 18:
-#line 238 "perly.y"
-    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval));
-                         TOKEN_GETMAD((ps[(1) - (2)].val.p_tkval),((LISTOP*)(yyval.opval))->op_first,'L'); ;}
+#line 236 "perly.y"
+    {
+                         if (PVAL((ps[(1) - (2)].val.p_tkval)) || (ps[(2) - (2)].val.opval)) {
+                             (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval));
+                             TOKEN_GETMAD((ps[(1) - (2)].val.p_tkval),
+                                 (ps[(2) - (2)].val.opval) ? cLISTOPx((yyval.opval))->op_first : (yyval.opval), 'L');
+                         } else {
+                             (yyval.opval) = IF_MAD(newOP(OP_NULL, 0), (ps[(2) - (2)].val.opval));
+                         }
+                       ;}
     break;
 
-  case 20:
-#line 242 "perly.y"
+  case 19:
+#line 249 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
+  case 20:
+#line 251 "perly.y"
+    {
+                         (yyval.opval) = newOP(OP_NULL,0);
+                         TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'p');
+                       ;}
+    break;
+
   case 21:
-#line 244 "perly.y"
-    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval)); ;}
+#line 256 "perly.y"
+    {
+                         CV *fmtcv = PL_compcv;
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         (yyval.opval) = newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
+                         prepend_madprops((ps[(1) - (4)].val.i_tkval)->tk_mad, (yyval.opval), 'F');
+                         (ps[(1) - (4)].val.i_tkval)->tk_mad = 0;
+                         token_free((ps[(1) - (4)].val.i_tkval));
+#else
+                         newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
+                         (yyval.opval) = (OP*)NULL;
+#endif
+                         if (CvOUTSIDE(fmtcv) && !CvUNIQUE(CvOUTSIDE(fmtcv))) {
+                             SvREFCNT_inc_simple_void(fmtcv);
+                             pad_add_anon((SV*)fmtcv, OP_NULL);
+                         }
+                       ;}
     break;
 
   case 22:
-#line 246 "perly.y"
+#line 274 "perly.y"
     {
-                         if (PVAL((ps[(1) - (2)].val.p_tkval))) {
-                             (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), newOP(OP_NULL, 0));
-                             TOKEN_GETMAD((ps[(1) - (2)].val.p_tkval),(yyval.opval),'L');
-                             TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),((LISTOP*)(yyval.opval))->op_first,';');
-                         }
-                         else {
-                             (yyval.opval) = IF_MAD(
-                                       newOP(OP_NULL, 0),
-                                       (OP*)NULL);
-                              PL_parser->copline = NOLINE;
-                             TOKEN_FREE((ps[(1) - (2)].val.p_tkval));
-                             TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),';');
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         {
+                             OP* o = newSVOP(OP_ANONCODE, 0,
+                               (SV*)newATTRSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval)));
+                             (yyval.opval) = newOP(OP_NULL,0);
+                             op_getmad(o,(yyval.opval),'&');
+                             op_getmad((ps[(3) - (6)].val.opval),(yyval.opval),'n');
+                             op_getmad((ps[(4) - (6)].val.opval),(yyval.opval),'s');
+                             op_getmad((ps[(5) - (6)].val.opval),(yyval.opval),'a');
+                             token_getmad((ps[(1) - (6)].val.i_tkval),(yyval.opval),'d');
+                             append_madprops((ps[(6) - (6)].val.opval)->op_madprop, (yyval.opval), 0);
+                             (ps[(6) - (6)].val.opval)->op_madprop = 0;
                          }
-                         PL_parser->expect = XSTATE;
+#else
+                         newATTRSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
+                         (yyval.opval) = (OP*)NULL;
+#endif
                        ;}
     break;
 
   case 23:
-#line 263 "perly.y"
+#line 295 "perly.y"
     {
-                         (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (3)].val.p_tkval)), (ps[(2) - (3)].val.opval));
-                         PL_parser->expect = XSTATE;
-                         DO_MAD({
-                             /* sideff might already have a nexstate */
-                             OP* op = ((LISTOP*)(yyval.opval))->op_first;
-                             if (op) {
-                                 while (op->op_sibling &&
-                                    op->op_sibling->op_type == OP_NEXTSTATE)
-                                       op = op->op_sibling;
-                                 token_getmad((ps[(1) - (3)].val.p_tkval),op,'L');
-                                 token_getmad((ps[(3) - (3)].val.i_tkval),op,';');
-                             }
-                         })
+                         /* Unimplemented "my sub foo { }" */
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         (yyval.opval) = newMYSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
+                         token_getmad((ps[(1) - (6)].val.i_tkval),(yyval.opval),'d');
+#else
+                         newMYSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
+                         (yyval.opval) = (OP*)NULL;
+#endif
                        ;}
     break;
 
   case 24:
-#line 279 "perly.y"
-    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)),
-                                newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                           NOLINE, (OP*)NULL, (ps[(2) - (2)].val.opval),
-                                           (OP*)NULL, 0)); ;}
+#line 307 "perly.y"
+    {
+#ifdef MAD
+                         (yyval.opval) = package((ps[(3) - (4)].val.opval));
+                         token_getmad((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
+                         if ((ps[(2) - (4)].val.opval))
+                             package_version((ps[(2) - (4)].val.opval));
+                         token_getmad((ps[(4) - (4)].val.i_tkval),(yyval.opval),';');
+#else
+                         package((ps[(3) - (4)].val.opval));
+                         if ((ps[(2) - (4)].val.opval))
+                             package_version((ps[(2) - (4)].val.opval));
+                         (yyval.opval) = (OP*)NULL;
+#endif
+                       ;}
     break;
 
   case 25:
-#line 284 "perly.y"
-    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval)); ;}
+#line 322 "perly.y"
+    { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
     break;
 
   case 26:
-#line 286 "perly.y"
+#line 324 "perly.y"
     {
-                         if (PVAL((ps[(1) - (2)].val.p_tkval))) {
-                             (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval));
-                         } else {
-                             (yyval.opval) = IF_MAD((ps[(2) - (2)].val.opval) ? (ps[(2) - (2)].val.opval) : newOP(OP_NULL, 0), (ps[(2) - (2)].val.opval));
-                         }
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         (yyval.opval) = utilize(IVAL((ps[(1) - (7)].val.i_tkval)), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
+                         token_getmad((ps[(1) - (7)].val.i_tkval),(yyval.opval),'o');
+                         token_getmad((ps[(7) - (7)].val.i_tkval),(yyval.opval),';');
+                         if (PL_parser->rsfp_filters &&
+                                     AvFILLp(PL_parser->rsfp_filters) >= 0)
+                             append_madprops(newMADPROP('!', MAD_NULL, NULL, 0), (yyval.opval), 0);
+#else
+                         utilize(IVAL((ps[(1) - (7)].val.i_tkval)), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
+                         (yyval.opval) = (OP*)NULL;
+#endif
                        ;}
     break;
 
   case 27:
-#line 297 "perly.y"
-    { (yyval.opval) = (OP*)NULL; ;}
+#line 339 "perly.y"
+    {
+                         (yyval.opval) = block_end((ps[(3) - (7)].val.ival), newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
+                         TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
+                         TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
+                         TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
+                       ;}
     break;
 
   case 28:
-#line 299 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
+#line 347 "perly.y"
+    {
+                         (yyval.opval) = block_end((ps[(3) - (7)].val.ival), newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
+                         TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
+                         TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
+                         TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
+                       ;}
     break;
 
   case 29:
-#line 301 "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');
+#line 355 "perly.y"
+    {
+                         (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
+                                 newGIVENOP((ps[(5) - (7)].val.opval), scope((ps[(7) - (7)].val.opval)), (PADOFFSET)(ps[(4) - (7)].val.ival)));
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
                        ;}
     break;
 
   case 30:
-#line 305 "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');
-                       ;}
+#line 361 "perly.y"
+    { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), scope((ps[(6) - (6)].val.opval)))); ;}
     break;
 
   case 31:
-#line 309 "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');
-                       ;}
+#line 363 "perly.y"
+    { (yyval.opval) = newWHENOP(0, scope((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 32:
-#line 313 "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');
+#line 365 "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)));
+                         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),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (8)].val.i_tkval));
                        ;}
     break;
 
   case 33:
-#line 317 "perly.y"
-    { (yyval.opval) = newFOROP(0, NULL, (line_t)IVAL((ps[(2) - (3)].val.i_tkval)),
-                                       (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
-                         TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),((LISTOP*)(yyval.opval))->op_first->op_sibling,'w');
+#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)));
+                         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),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (8)].val.i_tkval));
                        ;}
     break;
 
   case 34:
-#line 322 "perly.y"
-    { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), scope((ps[(1) - (3)].val.opval))); ;}
+#line 386 "perly.y"
+    {
+                         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));
+                         if (initop) {
+                             forop = op_prepend_elem(OP_LINESEQ, initop,
+                                 op_append_elem(OP_LINESEQ,
+                                     newOP(OP_UNSTACK, OPf_SPECIAL),
+                                     forop));
+                         }
+                         DO_MAD({ forop = newUNOP(OP_NULL, 0, forop); })
+                         (yyval.opval) = block_end((ps[(3) - (11)].val.ival), forop);
+                         TOKEN_GETMAD((ps[(1) - (11)].val.i_tkval),(yyval.opval),'3');
+                         TOKEN_GETMAD((ps[(2) - (11)].val.i_tkval),(yyval.opval),'(');
+                         TOKEN_GETMAD((ps[(5) - (11)].val.i_tkval),(yyval.opval),'1');
+                         TOKEN_GETMAD((ps[(7) - (11)].val.i_tkval),(yyval.opval),'2');
+                         TOKEN_GETMAD((ps[(10) - (11)].val.i_tkval),(yyval.opval),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (11)].val.i_tkval));
+                       ;}
     break;
 
   case 35:
-#line 327 "perly.y"
-    { (yyval.opval) = (OP*)NULL; ;}
+#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)));
+                         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),'(');
+                         TOKEN_GETMAD((ps[(7) - (9)].val.i_tkval),(yyval.opval),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (9)].val.i_tkval));
+                       ;}
     break;
 
   case 36:
-#line 329 "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');
+#line 417 "perly.y"
+    {
+                         (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
+                                 newFOROP(0, (line_t)IVAL((ps[(1) - (8)].val.i_tkval)),
+                                     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),'(');
+                         TOKEN_GETMAD((ps[(6) - (8)].val.i_tkval),(yyval.opval),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (8)].val.i_tkval));
                        ;}
     break;
 
   case 37:
-#line 333 "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;
-                         TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'I');
-                         TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'(');
-                         TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),')');
+#line 427 "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)));
+                         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),')');
+                         PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
                        ;}
     break;
 
   case 38:
-#line 344 "perly.y"
-    { PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
-                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
-                                  newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
-                         TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
-                         TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
-                         TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
+#line 437 "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);
                        ;}
     break;
 
   case 39:
-#line 352 "perly.y"
-    { PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
-                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
-                                  newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
-                         TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
-                         TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
-                         TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
+#line 443 "perly.y"
+    {
+                         int save_3_latefree = (ps[(3) - (5)].val.opval)->op_latefree;
+                         (ps[(3) - (5)].val.opval)->op_latefree = 1;
+                         package((ps[(3) - (5)].val.opval));
+                         (ps[(3) - (5)].val.opval)->op_latefree = save_3_latefree;
+                         if ((ps[(2) - (5)].val.opval)) {
+                             int save_2_latefree = (ps[(2) - (5)].val.opval)->op_latefree;
+                             (ps[(2) - (5)].val.opval)->op_latefree = 1;
+                             package_version((ps[(2) - (5)].val.opval));
+                             (ps[(2) - (5)].val.opval)->op_latefree = save_2_latefree;
+                         }
                        ;}
     break;
 
   case 40:
-#line 363 "perly.y"
-    { (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
-               newWHENOP((ps[(4) - (6)].val.opval), scope((ps[(6) - (6)].val.opval)))); ;}
+#line 456 "perly.y"
+    {
+                         /* a block is a loop that happens once */
+                         (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL, NOLINE,
+                                 (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))
+                             op_free((ps[(2) - (8)].val.opval));
+                         TOKEN_GETMAD((ps[(4) - (8)].val.i_tkval),(yyval.opval),'{');
+                         TOKEN_GETMAD((ps[(8) - (8)].val.i_tkval),(yyval.opval),'}');
+                         if (PL_parser->copline > (line_t)IVAL((ps[(4) - (8)].val.i_tkval)))
+                             PL_parser->copline = (line_t)IVAL((ps[(4) - (8)].val.i_tkval));
+                       ;}
     break;
 
   case 41:
-#line 366 "perly.y"
-    { (yyval.opval) = newWHENOP(0, scope((ps[(2) - (2)].val.opval))); ;}
+#line 469 "perly.y"
+    {
+                         PL_parser->expect = XSTATE;
+                         (yyval.opval) = (ps[(1) - (2)].val.opval);
+                         TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),';');
+                       ;}
     break;
 
   case 42:
-#line 371 "perly.y"
-    { (yyval.opval) = (OP*)NULL; ;}
+#line 475 "perly.y"
+    {
+                         PL_parser->expect = XSTATE;
+                         (yyval.opval) = IF_MAD(newOP(OP_NULL, 0), (OP*)NULL);
+                         TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),';');
+                         PL_parser->copline = NOLINE;
+                       ;}
     break;
 
   case 43:
-#line 373 "perly.y"
-    { (yyval.opval) = scope((ps[(2) - (2)].val.opval));
-                         TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
-                       ;}
+#line 485 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 44:
-#line 380 "perly.y"
-    { OP *innerop;
-                         PL_parser->copline = (line_t)IVAL((ps[(2) - (9)].val.i_tkval));
-                           (yyval.opval) = block_end((ps[(4) - (9)].val.ival),
-                                  newSTATEOP(0, PVAL((ps[(1) - (9)].val.p_tkval)),
-                                    innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                               IVAL((ps[(2) - (9)].val.i_tkval)), (ps[(5) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval), (ps[(7) - (9)].val.ival))));
-                         TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),innerop,'L');
-                         TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),innerop,'W');
-                         TOKEN_GETMAD((ps[(3) - (9)].val.i_tkval),innerop,'(');
-                         TOKEN_GETMAD((ps[(6) - (9)].val.i_tkval),innerop,')');
-                       ;}
+#line 487 "perly.y"
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 45:
-#line 393 "perly.y"
-    { OP *innerop;
-                         PL_parser->copline = (line_t)IVAL((ps[(2) - (9)].val.i_tkval));
-                           (yyval.opval) = block_end((ps[(4) - (9)].val.ival),
-                                  newSTATEOP(0, PVAL((ps[(1) - (9)].val.p_tkval)),
-                                    innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                               IVAL((ps[(2) - (9)].val.i_tkval)), (ps[(5) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval), (ps[(7) - (9)].val.ival))));
-                         TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),innerop,'L');
-                         TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),innerop,'W');
-                         TOKEN_GETMAD((ps[(3) - (9)].val.i_tkval),innerop,'(');
-                         TOKEN_GETMAD((ps[(6) - (9)].val.i_tkval),innerop,')');
+#line 489 "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 405 "perly.y"
-    { OP *innerop;
-                         (yyval.opval) = block_end((ps[(4) - (10)].val.ival),
-                            innerop = newFOROP(0, PVAL((ps[(1) - (10)].val.p_tkval)), (line_t)IVAL((ps[(2) - (10)].val.i_tkval)),
-                                           (ps[(5) - (10)].val.opval), (ps[(7) - (10)].val.opval), (ps[(9) - (10)].val.opval), (ps[(10) - (10)].val.opval)));
-                         TOKEN_GETMAD((ps[(1) - (10)].val.p_tkval),((LISTOP*)innerop)->op_first,'L');
-                         TOKEN_GETMAD((ps[(2) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
-                         TOKEN_GETMAD((ps[(3) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'d');
-                         TOKEN_GETMAD((ps[(6) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
-                         TOKEN_GETMAD((ps[(8) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
+#line 493 "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 416 "perly.y"
-    { OP *innerop;
-                         (yyval.opval) = block_end((ps[(5) - (9)].val.ival),
-                            innerop = newFOROP(0, PVAL((ps[(1) - (9)].val.p_tkval)), (line_t)IVAL((ps[(2) - (9)].val.i_tkval)),
-                                   mod((ps[(3) - (9)].val.opval), OP_ENTERLOOP), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
-                         TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),((LISTOP*)innerop)->op_first,'L');
-                         TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
-                         TOKEN_GETMAD((ps[(4) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
-                         TOKEN_GETMAD((ps[(7) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
+#line 497 "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 426 "perly.y"
-    { OP *innerop;
-                         (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
-                            innerop = newFOROP(0, PVAL((ps[(1) - (8)].val.p_tkval)), (line_t)IVAL((ps[(2) - (8)].val.i_tkval)),
-                                                   (OP*)NULL, (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
-                         TOKEN_GETMAD((ps[(1) - (8)].val.p_tkval),((LISTOP*)innerop)->op_first,'L');
-                         TOKEN_GETMAD((ps[(2) - (8)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
-                         TOKEN_GETMAD((ps[(3) - (8)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
-                         TOKEN_GETMAD((ps[(6) - (8)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
+#line 501 "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 438 "perly.y"
-    { OP *forop;
-                         PL_parser->copline = (line_t)IVAL((ps[(2) - (12)].val.i_tkval));
-                         forop = newSTATEOP(0, PVAL((ps[(1) - (12)].val.p_tkval)),
-                                           newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                               IVAL((ps[(2) - (12)].val.i_tkval)), scalar((ps[(7) - (12)].val.opval)),
-                                               (ps[(12) - (12)].val.opval), (ps[(10) - (12)].val.opval), (ps[(9) - (12)].val.ival)));
-#ifdef MAD
-                         forop = newUNOP(OP_NULL, 0, op_append_elem(OP_LINESEQ,
-                               newSTATEOP(0,
-                                          CopLABEL_alloc(((ps[(1) - (12)].val.p_tkval))->tk_lval.pval),
-                                          ((ps[(5) - (12)].val.opval) ? (ps[(5) - (12)].val.opval) : newOP(OP_NULL, 0)) ),
-                               forop));
-
-                         token_getmad((ps[(2) - (12)].val.i_tkval),forop,'3');
-                         token_getmad((ps[(3) - (12)].val.i_tkval),forop,'(');
-                         token_getmad((ps[(6) - (12)].val.i_tkval),forop,'1');
-                         token_getmad((ps[(8) - (12)].val.i_tkval),forop,'2');
-                         token_getmad((ps[(11) - (12)].val.i_tkval),forop,')');
-                         token_getmad((ps[(1) - (12)].val.p_tkval),forop,'L');
-#else
-                         if ((ps[(5) - (12)].val.opval)) {
-                               forop = op_append_elem(OP_LINESEQ,
-                                        newSTATEOP(0, CopLABEL_alloc((ps[(1) - (12)].val.p_tkval)), (ps[(5) - (12)].val.opval)),
-                                       forop);
-                         }
-
-
-#endif
-                         (yyval.opval) = block_end((ps[(4) - (12)].val.ival), forop); ;}
+#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);
+                         TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
+                       ;}
     break;
 
   case 50:
-#line 468 "perly.y"
-    { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (3)].val.p_tkval)),
-                                newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                           NOLINE, (OP*)NULL, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval), 0));
-                         TOKEN_GETMAD((ps[(1) - (3)].val.p_tkval),((LISTOP*)(yyval.opval))->op_first,'L'); ;}
+#line 510 "perly.y"
+    { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), scope((ps[(1) - (3)].val.opval))); ;}
     break;
 
   case 51:
-#line 476 "perly.y"
-    { PL_parser->copline = (line_t) IVAL((ps[(2) - (8)].val.i_tkval));
-                           (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
-                               newSTATEOP(0, PVAL((ps[(1) - (8)].val.p_tkval)),
-                                   newGIVENOP((ps[(6) - (8)].val.opval), scope((ps[(8) - (8)].val.opval)),
-                                       (PADOFFSET) (ps[(5) - (8)].val.ival)) )); ;}
+#line 515 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 52:
-#line 485 "perly.y"
+#line 517 "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"
+    { 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;
+                         TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'I');
+                         TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'(');
+                         TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),')');
+                       ;}
+    break;
+
+  case 54:
+#line 532 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
+    break;
+
+  case 55:
+#line 534 "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"
     { (yyval.ival) = (PL_min_intro_pending &&
                            PL_max_intro_pending >=  PL_min_intro_pending);
                          intro_my(); ;}
     break;
 
-  case 53:
-#line 491 "perly.y"
+  case 57:
+#line 547 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 55:
-#line 497 "perly.y"
+  case 59:
+#line 553 "perly.y"
     { YYSTYPE tmplval;
                          (void)scan_num("1", &tmplval);
                          (yyval.opval) = tmplval.opval; ;}
     break;
 
-  case 57:
-#line 505 "perly.y"
+  case 61:
+#line 561 "perly.y"
     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
-  case 58:
-#line 510 "perly.y"
+  case 62:
+#line 566 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
-  case 59:
-#line 514 "perly.y"
+  case 63:
+#line 570 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
-  case 60:
-#line 518 "perly.y"
+  case 64:
+#line 574 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
-  case 61:
-#line 523 "perly.y"
+  case 65:
+#line 579 "perly.y"
     {
 #ifdef MAD
                          YYSTYPE tmplval;
@@ -485,130 +570,36 @@ case 2:
                        ;}
     break;
 
-  case 63:
-#line 537 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
-    break;
-
-  case 64:
-#line 539 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
-    break;
-
-  case 65:
-#line 541 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
-    break;
-
-  case 66:
-#line 543 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
-    break;
-
   case 67:
-#line 545 "perly.y"
+#line 591 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 68:
-#line 550 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
-    break;
-
-  case 69:
-#line 554 "perly.y"
-    { (yyval.opval) = newOP(OP_NULL,0);
-                         TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'p');
-                       ;}
-    break;
-
-  case 70:
-#line 560 "perly.y"
-    {
-                         CV *fmtcv = PL_compcv;
-                         SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         (yyval.opval) = newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
-                         prepend_madprops((ps[(1) - (4)].val.i_tkval)->tk_mad, (yyval.opval), 'F');
-                         (ps[(1) - (4)].val.i_tkval)->tk_mad = 0;
-                         token_free((ps[(1) - (4)].val.i_tkval));
-#else
-                         newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
-                         (yyval.opval) = (OP*)NULL;
-#endif
-                         if (CvOUTSIDE(fmtcv) && !CvUNIQUE(CvOUTSIDE(fmtcv))) {
-                           SvREFCNT_inc_simple_void(fmtcv);
-                           pad_add_anon((SV*)fmtcv, OP_NULL);
-                         }
-                       ;}
-    break;
-
-  case 71:
-#line 579 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
-    break;
-
-  case 72:
-#line 580 "perly.y"
+#line 592 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 73:
-#line 585 "perly.y"
-    { SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         (yyval.opval) = newMYSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
-                         token_getmad((ps[(1) - (6)].val.i_tkval),(yyval.opval),'d');
-#else
-                         newMYSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
-                         (yyval.opval) = (OP*)NULL;
-#endif
-                       ;}
-    break;
-
-  case 74:
-#line 598 "perly.y"
-    { SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         {
-                             OP* o = newSVOP(OP_ANONCODE, 0,
-                               (SV*)newATTRSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval)));
-                             (yyval.opval) = newOP(OP_NULL,0);
-                             op_getmad(o,(yyval.opval),'&');
-                             op_getmad((ps[(3) - (6)].val.opval),(yyval.opval),'n');
-                             op_getmad((ps[(4) - (6)].val.opval),(yyval.opval),'s');
-                             op_getmad((ps[(5) - (6)].val.opval),(yyval.opval),'a');
-                             token_getmad((ps[(1) - (6)].val.i_tkval),(yyval.opval),'d');
-                             append_madprops((ps[(6) - (6)].val.opval)->op_madprop, (yyval.opval), 0);
-                             (ps[(6) - (6)].val.opval)->op_madprop = 0;
-                           }
-#else
-                         newATTRSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
-                         (yyval.opval) = (OP*)NULL;
-#endif
-                       ;}
-    break;
-
-  case 75:
-#line 620 "perly.y"
+  case 69:
+#line 596 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
-  case 76:
-#line 626 "perly.y"
+  case 70:
+#line 602 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
-  case 77:
-#line 631 "perly.y"
+  case 71:
+#line 607 "perly.y"
     { (yyval.ival) = start_subparse(TRUE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
-  case 78:
-#line 636 "perly.y"
+  case 72:
+#line 612 "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")
@@ -617,25 +608,25 @@ case 2:
                          (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 79:
-#line 646 "perly.y"
+  case 73:
+#line 622 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 81:
-#line 652 "perly.y"
+  case 75:
+#line 628 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 82:
-#line 654 "perly.y"
+  case 76:
+#line 630 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
-  case 83:
-#line 658 "perly.y"
+  case 77:
+#line 634 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -644,15 +635,15 @@ case 2:
                        ;}
     break;
 
-  case 84:
-#line 668 "perly.y"
+  case 78:
+#line 644 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
-  case 85:
-#line 672 "perly.y"
+  case 79:
+#line 648 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -661,13 +652,13 @@ case 2:
                        ;}
     break;
 
-  case 86:
-#line 681 "perly.y"
+  case 80:
+#line 657 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 87:
-#line 682 "perly.y"
+  case 81:
+#line 658 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL,0),
                                    (OP*)NULL
@@ -677,98 +668,29 @@ case 2:
                        ;}
     break;
 
-  case 88:
-#line 692 "perly.y"
-    {
-#ifdef MAD
-                         (yyval.opval) = package((ps[(3) - (4)].val.opval));
-                         token_getmad((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
-                         if ((ps[(2) - (4)].val.opval))
-                             package_version((ps[(2) - (4)].val.opval));
-                         token_getmad((ps[(4) - (4)].val.i_tkval),(yyval.opval),';');
-#else
-                         package((ps[(3) - (4)].val.opval));
-                         if ((ps[(2) - (4)].val.opval))
-                             package_version((ps[(2) - (4)].val.opval));
-                         (yyval.opval) = (OP*)NULL;
-#endif
-                       ;}
-    break;
-
-  case 89:
-#line 709 "perly.y"
-    {
-                         int save_3_latefree = (ps[(3) - (5)].val.opval)->op_latefree;
-                         (ps[(3) - (5)].val.opval)->op_latefree = 1;
-                         package((ps[(3) - (5)].val.opval));
-                         (ps[(3) - (5)].val.opval)->op_latefree = save_3_latefree;
-                         if ((ps[(2) - (5)].val.opval)) {
-                             int save_2_latefree = (ps[(2) - (5)].val.opval)->op_latefree;
-                             (ps[(2) - (5)].val.opval)->op_latefree = 1;
-                             package_version((ps[(2) - (5)].val.opval));
-                             (ps[(2) - (5)].val.opval)->op_latefree = save_2_latefree;
-                         }
-                       ;}
-    break;
-
-  case 90:
-#line 722 "perly.y"
-    { if (PL_parser->copline > (line_t)IVAL((ps[(4) - (8)].val.i_tkval)))
-                             PL_parser->copline = (line_t)IVAL((ps[(4) - (8)].val.i_tkval));
-                         (yyval.opval) = block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval));
-                         TOKEN_GETMAD((ps[(4) - (8)].val.i_tkval),(yyval.opval),'{');
-                         TOKEN_GETMAD((ps[(8) - (8)].val.i_tkval),(yyval.opval),'}');
-                         op_free((ps[(3) - (8)].val.opval));
-                         if ((ps[(2) - (8)].val.opval))
-                             op_free((ps[(2) - (8)].val.opval));
-                       ;}
-    break;
-
-  case 91:
-#line 734 "perly.y"
-    { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
-    break;
-
-  case 92:
-#line 736 "perly.y"
-    { SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         (yyval.opval) = utilize(IVAL((ps[(1) - (7)].val.i_tkval)), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
-                         token_getmad((ps[(1) - (7)].val.i_tkval),(yyval.opval),'o');
-                         token_getmad((ps[(7) - (7)].val.i_tkval),(yyval.opval),';');
-                         if (PL_parser->rsfp_filters &&
-                                     AvFILLp(PL_parser->rsfp_filters) >= 0)
-                             append_madprops(newMADPROP('!', MAD_NULL, NULL, 0), (yyval.opval), 0);
-#else
-                         utilize(IVAL((ps[(1) - (7)].val.i_tkval)), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
-                         (yyval.opval) = (OP*)NULL;
-#endif
-                       ;}
-    break;
-
-  case 93:
-#line 753 "perly.y"
+  case 82:
+#line 669 "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 94:
-#line 757 "perly.y"
+  case 83:
+#line 673 "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 95:
-#line 761 "perly.y"
+  case 84:
+#line 677 "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 97:
-#line 769 "perly.y"
+  case 86:
+#line 685 "perly.y"
     {
 #ifdef MAD
                          OP* op = newNULLLIST();
@@ -780,8 +702,8 @@ case 2:
                        ;}
     break;
 
-  case 98:
-#line 779 "perly.y"
+  case 87:
+#line 695 "perly.y"
     { 
                          OP* term = (ps[(3) - (3)].val.opval);
                          DO_MAD(
@@ -792,16 +714,16 @@ case 2:
                        ;}
     break;
 
-  case 100:
-#line 792 "perly.y"
+  case 89:
+#line 708 "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');
                        ;}
     break;
 
-  case 101:
-#line 797 "perly.y"
+  case 90:
+#line 713 "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');
@@ -810,8 +732,8 @@ case 2:
                        ;}
     break;
 
-  case 102:
-#line 804 "perly.y"
+  case 91:
+#line 720 "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)),
@@ -822,8 +744,8 @@ case 2:
                        ;}
     break;
 
-  case 103:
-#line 813 "perly.y"
+  case 92:
+#line 729 "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))));
@@ -831,8 +753,8 @@ case 2:
                        ;}
     break;
 
-  case 104:
-#line 819 "perly.y"
+  case 93:
+#line 735 "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)),
@@ -840,8 +762,8 @@ case 2:
                        ;}
     break;
 
-  case 105:
-#line 825 "perly.y"
+  case 94:
+#line 741 "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)),
@@ -851,15 +773,15 @@ case 2:
                        ;}
     break;
 
-  case 106:
-#line 833 "perly.y"
+  case 95:
+#line 749 "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 107:
-#line 837 "perly.y"
+  case 96:
+#line 753 "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),'(');
@@ -867,22 +789,22 @@ case 2:
                        ;}
     break;
 
-  case 108:
-#line 843 "perly.y"
+  case 97:
+#line 759 "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 109:
-#line 846 "perly.y"
+  case 98:
+#line 762 "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)));
                        ;}
     break;
 
-  case 112:
-#line 861 "perly.y"
+  case 101:
+#line 777 "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),'{');
@@ -891,16 +813,16 @@ case 2:
                        ;}
     break;
 
-  case 113:
-#line 868 "perly.y"
+  case 102:
+#line 784 "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),']');
                        ;}
     break;
 
-  case 114:
-#line 873 "perly.y"
+  case 103:
+#line 789 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
                                        scalar((ps[(4) - (5)].val.opval)));
@@ -910,8 +832,8 @@ case 2:
                        ;}
     break;
 
-  case 115:
-#line 881 "perly.y"
+  case 104:
+#line 797 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
                                        scalar((ps[(3) - (4)].val.opval)));
@@ -920,8 +842,8 @@ case 2:
                        ;}
     break;
 
-  case 116:
-#line 888 "perly.y"
+  case 105:
+#line 804 "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),'{');
@@ -930,8 +852,8 @@ case 2:
                        ;}
     break;
 
-  case 117:
-#line 895 "perly.y"
+  case 106:
+#line 811 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(4) - (6)].val.opval)));
@@ -943,8 +865,8 @@ case 2:
                        ;}
     break;
 
-  case 118:
-#line 905 "perly.y"
+  case 107:
+#line 821 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(3) - (5)].val.opval)));
@@ -955,8 +877,8 @@ case 2:
                        ;}
     break;
 
-  case 119:
-#line 914 "perly.y"
+  case 108:
+#line 830 "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');
@@ -965,8 +887,8 @@ case 2:
                        ;}
     break;
 
-  case 120:
-#line 921 "perly.y"
+  case 109:
+#line 837 "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)))));
@@ -976,8 +898,8 @@ case 2:
                        ;}
     break;
 
-  case 121:
-#line 930 "perly.y"
+  case 110:
+#line 846 "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)))));
@@ -986,8 +908,8 @@ case 2:
                        ;}
     break;
 
-  case 122:
-#line 937 "perly.y"
+  case 111:
+#line 853 "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),'(');
@@ -995,8 +917,8 @@ case 2:
                        ;}
     break;
 
-  case 123:
-#line 943 "perly.y"
+  case 112:
+#line 859 "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),')');
@@ -1005,16 +927,16 @@ case 2:
                        ;}
     break;
 
-  case 124:
-#line 950 "perly.y"
+  case 113:
+#line 866 "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),']');
                        ;}
     break;
 
-  case 125:
-#line 955 "perly.y"
+  case 114:
+#line 871 "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),')');
@@ -1023,22 +945,22 @@ case 2:
                        ;}
     break;
 
-  case 126:
-#line 965 "perly.y"
+  case 115:
+#line 881 "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 127:
-#line 969 "perly.y"
+  case 116:
+#line 885 "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 128:
-#line 973 "perly.y"
+  case 117:
+#line 889 "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)));
@@ -1046,50 +968,50 @@ case 2:
                        ;}
     break;
 
-  case 129:
-#line 979 "perly.y"
+  case 118:
+#line 895 "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 130:
-#line 983 "perly.y"
+  case 119:
+#line 899 "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 131:
-#line 987 "perly.y"
+  case 120:
+#line 903 "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 132:
-#line 991 "perly.y"
+  case 121:
+#line 907 "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 133:
-#line 995 "perly.y"
+  case 122:
+#line 911 "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 134:
-#line 999 "perly.y"
+  case 123:
+#line 915 "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 135:
-#line 1003 "perly.y"
+  case 124:
+#line 919 "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({
@@ -1103,29 +1025,29 @@ case 2:
                        ;}
     break;
 
-  case 136:
-#line 1015 "perly.y"
+  case 125:
+#line 931 "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 137:
-#line 1019 "perly.y"
+  case 126:
+#line 935 "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 138:
-#line 1023 "perly.y"
+  case 127:
+#line 939 "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 139:
-#line 1027 "perly.y"
+  case 128:
+#line 943 "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
@@ -1134,15 +1056,15 @@ case 2:
                        ;}
     break;
 
-  case 140:
-#line 1037 "perly.y"
+  case 129:
+#line 953 "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 141:
-#line 1041 "perly.y"
+  case 130:
+#line 957 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
                                    (ps[(2) - (2)].val.opval)
@@ -1151,70 +1073,70 @@ case 2:
                        ;}
     break;
 
-  case 142:
-#line 1048 "perly.y"
+  case 131:
+#line 964 "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 143:
-#line 1052 "perly.y"
+  case 132:
+#line 968 "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 144:
-#line 1056 "perly.y"
+  case 133:
+#line 972 "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');
                        ;}
     break;
 
-  case 145:
-#line 1061 "perly.y"
+  case 134:
+#line 977 "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');
                        ;}
     break;
 
-  case 146:
-#line 1066 "perly.y"
+  case 135:
+#line 982 "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');
                        ;}
     break;
 
-  case 147:
-#line 1071 "perly.y"
+  case 136:
+#line 987 "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');
                        ;}
     break;
 
-  case 148:
-#line 1080 "perly.y"
+  case 137:
+#line 996 "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),']');
                        ;}
     break;
 
-  case 149:
-#line 1085 "perly.y"
+  case 138:
+#line 1001 "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),']');
                        ;}
     break;
 
-  case 150:
-#line 1090 "perly.y"
+  case 139:
+#line 1006 "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),';');
@@ -1222,8 +1144,8 @@ case 2:
                        ;}
     break;
 
-  case 151:
-#line 1096 "perly.y"
+  case 140:
+#line 1012 "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),';');
@@ -1231,8 +1153,8 @@ case 2:
                        ;}
     break;
 
-  case 152:
-#line 1102 "perly.y"
+  case 141:
+#line 1018 "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');
@@ -1241,22 +1163,22 @@ case 2:
                        ;}
     break;
 
-  case 153:
-#line 1113 "perly.y"
+  case 142:
+#line 1029 "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 154:
-#line 1117 "perly.y"
+  case 143:
+#line 1033 "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 155:
-#line 1121 "perly.y"
+  case 144:
+#line 1037 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
@@ -1270,8 +1192,8 @@ case 2:
                        ;}
     break;
 
-  case 156:
-#line 1133 "perly.y"
+  case 145:
+#line 1049 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
                            op_append_elem(OP_LIST,
@@ -1286,8 +1208,8 @@ case 2:
                        ;}
     break;
 
-  case 157:
-#line 1146 "perly.y"
+  case 146:
+#line 1062 "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();
@@ -1297,8 +1219,8 @@ case 2:
                        ;}
     break;
 
-  case 158:
-#line 1154 "perly.y"
+  case 147:
+#line 1070 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
                                (ps[(4) - (5)].val.opval),
@@ -1309,86 +1231,86 @@ case 2:
                        ;}
     break;
 
-  case 163:
-#line 1170 "perly.y"
+  case 152:
+#line 1086 "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),':');
                        ;}
     break;
 
-  case 164:
-#line 1175 "perly.y"
+  case 153:
+#line 1091 "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 165:
-#line 1179 "perly.y"
+  case 154:
+#line 1095 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 166:
-#line 1181 "perly.y"
+  case 155:
+#line 1097 "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 167:
-#line 1185 "perly.y"
+  case 156:
+#line 1101 "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),')');
                        ;}
     break;
 
-  case 168:
-#line 1190 "perly.y"
+  case 157:
+#line 1106 "perly.y"
     { (yyval.opval) = IF_MAD(newUNOP(OP_NULL,0,(ps[(1) - (1)].val.opval)), (ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 169:
-#line 1192 "perly.y"
+  case 158:
+#line 1108 "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),')');
                        ;}
     break;
 
-  case 170:
-#line 1197 "perly.y"
+  case 159:
+#line 1113 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 171:
-#line 1199 "perly.y"
+  case 160:
+#line 1115 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 172:
-#line 1201 "perly.y"
+  case 161:
+#line 1117 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 173:
-#line 1203 "perly.y"
+  case 162:
+#line 1119 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 174:
-#line 1205 "perly.y"
+  case 163:
+#line 1121 "perly.y"
     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
     break;
 
-  case 175:
-#line 1207 "perly.y"
+  case 164:
+#line 1123 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 176:
-#line 1209 "perly.y"
+  case 165:
+#line 1125 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_ASLICE, 0,
@@ -1399,8 +1321,8 @@ case 2:
                        ;}
     break;
 
-  case 177:
-#line 1218 "perly.y"
+  case 166:
+#line 1134 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_HSLICE, 0,
@@ -1413,26 +1335,26 @@ case 2:
                        ;}
     break;
 
-  case 178:
-#line 1229 "perly.y"
+  case 167:
+#line 1145 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 179:
-#line 1231 "perly.y"
+  case 168:
+#line 1147 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
-  case 180:
-#line 1233 "perly.y"
+  case 169:
+#line 1149 "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),')');
                        ;}
     break;
 
-  case 181:
-#line 1238 "perly.y"
+  case 170:
+#line 1154 "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))));
@@ -1447,91 +1369,91 @@ case 2:
                        ;}
     break;
 
-  case 182:
-#line 1251 "perly.y"
+  case 171:
+#line 1167 "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');
                        ;}
     break;
 
-  case 183:
-#line 1256 "perly.y"
+  case 172:
+#line 1172 "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');
                        ;}
     break;
 
-  case 184:
-#line 1261 "perly.y"
+  case 173:
+#line 1177 "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 185:
-#line 1265 "perly.y"
+  case 174:
+#line 1181 "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 186:
-#line 1269 "perly.y"
+  case 175:
+#line 1185 "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 187:
-#line 1273 "perly.y"
+  case 176:
+#line 1189 "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 188:
-#line 1277 "perly.y"
+  case 177:
+#line 1193 "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 189:
-#line 1281 "perly.y"
+  case 178:
+#line 1197 "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 190:
-#line 1285 "perly.y"
+  case 179:
+#line 1201 "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 191:
-#line 1289 "perly.y"
+  case 180:
+#line 1205 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
-  case 192:
-#line 1291 "perly.y"
+  case 181:
+#line 1207 "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 193:
-#line 1294 "perly.y"
+  case 182:
+#line 1210 "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 194:
-#line 1298 "perly.y"
+  case 183:
+#line 1214 "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),'(');
@@ -1539,14 +1461,14 @@ case 2:
                        ;}
     break;
 
-  case 195:
-#line 1304 "perly.y"
+  case 184:
+#line 1220 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
-  case 196:
-#line 1307 "perly.y"
+  case 185:
+#line 1223 "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);
@@ -1557,8 +1479,8 @@ case 2:
                        ;}
     break;
 
-  case 197:
-#line 1316 "perly.y"
+  case 186:
+#line 1232 "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),'(');
@@ -1566,16 +1488,16 @@ case 2:
                        ;}
     break;
 
-  case 198:
-#line 1322 "perly.y"
+  case 187:
+#line 1238 "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),')');
                        ;}
     break;
 
-  case 201:
-#line 1329 "perly.y"
+  case 190:
+#line 1245 "perly.y"
     {
                          (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
                                newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
@@ -1583,8 +1505,8 @@ case 2:
                        ;}
     break;
 
-  case 203:
-#line 1339 "perly.y"
+  case 192:
+#line 1255 "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');
@@ -1594,143 +1516,143 @@ case 2:
                        ;}
     break;
 
-  case 204:
-#line 1347 "perly.y"
+  case 193:
+#line 1263 "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 205:
-#line 1354 "perly.y"
+  case 194:
+#line 1270 "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),')');
                        ;}
     break;
 
-  case 206:
-#line 1359 "perly.y"
+  case 195:
+#line 1275 "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),')');
                        ;}
     break;
 
-  case 207:
-#line 1364 "perly.y"
+  case 196:
+#line 1280 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 208:
-#line 1366 "perly.y"
+  case 197:
+#line 1282 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 209:
-#line 1368 "perly.y"
+  case 198:
+#line 1284 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 210:
-#line 1373 "perly.y"
+  case 199:
+#line 1289 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 211:
-#line 1375 "perly.y"
+  case 200:
+#line 1291 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 212:
-#line 1379 "perly.y"
+  case 201:
+#line 1295 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 213:
-#line 1381 "perly.y"
+  case 202:
+#line 1297 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 214:
-#line 1385 "perly.y"
+  case 203:
+#line 1301 "perly.y"
     { (yyval.i_tkval) = (ps[(1) - (1)].val.i_tkval); ;}
     break;
 
-  case 215:
-#line 1387 "perly.y"
+  case 204:
+#line 1303 "perly.y"
     { munge_qwlist_to_paren_list((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 216:
-#line 1389 "perly.y"
+  case 205:
+#line 1305 "perly.y"
     { (yyval.i_tkval) = (ps[(3) - (3)].val.i_tkval); ;}
     break;
 
-  case 217:
-#line 1395 "perly.y"
+  case 206:
+#line 1311 "perly.y"
     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 218:
-#line 1399 "perly.y"
+  case 207:
+#line 1315 "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 219:
-#line 1405 "perly.y"
+  case 208:
+#line 1321 "perly.y"
     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
                        ;}
     break;
 
-  case 220:
-#line 1411 "perly.y"
+  case 209:
+#line 1327 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
                        ;}
     break;
 
-  case 221:
-#line 1417 "perly.y"
+  case 210:
+#line 1333 "perly.y"
     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
                        ;}
     break;
 
-  case 222:
-#line 1423 "perly.y"
+  case 211:
+#line 1339 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
                        ;}
     break;
 
-  case 223:
-#line 1429 "perly.y"
+  case 212:
+#line 1345 "perly.y"
     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
                        ;}
     break;
 
-  case 224:
-#line 1436 "perly.y"
+  case 213:
+#line 1352 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 225:
-#line 1438 "perly.y"
+  case 214:
+#line 1354 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 226:
-#line 1440 "perly.y"
+  case 215:
+#line 1356 "perly.y"
     { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 227:
-#line 1443 "perly.y"
+  case 216:
+#line 1359 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
index 236e681..bd6e118 100644 (file)
--- a/perly.tab
+++ b/perly.tab
@@ -1,15 +1,15 @@
 #define YYFINAL  11
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   2143
+#define YYLAST   2180
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  98
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  73
+#define YYNNTS  62
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  227
+#define YYNRULES  216
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  449
+#define YYNSTATES  438
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
@@ -64,27 +64,26 @@ static const yytype_uint16 yyprhs[] =
 {
        0,     0,     3,     6,     7,    11,    12,    16,    17,    21,
       24,    29,    30,    31,    32,    37,    38,    39,    42,    45,
-      47,    49,    52,    55,    59,    62,    65,    68,    70,    72,
-      76,    80,    84,    88,    92,    96,    97,   100,   107,   115,
-     123,   130,   133,   134,   137,   147,   157,   168,   178,   187,
-     200,   204,   213,   214,   215,   217,   218,   220,   222,   224,
-     226,   228,   229,   231,   233,   235,   237,   239,   241,   243,
-     245,   250,   252,   253,   260,   267,   268,   269,   270,   272,
-     273,   275,   276,   279,   281,   284,   286,   288,   290,   295,
-     296,   305,   306,   314,   318,   322,   326,   328,   331,   335,
-     337,   341,   347,   354,   358,   362,   368,   371,   376,   377,
-     383,   385,   387,   393,   398,   404,   409,   415,   422,   428,
-     433,   439,   444,   448,   455,   460,   466,   470,   474,   478,
-     482,   486,   490,   494,   498,   502,   506,   510,   514,   518,
-     522,   525,   528,   531,   534,   537,   540,   543,   546,   550,
-     553,   558,   562,   568,   571,   574,   579,   585,   590,   596,
-     598,   600,   602,   604,   610,   613,   615,   618,   622,   624,
-     627,   629,   631,   633,   635,   637,   639,   644,   650,   652,
-     654,   658,   663,   667,   669,   672,   675,   677,   680,   683,
-     685,   688,   690,   693,   695,   699,   701,   705,   710,   715,
-     717,   719,   721,   723,   727,   730,   734,   737,   739,   741,
-     743,   744,   746,   747,   749,   751,   752,   756,   758,   761,
-     764,   767,   770,   773,   776,   778,   780,   782
+      47,    49,    54,    61,    68,    73,    74,    82,    90,    98,
+     106,   113,   116,   125,   134,   146,   156,   165,   173,   176,
+     177,   186,   189,   191,   193,   195,   199,   203,   207,   211,
+     215,   219,   220,   223,   230,   231,   234,   235,   236,   238,
+     239,   241,   243,   245,   247,   249,   250,   252,   254,   255,
+     256,   257,   258,   260,   261,   263,   264,   267,   269,   272,
+     274,   276,   278,   282,   286,   290,   292,   295,   299,   301,
+     305,   311,   318,   322,   326,   332,   335,   340,   341,   347,
+     349,   351,   357,   362,   368,   373,   379,   386,   392,   397,
+     403,   408,   412,   419,   424,   430,   434,   438,   442,   446,
+     450,   454,   458,   462,   466,   470,   474,   478,   482,   486,
+     489,   492,   495,   498,   501,   504,   507,   510,   514,   517,
+     522,   526,   532,   535,   538,   543,   549,   554,   560,   562,
+     564,   566,   568,   574,   577,   579,   582,   586,   588,   591,
+     593,   595,   597,   599,   601,   603,   608,   614,   616,   618,
+     622,   627,   631,   633,   636,   639,   641,   644,   647,   649,
+     652,   654,   657,   659,   663,   665,   669,   674,   679,   681,
+     683,   685,   687,   691,   694,   698,   701,   703,   705,   707,
+     708,   710,   711,   713,   715,   716,   720,   722,   725,   728,
+     731,   734,   737,   740,   742,   744,   746
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
@@ -94,109 +93,104 @@ static const yytype_int16 yyrhs[] =
       -1,    -1,     5,   101,   111,    -1,    -1,     6,   102,   110,
       -1,   107,   110,    -1,     7,   105,   110,     8,    -1,    -1,
       -1,    -1,     7,   109,   110,     8,    -1,    -1,    -1,   110,
-     111,    -1,   126,   114,    -1,   117,    -1,   118,    -1,   126,
-     115,    -1,   126,    18,    -1,   126,   112,    18,    -1,   126,
-     142,    -1,   126,    30,    -1,   126,   127,    -1,     1,    -1,
-     146,    -1,   146,    39,   146,    -1,   146,    40,   146,    -1,
-     146,    37,   146,    -1,   146,    38,   122,    -1,   146,    44,
-     146,    -1,   146,    46,   146,    -1,    -1,    41,   108,    -1,
-      42,   161,   123,    95,   108,   113,    -1,    39,   161,   105,
-     123,    95,   108,   113,    -1,    40,   161,   105,   125,    95,
-     108,   113,    -1,    46,   161,   105,   123,    95,   108,    -1,
-      47,   104,    -1,    -1,    43,   104,    -1,   126,    37,   161,
-     105,   121,    95,   119,   108,   116,    -1,   126,    38,   161,
-     105,   122,    95,   119,   108,   116,    -1,   126,    44,    65,
-     105,   163,   161,   123,    95,   108,   116,    -1,   126,    44,
-     165,   161,   105,   123,    95,   108,   116,    -1,   126,    44,
-     161,   105,   123,    95,   108,   116,    -1,   126,    44,   161,
-     105,   124,    18,   121,    18,   119,   124,    95,   108,    -1,
-     126,   104,   116,    -1,   126,    45,   161,   105,   106,   123,
-      95,   108,    -1,    -1,    -1,   112,    -1,    -1,   146,    -1,
-     146,    -1,   146,    -1,   120,    -1,   122,    -1,    -1,    31,
-      -1,   129,    -1,   132,    -1,   131,    -1,   141,    -1,   144,
-      -1,   128,    -1,    97,    -1,    32,   135,   130,   104,    -1,
-      19,    -1,    -1,    66,   133,   136,   137,   138,   140,    -1,
-      33,   133,   136,   137,   138,   140,    -1,    -1,    -1,    -1,
-      19,    -1,    -1,    22,    -1,    -1,    68,    22,    -1,    68,
-      -1,    68,    22,    -1,    68,    -1,   104,    -1,    18,    -1,
-      35,    19,    19,    18,    -1,    -1,    35,    19,    19,     7,
-     105,   143,   110,     8,    -1,    -1,    36,   133,   145,    19,
-      19,   159,    18,    -1,   146,    72,   146,    -1,   146,    71,
-     146,    -1,   146,    70,   146,    -1,   147,    -1,   147,    74,
-      -1,   147,    74,   156,    -1,   156,    -1,    55,   170,   147,
-      -1,    53,    96,   170,   146,    95,    -1,   156,    94,   150,
-     161,   160,    95,    -1,   156,    94,   150,    -1,    20,   170,
-     159,    -1,    21,   170,    96,   160,    95,    -1,    55,   159,
-      -1,    53,    96,   160,    95,    -1,    -1,    28,   134,   104,
-     149,   159,    -1,    20,    -1,   165,    -1,   169,     7,   146,
-      18,     8,    -1,   165,     9,   146,    10,    -1,   156,    94,
-       9,   146,    10,    -1,   151,     9,   146,    10,    -1,   165,
-       7,   146,    18,     8,    -1,   156,    94,     7,   146,    18,
-       8,    -1,   151,     7,   146,    18,     8,    -1,   156,    94,
-      96,    95,    -1,   156,    94,    96,   146,    95,    -1,   151,
-     161,   146,    95,    -1,   151,   161,    95,    -1,    96,   146,
-      95,     9,   146,    10,    -1,    25,     9,   146,    10,    -1,
-      96,    95,     9,   146,    10,    -1,   156,    75,   156,    -1,
-     156,    89,   156,    -1,   156,    58,   156,    -1,   156,    59,
-     156,    -1,   156,    83,   156,    -1,   156,    56,   156,    -1,
-     156,    57,   156,    -1,   156,    82,   156,    -1,   156,    81,
-     156,    -1,   156,    49,   156,    -1,   156,    80,   156,    -1,
-     156,    79,   156,    -1,   156,    78,   156,    -1,   156,    84,
-     156,    -1,    11,   156,    -1,    12,   156,    -1,    85,   156,
-      -1,    86,   156,    -1,   156,    91,    -1,   156,    90,    -1,
-      93,   156,    -1,    92,   156,    -1,     9,   146,    10,    -1,
-       9,    10,    -1,    62,   146,    18,     8,    -1,    62,    18,
-       8,    -1,    34,   134,   137,   138,   104,    -1,    61,   156,
-      -1,    61,   104,    -1,    61,    19,   161,    95,    -1,    61,
-      19,   161,   146,    95,    -1,    61,   165,   161,    95,    -1,
-      61,   165,   161,   146,    95,    -1,   152,    -1,   153,    -1,
-     154,    -1,   155,    -1,   156,    76,   156,    77,   156,    -1,
-      87,   156,    -1,   157,    -1,    64,   156,    -1,    96,   146,
-      95,    -1,    25,    -1,    96,    95,    -1,   165,    -1,   169,
-      -1,   167,    -1,   166,    -1,   168,    -1,   151,    -1,   166,
-       9,   146,    10,    -1,   166,     7,   146,    18,     8,    -1,
-      22,    -1,   164,    -1,   164,   161,    95,    -1,   164,   161,
-     146,    95,    -1,    63,    19,   159,    -1,    48,    -1,    48,
-     156,    -1,    73,   147,    -1,    54,    -1,    54,   104,    -1,
-      54,   156,    -1,    67,    -1,    67,   156,    -1,    27,    -1,
-      27,   156,    -1,    51,    -1,    51,    96,    95,    -1,    26,
-      -1,    52,    96,    95,    -1,    52,    96,   146,    95,    -1,
-      23,    96,   147,    95,    -1,    19,    -1,   148,    -1,    50,
-      -1,    29,    -1,    65,   158,   139,    -1,    65,   158,    -1,
-      96,   146,    95,    -1,    96,    95,    -1,   165,    -1,   167,
-      -1,   166,    -1,    -1,   147,    -1,    -1,   146,    -1,    96,
-      -1,    -1,    25,   162,    96,    -1,   165,    -1,    17,   170,
-      -1,    13,   170,    -1,    14,   170,    -1,    15,   170,    -1,
-      60,   170,    -1,    16,   170,    -1,    19,    -1,   165,    -1,
-     104,    -1,    24,    -1
+     111,    -1,   125,   112,    -1,    30,    -1,    97,    -1,    32,
+     129,   126,   104,    -1,    33,   127,   130,   131,   132,   134,
+      -1,    66,   127,   130,   131,   132,   134,    -1,    35,    19,
+      19,    18,    -1,    -1,    36,   127,   113,    19,    19,   148,
+      18,    -1,    39,   150,   105,   122,    95,   108,   116,    -1,
+      40,   150,   105,   124,    95,   108,   116,    -1,    45,   150,
+     105,   106,   122,    95,   108,    -1,    46,   150,   105,   122,
+      95,   108,    -1,    47,   104,    -1,    37,   150,   105,   120,
+      95,   118,   108,   117,    -1,    38,   150,   105,   121,    95,
+     118,   108,   117,    -1,    44,   150,   105,   123,    18,   120,
+      18,   118,   123,    95,   108,    -1,    44,    65,   105,   152,
+     150,   122,    95,   108,   117,    -1,    44,   154,   150,   105,
+     122,    95,   108,   117,    -1,    44,   150,   105,   122,    95,
+     108,   117,    -1,   104,   117,    -1,    -1,    35,    19,    19,
+       7,   105,   114,   110,     8,    -1,   115,    18,    -1,    18,
+      -1,     1,    -1,   135,    -1,   135,    39,   135,    -1,   135,
+      40,   135,    -1,   135,    37,   135,    -1,   135,    38,   121,
+      -1,   135,    44,   135,    -1,   135,    46,   135,    -1,    -1,
+      41,   108,    -1,    42,   150,   122,    95,   108,   116,    -1,
+      -1,    43,   104,    -1,    -1,    -1,   115,    -1,    -1,   135,
+      -1,   135,    -1,   135,    -1,   119,    -1,   121,    -1,    -1,
+      31,    -1,    19,    -1,    -1,    -1,    -1,    -1,    19,    -1,
+      -1,    22,    -1,    -1,    68,    22,    -1,    68,    -1,    68,
+      22,    -1,    68,    -1,   104,    -1,    18,    -1,   135,    72,
+     135,    -1,   135,    71,   135,    -1,   135,    70,   135,    -1,
+     136,    -1,   136,    74,    -1,   136,    74,   145,    -1,   145,
+      -1,    55,   159,   136,    -1,    53,    96,   159,   135,    95,
+      -1,   145,    94,   139,   150,   149,    95,    -1,   145,    94,
+     139,    -1,    20,   159,   148,    -1,    21,   159,    96,   149,
+      95,    -1,    55,   148,    -1,    53,    96,   149,    95,    -1,
+      -1,    28,   128,   104,   138,   148,    -1,    20,    -1,   154,
+      -1,   158,     7,   135,    18,     8,    -1,   154,     9,   135,
+      10,    -1,   145,    94,     9,   135,    10,    -1,   140,     9,
+     135,    10,    -1,   154,     7,   135,    18,     8,    -1,   145,
+      94,     7,   135,    18,     8,    -1,   140,     7,   135,    18,
+       8,    -1,   145,    94,    96,    95,    -1,   145,    94,    96,
+     135,    95,    -1,   140,   150,   135,    95,    -1,   140,   150,
+      95,    -1,    96,   135,    95,     9,   135,    10,    -1,    25,
+       9,   135,    10,    -1,    96,    95,     9,   135,    10,    -1,
+     145,    75,   145,    -1,   145,    89,   145,    -1,   145,    58,
+     145,    -1,   145,    59,   145,    -1,   145,    83,   145,    -1,
+     145,    56,   145,    -1,   145,    57,   145,    -1,   145,    82,
+     145,    -1,   145,    81,   145,    -1,   145,    49,   145,    -1,
+     145,    80,   145,    -1,   145,    79,   145,    -1,   145,    78,
+     145,    -1,   145,    84,   145,    -1,    11,   145,    -1,    12,
+     145,    -1,    85,   145,    -1,    86,   145,    -1,   145,    91,
+      -1,   145,    90,    -1,    93,   145,    -1,    92,   145,    -1,
+       9,   135,    10,    -1,     9,    10,    -1,    62,   135,    18,
+       8,    -1,    62,    18,     8,    -1,    34,   128,   131,   132,
+     104,    -1,    61,   145,    -1,    61,   104,    -1,    61,    19,
+     150,    95,    -1,    61,    19,   150,   135,    95,    -1,    61,
+     154,   150,    95,    -1,    61,   154,   150,   135,    95,    -1,
+     141,    -1,   142,    -1,   143,    -1,   144,    -1,   145,    76,
+     145,    77,   145,    -1,    87,   145,    -1,   146,    -1,    64,
+     145,    -1,    96,   135,    95,    -1,    25,    -1,    96,    95,
+      -1,   154,    -1,   158,    -1,   156,    -1,   155,    -1,   157,
+      -1,   140,    -1,   155,     9,   135,    10,    -1,   155,     7,
+     135,    18,     8,    -1,    22,    -1,   153,    -1,   153,   150,
+      95,    -1,   153,   150,   135,    95,    -1,    63,    19,   148,
+      -1,    48,    -1,    48,   145,    -1,    73,   136,    -1,    54,
+      -1,    54,   104,    -1,    54,   145,    -1,    67,    -1,    67,
+     145,    -1,    27,    -1,    27,   145,    -1,    51,    -1,    51,
+      96,    95,    -1,    26,    -1,    52,    96,    95,    -1,    52,
+      96,   135,    95,    -1,    23,    96,   136,    95,    -1,    19,
+      -1,   137,    -1,    50,    -1,    29,    -1,    65,   147,   133,
+      -1,    65,   147,    -1,    96,   135,    95,    -1,    96,    95,
+      -1,   154,    -1,   156,    -1,   155,    -1,    -1,   136,    -1,
+      -1,   135,    -1,    96,    -1,    -1,    25,   151,    96,    -1,
+     154,    -1,    17,   159,    -1,    13,   159,    -1,    14,   159,
+      -1,    15,   159,    -1,    60,   159,    -1,    16,   159,    -1,
+      19,    -1,   154,    -1,   104,    -1,    24,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   144,   144,   147,   146,   159,   158,   171,   170,   182,
-     188,   198,   202,   206,   212,   222,   227,   228,   237,   240,
-     241,   243,   245,   262,   278,   283,   285,   296,   298,   300,
-     304,   308,   312,   316,   321,   327,   328,   332,   343,   351,
-     362,   365,   371,   372,   379,   392,   404,   415,   425,   435,
-     467,   475,   485,   491,   492,   497,   500,   504,   509,   513,
-     517,   523,   532,   536,   538,   540,   542,   544,   549,   553,
-     559,   579,   580,   584,   597,   620,   626,   631,   636,   646,
-     647,   652,   653,   657,   667,   671,   681,   682,   691,   709,
-     708,   734,   733,   752,   756,   760,   764,   768,   778,   787,
-     791,   796,   803,   812,   818,   824,   832,   836,   843,   842,
-     853,   854,   858,   867,   872,   880,   887,   894,   904,   913,
-     920,   929,   936,   942,   949,   954,   964,   968,   972,   978,
-     982,   986,   990,   994,   998,  1002,  1014,  1018,  1022,  1026,
-    1036,  1040,  1047,  1051,  1055,  1060,  1065,  1070,  1079,  1084,
-    1089,  1095,  1101,  1112,  1116,  1120,  1132,  1145,  1153,  1165,
-    1166,  1167,  1168,  1169,  1174,  1178,  1180,  1184,  1189,  1191,
-    1196,  1198,  1200,  1202,  1204,  1206,  1208,  1217,  1228,  1230,
-    1232,  1237,  1250,  1255,  1260,  1264,  1268,  1272,  1276,  1280,
-    1284,  1288,  1290,  1293,  1297,  1303,  1306,  1315,  1321,  1326,
-    1327,  1328,  1334,  1338,  1346,  1353,  1358,  1363,  1365,  1367,
-    1372,  1374,  1379,  1380,  1384,  1387,  1386,  1394,  1398,  1404,
-    1410,  1416,  1422,  1428,  1435,  1437,  1439,  1442
+       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
 };
 #endif
 
@@ -220,15 +214,14 @@ static const char *const yytname[] =
   "POWOP", "POSTDEC", "POSTINC", "PREDEC", "PREINC", "ARROW", "')'", "'('",
   "PEG", "$accept", "grammar", "@1", "@2", "@3", "prog", "block",
   "remember", "mydefsv", "progstart", "mblock", "mremember", "stmtseq",
-  "fullstmt", "sideff", "else", "cond", "case", "cont", "loop", "switch",
-  "mintro", "nexpr", "texpr", "iexpr", "mexpr", "mnexpr", "miexpr",
-  "label", "decl", "peg", "format", "formname", "mysubrout", "subrout",
-  "startsub", "startanonsub", "startformsub", "subname", "proto",
-  "subattrlist", "myattrlist", "subbody", "package", "package_block", "@4",
-  "use", "@5", "expr", "argexpr", "listop", "@6", "method", "subscripted",
-  "termbinop", "termunop", "anonymous", "termdo", "term", "myattrterm",
-  "myterm", "listexpr", "listexprcom", "lpar_or_qw", "@7", "my_scalar",
-  "amper", "scalar", "ary", "hsh", "arylen", "star", "indirob", 0
+  "fullstmt", "barestmt", "@4", "@5", "sideff", "else", "cont", "mintro",
+  "nexpr", "texpr", "iexpr", "mexpr", "mnexpr", "miexpr", "label",
+  "formname", "startsub", "startanonsub", "startformsub", "subname",
+  "proto", "subattrlist", "myattrlist", "subbody", "expr", "argexpr",
+  "listop", "@6", "method", "subscripted", "termbinop", "termunop",
+  "anonymous", "termdo", "term", "myattrterm", "myterm", "listexpr",
+  "listexprcom", "lpar_or_qw", "@7", "my_scalar", "amper", "scalar", "ary",
+  "hsh", "arylen", "star", "indirob", 0
 };
 #endif
 
@@ -254,28 +247,27 @@ static const yytype_uint16 yytoknum[] =
 static const yytype_uint8 yyr1[] =
 {
        0,    98,    99,   100,    99,   101,    99,   102,    99,   103,
-     104,   105,   106,   107,   108,   109,   110,   110,   111,   111,
-     111,   111,   111,   111,   111,   111,   111,   112,   112,   112,
-     112,   112,   112,   112,   112,   113,   113,   113,   114,   114,
-     115,   115,   116,   116,   117,   117,   117,   117,   117,   117,
-     117,   118,   119,   120,   120,   121,   121,   122,   123,   124,
-     125,   126,   126,   127,   127,   127,   127,   127,   127,   128,
-     129,   130,   130,   131,   132,   133,   134,   135,   136,   137,
-     137,   138,   138,   138,   139,   139,   140,   140,   141,   143,
-     142,   145,   144,   146,   146,   146,   146,   147,   147,   147,
-     148,   148,   148,   148,   148,   148,   148,   148,   149,   148,
-     150,   150,   151,   151,   151,   151,   151,   151,   151,   151,
-     151,   151,   151,   151,   151,   151,   152,   152,   152,   152,
-     152,   152,   152,   152,   152,   152,   152,   152,   152,   152,
-     153,   153,   153,   153,   153,   153,   153,   153,   154,   154,
-     154,   154,   154,   155,   155,   155,   155,   155,   155,   156,
-     156,   156,   156,   156,   156,   156,   156,   156,   156,   156,
-     156,   156,   156,   156,   156,   156,   156,   156,   156,   156,
-     156,   156,   156,   156,   156,   156,   156,   156,   156,   156,
-     156,   156,   156,   156,   156,   156,   156,   156,   156,   156,
-     156,   156,   156,   157,   157,   158,   158,   158,   158,   158,
-     159,   159,   160,   160,   161,   162,   161,   163,   164,   165,
-     166,   167,   168,   169,   170,   170,   170,   170
+     104,   105,   106,   107,   108,   109,   110,   110,   111,   112,
+     112,   112,   112,   112,   112,   113,   112,   112,   112,   112,
+     112,   112,   112,   112,   112,   112,   112,   112,   112,   114,
+     112,   112,   112,   115,   115,   115,   115,   115,   115,   115,
+     115,   116,   116,   116,   117,   117,   118,   119,   119,   120,
+     120,   121,   122,   123,   124,   125,   125,   126,   126,   127,
+     128,   129,   130,   131,   131,   132,   132,   132,   133,   133,
+     134,   134,   135,   135,   135,   135,   136,   136,   136,   137,
+     137,   137,   137,   137,   137,   137,   137,   138,   137,   139,
+     139,   140,   140,   140,   140,   140,   140,   140,   140,   140,
+     140,   140,   140,   140,   140,   141,   141,   141,   141,   141,
+     141,   141,   141,   141,   141,   141,   141,   141,   141,   142,
+     142,   142,   142,   142,   142,   142,   142,   143,   143,   143,
+     143,   143,   144,   144,   144,   144,   144,   144,   145,   145,
+     145,   145,   145,   145,   145,   145,   145,   145,   145,   145,
+     145,   145,   145,   145,   145,   145,   145,   145,   145,   145,
+     145,   145,   145,   145,   145,   145,   145,   145,   145,   145,
+     145,   145,   145,   145,   145,   145,   145,   145,   145,   145,
+     145,   145,   146,   146,   147,   147,   147,   147,   147,   148,
+     148,   149,   149,   150,   151,   150,   152,   153,   154,   155,
+     156,   157,   158,   159,   159,   159,   159
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -283,27 +275,26 @@ static const yytype_uint8 yyr2[] =
 {
        0,     2,     2,     0,     3,     0,     3,     0,     3,     2,
        4,     0,     0,     0,     4,     0,     0,     2,     2,     1,
-       1,     2,     2,     3,     2,     2,     2,     1,     1,     3,
-       3,     3,     3,     3,     3,     0,     2,     6,     7,     7,
-       6,     2,     0,     2,     9,     9,    10,     9,     8,    12,
-       3,     8,     0,     0,     1,     0,     1,     1,     1,     1,
-       1,     0,     1,     1,     1,     1,     1,     1,     1,     1,
-       4,     1,     0,     6,     6,     0,     0,     0,     1,     0,
-       1,     0,     2,     1,     2,     1,     1,     1,     4,     0,
-       8,     0,     7,     3,     3,     3,     1,     2,     3,     1,
-       3,     5,     6,     3,     3,     5,     2,     4,     0,     5,
-       1,     1,     5,     4,     5,     4,     5,     6,     5,     4,
-       5,     4,     3,     6,     4,     5,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       2,     2,     2,     2,     2,     2,     2,     2,     3,     2,
-       4,     3,     5,     2,     2,     4,     5,     4,     5,     1,
-       1,     1,     1,     5,     2,     1,     2,     3,     1,     2,
-       1,     1,     1,     1,     1,     1,     4,     5,     1,     1,
-       3,     4,     3,     1,     2,     2,     1,     2,     2,     1,
-       2,     1,     2,     1,     3,     1,     3,     4,     4,     1,
-       1,     1,     1,     3,     2,     3,     2,     1,     1,     1,
-       0,     1,     0,     1,     1,     0,     3,     1,     2,     2,
-       2,     2,     2,     2,     1,     1,     1,     1
+       1,     4,     6,     6,     4,     0,     7,     7,     7,     7,
+       6,     2,     8,     8,    11,     9,     8,     7,     2,     0,
+       8,     2,     1,     1,     1,     3,     3,     3,     3,     3,
+       3,     0,     2,     6,     0,     2,     0,     0,     1,     0,
+       1,     1,     1,     1,     1,     0,     1,     1,     0,     0,
+       0,     0,     1,     0,     1,     0,     2,     1,     2,     1,
+       1,     1,     3,     3,     3,     1,     2,     3,     1,     3,
+       5,     6,     3,     3,     5,     2,     4,     0,     5,     1,
+       1,     5,     4,     5,     4,     5,     6,     5,     4,     5,
+       4,     3,     6,     4,     5,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     2,
+       2,     2,     2,     2,     2,     2,     2,     3,     2,     4,
+       3,     5,     2,     2,     4,     5,     4,     5,     1,     1,
+       1,     1,     5,     2,     1,     2,     3,     1,     2,     1,
+       1,     1,     1,     1,     1,     4,     5,     1,     1,     3,
+       4,     3,     1,     2,     2,     1,     2,     2,     1,     2,
+       1,     2,     1,     3,     1,     3,     4,     4,     1,     1,
+       1,     1,     3,     2,     3,     2,     1,     1,     1,     0,
+       1,     0,     1,     1,     0,     3,     1,     2,     2,     2,
+       2,     2,     2,     1,     1,     1,     1
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -311,445 +302,436 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       0,    13,     3,     5,     7,     0,     2,    16,     0,    61,
-      16,     1,    61,    11,     4,    62,     6,    19,    20,     0,
-      61,    17,    16,    27,     0,     0,     0,     0,     0,     0,
-       0,     0,    22,   199,     0,     0,   178,     0,   168,   195,
-     191,    76,   202,    25,    77,    75,    76,     0,    75,     0,
-       0,     0,     0,     0,     0,     0,     0,   183,   201,   193,
-       0,     0,   186,   210,     0,     0,     0,     0,     0,     0,
-      75,   189,     0,     0,     0,     0,     0,     0,     0,    69,
-      42,     0,    18,    21,    26,    68,    63,    65,    64,    66,
-      24,    67,    28,    96,   200,   175,   159,   160,   161,   162,
-      99,   165,   179,   170,   173,   172,   174,   171,    61,   149,
-       0,   140,   141,   224,   227,   226,   225,   219,   220,   221,
-     223,   218,   210,     0,     0,     0,   192,     0,    72,     0,
-      79,     0,    91,   215,   214,    11,    11,    11,    11,    11,
-      11,     0,    11,    11,    41,   184,     0,     0,   212,   187,
-     188,   224,   211,   106,   225,     0,   222,   199,   154,   153,
-     170,     0,     0,   210,   166,     0,   204,   207,   209,   208,
-       0,   190,   185,   142,   143,   164,   147,   146,   169,     0,
-       0,    50,    23,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    97,     0,     0,     0,     0,     0,     0,     0,
+       0,    13,     3,     5,     7,     0,     2,    16,     0,    65,
+      16,     1,    65,    11,     4,    66,     6,     0,    65,    17,
+      16,    43,     0,     0,     0,     0,     0,     0,     0,     0,
+      42,   188,     0,     0,   167,     0,   157,   184,   180,    70,
+     191,    19,    71,    69,    70,     0,    69,     0,     0,     0,
+       0,     0,     0,     0,     0,   172,   190,   182,     0,     0,
+     175,   199,     0,     0,     0,     0,     0,     0,    69,   178,
+       0,     0,     0,     0,     0,     0,     0,    20,    54,    18,
+       0,    44,    85,   189,   164,   148,   149,   150,   151,    88,
+     154,   168,   159,   162,   161,   163,   160,    65,   138,     0,
+     129,   130,   213,   216,   215,   214,   208,   209,   210,   212,
+     207,   199,     0,     0,     0,   181,     0,    68,     0,    73,
+       0,    25,   204,   203,    11,    11,    11,    11,    11,    11,
+       0,    11,    11,    31,   173,     0,     0,   201,   176,   177,
+     213,   200,    95,   214,     0,   211,   188,   143,   142,   159,
+       0,     0,   199,   155,     0,   193,   196,   198,   197,     0,
+     179,   174,   131,   132,   153,   136,   135,   158,     0,     0,
+      38,    41,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    86,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   145,   144,     0,     0,     0,     0,     0,     0,     0,
-      10,   148,   104,   212,     0,     0,   108,    71,     0,    78,
-      79,    80,    81,     0,     0,     0,    55,     0,     0,     0,
-       0,     0,    11,    12,     0,   194,   196,     0,   213,     0,
-       0,   100,     0,     0,   151,     0,   182,   206,     0,    85,
-     203,    79,     0,   167,    43,    31,    32,    57,    29,    30,
-      33,    34,    95,    94,    93,    98,     0,     0,   122,     0,
-     135,   131,   132,   128,   129,   126,     0,   138,   137,   136,
-     134,   133,   130,   139,   127,     0,     0,   110,     0,   103,
-     111,   180,     0,     0,     0,     0,     0,     0,     0,   198,
-     124,   210,    70,    81,    83,     0,    11,    88,     0,   216,
-       0,    56,     0,     0,    58,    60,     0,     0,   217,    54,
-      59,     0,     0,    28,     0,     0,     0,   197,   107,     0,
-     155,     0,   157,     0,   150,   205,    84,    81,     0,     0,
-       0,   115,   121,     0,     0,     0,   119,     0,   212,   181,
-       0,   113,     0,   176,     0,   105,   109,     0,    82,   152,
-      89,   210,    52,    52,     0,     0,     0,     0,    55,     0,
-       0,     0,   101,   156,   158,     0,   125,     0,   118,   163,
-       0,   114,   120,     0,   116,   177,   112,    87,    86,    74,
-      16,     0,     0,     0,    15,    35,    35,     0,    42,     0,
-       0,     0,    40,    73,   123,   117,   102,    61,    92,    42,
-      42,    16,     0,     0,    38,    39,     0,    48,    52,    42,
-      51,    90,    44,    45,    61,    36,     0,    42,     0,    47,
-      14,     0,    46,     0,     0,     0,    35,    49,    37
+     134,   133,     0,     0,     0,     0,     0,     0,     0,    10,
+     137,    93,   201,     0,     0,    97,    67,     0,    72,    73,
+      74,    75,     0,     0,     0,    59,     0,     0,     0,     0,
+       0,    11,    12,     0,   183,   185,     0,   202,     0,     0,
+      89,     0,     0,   140,     0,   171,   195,     0,    79,   192,
+      73,     0,   156,    55,    47,    48,    61,    45,    46,    49,
+      50,    84,    83,    82,    87,     0,     0,   111,     0,   124,
+     120,   121,   117,   118,   115,     0,   127,   126,   125,   123,
+     122,   119,   128,   116,     0,     0,    99,     0,    92,   100,
+     169,     0,     0,     0,     0,     0,     0,     0,   187,   113,
+     199,    21,    75,    77,     0,    11,    24,     0,   205,     0,
+      60,     0,     0,    62,    64,     0,     0,   206,    58,    63,
+       0,     0,    44,     0,     0,     0,   186,    96,     0,   144,
+       0,   146,     0,   139,   194,    78,    75,     0,     0,     0,
+     104,   110,     0,     0,     0,   108,     0,   201,   170,     0,
+     102,     0,   165,     0,    94,    98,     0,    76,   141,    39,
+     199,    56,    56,     0,     0,     0,     0,    59,     0,     0,
+       0,    90,   145,   147,     0,   114,     0,   107,   152,     0,
+     103,   109,     0,   105,   166,   101,    81,    80,    22,    16,
+       0,     0,     0,    15,    51,    51,     0,    54,     0,     0,
+       0,    30,    23,   112,   106,    91,    65,    26,    54,    54,
+      16,     0,     0,    27,    28,     0,    37,    56,    54,    29,
+      40,    32,    33,    65,    52,     0,    54,     0,    36,    14,
+       0,    35,     0,     0,     0,    51,    34,    53
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,     5,     8,     9,    10,     6,   115,    22,   335,     7,
-     405,   421,    12,    21,   329,   424,    82,    83,   181,    17,
-      18,   402,   330,   320,   266,   323,   332,   326,    19,    84,
-      85,    86,   228,    87,    88,   129,   127,   128,   230,   232,
-     315,   260,   399,    89,    90,   400,    91,   234,   324,    93,
-      94,   311,   299,    95,    96,    97,    98,    99,   100,   101,
-     166,   153,   249,   135,   235,   327,   102,   103,   104,   105,
-     106,   107,   117
+      -1,     5,     8,     9,    10,     6,   104,    20,   324,     7,
+     394,   410,    12,    19,    79,   223,   389,   318,   413,   170,
+     391,   319,   309,   255,   312,   321,   315,    17,   217,   118,
+     116,   117,   219,   221,   304,   249,   388,   313,    82,    83,
+     300,   288,    84,    85,    86,    87,    88,    89,    90,   155,
+     142,   238,   124,   224,   316,    91,    92,    93,    94,    95,
+      96,   106
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -392
+#define YYPACT_NINF -350
 static const yytype_int16 yypact[] =
 {
-     401,  -392,  -392,  -392,  -392,    14,  -392,  -392,    12,    27,
-    -392,  -392,    48,  -392,  -392,  -392,  -392,  -392,  -392,   435,
-      61,  -392,  -392,  -392,  1031,  1907,  1907,   500,   500,   500,
-     500,   500,  -392,  -392,   500,   500,  -392,   -25,   108,  -392,
-    1907,  -392,  -392,  -392,  -392,  -392,  -392,   112,  -392,     4,
-       4,     4,     4,     5,     4,     4,    12,  1907,  -392,    60,
-      89,    93,   795,   707,   500,   883,  1117,   182,  1907,    37,
-    -392,  1907,  1907,  1907,  1907,  1907,  1907,  1907,  1203,  -392,
-      80,   209,  -392,  -392,  -392,  -392,  -392,  -392,  -392,  -392,
-    -392,  -392,  1115,   161,  -392,     1,  -392,  -392,  -392,  -392,
-     319,  -392,     4,   200,   212,  -392,  -392,   229,    38,  -392,
-      32,    90,    90,  -392,  -392,  -392,  -392,  -392,  -392,  -392,
-    -392,  -392,  1907,   146,  1907,  1907,   915,    12,   230,   235,
-     226,   237,  -392,  -392,  -392,  -392,  -392,  -392,  -392,  -392,
-    -392,     4,  -392,  -392,  -392,   319,   168,  1291,   707,  -392,
-     915,  1967,   161,  -392,   944,  1907,  -392,     4,  -392,   915,
-       2,   256,    23,  1907,   915,  1379,   198,  -392,  -392,  -392,
-     235,   915,   161,    90,    90,    90,   150,   150,   258,   158,
-      12,  -392,  -392,  1907,  1907,  1907,  1907,  1907,  1907,  1907,
-    1907,  1907,  1907,  1907,  1907,  1467,  1907,  1907,  1907,  1907,
-    1907,  1907,  1907,  1907,  1907,  1907,  1907,  1907,  1907,  1907,
-    1907,  -392,  -392,    36,  1555,  1907,  1907,  1907,  1907,  1907,
-    -392,  -392,  -392,  1907,   -17,    43,  -392,  -392,    12,  -392,
-     226,  -392,   202,   127,   262,   179,  1907,  1907,  1907,  1907,
-     270,   529,  -392,  -392,  1907,  -392,  -392,   238,    88,   193,
-    1907,   161,  1643,  1731,  -392,   281,  -392,  -392,   344,   269,
-    -392,   226,  1907,   283,  -392,    88,  -392,    88,    88,    88,
-      88,    88,   222,   222,  -392,   319,    70,    77,  -392,   421,
-    2049,   780,   296,   563,   280,   319,   267,   517,   517,   478,
-     603,   692,   978,    90,    90,  1907,  1907,  -392,  1819,     4,
-    -392,  -392,   434,   175,    81,   187,   116,   190,   208,  -392,
-    -392,  1907,  -392,   202,   289,    12,  -392,  -392,   293,  -392,
-     219,    88,   227,   232,    88,  -392,   236,     4,  -392,  -392,
-    -392,   239,   299,   234,  1907,  1907,   240,  -392,  -392,   515,
-    -392,   578,  -392,   604,  -392,  -392,  -392,   202,   140,  1907,
-     312,  -392,  -392,  1907,   214,   144,  -392,   668,  1907,  -392,
-     313,  -392,   324,  -392,   329,  -392,  -392,   155,  -392,  -392,
-    -392,  1907,  -392,  -392,   333,   333,  1907,   333,  1907,   246,
-     265,   333,  -392,  -392,  -392,   155,  -392,   167,  -392,  2010,
-     354,  -392,  -392,   268,  -392,  -392,  -392,  -392,  -392,  -392,
-    -392,   348,   333,   333,  -392,   102,   102,   272,    80,   355,
-     333,   333,  -392,  -392,  -392,  -392,  -392,    65,  -392,    80,
-      80,  -392,   333,     4,  -392,  -392,   333,  -392,  -392,    80,
-    -392,  -392,  -392,  -392,   104,  -392,  1907,    80,   617,  -392,
-    -392,   277,  -392,   286,   333,   333,   102,  -392,  -392
+     337,  -350,  -350,  -350,  -350,     2,  -350,  -350,     3,    29,
+    -350,  -350,    13,  -350,  -350,  -350,  -350,   433,    93,  -350,
+    -350,  -350,  1029,  1905,  1905,   497,   497,   497,   497,   497,
+    -350,  -350,   497,   497,  -350,   -24,    68,  -350,  1905,  -350,
+    -350,  -350,  -350,  -350,  -350,    86,  -350,    -1,    -1,    -1,
+      -1,    79,    -1,    -1,     3,  1905,  -350,     5,    22,    37,
+     793,   705,   497,   881,  1115,   120,  1905,     7,  -350,  1905,
+    1905,  1905,  1905,  1905,  1905,  1905,  1201,  -350,   106,  -350,
+     135,   703,    94,  -350,    44,  -350,  -350,  -350,  -350,  2008,
+    -350,    -1,   170,   193,  -350,  -350,   178,    23,  -350,    38,
+     129,   129,  -350,  -350,  -350,  -350,  -350,  -350,  -350,  -350,
+    -350,  1905,    84,  1905,  1905,   190,     3,   175,   185,   207,
+     216,  -350,  -350,  -350,  -350,  -350,  -350,  -350,  -350,  -350,
+      -1,  -350,  -350,  -350,  2008,   146,  1289,   705,  -350,   190,
+    1965,    94,  -350,   942,  1905,  -350,    -1,  -350,   190,    82,
+     239,   111,  1905,   190,  1377,   174,  -350,  -350,  -350,   185,
+     190,    94,   129,   129,   129,   237,   237,   242,   253,     3,
+    -350,  -350,  1905,  1905,  1905,  1905,  1905,  1905,  1905,  1905,
+    1905,  1905,  1905,  1905,  1465,  1905,  1905,  1905,  1905,  1905,
+    1905,  1905,  1905,  1905,  1905,  1905,  1905,  1905,  1905,  1905,
+    -350,  -350,    58,  1553,  1905,  1905,  1905,  1905,  1905,  -350,
+    -350,  -350,  1905,    74,    51,  -350,  -350,     3,  -350,   207,
+    -350,   187,    95,   246,   160,  1905,  1905,  1905,  1905,   251,
+     527,  -350,  -350,  1905,  -350,  -350,   304,   313,   188,  1905,
+      94,  1641,  1729,  -350,   280,  -350,  -350,   321,   271,  -350,
+     207,  1905,   289,  -350,   313,  -350,   313,   313,   313,   313,
+     313,   230,   230,  -350,  2008,   156,    56,  -350,   419,  2086,
+     323,   515,   201,   418,  2008,   277,   306,   306,   476,   255,
+     600,   314,   129,   129,  1905,  1905,  -350,  1817,    -1,  -350,
+    -350,   513,   166,    60,   189,    64,   245,   215,  -350,  -350,
+    1905,  -350,   187,   307,     3,  -350,  -350,   328,  -350,   275,
+     313,   282,   299,   313,  -350,   316,    -1,  -350,  -350,  -350,
+     340,   384,   206,  1905,  1905,   341,  -350,  -350,   576,  -350,
+     590,  -350,   602,  -350,  -350,  -350,   187,    75,  1905,   324,
+    -350,  -350,  1905,   248,    80,  -350,   666,  1905,  -350,   401,
+    -350,   410,  -350,   429,  -350,  -350,   192,  -350,  -350,  -350,
+    1905,  -350,  -350,   431,   431,  1905,   431,  1905,   344,   346,
+     431,  -350,  -350,  -350,   192,  -350,   161,  -350,  2047,   435,
+    -350,  -350,   362,  -350,  -350,  -350,  -350,  -350,  -350,  -350,
+     446,   431,   431,  -350,   173,   173,   379,   106,   457,   431,
+     431,  -350,  -350,  -350,  -350,  -350,    48,  -350,   106,   106,
+    -350,   431,    -1,  -350,  -350,   431,  -350,  -350,   106,  -350,
+    -350,  -350,  -350,   165,  -350,  1905,   106,   615,  -350,  -350,
+     387,  -350,   397,   431,   431,   173,  -350,  -350
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -392,  -392,  -392,  -392,  -392,  -392,    -2,  -103,  -392,  -392,
-    -220,  -392,    -9,   373,   365,  -391,  -392,  -392,  -101,  -392,
-    -392,  -361,  -392,    10,  -175,  -213,   -49,  -392,  -392,  -392,
-    -392,  -392,  -392,  -392,  -392,    68,   346,  -392,   241,  -125,
-    -309,  -392,    11,  -392,  -392,  -392,  -392,  -392,   -19,   -56,
-    -392,  -392,  -392,  -392,  -392,  -392,  -392,  -392,   225,  -392,
-    -392,  -119,  -221,   -30,  -392,  -392,  -392,    55,   349,   351,
-    -392,  -392,    46
+    -350,  -350,  -350,  -350,  -350,  -350,    -5,   -89,  -350,  -350,
+    -194,  -350,    -9,   492,  -350,  -350,  -350,   486,  -349,  -122,
+    -337,  -350,   138,    43,  -224,    88,  -350,  -350,  -350,    30,
+     467,  -350,   354,  -125,  -295,  -350,   143,   -17,   -38,  -350,
+    -350,  -350,  -350,  -350,  -350,  -350,  -350,   234,  -350,  -350,
+    -107,  -204,   -34,  -350,  -350,  -350,     1,   455,   456,  -350,
+    -350,    55
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -200
+#define YYTABLE_NINF -189
 static const yytype_int16 yytable[] =
 {
-      92,    20,   308,   222,   367,   110,    14,   152,   193,   215,
-     194,   216,   403,   108,    11,   425,   172,    80,    27,    13,
-     136,   137,   138,   140,   142,   143,   133,   133,   331,   133,
-     133,   336,   236,   237,   238,   239,   240,   241,   385,   243,
-     244,   255,   221,   295,   256,   296,   220,   162,    -9,    27,
-      27,    28,    29,   310,   144,   448,   297,   192,    15,   179,
-     149,    -8,   322,   158,   325,   195,   152,   438,   224,    15,
-     139,   124,   214,   431,   118,   119,   120,   121,   309,    15,
-     122,   123,   116,   116,   116,   116,   116,   351,   350,   116,
-     116,   361,    15,   189,   190,   191,    15,   134,   134,   251,
-     134,   134,   189,   190,   191,   313,   225,   152,   141,   155,
-     156,   242,   440,   189,   190,   191,   132,   125,   154,   116,
-     160,   379,   380,   180,   167,   226,   363,   252,   247,   248,
-     253,   131,   298,   165,   316,    15,   347,   393,   170,   334,
-     189,   190,   191,   422,   423,   317,   258,   189,   190,   191,
-     386,   189,   190,   191,   391,   406,   146,   408,   189,   190,
-     191,   412,    13,   407,   265,   267,   268,   269,   270,   271,
-     272,   273,   274,   397,   276,   277,   279,   414,   264,   210,
-     211,   212,   419,   420,   213,   147,   189,   190,   191,   148,
-     429,   430,   366,   360,   250,   302,   303,   304,   305,   306,
-     307,   163,   435,   154,   248,   362,   437,   215,   364,   216,
-     189,   190,   191,   370,   189,   190,   191,   321,   267,   217,
-     267,   218,   333,   441,   446,   447,   312,   182,   189,   190,
-     191,   339,   390,   341,   343,   192,   219,   189,   190,   191,
-    -200,  -200,   223,   348,   213,   189,   190,   191,   231,   227,
-     111,   112,   401,   263,   229,   152,   233,   189,   190,   191,
-     189,   190,   191,   245,   254,   126,   259,   262,   300,   358,
-     314,   183,   184,   185,   186,   319,   354,   355,   187,   357,
-     188,   318,   145,    27,   189,   190,   191,   150,   338,   344,
-     159,   346,   349,   164,   191,   328,   171,   376,   173,   174,
-     175,   176,   177,   365,   189,   190,   191,   427,   189,   190,
-     191,   368,   371,   369,   372,   152,   196,   378,   432,   433,
-     388,   394,   373,   197,   198,   199,   200,   374,   439,   -58,
-     387,   375,   395,   337,   377,   381,   442,   396,   199,   248,
-     404,   410,   201,   202,   353,   203,   204,   205,   206,   207,
-     208,   209,   197,  -200,   199,   200,   210,   211,   212,   321,
-     411,   213,   415,   416,   209,   398,   418,   426,   196,   210,
-     211,   212,   444,   428,   213,   197,   198,   199,   200,   208,
-     209,   445,    16,   398,    81,   210,   211,   212,   409,   443,
-     213,   417,   130,   436,   201,   202,   413,   203,   204,   205,
-     206,   207,   208,   209,     1,     2,     3,     4,   210,   211,
-     212,   261,   434,   213,   189,   190,   191,   275,   168,    92,
-     169,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,    23,     0,     0,   345,
-       0,     0,    13,     0,    24,     0,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,     0,
-      38,    39,    40,    41,    42,    43,     0,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,     0,     0,     0,    53,
-      54,    55,    56,    57,     0,    58,    59,    60,    61,    62,
-      63,   189,   190,   191,     0,    64,    65,    66,    67,    68,
-      69,    70,    71,     0,   189,   190,   191,    13,    72,     0,
-       0,     0,     0,    27,     0,     0,   352,     0,     0,   113,
-      73,    74,    75,     0,   114,     0,     0,    76,    77,   359,
-      23,    78,    79,     0,   197,   198,   199,   200,    24,     0,
-      25,    26,    27,    28,    29,    30,    31,   -53,    33,    34,
-      35,    36,    37,     0,    38,    39,    40,    41,    42,   206,
-     207,   208,   209,    46,     0,     0,     0,   210,   211,   212,
-       0,     0,   213,   197,   198,   199,   200,    57,   389,    58,
-      59,    60,    61,    62,    63,   189,   190,   191,     0,    64,
-      65,    66,    67,    68,    69,     0,    71,   205,   206,   207,
-     208,   209,    72,     0,     0,     0,   210,   211,   212,     0,
-     382,   213,     0,     0,    73,    74,    75,     0,    23,     0,
-       0,    76,    77,     0,     0,    78,    24,     0,    25,    26,
-      27,    28,    29,    30,    31,     0,    33,    34,    35,    36,
-      37,     0,    38,    39,    40,    41,    42,   209,   189,   190,
-     191,    46,   210,   211,   212,     0,     0,   213,     0,   197,
-     198,   199,   200,     0,     0,    57,     0,    58,    59,    60,
-      61,    62,    63,   383,   189,   190,   191,    64,    65,    66,
-      67,    68,    69,     0,    71,   207,   208,   209,     0,     0,
-      72,     0,   210,   211,   212,     0,     0,   213,     0,   384,
-       0,     0,    73,    74,    75,     0,     0,     0,     0,    76,
-      77,     0,   -53,    78,    13,     0,    24,     0,    25,    26,
-      27,    28,    29,    30,    31,     0,   151,    34,    35,    36,
-      37,   114,    38,    39,    40,    41,    42,     0,   189,   190,
-     191,    46,     0,     0,     0,     0,     0,     0,   197,   198,
-     199,   200,     0,     0,     0,    57,     0,    58,    59,    60,
-      61,    62,    63,   392,     0,     0,     0,    64,    65,    66,
-      67,    68,    69,     0,    71,   208,   209,     0,     0,     0,
-      72,   210,   211,   212,     0,     0,   213,     0,     0,     0,
-       0,     0,    73,    74,    75,     0,     0,     0,     0,    76,
-      77,     0,    13,    78,    24,     0,    25,    26,    27,    28,
-      29,    30,    31,     0,    33,    34,    35,    36,    37,     0,
-      38,    39,    40,    41,    42,     0,     0,     0,     0,    46,
-       0,     0,     0,     0,     0,     0,  -200,     0,   199,   200,
-       0,     0,     0,    57,     0,    58,    59,    60,    61,    62,
-      63,     0,     0,     0,     0,    64,    65,    66,    67,    68,
-      69,     0,    71,   208,   209,     0,     0,     0,    72,   210,
-     211,   212,     0,     0,   213,     0,     0,     0,     0,     0,
-      73,    74,    75,     0,     0,     0,     0,    76,    77,     0,
-      13,    78,    24,     0,    25,    26,    27,    28,    29,    30,
-      31,     0,   157,    34,    35,    36,    37,     0,    38,    39,
-      40,    41,    42,     0,     0,     0,     0,    46,     0,     0,
+      81,    18,    11,    14,   211,    99,   320,   356,   297,   325,
+      13,    97,    78,    -9,   125,   126,   127,   129,   131,   132,
+      25,    26,    27,   141,   122,   392,   105,   105,   105,   105,
+     105,   209,   161,   105,   105,   225,   226,   227,   228,   229,
+     230,   374,   232,   233,    15,   245,   414,   151,   210,   133,
+     184,   182,   130,   183,    15,   138,   420,   203,   147,   168,
+      15,   299,   143,   105,   149,   284,   340,   285,   156,   122,
+     350,    25,   113,   141,   352,   213,   121,   114,   286,    15,
+     427,   107,   108,   109,   110,   375,   437,   111,   112,   204,
+     380,   205,    25,    -8,   302,   123,   231,   214,   159,   368,
+     369,   135,   305,   154,   122,   120,   240,   122,   178,   179,
+     180,   215,   241,   306,   141,   242,   144,   145,   136,   236,
+     237,   178,   179,   180,    15,   336,   178,   179,   180,   244,
+     178,   179,   180,   137,   178,   179,   180,   247,   143,   152,
+     123,   396,   323,   382,   128,   178,   179,   180,   181,   169,
+     178,   179,   180,   171,   287,   254,   256,   257,   258,   259,
+     260,   261,   262,   263,   253,   265,   266,   268,   181,   298,
+     395,   403,   397,   429,   339,   123,   401,   204,   123,   205,
+     212,   178,   179,   180,   349,   208,   291,   292,   293,   294,
+     295,   296,   239,   355,   216,   237,    15,   408,   409,    13,
+     206,   430,   207,   289,   218,   418,   419,   351,   310,   256,
+     386,   256,   301,   322,   411,   412,   359,   424,   199,   200,
+     201,   426,   328,   202,   330,   332,   178,   179,   180,   220,
+     317,   178,   179,   180,   337,   222,   178,   179,   180,   435,
+     436,   234,   248,   172,   173,   174,   175,   243,   188,   189,
+     176,   251,   177,   390,   347,   303,   308,   100,   101,   178,
+     179,   180,   141,   353,    25,   307,   379,   343,   344,   311,
+     346,   314,   115,   197,   198,   416,   178,   179,   180,   199,
+     200,   201,   365,   327,   202,   198,   421,   422,   333,   134,
+     199,   200,   201,   335,   139,   202,   428,   148,   338,   358,
+     153,   -62,   180,   160,   431,   162,   163,   164,   165,   166,
+     354,   186,   187,   188,   189,   178,   179,   180,   178,   179,
+     180,   376,   141,   178,   179,   180,   185,  -189,  -189,   357,
+     237,   202,   377,   186,   187,   188,   189,   196,   197,   198,
+       1,     2,     3,     4,   199,   200,   201,   360,   252,   202,
+     310,   387,   190,   191,   342,   192,   193,   194,   195,   196,
+     197,   198,   186,   187,   188,   189,   199,   200,   201,   387,
+     361,   202,   188,   189,   178,   179,   180,   362,   425,  -189,
+     406,   188,   189,   178,   179,   180,   194,   195,   196,   197,
+     198,   178,   179,   180,   363,   199,   200,   201,   198,   326,
+     202,   423,   367,   199,   200,   201,   197,   198,   202,   383,
+      81,   364,   199,   200,   201,   264,   334,   202,   384,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,    21,   366,   370,   385,   393,   399,
+      13,   400,    22,   404,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,   405,    36,    37,
+      38,    39,    40,    41,   407,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,   415,   417,   188,    51,    52,    53,
+      54,    55,   433,    56,    57,    58,    59,    60,    61,   178,
+     179,   180,   434,    62,    63,    64,    65,    66,    67,    68,
+      69,    16,   198,    80,    13,   398,    70,   199,   200,   201,
+      25,   119,   202,   250,   341,   432,   102,   402,    71,    72,
+      73,   103,   157,   158,     0,    74,    75,     0,    21,    76,
+      77,     0,   186,   187,   188,   189,    22,     0,    23,    24,
+      25,    26,    27,    28,    29,   -57,    31,    32,    33,    34,
+      35,     0,    36,    37,    38,    39,    40,   195,   196,   197,
+     198,    44,     0,     0,     0,   199,   200,   201,     0,     0,
+     202,   186,  -189,   188,   189,    55,   378,    56,    57,    58,
+      59,    60,    61,   178,   179,   180,     0,    62,    63,    64,
+      65,    66,    67,     0,    69,     0,     0,     0,   197,   198,
+      70,     0,     0,     0,   199,   200,   201,     0,   348,   202,
+       0,     0,    71,    72,    73,     0,    21,     0,     0,    74,
+      75,     0,     0,    76,    22,     0,    23,    24,    25,    26,
+      27,    28,    29,     0,    31,    32,    33,    34,    35,     0,
+      36,    37,    38,    39,    40,     0,   178,   179,   180,    44,
+       0,     0,     0,     0,     0,     0,   186,   187,   188,   189,
+     178,   179,   180,    55,     0,    56,    57,    58,    59,    60,
+      61,   371,   178,   179,   180,    62,    63,    64,    65,    66,
+      67,     0,    69,   197,   198,   372,     0,     0,    70,   199,
+     200,   201,     0,     0,   202,     0,     0,   373,     0,     0,
+      71,    72,    73,     0,     0,     0,     0,    74,    75,     0,
+     -57,    76,    13,     0,    22,     0,    23,    24,    25,    26,
+      27,    28,    29,     0,   140,    32,    33,    34,    35,   103,
+      36,    37,    38,    39,    40,     0,   178,   179,   180,    44,
+     172,   173,   174,   175,     0,     0,     0,   176,     0,   177,
+       0,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,   381,     0,     0,     0,    62,    63,    64,    65,    66,
+      67,     0,    69,   178,   179,   180,     0,     0,    70,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    57,     0,    58,    59,    60,    61,    62,    63,     0,
-       0,     0,     0,    64,    65,    66,    67,    68,    69,     0,
-      71,   215,     0,   216,  -170,     0,    72,     0,     0,     0,
-       0,     0,  -170,     0,     0,     0,     0,     0,    73,    74,
-      75,     0,     0,   199,   200,    76,    77,     0,     0,    78,
-       0,  -170,  -170,  -170,  -170,     0,     0,     0,  -170,     0,
-    -170,     0,     0,  -170,     0,     0,     0,     0,   208,   209,
-    -170,  -170,  -170,  -170,   210,   211,   212,     0,     0,   213,
-       0,     0,     0,     0,  -170,  -170,  -170,     0,  -170,  -170,
-    -170,  -170,  -170,  -170,  -170,  -170,  -170,  -170,  -170,     0,
-       0,     0,     0,  -170,  -170,  -170,   199,   200,  -170,  -170,
-      24,   109,    25,    26,    27,    28,    29,    30,    31,     0,
-      33,    34,    35,    36,    37,     0,    38,    39,    40,    41,
-      42,     0,   209,     0,     0,    46,     0,   210,   211,   212,
-       0,     0,   213,     0,     0,     0,     0,     0,     0,    57,
-       0,    58,    59,    60,    61,    62,    63,     0,     0,     0,
-       0,    64,    65,    66,    67,    68,    69,     0,    71,     0,
-       0,     0,     0,     0,    72,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    73,    74,    75,     0,
-       0,     0,     0,    76,    77,     0,    24,    78,    25,    26,
-      27,    28,    29,    30,    31,   161,    33,    34,    35,    36,
-      37,     0,    38,    39,    40,    41,    42,     0,     0,     0,
-       0,    46,   183,   184,   185,   186,     0,     0,     0,   187,
-       0,   188,     0,     0,     0,    57,     0,    58,    59,    60,
-      61,    62,    63,     0,     0,     0,     0,    64,    65,    66,
-      67,    68,    69,     0,    71,   189,   190,   191,     0,     0,
-      72,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    73,    74,    75,     0,     0,     0,     0,    76,
-      77,     0,    24,    78,    25,    26,    27,    28,    29,    30,
-      31,     0,    33,    34,    35,    36,    37,     0,    38,    39,
-      40,    41,    42,     0,     0,     0,     0,    46,     0,     0,
+      71,    72,    73,     0,     0,     0,     0,    74,    75,     0,
+      13,    76,    22,     0,    23,    24,    25,    26,    27,    28,
+      29,     0,    31,    32,    33,    34,    35,     0,    36,    37,
+      38,    39,    40,     0,     0,     0,     0,    44,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    57,     0,    58,    59,    60,    61,    62,    63,     0,
-       0,     0,     0,    64,    65,    66,    67,    68,    69,     0,
-      71,     0,     0,     0,     0,     0,    72,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    73,    74,
-      75,     0,     0,     0,     0,    76,    77,     0,   178,    78,
-      24,     0,    25,    26,    27,    28,    29,    30,    31,     0,
-      33,    34,    35,    36,    37,     0,    38,    39,    40,    41,
-      42,     0,     0,     0,     0,    46,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    57,
-       0,    58,    59,    60,    61,    62,    63,     0,     0,     0,
-       0,    64,    65,    66,    67,    68,    69,     0,    71,     0,
-       0,     0,     0,     0,    72,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    73,    74,    75,     0,
-       0,     0,     0,    76,    77,     0,   246,    78,    24,     0,
-      25,    26,    27,    28,    29,    30,    31,     0,    33,    34,
-      35,    36,    37,     0,    38,    39,    40,    41,    42,     0,
-       0,     0,     0,    46,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    57,     0,    58,
-      59,    60,    61,    62,    63,     0,     0,     0,     0,    64,
-      65,    66,    67,    68,    69,     0,    71,     0,     0,     0,
-       0,     0,    72,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    73,    74,    75,     0,     0,     0,
-       0,    76,    77,     0,   257,    78,    24,     0,    25,    26,
-      27,    28,    29,    30,    31,     0,    33,    34,    35,    36,
-      37,     0,    38,    39,    40,    41,    42,     0,     0,     0,
-       0,    46,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    57,     0,    58,    59,    60,
-      61,    62,    63,     0,     0,     0,     0,    64,    65,    66,
-      67,    68,    69,     0,    71,     0,     0,     0,     0,     0,
-      72,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    73,    74,    75,     0,     0,     0,     0,    76,
-      77,     0,   278,    78,    24,     0,    25,    26,    27,    28,
-      29,    30,    31,     0,    33,    34,    35,    36,    37,     0,
-      38,    39,    40,    41,    42,     0,     0,     0,     0,    46,
+       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
+       0,     0,     0,    62,    63,    64,    65,    66,    67,     0,
+      69,     0,     0,     0,     0,     0,    70,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    71,    72,
+      73,     0,     0,     0,     0,    74,    75,     0,    13,    76,
+      22,     0,    23,    24,    25,    26,    27,    28,    29,     0,
+     146,    32,    33,    34,    35,     0,    36,    37,    38,    39,
+      40,     0,     0,     0,     0,    44,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,     0,
+       0,    62,    63,    64,    65,    66,    67,     0,    69,   204,
+       0,   205,  -159,     0,    70,     0,     0,     0,     0,     0,
+    -159,     0,     0,     0,     0,     0,    71,    72,    73,     0,
+       0,     0,     0,    74,    75,     0,     0,    76,     0,  -159,
+    -159,  -159,  -159,     0,     0,     0,  -159,     0,  -159,     0,
+       0,  -159,     0,     0,     0,     0,     0,     0,  -159,  -159,
+    -159,  -159,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,  -159,  -159,  -159,     0,  -159,  -159,  -159,  -159,
+    -159,  -159,  -159,  -159,  -159,  -159,  -159,     0,     0,     0,
+       0,  -159,  -159,  -159,     0,     0,  -159,  -159,    22,    98,
+      23,    24,    25,    26,    27,    28,    29,     0,    31,    32,
+      33,    34,    35,     0,    36,    37,    38,    39,    40,     0,
+       0,     0,     0,    44,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,     0,     0,    62,
+      63,    64,    65,    66,    67,     0,    69,     0,     0,     0,
+       0,     0,    70,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    71,    72,    73,     0,     0,     0,
+       0,    74,    75,     0,    22,    76,    23,    24,    25,    26,
+      27,    28,    29,   150,    31,    32,    33,    34,    35,     0,
+      36,    37,    38,    39,    40,     0,     0,     0,     0,    44,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    57,     0,    58,    59,    60,    61,    62,
-      63,     0,     0,     0,     0,    64,    65,    66,    67,    68,
-      69,     0,    71,     0,     0,     0,     0,     0,    72,     0,
+       0,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,     0,     0,    62,    63,    64,    65,    66,
+      67,     0,    69,     0,     0,     0,     0,     0,    70,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      73,    74,    75,     0,     0,     0,     0,    76,    77,     0,
-     301,    78,    24,     0,    25,    26,    27,    28,    29,    30,
-      31,     0,    33,    34,    35,    36,    37,     0,    38,    39,
-      40,    41,    42,     0,     0,     0,     0,    46,     0,     0,
+      71,    72,    73,     0,     0,     0,     0,    74,    75,     0,
+      22,    76,    23,    24,    25,    26,    27,    28,    29,     0,
+      31,    32,    33,    34,    35,     0,    36,    37,    38,    39,
+      40,     0,     0,     0,     0,    44,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,     0,
+       0,    62,    63,    64,    65,    66,    67,     0,    69,     0,
+       0,     0,     0,     0,    70,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    71,    72,    73,     0,
+       0,     0,     0,    74,    75,     0,   167,    76,    22,     0,
+      23,    24,    25,    26,    27,    28,    29,     0,    31,    32,
+      33,    34,    35,     0,    36,    37,    38,    39,    40,     0,
+       0,     0,     0,    44,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,     0,     0,    62,
+      63,    64,    65,    66,    67,     0,    69,     0,     0,     0,
+       0,     0,    70,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    71,    72,    73,     0,     0,     0,
+       0,    74,    75,     0,   235,    76,    22,     0,    23,    24,
+      25,    26,    27,    28,    29,     0,    31,    32,    33,    34,
+      35,     0,    36,    37,    38,    39,    40,     0,     0,     0,
+       0,    44,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,     0,     0,    62,    63,    64,
+      65,    66,    67,     0,    69,     0,     0,     0,     0,     0,
+      70,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    71,    72,    73,     0,     0,     0,     0,    74,
+      75,     0,   246,    76,    22,     0,    23,    24,    25,    26,
+      27,    28,    29,     0,    31,    32,    33,    34,    35,     0,
+      36,    37,    38,    39,    40,     0,     0,     0,     0,    44,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    57,     0,    58,    59,    60,    61,    62,    63,     0,
-       0,     0,     0,    64,    65,    66,    67,    68,    69,     0,
-      71,     0,     0,     0,     0,     0,    72,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    73,    74,
-      75,     0,     0,     0,     0,    76,    77,     0,   340,    78,
-      24,     0,    25,    26,    27,    28,    29,    30,    31,     0,
-      33,    34,    35,    36,    37,     0,    38,    39,    40,    41,
-      42,     0,     0,     0,     0,    46,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    57,
-       0,    58,    59,    60,    61,    62,    63,     0,     0,     0,
-       0,    64,    65,    66,    67,    68,    69,     0,    71,     0,
-       0,     0,     0,     0,    72,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    73,    74,    75,     0,
-       0,     0,     0,    76,    77,     0,   342,    78,    24,     0,
-      25,    26,    27,    28,    29,    30,    31,     0,    33,    34,
-      35,    36,    37,     0,    38,    39,    40,    41,    42,     0,
-       0,     0,     0,    46,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    57,     0,    58,
-      59,    60,    61,    62,    63,     0,     0,     0,     0,    64,
-      65,    66,    67,    68,    69,     0,    71,     0,     0,     0,
-       0,     0,    72,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    73,    74,    75,     0,     0,     0,
-       0,    76,    77,     0,   356,    78,    24,     0,    25,    26,
-      27,    28,    29,    30,    31,     0,    33,    34,    35,    36,
-      37,     0,    38,    39,    40,    41,    42,     0,     0,     0,
-       0,    46,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    57,     0,    58,    59,    60,
-      61,    62,    63,     0,     0,     0,     0,    64,    65,    66,
-      67,    68,    69,     0,    71,     0,     0,  -199,     0,     0,
-      72,     0,     0,     0,     0,  -199,     0,     0,     0,     0,
-       0,     0,    73,    74,    75,     0,     0,     0,     0,    76,
-      77,     0,     0,    78,  -199,  -199,  -199,  -199,     0,     0,
-       0,  -199,     0,  -199,     0,     0,  -199,     0,     0,     0,
-       0,     0,     0,  -199,  -199,  -199,  -199,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  -199,  -199,  -199,
-       0,  -199,  -199,  -199,  -199,  -199,  -199,  -199,  -199,  -199,
-    -199,  -199,     0,     0,     0,     0,  -199,  -199,  -199,   196,
-       0,  -199,  -199,     0,     0,     0,   197,   198,   199,   200,
+       0,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,     0,     0,    62,    63,    64,    65,    66,
+      67,     0,    69,     0,     0,     0,     0,     0,    70,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   202,     0,   203,   204,
-     205,   206,   207,   208,   209,     0,     0,     0,  -200,   210,
-     211,   212,     0,     0,   213,   197,   198,   199,   200,     0,
+      71,    72,    73,     0,     0,     0,     0,    74,    75,     0,
+     267,    76,    22,     0,    23,    24,    25,    26,    27,    28,
+      29,     0,    31,    32,    33,    34,    35,     0,    36,    37,
+      38,    39,    40,     0,     0,     0,     0,    44,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   203,   204,   205,
-     206,   207,   208,   209,     0,     0,     0,     0,   210,   211,
-     212,     0,     0,   213
+       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
+       0,     0,     0,    62,    63,    64,    65,    66,    67,     0,
+      69,     0,     0,     0,     0,     0,    70,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    71,    72,
+      73,     0,     0,     0,     0,    74,    75,     0,   290,    76,
+      22,     0,    23,    24,    25,    26,    27,    28,    29,     0,
+      31,    32,    33,    34,    35,     0,    36,    37,    38,    39,
+      40,     0,     0,     0,     0,    44,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,     0,
+       0,    62,    63,    64,    65,    66,    67,     0,    69,     0,
+       0,     0,     0,     0,    70,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    71,    72,    73,     0,
+       0,     0,     0,    74,    75,     0,   329,    76,    22,     0,
+      23,    24,    25,    26,    27,    28,    29,     0,    31,    32,
+      33,    34,    35,     0,    36,    37,    38,    39,    40,     0,
+       0,     0,     0,    44,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,     0,     0,    62,
+      63,    64,    65,    66,    67,     0,    69,     0,     0,     0,
+       0,     0,    70,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    71,    72,    73,     0,     0,     0,
+       0,    74,    75,     0,   331,    76,    22,     0,    23,    24,
+      25,    26,    27,    28,    29,     0,    31,    32,    33,    34,
+      35,     0,    36,    37,    38,    39,    40,     0,     0,     0,
+       0,    44,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,     0,     0,    62,    63,    64,
+      65,    66,    67,     0,    69,     0,     0,     0,     0,     0,
+      70,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    71,    72,    73,     0,     0,     0,     0,    74,
+      75,     0,   345,    76,    22,     0,    23,    24,    25,    26,
+      27,    28,    29,     0,    31,    32,    33,    34,    35,     0,
+      36,    37,    38,    39,    40,     0,     0,     0,     0,    44,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,     0,     0,    62,    63,    64,    65,    66,
+      67,     0,    69,     0,     0,  -188,     0,     0,    70,     0,
+       0,     0,     0,  -188,     0,     0,     0,     0,     0,     0,
+      71,    72,    73,     0,     0,     0,     0,    74,    75,     0,
+       0,    76,  -188,  -188,  -188,  -188,     0,     0,     0,  -188,
+       0,  -188,     0,     0,  -188,     0,     0,     0,     0,     0,
+       0,  -188,  -188,  -188,  -188,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,  -188,  -188,  -188,     0,  -188,
+    -188,  -188,  -188,  -188,  -188,  -188,  -188,  -188,  -188,  -188,
+       0,     0,     0,     0,  -188,  -188,  -188,   185,     0,  -188,
+    -188,     0,     0,     0,   186,   187,   188,   189,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   190,   191,     0,   192,   193,   194,   195,
+     196,   197,   198,     0,     0,     0,   185,   199,   200,   201,
+       0,     0,   202,   186,   187,   188,   189,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   191,     0,   192,   193,   194,   195,   196,
+     197,   198,     0,     0,     0,  -189,   199,   200,   201,     0,
+       0,   202,   186,   187,   188,   189,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   192,   193,   194,   195,   196,   197,
+     198,     0,     0,     0,     0,   199,   200,   201,     0,     0,
+     202
 };
 
 static const yytype_int16 yycheck[] =
 {
-      19,    10,   223,   122,   313,    24,     8,    63,     7,     7,
-       9,     9,   373,    22,     0,   406,    72,    19,    13,     7,
-      50,    51,    52,    53,    54,    55,    25,    25,   241,    25,
-      25,   244,   135,   136,   137,   138,   139,   140,   347,   142,
-     143,    18,    10,     7,   163,     9,     8,    66,     0,    13,
-      13,    14,    15,    10,    56,   446,    20,    74,    31,    78,
-      62,     0,   237,    65,   239,    95,   122,   428,   124,    31,
-      65,    96,   102,     8,    28,    29,    30,    31,    95,    31,
-      34,    35,    27,    28,    29,    30,    31,    10,    18,    34,
-      35,    10,    31,    70,    71,    72,    31,    96,    96,   155,
-      96,    96,    70,    71,    72,   230,   125,   163,    53,    63,
-      64,   141,     8,    70,    71,    72,    48,     9,    63,    64,
-      65,   334,   335,    43,    69,   127,    10,   157,   147,   148,
-     160,    19,    96,    96,     7,    31,   261,   358,    70,   242,
-      70,    71,    72,    41,    42,    18,   165,    70,    71,    72,
-      10,    70,    71,    72,    10,   375,    96,   377,    70,    71,
-      72,   381,     7,   376,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,    18,   193,   194,   195,    10,   180,    89,
-      90,    91,   402,   403,    94,    96,    70,    71,    72,    96,
-     410,   411,   311,    18,   148,   214,   215,   216,   217,   218,
-     219,    19,   422,   148,   223,    18,   426,     7,    18,     9,
-      70,    71,    72,   316,    70,    71,    72,   236,   237,     7,
-     239,     9,   241,   436,   444,   445,   228,    18,    70,    71,
-      72,   250,    18,   252,   253,    74,     7,    70,    71,    72,
-      90,    91,    96,   262,    94,    70,    71,    72,    22,    19,
-      25,    26,   371,    95,    19,   311,    19,    70,    71,    72,
-      70,    71,    72,    95,     8,    40,    68,     9,   213,   299,
-      68,    37,    38,    39,    40,    96,   295,   296,    44,   298,
-      46,    19,    57,    13,    70,    71,    72,    62,    95,     8,
-      65,    22,     9,    68,    72,   240,    71,   327,    73,    74,
-      75,    76,    77,    95,    70,    71,    72,   408,    70,    71,
-      72,    22,    19,   315,    95,   371,    49,    18,   419,   420,
-       8,     8,    95,    56,    57,    58,    59,    95,   429,    95,
-     349,    95,     8,    95,    95,    95,   437,     8,    58,   358,
-       7,    95,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    56,    57,    58,    59,    89,    90,    91,   378,
-      95,    94,     8,    95,    84,   367,    18,    95,    49,    89,
-      90,    91,    95,    18,    94,    56,    57,    58,    59,    83,
-      84,    95,     9,   385,    19,    89,    90,    91,   378,   438,
-      94,   400,    46,   423,    75,    76,   385,    78,    79,    80,
-      81,    82,    83,    84,     3,     4,     5,     6,    89,    90,
-      91,   170,   421,    94,    70,    71,    72,   192,    69,   438,
-      69,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,     1,    -1,    -1,    95,
-      -1,    -1,     7,    -1,     9,    -1,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    -1,
-      25,    26,    27,    28,    29,    30,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    -1,    -1,    -1,    44,
-      45,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
-      55,    70,    71,    72,    -1,    60,    61,    62,    63,    64,
-      65,    66,    67,    -1,    70,    71,    72,     7,    73,    -1,
-      -1,    -1,    -1,    13,    -1,    -1,    95,    -1,    -1,    19,
-      85,    86,    87,    -1,    24,    -1,    -1,    92,    93,    95,
-       1,    96,    97,    -1,    56,    57,    58,    59,     9,    -1,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    -1,    25,    26,    27,    28,    29,    81,
-      82,    83,    84,    34,    -1,    -1,    -1,    89,    90,    91,
-      -1,    -1,    94,    56,    57,    58,    59,    48,   353,    50,
-      51,    52,    53,    54,    55,    70,    71,    72,    -1,    60,
-      61,    62,    63,    64,    65,    -1,    67,    80,    81,    82,
-      83,    84,    73,    -1,    -1,    -1,    89,    90,    91,    -1,
-      95,    94,    -1,    -1,    85,    86,    87,    -1,     1,    -1,
-      -1,    92,    93,    -1,    -1,    96,     9,    -1,    11,    12,
-      13,    14,    15,    16,    17,    -1,    19,    20,    21,    22,
-      23,    -1,    25,    26,    27,    28,    29,    84,    70,    71,
-      72,    34,    89,    90,    91,    -1,    -1,    94,    -1,    56,
-      57,    58,    59,    -1,    -1,    48,    -1,    50,    51,    52,
-      53,    54,    55,    95,    70,    71,    72,    60,    61,    62,
-      63,    64,    65,    -1,    67,    82,    83,    84,    -1,    -1,
-      73,    -1,    89,    90,    91,    -1,    -1,    94,    -1,    95,
-      -1,    -1,    85,    86,    87,    -1,    -1,    -1,    -1,    92,
-      93,    -1,    95,    96,     7,    -1,     9,    -1,    11,    12,
-      13,    14,    15,    16,    17,    -1,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    -1,    70,    71,
-      72,    34,    -1,    -1,    -1,    -1,    -1,    -1,    56,    57,
-      58,    59,    -1,    -1,    -1,    48,    -1,    50,    51,    52,
-      53,    54,    55,    95,    -1,    -1,    -1,    60,    61,    62,
-      63,    64,    65,    -1,    67,    83,    84,    -1,    -1,    -1,
-      73,    89,    90,    91,    -1,    -1,    94,    -1,    -1,    -1,
-      -1,    -1,    85,    86,    87,    -1,    -1,    -1,    -1,    92,
-      93,    -1,     7,    96,     9,    -1,    11,    12,    13,    14,
+      17,    10,     0,     8,   111,    22,   230,   302,   212,   233,
+       7,    20,    17,     0,    48,    49,    50,    51,    52,    53,
+      13,    14,    15,    61,    25,   362,    25,    26,    27,    28,
+      29,     8,    70,    32,    33,   124,   125,   126,   127,   128,
+     129,   336,   131,   132,    31,   152,   395,    64,    10,    54,
+      84,     7,    51,     9,    31,    60,     8,    91,    63,    76,
+      31,    10,    61,    62,    63,     7,    10,     9,    67,    25,
+      10,    13,    96,   111,    10,   113,    46,     9,    20,    31,
+     417,    26,    27,    28,    29,    10,   435,    32,    33,     7,
+      10,     9,    13,     0,   219,    96,   130,   114,    68,   323,
+     324,    96,     7,    96,    25,    19,   144,    25,    70,    71,
+      72,   116,   146,    18,   152,   149,    61,    62,    96,   136,
+     137,    70,    71,    72,    31,   250,    70,    71,    72,    18,
+      70,    71,    72,    96,    70,    71,    72,   154,   137,    19,
+      96,   365,   231,   347,    65,    70,    71,    72,    74,    43,
+      70,    71,    72,    18,    96,   172,   173,   174,   175,   176,
+     177,   178,   179,   180,   169,   182,   183,   184,    74,    95,
+     364,    10,   366,     8,    18,    96,   370,     7,    96,     9,
+      96,    70,    71,    72,    18,     7,   203,   204,   205,   206,
+     207,   208,   137,   300,    19,   212,    31,   391,   392,     7,
+       7,   425,     9,   202,    19,   399,   400,    18,   225,   226,
+      18,   228,   217,   230,    41,    42,   305,   411,    89,    90,
+      91,   415,   239,    94,   241,   242,    70,    71,    72,    22,
+     229,    70,    71,    72,   251,    19,    70,    71,    72,   433,
+     434,    95,    68,    37,    38,    39,    40,     8,    58,    59,
+      44,     9,    46,   360,   288,    68,    96,    23,    24,    70,
+      71,    72,   300,    18,    13,    19,    18,   284,   285,   226,
+     287,   228,    38,    83,    84,   397,    70,    71,    72,    89,
+      90,    91,   316,    95,    94,    84,   408,   409,     8,    55,
+      89,    90,    91,    22,    60,    94,   418,    63,     9,   304,
+      66,    95,    72,    69,   426,    71,    72,    73,    74,    75,
+      95,    56,    57,    58,    59,    70,    71,    72,    70,    71,
+      72,   338,   360,    70,    71,    72,    49,    90,    91,    22,
+     347,    94,     8,    56,    57,    58,    59,    82,    83,    84,
+       3,     4,     5,     6,    89,    90,    91,    19,    95,    94,
+     367,   356,    75,    76,    77,    78,    79,    80,    81,    82,
+      83,    84,    56,    57,    58,    59,    89,    90,    91,   374,
+      95,    94,    58,    59,    70,    71,    72,    95,   412,    56,
+     389,    58,    59,    70,    71,    72,    80,    81,    82,    83,
+      84,    70,    71,    72,    95,    89,    90,    91,    84,    95,
+      94,   410,    18,    89,    90,    91,    83,    84,    94,     8,
+     427,    95,    89,    90,    91,   181,    95,    94,     8,   185,
+     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
+     196,   197,   198,   199,     1,    95,    95,     8,     7,    95,
+       7,    95,     9,     8,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    95,    25,    26,
+      27,    28,    29,    30,    18,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    95,    18,    58,    44,    45,    46,
+      47,    48,    95,    50,    51,    52,    53,    54,    55,    70,
+      71,    72,    95,    60,    61,    62,    63,    64,    65,    66,
+      67,     9,    84,    17,     7,   367,    73,    89,    90,    91,
+      13,    44,    94,   159,    95,   427,    19,   374,    85,    86,
+      87,    24,    67,    67,    -1,    92,    93,    -1,     1,    96,
+      97,    -1,    56,    57,    58,    59,     9,    -1,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    -1,    25,    26,    27,    28,    29,    81,    82,    83,
+      84,    34,    -1,    -1,    -1,    89,    90,    91,    -1,    -1,
+      94,    56,    57,    58,    59,    48,   342,    50,    51,    52,
+      53,    54,    55,    70,    71,    72,    -1,    60,    61,    62,
+      63,    64,    65,    -1,    67,    -1,    -1,    -1,    83,    84,
+      73,    -1,    -1,    -1,    89,    90,    91,    -1,    95,    94,
+      -1,    -1,    85,    86,    87,    -1,     1,    -1,    -1,    92,
+      93,    -1,    -1,    96,     9,    -1,    11,    12,    13,    14,
       15,    16,    17,    -1,    19,    20,    21,    22,    23,    -1,
-      25,    26,    27,    28,    29,    -1,    -1,    -1,    -1,    34,
-      -1,    -1,    -1,    -1,    -1,    -1,    56,    -1,    58,    59,
+      25,    26,    27,    28,    29,    -1,    70,    71,    72,    34,
+      -1,    -1,    -1,    -1,    -1,    -1,    56,    57,    58,    59,
+      70,    71,    72,    48,    -1,    50,    51,    52,    53,    54,
+      55,    95,    70,    71,    72,    60,    61,    62,    63,    64,
+      65,    -1,    67,    83,    84,    95,    -1,    -1,    73,    89,
+      90,    91,    -1,    -1,    94,    -1,    -1,    95,    -1,    -1,
+      85,    86,    87,    -1,    -1,    -1,    -1,    92,    93,    -1,
+      95,    96,     7,    -1,     9,    -1,    11,    12,    13,    14,
+      15,    16,    17,    -1,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    -1,    70,    71,    72,    34,
+      37,    38,    39,    40,    -1,    -1,    -1,    44,    -1,    46,
       -1,    -1,    -1,    48,    -1,    50,    51,    52,    53,    54,
-      55,    -1,    -1,    -1,    -1,    60,    61,    62,    63,    64,
-      65,    -1,    67,    83,    84,    -1,    -1,    -1,    73,    89,
-      90,    91,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,
+      55,    95,    -1,    -1,    -1,    60,    61,    62,    63,    64,
+      65,    -1,    67,    70,    71,    72,    -1,    -1,    73,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       85,    86,    87,    -1,    -1,    -1,    -1,    92,    93,    -1,
        7,    96,     9,    -1,    11,    12,    13,    14,    15,    16,
       17,    -1,    19,    20,    21,    22,    23,    -1,    25,    26,
@@ -757,46 +739,46 @@ static const yytype_int16 yycheck[] =
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    48,    -1,    50,    51,    52,    53,    54,    55,    -1,
       -1,    -1,    -1,    60,    61,    62,    63,    64,    65,    -1,
-      67,     7,    -1,     9,    10,    -1,    73,    -1,    -1,    -1,
-      -1,    -1,    18,    -1,    -1,    -1,    -1,    -1,    85,    86,
-      87,    -1,    -1,    58,    59,    92,    93,    -1,    -1,    96,
-      -1,    37,    38,    39,    40,    -1,    -1,    -1,    44,    -1,
-      46,    -1,    -1,    49,    -1,    -1,    -1,    -1,    83,    84,
-      56,    57,    58,    59,    89,    90,    91,    -1,    -1,    94,
-      -1,    -1,    -1,    -1,    70,    71,    72,    -1,    74,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    -1,
-      -1,    -1,    -1,    89,    90,    91,    58,    59,    94,    95,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    -1,
-      19,    20,    21,    22,    23,    -1,    25,    26,    27,    28,
-      29,    -1,    84,    -1,    -1,    34,    -1,    89,    90,    91,
-      -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    48,
-      -1,    50,    51,    52,    53,    54,    55,    -1,    -1,    -1,
-      -1,    60,    61,    62,    63,    64,    65,    -1,    67,    -1,
-      -1,    -1,    -1,    -1,    73,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    85,    86,    87,    -1,
-      -1,    -1,    -1,    92,    93,    -1,     9,    96,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    -1,    25,    26,    27,    28,    29,    -1,    -1,    -1,
-      -1,    34,    37,    38,    39,    40,    -1,    -1,    -1,    44,
-      -1,    46,    -1,    -1,    -1,    48,    -1,    50,    51,    52,
-      53,    54,    55,    -1,    -1,    -1,    -1,    60,    61,    62,
-      63,    64,    65,    -1,    67,    70,    71,    72,    -1,    -1,
-      73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    85,    86,    87,    -1,    -1,    -1,    -1,    92,
-      93,    -1,     9,    96,    11,    12,    13,    14,    15,    16,
-      17,    -1,    19,    20,    21,    22,    23,    -1,    25,    26,
-      27,    28,    29,    -1,    -1,    -1,    -1,    34,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    48,    -1,    50,    51,    52,    53,    54,    55,    -1,
-      -1,    -1,    -1,    60,    61,    62,    63,    64,    65,    -1,
       67,    -1,    -1,    -1,    -1,    -1,    73,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    85,    86,
-      87,    -1,    -1,    -1,    -1,    92,    93,    -1,    95,    96,
+      87,    -1,    -1,    -1,    -1,    92,    93,    -1,     7,    96,
        9,    -1,    11,    12,    13,    14,    15,    16,    17,    -1,
       19,    20,    21,    22,    23,    -1,    25,    26,    27,    28,
       29,    -1,    -1,    -1,    -1,    34,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
       -1,    50,    51,    52,    53,    54,    55,    -1,    -1,    -1,
+      -1,    60,    61,    62,    63,    64,    65,    -1,    67,     7,
+      -1,     9,    10,    -1,    73,    -1,    -1,    -1,    -1,    -1,
+      18,    -1,    -1,    -1,    -1,    -1,    85,    86,    87,    -1,
+      -1,    -1,    -1,    92,    93,    -1,    -1,    96,    -1,    37,
+      38,    39,    40,    -1,    -1,    -1,    44,    -1,    46,    -1,
+      -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    56,    57,
+      58,    59,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    70,    71,    72,    -1,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    -1,    -1,    -1,
+      -1,    89,    90,    91,    -1,    -1,    94,    95,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
+      21,    22,    23,    -1,    25,    26,    27,    28,    29,    -1,
+      -1,    -1,    -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    -1,    50,
+      51,    52,    53,    54,    55,    -1,    -1,    -1,    -1,    60,
+      61,    62,    63,    64,    65,    -1,    67,    -1,    -1,    -1,
+      -1,    -1,    73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    85,    86,    87,    -1,    -1,    -1,
+      -1,    92,    93,    -1,     9,    96,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    -1,
+      25,    26,    27,    28,    29,    -1,    -1,    -1,    -1,    34,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    -1,    50,    51,    52,    53,    54,
+      55,    -1,    -1,    -1,    -1,    60,    61,    62,    63,    64,
+      65,    -1,    67,    -1,    -1,    -1,    -1,    -1,    73,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      85,    86,    87,    -1,    -1,    -1,    -1,    92,    93,    -1,
+       9,    96,    11,    12,    13,    14,    15,    16,    17,    -1,
+      19,    20,    21,    22,    23,    -1,    25,    26,    27,    28,
+      29,    -1,    -1,    -1,    -1,    34,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
+      -1,    50,    51,    52,    53,    54,    55,    -1,    -1,    -1,
       -1,    60,    61,    62,    63,    64,    65,    -1,    67,    -1,
       -1,    -1,    -1,    -1,    73,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    85,    86,    87,    -1,
@@ -859,24 +841,37 @@ static const yytype_int16 yycheck[] =
       -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    48,    -1,    50,    51,    52,
       53,    54,    55,    -1,    -1,    -1,    -1,    60,    61,    62,
-      63,    64,    65,    -1,    67,    -1,    -1,    10,    -1,    -1,
-      73,    -1,    -1,    -1,    -1,    18,    -1,    -1,    -1,    -1,
+      63,    64,    65,    -1,    67,    -1,    -1,    -1,    -1,    -1,
+      73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    85,    86,    87,    -1,    -1,    -1,    -1,    92,
-      93,    -1,    -1,    96,    37,    38,    39,    40,    -1,    -1,
-      -1,    44,    -1,    46,    -1,    -1,    49,    -1,    -1,    -1,
-      -1,    -1,    -1,    56,    57,    58,    59,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
-      -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    -1,    -1,    -1,    -1,    89,    90,    91,    49,
-      -1,    94,    95,    -1,    -1,    -1,    56,    57,    58,    59,
+      93,    -1,    95,    96,     9,    -1,    11,    12,    13,    14,
+      15,    16,    17,    -1,    19,    20,    21,    22,    23,    -1,
+      25,    26,    27,    28,    29,    -1,    -1,    -1,    -1,    34,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    76,    -1,    78,    79,
-      80,    81,    82,    83,    84,    -1,    -1,    -1,    49,    89,
-      90,    91,    -1,    -1,    94,    56,    57,    58,    59,    -1,
+      -1,    -1,    -1,    48,    -1,    50,    51,    52,    53,    54,
+      55,    -1,    -1,    -1,    -1,    60,    61,    62,    63,    64,
+      65,    -1,    67,    -1,    -1,    10,    -1,    -1,    73,    -1,
+      -1,    -1,    -1,    18,    -1,    -1,    -1,    -1,    -1,    -1,
+      85,    86,    87,    -1,    -1,    -1,    -1,    92,    93,    -1,
+      -1,    96,    37,    38,    39,    40,    -1,    -1,    -1,    44,
+      -1,    46,    -1,    -1,    49,    -1,    -1,    -1,    -1,    -1,
+      -1,    56,    57,    58,    59,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    70,    71,    72,    -1,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      -1,    -1,    -1,    -1,    89,    90,    91,    49,    -1,    94,
+      95,    -1,    -1,    -1,    56,    57,    58,    59,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    78,    79,    80,
-      81,    82,    83,    84,    -1,    -1,    -1,    -1,    89,    90,
-      91,    -1,    -1,    94
+      -1,    -1,    -1,    75,    76,    -1,    78,    79,    80,    81,
+      82,    83,    84,    -1,    -1,    -1,    49,    89,    90,    91,
+      -1,    -1,    94,    56,    57,    58,    59,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    76,    -1,    78,    79,    80,    81,    82,
+      83,    84,    -1,    -1,    -1,    49,    89,    90,    91,    -1,
+      -1,    94,    56,    57,    58,    59,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    78,    79,    80,    81,    82,    83,
+      84,    -1,    -1,    -1,    -1,    89,    90,    91,    -1,    -1,
+      94
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -884,50 +879,49 @@ static const yytype_int16 yycheck[] =
 static const yytype_uint8 yystos[] =
 {
        0,     3,     4,     5,     6,    99,   103,   107,   100,   101,
-     102,     0,   110,     7,   104,    31,   111,   117,   118,   126,
-     110,   111,   105,     1,     9,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    25,    26,
-      27,    28,    29,    30,    32,    33,    34,    35,    36,    37,
-      38,    39,    40,    44,    45,    46,    47,    48,    50,    51,
-      52,    53,    54,    55,    60,    61,    62,    63,    64,    65,
-      66,    67,    73,    85,    86,    87,    92,    93,    96,    97,
-     104,   112,   114,   115,   127,   128,   129,   131,   132,   141,
-     142,   144,   146,   147,   148,   151,   152,   153,   154,   155,
-     156,   157,   164,   165,   166,   167,   168,   169,   110,    10,
-     146,   156,   156,    19,    24,   104,   165,   170,   170,   170,
-     170,   170,   170,   170,    96,     9,   156,   134,   135,   133,
-     134,    19,   133,    25,    96,   161,   161,   161,   161,    65,
-     161,   165,   161,   161,   104,   156,    96,    96,    96,   104,
-     156,    19,   147,   159,   165,   170,   170,    19,   104,   156,
-     165,    18,   146,    19,   156,    96,   158,   165,   166,   167,
-     133,   156,   147,   156,   156,   156,   156,   156,    95,   146,
-      43,   116,    18,    37,    38,    39,    40,    44,    46,    70,
-      71,    72,    74,     7,     9,   161,    49,    56,    57,    58,
-      59,    75,    76,    78,    79,    80,    81,    82,    83,    84,
-      89,    90,    91,    94,   161,     7,     9,     7,     9,     7,
-       8,    10,   159,    96,   147,   146,   104,    19,   130,    19,
-     136,    22,   137,    19,   145,   162,   105,   105,   105,   105,
-     105,   105,   161,   105,   105,    95,    95,   146,   146,   160,
-     170,   147,   161,   161,     8,    18,   159,    95,   146,    68,
-     139,   136,     9,    95,   104,   146,   122,   146,   146,   146,
-     146,   146,   146,   146,   146,   156,   146,   146,    95,   146,
-     156,   156,   156,   156,   156,   156,   156,   156,   156,   156,
-     156,   156,   156,   156,   156,     7,     9,    20,    96,   150,
-     165,    95,   146,   146,   146,   146,   146,   146,   160,    95,
-      10,   149,   104,   137,    68,   138,     7,    18,    19,    96,
-     121,   146,   122,   123,   146,   122,   125,   163,   165,   112,
-     120,   123,   124,   146,   105,   106,   123,    95,    95,   146,
-      95,   146,    95,   146,     8,    95,    22,   137,   146,     9,
-      18,    10,    95,    77,   146,   146,    95,   146,   161,    95,
-      18,    10,    18,    10,    18,    95,   159,   138,    22,   104,
-     105,    19,    95,    95,    95,    95,   161,    95,    18,   123,
-     123,    95,    95,    95,    95,   138,    10,   146,     8,   156,
-      18,    10,    95,   160,     8,     8,     8,    18,   104,   140,
-     143,   159,   119,   119,     7,   108,   108,   123,   108,   121,
-      95,    95,   108,   140,    10,     8,    95,   110,    18,   108,
-     108,   109,    41,    42,   113,   113,    95,   116,    18,   108,
-     108,     8,   116,   116,   110,   108,   161,   108,   119,   116,
-       8,   123,   116,   124,    95,    95,   108,   108,   113
+     102,     0,   110,     7,   104,    31,   111,   125,   110,   111,
+     105,     1,     9,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    25,    26,    27,    28,
+      29,    30,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    44,    45,    46,    47,    48,    50,    51,    52,    53,
+      54,    55,    60,    61,    62,    63,    64,    65,    66,    67,
+      73,    85,    86,    87,    92,    93,    96,    97,   104,   112,
+     115,   135,   136,   137,   140,   141,   142,   143,   144,   145,
+     146,   153,   154,   155,   156,   157,   158,   110,    10,   135,
+     145,   145,    19,    24,   104,   154,   159,   159,   159,   159,
+     159,   159,   159,    96,     9,   145,   128,   129,   127,   128,
+      19,   127,    25,    96,   150,   150,   150,   150,    65,   150,
+     154,   150,   150,   104,   145,    96,    96,    96,   104,   145,
+      19,   136,   148,   154,   159,   159,    19,   104,   145,   154,
+      18,   135,    19,   145,    96,   147,   154,   155,   156,   127,
+     145,   136,   145,   145,   145,   145,   145,    95,   135,    43,
+     117,    18,    37,    38,    39,    40,    44,    46,    70,    71,
+      72,    74,     7,     9,   150,    49,    56,    57,    58,    59,
+      75,    76,    78,    79,    80,    81,    82,    83,    84,    89,
+      90,    91,    94,   150,     7,     9,     7,     9,     7,     8,
+      10,   148,    96,   136,   135,   104,    19,   126,    19,   130,
+      22,   131,    19,   113,   151,   105,   105,   105,   105,   105,
+     105,   150,   105,   105,    95,    95,   135,   135,   149,   159,
+     136,   150,   150,     8,    18,   148,    95,   135,    68,   133,
+     130,     9,    95,   104,   135,   121,   135,   135,   135,   135,
+     135,   135,   135,   135,   145,   135,   135,    95,   135,   145,
+     145,   145,   145,   145,   145,   145,   145,   145,   145,   145,
+     145,   145,   145,   145,     7,     9,    20,    96,   139,   154,
+      95,   135,   135,   135,   135,   135,   135,   149,    95,    10,
+     138,   104,   131,    68,   132,     7,    18,    19,    96,   120,
+     135,   121,   122,   135,   121,   124,   152,   154,   115,   119,
+     122,   123,   135,   105,   106,   122,    95,    95,   135,    95,
+     135,    95,   135,     8,    95,    22,   131,   135,     9,    18,
+      10,    95,    77,   135,   135,    95,   135,   150,    95,    18,
+      10,    18,    10,    18,    95,   148,   132,    22,   104,   105,
+      19,    95,    95,    95,    95,   150,    95,    18,   122,   122,
+      95,    95,    95,    95,   132,    10,   135,     8,   145,    18,
+      10,    95,   149,     8,     8,     8,    18,   104,   134,   114,
+     148,   118,   118,     7,   108,   108,   122,   108,   120,    95,
+      95,   108,   134,    10,     8,    95,   110,    18,   108,   108,
+     109,    41,    42,   116,   116,    95,   117,    18,   108,   108,
+       8,   117,   117,   110,   108,   150,   108,   118,   117,     8,
+     122,   117,   123,    95,    95,   108,   108,   116
 };
 
 typedef enum {
@@ -952,13 +946,12 @@ static const toketypes yy_type_tab[] =
   toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_ival,
   toketype_i_tkval, toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_opval,
   toketype_ival, toketype_ival, toketype_ival, toketype_opval, toketype_ival, toketype_opval,
-  toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval,
-  toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval,
-  toketype_p_tkval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval,
-  toketype_ival, toketype_ival, toketype_ival, toketype_opval, toketype_opval,
-  toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_ival,
-  toketype_opval, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_opval, toketype_opval,
+  toketype_opval, toketype_opval, toketype_ival, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_ival,
+  toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_p_tkval,
+  toketype_opval, toketype_ival, toketype_ival, toketype_ival, toketype_opval,
+  toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval,
+  toketype_opval, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval,
   toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval,
-  toketype_opval, toketype_opval, toketype_opval, toketype_i_tkval, toketype_ival, toketype_opval,
-  toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval
+  toketype_opval, toketype_i_tkval, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval,
+  toketype_opval, toketype_opval, toketype_opval, toketype_opval
 };
diff --git a/perly.y b/perly.y
index 33dbb1f..29fb93a 100644 (file)
--- a/perly.y
+++ b/perly.y
 /* FIXME for MAD - are these two ival? */
 %type <ival> mydefsv mintro
 
-%type <opval> fullstmt decl format subrout mysubrout package use peg
-%type <opval> block package_block mblock stmtseq loop cond else
+%type <opval> stmtseq fullstmt barestmt block mblock else
 %type <opval> expr term subscripted scalar ary hsh arylen star amper sideff
 %type <opval> argexpr nexpr texpr iexpr mexpr mnexpr miexpr
 %type <opval> listexpr listexprcom indirob listop method
 %type <opval> formname subname proto subbody cont my_scalar
 %type <opval> subattrlist myattrlist myattrterm myterm
 %type <opval> termbinop termunop anonymous termdo
-%type <opval> switch case
 %type <p_tkval> label
 
 %nonassoc <i_tkval> PREC_LOW
@@ -222,7 +220,7 @@ mremember:  /* NULL */      /* start a partial lexical scope */
                        { $$ = block_start(FALSE); }
        ;
 
-/* A collection of "lines" in the program */
+/* A sequence of statements in the program */
 stmtseq        :       /* NULL */
                        { $$ = (OP*)NULL; }
        |       stmtseq fullstmt
@@ -233,62 +231,252 @@ stmtseq  :       /* NULL */
                        }
        ;
 
-/* A statement in the program */
-fullstmt:      label cond
-                       { $$ = newSTATEOP(0, PVAL($1), $2);
-                         TOKEN_GETMAD($1,((LISTOP*)$$)->op_first,'L'); }
-       |       loop    /* loops add their own labels */
-       |       switch  /* ... and so do switches */
+/* A statement in the program, including optional label */
+fullstmt:      label barestmt
+                       {
+                         if (PVAL($1) || $2) {
+                             $$ = newSTATEOP(0, PVAL($1), $2);
+                             TOKEN_GETMAD($1,
+                                 $2 ? cLISTOPx($$)->op_first : $$, 'L');
+                         } else {
+                             $$ = IF_MAD(newOP(OP_NULL, 0), $2);
+                         }
+                       }
+       ;
+
+/* A bare statement, lacking label and other aspects of state op */
+barestmt:      PLUGSTMT
                        { $$ = $1; }
-       |       label case
-                       { $$ = newSTATEOP(0, PVAL($1), $2); }
-       |       label ';'
+       |       PEG
+                       {
+                         $$ = newOP(OP_NULL,0);
+                         TOKEN_GETMAD($1,$$,'p');
+                       }
+       |       FORMAT startformsub formname block
                        {
-                         if (PVAL($1)) {
-                             $$ = newSTATEOP(0, PVAL($1), newOP(OP_NULL, 0));
-                             TOKEN_GETMAD($1,$$,'L');
-                             TOKEN_GETMAD($2,((LISTOP*)$$)->op_first,';');
+                         CV *fmtcv = PL_compcv;
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         $$ = newFORM($2, $3, $4);
+                         prepend_madprops($1->tk_mad, $$, 'F');
+                         $1->tk_mad = 0;
+                         token_free($1);
+#else
+                         newFORM($2, $3, $4);
+                         $$ = (OP*)NULL;
+#endif
+                         if (CvOUTSIDE(fmtcv) && !CvUNIQUE(CvOUTSIDE(fmtcv))) {
+                             SvREFCNT_inc_simple_void(fmtcv);
+                             pad_add_anon((SV*)fmtcv, OP_NULL);
                          }
-                         else {
-                             $$ = IF_MAD(
-                                       newOP(OP_NULL, 0),
-                                       (OP*)NULL);
-                              PL_parser->copline = NOLINE;
-                             TOKEN_FREE($1);
-                             TOKEN_GETMAD($2,$$,';');
+                       }
+       |       SUB startsub subname proto subattrlist subbody
+                       {
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         {
+                             OP* o = newSVOP(OP_ANONCODE, 0,
+                               (SV*)newATTRSUB($2, $3, $4, $5, $6));
+                             $$ = newOP(OP_NULL,0);
+                             op_getmad(o,$$,'&');
+                             op_getmad($3,$$,'n');
+                             op_getmad($4,$$,'s');
+                             op_getmad($5,$$,'a');
+                             token_getmad($1,$$,'d');
+                             append_madprops($6->op_madprop, $$, 0);
+                             $6->op_madprop = 0;
                          }
-                         PL_parser->expect = XSTATE;
+#else
+                         newATTRSUB($2, $3, $4, $5, $6);
+                         $$ = (OP*)NULL;
+#endif
                        }
-       |       label sideff ';'
+       |       MYSUB startsub subname proto subattrlist subbody
                        {
-                         $$ = newSTATEOP(0, PVAL($1), $2);
-                         PL_parser->expect = XSTATE;
-                         DO_MAD({
-                             /* sideff might already have a nexstate */
-                             OP* op = ((LISTOP*)$$)->op_first;
-                             if (op) {
-                                 while (op->op_sibling &&
-                                    op->op_sibling->op_type == OP_NEXTSTATE)
-                                       op = op->op_sibling;
-                                 token_getmad($1,op,'L');
-                                 token_getmad($3,op,';');
-                             }
-                         })
+                         /* Unimplemented "my sub foo { }" */
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         $$ = newMYSUB($2, $3, $4, $5, $6);
+                         token_getmad($1,$$,'d');
+#else
+                         newMYSUB($2, $3, $4, $5, $6);
+                         $$ = (OP*)NULL;
+#endif
                        }
-       |       label package_block
-                       { $$ = newSTATEOP(0, PVAL($1),
-                                newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                           NOLINE, (OP*)NULL, $2,
-                                           (OP*)NULL, 0)); }
-       |       label PLUGSTMT
-                       { $$ = newSTATEOP(0, PVAL($1), $2); }
-       |       label decl
+       |       PACKAGE WORD WORD ';'
                        {
-                         if (PVAL($1)) {
-                             $$ = newSTATEOP(0, PVAL($1), $2);
-                         } else {
-                             $$ = IF_MAD($2 ? $2 : newOP(OP_NULL, 0), $2);
+#ifdef MAD
+                         $$ = package($3);
+                         token_getmad($1,$$,'o');
+                         if ($2)
+                             package_version($2);
+                         token_getmad($4,$$,';');
+#else
+                         package($3);
+                         if ($2)
+                             package_version($2);
+                         $$ = (OP*)NULL;
+#endif
+                       }
+       |       USE startsub
+                       { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
+               WORD WORD listexpr ';'
+                       {
+                         SvREFCNT_inc_simple_void(PL_compcv);
+#ifdef MAD
+                         $$ = utilize(IVAL($1), $2, $4, $5, $6);
+                         token_getmad($1,$$,'o');
+                         token_getmad($7,$$,';');
+                         if (PL_parser->rsfp_filters &&
+                                     AvFILLp(PL_parser->rsfp_filters) >= 0)
+                             append_madprops(newMADPROP('!', MAD_NULL, NULL, 0), $$, 0);
+#else
+                         utilize(IVAL($1), $2, $4, $5, $6);
+                         $$ = (OP*)NULL;
+#endif
+                       }
+       |       IF lpar_or_qw remember mexpr ')' mblock else
+                       {
+                         $$ = block_end($3, newCONDOP(0, $4, scope($6), $7));
+                         TOKEN_GETMAD($1,$$,'I');
+                         TOKEN_GETMAD($2,$$,'(');
+                         TOKEN_GETMAD($5,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       UNLESS lpar_or_qw remember miexpr ')' mblock else
+                       {
+                         $$ = block_end($3, newCONDOP(0, $4, scope($6), $7));
+                         TOKEN_GETMAD($1,$$,'I');
+                         TOKEN_GETMAD($2,$$,'(');
+                         TOKEN_GETMAD($5,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       GIVEN lpar_or_qw remember mydefsv mexpr ')' mblock
+                       {
+                         $$ = block_end($3,
+                                 newGIVENOP($5, scope($7), (PADOFFSET)$4));
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       WHEN lpar_or_qw remember mexpr ')' mblock
+                       { $$ = block_end($3, newWHENOP($4, scope($6))); }
+       |       DEFAULT block
+                       { $$ = newWHENOP(0, scope($2)); }
+       |       WHILE lpar_or_qw remember texpr ')' mintro mblock cont
+                       {
+                         $$ = block_end($3,
+                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
+                                     IVAL($1), $4, $7, $8, $6));
+                         TOKEN_GETMAD($1,$$,'W');
+                         TOKEN_GETMAD($2,$$,'(');
+                         TOKEN_GETMAD($5,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       UNTIL lpar_or_qw remember iexpr ')' mintro mblock cont
+                       {
+                         $$ = block_end($3,
+                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
+                                     IVAL($1), $4, $7, $8, $6));
+                         TOKEN_GETMAD($1,$$,'W');
+                         TOKEN_GETMAD($2,$$,'(');
+                         TOKEN_GETMAD($5,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       FOR lpar_or_qw remember mnexpr ';' texpr ';' mintro mnexpr ')'
+               mblock
+                       {
+                         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);
+                         if (initop) {
+                             forop = op_prepend_elem(OP_LINESEQ, initop,
+                                 op_append_elem(OP_LINESEQ,
+                                     newOP(OP_UNSTACK, OPf_SPECIAL),
+                                     forop));
                          }
+                         DO_MAD({ forop = newUNOP(OP_NULL, 0, forop); })
+                         $$ = block_end($3, forop);
+                         TOKEN_GETMAD($1,$$,'3');
+                         TOKEN_GETMAD($2,$$,'(');
+                         TOKEN_GETMAD($5,$$,'1');
+                         TOKEN_GETMAD($7,$$,'2');
+                         TOKEN_GETMAD($10,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       FOR MY remember my_scalar lpar_or_qw mexpr ')' mblock cont
+                       {
+                         $$ = block_end($3,
+                                 newFOROP(0, (line_t)IVAL($1),
+                                     $4, $6, $8, $9));
+                         TOKEN_GETMAD($1,$$,'W');
+                         TOKEN_GETMAD($2,$$,'d');
+                         TOKEN_GETMAD($5,$$,'(');
+                         TOKEN_GETMAD($7,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       FOR scalar lpar_or_qw remember mexpr ')' mblock cont
+                       {
+                         $$ = block_end($4,
+                                 newFOROP(0, (line_t)IVAL($1),
+                                     mod($2, OP_ENTERLOOP), $5, $7, $8));
+                         TOKEN_GETMAD($1,$$,'W');
+                         TOKEN_GETMAD($3,$$,'(');
+                         TOKEN_GETMAD($6,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       FOR lpar_or_qw remember mexpr ')' mblock cont
+                       {
+                         $$ = block_end($3,
+                                 newFOROP(0, (line_t)IVAL($1),
+                                     (OP*)NULL, $4, $6, $7));
+                         TOKEN_GETMAD($1,$$,'W');
+                         TOKEN_GETMAD($2,$$,'(');
+                         TOKEN_GETMAD($5,$$,')');
+                         PL_parser->copline = (line_t)IVAL($1);
+                       }
+       |       block cont
+                       {
+                         /* a block is a loop that happens once */
+                         $$ = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
+                                 NOLINE, (OP*)NULL, $1, $2, 0);
+                       }
+       |       PACKAGE WORD WORD '{' remember
+                       {
+                         int save_3_latefree = $3->op_latefree;
+                         $3->op_latefree = 1;
+                         package($3);
+                         $3->op_latefree = save_3_latefree;
+                         if ($2) {
+                             int save_2_latefree = $2->op_latefree;
+                             $2->op_latefree = 1;
+                             package_version($2);
+                             $2->op_latefree = save_2_latefree;
+                         }
+                       }
+               stmtseq '}'
+                       {
+                         /* a block is a loop that happens once */
+                         $$ = newWHILEOP(0, 1, (LOOP*)(OP*)NULL, NOLINE,
+                                 (OP*)NULL, block_end($5, $7), (OP*)NULL, 0);
+                         op_free($3);
+                         if ($2)
+                             op_free($2);
+                         TOKEN_GETMAD($4,$$,'{');
+                         TOKEN_GETMAD($8,$$,'}');
+                         if (PL_parser->copline > (line_t)IVAL($4))
+                             PL_parser->copline = (line_t)IVAL($4);
+                       }
+       |       sideff ';'
+                       {
+                         PL_parser->expect = XSTATE;
+                         $$ = $1;
+                         TOKEN_GETMAD($2,$$,';');
+                       }
+       |       ';'
+                       {
+                         PL_parser->expect = XSTATE;
+                         $$ = IF_MAD(newOP(OP_NULL, 0), (OP*)NULL);
+                         TOKEN_GETMAD($1,$$,';');
+                         PL_parser->copline = NOLINE;
                        }
        ;
 
@@ -314,9 +502,9 @@ sideff      :       error
                          TOKEN_GETMAD($2,$$,'w');
                        }
        |       expr FOR expr
-                       { $$ = newFOROP(0, NULL, (line_t)IVAL($2),
+                       { $$ = newFOROP(0, (line_t)IVAL($2),
                                        (OP*)NULL, $3, $1, (OP*)NULL);
-                         TOKEN_GETMAD($2,((LISTOP*)$$)->op_first->op_sibling,'w');
+                         TOKEN_GETMAD($2,$$,'w');
                        }
        |       expr WHEN expr
                        { $$ = newWHENOP($3, scope($1)); }
@@ -339,33 +527,6 @@ else       :       /* NULL */
                        }
        ;
 
-/* Real conditional expressions */
-cond   :       IF lpar_or_qw remember mexpr ')' mblock else
-                       { PL_parser->copline = (line_t)IVAL($1);
-                           $$ = block_end($3,
-                                  newCONDOP(0, $4, scope($6), $7));
-                         TOKEN_GETMAD($1,$$,'I');
-                         TOKEN_GETMAD($2,$$,'(');
-                         TOKEN_GETMAD($5,$$,')');
-                       }
-       |       UNLESS lpar_or_qw remember miexpr ')' mblock else
-                       { PL_parser->copline = (line_t)IVAL($1);
-                           $$ = block_end($3,
-                                  newCONDOP(0, $4, scope($6), $7));
-                         TOKEN_GETMAD($1,$$,'I');
-                         TOKEN_GETMAD($2,$$,'(');
-                         TOKEN_GETMAD($5,$$,')');
-                       }
-       ;
-
-/* Cases for a switch statement */
-case   :       WHEN lpar_or_qw remember mexpr ')' mblock
-       { $$ = block_end($3,
-               newWHENOP($4, scope($6))); }
-       |       DEFAULT block
-       { $$ = newWHENOP(0, scope($2)); }
-       ;
-
 /* Continue blocks */
 cont   :       /* NULL */
                        { $$ = (OP*)NULL; }
@@ -375,111 +536,6 @@ cont      :       /* NULL */
                        }
        ;
 
-/* Loops: while, until, for, and a bare block */
-loop   :       label WHILE lpar_or_qw remember texpr ')' mintro mblock cont
-                       { OP *innerop;
-                         PL_parser->copline = (line_t)IVAL($2);
-                           $$ = block_end($4,
-                                  newSTATEOP(0, PVAL($1),
-                                    innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                               IVAL($2), $5, $8, $9, $7)));
-                         TOKEN_GETMAD($1,innerop,'L');
-                         TOKEN_GETMAD($2,innerop,'W');
-                         TOKEN_GETMAD($3,innerop,'(');
-                         TOKEN_GETMAD($6,innerop,')');
-                       }
-
-       |       label UNTIL lpar_or_qw remember iexpr ')' mintro mblock cont
-                       { OP *innerop;
-                         PL_parser->copline = (line_t)IVAL($2);
-                           $$ = block_end($4,
-                                  newSTATEOP(0, PVAL($1),
-                                    innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                               IVAL($2), $5, $8, $9, $7)));
-                         TOKEN_GETMAD($1,innerop,'L');
-                         TOKEN_GETMAD($2,innerop,'W');
-                         TOKEN_GETMAD($3,innerop,'(');
-                         TOKEN_GETMAD($6,innerop,')');
-                       }
-       |       label FOR MY remember my_scalar lpar_or_qw mexpr ')' mblock cont
-                       { OP *innerop;
-                         $$ = block_end($4,
-                            innerop = newFOROP(0, PVAL($1), (line_t)IVAL($2),
-                                           $5, $7, $9, $10));
-                         TOKEN_GETMAD($1,((LISTOP*)innerop)->op_first,'L');
-                         TOKEN_GETMAD($2,((LISTOP*)innerop)->op_first->op_sibling,'W');
-                         TOKEN_GETMAD($3,((LISTOP*)innerop)->op_first->op_sibling,'d');
-                         TOKEN_GETMAD($6,((LISTOP*)innerop)->op_first->op_sibling,'(');
-                         TOKEN_GETMAD($8,((LISTOP*)innerop)->op_first->op_sibling,')');
-                       }
-       |       label FOR scalar lpar_or_qw remember mexpr ')' mblock cont
-                       { OP *innerop;
-                         $$ = block_end($5,
-                            innerop = newFOROP(0, PVAL($1), (line_t)IVAL($2),
-                                   mod($3, OP_ENTERLOOP), $6, $8, $9));
-                         TOKEN_GETMAD($1,((LISTOP*)innerop)->op_first,'L');
-                         TOKEN_GETMAD($2,((LISTOP*)innerop)->op_first->op_sibling,'W');
-                         TOKEN_GETMAD($4,((LISTOP*)innerop)->op_first->op_sibling,'(');
-                         TOKEN_GETMAD($7,((LISTOP*)innerop)->op_first->op_sibling,')');
-                       }
-       |       label FOR lpar_or_qw remember mexpr ')' mblock cont
-                       { OP *innerop;
-                         $$ = block_end($4,
-                            innerop = newFOROP(0, PVAL($1), (line_t)IVAL($2),
-                                                   (OP*)NULL, $5, $7, $8));
-                         TOKEN_GETMAD($1,((LISTOP*)innerop)->op_first,'L');
-                         TOKEN_GETMAD($2,((LISTOP*)innerop)->op_first->op_sibling,'W');
-                         TOKEN_GETMAD($3,((LISTOP*)innerop)->op_first->op_sibling,'(');
-                         TOKEN_GETMAD($6,((LISTOP*)innerop)->op_first->op_sibling,')');
-                       }
-       |       label FOR lpar_or_qw remember mnexpr ';' texpr ';' mintro mnexpr ')'
-                   mblock
-                       /* basically fake up an initialize-while stmtseq */
-                       { OP *forop;
-                         PL_parser->copline = (line_t)IVAL($2);
-                         forop = newSTATEOP(0, PVAL($1),
-                                           newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                               IVAL($2), scalar($7),
-                                               $12, $10, $9));
-#ifdef MAD
-                         forop = newUNOP(OP_NULL, 0, op_append_elem(OP_LINESEQ,
-                               newSTATEOP(0,
-                                          CopLABEL_alloc(($1)->tk_lval.pval),
-                                          ($5 ? $5 : newOP(OP_NULL, 0)) ),
-                               forop));
-
-                         token_getmad($2,forop,'3');
-                         token_getmad($3,forop,'(');
-                         token_getmad($6,forop,'1');
-                         token_getmad($8,forop,'2');
-                         token_getmad($11,forop,')');
-                         token_getmad($1,forop,'L');
-#else
-                         if ($5) {
-                               forop = op_append_elem(OP_LINESEQ,
-                                        newSTATEOP(0, CopLABEL_alloc($1), $5),
-                                       forop);
-                         }
-
-
-#endif
-                         $$ = block_end($4, forop); }
-       |       label block cont  /* a block is a loop that happens once */
-                       { $$ = newSTATEOP(0, PVAL($1),
-                                newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-                                           NOLINE, (OP*)NULL, $2, $3, 0));
-                         TOKEN_GETMAD($1,((LISTOP*)$$)->op_first,'L'); }
-       ;
-
-/* Switch blocks */
-switch :       label GIVEN lpar_or_qw remember mydefsv mexpr ')' mblock
-                       { PL_parser->copline = (line_t) IVAL($2);
-                           $$ = block_end($4,
-                               newSTATEOP(0, PVAL($1),
-                                   newGIVENOP($6, scope($8),
-                                       (PADOFFSET) $5) )); }
-       ;
-
 /* determine whether there are any new my declarations */
 mintro :       /* NULL */
                        { $$ = (PL_min_intro_pending &&
@@ -532,90 +588,10 @@ label     :       /* empty */
        |       LABEL
        ;
 
-/* Some kind of declaration - just hang on peg in the parse tree */
-decl   :       format
-                       { $$ = $1; }
-       |       subrout
-                       { $$ = $1; }
-       |       mysubrout
-                       { $$ = $1; }
-       |       package
-                       { $$ = $1; }
-       |       use
-                       { $$ = $1; }
-
-    /* these two are only used by MAD */
-
-       |       peg
-                       { $$ = $1; }
-       ;
-
-peg    :       PEG
-                       { $$ = newOP(OP_NULL,0);
-                         TOKEN_GETMAD($1,$$,'p');
-                       }
-       ;
-
-format :       FORMAT startformsub formname block
-                       {
-                         CV *fmtcv = PL_compcv;
-                         SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         $$ = newFORM($2, $3, $4);
-                         prepend_madprops($1->tk_mad, $$, 'F');
-                         $1->tk_mad = 0;
-                         token_free($1);
-#else
-                         newFORM($2, $3, $4);
-                         $$ = (OP*)NULL;
-#endif
-                         if (CvOUTSIDE(fmtcv) && !CvUNIQUE(CvOUTSIDE(fmtcv))) {
-                           SvREFCNT_inc_simple_void(fmtcv);
-                           pad_add_anon((SV*)fmtcv, OP_NULL);
-                         }
-                       }
-       ;
-
 formname:      WORD            { $$ = $1; }
        |       /* NULL */      { $$ = (OP*)NULL; }
        ;
 
-/* Unimplemented "my sub foo { }" */
-mysubrout:     MYSUB startsub subname proto subattrlist subbody
-                       { SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         $$ = newMYSUB($2, $3, $4, $5, $6);
-                         token_getmad($1,$$,'d');
-#else
-                         newMYSUB($2, $3, $4, $5, $6);
-                         $$ = (OP*)NULL;
-#endif
-                       }
-       ;
-
-/* Subroutine definition */
-subrout        :       SUB startsub subname proto subattrlist subbody
-                       { SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         {
-                             OP* o = newSVOP(OP_ANONCODE, 0,
-                               (SV*)newATTRSUB($2, $3, $4, $5, $6));
-                             $$ = newOP(OP_NULL,0);
-                             op_getmad(o,$$,'&');
-                             op_getmad($3,$$,'n');
-                             op_getmad($4,$$,'s');
-                             op_getmad($5,$$,'a');
-                             token_getmad($1,$$,'d');
-                             append_madprops($6->op_madprop, $$, 0);
-                             $6->op_madprop = 0;
-                           }
-#else
-                         newATTRSUB($2, $3, $4, $5, $6);
-                         $$ = (OP*)NULL;
-#endif
-                       }
-       ;
-
 startsub:      /* NULL */      /* start a regular subroutine scope */
                        { $$ = start_subparse(FALSE, 0);
                            SAVEFREESV(PL_compcv); }
@@ -688,66 +664,6 @@ subbody    :       block   { $$ = $1; }
                        }
        ;
 
-package :      PACKAGE WORD WORD ';'
-                       {
-#ifdef MAD
-                         $$ = package($3);
-                         token_getmad($1,$$,'o');
-                         if ($2)
-                             package_version($2);
-                         token_getmad($4,$$,';');
-#else
-                         package($3);
-                         if ($2)
-                             package_version($2);
-                         $$ = (OP*)NULL;
-#endif
-                       }
-       ;
-
-package_block: PACKAGE WORD WORD '{' remember
-                       {
-                         int save_3_latefree = $3->op_latefree;
-                         $3->op_latefree = 1;
-                         package($3);
-                         $3->op_latefree = save_3_latefree;
-                         if ($2) {
-                             int save_2_latefree = $2->op_latefree;
-                             $2->op_latefree = 1;
-                             package_version($2);
-                             $2->op_latefree = save_2_latefree;
-                         }
-                       }
-                   stmtseq '}'
-                       { if (PL_parser->copline > (line_t)IVAL($4))
-                             PL_parser->copline = (line_t)IVAL($4);
-                         $$ = block_end($5, $7);
-                         TOKEN_GETMAD($4,$$,'{');
-                         TOKEN_GETMAD($8,$$,'}');
-                         op_free($3);
-                         if ($2)
-                             op_free($2);
-                       }
-       ;
-
-use    :       USE startsub
-                       { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
-                   WORD WORD listexpr ';'
-                       { SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-                         $$ = utilize(IVAL($1), $2, $4, $5, $6);
-                         token_getmad($1,$$,'o');
-                         token_getmad($7,$$,';');
-                         if (PL_parser->rsfp_filters &&
-                                     AvFILLp(PL_parser->rsfp_filters) >= 0)
-                             append_madprops(newMADPROP('!', MAD_NULL, NULL, 0), $$, 0);
-#else
-                         utilize(IVAL($1), $2, $4, $5, $6);
-                         $$ = (OP*)NULL;
-#endif
-                       }
-       ;
-
 /* Ordinary expressions; logical combinations */
 expr   :       expr ANDOP expr
                        { $$ = newLOGOP(OP_AND, 0, $1, $3);
index 9eebf43..b3c7ba2 100644 (file)
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -2783,6 +2783,14 @@ PP(pp_goto)
                                    enterops, enterops + GOTO_DEPTH);
                if (retop)
                    break;
+               if (gotoprobe->op_sibling &&
+                       gotoprobe->op_sibling->op_type == OP_UNSTACK &&
+                       gotoprobe->op_sibling->op_sibling) {
+                   retop = dofindlabel(gotoprobe->op_sibling->op_sibling,
+                                       label, enterops, enterops + GOTO_DEPTH);
+                   if (retop)
+                       break;
+               }
            }
            PL_lastgotoprobe = gotoprobe;
        }
index 34542c2..3414365 100644 (file)
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -223,13 +223,14 @@ PP(pp_cond_expr)
 PP(pp_unstack)
 {
     dVAR;
-    I32 oldsave;
     PERL_ASYNC_CHECK();
     TAINT_NOT;         /* Each statement is presumed innocent */
     PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
     FREETMPS;
-    oldsave = PL_scopestack[PL_scopestack_ix - 1];
-    LEAVE_SCOPE(oldsave);
+    if (!(PL_op->op_flags & OPf_SPECIAL)) {
+       I32 oldsave = PL_scopestack[PL_scopestack_ix - 1];
+       LEAVE_SCOPE(oldsave);
+    }
     return NORMAL;
 }
 
diff --git a/proto.h b/proto.h
index 7b95890..bd572be 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, char* label, line_t forline, OP* sv, OP* expr, OP* block, OP* cont)
+PERL_CALLCONV OP*      Perl_newFOROP(pTHX_ I32 flags, line_t forline, OP* sv, OP* expr, OP* block, OP* cont)
                        __attribute__malloc__
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_5);
+                       __attribute__nonnull__(pTHX_4);
 #define PERL_ARGS_ASSERT_NEWFOROP      \
        assert(expr)
 
index 36cbb38..3cac218 100644 (file)
@@ -35,13 +35,13 @@ __SWDTEST__
                 progfile => $filename,
                 args => ['3'],
                );
-    like($r, qr/^sub<Devel::switchd::import>;import<Devel::switchd>;DB<main,$::tempfile_regexp,9>;sub<Foo::foo>;DB<Foo,$::tempfile_regexp,5>;DB<Foo,$::tempfile_regexp,6>;DB<Foo,$::tempfile_regexp,6>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;$/);
+    like($r, qr/^sub<Devel::switchd::import>;import<Devel::switchd>;DB<main,$::tempfile_regexp,9>;sub<Foo::foo>;DB<Foo,$::tempfile_regexp,5>;DB<Foo,$::tempfile_regexp,6>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;$/);
     $r = runperl(
                 switches => [ '-Ilib', '-f', '-d:switchd=a,42' ],
                 progfile => $filename,
                 args => ['4'],
                );
-    like($r, qr/^sub<Devel::switchd::import>;import<Devel::switchd a 42>;DB<main,$::tempfile_regexp,9>;sub<Foo::foo>;DB<Foo,$::tempfile_regexp,5>;DB<Foo,$::tempfile_regexp,6>;DB<Foo,$::tempfile_regexp,6>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;$/);
+    like($r, qr/^sub<Devel::switchd::import>;import<Devel::switchd a 42>;DB<main,$::tempfile_regexp,9>;sub<Foo::foo>;DB<Foo,$::tempfile_regexp,5>;DB<Foo,$::tempfile_regexp,6>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;sub<Bar::bar>;DB<Bar,$::tempfile_regexp,2>;$/);
 }
 
 # [perl #71806]