Set PL_expect less often when parsing semicolons

As it worked before, the parser (perly.y) would set PL_expect to
XSTATE after encountering a statement-terminating semicolon.

Two functions in op.c--package and utilize--had to set the value to
XSTATE as a result.

Also, in the case of a closing brace, the lexer emits an implicit
semicolon followed by '}' (emitted via force_next).  force_next
records the value of PL_expect and restores it when emitting the
token.  So in this case the value of PL_expect was flipping back and
forth between two values.

Instead of having the parser set it to XSTATE, we can have the lexer
set it to XSTATE by default when emitting an explicit semicolon.  (It
was setting it to XTERM.)  The parser can set it to XTERM in the only
place that matters; viz., the header of a for-loop.  This simplifies
things conceptually, and makes the code a whole line shorter.

(The diff stat shows more savings in line count, but that is because
the version of bison I used to regenerate the tables produces smaller
headers than what was already committed.)

1 files changed, 455 insertions, 446 deletions

diff --git a/perly.act b/perly.act
index 61850f48e5..ff027086ac 100644
--- a/perly.act
+++ b/perly.act
@@ -8,7 +8,7 @@ case 2:
 #line 114 "perly.y"
     {
 			  PL_parser->expect = XSTATE;
-			}
+			;}
     break;
 
   case 3:
@@ -16,14 +16,14 @@ case 2:
     {
 			  newPROG(block_end((ps[(3) - (4)].val.ival),(ps[(4) - (4)].val.opval)));
 			  (yyval.ival) = 0;
-			}
+			;}
     break;
 
   case 4:
 #line 123 "perly.y"
     {
 			  parser->expect = XTERM;
-			}
+			;}
     break;
 
   case 5:
@@ -31,14 +31,14 @@ case 2:
     {
 			  PL_eval_root = (ps[(3) - (3)].val.opval);
 			  (yyval.ival) = 0;
-			}
+			;}
     break;
 
   case 6:
 #line 132 "perly.y"
     {
 			  parser->expect = XBLOCK;
-			}
+			;}
     break;
 
   case 7:
@@ -49,14 +49,14 @@ case 2:
 			  (yyval.ival) = 0;
 			  yyunlex();
 			  parser->yychar = YYEOF;
-			}
+			;}
     break;
 
   case 8:
 #line 144 "perly.y"
     {
 			  parser->expect = XSTATE;
-			}
+			;}
     break;
 
   case 9:
@@ -67,14 +67,14 @@ case 2:
 			  (yyval.ival) = 0;
 			  yyunlex();
 			  parser->yychar = YYEOF;
-			}
+			;}
     break;
 
   case 10:
 #line 156 "perly.y"
     {
 			  parser->expect = XSTATE;
-			}
+			;}
     break;
 
   case 11:
@@ -85,14 +85,14 @@ case 2:
 			  (yyval.ival) = 0;
 			  yyunlex();
 			  parser->yychar = YYEOF;
-			}
+			;}
     break;
 
   case 12:
 #line 168 "perly.y"
     {
 			  parser->expect = XSTATE;
-			}
+			;}
     break;
 
   case 13:
@@ -100,7 +100,7 @@ case 2:
     {
 			  PL_eval_root = (ps[(3) - (3)].val.opval);
 			  (yyval.ival) = 0;
-			}
+			;}
     break;
 
   case 14:
@@ -108,7 +108,7 @@ case 2:
     { if (PL_parser->copline > (line_t)(ps[(1) - (4)].val.ival))
 			      PL_parser->copline = (line_t)(ps[(1) - (4)].val.ival);
 			  (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
-			}
+			;}
     break;
 
   case 15:
@@ -116,12 +116,12 @@ case 2:
     { if (PL_parser->copline > (line_t)(ps[(1) - (7)].val.ival))
 			      PL_parser->copline = (line_t)(ps[(1) - (7)].val.ival);
 			  (yyval.opval) = block_end((ps[(2) - (7)].val.ival), (ps[(5) - (7)].val.opval));
-			}
+			;}
     break;
 
   case 16:
 #line 195 "perly.y"
-    { (yyval.ival) = block_start(TRUE); }
+    { (yyval.ival) = block_start(TRUE); ;}
     break;
 
   case 17:
@@ -129,17 +129,17 @@ case 2:
     { if (PL_parser->copline > (line_t)(ps[(1) - (4)].val.ival))
 			      PL_parser->copline = (line_t)(ps[(1) - (4)].val.ival);
 			  (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
-			}
+			;}
     break;
 
   case 18:
 #line 206 "perly.y"
