From 885f144454e4ed8faad377f0ccc816383e9930ba Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Thu, 23 Jan 2025 14:16:12 +0000 Subject: [PATCH 1/3] Comment the line responsible for parsing `my sub` so it's slightly easier to find by grep et.al. --- toke.c | 1 + 1 file changed, 1 insertion(+) diff --git a/toke.c b/toke.c index 9c035755507d..3b6ea05150f4 100644 --- a/toke.c +++ b/toke.c @@ -7191,6 +7191,7 @@ yyl_my(pTHX_ char *s, I32 my) STRLEN len; s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, TRUE, &len); if (memEQs(PL_tokenbuf, len, "sub")) + /* my sub ... */ return yyl_sub(aTHX_ s, my); PL_in_my_stash = find_in_my_stash(PL_tokenbuf, len); if (!PL_in_my_stash) { From 3047c615671c2a919e4c9176a6220455aa5f8c20 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Thu, 23 Jan 2025 14:22:13 +0000 Subject: [PATCH 2/3] Allow `my method` syntax --- pod/perlclass.pod | 20 ++++++++++++++++++++ pod/perldelta.pod | 6 ++++++ t/class/method.t | 14 ++++++++++++++ toke.c | 3 +++ 4 files changed, 43 insertions(+) diff --git a/pod/perlclass.pod b/pod/perlclass.pod index be67f5622784..aa69f9b2bb27 100644 --- a/pod/perlclass.pod +++ b/pod/perlclass.pod @@ -185,6 +185,26 @@ Just like regular subroutines, methods I be anonymous: } } +Methods can also be declared as lexical subroutines, using the C prefix. +This creates a subroutine that is lexically visible within the current scope, +but does not appear in the symbol table. The effect is that of a I +method; one that can be called from within the class's own code, but not from +outside. + +At present, there is no special syntax for invoking a lexical method, so for +now they must be called as if they are regular (lexical) subroutines, +remembering to pass the C<$self> invocant as the first positional argument. + + class LexicalMethod { + my method abc ($x, $y) { + say "Internal method abc invoked with x=$x y=$y"; + } + + method xyz { + abc($self, "x", "y"); + } + } + =head1 ATTRIBUTES Specific aspects of the keywords mentioned above are managed using diff --git a/pod/perldelta.pod b/pod/perldelta.pod index 3421b8f51fa1..5309b76b8a79 100644 --- a/pod/perldelta.pod +++ b/pod/perldelta.pod @@ -27,6 +27,12 @@ here, but most should go in the L section. [ List each enhancement as a =head2 entry ] +=head2 Lexical method syntax using C + +Like C since Perl version 5.18, C can now be prefixed with the +C keyword. This declares a subroutine that has lexical, rather than +package visibility. See L for more detail. + =head1 Security XXX Any security-related notices go here. In particular, any security diff --git a/t/class/method.t b/t/class/method.t index 825347f6a674..f655fc41d1eb 100644 --- a/t/class/method.t +++ b/t/class/method.t @@ -89,4 +89,18 @@ no warnings 'experimental::class'; is(Testcase6->new->forwarded, "OK", 'forward-declared method works'); } +# methods can be declared lexically +{ + class Testcase7 { + my method priv { + return "private-result"; + } + + method m { return priv($self); } + } + + is(Testcase7->new->m, "private-result", 'lexical method can be declared and called'); + ok(!Testcase7->can("priv"), 'lexical method does not appear in the symbol table'); +} + done_testing; diff --git a/toke.c b/toke.c index 3b6ea05150f4..4c9067198e92 100644 --- a/toke.c +++ b/toke.c @@ -7193,6 +7193,9 @@ yyl_my(pTHX_ char *s, I32 my) if (memEQs(PL_tokenbuf, len, "sub")) /* my sub ... */ return yyl_sub(aTHX_ s, my); + if (memEQs(PL_tokenbuf, len, "method")) + /* my method ... */ + return yyl_sub(aTHX_ s, KEY_method); PL_in_my_stash = find_in_my_stash(PL_tokenbuf, len); if (!PL_in_my_stash) { char tmpbuf[1024]; From 43bee5b51bb1a5481567514311e35b203e3208fd Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Fri, 7 Feb 2025 13:34:24 +0000 Subject: [PATCH 3/3] Support lexical method invocation syntax of ->& (PPC0033) --- perly.act | 636 +++++++++--------- perly.h | 2 +- perly.tab | 1632 ++++++++++++++++++++++----------------------- perly.y | 12 + pod/perlclass.pod | 10 +- pod/perldelta.pod | 11 +- pod/perlop.pod | 6 + t/class/method.t | 31 + toke.c | 2 + 9 files changed, 1212 insertions(+), 1130 deletions(-) diff --git a/perly.act b/perly.act index 7b680fabf3f9..957e0e15e643 100644 --- a/perly.act +++ b/perly.act @@ -1159,8 +1159,28 @@ case 2: /* @1: %empty */ break; - case 157: /* listop: METHCALL0 indirob optlistexpr */ + case 157: /* listop: term ARROW PERLY_AMPERSAND subname PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ #line 1010 "perly.y" + { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED, + op_append_elem(OP_LIST, + op_prepend_elem(OP_LIST, scalar((ps[-6].val.opval)), (ps[-1].val.opval)), + newCVREF(0, (ps[-3].val.opval)))); + } + + break; + + case 158: /* listop: term ARROW PERLY_AMPERSAND subname */ +#line 1016 "perly.y" + { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED, + op_append_elem(OP_LIST, + scalar((ps[-3].val.opval)), + newCVREF(0, (ps[0].val.opval)))); + } + + break; + + case 159: /* listop: METHCALL0 indirob optlistexpr */ +#line 1022 "perly.y" { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), @@ -1169,8 +1189,8 @@ case 2: /* @1: %empty */ break; - case 158: /* listop: METHCALL indirob PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ -#line 1016 "perly.y" + case 160: /* listop: METHCALL indirob PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ +#line 1028 "perly.y" { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)), @@ -1179,26 +1199,26 @@ case 2: /* @1: %empty */ break; - case 159: /* listop: LSTOP optlistexpr */ -#line 1022 "perly.y" + case 161: /* listop: LSTOP optlistexpr */ +#line 1034 "perly.y" { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); } break; - case 160: /* listop: FUNC PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ -#line 1024 "perly.y" + case 162: /* listop: FUNC PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ +#line 1036 "perly.y" { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); } break; - case 161: /* listop: FUNC SUBLEXSTART optexpr SUBLEXEND */ -#line 1026 "perly.y" + case 163: /* listop: FUNC SUBLEXSTART optexpr SUBLEXEND */ +#line 1038 "perly.y" { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); } break; - case 162: /* @22: %empty */ -#line 1028 "perly.y" + case 164: /* @22: %empty */ +#line 1040 "perly.y" { SvREFCNT_inc_simple_void(PL_compcv); (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); /* prevent double op_free() if the following fails to parse */ @@ -1207,8 +1227,8 @@ case 2: /* @1: %empty */ break; - case 163: /* listop: LSTOPSUB startanonsub block @22 optlistexpr */ -#line 1034 "perly.y" + case 165: /* listop: LSTOPSUB startanonsub block @22 optlistexpr */ +#line 1046 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval))); @@ -1216,21 +1236,21 @@ case 2: /* @1: %empty */ break; - case 166: /* subscripted: gelem PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1049 "perly.y" + case 168: /* subscripted: gelem PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1061 "perly.y" { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); } break; - case 167: /* subscripted: scalar PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1051 "perly.y" + case 169: /* subscripted: scalar PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1063 "perly.y" { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval))); } break; - case 168: /* subscripted: term ARROW PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1054 "perly.y" + case 170: /* subscripted: term ARROW PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1066 "perly.y" { (yyval.opval) = newBINOP(OP_AELEM, 0, ref(newAVREF((ps[-4].val.opval)),OP_RV2AV), scalar((ps[-1].val.opval))); @@ -1238,8 +1258,8 @@ case 2: /* @1: %empty */ break; - case 169: /* subscripted: subscripted PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1059 "perly.y" + case 171: /* subscripted: subscripted PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1071 "perly.y" { (yyval.opval) = newBINOP(OP_AELEM, 0, ref(newAVREF((ps[-3].val.opval)),OP_RV2AV), scalar((ps[-1].val.opval))); @@ -1247,31 +1267,31 @@ case 2: /* @1: %empty */ break; - case 170: /* subscripted: scalar PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1064 "perly.y" + case 172: /* subscripted: scalar PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1076 "perly.y" { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval))); } break; - case 171: /* subscripted: term ARROW PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1067 "perly.y" + case 173: /* subscripted: term ARROW PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1079 "perly.y" { (yyval.opval) = newBINOP(OP_HELEM, 0, ref(newHVREF((ps[-5].val.opval)),OP_RV2HV), jmaybe((ps[-2].val.opval))); } break; - case 172: /* subscripted: subscripted PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1071 "perly.y" + case 174: /* subscripted: subscripted PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1083 "perly.y" { (yyval.opval) = newBINOP(OP_HELEM, 0, ref(newHVREF((ps[-4].val.opval)),OP_RV2HV), jmaybe((ps[-2].val.opval))); } break; - case 173: /* subscripted: term ARROW PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1075 "perly.y" + case 175: /* subscripted: term ARROW PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1087 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, newCVREF(0, scalar((ps[-3].val.opval)))); if (parser->expect == XBLOCK) @@ -1280,8 +1300,8 @@ case 2: /* @1: %empty */ break; - case 174: /* subscripted: term ARROW PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1081 "perly.y" + case 176: /* subscripted: term ARROW PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1093 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, (ps[-1].val.opval), newCVREF(0, scalar((ps[-4].val.opval))))); @@ -1291,8 +1311,8 @@ case 2: /* @1: %empty */ break; - case 175: /* subscripted: subscripted PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1089 "perly.y" + case 177: /* subscripted: subscripted PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1101 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, (ps[-1].val.opval), newCVREF(0, scalar((ps[-3].val.opval))))); @@ -1302,8 +1322,8 @@ case 2: /* @1: %empty */ break; - case 176: /* subscripted: subscripted PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1096 "perly.y" + case 178: /* subscripted: subscripted PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1108 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, newCVREF(0, scalar((ps[-2].val.opval)))); if (parser->expect == XBLOCK) @@ -1312,56 +1332,56 @@ case 2: /* @1: %empty */ break; - case 177: /* subscripted: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1102 "perly.y" + case 179: /* subscripted: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1114 "perly.y" { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); } break; - case 178: /* subscripted: QWLIST PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1104 "perly.y" + case 180: /* subscripted: QWLIST PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1116 "perly.y" { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); } break; - case 179: /* subscripted: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1106 "perly.y" + case 181: /* subscripted: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1118 "perly.y" { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); } break; - case 180: /* termbinop: term PLUGIN_HIGH_OP term */ -#line 1111 "perly.y" + case 182: /* termbinop: term PLUGIN_HIGH_OP term */ +#line 1123 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 181: /* termbinop: term ASSIGNOP term */ -#line 1113 "perly.y" + case 183: /* termbinop: term ASSIGNOP term */ +#line 1125 "perly.y" { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); } break; - case 182: /* termbinop: term PLUGIN_ASSIGN_OP term */ -#line 1115 "perly.y" + case 184: /* termbinop: term PLUGIN_ASSIGN_OP term */ +#line 1127 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 183: /* termbinop: term POWOP term */ -#line 1117 "perly.y" + case 185: /* termbinop: term POWOP term */ +#line 1129 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 184: /* termbinop: term PLUGIN_POW_OP term */ -#line 1119 "perly.y" + case 186: /* termbinop: term PLUGIN_POW_OP term */ +#line 1131 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 185: /* termbinop: term MULOP term */ -#line 1121 "perly.y" + case 187: /* termbinop: term MULOP term */ +#line 1133 "perly.y" { if ((ps[-1].val.ival) != OP_REPEAT) scalar((ps[-2].val.opval)); (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval))); @@ -1369,220 +1389,220 @@ case 2: /* @1: %empty */ break; - case 186: /* termbinop: term PLUGIN_MUL_OP term */ -#line 1126 "perly.y" + case 188: /* termbinop: term PLUGIN_MUL_OP term */ +#line 1138 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 187: /* termbinop: term ADDOP term */ -#line 1128 "perly.y" + case 189: /* termbinop: term ADDOP term */ +#line 1140 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 188: /* termbinop: term PLUGIN_ADD_OP term */ -#line 1130 "perly.y" + case 190: /* termbinop: term PLUGIN_ADD_OP term */ +#line 1142 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 189: /* termbinop: term SHIFTOP term */ -#line 1132 "perly.y" + case 191: /* termbinop: term SHIFTOP term */ +#line 1144 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 190: /* termbinop: termrelop */ -#line 1134 "perly.y" + case 192: /* termbinop: termrelop */ +#line 1146 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 191: /* termbinop: termeqop */ -#line 1136 "perly.y" + case 193: /* termbinop: termeqop */ +#line 1148 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 192: /* termbinop: term BITANDOP term */ -#line 1138 "perly.y" + case 194: /* termbinop: term BITANDOP term */ +#line 1150 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 193: /* termbinop: term BITOROP term */ -#line 1140 "perly.y" + case 195: /* termbinop: term BITOROP term */ +#line 1152 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 194: /* termbinop: term DOTDOT term */ -#line 1142 "perly.y" + case 196: /* termbinop: term DOTDOT term */ +#line 1154 "perly.y" { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 195: /* termbinop: term ANDAND term */ -#line 1144 "perly.y" + case 197: /* termbinop: term ANDAND term */ +#line 1156 "perly.y" { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 196: /* termbinop: term PLUGIN_LOGICAL_AND_OP term */ -#line 1146 "perly.y" + case 198: /* termbinop: term PLUGIN_LOGICAL_AND_OP term */ +#line 1158 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 197: /* termbinop: term OROR term */ -#line 1148 "perly.y" + case 199: /* termbinop: term OROR term */ +#line 1160 "perly.y" { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 198: /* termbinop: term PLUGIN_LOGICAL_OR_OP term */ -#line 1150 "perly.y" + case 200: /* termbinop: term PLUGIN_LOGICAL_OR_OP term */ +#line 1162 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 199: /* termbinop: term DORDOR term */ -#line 1152 "perly.y" + case 201: /* termbinop: term DORDOR term */ +#line 1164 "perly.y" { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 200: /* termbinop: term MATCHOP term */ -#line 1154 "perly.y" + case 202: /* termbinop: term MATCHOP term */ +#line 1166 "perly.y" { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 201: /* termbinop: term PLUGIN_LOW_OP term */ -#line 1156 "perly.y" + case 203: /* termbinop: term PLUGIN_LOW_OP term */ +#line 1168 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 202: /* termrelop: relopchain */ -#line 1160 "perly.y" + case 204: /* termrelop: relopchain */ +#line 1172 "perly.y" { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); } break; - case 203: /* termrelop: term NCRELOP term */ -#line 1162 "perly.y" + case 205: /* termrelop: term NCRELOP term */ +#line 1174 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 204: /* termrelop: termrelop NCRELOP */ -#line 1164 "perly.y" + case 206: /* termrelop: termrelop NCRELOP */ +#line 1176 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 205: /* termrelop: termrelop CHRELOP */ -#line 1166 "perly.y" + case 207: /* termrelop: termrelop CHRELOP */ +#line 1178 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 206: /* termrelop: term PLUGIN_REL_OP term */ -#line 1168 "perly.y" + case 208: /* termrelop: term PLUGIN_REL_OP term */ +#line 1180 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 207: /* relopchain: term CHRELOP term */ -#line 1172 "perly.y" + case 209: /* relopchain: term CHRELOP term */ +#line 1184 "perly.y" { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 208: /* relopchain: relopchain CHRELOP term */ -#line 1174 "perly.y" + case 210: /* relopchain: relopchain CHRELOP term */ +#line 1186 "perly.y" { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 209: /* termeqop: eqopchain */ -#line 1178 "perly.y" + case 211: /* termeqop: eqopchain */ +#line 1190 "perly.y" { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); } break; - case 210: /* termeqop: term NCEQOP term */ -#line 1180 "perly.y" + case 212: /* termeqop: term NCEQOP term */ +#line 1192 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 211: /* termeqop: termeqop NCEQOP */ -#line 1182 "perly.y" + case 213: /* termeqop: termeqop NCEQOP */ +#line 1194 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 212: /* termeqop: termeqop CHEQOP */ -#line 1184 "perly.y" + case 214: /* termeqop: termeqop CHEQOP */ +#line 1196 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 213: /* eqopchain: term CHEQOP term */ -#line 1188 "perly.y" + case 215: /* eqopchain: term CHEQOP term */ +#line 1200 "perly.y" { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 214: /* eqopchain: eqopchain CHEQOP term */ -#line 1190 "perly.y" + case 216: /* eqopchain: eqopchain CHEQOP term */ +#line 1202 "perly.y" { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 215: /* termunop: PERLY_MINUS term */ -#line 1195 "perly.y" + case 217: /* termunop: PERLY_MINUS term */ +#line 1207 "perly.y" { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); } break; - case 216: /* termunop: PERLY_PLUS term */ -#line 1197 "perly.y" + case 218: /* termunop: PERLY_PLUS term */ +#line 1209 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 217: /* termunop: PERLY_EXCLAMATION_MARK term */ -#line 1200 "perly.y" + case 219: /* termunop: PERLY_EXCLAMATION_MARK term */ +#line 1212 "perly.y" { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); } break; - case 218: /* termunop: PERLY_TILDE term */ -#line 1202 "perly.y" + case 220: /* termunop: PERLY_TILDE term */ +#line 1214 "perly.y" { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); } break; - case 219: /* termunop: term POSTINC */ -#line 1204 "perly.y" + case 221: /* termunop: term POSTINC */ +#line 1216 "perly.y" { (yyval.opval) = newUNOP(OP_POSTINC, 0, op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); } break; - case 220: /* termunop: term POSTDEC */ -#line 1207 "perly.y" + case 222: /* termunop: term POSTDEC */ +#line 1219 "perly.y" { (yyval.opval) = newUNOP(OP_POSTDEC, 0, op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));} break; - case 221: /* termunop: term POSTJOIN */ -#line 1210 "perly.y" + case 223: /* termunop: term POSTJOIN */ +#line 1222 "perly.y" { (yyval.opval) = op_convert_list(OP_JOIN, 0, op_append_elem( OP_LIST, @@ -1596,48 +1616,48 @@ case 2: /* @1: %empty */ break; - case 222: /* termunop: PREINC term */ -#line 1221 "perly.y" + case 224: /* termunop: PREINC term */ +#line 1233 "perly.y" { (yyval.opval) = newUNOP(OP_PREINC, 0, op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); } break; - case 223: /* termunop: PREDEC term */ -#line 1224 "perly.y" + case 225: /* termunop: PREDEC term */ +#line 1236 "perly.y" { (yyval.opval) = newUNOP(OP_PREDEC, 0, op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); } break; - case 224: /* anonymous: PERLY_BRACKET_OPEN optexpr PERLY_BRACKET_CLOSE */ -#line 1232 "perly.y" + case 226: /* anonymous: PERLY_BRACKET_OPEN optexpr PERLY_BRACKET_CLOSE */ +#line 1244 "perly.y" { (yyval.opval) = newANONLIST((ps[-1].val.opval)); } break; - case 225: /* anonymous: HASHBRACK optexpr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1234 "perly.y" + case 227: /* anonymous: HASHBRACK optexpr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1246 "perly.y" { (yyval.opval) = newANONHASH((ps[-2].val.opval)); } break; - case 226: /* anonymous: KW_SUB_anon startanonsub proto subattrlist subbody */ -#line 1236 "perly.y" + case 228: /* anonymous: KW_SUB_anon startanonsub proto subattrlist subbody */ +#line 1248 "perly.y" { SvREFCNT_inc_simple_void(PL_compcv); (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); } break; - case 227: /* anonymous: KW_SUB_anon_sig startanonsub subattrlist sigsubbody */ -#line 1239 "perly.y" + case 229: /* anonymous: KW_SUB_anon_sig startanonsub subattrlist sigsubbody */ +#line 1251 "perly.y" { SvREFCNT_inc_simple_void(PL_compcv); (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); } break; - case 228: /* anonymous: KW_METHOD_anon startanonmethod subattrlist sigsubbody */ -#line 1242 "perly.y" + case 230: /* anonymous: KW_METHOD_anon startanonmethod subattrlist sigsubbody */ +#line 1254 "perly.y" { SvREFCNT_inc_simple_void(PL_compcv); (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); @@ -1645,98 +1665,98 @@ case 2: /* @1: %empty */ break; - case 229: /* termdo: KW_DO term */ -#line 1250 "perly.y" + case 231: /* termdo: KW_DO term */ +#line 1262 "perly.y" { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));} break; - case 230: /* termdo: KW_DO block */ -#line 1252 "perly.y" + case 232: /* termdo: KW_DO block */ +#line 1264 "perly.y" { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));} break; - case 235: /* term: term PERLY_QUESTION_MARK term PERLY_COLON term */ -#line 1260 "perly.y" + case 237: /* term: term PERLY_QUESTION_MARK term PERLY_COLON term */ +#line 1272 "perly.y" { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 236: /* term: REFGEN term */ -#line 1262 "perly.y" + case 238: /* term: REFGEN term */ +#line 1274 "perly.y" { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); } break; - case 237: /* term: myattrterm */ -#line 1264 "perly.y" + case 239: /* term: myattrterm */ +#line 1276 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 238: /* term: KW_LOCAL term */ -#line 1266 "perly.y" + case 240: /* term: KW_LOCAL term */ +#line 1278 "perly.y" { (yyval.opval) = localize((ps[0].val.opval),0); } break; - case 239: /* term: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1268 "perly.y" + case 241: /* term: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1280 "perly.y" { (yyval.opval) = sawparens((ps[-1].val.opval)); } break; - case 240: /* term: QWLIST */ -#line 1270 "perly.y" + case 242: /* term: QWLIST */ +#line 1282 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 241: /* term: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1272 "perly.y" + case 243: /* term: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1284 "perly.y" { (yyval.opval) = sawparens(newNULLLIST()); } break; - case 242: /* term: scalar */ -#line 1274 "perly.y" + case 244: /* term: scalar */ +#line 1286 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 243: /* term: star */ -#line 1276 "perly.y" + case 245: /* term: star */ +#line 1288 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 244: /* term: hsh */ -#line 1278 "perly.y" + case 246: /* term: hsh */ +#line 1290 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 245: /* term: ary */ -#line 1280 "perly.y" + case 247: /* term: ary */ +#line 1292 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 246: /* term: arylen */ -#line 1282 "perly.y" + case 248: /* term: arylen */ +#line 1294 "perly.y" { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));} break; - case 247: /* term: subscripted */ -#line 1284 "perly.y" + case 249: /* term: subscripted */ +#line 1296 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 248: /* term: sliceme PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1286 "perly.y" + case 250: /* term: sliceme PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1298 "perly.y" { (yyval.opval) = op_prepend_elem(OP_ASLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_ASLICE, 0, @@ -1749,8 +1769,8 @@ case 2: /* @1: %empty */ break; - case 249: /* term: kvslice PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1296 "perly.y" + case 251: /* term: kvslice PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1308 "perly.y" { (yyval.opval) = op_prepend_elem(OP_KVASLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_KVASLICE, 0, @@ -1763,8 +1783,8 @@ case 2: /* @1: %empty */ break; - case 250: /* term: sliceme PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1306 "perly.y" + case 252: /* term: sliceme PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1318 "perly.y" { (yyval.opval) = op_prepend_elem(OP_HSLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_HSLICE, 0, @@ -1777,8 +1797,8 @@ case 2: /* @1: %empty */ break; - case 251: /* term: kvslice PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1316 "perly.y" + case 253: /* term: kvslice PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1328 "perly.y" { (yyval.opval) = op_prepend_elem(OP_KVHSLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_KVHSLICE, 0, @@ -1791,27 +1811,27 @@ case 2: /* @1: %empty */ break; - case 252: /* term: THING */ -#line 1326 "perly.y" + case 254: /* term: THING */ +#line 1338 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 253: /* term: amper */ -#line 1328 "perly.y" + case 255: /* term: amper */ +#line 1340 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); } break; - case 254: /* term: amper PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1330 "perly.y" + case 256: /* term: amper PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1342 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval))); } break; - case 255: /* term: amper PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1333 "perly.y" + case 257: /* term: amper PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1345 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval)))); @@ -1819,153 +1839,153 @@ case 2: /* @1: %empty */ break; - case 256: /* term: NOAMP subname optlistexpr */ -#line 1338 "perly.y" + case 258: /* term: NOAMP subname optlistexpr */ +#line 1350 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); } break; - case 257: /* term: term ARROW PERLY_DOLLAR PERLY_STAR */ -#line 1342 "perly.y" + case 259: /* term: term ARROW PERLY_DOLLAR PERLY_STAR */ +#line 1354 "perly.y" { (yyval.opval) = newSVREF((ps[-3].val.opval)); } break; - case 258: /* term: term ARROW PERLY_SNAIL PERLY_STAR */ -#line 1344 "perly.y" + case 260: /* term: term ARROW PERLY_SNAIL PERLY_STAR */ +#line 1356 "perly.y" { (yyval.opval) = newAVREF((ps[-3].val.opval)); } break; - case 259: /* term: term ARROW PERLY_PERCENT_SIGN PERLY_STAR */ -#line 1346 "perly.y" + case 261: /* term: term ARROW PERLY_PERCENT_SIGN PERLY_STAR */ +#line 1358 "perly.y" { (yyval.opval) = newHVREF((ps[-3].val.opval)); } break; - case 260: /* term: term ARROW PERLY_AMPERSAND PERLY_STAR */ -#line 1348 "perly.y" + case 262: /* term: term ARROW PERLY_AMPERSAND PERLY_STAR */ +#line 1360 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); } break; - case 261: /* term: term ARROW PERLY_STAR PERLY_STAR */ -#line 1351 "perly.y" + case 263: /* term: term ARROW PERLY_STAR PERLY_STAR */ +#line 1363 "perly.y" { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); } break; - case 262: /* term: LOOPEX */ -#line 1353 "perly.y" + case 264: /* term: LOOPEX */ +#line 1365 "perly.y" { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL); PL_hints |= HINT_BLOCK_SCOPE; } break; - case 263: /* term: LOOPEX term */ -#line 1356 "perly.y" + case 265: /* term: LOOPEX term */ +#line 1368 "perly.y" { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); } break; - case 264: /* term: NOTOP listexpr */ -#line 1358 "perly.y" + case 266: /* term: NOTOP listexpr */ +#line 1370 "perly.y" { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); } break; - case 265: /* term: UNIOP */ -#line 1360 "perly.y" + case 267: /* term: UNIOP */ +#line 1372 "perly.y" { (yyval.opval) = newOP((ps[0].val.ival), 0); } break; - case 266: /* term: UNIOP block */ -#line 1362 "perly.y" + case 268: /* term: UNIOP block */ +#line 1374 "perly.y" { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); } break; - case 267: /* term: UNIOP term */ -#line 1364 "perly.y" + case 269: /* term: UNIOP term */ +#line 1376 "perly.y" { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); } break; - case 268: /* term: KW_REQUIRE */ -#line 1366 "perly.y" + case 270: /* term: KW_REQUIRE */ +#line 1378 "perly.y" { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); } break; - case 269: /* term: KW_REQUIRE term */ -#line 1368 "perly.y" + case 271: /* term: KW_REQUIRE term */ +#line 1380 "perly.y" { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); } break; - case 270: /* term: UNIOPSUB */ -#line 1370 "perly.y" + case 272: /* term: UNIOPSUB */ +#line 1382 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); } break; - case 271: /* term: UNIOPSUB term */ -#line 1372 "perly.y" + case 273: /* term: UNIOPSUB term */ +#line 1384 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); } break; - case 272: /* term: FUNC0 */ -#line 1375 "perly.y" + case 274: /* term: FUNC0 */ +#line 1387 "perly.y" { (yyval.opval) = newOP((ps[0].val.ival), 0); } break; - case 273: /* term: FUNC0 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1377 "perly.y" + case 275: /* term: FUNC0 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1389 "perly.y" { (yyval.opval) = newOP((ps[-2].val.ival), 0);} break; - case 274: /* term: FUNC0OP */ -#line 1379 "perly.y" + case 276: /* term: FUNC0OP */ +#line 1391 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 275: /* term: FUNC0OP PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1381 "perly.y" + case 277: /* term: FUNC0OP PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1393 "perly.y" { (yyval.opval) = (ps[-2].val.opval); } break; - case 276: /* term: FUNC0SUB */ -#line 1383 "perly.y" + case 278: /* term: FUNC0SUB */ +#line 1395 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); } break; - case 277: /* term: FUNC1 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1385 "perly.y" + case 279: /* term: FUNC1 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1397 "perly.y" { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT) ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0))) : newOP((ps[-2].val.ival), OPf_SPECIAL); } break; - case 278: /* term: FUNC1 PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1389 "perly.y" + case 280: /* term: FUNC1 PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1401 "perly.y" { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); } break; - case 279: /* @23: %empty */ -#line 1391 "perly.y" + case 281: /* @23: %empty */ +#line 1403 "perly.y" { if ( (ps[0].val.opval)->op_type != OP_TRANS && (ps[0].val.opval)->op_type != OP_TRANSR @@ -1979,68 +1999,68 @@ case 2: /* @1: %empty */ break; - case 280: /* term: PMFUNC @23 SUBLEXSTART listexpr optrepl SUBLEXEND */ -#line 1402 "perly.y" + case 282: /* term: PMFUNC @23 SUBLEXSTART listexpr optrepl SUBLEXEND */ +#line 1414 "perly.y" { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); } break; - case 284: /* myattrterm: KW_MY myterm myattrlist */ -#line 1411 "perly.y" + case 286: /* myattrterm: KW_MY myterm myattrlist */ +#line 1423 "perly.y" { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); } break; - case 285: /* myattrterm: KW_MY myterm */ -#line 1413 "perly.y" + case 287: /* myattrterm: KW_MY myterm */ +#line 1425 "perly.y" { (yyval.opval) = localize((ps[0].val.opval),1); } break; - case 286: /* myattrterm: KW_MY REFGEN myterm myattrlist */ -#line 1415 "perly.y" + case 288: /* myattrterm: KW_MY REFGEN myterm myattrlist */ +#line 1427 "perly.y" { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); } break; - case 287: /* myattrterm: KW_MY REFGEN term */ -#line 1417 "perly.y" + case 289: /* myattrterm: KW_MY REFGEN term */ +#line 1429 "perly.y" { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); } break; - case 288: /* myterm: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1422 "perly.y" + case 290: /* myterm: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1434 "perly.y" { (yyval.opval) = sawparens((ps[-1].val.opval)); } break; - case 289: /* myterm: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1424 "perly.y" + case 291: /* myterm: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1436 "perly.y" { (yyval.opval) = sawparens(newNULLLIST()); } break; - case 290: /* myterm: scalar */ -#line 1427 "perly.y" + case 292: /* myterm: scalar */ +#line 1439 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 291: /* myterm: hsh */ -#line 1429 "perly.y" + case 293: /* myterm: hsh */ +#line 1441 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 292: /* myterm: ary */ -#line 1431 "perly.y" + case 294: /* myterm: ary */ +#line 1443 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 293: /* fieldvar: scalar */ -#line 1436 "perly.y" + case 295: /* fieldvar: scalar */ +#line 1448 "perly.y" { (yyval.pval) = PadnamelistARRAY(PL_comppad_name)[(ps[0].val.opval)->op_targ]; op_free((ps[0].val.opval)); @@ -2048,8 +2068,8 @@ case 2: /* @1: %empty */ break; - case 294: /* fieldvar: hsh */ -#line 1441 "perly.y" + case 296: /* fieldvar: hsh */ +#line 1453 "perly.y" { (yyval.pval) = PadnamelistARRAY(PL_comppad_name)[(ps[0].val.opval)->op_targ]; op_free((ps[0].val.opval)); @@ -2057,8 +2077,8 @@ case 2: /* @1: %empty */ break; - case 295: /* fieldvar: ary */ -#line 1446 "perly.y" + case 297: /* fieldvar: ary */ +#line 1458 "perly.y" { (yyval.pval) = PadnamelistARRAY(PL_comppad_name)[(ps[0].val.opval)->op_targ]; op_free((ps[0].val.opval)); @@ -2066,20 +2086,20 @@ case 2: /* @1: %empty */ break; - case 296: /* optfieldattrlist: COLONATTR THING */ -#line 1454 "perly.y" + case 298: /* optfieldattrlist: COLONATTR THING */ +#line 1466 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 297: /* optfieldattrlist: COLONATTR */ -#line 1456 "perly.y" + case 299: /* optfieldattrlist: COLONATTR */ +#line 1468 "perly.y" { (yyval.opval) = NULL; } break; - case 299: /* fielddecl: KW_FIELD fieldvar optfieldattrlist */ -#line 1462 "perly.y" + case 301: /* fielddecl: KW_FIELD fieldvar optfieldattrlist */ +#line 1474 "perly.y" { parser->in_my = 0; if((ps[0].val.opval)) @@ -2089,8 +2109,8 @@ case 2: /* @1: %empty */ break; - case 300: /* $@24: %empty */ -#line 1469 "perly.y" + case 302: /* $@24: %empty */ +#line 1481 "perly.y" { parser->in_my = 0; if((ps[-1].val.opval)) @@ -2101,8 +2121,8 @@ case 2: /* @1: %empty */ break; - case 301: /* fielddecl: KW_FIELD fieldvar optfieldattrlist ASSIGNOP $@24 term */ -#line 1477 "perly.y" + case 303: /* fielddecl: KW_FIELD fieldvar optfieldattrlist ASSIGNOP $@24 term */ +#line 1489 "perly.y" { class_set_field_defop((PADNAME *)(ps[-4].val.pval), (ps[-2].val.ival), (ps[0].val.opval)); LEAVE; @@ -2111,122 +2131,122 @@ case 2: /* @1: %empty */ break; - case 307: /* optrepl: PERLY_SLASH expr */ -#line 1497 "perly.y" + case 309: /* optrepl: PERLY_SLASH expr */ +#line 1509 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 308: /* my_scalar: scalar */ -#line 1503 "perly.y" + case 310: /* my_scalar: scalar */ +#line 1515 "perly.y" { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); } break; - case 309: /* list_of_scalars: list_of_scalars PERLY_COMMA */ -#line 1508 "perly.y" + case 311: /* list_of_scalars: list_of_scalars PERLY_COMMA */ +#line 1520 "perly.y" { (yyval.opval) = (ps[-1].val.opval); } break; - case 310: /* list_of_scalars: list_of_scalars PERLY_COMMA scalar */ -#line 1510 "perly.y" + case 312: /* list_of_scalars: list_of_scalars PERLY_COMMA scalar */ +#line 1522 "perly.y" { (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 312: /* my_list_of_scalars: list_of_scalars */ -#line 1517 "perly.y" + case 314: /* my_list_of_scalars: list_of_scalars */ +#line 1529 "perly.y" { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); } break; - case 320: /* amper: PERLY_AMPERSAND indirob */ -#line 1534 "perly.y" + case 322: /* amper: PERLY_AMPERSAND indirob */ +#line 1546 "perly.y" { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); } break; - case 321: /* scalar: PERLY_DOLLAR indirob */ -#line 1538 "perly.y" + case 323: /* scalar: PERLY_DOLLAR indirob */ +#line 1550 "perly.y" { (yyval.opval) = newSVREF((ps[0].val.opval)); } break; - case 322: /* ary: PERLY_SNAIL indirob */ -#line 1542 "perly.y" + case 324: /* ary: PERLY_SNAIL indirob */ +#line 1554 "perly.y" { (yyval.opval) = newAVREF((ps[0].val.opval)); if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival); } break; - case 323: /* hsh: PERLY_PERCENT_SIGN indirob */ -#line 1548 "perly.y" + case 325: /* hsh: PERLY_PERCENT_SIGN indirob */ +#line 1560 "perly.y" { (yyval.opval) = newHVREF((ps[0].val.opval)); if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival); } break; - case 324: /* arylen: DOLSHARP indirob */ -#line 1554 "perly.y" + case 326: /* arylen: DOLSHARP indirob */ +#line 1566 "perly.y" { (yyval.opval) = newAVREF((ps[0].val.opval)); } break; - case 325: /* arylen: term ARROW DOLSHARP PERLY_STAR */ -#line 1556 "perly.y" + case 327: /* arylen: term ARROW DOLSHARP PERLY_STAR */ +#line 1568 "perly.y" { (yyval.opval) = newAVREF((ps[-3].val.opval)); } break; - case 326: /* star: PERLY_STAR indirob */ -#line 1560 "perly.y" + case 328: /* star: PERLY_STAR indirob */ +#line 1572 "perly.y" { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); } break; - case 328: /* sliceme: term ARROW PERLY_SNAIL */ -#line 1565 "perly.y" + case 330: /* sliceme: term ARROW PERLY_SNAIL */ +#line 1577 "perly.y" { (yyval.opval) = newAVREF((ps[-2].val.opval)); } break; - case 330: /* kvslice: term ARROW PERLY_PERCENT_SIGN */ -#line 1570 "perly.y" + case 332: /* kvslice: term ARROW PERLY_PERCENT_SIGN */ +#line 1582 "perly.y" { (yyval.opval) = newHVREF((ps[-2].val.opval)); } break; - case 332: /* gelem: term ARROW PERLY_STAR */ -#line 1575 "perly.y" + case 334: /* gelem: term ARROW PERLY_STAR */ +#line 1587 "perly.y" { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); } break; - case 333: /* indirob: BAREWORD */ -#line 1580 "perly.y" + case 335: /* indirob: BAREWORD */ +#line 1592 "perly.y" { (yyval.opval) = scalar((ps[0].val.opval)); } break; - case 334: /* indirob: scalar */ -#line 1582 "perly.y" + case 336: /* indirob: scalar */ +#line 1594 "perly.y" { (yyval.opval) = scalar((ps[0].val.opval)); } break; - case 335: /* indirob: block */ -#line 1584 "perly.y" + case 337: /* indirob: block */ +#line 1596 "perly.y" { (yyval.opval) = op_scope((ps[0].val.opval)); } break; - case 336: /* indirob: PRIVATEREF */ -#line 1587 "perly.y" + case 338: /* indirob: PRIVATEREF */ +#line 1599 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; @@ -2238,6 +2258,6 @@ case 2: /* @1: %empty */ /* Generated from: - * 59c1b0d8db6eb03422c4aa700803c201837a9c4085a3177364c2eda6cbeb7cc7 perly.y + * 0f40c00aa6e92910072b579304d07e319b034979bfaf4292495c7a23de0bd41a perly.y * f13e9c08cea6302f0c1d1f467405bd0e0880d0ea92d0669901017a7f7e94ab28 regen_perly.pl * ex: set ro ft=c: */ diff --git a/perly.h b/perly.h index 4fd7a4acaf22..ad5130163a19 100644 --- a/perly.h +++ b/perly.h @@ -241,6 +241,6 @@ int yyparse (void); /* Generated from: - * 59c1b0d8db6eb03422c4aa700803c201837a9c4085a3177364c2eda6cbeb7cc7 perly.y + * 0f40c00aa6e92910072b579304d07e319b034979bfaf4292495c7a23de0bd41a perly.y * f13e9c08cea6302f0c1d1f467405bd0e0880d0ea92d0669901017a7f7e94ab28 regen_perly.pl * ex: set ro ft=c: */ diff --git a/perly.tab b/perly.tab index 9d769a2778a8..a749fa3588b7 100644 --- a/perly.tab +++ b/perly.tab @@ -258,16 +258,16 @@ typedef enum yysymbol_kind_t yysymbol_kind_t; #define YYFINAL 16 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 3666 +#define YYLAST 3664 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 129 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 113 /* YYNRULES -- Number of rules. */ -#define YYNRULES 336 +#define YYNRULES 338 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 656 +#define YYNSTATES 660 /* YYMAXUTOK -- Last valid token kind. */ #define YYMAXUTOK 383 @@ -345,24 +345,24 @@ static const yytype_int16 yyrline[] = 879, 880, 885, 886, 890, 894, 894, 927, 928, 933, 945, 946, 951, 950, 963, 965, 967, 969, 971, 975, 977, 982, 986, 990, 994, 998, 1004, 1009, 1015, 1021, - 1023, 1025, 1028, 1027, 1041, 1042, 1046, 1050, 1053, 1058, - 1063, 1066, 1070, 1074, 1080, 1088, 1095, 1101, 1103, 1105, - 1110, 1112, 1114, 1116, 1118, 1120, 1125, 1127, 1129, 1131, - 1133, 1135, 1137, 1139, 1141, 1143, 1145, 1147, 1149, 1151, - 1153, 1155, 1159, 1161, 1163, 1165, 1167, 1171, 1173, 1177, - 1179, 1181, 1183, 1187, 1189, 1194, 1196, 1199, 1201, 1203, - 1206, 1209, 1220, 1223, 1231, 1233, 1235, 1238, 1241, 1249, - 1251, 1255, 1256, 1257, 1258, 1259, 1261, 1263, 1265, 1267, - 1269, 1271, 1273, 1275, 1277, 1279, 1281, 1283, 1285, 1295, - 1305, 1315, 1325, 1327, 1329, 1332, 1337, 1341, 1343, 1345, - 1347, 1350, 1352, 1355, 1357, 1359, 1361, 1363, 1365, 1367, - 1369, 1371, 1374, 1376, 1378, 1380, 1382, 1384, 1388, 1391, - 1390, 1403, 1404, 1405, 1410, 1412, 1414, 1416, 1421, 1423, - 1426, 1428, 1430, 1435, 1440, 1445, 1453, 1455, 1457, 1461, - 1469, 1468, 1486, 1487, 1491, 1492, 1496, 1497, 1502, 1507, - 1509, 1513, 1516, 1520, 1521, 1522, 1525, 1526, 1529, 1530, - 1533, 1537, 1541, 1547, 1553, 1555, 1559, 1563, 1564, 1568, - 1569, 1573, 1574, 1579, 1581, 1583, 1586 + 1027, 1033, 1035, 1037, 1040, 1039, 1053, 1054, 1058, 1062, + 1065, 1070, 1075, 1078, 1082, 1086, 1092, 1100, 1107, 1113, + 1115, 1117, 1122, 1124, 1126, 1128, 1130, 1132, 1137, 1139, + 1141, 1143, 1145, 1147, 1149, 1151, 1153, 1155, 1157, 1159, + 1161, 1163, 1165, 1167, 1171, 1173, 1175, 1177, 1179, 1183, + 1185, 1189, 1191, 1193, 1195, 1199, 1201, 1206, 1208, 1211, + 1213, 1215, 1218, 1221, 1232, 1235, 1243, 1245, 1247, 1250, + 1253, 1261, 1263, 1267, 1268, 1269, 1270, 1271, 1273, 1275, + 1277, 1279, 1281, 1283, 1285, 1287, 1289, 1291, 1293, 1295, + 1297, 1307, 1317, 1327, 1337, 1339, 1341, 1344, 1349, 1353, + 1355, 1357, 1359, 1362, 1364, 1367, 1369, 1371, 1373, 1375, + 1377, 1379, 1381, 1383, 1386, 1388, 1390, 1392, 1394, 1396, + 1400, 1403, 1402, 1415, 1416, 1417, 1422, 1424, 1426, 1428, + 1433, 1435, 1438, 1440, 1442, 1447, 1452, 1457, 1465, 1467, + 1469, 1473, 1481, 1480, 1498, 1499, 1503, 1504, 1508, 1509, + 1514, 1519, 1521, 1525, 1528, 1532, 1533, 1534, 1537, 1538, + 1541, 1542, 1545, 1549, 1553, 1559, 1565, 1567, 1571, 1575, + 1576, 1580, 1581, 1585, 1586, 1591, 1593, 1595, 1598 }; #endif @@ -432,12 +432,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-548) +#define YYPACT_NINF (-536) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-335) +#define YYTABLE_NINF (-337) #define yytable_value_is_error(Yyn) \ ((Yyn) == YYTABLE_NINF) @@ -446,72 +446,72 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 706, -548, -548, -548, -548, -548, -548, -548, 32, -548, - 2994, 25, 1950, 1837, -548, -548, -548, -548, 350, 2994, - 350, 2994, 350, 2994, 350, 350, 2994, 33, 2994, 2274, - -548, -548, -548, -548, 350, 350, -548, -548, 46, -60, - -548, 2994, -548, -548, 2994, -52, -34, -42, 2274, 2194, - 25, 350, 2994, 57, 2994, 2994, 2994, 2994, 2994, 2994, - 2354, -548, 289, 94, -548, 11, -548, -7, 39, 98, - 27, -548, -548, -548, 3184, -548, -548, 12, 82, 143, - 158, -548, 146, 167, 187, 157, -548, -548, -548, -548, - -548, 179, 189, 233, 71, 115, -1, 131, 139, 275, - 275, -548, 57, -548, -548, -548, 265, -548, 57, 250, - -548, 268, 337, 278, 1837, -548, -548, -548, -548, 777, - -548, 390, 890, -548, -548, -548, -548, -548, 283, -548, - 316, -548, 316, -548, -548, 3520, 3074, 2434, 216, -548, - -548, -548, 3520, -548, 3520, 245, 220, 220, 2994, 181, - 227, 2994, 183, 3520, 25, 3184, 200, 2514, 2994, 2194, - -548, 3520, 3154, -548, 94, -548, 2594, 2994, 2994, -548, - 292, -548, -548, 2994, 94, 316, 316, 316, 214, 214, - 315, 361, 2994, 2994, 2994, 2994, 2994, 2994, 2994, 2674, - -548, -548, 2994, -548, -548, 2994, 2994, 2994, 2994, 2994, - 2994, 2994, 2994, 2994, 2994, 2994, 2994, 2994, 2994, 2994, - 2994, 2994, 2994, 2994, 2994, 2994, 2994, 2994, 2994, 2994, - 2994, -548, -548, -548, 2994, 53, 2754, 2994, 2994, 2994, - 2994, 2994, 2994, 2994, -548, 298, 300, 302, 247, -548, - -548, -548, -548, -548, 213, 541, -548, -548, 235, -548, - -548, -548, 323, -548, -548, -548, -548, -548, -548, 25, - -548, -548, -548, 2994, 2994, 2994, 2994, 2994, -548, -548, - -548, -548, 307, -548, -548, -548, 307, -548, -548, -548, - 352, -548, -548, 2834, 316, 216, 49, 70, 76, -548, - 384, 312, -548, -548, -548, 220, 314, -548, -548, -548, - -548, 2994, 2994, 74, -548, -548, -548, -548, 407, 301, - 251, 2994, 94, 94, 372, -548, 2994, 378, 96, 96, - -548, -548, 3288, 124, 92, -548, 431, 394, 3481, 3340, - 316, 276, 342, 3236, 3288, 3288, 926, 3379, 3379, 3379, - 3402, 3402, 3441, 3462, 3481, 3481, 394, 394, 3501, 3540, - 342, 276, 316, 316, 0, 368, 2994, 2994, 288, 371, - 380, 386, -548, 387, 2914, 287, -548, -548, 435, 180, - 100, 225, 104, 242, 116, 252, 1046, -548, -548, 405, - 50, 220, 369, -548, 331, 2994, 2994, -548, -12, -548, - -548, 303, -548, -548, -548, -548, 2032, 233, -548, 2994, - 2994, -548, -548, 379, -548, 411, -548, -548, -548, 289, - -548, -548, -548, 289, -548, -548, 339, 341, 390, 14, - 562, -548, -548, -548, -548, -548, 317, -548, -548, 319, - 77, -548, 2994, -548, -548, -548, 609, -548, 120, 2994, - 436, -548, -548, 2994, -548, 257, 129, -548, -548, -548, - -548, -548, -548, 613, 2994, -548, 446, -548, 447, -548, - 448, -548, 450, -548, -548, -548, -548, -548, 69, -548, - -548, 320, 289, 336, 453, 345, -548, -548, -548, -548, - -548, 354, 462, 203, -548, 2994, 359, 363, 289, 1159, - 366, 438, 245, -548, 484, -548, -548, 220, 2994, 2994, - -548, 62, -548, -548, -548, 490, -548, -548, 2994, -548, - 416, -548, -548, -548, 215, -548, 572, 497, -548, -548, - 385, -548, -548, -548, -548, 492, -548, -548, -548, 2994, - 275, 275, 500, 402, -548, 2994, 2994, 275, -548, 403, - 408, -548, -548, -548, -548, -548, -548, 2994, 220, -548, - 508, 3184, 3184, 409, -548, 289, -548, -548, -548, -548, - 455, -548, -548, 3184, 193, 193, 453, 413, 415, 421, - 250, 2994, 2994, 275, 275, 275, 453, 275, 530, 411, - 1272, -548, -548, -548, -548, -548, -548, 1385, -548, 275, - 425, -548, -548, -548, -548, 2994, 275, 275, -548, 534, - 432, 250, 250, 250, -548, 521, -548, -548, -548, 1498, - -548, 26, -548, 1611, -548, 2994, 437, 250, 250, -548, - 275, -548, -548, -548, 439, 25, -548, -548, 550, 485, - -548, -548, 443, 275, -548, -548, -548, 250, -548, -548, - -548, -548, -548, -548, 275, 250, 2114, -548, 1724, 193, - -548, 454, -548, -548, 275, -548 + 652, -536, -536, -536, -536, -536, -536, -536, 79, -536, + 2973, 75, 1929, 1816, -536, -536, -536, -536, 42, 2973, + 42, 2973, 42, 2973, 42, 42, 2973, 47, 2973, 2253, + -536, -536, -536, -536, 42, 42, -536, -536, 88, -36, + -536, 2973, -536, -536, 2973, -12, 2, -34, 2253, 2173, + 75, 42, 2973, -1, 2973, 2973, 2973, 2973, 2973, 2973, + 2333, -536, 351, 98, -536, 4, -536, -49, 54, 45, + 15, -536, -536, -536, 897, -536, -536, 12, 177, 253, + 283, -536, 161, 296, 310, 184, -536, -536, -536, -536, + -536, 132, 136, 203, 74, 92, 13, 93, 105, 223, + 223, -536, -1, -536, -536, -536, 222, -536, -1, 215, + -536, 255, 399, 256, 1816, -536, -536, -536, -536, 754, + -536, 277, 867, -536, -536, -536, -536, -536, 270, -536, + 374, -536, 374, -536, -536, 3519, 3053, 2413, 208, -536, + -536, -536, 3519, -536, 3519, 248, 242, 242, 2973, 206, + 254, 2973, 217, 3519, 75, 897, 218, 2493, 2973, 2173, + -536, 3519, 3133, -536, 98, -536, 2573, 2973, 2973, -536, + 327, -536, -536, 2973, 98, 374, 374, 374, 480, 480, + 342, 250, 2973, 2973, 2973, 2973, 2973, 2973, 2973, 2653, + -536, -536, 2973, -536, -536, 2973, 2973, 2973, 2973, 2973, + 2973, 2973, 2973, 2973, 2973, 2973, 2973, 2973, 2973, 2973, + 2973, 2973, 2973, 2973, 2973, 2973, 2973, 2973, 2973, 2973, + 2973, -536, -536, -536, 2973, 302, 2733, 2973, 2973, 2973, + 2973, 2973, 2973, 2973, -536, 308, 314, 315, 282, -536, + -536, -536, -536, -536, 252, 359, -536, -536, 244, -536, + -536, -536, 339, -536, -536, -536, -536, -536, -536, 75, + -536, -536, -536, 2973, 2973, 2973, 2973, 2973, -536, -536, + -536, -536, 326, -536, -536, -536, 326, -536, -536, -536, + 376, -536, -536, 2813, 374, 208, 37, 57, 65, -536, + 260, 336, -536, -536, -536, 242, 337, -536, -536, -536, + -536, 2973, 2973, 119, -536, -536, -536, -536, 377, 320, + 273, 2973, 98, 98, 395, -536, 2973, 397, 86, 86, + -536, -536, 3215, 16, 139, -536, 424, 3480, 3460, 3319, + 374, 387, 352, 3163, 3215, 3215, 576, 3358, 3358, 3358, + 3381, 3381, 3420, 3441, 3460, 3460, 3480, 3480, 3499, 3538, + 352, 387, 374, 374, 32, 31, 2973, 2973, 24, 386, + 388, 389, -536, 390, 2893, 289, -536, -536, 438, 123, + 155, 178, 159, 267, 170, 306, 1025, -536, -536, 400, + 44, 242, 363, -536, 328, 2973, 2973, -536, 6, -536, + -536, 297, -536, -536, -536, -536, 2011, 203, -536, 2973, + 2973, -536, -536, 371, -536, 405, -536, -536, -536, 351, + -536, -536, -536, 351, -536, -536, 338, 343, 277, 14, + 451, -536, -536, -536, -536, -536, 304, -536, -536, 312, + 87, -536, 2973, -536, -536, -536, 508, -536, 190, 2973, + 434, -536, -536, 2973, -536, 319, 311, 239, -536, -536, + -536, -536, -536, -536, 523, 2973, -536, 437, -536, 440, + -536, 441, -536, 443, -536, -536, -536, -536, -536, 51, + -536, -536, 329, 351, 330, 446, 331, -536, -536, -536, + -536, -536, 345, 457, 90, -536, 2973, 346, 355, 351, + 1138, 356, 432, 248, -536, 475, -536, -536, 242, 2973, + 2973, -536, 21, -536, -536, -536, 476, -536, -536, 2973, + -536, 408, -536, -536, -536, 245, -536, 3267, 2973, 490, + -536, -536, 380, -536, -536, -536, -536, 497, -536, -536, + -536, 2973, 223, 223, 505, 406, -536, 2973, 2973, 223, + -536, 394, 409, -536, -536, -536, -536, -536, -536, 2973, + 242, -536, 502, 897, 897, 410, -536, 351, -536, -536, + 418, -536, -536, 465, -536, -536, 897, 174, 174, 446, + 422, 425, 426, 215, 2973, 2973, 223, 223, 223, 446, + 223, 538, 405, 1251, -536, -536, -536, -536, -536, -536, + -536, 1364, -536, 223, 427, -536, -536, -536, -536, 2973, + 223, 223, -536, 542, 439, 215, 215, 215, -536, 525, + -536, -536, -536, 1477, -536, 19, -536, 1590, -536, 2973, + 448, 215, 215, -536, 223, -536, -536, -536, 452, 75, + -536, -536, 551, 499, -536, -536, 460, 223, -536, -536, + -536, 215, -536, -536, -536, -536, -536, -536, 223, 215, + 2093, -536, 1703, 174, -536, 482, -536, -536, 223, -536 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -521,102 +521,102 @@ static const yytype_int16 yydefact[] = { 0, 2, 4, 6, 8, 10, 12, 14, 0, 21, 19, 0, 0, 0, 19, 135, 1, 19, 0, 19, - 0, 0, 0, 0, 0, 0, 0, 0, 268, 0, - 103, 103, 104, 281, 0, 0, 252, 279, 240, 274, - 276, 270, 103, 283, 262, 272, 0, 0, 265, 19, + 0, 0, 0, 0, 0, 0, 0, 0, 270, 0, + 103, 103, 104, 283, 0, 0, 254, 281, 242, 276, + 278, 272, 103, 285, 264, 274, 0, 0, 267, 19, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, - 0, 304, 305, 148, 282, 247, 231, 190, 202, 191, - 209, 232, 233, 234, 151, 237, 5, 253, 242, 245, - 244, 246, 243, 0, 0, 0, 21, 7, 78, 73, + 0, 306, 307, 148, 284, 249, 233, 192, 204, 193, + 211, 234, 235, 236, 151, 239, 5, 255, 244, 247, + 246, 248, 245, 0, 0, 0, 21, 7, 78, 73, 105, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 102, 0, 16, 17, 36, 0, 102, 0, 19, 9, 0, 79, 0, 0, 11, 33, 32, 28, 0, - 15, 19, 0, 333, 336, 335, 334, 320, 0, 321, - 215, 323, 216, 322, 326, 238, 0, 0, 285, 290, - 292, 291, 269, 230, 229, 19, 19, 19, 19, 0, - 0, 0, 0, 271, 0, 263, 0, 0, 19, 19, - 266, 267, 281, 302, 303, 159, 242, 0, 0, 324, - 0, 106, 107, 19, 264, 217, 218, 236, 222, 223, - 241, 0, 0, 0, 0, 0, 149, 0, 0, 0, - 205, 204, 0, 212, 211, 0, 0, 0, 0, 0, + 15, 19, 0, 335, 338, 337, 336, 322, 0, 323, + 217, 325, 218, 324, 328, 240, 0, 0, 287, 292, + 294, 293, 271, 232, 231, 19, 19, 19, 19, 0, + 0, 0, 0, 273, 0, 265, 0, 0, 19, 19, + 268, 269, 283, 304, 305, 161, 244, 0, 0, 326, + 0, 106, 107, 19, 266, 219, 220, 238, 224, 225, + 243, 0, 0, 0, 0, 0, 149, 0, 0, 0, + 207, 206, 0, 214, 213, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 219, 220, 221, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 19, 19, 0, 0, 19, 293, - 295, 294, 21, 21, 21, 0, 21, 21, 0, 21, + 0, 221, 222, 223, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 19, 19, 0, 0, 19, 295, + 297, 296, 21, 21, 21, 0, 21, 21, 0, 21, 21, 23, 0, 71, 46, 102, 72, 42, 102, 0, 88, 64, 70, 0, 0, 0, 0, 0, 69, 35, 34, 29, 115, 118, 117, 130, 115, 126, 125, 129, - 131, 136, 224, 0, 287, 0, 242, 245, 244, 289, - 0, 114, 284, 109, 108, 19, 112, 110, 21, 21, - 157, 19, 0, 0, 275, 162, 273, 277, 0, 0, - 0, 0, 152, 153, 0, 256, 0, 239, 146, 147, - 144, 145, 150, 0, 0, 176, 0, 208, 214, 194, - 183, 185, 187, 201, 181, 182, 0, 197, 199, 198, - 195, 196, 193, 192, 213, 210, 207, 203, 206, 189, - 188, 186, 200, 184, 180, 0, 0, 0, 0, 330, - 328, 332, 164, 0, 0, 156, 165, 254, 0, 0, + 131, 136, 226, 0, 289, 0, 244, 247, 246, 291, + 0, 114, 286, 109, 108, 19, 112, 110, 21, 21, + 159, 19, 0, 0, 277, 164, 275, 279, 0, 0, + 0, 0, 152, 153, 0, 258, 0, 241, 146, 147, + 144, 145, 150, 0, 0, 178, 0, 210, 216, 196, + 185, 187, 189, 203, 183, 184, 0, 199, 201, 200, + 197, 198, 195, 194, 215, 212, 209, 205, 208, 191, + 190, 188, 202, 186, 182, 0, 0, 0, 0, 332, + 330, 334, 166, 0, 0, 156, 167, 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100, 101, 0, - 0, 19, 297, 298, 299, 0, 0, 318, 0, 319, - 316, 0, 317, 313, 314, 315, 0, 0, 21, 0, + 0, 19, 299, 300, 301, 0, 0, 320, 0, 321, + 318, 0, 319, 315, 316, 317, 0, 0, 21, 0, 95, 19, 21, 0, 38, 21, 40, 89, 80, 77, - 81, 84, 83, 97, 82, 116, 122, 119, 127, 241, - 0, 286, 288, 113, 21, 111, 19, 227, 228, 0, - 19, 178, 19, 278, 161, 160, 0, 225, 0, 0, - 0, 169, 175, 0, 260, 0, 0, 257, 259, 258, - 261, 325, 173, 0, 19, 255, 0, 167, 0, 248, - 0, 249, 0, 18, 21, 37, 21, 44, 0, 296, - 300, 0, 98, 0, 0, 0, 308, 21, 93, 94, - 99, 0, 0, 79, 58, 0, 0, 0, 96, 0, - 19, 0, 19, 138, 0, 43, 137, 19, 123, 120, - 128, 239, 226, 135, 132, 0, 133, 158, 0, 306, - 0, 163, 154, 179, 0, 172, 235, 0, 168, 174, - 0, 170, 250, 251, 166, 0, 65, 21, 45, 0, - 0, 0, 312, 0, 311, 0, 0, 0, 52, 0, - 0, 92, 92, 22, 25, 24, 62, 19, 19, 19, - 21, 124, 121, 0, 142, 307, 280, 177, 171, 155, - 0, 19, 67, 301, 19, 19, 309, 0, 0, 0, - 19, 95, 0, 0, 0, 0, 0, 0, 0, 21, - 0, 141, 41, 140, 134, 19, 19, 0, 19, 0, - 0, 85, 48, 49, 310, 0, 0, 0, 61, 0, - 0, 19, 19, 19, 26, 90, 47, 39, 139, 0, - 30, 0, 66, 0, 86, 0, 0, 19, 19, 53, - 0, 57, 51, 50, 0, 0, 63, 143, 0, 19, - 31, 68, 0, 0, 55, 60, 92, 19, 27, 91, - 20, 19, 75, 74, 0, 19, 0, 59, 0, 19, - 56, 0, 76, 87, 0, 54 + 81, 84, 83, 97, 82, 116, 122, 119, 127, 243, + 0, 288, 290, 113, 21, 111, 19, 229, 230, 0, + 19, 180, 19, 280, 163, 162, 0, 227, 0, 0, + 0, 171, 177, 0, 262, 158, 0, 0, 259, 261, + 260, 263, 327, 175, 0, 19, 257, 0, 169, 0, + 250, 0, 251, 0, 18, 21, 37, 21, 44, 0, + 298, 302, 0, 98, 0, 0, 0, 310, 21, 93, + 94, 99, 0, 0, 79, 58, 0, 0, 0, 96, + 0, 19, 0, 19, 138, 0, 43, 137, 19, 123, + 120, 128, 241, 228, 135, 132, 0, 133, 160, 0, + 308, 0, 165, 154, 181, 0, 174, 237, 19, 0, + 170, 176, 0, 172, 252, 253, 168, 0, 65, 21, + 45, 0, 0, 0, 314, 0, 313, 0, 0, 0, + 52, 0, 0, 92, 92, 22, 25, 24, 62, 19, + 19, 19, 21, 124, 121, 0, 142, 309, 282, 179, + 0, 173, 155, 0, 19, 67, 303, 19, 19, 311, + 0, 0, 0, 19, 95, 0, 0, 0, 0, 0, + 0, 0, 21, 0, 141, 41, 140, 134, 19, 157, + 19, 0, 19, 0, 0, 85, 48, 49, 312, 0, + 0, 0, 61, 0, 0, 19, 19, 19, 26, 90, + 47, 39, 139, 0, 30, 0, 66, 0, 86, 0, + 0, 19, 19, 53, 0, 57, 51, 50, 0, 0, + 63, 143, 0, 19, 31, 68, 0, 0, 55, 60, + 92, 19, 27, 91, 20, 19, 75, 74, 0, 19, + 0, 59, 0, 19, 56, 0, 76, 87, 0, 54 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -548, -548, -548, -548, -548, -548, -548, -548, -548, -548, - -4, -10, -548, 19, 13, -548, -548, -548, -548, -16, - -548, 560, 460, 5, -548, -548, -548, -548, -548, -548, - -548, -548, -548, -548, -548, -548, -31, -390, -528, -547, - -548, -516, -548, 4, 184, -312, -66, -548, -96, 66, - -548, -548, -50, 97, -135, 309, 327, -548, -548, -548, - 177, -548, -548, -548, -548, 102, -548, 17, 175, -548, - -296, -548, 93, -44, -548, -548, -548, -548, -548, -548, - -548, -548, -548, -548, -548, -548, 556, -548, -548, 470, - -548, -548, -548, -548, -140, -17, -548, -548, -548, -548, - 219, -548, -548, 373, 152, -14, -8, -548, -548, -548, - -548, -548, 16 + -536, -536, -536, -536, -536, -536, -536, -536, -536, -536, + -4, -10, -536, 56, -7, -536, -536, -536, -536, -16, + -536, 594, 496, -9, -536, -536, -536, -536, -536, -536, + -536, -536, -536, -536, -536, -536, 52, -394, -535, -259, + -536, -520, -536, 46, 219, -332, -31, -536, -94, 49, + -536, -536, -76, 128, -124, 341, 348, -536, -536, -536, + 204, -536, -536, -536, -536, 129, -536, 55, 210, -536, + -287, -536, 9, -44, -536, -536, -536, -536, -536, -536, + -536, -536, -536, -536, -536, -536, 533, -536, -536, 491, + -536, -536, -536, -536, -137, -15, -536, -536, -536, -536, + 249, -536, -536, 391, 63, -21, -19, -536, -536, -536, + -536, -536, 152 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { 0, 8, 9, 10, 11, 12, 13, 14, 15, 108, - 109, 118, 465, 426, 252, 401, 546, 576, 624, 119, - 611, 271, 116, 117, 492, 497, 405, 403, 571, 636, - 539, 577, 561, 588, 630, 643, 408, 111, 592, 261, - 626, 574, 480, 487, 412, 471, 482, 379, 254, 145, + 109, 118, 466, 426, 252, 401, 548, 579, 628, 119, + 615, 271, 116, 117, 493, 498, 405, 403, 574, 640, + 541, 580, 564, 592, 634, 647, 408, 111, 596, 261, + 630, 577, 481, 488, 412, 472, 483, 379, 254, 145, 147, 235, 173, 295, 298, 292, 416, 276, 277, 278, - 279, 280, 281, 505, 506, 120, 121, 495, 496, 582, - 427, 585, 112, 63, 64, 432, 365, 65, 66, 67, + 279, 280, 281, 506, 507, 120, 121, 496, 497, 585, + 427, 588, 112, 63, 64, 432, 365, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 150, 75, 138, - 238, 384, 113, 529, 165, 76, 510, 475, 532, 533, + 238, 384, 113, 531, 165, 76, 511, 476, 534, 535, 390, 391, 247, 77, 78, 79, 80, 81, 82, 83, 84, 85, 129 }; @@ -626,86 +626,95 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 61, 122, 128, 428, 20, 164, 479, 87, 300, 61, - 174, 257, 299, 140, 125, 20, 125, 110, 125, 141, - 125, 125, 187, 598, 188, 143, 575, 316, 17, 244, - 125, 125, 16, 315, 127, 170, 86, 593, 131, 163, - 133, 134, 61, 158, 160, 125, 168, 125, 628, 20, - 148, 149, 255, 22, 621, 622, 623, 24, 258, 151, - 227, 466, 228, 355, 356, 167, 357, 169, 152, 358, - 634, 635, 467, 359, 473, 439, 156, 360, 361, 240, - 527, -327, 629, -327, 481, 241, 159, -329, 431, -329, - 647, 528, 186, 227, 157, 228, -289, 146, 650, 260, - 508, 190, 191, 62, 164, 234, 441, 362, 154, 186, - 171, 275, 62, 253, 457, 172, 474, 245, 459, 270, - 646, 653, 287, 312, 313, -335, 225, 246, 288, 164, - 461, -290, 363, 195, 513, 294, 297, 297, 163, 189, - 226, 309, 310, 518, -288, 62, 440, 192, 61, 61, - 305, 136, -292, 181, -327, 125, -327, -331, -291, 404, - 424, 137, 406, 163, 182, 183, 184, 185, 233, -329, - 126, -329, 126, 540, 126, 311, 126, 126, 229, 139, - 230, 364, 182, 183, 184, 185, 126, 126, 184, 185, - 182, 183, 184, 185, 182, 183, 184, 185, 231, 242, - 232, 166, 456, 126, 193, 194, 182, 183, 184, 185, - 182, 183, 184, 185, 182, 183, 184, 185, 376, 182, - 183, 184, 185, 568, 569, 378, 589, 590, 383, 557, - 290, 394, 236, 410, 411, 263, 414, 395, 264, 265, - 266, 267, 237, 243, 303, 239, 468, 458, 248, 20, - 308, 62, 62, 22, 583, 407, 479, 24, 430, 249, - 600, 385, 386, 388, 460, 396, 397, 250, 399, 400, - 182, 183, 184, 185, 462, 318, 319, 320, 321, 517, - 323, 324, 326, 616, 429, 297, 251, 256, 286, 259, - 262, 61, 511, 182, 183, 184, 185, 282, 291, 86, - 268, 293, 296, 632, 20, 182, 183, 184, 185, 301, - 304, 166, 302, 447, 314, 182, 183, 184, 185, 368, - 369, 370, 371, 372, 373, 374, 375, 306, 316, 382, - -98, 387, 182, 183, 184, 185, -335, -335, -335, 224, - 225, 123, 182, 183, 184, 185, 124, 182, 183, 184, - 185, 377, 197, 380, 125, 381, 409, 409, 409, 413, - 409, 86, 550, 398, 402, 415, 20, 418, 423, 263, - 425, 297, 264, 265, 266, 267, 420, 366, 435, 182, - 183, 184, 185, 394, 437, 489, 478, 434, 164, 395, - 219, 439, 197, 444, 62, 220, 448, 393, 221, 222, - 223, 224, 225, 123, 436, 449, 272, 578, 124, 438, - 273, 450, 451, 579, 274, 454, 504, 485, 197, 198, - 509, 490, 163, 464, 494, 469, 470, 182, 183, 184, - 185, 477, 491, 493, 498, 220, 499, 520, 221, 222, - 223, 224, 225, 494, 61, 503, 507, 530, 515, 445, - 446, 182, 183, 184, 185, 218, 219, 453, 521, 522, - 523, 220, 524, 531, 221, 222, 223, 224, 225, 20, - 197, 198, 199, 535, 182, 183, 184, 185, 472, 472, - 545, 537, 294, 525, 538, 526, 541, 297, 317, 483, - 542, 547, 413, 488, 544, 549, 536, 182, 183, 184, - 185, 554, 556, 164, 215, 216, 217, 218, 219, 558, - 126, 422, 559, 220, 560, 566, 221, 222, 223, 224, - 225, 182, 183, 184, 185, 182, 183, 184, 185, 567, - 581, 572, 514, 580, 433, 573, 584, 163, 297, 586, - 476, 595, 596, 564, 565, 587, 562, 62, 597, 393, - 570, 18, 606, 615, 591, 591, 619, 20, 442, 620, - 260, 22, 455, 625, 633, 24, 638, 640, 641, 609, - 644, 389, 613, 115, 269, 599, 610, 130, 472, 132, - 651, 654, 135, 486, 142, 144, 601, 602, 603, 548, - 605, 260, 260, 260, 421, 500, 607, 153, 494, 502, - 155, 555, 614, 417, 161, 553, 285, 260, 260, 617, - 618, 175, 176, 177, 178, 179, 484, 0, 392, 642, - 0, 639, 0, 0, 0, 648, 534, 260, 472, 472, - 0, 0, 0, 637, 0, 260, 478, 0, 0, 591, - 196, 0, 0, 0, 0, 0, 645, 0, 197, 198, - 199, 0, 182, 183, 184, 185, 0, 649, 0, 0, - 0, 0, 0, 0, 488, 472, 0, 655, 0, 203, - 0, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 0, 472, 501, - 0, 220, 284, 0, 221, 222, 223, 224, 225, 182, - 183, 184, 185, 182, 183, 184, 185, 0, 472, 1, - 2, 3, 4, 5, 6, 7, 0, 0, 594, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 604, 0, - 0, 0, 0, 0, 0, 0, 512, 0, 0, 0, - 519, 0, 322, 0, 0, 0, 0, 0, 327, 0, - 0, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, 353, -13, 88, 0, - 354, 0, 0, 0, 0, 0, 0, 18, 86, 0, - 19, 0, 0, 20, 0, 0, 21, 22, 23, 89, + 61, 122, 480, 110, 128, 164, 140, 87, 141, 61, + 174, 300, 428, 257, 125, 187, 125, 188, 125, 62, + 125, 125, 20, 299, 578, 143, 255, 316, 62, 20, + 125, 125, 258, 597, 439, 86, 315, 170, 440, 163, + 20, 632, 61, 244, 160, 125, 168, 125, 227, 448, + 228, 158, 171, 86, 474, 467, 444, 172, 20, 190, + 191, 62, 529, 20, 482, 17, 468, 22, -329, 181, + -329, 24, 240, 530, 241, 633, -331, 123, -331, 16, + 146, 126, 124, 126, 171, 126, 86, 126, 126, 172, + 139, 154, 152, 253, 159, 123, -291, 126, 126, 260, + 124, 151, 186, -290, 164, 270, 182, 183, 184, 185, + 509, 275, 166, 186, 126, 287, 156, 288, 657, -292, + 650, 195, 263, 312, 313, 264, 265, 266, 267, 164, + 157, 245, 189, 431, 475, 294, 297, 297, 163, -294, + 226, 246, 234, 309, 310, 457, 290, -293, 61, 61, + 305, 193, 194, 441, 542, 125, 239, -337, 225, 248, + 303, 404, 192, 163, 406, 136, 308, 62, 62, 458, + 127, 424, -333, 460, 131, 137, 133, 134, 184, 185, + 182, 183, 184, 185, 462, 236, 148, 149, 227, 237, + 228, 318, 319, 320, 321, 233, 323, 324, 326, 286, + 459, 167, 242, 169, 514, 571, 572, 593, 594, 182, + 183, 184, 185, 182, 183, 184, 185, -98, 376, 20, + 243, 249, 166, 22, 394, 378, 395, 24, 383, 182, + 183, 184, 185, 250, 251, 368, 369, 370, 371, 372, + 373, 374, 375, 604, 256, 182, 183, 184, 185, 182, + 183, 184, 185, 520, 259, 407, 480, 469, 430, 559, + 182, 183, 184, 185, -329, 586, -329, 620, 182, 183, + 184, 185, 409, 409, 409, 413, 409, 262, 268, 445, + 182, 183, 184, 185, 282, 297, 429, 636, 366, 461, + 291, 61, 420, 272, -331, 512, -331, 273, 385, 386, + 388, 274, 396, 397, 293, 399, 400, 229, 393, 230, + 62, 311, 355, 356, 602, 357, 410, 411, 358, 414, + 436, 231, 359, 232, 296, 438, 360, 361, 463, 182, + 183, 184, 185, 519, 301, 182, 183, 184, 185, 302, + 182, 183, 184, 185, 304, 306, 625, 626, 627, 314, + 182, 183, 184, 185, 125, 316, 362, 182, 183, 184, + 185, 377, 638, 639, 382, 446, 447, 380, 381, 18, + 387, 297, 398, 454, 552, 20, 394, 317, 395, 22, + 402, 363, 651, 24, 415, 490, 479, 422, 164, 389, + 654, 418, 423, 425, 473, 473, 182, 183, 184, 185, + 435, 182, 183, 184, 185, 484, 434, 437, 413, 489, + 439, 449, 581, 450, 451, 452, 505, 455, 465, 470, + 510, 126, 163, 471, 492, 478, 582, 494, 197, 198, + 364, 263, 504, 499, 264, 265, 266, 267, 500, 508, + 522, 182, 183, 184, 185, 61, 516, 518, 515, 523, + 197, 477, 524, 525, 486, 526, 532, 533, 491, 537, + 393, 495, 20, 197, 62, 218, 219, 182, 183, 184, + 185, 220, 539, 543, 221, 222, 223, 224, 225, 540, + 495, 547, 544, 294, 546, 549, 551, 556, 297, 182, + 183, 184, 185, 220, 558, 473, 221, 222, 223, 224, + 225, 219, 561, 560, 433, 164, 220, 562, 61, 221, + 222, 223, 224, 225, 182, 183, 184, 185, 557, 563, + 569, 527, 575, 528, 584, 567, 568, 62, 182, 183, + 184, 185, 573, 570, 538, 583, 576, 587, 536, 163, + 297, 182, 183, 184, 185, 589, 473, 473, 591, 590, + 599, 442, 600, 601, 130, 619, 132, 595, 595, 135, + 610, 142, 144, 260, 623, 456, 624, 629, 644, 605, + 606, 607, 613, 609, 153, 637, 617, 155, 502, 642, + 614, 161, 645, 489, 473, 565, 618, 648, 175, 176, + 177, 178, 179, 621, 622, 260, 260, 260, 182, 183, + 184, 185, -337, -337, -337, 224, 225, 115, 473, 658, + 269, 260, 260, 182, 183, 184, 185, 641, 487, 655, + 603, 550, 501, 646, 417, 643, 421, 285, 473, 652, + 649, 260, 598, 555, 503, 513, 392, 611, 495, 260, + 479, 653, 608, 595, 196, 0, 485, 0, 0, 0, + 521, 659, 197, 198, 199, 1, 2, 3, 4, 5, + 6, 7, 0, 0, 0, 200, 0, 0, 0, 284, + 0, 201, 202, 203, 443, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 0, 0, 0, 0, 220, 0, 0, 221, 222, + 223, 224, 225, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 322, + 0, 0, 0, 0, 0, 327, 0, 0, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, 353, -13, 88, 0, 354, 0, 0, + 0, 0, 0, 0, 18, 86, 0, 19, 0, 0, + 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, + 90, 91, 92, 26, 27, 93, 94, 0, 0, 95, + 96, 97, 98, 0, 99, 0, 0, 100, 28, 29, + 101, 102, 103, 30, 31, 104, 32, 33, 34, 35, + 36, 37, 0, 38, 39, 40, 41, 42, 43, 105, + 114, 44, 0, 106, 45, 46, 47, 48, 49, 50, + 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, + 0, 107, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -3, 88, 55, + 56, 0, 57, 0, 58, 59, 0, 18, 86, 0, + 19, 0, 60, 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, 0, 0, 100, 28, 29, 101, 102, 103, 30, 31, 104, 32, @@ -713,62 +722,17 @@ static const yytype_int16 yytable[] = 42, 43, 105, 114, 44, 0, 106, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, 107, 0, 0, 0, 0, 0, - 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -3, 88, 55, 56, 0, 57, 0, 58, 59, 0, - 18, 86, 0, 19, 0, 60, 20, 0, 0, 21, - 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, - 27, 93, 94, 0, 0, 95, 96, 97, 98, 0, - 99, 0, 0, 100, 28, 29, 101, 102, 103, 30, - 31, 104, 32, 33, 34, 35, 36, 37, 0, 38, - 39, 40, 41, 42, 43, 105, 114, 44, 0, 106, - 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, - 52, 53, 0, 0, 0, 0, 0, 107, 0, 0, - 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 196, 0, 0, 0, 0, 516, - 0, 0, 197, 198, 199, 55, 56, 0, 57, 0, - 58, 59, 0, 0, 0, 200, 0, 0, 60, 0, - 0, 201, 202, 203, 443, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 0, 0, 0, 0, 220, 0, 88, 221, 222, - 223, 224, 225, 0, 551, 552, 18, 86, 463, 19, - 0, 0, 20, 0, 0, 21, 22, 23, 89, 0, - 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, - 0, 95, 96, 97, 98, 563, 99, 0, 0, 100, - 28, 29, 101, 102, 103, 30, 31, 104, 32, 33, - 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, - 43, 105, 114, 44, 0, 106, 45, 46, 47, 48, - 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, - 0, 0, 0, 107, 0, 0, 0, 0, 0, 0, - 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 88, 55, 56, 0, 57, 0, 58, 59, 0, 18, - 86, 543, 19, 0, 60, 20, 0, 0, 21, 22, - 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, - 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, - 0, 0, 100, 28, 29, 101, 102, 103, 30, 31, - 104, 32, 33, 34, 35, 36, 37, 0, 38, 39, - 40, 41, 42, 43, 105, 114, 44, 0, 106, 45, - 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, - 53, 0, 0, 0, 0, 0, 107, 0, 0, 0, - 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 88, 55, 56, 0, 57, 0, 58, - 59, 0, 18, 86, 608, 19, 0, 60, 20, 0, - 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, - 92, 26, 27, 93, 94, 0, 0, 95, 96, 97, - 98, 0, 99, 0, 0, 100, 28, 29, 101, 102, - 103, 30, 31, 104, 32, 33, 34, 35, 36, 37, - 0, 38, 39, 40, 41, 42, 43, 105, 114, 44, - 0, 106, 45, 46, 47, 48, 49, 50, 0, 0, - 0, 51, 52, 53, 0, 0, 0, 0, 0, 107, - 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 88, 55, 56, 0, - 57, 0, 58, 59, 0, 18, 86, 612, 19, 0, - 60, 20, 0, 0, 21, 22, 23, 89, 0, 24, + 0, 54, 0, 0, 0, 196, 0, 0, 0, 0, + 0, 0, 0, 197, 198, 199, 517, 0, 0, 0, + 0, 0, 55, 56, 0, 57, 200, 58, 59, 0, + 0, 0, 201, 202, 203, 60, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 0, 0, 0, 0, 220, 0, 0, 221, + 222, 223, 224, 225, 0, 0, 88, 0, 0, 0, + 0, 0, 553, 554, 0, 18, 86, 464, 19, 0, + 0, 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, 0, - 95, 96, 97, 98, 0, 99, 0, 0, 100, 28, + 95, 96, 97, 98, 566, 99, 0, 0, 100, 28, 29, 101, 102, 103, 30, 31, 104, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 105, 114, 44, 0, 106, 45, 46, 47, 48, 49, @@ -777,7 +741,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 55, 56, 0, 57, 0, 58, 59, 0, 18, 86, - 627, 19, 0, 60, 20, 0, 0, 21, 22, 23, + 545, 19, 0, 60, 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, 0, 0, 100, 28, 29, 101, 102, 103, 30, 31, 104, @@ -788,7 +752,7 @@ static const yytype_int16 yytable[] = 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 55, 56, 0, 57, 0, 58, 59, - 0, 18, 86, 631, 19, 0, 60, 20, 0, 0, + 0, 18, 86, 612, 19, 0, 60, 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, 0, 0, 100, 28, 29, 101, 102, 103, @@ -799,18 +763,18 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 55, 56, 0, 57, - 0, 58, 59, 0, 18, 86, 0, 19, 0, 60, + 0, 58, 59, 0, 18, 86, 616, 19, 0, 60, 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, 0, 0, 100, 28, 29, 101, 102, 103, 30, 31, 104, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 105, 114, 44, 0, 106, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 652, 0, + 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, 107, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 55, - 56, 0, 57, 0, 58, 59, 0, 18, 86, 0, + 56, 0, 57, 0, 58, 59, 0, 18, 86, 631, 19, 0, 60, 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, 0, 0, @@ -822,261 +786,306 @@ static const yytype_int16 yytable[] = 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 55, 56, 0, 57, 0, 58, 59, 0, - 18, 86, 0, 19, 0, 60, 20, 0, 0, 21, + 18, 86, 635, 19, 0, 60, 20, 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, 0, 0, 100, 28, 29, 101, 102, 103, 30, 31, 104, 32, 33, 34, 35, 36, 37, 0, 38, - 39, 40, 41, 42, 43, 105, 0, 44, 0, 106, + 39, 40, 41, 42, 43, 105, 114, 44, 0, 106, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, - 52, 53, 0, 88, 0, 0, 0, 107, 0, 0, - 0, 0, 18, 0, 54, 19, 0, 0, 20, 0, - 0, 21, 22, 23, -19, 0, 24, 25, 0, 0, - 0, 26, 27, 0, 0, 55, 56, 0, 57, 0, - 58, 59, 0, 0, 0, 0, 28, 29, 60, 0, - 0, 30, 31, 0, 32, 33, 34, 35, 36, 37, - 0, 38, 39, 40, 41, 42, 43, 0, 0, 44, - 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, - 0, 51, 52, 53, 0, 88, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 54, 19, 0, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 55, 56, 0, - 57, 0, 58, 59, 0, 0, 0, 0, 28, 29, - 60, 0, 0, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 86, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, -19, 60, 30, 31, 0, 32, 162, 34, 35, - 36, 37, 124, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 86, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 0, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 0, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 180, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 289, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, -334, 227, 0, 228, 54, 0, - -334, 0, 0, -334, -334, -334, 0, 0, -334, -334, - 0, 0, 0, -334, -334, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, -334, -334, - 0, 307, 60, -334, -334, 0, -334, -334, -334, -334, - -334, -334, 0, -334, -334, -334, -334, -334, -334, 0, - 0, -334, 0, 0, -334, -334, -334, -334, -334, -334, - 0, 0, 0, -334, -334, -334, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, -334, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, -334, - -334, 0, -334, 0, -334, -334, 0, 0, 28, 29, - 0, 0, -334, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 325, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 367, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 419, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 452, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 54, 0, - 20, 0, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, - 0, 0, 60, 30, 31, 0, 32, 33, 34, 35, - 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, - 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, - 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, 0, 0, 0, -333, 0, 0, -333, 54, 0, - -333, 0, 0, -333, -333, -333, 0, 0, -333, -333, - 0, 0, 0, -333, -333, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, -333, -333, - 0, 0, 283, -333, -333, 0, -333, -333, -333, -333, - -333, -333, 0, -333, -333, -333, -333, -333, -333, 0, - 0, -333, 0, 0, -333, -333, -333, -333, -333, -333, - 0, 0, 0, -333, -333, -333, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -333, 0, - 0, 0, 196, 0, 0, 0, 0, 0, 0, 0, - 197, 198, 199, 0, 0, 0, 0, 0, 0, -333, - -333, 0, -333, 200, -333, -333, 0, 0, 0, 201, - 202, 203, -333, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 0, - 0, 0, 0, 220, 196, 0, 221, 222, 223, 224, - 225, 0, 197, 198, 199, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -335, 0, 0, 0, 0, - 0, 201, 202, 203, 0, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 0, 0, 0, 0, 220, 196, 0, 221, 222, - 223, 224, 225, 0, 197, 198, 199, 0, 0, 0, + 52, 53, 0, 0, 0, 0, 0, 107, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 201, 202, 203, 0, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 0, 0, 0, 0, 220, -335, 0, - 221, 222, 223, 224, 225, 0, 197, 198, 199, 0, + 0, 0, 0, 0, 88, 55, 56, 0, 57, 0, + 58, 59, 0, 18, 86, 0, 19, 0, 60, 20, + 0, 0, 21, 22, 23, 89, 0, 24, 25, 90, + 91, 92, 26, 27, 93, 94, 0, 0, 95, 96, + 97, 98, 0, 99, 0, 0, 100, 28, 29, 101, + 102, 103, 30, 31, 104, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 105, 114, + 44, 0, 106, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 656, 0, 0, + 107, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 197, 198, 199, 0, 220, - 0, 0, 221, 222, 223, 224, 225, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 197, 198, - 199, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 0, 0, 0, 0, 220, 0, - 0, 221, 222, 223, 224, 225, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 197, 198, 199, - 0, 220, 0, 0, 221, 222, 223, 224, 225, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 197, 198, - 199, 0, 0, 0, 0, 0, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 0, 197, 198, 199, - 220, 0, 0, 221, 222, 223, 224, 225, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 197, 198, 199, - 0, 220, 0, 0, 221, 222, 223, 224, 225, 213, + 0, 0, 0, 0, 0, 0, 0, 88, 55, 56, + 0, 57, 0, 58, 59, 0, 18, 86, 0, 19, + 0, 60, 20, 0, 0, 21, 22, 23, 89, 0, + 24, 25, 90, 91, 92, 26, 27, 93, 94, 0, + 0, 95, 96, 97, 98, 0, 99, 0, 0, 100, + 28, 29, 101, 102, 103, 30, 31, 104, 32, 33, + 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, + 43, 105, 114, 44, 0, 106, 45, 46, 47, 48, + 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, + 0, 0, 0, 107, 0, 0, 0, 0, 0, 0, + 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 88, 55, 56, 0, 57, 0, 58, 59, 0, 18, + 86, 0, 19, 0, 60, 20, 0, 0, 21, 22, + 23, 89, 0, 24, 25, 90, 91, 92, 26, 27, + 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, + 0, 0, 100, 28, 29, 101, 102, 103, 30, 31, + 104, 32, 33, 34, 35, 36, 37, 0, 38, 39, + 40, 41, 42, 43, 105, 0, 44, 0, 106, 45, + 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, + 53, 0, 88, 0, 0, 0, 107, 0, 0, 0, + 0, 18, 0, 54, 19, 0, 0, 20, 0, 0, + 21, 22, 23, -19, 0, 24, 25, 0, 0, 0, + 26, 27, 0, 0, 55, 56, 0, 57, 0, 58, + 59, 0, 0, 0, 0, 28, 29, 60, 0, 0, + 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, + 38, 39, 40, 41, 42, 43, 0, 0, 44, 0, + 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, + 51, 52, 53, 0, 88, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 54, 19, 0, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 55, 56, 0, 57, + 0, 58, 59, 0, 0, 0, 0, 28, 29, 60, + 0, 0, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 86, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + -19, 60, 30, 31, 0, 32, 162, 34, 35, 36, + 37, 124, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 86, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 0, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 0, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 180, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 289, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, -336, 227, 0, 228, 54, 0, -336, + 0, 0, -336, -336, -336, 0, 0, -336, -336, 0, + 0, 0, -336, -336, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, -336, -336, 0, + 307, 60, -336, -336, 0, -336, -336, -336, -336, -336, + -336, 0, -336, -336, -336, -336, -336, -336, 0, 0, + -336, 0, 0, -336, -336, -336, -336, -336, -336, 0, + 0, 0, -336, -336, -336, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, -336, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, -336, -336, + 0, -336, 0, -336, -336, 0, 0, 28, 29, 0, + 0, -336, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 325, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 367, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 419, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 453, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 18, 0, 0, 19, 54, 0, 20, + 0, 0, 21, 22, 23, 0, 0, 24, 25, 0, + 0, 0, 26, 27, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, + 0, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 0, 0, 0, -335, 0, 0, -335, 54, 0, -335, + 0, 0, -335, -335, -335, 0, 0, -335, -335, 0, + 0, 0, -335, -335, 0, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, -335, -335, 0, + 0, 283, -335, -335, 0, -335, -335, -335, -335, -335, + -335, 0, -335, -335, -335, -335, -335, -335, 0, 0, + -335, 0, 0, -335, -335, -335, -335, -335, -335, 0, + 0, 0, -335, -335, -335, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -335, 0, 0, + 0, 196, 0, 0, 0, 0, 0, 0, 0, 197, + 198, 199, 0, 0, 0, 0, 0, 0, -335, -335, + 0, -335, -337, -335, -335, 0, 0, 0, 201, 202, + 203, -335, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 0, 0, + 0, 0, 220, 196, 0, 221, 222, 223, 224, 225, + 0, 197, 198, 199, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 201, 202, 203, 0, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 0, 0, 0, 0, 220, 196, 0, 221, 222, 223, + 224, 225, 0, 197, 198, 199, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 203, 0, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 0, 0, 0, 0, 220, -337, 0, 221, + 222, 223, 224, 225, 0, 197, 198, 199, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 197, 198, 199, 0, 220, 0, + 0, 221, 222, 223, 224, 225, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 197, 198, 199, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 0, 0, 0, 0, 220, 0, 0, + 221, 222, 223, 224, 225, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 197, 198, 199, 0, 220, 0, 0, 221, 222, 223, 224, 225, 0, 0, - 0, -335, 216, 217, 218, 219, 197, 198, 199, 0, - 220, 0, 0, 221, 222, 223, 224, 225, 0, 0, - 0, 216, 217, 218, 219, 0, 0, 0, 0, 220, + 0, 0, 0, 0, 0, 0, 0, 197, 198, 199, + 0, 0, 0, 0, 0, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 0, 197, 198, 199, 220, + 0, 0, 221, 222, 223, 224, 225, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 197, 198, 199, 0, + 220, 0, 0, 221, 222, 223, 224, 225, 213, 214, + 215, 216, 217, 218, 219, 197, 198, 199, 0, 220, 0, 0, 221, 222, 223, 224, 225, 0, 0, 0, - 0, 0, 217, 218, 219, 0, 0, 0, 0, 220, - 0, 0, 221, 222, 223, 224, 225 + 215, 216, 217, 218, 219, 197, 198, 199, 0, 220, + 0, 0, 221, 222, 223, 224, 225, 0, 0, -337, + 216, 217, 218, 219, 197, 198, 199, 0, 220, 0, + 0, 221, 222, 223, 224, 225, 0, 0, 0, 0, + 216, 217, 218, 219, 0, 0, 0, 0, 220, 0, + 0, 221, 222, 223, 224, 225, 0, 0, 0, 0, + 217, 218, 219, 0, 0, 0, 0, 220, 0, 0, + 221, 222, 223, 224, 225 }; static const yytype_int16 yycheck[] = { - 10, 17, 19, 299, 16, 49, 396, 11, 148, 19, - 54, 107, 147, 27, 18, 16, 20, 12, 22, 27, - 24, 25, 11, 570, 13, 29, 542, 13, 9, 30, - 34, 35, 0, 173, 18, 52, 11, 565, 22, 49, - 24, 25, 52, 85, 48, 49, 50, 51, 22, 16, - 34, 35, 102, 20, 601, 602, 603, 24, 108, 13, - 11, 11, 13, 10, 11, 49, 13, 51, 128, 16, - 617, 618, 22, 20, 386, 13, 128, 24, 25, 93, - 11, 11, 56, 13, 396, 93, 128, 11, 14, 13, - 637, 22, 15, 11, 128, 13, 82, 31, 645, 109, - 23, 108, 109, 10, 148, 86, 14, 54, 42, 15, - 53, 121, 19, 100, 14, 58, 128, 118, 14, 114, - 636, 649, 136, 167, 168, 125, 126, 128, 136, 173, - 14, 82, 79, 106, 14, 145, 146, 147, 148, 128, - 128, 158, 159, 14, 82, 52, 22, 108, 158, 159, - 154, 118, 82, 60, 11, 159, 13, 11, 82, 255, - 295, 128, 258, 173, 90, 91, 92, 93, 11, 11, - 18, 13, 20, 485, 22, 159, 24, 25, 11, 27, - 13, 128, 90, 91, 92, 93, 34, 35, 92, 93, - 90, 91, 92, 93, 90, 91, 92, 93, 11, 128, - 13, 49, 22, 51, 106, 107, 90, 91, 92, 93, - 90, 91, 92, 93, 90, 91, 92, 93, 234, 90, - 91, 92, 93, 535, 536, 235, 33, 34, 238, 14, - 137, 245, 53, 264, 265, 32, 267, 245, 35, 36, - 37, 38, 53, 128, 151, 93, 381, 22, 96, 16, - 157, 158, 159, 20, 550, 259, 646, 24, 302, 128, - 572, 242, 243, 244, 22, 246, 247, 128, 249, 250, - 90, 91, 92, 93, 22, 182, 183, 184, 185, 22, - 187, 188, 189, 595, 301, 295, 11, 22, 136, 39, - 22, 301, 432, 90, 91, 92, 93, 14, 82, 11, - 22, 56, 82, 615, 16, 90, 91, 92, 93, 128, - 127, 159, 85, 25, 22, 90, 91, 92, 93, 226, - 227, 228, 229, 230, 231, 232, 233, 127, 13, 82, - 127, 118, 90, 91, 92, 93, 122, 123, 124, 125, - 126, 53, 90, 91, 92, 93, 58, 90, 91, 92, - 93, 53, 76, 53, 358, 53, 263, 264, 265, 266, - 267, 11, 497, 128, 41, 58, 16, 15, 56, 32, - 56, 381, 35, 36, 37, 38, 283, 225, 127, 90, - 91, 92, 93, 397, 12, 401, 396, 86, 432, 397, - 114, 13, 76, 25, 301, 119, 25, 245, 122, 123, - 124, 125, 126, 53, 311, 25, 16, 547, 58, 316, - 20, 25, 25, 548, 24, 128, 426, 398, 76, 77, - 430, 402, 432, 18, 405, 56, 95, 90, 91, 92, - 93, 128, 53, 22, 95, 119, 95, 454, 122, 123, - 124, 125, 126, 424, 454, 128, 127, 127, 12, 356, - 357, 90, 91, 92, 93, 113, 114, 364, 12, 12, - 12, 119, 12, 127, 122, 123, 124, 125, 126, 16, - 76, 77, 78, 128, 90, 91, 92, 93, 385, 386, - 490, 127, 492, 464, 22, 466, 127, 497, 127, 396, - 127, 53, 399, 400, 128, 11, 477, 90, 91, 92, - 93, 11, 86, 547, 110, 111, 112, 113, 114, 12, - 358, 127, 127, 119, 22, 15, 122, 123, 124, 125, - 126, 90, 91, 92, 93, 90, 91, 92, 93, 127, - 22, 128, 439, 549, 127, 127, 127, 547, 548, 84, - 388, 128, 127, 530, 531, 561, 527, 454, 127, 397, - 537, 10, 22, 128, 564, 565, 22, 16, 127, 127, - 570, 20, 127, 42, 127, 24, 127, 17, 83, 585, - 127, 30, 588, 13, 114, 571, 586, 21, 485, 23, - 646, 127, 26, 399, 28, 29, 573, 574, 575, 492, - 577, 601, 602, 603, 285, 418, 579, 41, 579, 424, - 44, 508, 589, 276, 48, 503, 136, 617, 618, 596, - 597, 55, 56, 57, 58, 59, 397, -1, 245, 629, - -1, 625, -1, -1, -1, 641, 474, 637, 535, 536, - -1, -1, -1, 620, -1, 645, 646, -1, -1, 649, - 68, -1, -1, -1, -1, -1, 633, -1, 76, 77, - 78, -1, 90, 91, 92, 93, -1, 644, -1, -1, - -1, -1, -1, -1, 571, 572, -1, 654, -1, 97, - -1, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, -1, 595, 127, - -1, 119, 136, -1, 122, 123, 124, 125, 126, 90, - 91, 92, 93, 90, 91, 92, 93, -1, 615, 3, - 4, 5, 6, 7, 8, 9, -1, -1, 566, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 576, -1, - -1, -1, -1, -1, -1, -1, 127, -1, -1, -1, - 127, -1, 186, -1, -1, -1, -1, -1, 192, -1, - -1, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 0, 1, -1, - 224, -1, -1, -1, -1, -1, -1, 10, 11, -1, - 13, -1, -1, 16, -1, -1, 19, 20, 21, 22, + 10, 17, 396, 12, 19, 49, 27, 11, 27, 19, + 54, 148, 299, 107, 18, 11, 20, 13, 22, 10, + 24, 25, 16, 147, 544, 29, 102, 13, 19, 16, + 34, 35, 108, 568, 13, 11, 173, 52, 22, 49, + 16, 22, 52, 30, 48, 49, 50, 51, 11, 25, + 13, 85, 53, 11, 386, 11, 25, 58, 16, 108, + 109, 52, 11, 16, 396, 9, 22, 20, 11, 60, + 13, 24, 93, 22, 93, 56, 11, 53, 13, 0, + 31, 18, 58, 20, 53, 22, 11, 24, 25, 58, + 27, 42, 128, 100, 128, 53, 82, 34, 35, 109, + 58, 13, 15, 82, 148, 114, 90, 91, 92, 93, + 23, 121, 49, 15, 51, 136, 128, 136, 653, 82, + 640, 106, 32, 167, 168, 35, 36, 37, 38, 173, + 128, 118, 128, 14, 128, 145, 146, 147, 148, 82, + 128, 128, 86, 158, 159, 22, 137, 82, 158, 159, + 154, 106, 107, 14, 486, 159, 93, 125, 126, 96, + 151, 255, 108, 173, 258, 118, 157, 158, 159, 14, + 18, 295, 11, 14, 22, 128, 24, 25, 92, 93, + 90, 91, 92, 93, 14, 53, 34, 35, 11, 53, + 13, 182, 183, 184, 185, 11, 187, 188, 189, 136, + 22, 49, 128, 51, 14, 537, 538, 33, 34, 90, + 91, 92, 93, 90, 91, 92, 93, 127, 234, 16, + 128, 128, 159, 20, 245, 235, 245, 24, 238, 90, + 91, 92, 93, 128, 11, 226, 227, 228, 229, 230, + 231, 232, 233, 575, 22, 90, 91, 92, 93, 90, + 91, 92, 93, 14, 39, 259, 650, 381, 302, 14, + 90, 91, 92, 93, 11, 552, 13, 599, 90, 91, + 92, 93, 263, 264, 265, 266, 267, 22, 22, 355, + 90, 91, 92, 93, 14, 295, 301, 619, 225, 22, + 82, 301, 283, 16, 11, 432, 13, 20, 242, 243, + 244, 24, 246, 247, 56, 249, 250, 11, 245, 13, + 301, 159, 10, 11, 573, 13, 264, 265, 16, 267, + 311, 11, 20, 13, 82, 316, 24, 25, 22, 90, + 91, 92, 93, 22, 128, 90, 91, 92, 93, 85, + 90, 91, 92, 93, 127, 127, 605, 606, 607, 22, + 90, 91, 92, 93, 358, 13, 54, 90, 91, 92, + 93, 53, 621, 622, 82, 356, 357, 53, 53, 10, + 118, 381, 128, 364, 498, 16, 397, 127, 397, 20, + 41, 79, 641, 24, 58, 401, 396, 127, 432, 30, + 649, 15, 56, 56, 385, 386, 90, 91, 92, 93, + 127, 90, 91, 92, 93, 396, 86, 12, 399, 400, + 13, 25, 549, 25, 25, 25, 426, 128, 18, 56, + 430, 358, 432, 95, 53, 128, 550, 22, 76, 77, + 128, 32, 128, 95, 35, 36, 37, 38, 95, 127, + 455, 90, 91, 92, 93, 455, 12, 128, 439, 12, + 76, 388, 12, 12, 398, 12, 127, 127, 402, 128, + 397, 405, 16, 76, 455, 113, 114, 90, 91, 92, + 93, 119, 127, 127, 122, 123, 124, 125, 126, 22, + 424, 491, 127, 493, 128, 53, 11, 11, 498, 90, + 91, 92, 93, 119, 86, 486, 122, 123, 124, 125, + 126, 114, 12, 518, 127, 549, 119, 127, 518, 122, + 123, 124, 125, 126, 90, 91, 92, 93, 509, 22, + 15, 465, 128, 467, 22, 532, 533, 518, 90, 91, + 92, 93, 539, 127, 478, 551, 127, 127, 475, 549, + 550, 90, 91, 92, 93, 127, 537, 538, 564, 84, + 128, 127, 127, 127, 21, 128, 23, 567, 568, 26, + 22, 28, 29, 573, 22, 127, 127, 42, 17, 576, + 577, 578, 588, 580, 41, 127, 592, 44, 127, 127, + 590, 48, 83, 574, 575, 529, 593, 127, 55, 56, + 57, 58, 59, 600, 601, 605, 606, 607, 90, 91, + 92, 93, 122, 123, 124, 125, 126, 13, 599, 127, + 114, 621, 622, 90, 91, 92, 93, 624, 399, 650, + 574, 493, 418, 633, 276, 629, 285, 136, 619, 645, + 637, 641, 569, 504, 424, 127, 245, 582, 582, 649, + 650, 648, 579, 653, 68, -1, 397, -1, -1, -1, + 127, 658, 76, 77, 78, 3, 4, 5, 6, 7, + 8, 9, -1, -1, -1, 89, -1, -1, -1, 136, + -1, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, -1, -1, -1, -1, 119, -1, -1, 122, 123, + 124, 125, 126, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 186, + -1, -1, -1, -1, -1, 192, -1, -1, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 0, 1, -1, 224, -1, -1, + -1, -1, -1, -1, 10, 11, -1, 13, -1, -1, + 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, + 26, 27, 28, 29, 30, 31, 32, -1, -1, 35, + 36, 37, 38, -1, 40, -1, -1, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, -1, 69, 70, 71, 72, 73, 74, 75, + -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, + -1, 87, -1, -1, -1, -1, -1, -1, 94, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 0, 1, 115, + 116, -1, 118, -1, 120, 121, -1, 10, 11, -1, + 13, -1, 128, 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, 35, 36, 37, 38, -1, 40, -1, -1, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, @@ -1084,62 +1093,17 @@ static const yytype_int16 yycheck[] = 63, 64, 65, 66, 67, -1, 69, 70, 71, 72, 73, 74, 75, -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, 87, -1, -1, -1, -1, -1, - -1, 94, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 0, 1, 115, 116, -1, 118, -1, 120, 121, -1, - 10, 11, -1, 13, -1, 128, 16, -1, -1, 19, - 20, 21, 22, -1, 24, 25, 26, 27, 28, 29, - 30, 31, 32, -1, -1, 35, 36, 37, 38, -1, - 40, -1, -1, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, - 60, 61, 62, 63, 64, 65, 66, 67, -1, 69, - 70, 71, 72, 73, 74, 75, -1, -1, -1, 79, - 80, 81, -1, -1, -1, -1, -1, 87, -1, -1, - -1, -1, -1, -1, 94, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 68, -1, -1, -1, -1, 443, - -1, -1, 76, 77, 78, 115, 116, -1, 118, -1, - 120, 121, -1, -1, -1, 89, -1, -1, 128, -1, - -1, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, -1, -1, -1, -1, 119, -1, 1, 122, 123, - 124, 125, 126, -1, 498, 499, 10, 11, 12, 13, - -1, -1, 16, -1, -1, 19, 20, 21, 22, -1, - 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, - -1, 35, 36, 37, 38, 529, 40, -1, -1, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, - 64, 65, 66, 67, -1, 69, 70, 71, 72, 73, - 74, 75, -1, -1, -1, 79, 80, 81, -1, -1, - -1, -1, -1, 87, -1, -1, -1, -1, -1, -1, - 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1, 115, 116, -1, 118, -1, 120, 121, -1, 10, - 11, 12, 13, -1, 128, 16, -1, -1, 19, 20, - 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, - 31, 32, -1, -1, 35, 36, 37, 38, -1, 40, - -1, -1, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, -1, 69, 70, - 71, 72, 73, 74, 75, -1, -1, -1, 79, 80, - 81, -1, -1, -1, -1, -1, 87, -1, -1, -1, - -1, -1, -1, 94, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1, 115, 116, -1, 118, -1, 120, - 121, -1, 10, 11, 12, 13, -1, 128, 16, -1, - -1, 19, 20, 21, 22, -1, 24, 25, 26, 27, - 28, 29, 30, 31, 32, -1, -1, 35, 36, 37, - 38, -1, 40, -1, -1, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, - -1, 69, 70, 71, 72, 73, 74, 75, -1, -1, - -1, 79, 80, 81, -1, -1, -1, -1, -1, 87, - -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1, 115, 116, -1, - 118, -1, 120, 121, -1, 10, 11, 12, 13, -1, - 128, 16, -1, -1, 19, 20, 21, 22, -1, 24, + -1, 94, -1, -1, -1, 68, -1, -1, -1, -1, + -1, -1, -1, 76, 77, 78, 443, -1, -1, -1, + -1, -1, 115, 116, -1, 118, 89, 120, 121, -1, + -1, -1, 95, 96, 97, 128, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, -1, -1, -1, -1, 119, -1, -1, 122, + 123, 124, 125, 126, -1, -1, 1, -1, -1, -1, + -1, -1, 499, 500, -1, 10, 11, 12, 13, -1, + -1, 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, - 35, 36, 37, 38, -1, 40, -1, -1, 43, 44, + 35, 36, 37, 38, 531, 40, -1, -1, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, -1, 69, 70, 71, 72, 73, 74, @@ -1170,18 +1134,18 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 115, 116, -1, 118, - -1, 120, 121, -1, 10, 11, -1, 13, -1, 128, + -1, 120, 121, -1, 10, 11, 12, 13, -1, 128, 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, 35, 36, 37, 38, -1, 40, -1, -1, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, -1, 69, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, 84, -1, + -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, 87, -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 115, - 116, -1, 118, -1, 120, 121, -1, 10, 11, -1, + 116, -1, 118, -1, 120, 121, -1, 10, 11, 12, 13, -1, 128, 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, 35, 36, 37, 38, -1, 40, -1, -1, @@ -1193,177 +1157,213 @@ static const yytype_int16 yycheck[] = -1, 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 115, 116, -1, 118, -1, 120, 121, -1, - 10, 11, -1, 13, -1, 128, 16, -1, -1, 19, + 10, 11, 12, 13, -1, 128, 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, 35, 36, 37, 38, -1, 40, -1, -1, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, - 60, 61, 62, 63, 64, 65, -1, 67, -1, 69, + 60, 61, 62, 63, 64, 65, 66, 67, -1, 69, 70, 71, 72, 73, 74, 75, -1, -1, -1, 79, - 80, 81, -1, 1, -1, -1, -1, 87, -1, -1, - -1, -1, 10, -1, 94, 13, -1, -1, 16, -1, - -1, 19, 20, 21, 22, -1, 24, 25, -1, -1, - -1, 29, 30, -1, -1, 115, 116, -1, 118, -1, - 120, 121, -1, -1, -1, -1, 44, 45, 128, -1, - -1, 49, 50, -1, 52, 53, 54, 55, 56, 57, - -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, - -1, -1, 70, 71, 72, 73, 74, 75, -1, -1, - -1, 79, 80, 81, -1, 1, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, 94, 13, -1, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, 115, 116, -1, - 118, -1, 120, 121, -1, -1, -1, -1, 44, 45, - 128, -1, -1, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, 11, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, 11, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, -1, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, -1, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, 11, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, -1, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, 127, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, -1, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, 10, -1, -1, 13, 94, -1, - 16, -1, -1, 19, 20, 21, -1, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, -1, -1, 115, - 116, -1, 118, -1, 120, 121, -1, -1, 44, 45, - -1, -1, 128, 49, 50, -1, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, -1, -1, 70, 71, 72, 73, 74, 75, - -1, -1, -1, 79, 80, 81, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 94, -1, - -1, -1, 68, -1, -1, -1, -1, -1, -1, -1, - 76, 77, 78, -1, -1, -1, -1, -1, -1, 115, - 116, -1, 118, 89, 120, 121, -1, -1, -1, 95, - 96, 97, 128, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, -1, - -1, -1, -1, 119, 68, -1, 122, 123, 124, 125, - 126, -1, 76, 77, 78, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 89, -1, -1, -1, -1, - -1, 95, 96, 97, -1, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, -1, -1, -1, -1, 119, 68, -1, 122, 123, - 124, 125, 126, -1, 76, 77, 78, -1, -1, -1, + 80, 81, -1, -1, -1, -1, -1, 87, -1, -1, + -1, -1, -1, -1, 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 95, 96, 97, -1, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, -1, -1, -1, -1, 119, 68, -1, - 122, 123, 124, 125, 126, -1, 76, 77, 78, -1, + -1, -1, -1, -1, 1, 115, 116, -1, 118, -1, + 120, 121, -1, 10, 11, -1, 13, -1, 128, 16, + -1, -1, 19, 20, 21, 22, -1, 24, 25, 26, + 27, 28, 29, 30, 31, 32, -1, -1, 35, 36, + 37, 38, -1, 40, -1, -1, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, + 67, -1, 69, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, 84, -1, -1, + 87, -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 76, 77, 78, -1, 119, - -1, -1, 122, 123, 124, 125, 126, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 76, 77, - 78, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, -1, -1, -1, -1, 119, -1, - -1, 122, 123, 124, 125, 126, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 76, 77, 78, - -1, 119, -1, -1, 122, 123, 124, 125, 126, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 76, 77, - 78, -1, -1, -1, -1, -1, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, -1, 76, 77, 78, - 119, -1, -1, 122, 123, 124, 125, 126, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 76, 77, 78, - -1, 119, -1, -1, 122, 123, 124, 125, 126, 108, + -1, -1, -1, -1, -1, -1, -1, 1, 115, 116, + -1, 118, -1, 120, 121, -1, 10, 11, -1, 13, + -1, 128, 16, -1, -1, 19, 20, 21, 22, -1, + 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, + -1, 35, 36, 37, 38, -1, 40, -1, -1, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, -1, 69, 70, 71, 72, 73, + 74, 75, -1, -1, -1, 79, 80, 81, -1, -1, + -1, -1, -1, 87, -1, -1, -1, -1, -1, -1, + 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1, 115, 116, -1, 118, -1, 120, 121, -1, 10, + 11, -1, 13, -1, 128, 16, -1, -1, 19, 20, + 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, + 31, 32, -1, -1, 35, 36, 37, 38, -1, 40, + -1, -1, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, -1, 67, -1, 69, 70, + 71, 72, 73, 74, 75, -1, -1, -1, 79, 80, + 81, -1, 1, -1, -1, -1, 87, -1, -1, -1, + -1, 10, -1, 94, 13, -1, -1, 16, -1, -1, + 19, 20, 21, 22, -1, 24, 25, -1, -1, -1, + 29, 30, -1, -1, 115, 116, -1, 118, -1, 120, + 121, -1, -1, -1, -1, 44, 45, 128, -1, -1, + 49, 50, -1, 52, 53, 54, 55, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, -1, + -1, 70, 71, 72, 73, 74, 75, -1, -1, -1, + 79, 80, 81, -1, 1, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, 94, 13, -1, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, 115, 116, -1, 118, + -1, 120, 121, -1, -1, -1, -1, 44, 45, 128, + -1, -1, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, 11, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, 11, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + -1, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + -1, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, 11, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + -1, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + 127, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + -1, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, 13, 94, -1, 16, + -1, -1, 19, 20, 21, -1, -1, 24, 25, -1, + -1, -1, 29, 30, -1, -1, -1, -1, 115, 116, + -1, 118, -1, 120, 121, -1, -1, 44, 45, -1, + -1, 128, 49, 50, -1, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, -1, -1, 70, 71, 72, 73, 74, 75, -1, + -1, -1, 79, 80, 81, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 94, -1, -1, + -1, 68, -1, -1, -1, -1, -1, -1, -1, 76, + 77, 78, -1, -1, -1, -1, -1, -1, 115, 116, + -1, 118, 89, 120, 121, -1, -1, -1, 95, 96, + 97, 128, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, -1, -1, + -1, -1, 119, 68, -1, 122, 123, 124, 125, 126, + -1, 76, 77, 78, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 95, 96, 97, -1, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + -1, -1, -1, -1, 119, 68, -1, 122, 123, 124, + 125, 126, -1, 76, 77, 78, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 97, -1, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, -1, -1, -1, -1, 119, 68, -1, 122, + 123, 124, 125, 126, -1, 76, 77, 78, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 76, 77, 78, -1, 119, -1, + -1, 122, 123, 124, 125, 126, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 76, 77, 78, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, -1, -1, -1, -1, 119, -1, -1, + 122, 123, 124, 125, 126, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 76, 77, 78, -1, 119, -1, -1, 122, 123, 124, 125, 126, -1, -1, - -1, 110, 111, 112, 113, 114, 76, 77, 78, -1, - 119, -1, -1, 122, 123, 124, 125, 126, -1, -1, - -1, 111, 112, 113, 114, -1, -1, -1, -1, 119, + -1, -1, -1, -1, -1, -1, -1, 76, 77, 78, + -1, -1, -1, -1, -1, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, -1, 76, 77, 78, 119, + -1, -1, 122, 123, 124, 125, 126, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 76, 77, 78, -1, + 119, -1, -1, 122, 123, 124, 125, 126, 108, 109, + 110, 111, 112, 113, 114, 76, 77, 78, -1, 119, -1, -1, 122, 123, 124, 125, 126, -1, -1, -1, - -1, -1, 112, 113, 114, -1, -1, -1, -1, 119, - -1, -1, 122, 123, 124, 125, 126 + 110, 111, 112, 113, 114, 76, 77, 78, -1, 119, + -1, -1, 122, 123, 124, 125, 126, -1, -1, 110, + 111, 112, 113, 114, 76, 77, 78, -1, 119, -1, + -1, 122, 123, 124, 125, 126, -1, -1, -1, -1, + 111, 112, 113, 114, -1, -1, -1, -1, 119, -1, + -1, 122, 123, 124, 125, 126, -1, -1, -1, -1, + 112, 113, 114, -1, -1, -1, -1, 119, -1, -1, + 122, 123, 124, 125, 126 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -1414,28 +1414,28 @@ static const yytype_uint8 yystos[] = 165, 165, 173, 201, 165, 58, 185, 185, 15, 127, 201, 184, 127, 56, 183, 56, 142, 199, 199, 224, 202, 14, 204, 127, 86, 127, 201, 12, 201, 13, - 22, 14, 127, 98, 25, 201, 201, 25, 25, 25, - 25, 25, 127, 201, 128, 127, 22, 14, 22, 14, - 22, 14, 22, 12, 18, 141, 11, 22, 183, 56, - 95, 174, 201, 174, 128, 226, 233, 128, 140, 166, - 171, 174, 175, 201, 229, 142, 173, 172, 201, 148, - 142, 53, 153, 22, 142, 196, 197, 154, 95, 95, - 189, 127, 197, 128, 140, 192, 193, 127, 23, 140, - 225, 223, 127, 14, 201, 12, 215, 22, 14, 127, - 224, 12, 12, 12, 12, 142, 142, 11, 22, 222, - 127, 127, 227, 228, 233, 128, 142, 127, 22, 159, - 174, 127, 127, 12, 128, 140, 145, 53, 182, 11, - 183, 215, 215, 194, 11, 201, 86, 14, 12, 127, - 22, 161, 142, 215, 143, 143, 15, 127, 174, 174, - 143, 157, 128, 127, 170, 170, 146, 160, 223, 183, - 148, 22, 198, 199, 127, 200, 84, 148, 162, 33, - 34, 140, 167, 167, 233, 128, 127, 127, 168, 172, - 174, 143, 143, 143, 233, 143, 22, 196, 12, 148, - 140, 149, 12, 148, 143, 128, 174, 143, 143, 22, - 127, 168, 168, 168, 147, 42, 169, 12, 22, 56, - 163, 12, 174, 127, 168, 168, 158, 143, 127, 139, - 17, 83, 140, 164, 127, 143, 170, 168, 148, 143, - 168, 175, 84, 167, 127, 143 + 22, 14, 127, 98, 25, 181, 201, 201, 25, 25, + 25, 25, 25, 127, 201, 128, 127, 22, 14, 22, + 14, 22, 14, 22, 12, 18, 141, 11, 22, 183, + 56, 95, 174, 201, 174, 128, 226, 233, 128, 140, + 166, 171, 174, 175, 201, 229, 142, 173, 172, 201, + 148, 142, 53, 153, 22, 142, 196, 197, 154, 95, + 95, 189, 127, 197, 128, 140, 192, 193, 127, 23, + 140, 225, 223, 127, 14, 201, 12, 215, 128, 22, + 14, 127, 224, 12, 12, 12, 12, 142, 142, 11, + 22, 222, 127, 127, 227, 228, 233, 128, 142, 127, + 22, 159, 174, 127, 127, 12, 128, 140, 145, 53, + 182, 11, 183, 215, 215, 194, 11, 201, 86, 14, + 224, 12, 127, 22, 161, 142, 215, 143, 143, 15, + 127, 174, 174, 143, 157, 128, 127, 170, 170, 146, + 160, 223, 183, 148, 22, 198, 199, 127, 200, 127, + 84, 148, 162, 33, 34, 140, 167, 167, 233, 128, + 127, 127, 168, 172, 174, 143, 143, 143, 233, 143, + 22, 196, 12, 148, 140, 149, 12, 148, 143, 128, + 174, 143, 143, 22, 127, 168, 168, 168, 147, 42, + 169, 12, 22, 56, 163, 12, 174, 127, 168, 168, + 158, 143, 127, 139, 17, 83, 140, 164, 127, 143, + 170, 168, 148, 143, 168, 175, 84, 167, 127, 143 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ @@ -1457,24 +1457,24 @@ static const yytype_uint8 yyr1[] = 191, 191, 192, 192, 193, 195, 194, 196, 196, 197, 198, 198, 200, 199, 201, 201, 201, 201, 201, 202, 202, 202, 203, 203, 203, 203, 203, 203, 203, 203, - 203, 203, 204, 203, 205, 205, 206, 206, 206, 206, + 203, 203, 203, 203, 204, 203, 205, 205, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, + 206, 206, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, - 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, - 207, 207, 208, 208, 208, 208, 208, 209, 209, 210, - 210, 210, 210, 211, 211, 212, 212, 212, 212, 212, - 212, 212, 212, 212, 213, 213, 213, 213, 213, 214, - 214, 215, 215, 215, 215, 215, 215, 215, 215, 215, + 207, 207, 207, 207, 208, 208, 208, 208, 208, 209, + 209, 210, 210, 210, 210, 211, 211, 212, 212, 212, + 212, 212, 212, 212, 212, 212, 213, 213, 213, 213, + 213, 214, 214, 215, 215, 215, 215, 215, 215, 215, + 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, 215, 216, - 215, 215, 215, 215, 217, 217, 217, 217, 218, 218, - 218, 218, 218, 219, 219, 219, 220, 220, 220, 221, - 222, 221, 223, 223, 224, 224, 225, 225, 226, 227, - 227, 227, 228, 229, 229, 229, 230, 230, 231, 231, - 232, 233, 234, 235, 236, 236, 237, 238, 238, 239, - 239, 240, 240, 241, 241, 241, 241 + 215, 216, 215, 215, 215, 215, 217, 217, 217, 217, + 218, 218, 218, 218, 218, 219, 219, 219, 220, 220, + 220, 221, 222, 221, 223, 223, 224, 224, 225, 225, + 226, 227, 227, 227, 228, 229, 229, 229, 230, 230, + 231, 231, 232, 233, 234, 235, 236, 236, 237, 238, + 238, 239, 239, 240, 240, 241, 241, 241, 241 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -1495,25 +1495,25 @@ static const yytype_int8 yyr2[] = 3, 4, 2, 3, 4, 1, 1, 2, 3, 1, 1, 1, 1, 1, 3, 0, 2, 1, 1, 4, 1, 1, 0, 6, 3, 3, 3, 3, 1, 2, - 3, 1, 3, 3, 5, 6, 3, 3, 5, 2, - 4, 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, - 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 1, 3, 2, 2, 3, 3, 3, 1, - 3, 2, 2, 3, 3, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 3, 4, 5, 4, 4, 2, - 2, 1, 1, 1, 1, 5, 2, 1, 2, 3, - 1, 2, 1, 1, 1, 1, 1, 1, 4, 4, - 5, 5, 1, 1, 3, 4, 3, 4, 4, 4, - 4, 4, 1, 2, 2, 1, 2, 2, 1, 2, - 1, 2, 1, 3, 1, 3, 1, 3, 4, 0, - 6, 1, 1, 1, 3, 2, 4, 3, 3, 2, - 1, 1, 1, 1, 1, 1, 2, 1, 1, 3, - 0, 6, 1, 1, 1, 1, 1, 2, 1, 2, - 3, 1, 1, 1, 1, 1, 1, 1, 2, 2, - 2, 2, 2, 2, 2, 4, 2, 1, 3, 1, - 3, 1, 3, 1, 1, 1, 1 + 3, 1, 3, 3, 5, 6, 3, 7, 4, 3, + 5, 2, 4, 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, 1, 1, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 1, 3, 2, 2, 3, 3, + 3, 1, 3, 2, 2, 3, 3, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 3, 4, 5, 4, + 4, 2, 2, 1, 1, 1, 1, 5, 2, 1, + 2, 3, 1, 2, 1, 1, 1, 1, 1, 1, + 4, 4, 5, 5, 1, 1, 3, 4, 3, 4, + 4, 4, 4, 4, 1, 2, 2, 1, 2, 2, + 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, + 4, 0, 6, 1, 1, 1, 3, 2, 4, 3, + 3, 2, 1, 1, 1, 1, 1, 1, 2, 1, + 1, 3, 0, 6, 1, 1, 1, 1, 1, 2, + 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 4, 2, 1, + 3, 1, 3, 1, 3, 1, 1, 1, 1 }; typedef enum { @@ -1571,6 +1571,6 @@ static const toketypes yy_type_tab[] = }; /* Generated from: - * 59c1b0d8db6eb03422c4aa700803c201837a9c4085a3177364c2eda6cbeb7cc7 perly.y + * 0f40c00aa6e92910072b579304d07e319b034979bfaf4292495c7a23de0bd41a perly.y * f13e9c08cea6302f0c1d1f467405bd0e0880d0ea92d0669901017a7f7e94ab28 regen_perly.pl * ex: set ro ft=c: */ diff --git a/perly.y b/perly.y index 722c8ffdd1d2..2cba2c32f5ae 100644 --- a/perly.y +++ b/perly.y @@ -1006,6 +1006,18 @@ listop : LSTOP indirob listexpr /* map {...} @args or print $fh @args */ op_append_elem(OP_LIST, scalar($term), newMETHOP(OP_METHOD, 0, $methodname))); } + | term ARROW PERLY_AMPERSAND subname[method] PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE /* $foo->&bar(list) */ + { $$ = op_convert_list(OP_ENTERSUB, OPf_STACKED, + op_append_elem(OP_LIST, + op_prepend_elem(OP_LIST, scalar($term), $optexpr), + newCVREF(0, $method))); + } + | term ARROW PERLY_AMPERSAND subname[method] /* $foo->&bar */ + { $$ = op_convert_list(OP_ENTERSUB, OPf_STACKED, + op_append_elem(OP_LIST, + scalar($term), + newCVREF(0, $method))); + } | METHCALL0 indirob optlistexpr /* new Class @args */ { $$ = op_convert_list(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, diff --git a/pod/perlclass.pod b/pod/perlclass.pod index aa69f9b2bb27..298ff6e85846 100644 --- a/pod/perlclass.pod +++ b/pod/perlclass.pod @@ -191,9 +191,9 @@ but does not appear in the symbol table. The effect is that of a I method; one that can be called from within the class's own code, but not from outside. -At present, there is no special syntax for invoking a lexical method, so for -now they must be called as if they are regular (lexical) subroutines, -remembering to pass the C<$self> invocant as the first positional argument. +To invoke these lexical subroutines as methods, it is best to use the +C<< ->& >> operator. This bypasses method lookup by name, and directly +invokes a lexical subroutine as if it was a method. class LexicalMethod { my method abc ($x, $y) { @@ -201,10 +201,12 @@ remembering to pass the C<$self> invocant as the first positional argument. } method xyz { - abc($self, "x", "y"); + $self->&abc("x", "y"); } } + # The `abc` method is not visible from here + =head1 ATTRIBUTES Specific aspects of the keywords mentioned above are managed using diff --git a/pod/perldelta.pod b/pod/perldelta.pod index 5309b76b8a79..334cb39023cb 100644 --- a/pod/perldelta.pod +++ b/pod/perldelta.pod @@ -27,12 +27,21 @@ here, but most should go in the L section. [ List each enhancement as a =head2 entry ] -=head2 Lexical method syntax using C +=head2 Lexical method declaration using C Like C since Perl version 5.18, C can now be prefixed with the C keyword. This declares a subroutine that has lexical, rather than package visibility. See L for more detail. +=head2 Lexical method invocation operator C<< ->& >> + +Along with the ability to declare methods lexically, this release also permits +invoking a lexical subroutine as if it were a method, bypassing the usual +name-based method resolution by name. + +Combined with lexical method declaration, these two new abilities create the +effect of having private methods. + =head1 Security XXX Any security-related notices go here. In particular, any security diff --git a/pod/perlop.pod b/pod/perlop.pod index 7af391216a80..925f2824b60a 100644 --- a/pod/perlop.pod +++ b/pod/perlop.pod @@ -236,6 +236,12 @@ and (if it is a method name) the left side must be either an object (a blessed reference) or a class name (that is, a package name). See L. +The right side may also be the name of a subroutine, prefixed with the C<&> +sigil. This creates what looks like a lexical method invocation, where the +method subroutine is resolved lexically instead of by name by a search within +the packages of the object's class. This resolution happens entirely at +compile-time, and performs the same as a regular subroutine call at runtime. + The dereferencing cases (as opposed to method-calling cases) are somewhat extended by the C feature. For the details of that feature, consult L. diff --git a/t/class/method.t b/t/class/method.t index f655fc41d1eb..96dcf54e2cb7 100644 --- a/t/class/method.t +++ b/t/class/method.t @@ -103,4 +103,35 @@ no warnings 'experimental::class'; ok(!Testcase7->can("priv"), 'lexical method does not appear in the symbol table'); } +# ->& operator can invoke methods with lexical scope +{ + class Testcase8 { + my method priv { + return "private-result"; + } + + method notpriv { + return "pkg-result"; + } + + method lexm_paren { return $self->&priv(); } + method lexm_plain { return $self->&priv; } + + method pkgm { return $self->¬priv; } + } + + is(Testcase8->new->lexm_paren, "private-result", 'lexical method can be invoked with ->&m()'); + is(Testcase8->new->lexm_plain, "private-result", 'lexical method can be invoked with ->&m'); + is(Testcase8->new->pkgm, "pkg-result", 'package method can be invoked with ->&m'); + + class Testcase8Derived :isa(Testcase8) { + method notpriv { + return "different result"; + } + } + + is(Testcase8Derived->new->pkgm, "pkg-result", + '->&m operator does not follow inheritance'); +} + done_testing; diff --git a/toke.c b/toke.c index 4c9067198e92..0d45a3b01757 100644 --- a/toke.c +++ b/toke.c @@ -5959,6 +5959,8 @@ yyl_hyphen(pTHX_ char *s) } else if (*s == '$') OPERATOR(ARROW); + else if (*s == '&') + OPERATOR(ARROW); else TERM(ARROW); }