-    { (yyval.ival) = block_start(FALSE); }
+    { (yyval.ival) = block_start(FALSE); ;}
     break;
 
   case 19:
 #line 211 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 20:
@@ -148,12 +148,12 @@ case 2:
 			    PL_pad_reset_pending = TRUE;
 			    if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
 				PL_hints |= HINT_BLOCK_SCOPE;
-			}
+			;}
     break;
 
   case 21:
 #line 222 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 22:
@@ -162,38 +162,38 @@ case 2:
 			    PL_pad_reset_pending = TRUE;
 			    if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
 				PL_hints |= HINT_BLOCK_SCOPE;
-			}
+			;}
     break;
 
   case 23:
 #line 233 "perly.y"
     {
 			  (yyval.opval) = (ps[(1) - (1)].val.opval) ? newSTATEOP(0, NULL, (ps[(1) - (1)].val.opval)) : NULL;
-			}
+			;}
     break;
 
   case 24:
 #line 237 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 25:
 #line 241 "perly.y"
     {
 			  (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
-			}
+			;}
     break;
 
   case 26:
 #line 245 "perly.y"
     {
 			  (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
-			}
+			;}
     break;
 
   case 27:
 #line 252 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 28:
@@ -206,7 +206,7 @@ case 2:
 			      SvREFCNT_inc_simple_void(fmtcv);
 			      pad_add_anon(fmtcv, OP_NULL);
 			  }
-			}
+			;}
     break;
 
   case 29:
@@ -231,7 +231,7 @@ case 2:
 			      CvCLONE_on(PL_compcv);
 			  PL_parser->in_my = 0;
 			  PL_parser->in_my_stash = NULL;
-			}
+			;}
     break;
 
   case 30:
@@ -244,7 +244,7 @@ case 2:
 			  ;
 			  (yyval.opval) = (OP*)NULL;
 			  intro_my();
-			}
+			;}
     break;
 
   case 31:
@@ -254,12 +254,12 @@ case 2:
 			  if ((ps[(2) - (4)].val.opval))
 			      package_version((ps[(2) - (4)].val.opval));
 			  (yyval.opval) = (OP*)NULL;
-			}
+			;}
     break;
 
   case 32:
 #line 303 "perly.y"
-    { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
+    { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
     break;
 
   case 33:
@@ -268,7 +268,7 @@ case 2:
 			  SvREFCNT_inc_simple_void(PL_compcv);
 			  utilize((ps[(1) - (7)].val.ival), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
 			  (yyval.opval) = (OP*)NULL;
-			}
+			;}
     break;
 
   case 34:
@@ -277,7 +277,7 @@ case 2:
 			  (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 			      newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 			  PL_parser->copline = (line_t)(ps[(1) - (7)].val.ival);
-			}
+			;}
     break;
 
   case 35:
@@ -286,7 +286,7 @@ case 2:
 			  (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 			      newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
 			  PL_parser->copline = (line_t)(ps[(1) - (7)].val.ival);
-			}
+			;}
     break;
 
   case 36:
@@ -300,17 +300,17 @@ case 2:
 				      ? 0
 				      : offset));
 			  PL_parser->copline = (line_t)(ps[(1) - (6)].val.ival);
-			}
+			;}
     break;
 
   case 37:
 #line 334 "perly.y"
-    { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); }
+    { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); ;}
     break;
 
   case 38:
 #line 336 "perly.y"
-    { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); }
+    { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 39:
@@ -320,7 +320,7 @@ case 2:
 				  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				      (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
 			  PL_parser->copline = (line_t)(ps[(1) - (8)].val.ival);
-			}
+			;}
     break;
 
   case 40:
@@ -330,101 +330,109 @@ case 2:
 				  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				      (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
 			  PL_parser->copline = (line_t)(ps[(1) - (8)].val.ival);
-			}
+			;}
     break;
 
   case 41:
-#line 353 "perly.y"
+#line 352 "perly.y"
+    { parser->expect = XTERM; ;}
+    break;
+
+  case 42:
+#line 354 "perly.y"
+    { parser->expect = XTERM; ;}
+    break;
+
+  case 43:
+#line 357 "perly.y"
     {
-			  OP *initop = (ps[(4) - (11)].val.opval);
+			  OP *initop = (ps[(4) - (13)].val.opval);
 			  OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
-				      scalar((ps[(6) - (11)].val.opval)), (ps[(11) - (11)].val.opval), (ps[(9) - (11)].val.opval), (ps[(8) - (11)].val.ival));
+				      scalar((ps[(7) - (13)].val.opval)), (ps[(13) - (13)].val.opval), (ps[(11) - (13)].val.opval), (ps[(10) - (13)].val.ival));
 			  if (initop) {
 			      forop = op_prepend_elem(OP_LINESEQ, initop,
 				  op_append_elem(OP_LINESEQ,
 				      newOP(OP_UNSTACK, OPf_SPECIAL),
 				      forop));
 			  }
-			  (yyval.opval) = block_end((ps[(3) - (11)].val.ival), forop);
-			  PL_parser->copline = (line_t)(ps[(1) - (11)].val.ival);
-			}
+			  (yyval.opval) = block_end((ps[(3) - (13)].val.ival), forop);
+			  PL_parser->copline = (line_t)(ps[(1) - (13)].val.ival);
+			;}
     break;
 
-  case 42:
-#line 367 "perly.y"
+  case 44:
+#line 371 "perly.y"
     {
 			  (yyval.opval) = block_end((ps[(3) - (9)].val.ival), newFOROP(0, (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
 			  PL_parser->copline = (line_t)(ps[(1) - (9)].val.ival);
-			}
+			;}
     break;
 
-  case 43:
-#line 372 "perly.y"
+  case 45:
+#line 376 "perly.y"
     {
 			  (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
 				      op_lvalue((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
 			  PL_parser->copline = (line_t)(ps[(1) - (8)].val.ival);
-			}
+			;}
     break;
 
-  case 44:
-#line 378 "perly.y"
+  case 46:
+#line 382 "perly.y"
     {
 			  (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
 				  newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
 			  PL_parser->copline = (line_t)(ps[(1) - (7)].val.ival);
-			}
+			;}
     break;
 
-  case 45:
-#line 384 "perly.y"
+  case 47:
+#line 388 "perly.y"
     {
 			  /* a block is a loop that happens once */
 			  (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				  (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), 0);
-			}
+			;}
     break;
 
-  case 46:
-#line 390 "perly.y"
+  case 48:
+#line 394 "perly.y"
     {
 			  package((ps[(3) - (5)].val.opval));
 			  if ((ps[(2) - (5)].val.opval)) {
 			      package_version((ps[(2) - (5)].val.opval));
 			  }
-			}
+			;}
     break;
 
-  case 47:
-#line 397 "perly.y"
+  case 49:
+#line 401 "perly.y"
     {
 			  /* a block is a loop that happens once */
 			  (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				  (OP*)NULL, block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval)), (OP*)NULL, 0);
 			  if (PL_parser->copline > (line_t)(ps[(4) - (8)].val.ival))
 			      PL_parser->copline = (line_t)(ps[(4) - (8)].val.ival);
-			}
+			;}
     break;
 
-  case 48:
-#line 405 "perly.y"
+  case 50:
+#line 409 "perly.y"
     {
-			  PL_parser->expect = XSTATE;
 			  (yyval.opval) = (ps[(1) - (2)].val.opval);
-			}
+			;}
     break;
 
-  case 49:
-#line 410 "perly.y"
+  case 51:
+#line 413 "perly.y"
     {
-			  PL_parser->expect = XSTATE;
 			  (yyval.opval) = (OP*)NULL;
 			  PL_parser->copline = NOLINE;
-			}
+			;}
     break;
 
-  case 50:
-#line 419 "perly.y"
+  case 52:
+#line 421 "perly.y"
     { OP *list;
 			  if ((ps[(2) - (2)].val.opval)) {
 			      OP *term = (ps[(2) - (2)].val.opval);
@@ -438,197 +446,197 @@ case 2:
 			  else PL_parser->copline--;
 			  (yyval.opval) = newSTATEOP(0, NULL,
 					  convert(OP_FORMLINE, 0, list));
-			}
-    break;
-
-  case 51:
-#line 436 "perly.y"
-    { (yyval.opval) = NULL; }
-    break;
-
-  case 52:
-#line 438 "perly.y"
-    { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); }
+			;}
     break;
 
   case 53:
-#line 443 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+#line 438 "perly.y"
+    { (yyval.opval) = NULL; ;}
     break;
 
   case 54:
-#line 445 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+#line 440 "perly.y"
+    { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); ;}
     break;
 
   case 55:
-#line 447 "perly.y"
-    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); }
+#line 445 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 56:
-#line 449 "perly.y"
-    { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); }
+#line 447 "perly.y"
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 57:
-#line 451 "perly.y"
-    { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval)); }
+#line 449 "perly.y"
+    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 58:
-#line 453 "perly.y"
-    { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); }
+#line 451 "perly.y"
+    { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 59:
-#line 455 "perly.y"
-    { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
-			  PL_parser->copline = (line_t)(ps[(2) - (3)].val.ival); }
+#line 453 "perly.y"
+    { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 60:
-#line 458 "perly.y"
-    { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); }
+#line 455 "perly.y"
+    { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
     break;
 
   case 61:
-#line 463 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+#line 457 "perly.y"
+    { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
+			  PL_parser->copline = (line_t)(ps[(2) - (3)].val.ival); ;}
     break;
 
   case 62:
+#line 460 "perly.y"
+    { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); ;}
+    break;
+
+  case 63:
 #line 465 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
+    break;
+
+  case 64:
+#line 467 "perly.y"
     {
 			  ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
 			  (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
-			}
+			;}
     break;
 
-  case 63:
-#line 470 "perly.y"
+  case 65:
+#line 472 "perly.y"
     { PL_parser->copline = (line_t)(ps[(1) - (6)].val.ival);
 			    (yyval.opval) = newCONDOP(0,
 				newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)),
 				op_scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
 			  PL_hints |= HINT_BLOCK_SCOPE;
-			}
+			;}
     break;
 
-  case 64:
-#line 480 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+  case 66:
+#line 482 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 65:
-#line 482 "perly.y"
-    { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); }
+  case 67:
+#line 484 "perly.y"
+    { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 66:
-#line 487 "perly.y"
+  case 68:
+#line 489 "perly.y"
     { (yyval.ival) = (PL_min_intro_pending &&
 			    PL_max_intro_pending >=  PL_min_intro_pending);
-			  intro_my(); }
-    break;
-
-  case 67:
-#line 493 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+			  intro_my(); ;}
     break;
 
   case 69:
-#line 499 "perly.y"
-    { YYSTYPE tmplval;
-			  (void)scan_num("1", &tmplval);
-			  (yyval.opval) = tmplval.opval; }
+#line 495 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 71:
-#line 507 "perly.y"
-    { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); }
-    break;
-
-  case 72:
-#line 512 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); }
+#line 501 "perly.y"
+    { YYSTYPE tmplval;
+			  (void)scan_num("1", &tmplval);
+			  (yyval.opval) = tmplval.opval; ;}
     break;
 
   case 73:
-#line 516 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); }
+#line 509 "perly.y"
+    { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 74:
-#line 520 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); }
+#line 514 "perly.y"
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 75:
-#line 523 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+#line 518 "perly.y"
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 76:
-#line 524 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+#line 522 "perly.y"
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 77:
-#line 528 "perly.y"
-    { (yyval.ival) = start_subparse(FALSE, 0);
-			    SAVEFREESV(PL_compcv); }
+#line 525 "perly.y"
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 78:
-#line 534 "perly.y"
-    { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
-			    SAVEFREESV(PL_compcv); }
+#line 526 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 79:
-#line 539 "perly.y"
-    { (yyval.ival) = start_subparse(TRUE, 0);
-			    SAVEFREESV(PL_compcv); }
+#line 530 "perly.y"
+    { (yyval.ival) = start_subparse(FALSE, 0);
+			    SAVEFREESV(PL_compcv); ;}
     break;
 
-  case 82:
-#line 550 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+  case 80:
+#line 536 "perly.y"
+    { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
+			    SAVEFREESV(PL_compcv); ;}
     break;
 
-  case 84:
-#line 556 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+  case 81:
+#line 541 "perly.y"
+    { (yyval.ival) = start_subparse(TRUE, 0);
+			    SAVEFREESV(PL_compcv); ;}
     break;
 
-  case 85:
-#line 558 "perly.y"
-    { (yyval.opval) = (ps[(2) - (2)].val.opval); }
+  case 84:
+#line 552 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 86:
-#line 560 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+#line 558 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 87:
-#line 565 "perly.y"
-    { (yyval.opval) = (ps[(2) - (2)].val.opval); }
+#line 560 "perly.y"
+    { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
     break;
 
   case 88:
-#line 567 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+#line 562 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 89:
-#line 571 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+#line 567 "perly.y"
+    { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
     break;
 
   case 90:
+#line 569 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
+    break;
+
+  case 91:
 #line 573 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
+    break;
+
+  case 92:
+#line 575 "perly.y"
     {
 			  if (!FEATURE_SIGNATURES_IS_ENABLED)
 			    Perl_croak(aTHX_ "Experimental "
@@ -637,342 +645,340 @@ case 2:
 				packWARN(WARN_EXPERIMENTAL__SIGNATURES),
 				"The signatures feature is experimental");
 			  (yyval.opval) = parse_subsignature();
-			}
+			;}
     break;
 
-  case 91:
-#line 583 "perly.y"
+  case 93:
+#line 585 "perly.y"
     {
 			  (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(2) - (3)].val.opval),
 				newSTATEOP(0, NULL, sawparens(newNULLLIST())));
 			  PL_parser->expect = XBLOCK;
-			}
+			;}
     break;
 
-  case 92:
-#line 592 "perly.y"
+  case 94:
+#line 594 "perly.y"
     {
 			  if (PL_parser->copline > (line_t)(ps[(3) - (5)].val.ival))
 			      PL_parser->copline = (line_t)(ps[(3) - (5)].val.ival);
 			  (yyval.opval) = block_end((ps[(1) - (5)].val.ival),
 				op_append_list(OP_LINESEQ, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)));
-			}
+			;}
     break;
 
-  case 93:
-#line 601 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+  case 95:
+#line 603 "perly.y"
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 94:
-#line 602 "perly.y"
-    { (yyval.opval) = (OP*)NULL;
-			  PL_parser->expect = XSTATE;
-			}
+  case 96:
+#line 604 "perly.y"
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 95:
+  case 97:
 #line 609 "perly.y"
-    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 96:
+  case 98:
 #line 611 "perly.y"
-    { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 97:
+  case 99:
 #line 613 "perly.y"
-    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 99:
+  case 101:
 #line 619 "perly.y"
-    { (yyval.opval) = (ps[(1) - (2)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (2)].val.opval); ;}
     break;
 
-  case 100:
+  case 102:
 #line 621 "perly.y"
     { 
 			  OP* term = (ps[(3) - (3)].val.opval);
 			  (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
-			}
+			;}
     break;
 
-  case 102:
+  case 104:
 #line 630 "perly.y"
     { (yyval.opval) = convert((ps[(1) - (3)].val.ival), OPf_STACKED,
 				op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (3)].val.ival),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
-			}
+			;}
     break;
 
-  case 103:
+  case 105:
 #line 634 "perly.y"
     { (yyval.opval) = convert((ps[(1) - (5)].val.ival), OPf_STACKED,
 				op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (5)].val.ival),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
-			}
+			;}
     break;
 
-  case 104:
+  case 106:
 #line 638 "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)),
 				    newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
-			}
+			;}
     break;
 
-  case 105:
+  case 107:
 #line 644 "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))));
-			}
+			;}
     break;
 
-  case 106:
+  case 108:
 #line 649 "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)),
 				    newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
-			}
+			;}
     break;
 
-  case 107:
+  case 109:
 #line 655 "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)),
 				    newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
-			}
+			;}
     break;
 
-  case 108:
+  case 110:
 #line 661 "perly.y"
-    { (yyval.opval) = convert((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = convert((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 109:
+  case 111:
 #line 663 "perly.y"
-    { (yyval.opval) = convert((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); }
+    { (yyval.opval) = convert((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
     break;
 
-  case 110:
+  case 112:
 #line 665 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
-			  (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); }
+			  (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 111:
+  case 113:
 #line 668 "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 114:
+  case 116:
 #line 683 "perly.y"
     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
 			    PL_parser->expect = XOPERATOR;
-			}
+			;}
     break;
 
-  case 115:
+  case 117:
 #line 687 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
-			}
+			;}
     break;
 
-  case 116:
+  case 118:
 #line 690 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 					ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
 					scalar((ps[(4) - (5)].val.opval)));
-			}
+			;}
     break;
 
-  case 117:
+  case 119:
 #line 695 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 					ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
 					scalar((ps[(3) - (4)].val.opval)));
-			}
+			;}
     break;
 
-  case 118:
+  case 120:
 #line 700 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
 			    PL_parser->expect = XOPERATOR;
-			}
+			;}
     break;
 
-  case 119:
+  case 121:
 #line 704 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 					ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
 					jmaybe((ps[(4) - (6)].val.opval)));
 			    PL_parser->expect = XOPERATOR;
-			}
+			;}
     break;
 
-  case 120:
+  case 122:
 #line 710 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 					ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
 					jmaybe((ps[(3) - (5)].val.opval)));
 			    PL_parser->expect = XOPERATOR;
-			}
+			;}
     break;
 
-  case 121:
+  case 123:
 #line 716 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-				   newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); }
+				   newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); ;}
     break;
 
-  case 122:
+  case 124:
 #line 719 "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))))); }
+				       newCVREF(0, scalar((ps[(1) - (5)].val.opval))))); ;}
     break;
 
-  case 123:
+  case 125:
 #line 724 "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))))); }
+					       newCVREF(0, scalar((ps[(1) - (4)].val.opval))))); ;}
     break;
 
-  case 124:
+  case 126:
 #line 728 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-				   newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); }
+				   newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); ;}
     break;
 
-  case 125:
+  case 127:
 #line 731 "perly.y"
-    { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); }
+    { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); ;}
     break;
 
-  case 126:
+  case 128:
 #line 733 "perly.y"
-    { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); }
+    { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); ;}
     break;
 
-  case 127:
+  case 129:
 #line 735 "perly.y"
-    { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); }
+    { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); ;}
     break;
 
-  case 128:
+  case 130:
 #line 740 "perly.y"
-    { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 129:
+  case 131:
 #line 742 "perly.y"
-    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 130:
+  case 132:
 #line 744 "perly.y"
     {   if ((ps[(2) - (3)].val.ival) != OP_REPEAT)
 				scalar((ps[(1) - (3)].val.opval));
 			    (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
-			}
+			;}
     break;
 
-  case 131:
+  case 133:
 #line 749 "perly.y"
-    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 132:
+  case 134:
 #line 751 "perly.y"
-    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 133:
+  case 135:
 #line 753 "perly.y"
-    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 134:
+  case 136:
 #line 755 "perly.y"
-    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 135:
+  case 137:
 #line 757 "perly.y"
-    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 136:
+  case 138:
 #line 759 "perly.y"
-    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 137:
+  case 139:
 #line 761 "perly.y"
-    { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
+    { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
     break;
 
-  case 138:
+  case 140:
 #line 763 "perly.y"
-    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 139:
+  case 141:
 #line 765 "perly.y"
-    { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 140:
+  case 142:
 #line 767 "perly.y"
-    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 141:
+  case 143:
 #line 769 "perly.y"
-    { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 142:
+  case 144:
 #line 774 "perly.y"
-    { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); }
+    { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
-  case 143:
+  case 145:
 #line 776 "perly.y"
-    { (yyval.opval) = (ps[(2) - (2)].val.opval); }
+    { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
     break;
 
-  case 144:
+  case 146:
 #line 779 "perly.y"
-    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); }
+    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
-  case 145:
+  case 147:
 #line 781 "perly.y"
-    { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); }
+    { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
-  case 146:
+  case 148:
 #line 783 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
-					op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); }
+					op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); ;}
     break;
 
-  case 147:
+  case 149:
 #line 786 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
-					op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));}
+					op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));;}
     break;
 
-  case 148:
+  case 150:
 #line 789 "perly.y"
     { (yyval.opval) = convert(OP_JOIN, 0,
 				       op_append_elem(
@@ -983,123 +989,123 @@ case 2:
 					)),
 					(ps[(1) - (2)].val.opval)
 				       ));
-			}
+			;}
     break;
 
-  case 149:
+  case 151:
 #line 800 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREINC, 0,
-					op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); }
+					op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); ;}
     break;
 
-  case 150:
+  case 152:
 #line 803 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
-					op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); }
+					op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); ;}
     break;
 
-  case 151:
+  case 153:
 #line 810 "perly.y"
-    { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); }
+    { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); ;}
     break;
 
-  case 152:
+  case 154:
 #line 812 "perly.y"
-    { (yyval.opval) = newANONLIST((OP*)NULL);}
+    { (yyval.opval) = newANONLIST((OP*)NULL);;}
     break;
 
-  case 153:
+  case 155:
 #line 814 "perly.y"
-    { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); }
+    { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); ;}
     break;
 
-  case 154:
+  case 156:
 #line 816 "perly.y"
-    { (yyval.opval) = newANONHASH((OP*)NULL); }
+    { (yyval.opval) = newANONHASH((OP*)NULL); ;}
     break;
 
-  case 155:
+  case 157:
 #line 818 "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)); }
+			  (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
     break;
 
-  case 156:
+  case 158:
 #line 825 "perly.y"
-    { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));}
+    { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));;}
     break;
 
-  case 157:
+  case 159:
 #line 827 "perly.y"
-    { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));}
+    { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));;}
     break;
 
-  case 162:
+  case 164:
 #line 835 "perly.y"
-    { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); }
+    { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
     break;
 
-  case 163:
+  case 165:
 #line 837 "perly.y"
-    { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); }
+    { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); ;}
     break;
 
-  case 164:
+  case 166:
 #line 839 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 165:
+  case 167:
 #line 841 "perly.y"
-    { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); }
+    { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
     break;
 
-  case 166:
+  case 168:
 #line 843 "perly.y"
-    { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); }
+    { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
     break;
 
-  case 167:
+  case 169:
 #line 845 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 168:
+  case 170:
 #line 847 "perly.y"
-    { (yyval.opval) = sawparens(newNULLLIST()); }
+    { (yyval.opval) = sawparens(newNULLLIST()); ;}
     break;
 
-  case 169:
+  case 171:
 #line 849 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 170:
+  case 172:
 #line 851 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 171:
+  case 173:
 #line 853 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 172:
+  case 174:
 #line 855 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 173:
+  case 175:
 #line 857 "perly.y"
-    { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));}
+    { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
     break;
 
-  case 174:
+  case 176:
 #line 859 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 175:
+  case 177:
 #line 861 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
 				newOP(OP_PUSHMARK, 0),
@@ -1109,10 +1115,10 @@ case 2:
 			  if ((yyval.opval) && (ps[(1) - (4)].val.opval))
 			      (yyval.opval)->op_private |=
 				  (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
-			}
+			;}
     break;
 
-  case 176:
+  case 178:
 #line 871 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
 				newOP(OP_PUSHMARK, 0),
@@ -1122,10 +1128,10 @@ case 2:
 			  if ((yyval.opval) && (ps[(1) - (4)].val.opval))
 			      (yyval.opval)->op_private |=
 				  (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
-			}
+			;}
     break;
 
-  case 177:
+  case 179:
 #line 881 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
 				newOP(OP_PUSHMARK, 0),
@@ -1136,10 +1142,10 @@ case 2:
 			      (yyval.opval)->op_private |=
 				  (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
 			    PL_parser->expect = XOPERATOR;
-			}
+			;}
     break;
 
-  case 178:
+  case 180:
 #line 892 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
 				newOP(OP_PUSHMARK, 0),
@@ -1150,156 +1156,156 @@ case 2:
 			      (yyval.opval)->op_private |=
 				  (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
 			    PL_parser->expect = XOPERATOR;
-			}
+			;}
     break;
 
-  case 179:
+  case 181:
 #line 903 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 180:
+  case 182:
 #line 905 "perly.y"
-    { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); }
+    { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
-  case 181:
+  case 183:
 #line 907 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
-			}
+			;}
     break;
 
-  case 182:
+  case 184:
 #line 910 "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))));
-			}
+			;}
     break;
 
-  case 183:
+  case 185:
 #line 915 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 			    op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
-			}
+			;}
     break;
 
-  case 184:
+  case 186:
 #line 919 "perly.y"
-    { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); }
+    { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
-  case 185:
+  case 187:
 #line 921 "perly.y"
-    { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); }
+    { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
-  case 186:
+  case 188:
 #line 923 "perly.y"
-    { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); }
+    { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
-  case 187:
+  case 189:
 #line 925 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
-				       scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); }
+				       scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); ;}
     break;
 
-  case 188:
+  case 190:
 #line 928 "perly.y"
-    { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); }
+    { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); ;}
     break;
 
-  case 189:
+  case 191:
 #line 930 "perly.y"
     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), OPf_SPECIAL);
-			    PL_hints |= HINT_BLOCK_SCOPE; }
+			    PL_hints |= HINT_BLOCK_SCOPE; ;}
     break;
 
-  case 190:
+  case 192:
 #line 933 "perly.y"
-    { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 191:
+  case 193:
 #line 935 "perly.y"
-    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); }
+    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
     break;
 
-  case 192:
+  case 194:
 #line 937 "perly.y"
-    { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); }
+    { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
     break;
 
-  case 193:
+  case 195:
 #line 939 "perly.y"
-    { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 194:
+  case 196:
 #line 941 "perly.y"
-    { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 195:
+  case 197:
 #line 943 "perly.y"
-    { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); }
+    { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); ;}
     break;
 
-  case 196:
+  case 198:
 #line 945 "perly.y"
-    { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 197:
+  case 199:
 #line 947 "perly.y"
-    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); }
+    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
-  case 198:
+  case 200:
 #line 949 "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)))); }
+			    op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
     break;
 
-  case 199:
+  case 201:
 #line 952 "perly.y"
-    { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); }
+    { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
     break;
 
-  case 200:
+  case 202:
 #line 954 "perly.y"
-    { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);}
+    { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);;}
     break;
 
-  case 201:
+  case 203:
 #line 956 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 202:
+  case 204:
 #line 958 "perly.y"
-    { (yyval.opval) = (ps[(1) - (3)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (3)].val.opval); ;}
     break;
 
-  case 203:
+  case 205:
 #line 960 "perly.y"
-    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); }
+    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
-  case 204:
+  case 206:
 #line 962 "perly.y"
     { (yyval.opval) = ((ps[(1) - (3)].val.ival) == OP_NOT)
                           ? newUNOP((ps[(1) - (3)].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
-                          : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); }
+                          : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); ;}
     break;
 
-  case 205:
+  case 207:
 #line 966 "perly.y"
-    { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); }
+    { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
     break;
 
-  case 206:
+  case 208:
 #line 968 "perly.y"
     {
 			    if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
@@ -1310,160 +1316,163 @@ case 2:
 				SAVEFREESV(PL_compcv);
 			    } else
 				(yyval.ival) = 0;
-			}
+			;}
     break;
 
-  case 207:
+  case 209:
 #line 979 "perly.y"
-    { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); }
+    { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); ;}
     break;
 
-  case 210:
+  case 212:
 #line 983 "perly.y"
     {
 			  (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
 				newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
-			}
+			;}
     break;
 
-  case 212:
+  case 214:
 #line 992 "perly.y"
-    { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); }
+    { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); ;}
     break;
 
-  case 213:
+  case 215:
 #line 994 "perly.y"
-    { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); }
+    { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
     break;
 
-  case 214:
+  case 216:
 #line 999 "perly.y"
-    { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); }
+    { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
     break;
 
-  case 215:
+  case 217:
 #line 1001 "perly.y"
-    { (yyval.opval) = sawparens(newNULLLIST()); }
+    { (yyval.opval) = sawparens(newNULLLIST()); ;}
     break;
 
-  case 216:
+  case 218:
 #line 1004 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 217:
+  case 219:
 #line 1006 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 218:
+  case 220:
 #line 1008 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 219:
+  case 221:
 #line 1013 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 220:
+  case 222:
 #line 1015 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 221:
+  case 223:
 #line 1019 "perly.y"
-    { (yyval.opval) = (OP*)NULL; }
+    { (yyval.opval) = (OP*)NULL; ;}
     break;
 
-  case 222:
+  case 224:
 #line 1021 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
-  case 223:
+  case 225:
 #line 1027 "perly.y"
-    { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); }
+    { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 224:
+  case 226:
 #line 1031 "perly.y"
-    { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 225:
+  case 227:
 #line 1035 "perly.y"
-    { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 226:
+  case 228:
 #line 1039 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
 			  if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
-			}
+			;}
     break;
 
-  case 227:
+  case 229:
 #line 1045 "perly.y"
     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
 			  if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
-			}
+			;}
     break;
 
-  case 228:
+  case 230:
 #line 1051 "perly.y"
-    { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 229:
+  case 231:
 #line 1053 "perly.y"
-    { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); }
+    { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
     break;
 
-  case 230:
+  case 232:
 #line 1057 "perly.y"
-    { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); }
+    { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); ;}
     break;
 
-  case 232:
+  case 234:
 #line 1062 "perly.y"
-    { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); }
+    { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); ;}
     break;
 
-  case 234:
+  case 236:
 #line 1067 "perly.y"
-    { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); }
+    { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); ;}
     break;
 
-  case 236:
+  case 238:
 #line 1072 "perly.y"
-    { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); }
+    { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); ;}
     break;
 
-  case 237:
+  case 239:
 #line 1077 "perly.y"
-    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); }
+    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 238:
+  case 240:
 #line 1079 "perly.y"
-    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); }
+    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 239:
+  case 241:
 #line 1081 "perly.y"
-    { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); }
+    { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
     break;
 
-  case 240:
+  case 242:
 #line 1084 "perly.y"
-    { (yyval.opval) = (ps[(1) - (1)].val.opval); }
+    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
+
+/* Line 1267 of yacc.c.  */
+
       default: break;
     
 
 /* Generated from:
- * 7e6c275bbd1dbc800c205a8a8b0cd785e4859f94976ee7372149598471f16f81 perly.y
+ * e89acf986fa79bb74d827a4fd4823d07ff25bd99c2087cf4e7a7e6ae41d7a246 perly.y
  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
  * ex: set ro: */