From af33570fec10a70c2bac631ecf92053a0234717a Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Sat, 3 May 2025 14:58:39 +0100 Subject: [PATCH 1/5] Rename fields of `struct yy_parser_signature` for clarity The previous names were just copied from similar fields in previous signature handling code. These new names are a better fit for their current and intended future purpose. --- op.c | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/op.c b/op.c index 6c9ff7352f7c..17c2d46f66d2 100644 --- a/op.c +++ b/op.c @@ -16558,8 +16558,16 @@ Perl_rcpv_copy(pTHX_ char *pv) { /* Subroutine signature parsing */ struct yy_parser_signature { - UV elems; /* number of signature elements seen so far */ - UV optelems; /* number of optional signature elems seen */ + /* A note on terminology. We call each variable that appears in a + * signature a "parameter", and each scalar value the caller passes in at + * call time we call an "argument". + * Each scalar parameter variable will correspond to one argument value. + * The complication arises when we consider a slurpy array or hash + * parameter. Here, while it is exactly one *parameter*, it may account + * zero or more arguments. + */ + UV next_argix; /* the argument index of the next parameter we add */ + UV opt_params; /* number of optional scalar parameters */ char slurpy; /* the sigil of the slurpy var (or null) */ OP *elemops; /* NULL, or an OP_LINESEQ of individual element and fence ops */ }; @@ -16590,8 +16598,8 @@ Perl_subsignature_start(pTHX) Newx(signature, 1, yy_parser_signature); SAVEDESTRUCTOR_X(&destroy_subsignature_context, signature); - signature->elems = 0; - signature->optelems = 0; + signature->next_argix = 0; + signature->opt_params = 0; signature->slurpy = 0; signature->elemops = NULL; @@ -16649,7 +16657,8 @@ Perl_subsignature_append_positional(pTHX_ PADOFFSET padix, OPCODE defmode, OP *d if(signature->slurpy) yyerror("Slurpy parameter not last"); - UV argix = signature->elems; + UV argix = signature->next_argix; + signature->next_argix++; OP *varop = NULL; if(padix) { @@ -16661,10 +16670,8 @@ Perl_subsignature_append_positional(pTHX_ PADOFFSET padix, OPCODE defmode, OP *d cUNOP_AUXx(varop)->op_aux = INT2PTR(UNOP_AUX_item *, argix); } - signature->elems++; - if(defexpr) { - signature->optelems++; + signature->opt_params++; if(defexpr->op_type == OP_NULL && !(defexpr->op_flags & OPf_KIDS)) { @@ -16704,7 +16711,7 @@ Perl_subsignature_append_positional(pTHX_ PADOFFSET padix, OPCODE defmode, OP *d } } else - if(signature->optelems) + if(signature->opt_params) yyerror("Mandatory parameter follows optional parameter"); if(varop) { @@ -16731,7 +16738,8 @@ Perl_subsignature_append_slurpy(pTHX_ I32 sigil, PADOFFSET padix) if(signature->slurpy) yyerror("Multiple slurpy parameters not allowed"); - UV argix = signature->elems; + UV argix = signature->next_argix; + /* do not increment */ signature->slurpy = (char)sigil; @@ -16771,8 +16779,8 @@ Perl_subsignature_finish(pTHX) struct op_argcheck_aux *aux = (struct op_argcheck_aux *) PerlMemShared_malloc( sizeof(struct op_argcheck_aux)); - aux->params = signature->elems; - aux->opt_params = signature->optelems; + aux->params = signature->next_argix; + aux->opt_params = signature->opt_params; aux->slurpy = signature->slurpy; OP *check = newUNOP_AUX(OP_ARGCHECK, 0, NULL, (UNOP_AUX_item *)aux); From c40e7ffafd6996a44f8d0223e347d2134fb6aa40 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 6 Aug 2025 11:58:17 +0100 Subject: [PATCH 2/5] perly.y: Reduce repetition of signature scalar element grammar By defining a helper term for optional defaulting expression we can remove one of the three alternate cases down to just two. This will help when adding more code to these action blocks in future, --- perly.act | 735 ++++++++++++------------- perly.h | 2 +- perly.tab | 1587 +++++++++++++++++++++++++++-------------------------- perly.y | 17 +- 4 files changed, 1171 insertions(+), 1170 deletions(-) diff --git a/perly.act b/perly.act index 344fdf894d2a..e052adcce1e1 100644 --- a/perly.act +++ b/perly.act @@ -991,44 +991,41 @@ case 2: /* @1: %empty */ break; - case 127: /* sigscalarelem: PERLY_DOLLAR sigvar ASSIGNOP */ + case 127: /* sigscalarelem: PERLY_DOLLAR sigvar ASSIGNOP optsigscalardefault */ #line 861 "perly.y" { - subsignature_append_positional((ps[-1].val.ival), (ps[0].val.ival), newOP(OP_NULL, 0)); + subsignature_append_positional((ps[-2].val.ival), (ps[-1].val.ival), (ps[0].val.opval)); (yyval.opval) = NULL; } break; - case 128: /* sigscalarelem: PERLY_DOLLAR sigvar ASSIGNOP term */ -#line 866 "perly.y" - { - subsignature_append_positional((ps[-2].val.ival), (ps[-1].val.ival), (ps[0].val.opval)); - (yyval.opval) = NULL; - } + case 128: /* optsigscalardefault: %empty */ +#line 869 "perly.y" + { (yyval.opval) = newOP(OP_NULL, 0); } break; - case 129: /* sigelem: sigscalarelem */ -#line 875 "perly.y" + case 130: /* sigelem: sigscalarelem */ +#line 876 "perly.y" { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); } break; - case 130: /* sigelem: sigslurpelem */ -#line 877 "perly.y" + case 131: /* sigelem: sigslurpelem */ +#line 878 "perly.y" { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); } break; - case 138: /* subsignature: PERLY_PAREN_OPEN subsigguts PERLY_PAREN_CLOSE */ -#line 903 "perly.y" + case 139: /* subsignature: PERLY_PAREN_OPEN subsigguts PERLY_PAREN_CLOSE */ +#line 904 "perly.y" { (yyval.opval) = (ps[-1].val.opval); } break; - case 139: /* $@20: %empty */ -#line 906 "perly.y" + case 140: /* $@20: %empty */ +#line 907 "perly.y" { ENTER; subsignature_start(); @@ -1037,8 +1034,8 @@ case 2: /* @1: %empty */ break; - case 140: /* subsigguts: $@20 optsiglist */ -#line 912 "perly.y" + case 141: /* subsigguts: $@20 optsiglist */ +#line 913 "perly.y" { if (!FEATURE_SIGNATURES_IS_ENABLED && !CvIsMETHOD(PL_compcv)) croak("Experimental " @@ -1065,14 +1062,14 @@ case 2: /* @1: %empty */ break; - case 142: /* optsubbody: PERLY_SEMICOLON */ -#line 940 "perly.y" + case 143: /* optsubbody: PERLY_SEMICOLON */ +#line 941 "perly.y" { (yyval.opval) = NULL; } break; - case 143: /* subbody: remember PERLY_BRACE_OPEN stmtseq PERLY_BRACE_CLOSE */ -#line 946 "perly.y" + case 144: /* subbody: remember PERLY_BRACE_OPEN stmtseq PERLY_BRACE_CLOSE */ +#line 947 "perly.y" { if (parser->copline > (line_t)(ps[-2].val.ival)) parser->copline = (line_t)(ps[-2].val.ival); @@ -1081,20 +1078,20 @@ case 2: /* @1: %empty */ break; - case 145: /* optsigsubbody: PERLY_SEMICOLON */ -#line 958 "perly.y" + case 146: /* optsigsubbody: PERLY_SEMICOLON */ +#line 959 "perly.y" { (yyval.opval) = NULL; } break; - case 146: /* $@21: %empty */ -#line 963 "perly.y" + case 147: /* $@21: %empty */ +#line 964 "perly.y" { PL_parser->sig_seen = FALSE; } break; - case 147: /* sigsubbody: remember optsubsignature PERLY_BRACE_OPEN $@21 stmtseq PERLY_BRACE_CLOSE */ -#line 965 "perly.y" + case 148: /* sigsubbody: remember optsubsignature PERLY_BRACE_OPEN $@21 stmtseq PERLY_BRACE_CLOSE */ +#line 966 "perly.y" { if (parser->copline > (line_t)(ps[-3].val.ival)) parser->copline = (line_t)(ps[-3].val.ival); @@ -1104,38 +1101,38 @@ case 2: /* @1: %empty */ break; - case 148: /* expr: expr ANDOP expr */ -#line 976 "perly.y" + case 149: /* expr: expr ANDOP expr */ +#line 977 "perly.y" { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 149: /* expr: expr PLUGIN_LOGICAL_AND_LOW_OP expr */ -#line 978 "perly.y" + case 150: /* expr: expr PLUGIN_LOGICAL_AND_LOW_OP expr */ +#line 979 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 150: /* expr: expr OROP expr */ -#line 980 "perly.y" + case 151: /* expr: expr OROP expr */ +#line 981 "perly.y" { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 151: /* expr: expr PLUGIN_LOGICAL_OR_LOW_OP expr */ -#line 982 "perly.y" + case 152: /* expr: expr PLUGIN_LOGICAL_OR_LOW_OP expr */ +#line 983 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 153: /* listexpr: listexpr PERLY_COMMA */ -#line 988 "perly.y" + case 154: /* listexpr: listexpr PERLY_COMMA */ +#line 989 "perly.y" { (yyval.opval) = (ps[-1].val.opval); } break; - case 154: /* listexpr: listexpr PERLY_COMMA term */ -#line 990 "perly.y" + case 155: /* listexpr: listexpr PERLY_COMMA term */ +#line 991 "perly.y" { OP* term = (ps[0].val.opval); (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term); @@ -1143,32 +1140,32 @@ case 2: /* @1: %empty */ break; - case 156: /* listop: LSTOP indirob listexpr */ -#line 999 "perly.y" + case 157: /* listop: LSTOP indirob listexpr */ +#line 1000 "perly.y" { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED, op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) ); } break; - case 157: /* listop: BLKLSTOP block listexpr */ -#line 1003 "perly.y" + case 158: /* listop: BLKLSTOP block listexpr */ +#line 1004 "perly.y" { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED, op_prepend_elem(OP_LIST, newUNOP(OP_NULL, 0, op_scope((ps[-1].val.opval))), (ps[0].val.opval)) ); } break; - case 158: /* listop: FUNC PERLY_PAREN_OPEN indirob expr PERLY_PAREN_CLOSE */ -#line 1007 "perly.y" + case 159: /* listop: FUNC PERLY_PAREN_OPEN indirob expr PERLY_PAREN_CLOSE */ +#line 1008 "perly.y" { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED, op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) ); } break; - case 159: /* listop: term ARROW methodname PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ -#line 1011 "perly.y" + case 160: /* listop: term ARROW methodname PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ +#line 1012 "perly.y" { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)), @@ -1177,8 +1174,8 @@ case 2: /* @1: %empty */ break; - case 160: /* listop: term ARROW methodname */ -#line 1017 "perly.y" + case 161: /* listop: term ARROW methodname */ +#line 1018 "perly.y" { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, scalar((ps[-2].val.opval)), newMETHOP(OP_METHOD, 0, (ps[0].val.opval)))); @@ -1186,8 +1183,8 @@ case 2: /* @1: %empty */ break; - case 161: /* listop: term ARROW PERLY_AMPERSAND subname PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ -#line 1022 "perly.y" + case 162: /* listop: term ARROW PERLY_AMPERSAND subname PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ +#line 1023 "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)), @@ -1196,8 +1193,8 @@ case 2: /* @1: %empty */ break; - case 162: /* listop: term ARROW PERLY_AMPERSAND subname */ -#line 1028 "perly.y" + case 163: /* listop: term ARROW PERLY_AMPERSAND subname */ +#line 1029 "perly.y" { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, scalar((ps[-3].val.opval)), @@ -1206,8 +1203,8 @@ case 2: /* @1: %empty */ break; - case 163: /* listop: METHCALL0 indirob optlistexpr */ -#line 1034 "perly.y" + case 164: /* listop: METHCALL0 indirob optlistexpr */ +#line 1035 "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)), @@ -1216,8 +1213,8 @@ case 2: /* @1: %empty */ break; - case 164: /* listop: METHCALL indirob PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ -#line 1040 "perly.y" + case 165: /* listop: METHCALL indirob PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ +#line 1041 "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)), @@ -1226,26 +1223,26 @@ case 2: /* @1: %empty */ break; - case 165: /* listop: LSTOP optlistexpr */ -#line 1046 "perly.y" + case 166: /* listop: LSTOP optlistexpr */ +#line 1047 "perly.y" { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); } break; - case 166: /* listop: FUNC PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ -#line 1048 "perly.y" + case 167: /* listop: FUNC PERLY_PAREN_OPEN optexpr PERLY_PAREN_CLOSE */ +#line 1049 "perly.y" { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); } break; - case 167: /* listop: FUNC SUBLEXSTART optexpr SUBLEXEND */ -#line 1050 "perly.y" + case 168: /* listop: FUNC SUBLEXSTART optexpr SUBLEXEND */ +#line 1051 "perly.y" { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); } break; - case 168: /* @22: %empty */ -#line 1052 "perly.y" + case 169: /* @22: %empty */ +#line 1053 "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 */ @@ -1254,8 +1251,8 @@ case 2: /* @1: %empty */ break; - case 169: /* listop: LSTOPSUB startanonsub block @22 optlistexpr */ -#line 1058 "perly.y" + case 170: /* listop: LSTOPSUB startanonsub block @22 optlistexpr */ +#line 1059 "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))); @@ -1263,21 +1260,21 @@ case 2: /* @1: %empty */ break; - case 172: /* subscripted: gelem PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1073 "perly.y" + case 173: /* subscripted: gelem PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1074 "perly.y" { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); } break; - case 173: /* subscripted: scalar PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1075 "perly.y" + case 174: /* subscripted: scalar PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1076 "perly.y" { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval))); } break; - case 174: /* subscripted: term ARROW PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1078 "perly.y" + case 175: /* subscripted: term ARROW PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1079 "perly.y" { (yyval.opval) = newBINOP(OP_AELEM, 0, ref(newAVREF((ps[-4].val.opval)),OP_RV2AV), scalar((ps[-1].val.opval))); @@ -1285,8 +1282,8 @@ case 2: /* @1: %empty */ break; - case 175: /* subscripted: subscripted PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1083 "perly.y" + case 176: /* subscripted: subscripted PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1084 "perly.y" { (yyval.opval) = newBINOP(OP_AELEM, 0, ref(newAVREF((ps[-3].val.opval)),OP_RV2AV), scalar((ps[-1].val.opval))); @@ -1294,31 +1291,31 @@ case 2: /* @1: %empty */ break; - case 176: /* subscripted: scalar PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1088 "perly.y" + case 177: /* subscripted: scalar PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1089 "perly.y" { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval))); } break; - case 177: /* subscripted: term ARROW PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1091 "perly.y" + case 178: /* subscripted: term ARROW PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1092 "perly.y" { (yyval.opval) = newBINOP(OP_HELEM, 0, ref(newHVREF((ps[-5].val.opval)),OP_RV2HV), jmaybe((ps[-2].val.opval))); } break; - case 178: /* subscripted: subscripted PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1095 "perly.y" + case 179: /* subscripted: subscripted PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1096 "perly.y" { (yyval.opval) = newBINOP(OP_HELEM, 0, ref(newHVREF((ps[-4].val.opval)),OP_RV2HV), jmaybe((ps[-2].val.opval))); } break; - case 179: /* subscripted: term ARROW PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1099 "perly.y" + case 180: /* subscripted: term ARROW PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1100 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, newCVREF(0, scalar((ps[-3].val.opval)))); if (parser->expect == XBLOCK) @@ -1327,8 +1324,8 @@ case 2: /* @1: %empty */ break; - case 180: /* subscripted: term ARROW PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1105 "perly.y" + case 181: /* subscripted: term ARROW PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1106 "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))))); @@ -1338,8 +1335,8 @@ case 2: /* @1: %empty */ break; - case 181: /* subscripted: subscripted PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1113 "perly.y" + case 182: /* subscripted: subscripted PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1114 "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))))); @@ -1349,8 +1346,8 @@ case 2: /* @1: %empty */ break; - case 182: /* subscripted: subscripted PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1120 "perly.y" + case 183: /* subscripted: subscripted PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1121 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, newCVREF(0, scalar((ps[-2].val.opval)))); if (parser->expect == XBLOCK) @@ -1359,56 +1356,56 @@ case 2: /* @1: %empty */ break; - case 183: /* subscripted: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1126 "perly.y" + case 184: /* subscripted: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1127 "perly.y" { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); } break; - case 184: /* subscripted: QWLIST PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1128 "perly.y" + case 185: /* subscripted: QWLIST PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1129 "perly.y" { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); } break; - case 185: /* subscripted: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1130 "perly.y" + case 186: /* subscripted: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1131 "perly.y" { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); } break; - case 186: /* termbinop: term PLUGIN_HIGH_OP term */ -#line 1135 "perly.y" + case 187: /* termbinop: term PLUGIN_HIGH_OP term */ +#line 1136 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 187: /* termbinop: term ASSIGNOP term */ -#line 1137 "perly.y" + case 188: /* termbinop: term ASSIGNOP term */ +#line 1138 "perly.y" { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); } break; - case 188: /* termbinop: term PLUGIN_ASSIGN_OP term */ -#line 1139 "perly.y" + case 189: /* termbinop: term PLUGIN_ASSIGN_OP term */ +#line 1140 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 189: /* termbinop: term POWOP term */ -#line 1141 "perly.y" + case 190: /* termbinop: term POWOP term */ +#line 1142 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 190: /* termbinop: term PLUGIN_POW_OP term */ -#line 1143 "perly.y" + case 191: /* termbinop: term PLUGIN_POW_OP term */ +#line 1144 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 191: /* termbinop: term MULOP term */ -#line 1145 "perly.y" + case 192: /* termbinop: term MULOP term */ +#line 1146 "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))); @@ -1416,220 +1413,220 @@ case 2: /* @1: %empty */ break; - case 192: /* termbinop: term PLUGIN_MUL_OP term */ -#line 1150 "perly.y" + case 193: /* termbinop: term PLUGIN_MUL_OP term */ +#line 1151 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 193: /* termbinop: term ADDOP term */ -#line 1152 "perly.y" + case 194: /* termbinop: term ADDOP term */ +#line 1153 "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 PLUGIN_ADD_OP term */ -#line 1154 "perly.y" + case 195: /* termbinop: term PLUGIN_ADD_OP term */ +#line 1155 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 195: /* termbinop: term SHIFTOP term */ -#line 1156 "perly.y" + case 196: /* termbinop: term SHIFTOP term */ +#line 1157 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 196: /* termbinop: termrelop */ -#line 1158 "perly.y" + case 197: /* termbinop: termrelop */ +#line 1159 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 197: /* termbinop: termeqop */ -#line 1160 "perly.y" + case 198: /* termbinop: termeqop */ +#line 1161 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 198: /* termbinop: term BITANDOP term */ -#line 1162 "perly.y" + case 199: /* termbinop: term BITANDOP term */ +#line 1163 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 199: /* termbinop: term BITOROP term */ -#line 1164 "perly.y" + case 200: /* termbinop: term BITOROP term */ +#line 1165 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 200: /* termbinop: term DOTDOT term */ -#line 1166 "perly.y" + case 201: /* termbinop: term DOTDOT term */ +#line 1167 "perly.y" { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 201: /* termbinop: term ANDAND term */ -#line 1168 "perly.y" + case 202: /* termbinop: term ANDAND term */ +#line 1169 "perly.y" { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 202: /* termbinop: term PLUGIN_LOGICAL_AND_OP term */ -#line 1170 "perly.y" + case 203: /* termbinop: term PLUGIN_LOGICAL_AND_OP term */ +#line 1171 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 203: /* termbinop: term OROR term */ -#line 1172 "perly.y" + case 204: /* termbinop: term OROR term */ +#line 1173 "perly.y" { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 204: /* termbinop: term PLUGIN_LOGICAL_OR_OP term */ -#line 1174 "perly.y" + case 205: /* termbinop: term PLUGIN_LOGICAL_OR_OP term */ +#line 1175 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 205: /* termbinop: term DORDOR term */ -#line 1176 "perly.y" + case 206: /* termbinop: term DORDOR term */ +#line 1177 "perly.y" { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 206: /* termbinop: term MATCHOP term */ -#line 1178 "perly.y" + case 207: /* termbinop: term MATCHOP term */ +#line 1179 "perly.y" { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 207: /* termbinop: term PLUGIN_LOW_OP term */ -#line 1180 "perly.y" + case 208: /* termbinop: term PLUGIN_LOW_OP term */ +#line 1181 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 208: /* termrelop: relopchain */ -#line 1184 "perly.y" + case 209: /* termrelop: relopchain */ +#line 1185 "perly.y" { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); } break; - case 209: /* termrelop: term NCRELOP term */ -#line 1186 "perly.y" + case 210: /* termrelop: term NCRELOP term */ +#line 1187 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 210: /* termrelop: termrelop NCRELOP */ -#line 1188 "perly.y" + case 211: /* termrelop: termrelop NCRELOP */ +#line 1189 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 211: /* termrelop: termrelop CHRELOP */ -#line 1190 "perly.y" + case 212: /* termrelop: termrelop CHRELOP */ +#line 1191 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 212: /* termrelop: term PLUGIN_REL_OP term */ -#line 1192 "perly.y" + case 213: /* termrelop: term PLUGIN_REL_OP term */ +#line 1193 "perly.y" { (yyval.opval) = build_infix_plugin((ps[-2].val.opval), (ps[0].val.opval), (ps[-1].val.pval)); } break; - case 213: /* relopchain: term CHRELOP term */ -#line 1196 "perly.y" + case 214: /* relopchain: term CHRELOP term */ +#line 1197 "perly.y" { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 214: /* relopchain: relopchain CHRELOP term */ -#line 1198 "perly.y" + case 215: /* relopchain: relopchain CHRELOP term */ +#line 1199 "perly.y" { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 215: /* termeqop: eqopchain */ -#line 1202 "perly.y" + case 216: /* termeqop: eqopchain */ +#line 1203 "perly.y" { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); } break; - case 216: /* termeqop: term NCEQOP term */ -#line 1204 "perly.y" + case 217: /* termeqop: term NCEQOP term */ +#line 1205 "perly.y" { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); } break; - case 217: /* termeqop: termeqop NCEQOP */ -#line 1206 "perly.y" + case 218: /* termeqop: termeqop NCEQOP */ +#line 1207 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 218: /* termeqop: termeqop CHEQOP */ -#line 1208 "perly.y" + case 219: /* termeqop: termeqop CHEQOP */ +#line 1209 "perly.y" { yyerror("syntax error"); YYERROR; } break; - case 219: /* eqopchain: term CHEQOP term */ -#line 1212 "perly.y" + case 220: /* eqopchain: term CHEQOP term */ +#line 1213 "perly.y" { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 220: /* eqopchain: eqopchain CHEQOP term */ -#line 1214 "perly.y" + case 221: /* eqopchain: eqopchain CHEQOP term */ +#line 1215 "perly.y" { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 221: /* termunop: PERLY_MINUS term */ -#line 1219 "perly.y" + case 222: /* termunop: PERLY_MINUS term */ +#line 1220 "perly.y" { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); } break; - case 222: /* termunop: PERLY_PLUS term */ -#line 1221 "perly.y" + case 223: /* termunop: PERLY_PLUS term */ +#line 1222 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 223: /* termunop: PERLY_EXCLAMATION_MARK term */ -#line 1224 "perly.y" + case 224: /* termunop: PERLY_EXCLAMATION_MARK term */ +#line 1225 "perly.y" { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); } break; - case 224: /* termunop: PERLY_TILDE term */ -#line 1226 "perly.y" + case 225: /* termunop: PERLY_TILDE term */ +#line 1227 "perly.y" { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); } break; - case 225: /* termunop: term POSTINC */ -#line 1228 "perly.y" + case 226: /* termunop: term POSTINC */ +#line 1229 "perly.y" { (yyval.opval) = newUNOP(OP_POSTINC, 0, op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); } break; - case 226: /* termunop: term POSTDEC */ -#line 1231 "perly.y" + case 227: /* termunop: term POSTDEC */ +#line 1232 "perly.y" { (yyval.opval) = newUNOP(OP_POSTDEC, 0, op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));} break; - case 227: /* termunop: term POSTJOIN */ -#line 1234 "perly.y" + case 228: /* termunop: term POSTJOIN */ +#line 1235 "perly.y" { (yyval.opval) = op_convert_list(OP_JOIN, 0, op_append_elem( OP_LIST, @@ -1643,60 +1640,60 @@ case 2: /* @1: %empty */ break; - case 228: /* termunop: PREINC term */ -#line 1245 "perly.y" + case 229: /* termunop: PREINC term */ +#line 1246 "perly.y" { (yyval.opval) = newUNOP(OP_PREINC, 0, op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); } break; - case 229: /* termunop: PREDEC term */ -#line 1248 "perly.y" + case 230: /* termunop: PREDEC term */ +#line 1249 "perly.y" { (yyval.opval) = newUNOP(OP_PREDEC, 0, op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); } break; - case 230: /* anonymous: PERLY_BRACKET_OPEN optexpr PERLY_BRACKET_CLOSE */ -#line 1256 "perly.y" + case 231: /* anonymous: PERLY_BRACKET_OPEN optexpr PERLY_BRACKET_CLOSE */ +#line 1257 "perly.y" { (yyval.opval) = newANONLIST((ps[-1].val.opval)); } break; - case 231: /* anonymous: HASHBRACK optexpr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1258 "perly.y" + case 232: /* anonymous: HASHBRACK optexpr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1259 "perly.y" { (yyval.opval) = newANONHASH((ps[-2].val.opval)); } break; - case 232: /* anonymous: KW_SUB_anon startanonsub proto subattrlist subbody */ -#line 1260 "perly.y" + case 233: /* anonymous: KW_SUB_anon startanonsub proto subattrlist subbody */ +#line 1261 "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 233: /* anonymous: KW_SUB_anon startanonsub proto subattrlist */ -#line 1263 "perly.y" + case 234: /* anonymous: KW_SUB_anon startanonsub proto subattrlist */ +#line 1264 "perly.y" { yyerror("Illegal declaration of anonymous subroutine"); YYERROR; } break; - case 234: /* anonymous: KW_SUB_anon_sig startanonsub subattrlist sigsubbody */ -#line 1265 "perly.y" + case 235: /* anonymous: KW_SUB_anon_sig startanonsub subattrlist sigsubbody */ +#line 1266 "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 235: /* anonymous: KW_SUB_anon_sig startanonsub subattrlist */ -#line 1268 "perly.y" + case 236: /* anonymous: KW_SUB_anon_sig startanonsub subattrlist */ +#line 1269 "perly.y" { yyerror("Illegal declaration of anonymous subroutine"); YYERROR; } break; - case 236: /* anonymous: KW_METHOD_anon startanonmethod subattrlist sigsubbody */ -#line 1270 "perly.y" + case 237: /* anonymous: KW_METHOD_anon startanonmethod subattrlist sigsubbody */ +#line 1271 "perly.y" { SvREFCNT_inc_simple_void(PL_compcv); (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); @@ -1704,104 +1701,104 @@ case 2: /* @1: %empty */ break; - case 237: /* anonymous: KW_METHOD_anon startanonmethod subattrlist */ -#line 1275 "perly.y" + case 238: /* anonymous: KW_METHOD_anon startanonmethod subattrlist */ +#line 1276 "perly.y" { yyerror("Illegal declaration of anonymous subroutine"); YYERROR; } break; - case 238: /* termdo: KW_DO term */ -#line 1280 "perly.y" + case 239: /* termdo: KW_DO term */ +#line 1281 "perly.y" { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));} break; - case 239: /* termdo: KW_DO block */ -#line 1282 "perly.y" + case 240: /* termdo: KW_DO block */ +#line 1283 "perly.y" { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));} break; - case 244: /* term: term PERLY_QUESTION_MARK term PERLY_COLON term */ -#line 1290 "perly.y" + case 245: /* term: term PERLY_QUESTION_MARK term PERLY_COLON term */ +#line 1291 "perly.y" { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 245: /* term: REFGEN term */ -#line 1292 "perly.y" + case 246: /* term: REFGEN term */ +#line 1293 "perly.y" { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); } break; - case 246: /* term: myattrterm */ -#line 1294 "perly.y" + case 247: /* term: myattrterm */ +#line 1295 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 247: /* term: KW_LOCAL term */ -#line 1296 "perly.y" + case 248: /* term: KW_LOCAL term */ +#line 1297 "perly.y" { (yyval.opval) = localize((ps[0].val.opval),0); } break; - case 248: /* term: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1298 "perly.y" + case 249: /* term: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1299 "perly.y" { (yyval.opval) = sawparens((ps[-1].val.opval)); } break; - case 249: /* term: QWLIST */ -#line 1300 "perly.y" + case 250: /* term: QWLIST */ +#line 1301 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 250: /* term: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1302 "perly.y" + case 251: /* term: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1303 "perly.y" { (yyval.opval) = sawparens(newNULLLIST()); } break; - case 251: /* term: scalar */ -#line 1304 "perly.y" + case 252: /* term: scalar */ +#line 1305 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 252: /* term: star */ -#line 1306 "perly.y" + case 253: /* term: star */ +#line 1307 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 253: /* term: hsh */ -#line 1308 "perly.y" + case 254: /* term: hsh */ +#line 1309 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 254: /* term: ary */ -#line 1310 "perly.y" + case 255: /* term: ary */ +#line 1311 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 255: /* term: arylen */ -#line 1312 "perly.y" + case 256: /* term: arylen */ +#line 1313 "perly.y" { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));} break; - case 256: /* term: subscripted */ -#line 1314 "perly.y" + case 257: /* term: subscripted */ +#line 1315 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 257: /* term: sliceme PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1316 "perly.y" + case 258: /* term: sliceme PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1317 "perly.y" { (yyval.opval) = op_prepend_elem(OP_ASLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_ASLICE, 0, @@ -1814,8 +1811,8 @@ case 2: /* @1: %empty */ break; - case 258: /* term: kvslice PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ -#line 1326 "perly.y" + case 259: /* term: kvslice PERLY_BRACKET_OPEN expr PERLY_BRACKET_CLOSE */ +#line 1327 "perly.y" { (yyval.opval) = op_prepend_elem(OP_KVASLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_KVASLICE, 0, @@ -1828,8 +1825,8 @@ case 2: /* @1: %empty */ break; - case 259: /* term: sliceme PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1336 "perly.y" + case 260: /* term: sliceme PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1337 "perly.y" { (yyval.opval) = op_prepend_elem(OP_HSLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_HSLICE, 0, @@ -1842,8 +1839,8 @@ case 2: /* @1: %empty */ break; - case 260: /* term: kvslice PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ -#line 1346 "perly.y" + case 261: /* term: kvslice PERLY_BRACE_OPEN expr PERLY_SEMICOLON PERLY_BRACE_CLOSE */ +#line 1347 "perly.y" { (yyval.opval) = op_prepend_elem(OP_KVHSLICE, newOP(OP_PUSHMARK, 0), newLISTOP(OP_KVHSLICE, 0, @@ -1856,27 +1853,27 @@ case 2: /* @1: %empty */ break; - case 261: /* term: THING */ -#line 1356 "perly.y" + case 262: /* term: THING */ +#line 1357 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 262: /* term: amper */ -#line 1358 "perly.y" + case 263: /* term: amper */ +#line 1359 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); } break; - case 263: /* term: amper PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1360 "perly.y" + case 264: /* term: amper PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1361 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval))); } break; - case 264: /* term: amper PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1363 "perly.y" + case 265: /* term: amper PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1364 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval)))); @@ -1884,153 +1881,153 @@ case 2: /* @1: %empty */ break; - case 265: /* term: NOAMP subname optlistexpr */ -#line 1368 "perly.y" + case 266: /* term: NOAMP subname optlistexpr */ +#line 1369 "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 266: /* term: term ARROW PERLY_DOLLAR PERLY_STAR */ -#line 1372 "perly.y" + case 267: /* term: term ARROW PERLY_DOLLAR PERLY_STAR */ +#line 1373 "perly.y" { (yyval.opval) = newSVREF((ps[-3].val.opval)); } break; - case 267: /* term: term ARROW PERLY_SNAIL PERLY_STAR */ -#line 1374 "perly.y" + case 268: /* term: term ARROW PERLY_SNAIL PERLY_STAR */ +#line 1375 "perly.y" { (yyval.opval) = newAVREF((ps[-3].val.opval)); } break; - case 268: /* term: term ARROW PERLY_PERCENT_SIGN PERLY_STAR */ -#line 1376 "perly.y" + case 269: /* term: term ARROW PERLY_PERCENT_SIGN PERLY_STAR */ +#line 1377 "perly.y" { (yyval.opval) = newHVREF((ps[-3].val.opval)); } break; - case 269: /* term: term ARROW PERLY_AMPERSAND PERLY_STAR */ -#line 1378 "perly.y" + case 270: /* term: term ARROW PERLY_AMPERSAND PERLY_STAR */ +#line 1379 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); } break; - case 270: /* term: term ARROW PERLY_STAR PERLY_STAR */ -#line 1381 "perly.y" + case 271: /* term: term ARROW PERLY_STAR PERLY_STAR */ +#line 1382 "perly.y" { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); } break; - case 271: /* term: LOOPEX */ -#line 1383 "perly.y" + case 272: /* term: LOOPEX */ +#line 1384 "perly.y" { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL); PL_hints |= HINT_BLOCK_SCOPE; } break; - case 272: /* term: LOOPEX term */ -#line 1386 "perly.y" + case 273: /* term: LOOPEX term */ +#line 1387 "perly.y" { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); } break; - case 273: /* term: NOTOP listexpr */ -#line 1388 "perly.y" + case 274: /* term: NOTOP listexpr */ +#line 1389 "perly.y" { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); } break; - case 274: /* term: UNIOP */ -#line 1390 "perly.y" + case 275: /* term: UNIOP */ +#line 1391 "perly.y" { (yyval.opval) = newOP((ps[0].val.ival), 0); } break; - case 275: /* term: UNIOP block */ -#line 1392 "perly.y" + case 276: /* term: UNIOP block */ +#line 1393 "perly.y" { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); } break; - case 276: /* term: UNIOP term */ -#line 1394 "perly.y" + case 277: /* term: UNIOP term */ +#line 1395 "perly.y" { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); } break; - case 277: /* term: KW_REQUIRE */ -#line 1396 "perly.y" + case 278: /* term: KW_REQUIRE */ +#line 1397 "perly.y" { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); } break; - case 278: /* term: KW_REQUIRE term */ -#line 1398 "perly.y" + case 279: /* term: KW_REQUIRE term */ +#line 1399 "perly.y" { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); } break; - case 279: /* term: UNIOPSUB */ -#line 1400 "perly.y" + case 280: /* term: UNIOPSUB */ +#line 1401 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); } break; - case 280: /* term: UNIOPSUB term */ -#line 1402 "perly.y" + case 281: /* term: UNIOPSUB term */ +#line 1403 "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 281: /* term: FUNC0 */ -#line 1405 "perly.y" + case 282: /* term: FUNC0 */ +#line 1406 "perly.y" { (yyval.opval) = newOP((ps[0].val.ival), 0); } break; - case 282: /* term: FUNC0 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1407 "perly.y" + case 283: /* term: FUNC0 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1408 "perly.y" { (yyval.opval) = newOP((ps[-2].val.ival), 0);} break; - case 283: /* term: FUNC0OP */ -#line 1409 "perly.y" + case 284: /* term: FUNC0OP */ +#line 1410 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 284: /* term: FUNC0OP PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1411 "perly.y" + case 285: /* term: FUNC0OP PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1412 "perly.y" { (yyval.opval) = (ps[-2].val.opval); } break; - case 285: /* term: FUNC0SUB */ -#line 1413 "perly.y" + case 286: /* term: FUNC0SUB */ +#line 1414 "perly.y" { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); } break; - case 286: /* term: FUNC1 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1415 "perly.y" + case 287: /* term: FUNC1 PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1416 "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 287: /* term: FUNC1 PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1419 "perly.y" + case 288: /* term: FUNC1 PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1420 "perly.y" { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); } break; - case 288: /* @23: %empty */ -#line 1421 "perly.y" + case 289: /* @23: %empty */ +#line 1422 "perly.y" { if ( (ps[0].val.opval)->op_type != OP_TRANS && (ps[0].val.opval)->op_type != OP_TRANSR @@ -2044,68 +2041,68 @@ case 2: /* @1: %empty */ break; - case 289: /* term: PMFUNC @23 SUBLEXSTART listexpr optrepl SUBLEXEND */ -#line 1432 "perly.y" + case 290: /* term: PMFUNC @23 SUBLEXSTART listexpr optrepl SUBLEXEND */ +#line 1433 "perly.y" { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); } break; - case 293: /* myattrterm: KW_MY myterm myattrlist */ -#line 1441 "perly.y" + case 294: /* myattrterm: KW_MY myterm myattrlist */ +#line 1442 "perly.y" { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); } break; - case 294: /* myattrterm: KW_MY myterm */ -#line 1443 "perly.y" + case 295: /* myattrterm: KW_MY myterm */ +#line 1444 "perly.y" { (yyval.opval) = localize((ps[0].val.opval),1); } break; - case 295: /* myattrterm: KW_MY REFGEN myterm myattrlist */ -#line 1445 "perly.y" + case 296: /* myattrterm: KW_MY REFGEN myterm myattrlist */ +#line 1446 "perly.y" { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); } break; - case 296: /* myattrterm: KW_MY REFGEN term */ -#line 1447 "perly.y" + case 297: /* myattrterm: KW_MY REFGEN term */ +#line 1448 "perly.y" { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); } break; - case 297: /* myterm: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ -#line 1452 "perly.y" + case 298: /* myterm: PERLY_PAREN_OPEN expr PERLY_PAREN_CLOSE */ +#line 1453 "perly.y" { (yyval.opval) = sawparens((ps[-1].val.opval)); } break; - case 298: /* myterm: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ -#line 1454 "perly.y" + case 299: /* myterm: PERLY_PAREN_OPEN PERLY_PAREN_CLOSE */ +#line 1455 "perly.y" { (yyval.opval) = sawparens(newNULLLIST()); } break; - case 299: /* myterm: scalar */ -#line 1457 "perly.y" + case 300: /* myterm: scalar */ +#line 1458 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 300: /* myterm: hsh */ -#line 1459 "perly.y" + case 301: /* myterm: hsh */ +#line 1460 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 301: /* myterm: ary */ -#line 1461 "perly.y" + case 302: /* myterm: ary */ +#line 1462 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 302: /* fieldvar: scalar */ -#line 1466 "perly.y" + case 303: /* fieldvar: scalar */ +#line 1467 "perly.y" { (yyval.pval) = PadnamelistARRAY(PL_comppad_name)[(ps[0].val.opval)->op_targ]; op_free((ps[0].val.opval)); @@ -2113,8 +2110,8 @@ case 2: /* @1: %empty */ break; - case 303: /* fieldvar: hsh */ -#line 1471 "perly.y" + case 304: /* fieldvar: hsh */ +#line 1472 "perly.y" { (yyval.pval) = PadnamelistARRAY(PL_comppad_name)[(ps[0].val.opval)->op_targ]; op_free((ps[0].val.opval)); @@ -2122,8 +2119,8 @@ case 2: /* @1: %empty */ break; - case 304: /* fieldvar: ary */ -#line 1476 "perly.y" + case 305: /* fieldvar: ary */ +#line 1477 "perly.y" { (yyval.pval) = PadnamelistARRAY(PL_comppad_name)[(ps[0].val.opval)->op_targ]; op_free((ps[0].val.opval)); @@ -2131,20 +2128,20 @@ case 2: /* @1: %empty */ break; - case 305: /* optfieldattrlist: COLONATTR THING */ -#line 1484 "perly.y" + case 306: /* optfieldattrlist: COLONATTR THING */ +#line 1485 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 306: /* optfieldattrlist: COLONATTR */ -#line 1486 "perly.y" + case 307: /* optfieldattrlist: COLONATTR */ +#line 1487 "perly.y" { (yyval.opval) = NULL; } break; - case 308: /* fielddecl: KW_FIELD fieldvar optfieldattrlist */ -#line 1492 "perly.y" + case 309: /* fielddecl: KW_FIELD fieldvar optfieldattrlist */ +#line 1493 "perly.y" { parser->in_my = 0; if((ps[0].val.opval)) @@ -2154,8 +2151,8 @@ case 2: /* @1: %empty */ break; - case 309: /* $@24: %empty */ -#line 1499 "perly.y" + case 310: /* $@24: %empty */ +#line 1500 "perly.y" { parser->in_my = 0; if((ps[-1].val.opval)) @@ -2166,8 +2163,8 @@ case 2: /* @1: %empty */ break; - case 310: /* fielddecl: KW_FIELD fieldvar optfieldattrlist ASSIGNOP $@24 term */ -#line 1507 "perly.y" + case 311: /* fielddecl: KW_FIELD fieldvar optfieldattrlist ASSIGNOP $@24 term */ +#line 1508 "perly.y" { class_set_field_defop((PADNAME *)(ps[-4].val.pval), (ps[-2].val.ival), (ps[0].val.opval)); LEAVE; @@ -2176,122 +2173,122 @@ case 2: /* @1: %empty */ break; - case 316: /* optrepl: PERLY_SLASH expr */ -#line 1527 "perly.y" + case 317: /* optrepl: PERLY_SLASH expr */ +#line 1528 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; - case 317: /* my_scalar: scalar */ -#line 1533 "perly.y" + case 318: /* my_scalar: scalar */ +#line 1534 "perly.y" { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); } break; - case 318: /* list_of_scalars: list_of_scalars PERLY_COMMA */ -#line 1538 "perly.y" + case 319: /* list_of_scalars: list_of_scalars PERLY_COMMA */ +#line 1539 "perly.y" { (yyval.opval) = (ps[-1].val.opval); } break; - case 319: /* list_of_scalars: list_of_scalars PERLY_COMMA scalar */ -#line 1540 "perly.y" + case 320: /* list_of_scalars: list_of_scalars PERLY_COMMA scalar */ +#line 1541 "perly.y" { (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), (ps[0].val.opval)); } break; - case 321: /* my_list_of_scalars: list_of_scalars */ -#line 1547 "perly.y" + case 322: /* my_list_of_scalars: list_of_scalars */ +#line 1548 "perly.y" { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); } break; - case 329: /* amper: PERLY_AMPERSAND indirob */ -#line 1564 "perly.y" + case 330: /* amper: PERLY_AMPERSAND indirob */ +#line 1565 "perly.y" { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); } break; - case 330: /* scalar: PERLY_DOLLAR indirob */ -#line 1568 "perly.y" + case 331: /* scalar: PERLY_DOLLAR indirob */ +#line 1569 "perly.y" { (yyval.opval) = newSVREF((ps[0].val.opval)); } break; - case 331: /* ary: PERLY_SNAIL indirob */ -#line 1572 "perly.y" + case 332: /* ary: PERLY_SNAIL indirob */ +#line 1573 "perly.y" { (yyval.opval) = newAVREF((ps[0].val.opval)); if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival); } break; - case 332: /* hsh: PERLY_PERCENT_SIGN indirob */ -#line 1578 "perly.y" + case 333: /* hsh: PERLY_PERCENT_SIGN indirob */ +#line 1579 "perly.y" { (yyval.opval) = newHVREF((ps[0].val.opval)); if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival); } break; - case 333: /* arylen: DOLSHARP indirob */ -#line 1584 "perly.y" + case 334: /* arylen: DOLSHARP indirob */ +#line 1585 "perly.y" { (yyval.opval) = newAVREF((ps[0].val.opval)); } break; - case 334: /* arylen: term ARROW DOLSHARP PERLY_STAR */ -#line 1586 "perly.y" + case 335: /* arylen: term ARROW DOLSHARP PERLY_STAR */ +#line 1587 "perly.y" { (yyval.opval) = newAVREF((ps[-3].val.opval)); } break; - case 335: /* star: PERLY_STAR indirob */ -#line 1590 "perly.y" + case 336: /* star: PERLY_STAR indirob */ +#line 1591 "perly.y" { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); } break; - case 337: /* sliceme: term ARROW PERLY_SNAIL */ -#line 1595 "perly.y" + case 338: /* sliceme: term ARROW PERLY_SNAIL */ +#line 1596 "perly.y" { (yyval.opval) = newAVREF((ps[-2].val.opval)); } break; - case 339: /* kvslice: term ARROW PERLY_PERCENT_SIGN */ -#line 1600 "perly.y" + case 340: /* kvslice: term ARROW PERLY_PERCENT_SIGN */ +#line 1601 "perly.y" { (yyval.opval) = newHVREF((ps[-2].val.opval)); } break; - case 341: /* gelem: term ARROW PERLY_STAR */ -#line 1605 "perly.y" + case 342: /* gelem: term ARROW PERLY_STAR */ +#line 1606 "perly.y" { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); } break; - case 342: /* indirob: BAREWORD */ -#line 1610 "perly.y" + case 343: /* indirob: BAREWORD */ +#line 1611 "perly.y" { (yyval.opval) = scalar((ps[0].val.opval)); } break; - case 343: /* indirob: scalar */ -#line 1612 "perly.y" + case 344: /* indirob: scalar */ +#line 1613 "perly.y" { (yyval.opval) = scalar((ps[0].val.opval)); } break; - case 344: /* indirob: block */ -#line 1614 "perly.y" + case 345: /* indirob: block */ +#line 1615 "perly.y" { (yyval.opval) = op_scope((ps[0].val.opval)); } break; - case 345: /* indirob: PRIVATEREF */ -#line 1617 "perly.y" + case 346: /* indirob: PRIVATEREF */ +#line 1618 "perly.y" { (yyval.opval) = (ps[0].val.opval); } break; @@ -2303,6 +2300,6 @@ case 2: /* @1: %empty */ /* Generated from: - * a66533df84b2ea4db3ab085ffee3685d0e63a6946a65e9ce91b2621b7bd4e01e perly.y + * c36bc8f06e0d028fe375ec5042a868f1249c42d01a2da5b7be104611f300ff06 perly.y * f13e9c08cea6302f0c1d1f467405bd0e0880d0ea92d0669901017a7f7e94ab28 regen_perly.pl * ex: set ro ft=c: */ diff --git a/perly.h b/perly.h index f0b325e643db..330a5c5dce46 100644 --- a/perly.h +++ b/perly.h @@ -246,6 +246,6 @@ int yyparse (void); /* Generated from: - * a66533df84b2ea4db3ab085ffee3685d0e63a6946a65e9ce91b2621b7bd4e01e perly.y + * c36bc8f06e0d028fe375ec5042a868f1249c42d01a2da5b7be104611f300ff06 perly.y * f13e9c08cea6302f0c1d1f467405bd0e0880d0ea92d0669901017a7f7e94ab28 regen_perly.pl * ex: set ro ft=c: */ diff --git a/perly.tab b/perly.tab index a906d081e2b6..2d2de6914fc3 100644 --- a/perly.tab +++ b/perly.tab @@ -201,59 +201,60 @@ enum yysymbol_kind_t YYSYMBOL_sigslurpsigil = 190, /* sigslurpsigil */ YYSYMBOL_sigslurpelem = 191, /* sigslurpelem */ YYSYMBOL_sigscalarelem = 192, /* sigscalarelem */ - YYSYMBOL_sigelem = 193, /* sigelem */ - YYSYMBOL_siglist = 194, /* siglist */ - YYSYMBOL_optsiglist = 195, /* optsiglist */ - YYSYMBOL_optsubsignature = 196, /* optsubsignature */ - YYSYMBOL_subsignature = 197, /* subsignature */ - YYSYMBOL_subsigguts = 198, /* subsigguts */ - YYSYMBOL_199_20 = 199, /* $@20 */ - YYSYMBOL_optsubbody = 200, /* optsubbody */ - YYSYMBOL_subbody = 201, /* subbody */ - YYSYMBOL_optsigsubbody = 202, /* optsigsubbody */ - YYSYMBOL_sigsubbody = 203, /* sigsubbody */ - YYSYMBOL_204_21 = 204, /* $@21 */ - YYSYMBOL_expr = 205, /* expr */ - YYSYMBOL_listexpr = 206, /* listexpr */ - YYSYMBOL_listop = 207, /* listop */ - YYSYMBOL_208_22 = 208, /* @22 */ - YYSYMBOL_methodname = 209, /* methodname */ - YYSYMBOL_subscripted = 210, /* subscripted */ - YYSYMBOL_termbinop = 211, /* termbinop */ - YYSYMBOL_termrelop = 212, /* termrelop */ - YYSYMBOL_relopchain = 213, /* relopchain */ - YYSYMBOL_termeqop = 214, /* termeqop */ - YYSYMBOL_eqopchain = 215, /* eqopchain */ - YYSYMBOL_termunop = 216, /* termunop */ - YYSYMBOL_anonymous = 217, /* anonymous */ - YYSYMBOL_termdo = 218, /* termdo */ - YYSYMBOL_term = 219, /* term */ - YYSYMBOL_220_23 = 220, /* @23 */ - YYSYMBOL_myattrterm = 221, /* myattrterm */ - YYSYMBOL_myterm = 222, /* myterm */ - YYSYMBOL_fieldvar = 223, /* fieldvar */ - YYSYMBOL_optfieldattrlist = 224, /* optfieldattrlist */ - YYSYMBOL_fielddecl = 225, /* fielddecl */ - YYSYMBOL_226_24 = 226, /* $@24 */ - YYSYMBOL_optlistexpr = 227, /* optlistexpr */ - YYSYMBOL_optexpr = 228, /* optexpr */ - YYSYMBOL_optrepl = 229, /* optrepl */ - YYSYMBOL_my_scalar = 230, /* my_scalar */ - YYSYMBOL_list_of_scalars = 231, /* list_of_scalars */ - YYSYMBOL_my_list_of_scalars = 232, /* my_list_of_scalars */ - YYSYMBOL_my_var = 233, /* my_var */ - YYSYMBOL_refgen_topic = 234, /* refgen_topic */ - YYSYMBOL_my_refgen = 235, /* my_refgen */ - YYSYMBOL_amper = 236, /* amper */ - YYSYMBOL_scalar = 237, /* scalar */ - YYSYMBOL_ary = 238, /* ary */ - YYSYMBOL_hsh = 239, /* hsh */ - YYSYMBOL_arylen = 240, /* arylen */ - YYSYMBOL_star = 241, /* star */ - YYSYMBOL_sliceme = 242, /* sliceme */ - YYSYMBOL_kvslice = 243, /* kvslice */ - YYSYMBOL_gelem = 244, /* gelem */ - YYSYMBOL_indirob = 245 /* indirob */ + YYSYMBOL_optsigscalardefault = 193, /* optsigscalardefault */ + YYSYMBOL_sigelem = 194, /* sigelem */ + YYSYMBOL_siglist = 195, /* siglist */ + YYSYMBOL_optsiglist = 196, /* optsiglist */ + YYSYMBOL_optsubsignature = 197, /* optsubsignature */ + YYSYMBOL_subsignature = 198, /* subsignature */ + YYSYMBOL_subsigguts = 199, /* subsigguts */ + YYSYMBOL_200_20 = 200, /* $@20 */ + YYSYMBOL_optsubbody = 201, /* optsubbody */ + YYSYMBOL_subbody = 202, /* subbody */ + YYSYMBOL_optsigsubbody = 203, /* optsigsubbody */ + YYSYMBOL_sigsubbody = 204, /* sigsubbody */ + YYSYMBOL_205_21 = 205, /* $@21 */ + YYSYMBOL_expr = 206, /* expr */ + YYSYMBOL_listexpr = 207, /* listexpr */ + YYSYMBOL_listop = 208, /* listop */ + YYSYMBOL_209_22 = 209, /* @22 */ + YYSYMBOL_methodname = 210, /* methodname */ + YYSYMBOL_subscripted = 211, /* subscripted */ + YYSYMBOL_termbinop = 212, /* termbinop */ + YYSYMBOL_termrelop = 213, /* termrelop */ + YYSYMBOL_relopchain = 214, /* relopchain */ + YYSYMBOL_termeqop = 215, /* termeqop */ + YYSYMBOL_eqopchain = 216, /* eqopchain */ + YYSYMBOL_termunop = 217, /* termunop */ + YYSYMBOL_anonymous = 218, /* anonymous */ + YYSYMBOL_termdo = 219, /* termdo */ + YYSYMBOL_term = 220, /* term */ + YYSYMBOL_221_23 = 221, /* @23 */ + YYSYMBOL_myattrterm = 222, /* myattrterm */ + YYSYMBOL_myterm = 223, /* myterm */ + YYSYMBOL_fieldvar = 224, /* fieldvar */ + YYSYMBOL_optfieldattrlist = 225, /* optfieldattrlist */ + YYSYMBOL_fielddecl = 226, /* fielddecl */ + YYSYMBOL_227_24 = 227, /* $@24 */ + YYSYMBOL_optlistexpr = 228, /* optlistexpr */ + YYSYMBOL_optexpr = 229, /* optexpr */ + YYSYMBOL_optrepl = 230, /* optrepl */ + YYSYMBOL_my_scalar = 231, /* my_scalar */ + YYSYMBOL_list_of_scalars = 232, /* list_of_scalars */ + YYSYMBOL_my_list_of_scalars = 233, /* my_list_of_scalars */ + YYSYMBOL_my_var = 234, /* my_var */ + YYSYMBOL_refgen_topic = 235, /* refgen_topic */ + YYSYMBOL_my_refgen = 236, /* my_refgen */ + YYSYMBOL_amper = 237, /* amper */ + YYSYMBOL_scalar = 238, /* scalar */ + YYSYMBOL_ary = 239, /* ary */ + YYSYMBOL_hsh = 240, /* hsh */ + YYSYMBOL_arylen = 241, /* arylen */ + YYSYMBOL_star = 242, /* star */ + YYSYMBOL_sliceme = 243, /* sliceme */ + YYSYMBOL_kvslice = 244, /* kvslice */ + YYSYMBOL_gelem = 245, /* gelem */ + YYSYMBOL_indirob = 246 /* indirob */ }; typedef enum yysymbol_kind_t yysymbol_kind_t; @@ -262,16 +263,16 @@ typedef enum yysymbol_kind_t yysymbol_kind_t; #define YYFINAL 16 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 3759 +#define YYLAST 3753 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 133 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 113 +#define YYNNTS 114 /* YYNRULES -- Number of rules. */ -#define YYNRULES 345 +#define YYNRULES 346 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 676 +#define YYNSTATES 677 /* YYMAXUTOK -- Last valid token kind. */ #define YYMAXUTOK 387 @@ -345,29 +346,29 @@ static const yytype_int16 yyrline[] = 699, 704, 715, 716, 721, 723, 728, 735, 736, 740, 744, 748, 753, 757, 761, 762, 765, 771, 776, 781, 787, 788, 793, 794, 799, 800, 807, 812, 814, 825, - 827, 832, 834, 838, 843, 847, 855, 860, 865, 874, - 876, 884, 885, 886, 891, 892, 897, 898, 902, 906, - 906, 939, 940, 945, 957, 958, 963, 962, 975, 977, - 979, 981, 983, 987, 989, 994, 998, 1002, 1006, 1010, - 1016, 1021, 1027, 1033, 1039, 1045, 1047, 1049, 1052, 1051, - 1065, 1066, 1070, 1074, 1077, 1082, 1087, 1090, 1094, 1098, - 1104, 1112, 1119, 1125, 1127, 1129, 1134, 1136, 1138, 1140, - 1142, 1144, 1149, 1151, 1153, 1155, 1157, 1159, 1161, 1163, - 1165, 1167, 1169, 1171, 1173, 1175, 1177, 1179, 1183, 1185, - 1187, 1189, 1191, 1195, 1197, 1201, 1203, 1205, 1207, 1211, - 1213, 1218, 1220, 1223, 1225, 1227, 1230, 1233, 1244, 1247, - 1255, 1257, 1259, 1262, 1264, 1267, 1269, 1274, 1279, 1281, - 1285, 1286, 1287, 1288, 1289, 1291, 1293, 1295, 1297, 1299, - 1301, 1303, 1305, 1307, 1309, 1311, 1313, 1315, 1325, 1335, - 1345, 1355, 1357, 1359, 1362, 1367, 1371, 1373, 1375, 1377, - 1380, 1382, 1385, 1387, 1389, 1391, 1393, 1395, 1397, 1399, - 1401, 1404, 1406, 1408, 1410, 1412, 1414, 1418, 1421, 1420, - 1433, 1434, 1435, 1440, 1442, 1444, 1446, 1451, 1453, 1456, - 1458, 1460, 1465, 1470, 1475, 1483, 1485, 1487, 1491, 1499, - 1498, 1516, 1517, 1521, 1522, 1526, 1527, 1532, 1537, 1539, - 1543, 1546, 1550, 1551, 1552, 1555, 1556, 1559, 1560, 1563, - 1567, 1571, 1577, 1583, 1585, 1589, 1593, 1594, 1598, 1599, - 1603, 1604, 1609, 1611, 1613, 1616 + 827, 832, 834, 838, 843, 847, 855, 860, 868, 870, + 875, 877, 885, 886, 887, 892, 893, 898, 899, 903, + 907, 907, 940, 941, 946, 958, 959, 964, 963, 976, + 978, 980, 982, 984, 988, 990, 995, 999, 1003, 1007, + 1011, 1017, 1022, 1028, 1034, 1040, 1046, 1048, 1050, 1053, + 1052, 1066, 1067, 1071, 1075, 1078, 1083, 1088, 1091, 1095, + 1099, 1105, 1113, 1120, 1126, 1128, 1130, 1135, 1137, 1139, + 1141, 1143, 1145, 1150, 1152, 1154, 1156, 1158, 1160, 1162, + 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1184, + 1186, 1188, 1190, 1192, 1196, 1198, 1202, 1204, 1206, 1208, + 1212, 1214, 1219, 1221, 1224, 1226, 1228, 1231, 1234, 1245, + 1248, 1256, 1258, 1260, 1263, 1265, 1268, 1270, 1275, 1280, + 1282, 1286, 1287, 1288, 1289, 1290, 1292, 1294, 1296, 1298, + 1300, 1302, 1304, 1306, 1308, 1310, 1312, 1314, 1316, 1326, + 1336, 1346, 1356, 1358, 1360, 1363, 1368, 1372, 1374, 1376, + 1378, 1381, 1383, 1386, 1388, 1390, 1392, 1394, 1396, 1398, + 1400, 1402, 1405, 1407, 1409, 1411, 1413, 1415, 1419, 1422, + 1421, 1434, 1435, 1436, 1441, 1443, 1445, 1447, 1452, 1454, + 1457, 1459, 1461, 1466, 1471, 1476, 1484, 1486, 1488, 1492, + 1500, 1499, 1517, 1518, 1522, 1523, 1527, 1528, 1533, 1538, + 1540, 1544, 1547, 1551, 1552, 1553, 1556, 1557, 1560, 1561, + 1564, 1568, 1572, 1578, 1584, 1586, 1590, 1594, 1595, 1599, + 1600, 1604, 1605, 1610, 1612, 1614, 1617 }; #endif @@ -419,16 +420,17 @@ static const char *const yytname[] = "mintro", "nexpr", "texpr", "iexpr", "mexpr", "mnexpr", "formname", "startsub", "startanonsub", "startanonmethod", "startformsub", "subname", "proto", "subattrlist", "myattrlist", "sigvar", "sigslurpsigil", - "sigslurpelem", "sigscalarelem", "sigelem", "siglist", "optsiglist", - "optsubsignature", "subsignature", "subsigguts", "$@20", "optsubbody", - "subbody", "optsigsubbody", "sigsubbody", "$@21", "expr", "listexpr", - "listop", "@22", "methodname", "subscripted", "termbinop", "termrelop", - "relopchain", "termeqop", "eqopchain", "termunop", "anonymous", "termdo", - "term", "@23", "myattrterm", "myterm", "fieldvar", "optfieldattrlist", - "fielddecl", "$@24", "optlistexpr", "optexpr", "optrepl", "my_scalar", - "list_of_scalars", "my_list_of_scalars", "my_var", "refgen_topic", - "my_refgen", "amper", "scalar", "ary", "hsh", "arylen", "star", - "sliceme", "kvslice", "gelem", "indirob", YY_NULLPTR + "sigslurpelem", "sigscalarelem", "optsigscalardefault", "sigelem", + "siglist", "optsiglist", "optsubsignature", "subsignature", "subsigguts", + "$@20", "optsubbody", "subbody", "optsigsubbody", "sigsubbody", "$@21", + "expr", "listexpr", "listop", "@22", "methodname", "subscripted", + "termbinop", "termrelop", "relopchain", "termeqop", "eqopchain", + "termunop", "anonymous", "termdo", "term", "@23", "myattrterm", "myterm", + "fieldvar", "optfieldattrlist", "fielddecl", "$@24", "optlistexpr", + "optexpr", "optrepl", "my_scalar", "list_of_scalars", + "my_list_of_scalars", "my_var", "refgen_topic", "my_refgen", "amper", + "scalar", "ary", "hsh", "arylen", "star", "sliceme", "kvslice", "gelem", + "indirob", YY_NULLPTR }; static const char * @@ -438,12 +440,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-571) +#define YYPACT_NINF (-548) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-344) +#define YYTABLE_NINF (-345) #define yytable_value_is_error(Yyn) \ ((Yyn) == YYTABLE_NINF) @@ -452,74 +454,74 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 779, -571, -571, -571, -571, -571, -571, -571, 53, -571, - 3006, 52, 1948, 1831, -571, -571, -571, -571, 343, 3006, - 343, 3006, 343, 3006, 343, 343, 3006, 32, 3006, 2277, - -571, -571, -571, -571, 343, 343, -571, -571, 11, -51, - -571, 3006, -571, -571, 3006, -32, -25, -34, 2277, 2196, - 52, 343, 3006, -2, 3006, 3006, 3006, 3006, 3006, 3006, - 2358, -571, 395, 96, -571, 23, -571, -62, 3, 24, - 50, -571, -571, -571, 3254, -571, -571, -13, 93, 148, - 169, -571, 139, 236, 262, 145, -571, -571, -571, -571, - -571, 127, 142, 191, 73, 87, -1, 88, 97, 98, - 101, 52, 199, 199, -571, -2, -571, -571, -571, 202, - -571, -2, 197, -571, 215, 447, 224, 1831, -571, -571, - -571, -571, 675, -571, 192, 849, -571, -571, -571, -571, - -571, 242, -571, 534, -571, 534, -571, -571, 3610, 3087, - 2439, 176, -571, -571, -571, 3610, -571, 3610, 207, 186, - 186, 3006, 157, 204, 3006, 174, 3610, 52, 3254, 175, - 2520, 3006, 2196, -571, 3610, 3168, -571, 96, -571, 2601, - 3006, 3006, -571, 281, -571, -571, 3006, 96, 534, 534, - 534, 663, 663, 305, 261, 3006, 3006, 3006, 3006, 3006, - 3006, 3006, 2682, -571, -571, 3006, -571, -571, 3006, 3006, - 3006, 3006, 3006, 3006, 3006, 3006, 3006, 3006, 3006, 3006, - 3006, 3006, 3006, 3006, 3006, 3006, 3006, 3006, 3006, 3006, - 3006, 3006, 3006, 3006, -571, -571, -571, 3006, 193, 2763, - 3006, 3006, 3006, 3006, 3006, 3006, 3006, -571, 263, 266, - 267, 238, -571, -571, -571, -571, -571, 206, 456, -571, - -571, 198, -571, -571, -571, -571, -571, -571, 291, -571, - -571, -571, -571, -571, -571, 52, -571, -571, -571, 3006, - 3006, 3006, 3006, 3006, 3006, -571, -571, -571, -571, 272, - -571, -571, -571, 272, -571, -571, -571, 321, -571, -571, - 2844, 534, 176, 71, 79, 107, -571, 373, 284, -571, - -571, -571, 186, 290, -571, 15, 15, -571, 3006, 3006, - 95, -571, -571, -571, -571, 437, 270, 237, 3006, 96, - 96, 355, -571, 3006, 356, 78, 78, -571, -571, 3358, - 268, 158, -571, 451, 3571, 3551, 3410, 534, 477, 333, - 3306, 3358, 3358, 3202, 3449, 3449, 3449, 3472, 3472, 3511, - 3532, 3551, 3551, 3571, 3571, 3590, 3629, 333, 477, 534, - 534, 13, 47, 3006, 3006, 315, 349, 350, 352, -571, - 354, 2925, 255, -571, -571, 521, 289, 163, 294, 170, - 312, 200, 326, 966, -571, -571, 377, 46, 186, 338, - -571, 299, 3006, 3006, -571, 16, -571, -571, 271, -571, - -571, -571, -571, 2034, 191, -571, 3006, 3006, 3006, 3006, - -571, -571, 363, -571, 378, -571, -571, -571, 395, -571, - -571, -571, 395, -571, -571, -571, 311, 328, 192, 27, - 673, -571, -571, -571, 400, -571, 296, -571, -571, 298, - 26, -571, 3006, -571, -571, -571, 680, -571, 213, 3006, - 419, -571, -571, 3006, -571, 301, 344, 218, -571, -571, - -571, -571, -571, -571, 684, 3006, -571, 422, -571, 424, - -571, 425, -571, 435, -571, -571, -571, -571, -571, 55, - -571, -571, 318, 395, 322, 436, 325, -571, -571, -571, - -571, -571, 323, 453, 91, -571, 3006, 342, 365, 395, - 367, 368, 1129, 362, 431, 207, -571, 470, -571, -571, - 186, 3006, 3006, -571, 60, -571, -571, -571, 490, -571, - -571, 3006, -571, 412, -571, -571, -571, 256, -571, 999, - 3006, 495, -571, -571, 383, -571, -571, -571, -571, 486, - -571, -571, -571, 3006, 199, 199, 494, 384, -571, 3006, - 3006, 199, -571, 386, 388, -571, -571, 199, 199, -571, - -571, -571, -571, 3006, 186, -571, 499, 3254, 3254, 391, - -571, 395, -571, -571, 392, -571, -571, 439, -571, -571, - 3254, 134, 134, 436, 396, 393, 404, 197, 3006, 3006, - 199, 199, 199, -571, -571, 436, 199, 516, 378, 1246, - -571, -571, -571, -571, -571, -571, -571, 1363, -571, 199, - 408, -571, -571, -571, -571, 3006, 199, 199, -571, 528, - 420, 197, 197, 197, -571, 507, -571, -571, -571, 1480, - -571, 21, -571, 1597, -571, 3006, 430, 197, 197, -571, - 199, -571, -571, -571, 432, 52, -571, -571, 538, 469, - -571, -571, 433, 199, -571, -571, -571, 197, -571, -571, - -571, -571, -571, -571, 199, 197, 2115, -571, 1714, 134, - -571, 434, -571, -571, 199, -571 + 784, -548, -548, -548, -548, -548, -548, -548, 37, -548, + 3019, 55, 1961, 1844, -548, -548, -548, -548, 126, 3019, + 126, 3019, 126, 3019, 126, 126, 3019, 32, 3019, 2290, + -548, -548, -548, -548, 126, 126, -548, -548, 60, -56, + -548, 3019, -548, -548, 3019, -28, -3, -55, 2290, 2209, + 55, 126, 3019, 39, 3019, 3019, 3019, 3019, 3019, 3019, + 2371, -548, 386, 146, -548, 11, -548, -14, 76, -61, + 79, -548, -548, -548, 3267, -548, -548, 66, 46, 68, + 115, -548, 208, 211, 219, 212, -548, -548, -548, -548, + -548, 177, 180, 300, 105, 114, 25, 119, 125, 130, + 132, 55, 236, 236, -548, 39, -548, -548, -548, 244, + -548, 39, 228, -548, 250, 372, 267, 1844, -548, -548, + -548, -548, 688, -548, 302, 862, -548, -548, -548, -548, + -548, 279, -548, 546, -548, 546, -548, -548, 3603, 3100, + 2452, 214, -548, -548, -548, 3603, -548, 3603, 233, 220, + 220, 3019, 173, 230, 3019, 192, 3603, 55, 3267, 203, + 2533, 3019, 2209, -548, 3603, 3181, -548, 146, -548, 2614, + 3019, 3019, -548, 313, -548, -548, 3019, 146, 546, 546, + 546, 493, 493, 323, 303, 3019, 3019, 3019, 3019, 3019, + 3019, 3019, 2695, -548, -548, 3019, -548, -548, 3019, 3019, + 3019, 3019, 3019, 3019, 3019, 3019, 3019, 3019, 3019, 3019, + 3019, 3019, 3019, 3019, 3019, 3019, 3019, 3019, 3019, 3019, + 3019, 3019, 3019, 3019, -548, -548, -548, 3019, 193, 2776, + 3019, 3019, 3019, 3019, 3019, 3019, 3019, -548, 284, 287, + 310, 285, -548, -548, -548, -548, -548, 257, 571, -548, + -548, 253, -548, -548, -548, -548, -548, -548, 347, -548, + -548, -548, -548, -548, -548, 55, -548, -548, -548, 3019, + 3019, 3019, 3019, 3019, 3019, -548, -548, -548, -548, 331, + -548, -548, -548, 331, -548, -548, -548, 371, -548, -548, + 2857, 546, 214, 69, 73, 74, -548, 325, 336, -548, + -548, -548, 220, 364, -548, 18, 18, -548, 3019, 3019, + 13, -548, -548, -548, -548, 342, 316, 283, 3019, 146, + 146, 415, -548, 3019, 416, 15, 15, -548, -548, 3371, + 96, 78, -548, 355, 361, 3564, 3423, 546, 405, 381, + 3319, 3371, 3371, 3215, 3462, 3462, 3462, 3485, 3485, 3524, + 3545, 3564, 3564, 361, 361, 3584, 3623, 381, 405, 546, + 546, 5, 7, 3019, 3019, 204, 403, 406, 408, -548, + 420, 2938, 308, -548, -548, 446, 190, 89, 234, 200, + 268, 213, 280, 979, -548, -548, 428, 61, 220, 388, + -548, 354, 3019, 3019, -548, 24, -548, -548, 322, -548, + -548, -548, -548, 2047, 300, -548, 3019, 3019, 3019, 3019, + -548, -548, 401, -548, 437, -548, -548, -548, 386, -548, + -548, -548, 386, -548, -548, -548, 365, 366, 302, 20, + 451, -548, -548, -548, 449, -548, 338, -548, -548, 332, + 28, -548, 3019, -548, -548, -548, 510, -548, 255, 3019, + 459, -548, -548, 3019, -548, 340, 293, 259, -548, -548, + -548, -548, -548, -548, 521, 3019, -548, 480, -548, 482, + -548, 484, -548, 489, -548, -548, -548, -548, -548, 154, + -548, -548, 383, 386, 384, 486, 380, -548, -548, -548, + -548, -548, 385, 496, 217, -548, 3019, 390, 391, 386, + 393, 396, 1142, 387, 473, 233, -548, 525, -548, -548, + 220, 3019, 3019, -548, 41, -548, -548, -548, 541, -548, + -548, 3019, -548, 465, -548, -548, -548, 263, -548, 1012, + 3019, 544, -548, -548, 426, -548, -548, -548, -548, 538, + -548, -548, -548, 3019, 236, 236, 547, 430, -548, 3019, + 3019, 236, -548, 432, 434, -548, -548, 236, 236, -548, + -548, -548, -548, 3019, 220, -548, 548, -548, 3267, 3267, + 435, -548, 386, -548, -548, 440, -548, -548, 487, -548, + -548, 3267, 134, 134, 486, 436, 443, 445, 228, 3019, + 3019, 236, 236, 236, -548, -548, 486, 236, 557, 437, + 1259, -548, -548, -548, -548, -548, -548, -548, 1376, -548, + 236, 456, -548, -548, -548, -548, 3019, 236, 236, -548, + 561, 461, 228, 228, 228, -548, 549, -548, -548, -548, + 1493, -548, 31, -548, 1610, -548, 3019, 469, 228, 228, + -548, 236, -548, -548, -548, 471, 55, -548, -548, 579, + 522, -548, -548, 477, 236, -548, -548, -548, 228, -548, + -548, -548, -548, -548, -548, 236, 228, 2128, -548, 1727, + 134, -548, 499, -548, -548, 236, -548 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -528,107 +530,107 @@ static const yytype_int16 yypact[] = static const yytype_int16 yydefact[] = { 0, 2, 4, 6, 8, 10, 12, 14, 0, 21, - 19, 0, 0, 0, 19, 139, 1, 19, 0, 19, - 0, 0, 0, 0, 0, 0, 0, 0, 277, 0, - 107, 107, 108, 290, 0, 0, 261, 288, 249, 283, - 285, 279, 107, 292, 271, 281, 0, 0, 274, 19, + 19, 0, 0, 0, 19, 140, 1, 19, 0, 19, + 0, 0, 0, 0, 0, 0, 0, 0, 278, 0, + 107, 107, 108, 291, 0, 0, 262, 289, 250, 284, + 286, 280, 107, 293, 272, 282, 0, 0, 275, 19, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, - 0, 313, 314, 152, 291, 256, 240, 196, 208, 197, - 215, 241, 242, 243, 155, 246, 5, 262, 251, 254, - 253, 255, 252, 0, 0, 0, 21, 7, 81, 76, + 0, 314, 315, 153, 292, 257, 241, 197, 209, 198, + 216, 242, 243, 244, 156, 247, 5, 263, 252, 255, + 254, 256, 253, 0, 0, 0, 21, 7, 81, 76, 109, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 106, 0, 16, 17, 36, 0, 106, 0, 19, 9, 0, 82, 0, 0, 11, 33, - 32, 28, 0, 15, 19, 0, 342, 345, 344, 343, - 329, 0, 330, 221, 332, 222, 331, 335, 247, 0, - 0, 294, 299, 301, 300, 278, 239, 238, 19, 19, - 19, 19, 0, 0, 0, 0, 280, 0, 272, 0, - 0, 19, 19, 275, 276, 290, 311, 312, 165, 251, - 0, 0, 333, 0, 110, 111, 19, 273, 223, 224, - 245, 228, 229, 250, 0, 0, 0, 0, 0, 153, - 0, 0, 0, 211, 210, 0, 218, 217, 0, 0, + 32, 28, 0, 15, 19, 0, 343, 346, 345, 344, + 330, 0, 331, 222, 333, 223, 332, 336, 248, 0, + 0, 295, 300, 302, 301, 279, 240, 239, 19, 19, + 19, 19, 0, 0, 0, 0, 281, 0, 273, 0, + 0, 19, 19, 276, 277, 291, 312, 313, 166, 252, + 0, 0, 334, 0, 110, 111, 19, 274, 224, 225, + 246, 229, 230, 251, 0, 0, 0, 0, 0, 154, + 0, 0, 0, 212, 211, 0, 219, 218, 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, 225, 226, 227, 0, 0, 0, + 0, 0, 0, 0, 226, 227, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 19, 0, - 0, 19, 302, 304, 303, 21, 21, 21, 0, 21, + 0, 19, 303, 305, 304, 21, 21, 21, 0, 21, 21, 0, 21, 21, 21, 21, 52, 23, 0, 74, 46, 106, 75, 42, 106, 0, 92, 67, 73, 0, 0, 0, 0, 0, 0, 72, 35, 34, 29, 119, - 122, 121, 134, 119, 130, 129, 133, 135, 140, 230, - 0, 296, 0, 251, 254, 253, 298, 0, 118, 293, - 113, 112, 19, 116, 114, 235, 237, 163, 19, 0, - 0, 284, 168, 282, 286, 0, 0, 0, 0, 156, - 157, 0, 265, 0, 248, 150, 151, 148, 149, 154, - 0, 0, 182, 0, 214, 220, 200, 189, 191, 193, - 207, 187, 188, 0, 203, 205, 204, 201, 202, 199, - 198, 219, 216, 213, 209, 212, 195, 194, 192, 206, - 190, 186, 0, 0, 0, 0, 339, 337, 341, 170, - 0, 0, 160, 171, 263, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 104, 105, 0, 0, 19, 306, - 307, 308, 0, 0, 327, 0, 328, 325, 0, 326, - 322, 323, 324, 0, 0, 21, 0, 99, 0, 0, + 122, 121, 135, 119, 131, 130, 134, 136, 141, 231, + 0, 297, 0, 252, 255, 254, 299, 0, 118, 294, + 113, 112, 19, 116, 114, 236, 238, 164, 19, 0, + 0, 285, 169, 283, 287, 0, 0, 0, 0, 157, + 158, 0, 266, 0, 249, 151, 152, 149, 150, 155, + 0, 0, 183, 0, 215, 221, 201, 190, 192, 194, + 208, 188, 189, 0, 204, 206, 205, 202, 203, 200, + 199, 220, 217, 214, 210, 213, 196, 195, 193, 207, + 191, 187, 0, 0, 0, 0, 340, 338, 342, 171, + 0, 0, 161, 172, 264, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 104, 105, 0, 0, 19, 307, + 308, 309, 0, 0, 328, 0, 329, 326, 0, 327, + 323, 324, 325, 0, 0, 21, 0, 99, 0, 0, 19, 21, 0, 38, 21, 40, 93, 83, 80, 84, - 87, 86, 101, 85, 88, 120, 126, 123, 131, 250, - 0, 295, 297, 117, 233, 115, 19, 234, 236, 0, - 19, 184, 19, 287, 167, 166, 0, 231, 0, 0, - 0, 175, 181, 0, 269, 162, 0, 0, 266, 268, - 267, 270, 334, 179, 0, 19, 264, 0, 173, 0, - 257, 0, 258, 0, 18, 21, 37, 21, 44, 0, - 305, 309, 0, 102, 0, 0, 0, 317, 21, 97, + 87, 86, 101, 85, 88, 120, 126, 123, 132, 251, + 0, 296, 298, 117, 234, 115, 19, 235, 237, 0, + 19, 185, 19, 288, 168, 167, 0, 232, 0, 0, + 0, 176, 182, 0, 270, 163, 0, 0, 267, 269, + 268, 271, 335, 180, 0, 19, 265, 0, 174, 0, + 258, 0, 259, 0, 18, 21, 37, 21, 44, 0, + 306, 310, 0, 102, 0, 0, 0, 318, 21, 97, 98, 103, 0, 0, 82, 61, 0, 0, 0, 100, - 0, 0, 0, 19, 0, 19, 142, 0, 43, 141, - 19, 127, 124, 132, 248, 232, 139, 136, 0, 137, - 164, 0, 315, 0, 169, 158, 185, 0, 178, 244, - 19, 0, 174, 180, 0, 176, 259, 260, 172, 0, - 68, 21, 45, 0, 0, 0, 321, 0, 320, 0, + 0, 0, 0, 19, 0, 19, 143, 0, 43, 142, + 19, 128, 124, 133, 249, 233, 140, 137, 0, 138, + 165, 0, 316, 0, 170, 159, 186, 0, 179, 245, + 19, 0, 175, 181, 0, 177, 260, 261, 173, 0, + 68, 21, 45, 0, 0, 0, 322, 0, 321, 0, 0, 0, 55, 0, 0, 96, 96, 0, 0, 22, - 25, 24, 65, 19, 19, 19, 21, 128, 125, 0, - 146, 316, 289, 183, 0, 177, 159, 0, 19, 70, - 310, 19, 19, 318, 0, 0, 0, 19, 99, 0, - 0, 0, 0, 50, 51, 0, 0, 0, 21, 0, - 145, 41, 144, 138, 19, 161, 19, 0, 19, 0, - 0, 89, 48, 49, 319, 0, 0, 0, 64, 0, - 0, 19, 19, 19, 26, 94, 47, 39, 143, 0, - 30, 0, 69, 0, 90, 0, 0, 19, 19, 56, - 0, 60, 54, 53, 0, 0, 66, 147, 0, 19, - 31, 71, 0, 0, 58, 63, 96, 19, 27, 95, - 20, 19, 78, 77, 0, 19, 0, 62, 0, 19, - 59, 0, 79, 91, 0, 57 + 25, 24, 65, 19, 19, 19, 21, 127, 129, 125, + 0, 147, 317, 290, 184, 0, 178, 160, 0, 19, + 70, 311, 19, 19, 319, 0, 0, 0, 19, 99, + 0, 0, 0, 0, 50, 51, 0, 0, 0, 21, + 0, 146, 41, 145, 139, 19, 162, 19, 0, 19, + 0, 0, 89, 48, 49, 320, 0, 0, 0, 64, + 0, 0, 19, 19, 19, 26, 94, 47, 39, 144, + 0, 30, 0, 69, 0, 90, 0, 0, 19, 19, + 56, 0, 60, 54, 53, 0, 0, 66, 148, 0, + 19, 31, 71, 0, 0, 58, 63, 96, 19, 27, + 95, 20, 19, 78, 77, 0, 19, 0, 62, 0, + 19, 59, 0, 79, 91, 0, 57 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -571, -571, -571, -571, -571, -571, -571, -571, -571, -571, - -4, -10, -571, 92, -80, -571, -571, -571, -571, -16, - -571, 553, 457, 5, -571, -571, -571, -571, -571, -571, - -571, -571, -571, -571, -571, -571, 172, -397, -570, -336, - -571, -519, -571, -18, 173, -315, -91, -571, -88, 45, - -571, -571, -78, 76, -140, 286, 293, -571, -571, -571, - 155, -571, -571, -571, -571, 69, -571, -12, 153, -571, - -295, -571, 9, -46, -571, -571, -571, -571, -571, -571, - -571, -571, -571, -571, -571, -571, 625, -571, -571, 450, - -571, -571, -571, -571, -138, -17, -571, -571, -571, -571, - 187, -571, -571, 345, 40, -23, -22, -571, -571, -571, - -571, -571, 61 + -548, -548, -548, -548, -548, -548, -548, -548, -548, -548, + -4, -10, -548, 92, -7, -548, -548, -548, -548, -16, + -548, 614, 514, 3, -548, -548, -548, -548, -548, -548, + -548, -548, -548, -548, -548, -548, -63, -397, -547, -255, + -548, -544, -548, 43, 229, -315, -30, -548, -84, 174, + -548, -548, -88, 133, -140, 351, 356, -548, -548, -548, + -548, 216, -548, -548, -548, -548, 135, -548, 50, 221, + -548, -295, -548, 9, -46, -548, -548, -548, -548, -548, + -548, -548, -548, -548, -548, -548, -548, 638, -548, -548, + 511, -548, -548, -548, -548, -138, -17, -548, -548, -548, + -548, 249, -548, -548, 414, 40, -23, -22, -548, -548, + -548, -548, -548, 97 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { 0, 8, 9, 10, 11, 12, 13, 14, 15, 111, - 112, 121, 476, 436, 258, 410, 562, 595, 644, 122, - 631, 278, 119, 120, 505, 510, 414, 412, 588, 656, - 553, 596, 578, 608, 650, 663, 417, 114, 612, 267, - 646, 591, 491, 498, 421, 482, 493, 386, 260, 148, + 112, 121, 476, 436, 258, 410, 562, 596, 645, 122, + 632, 278, 119, 120, 505, 510, 414, 412, 589, 657, + 553, 597, 579, 609, 651, 664, 417, 114, 613, 267, + 647, 592, 491, 498, 421, 482, 493, 386, 260, 148, 150, 238, 176, 302, 305, 299, 426, 283, 284, 285, - 286, 287, 288, 518, 519, 123, 124, 508, 509, 601, - 437, 604, 115, 63, 64, 442, 372, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 153, 75, 141, - 241, 391, 116, 543, 168, 76, 523, 486, 546, 547, - 397, 398, 250, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 132 + 567, 286, 287, 288, 518, 519, 123, 124, 508, 509, + 602, 437, 605, 115, 63, 64, 442, 372, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 153, 75, + 141, 241, 391, 116, 543, 168, 76, 523, 486, 546, + 547, 397, 398, 250, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 132 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -637,92 +639,105 @@ static const yytype_int16 yydefgoto[] = static const yytype_int16 yytable[] = { 61, 125, 131, 167, 143, 144, 490, 87, 177, 61, - 306, 438, 613, 307, 128, 20, 128, 113, 128, 62, - 128, 128, 263, 259, 154, 146, -21, 261, 62, 247, - 128, 128, 20, 264, 190, 173, 191, 592, 322, 166, - 323, 189, 61, 648, 163, 128, 171, 128, 20, 521, - 193, 194, 22, 16, 174, 161, 24, 477, 129, 175, - 129, 62, 129, 86, 129, 129, 541, 142, 478, 184, - 243, 244, 454, 449, 129, 129, 149, 542, 484, 130, - 649, 155, 230, 134, 231, 136, 137, 157, 492, 169, - -336, 129, -336, 500, 501, 151, 152, 256, 162, 673, - 159, 17, 266, 174, 230, 167, 231, 160, 175, 441, - 170, 189, 172, -298, 282, 195, 294, 295, -338, 229, - -338, 248, 277, 269, 319, 320, 270, 271, 272, 273, - 167, 249, 274, 242, 196, 197, 251, 666, 301, 304, - 304, 166, -344, 228, 316, 317, -297, -21, 485, 297, - -340, 61, 61, 312, 139, 192, 236, -299, 128, -336, - 198, -336, 434, 310, 140, -301, 166, 609, 610, 315, - 62, 62, 451, 413, 187, 188, 415, 468, 237, 293, - -338, 554, -338, 239, 470, 185, 186, 187, 188, 185, - 186, 187, 188, -300, 325, 326, 327, 328, 240, 330, - 331, 333, 169, 362, 363, 245, 364, 20, 279, 365, - 257, 22, 280, 366, 472, 24, 281, 367, 368, 246, - 252, 383, -102, 318, 262, 401, 402, 526, 385, 253, - 254, 390, 532, 255, 585, 586, 265, 268, 375, 376, - 377, 378, 379, 380, 381, 382, 275, 232, 479, 233, - 369, 618, 185, 186, 187, 188, 289, 185, 186, 187, - 188, 416, 298, 440, 185, 186, 187, 188, 373, 490, - 573, 602, 303, 234, 620, 235, 370, 300, 418, 418, - 418, 422, 418, 418, 455, 641, 642, 643, 400, 308, - 450, 439, 304, 309, 185, 186, 187, 188, 61, 430, - 636, 654, 655, 321, 524, 311, 313, 185, 186, 187, - 188, 467, 185, 186, 187, 188, 469, 62, 323, 384, - 652, 667, 387, 388, 389, 371, 86, 446, 394, 670, - 405, 20, 448, 425, 471, 411, 428, 392, 393, 395, - 458, 403, 404, 433, 406, 407, 408, 409, 473, 435, - 185, 186, 187, 188, 86, 185, 186, 187, 188, 20, - 444, 128, 185, 186, 187, 188, 531, 447, 445, 449, - 566, 126, 456, 457, 459, 460, 127, 461, 304, 462, - 464, 401, 402, 185, 186, 187, 188, 465, 185, 186, - 187, 188, 324, 489, 502, 475, 167, 480, 481, 126, - 506, 483, 483, 488, 127, 129, 185, 186, 187, 188, - 511, -21, 494, 200, 201, 422, 499, 483, 483, 504, - 185, 186, 187, 188, 598, 597, 517, 512, 516, 520, - 522, 528, 166, 530, 535, 487, 536, 537, 185, 186, - 187, 188, 419, 420, 400, 423, 424, 538, 534, 544, - 221, 222, 20, 545, 551, 61, 223, 549, 527, 224, - 225, 226, 227, 228, 581, 582, 18, 185, 186, 187, - 188, 587, 20, 555, 62, 552, 22, 593, 594, 269, - 24, 565, 270, 271, 272, 273, 396, 563, 274, 185, - 186, 187, 188, 561, 560, 301, 556, 496, 557, 558, - 304, 570, 572, 503, 432, 483, 507, 575, 577, 583, - 621, 622, 623, 574, 576, 584, 625, 167, 589, 590, - 61, 600, 603, 605, 616, 548, 507, 606, 615, 634, - 571, 185, 186, 187, 188, 617, 637, 638, 626, 62, - 635, 185, 186, 187, 188, 185, 186, 187, 188, 599, - 639, 640, 645, 166, 304, 660, 661, 200, 483, 483, - 657, 653, 607, 658, 664, 674, 118, 539, 443, 540, - 619, 611, 611, 665, 276, 671, 427, 266, 431, 497, - 550, 564, 452, 513, 669, 569, 627, 515, 629, 292, - 0, 495, 633, 399, 675, 222, 630, 499, 483, 0, - 223, 0, 0, 224, 225, 226, 227, 228, 0, 0, - 0, 266, 266, 266, 200, 185, 186, 187, 188, 0, - 0, 0, 0, 614, 483, 0, 0, 266, 266, 0, - 0, 0, 0, 579, 0, 624, 0, 0, 0, 662, - 0, 659, 0, 0, 483, 668, 133, 266, 135, 0, - 0, 138, 466, 145, 147, 266, 489, 223, 0, 611, - 224, 225, 226, 227, 228, 0, 156, 0, 0, 158, - 0, 0, 0, 164, 0, -13, 88, 0, 0, 0, - 178, 179, 180, 181, 182, 18, 86, 0, 19, 0, - 507, 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, 100, 101, 102, 0, - 0, 103, 28, 29, 104, 105, 106, 30, 31, 107, - 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, - 41, 42, 43, 108, 117, 0, 44, 0, 109, 45, - 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, - 53, 0, 0, 0, 291, 0, 110, 185, 186, 187, - 188, 0, 0, 54, 185, 186, 187, 188, 185, 186, - 187, 188, 1, 2, 3, 4, 5, 6, 7, -344, - -344, -344, 227, 228, 55, 56, 0, 57, 0, 58, - 59, 0, 0, 0, 514, 0, 0, 60, 0, 0, - 0, 525, 0, 0, 329, 533, 0, 0, 0, 0, - 334, 0, 0, 335, 336, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -3, - 88, 0, 361, 0, 0, 0, 0, 0, 0, 18, - 86, 0, 19, 0, 0, 20, 0, 0, 21, 22, + 306, 438, 593, 307, 128, 113, 128, 261, 128, 62, + 128, 128, 190, 264, 191, 146, 263, 441, 62, -21, + 128, 128, 454, 323, 161, 173, 614, 16, 322, 166, + 20, 20, 61, 189, 163, 128, 171, 128, 20, 196, + 197, 521, 22, 649, 449, 247, 24, 230, 129, 231, + 129, 62, 129, 174, 129, 129, 86, 142, 175, 184, + 243, 244, 477, 154, 129, 129, 155, 162, 484, -337, + 230, -337, 231, 478, -337, -339, -337, -339, 492, 169, + 650, 129, 451, 500, 501, 174, 259, 256, 193, 194, + 175, 17, 266, 468, 159, 167, -299, 185, 186, 187, + 188, 187, 188, 667, 282, 130, 294, 295, 450, 134, + 277, 136, 137, 674, 319, 320, -339, -298, -339, 160, + 167, 151, 152, 242, -345, 228, 251, 86, 301, 304, + 304, 166, 20, 192, 316, 317, 170, 248, 172, 297, + -21, 61, 61, 312, 139, -300, 485, 249, 128, -302, + -301, 189, 434, 310, 140, 541, 166, 610, 611, 315, + 62, 62, 185, 186, 187, 188, 542, 413, 237, 293, + 415, 554, 126, 185, 186, 187, 188, 127, 195, 198, + 185, 186, 187, 188, 325, 326, 327, 328, 229, 330, + 331, 333, 169, 362, 363, 149, 364, 419, 420, 365, + 423, 424, 467, 366, 470, 86, 157, 367, 368, -341, + 20, 383, 232, 236, 233, 401, 402, 472, 385, 458, + 234, 390, 235, 239, 586, 587, 240, 245, 375, 376, + 377, 378, 379, 380, 381, 382, 246, 257, 479, 269, + 369, 252, 270, 271, 272, 273, 469, 253, 274, 318, + 126, 416, 254, 440, 255, 127, 262, 265, 373, 526, + 490, 603, 268, 532, 455, 621, 370, 574, 418, 418, + 418, 422, 418, 418, 185, 186, 187, 188, 400, 275, + 471, 439, 304, 289, 185, 186, 187, 188, 61, 430, + 298, 637, 473, 300, 524, 308, 303, 185, 186, 187, + 188, 185, 186, 187, 188, 531, 20, 62, 279, 309, + 22, 653, 280, 311, 24, 371, 281, 446, 185, 186, + 187, 188, 448, 619, 313, 321, 323, 392, 393, 395, + 384, 403, 404, 387, 406, 407, 408, 409, -102, 185, + 186, 187, 188, 185, 186, 187, 188, 185, 186, 187, + 188, 128, 185, 186, 187, 188, 388, 642, 643, 644, + 566, 389, 456, 457, 185, 186, 187, 188, 304, 394, + 464, 401, 402, 655, 656, 405, 428, 185, 186, 187, + 188, 411, 425, 489, 502, 433, 167, 185, 186, 187, + 188, 483, 483, 668, 269, 129, 444, 270, 271, 272, + 273, 671, 494, 274, 445, 422, 499, 483, 483, 185, + 186, 187, 188, 435, 599, 598, 517, 447, 459, 449, + 522, 460, 166, 461, 324, 487, 185, 186, 187, 188, + 465, 200, 201, 202, 400, 462, 475, 480, 534, 185, + 186, 187, 188, 481, 488, 61, 432, 504, 527, 506, + -21, 200, 201, 520, 511, 512, 185, 186, 187, 188, + 516, 528, 530, 443, 62, 218, 219, 220, 221, 222, + 185, 186, 187, 188, 223, 200, 452, 224, 225, 226, + 227, 228, 535, 561, 536, 301, 537, 496, 221, 222, + 304, 538, 20, 503, 223, 483, 507, 224, 225, 226, + 227, 228, 549, 575, 544, 545, 551, 167, 552, 560, + 61, 555, 556, 222, 557, 548, 507, 558, 223, 563, + 572, 224, 225, 226, 227, 228, 565, 582, 583, 62, + 185, 186, 187, 188, 588, 185, 186, 187, 188, 600, + 594, 595, 571, 166, 304, 573, 576, 577, 483, 483, + 578, 585, 584, 608, 590, 591, 604, 539, 616, 540, + 601, 606, 612, 612, 617, 607, 618, 466, 266, 627, + 550, 18, 514, 640, 622, 623, 624, 20, 636, 630, + 626, 22, 641, 634, 646, 24, 661, 631, 499, 483, + 654, 396, 659, 635, 185, 186, 187, 188, 665, 662, + 638, 639, 266, 266, 266, 185, 186, 187, 188, -345, + -345, -345, 227, 228, 615, 483, 200, 118, 266, 266, + 675, 276, 620, 580, 658, 497, 625, 672, 564, 427, + 663, 525, 660, 431, 513, 483, 669, 666, 266, 628, + 292, 570, 533, 495, 0, 515, 266, 489, 670, 133, + 612, 135, 399, 0, 138, 0, 145, 147, 676, 223, + 0, 0, 224, 225, 226, 227, 228, 0, 0, 156, + 0, 0, 158, 0, 0, 0, 164, 0, -13, 88, + 0, 507, 0, 178, 179, 180, 181, 182, 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, 100, + 101, 102, 0, 0, 103, 28, 29, 104, 105, 106, + 30, 31, 107, 32, 33, 34, 35, 36, 37, 0, + 38, 39, 40, 41, 42, 43, 108, 117, 0, 44, + 0, 109, 45, 46, 47, 48, 49, 50, 0, 0, + 0, 51, 52, 53, 0, 0, 0, 291, 0, 110, + 0, 0, 0, 0, 0, 0, 54, 1, 2, 3, + 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, + 57, 0, 58, 59, 0, 0, 0, 0, 0, 0, + 60, 0, 0, 0, 0, 0, 0, 329, 0, 0, + 0, 0, 0, 334, 0, 0, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, -3, 88, 0, 361, 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, 100, 101, 102, 0, 0, 103, 28, + 29, 104, 105, 106, 30, 31, 107, 32, 33, 34, + 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, + 108, 117, 0, 44, 0, 109, 45, 46, 47, 48, + 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, + 0, 0, 0, 110, 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, 474, 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, 100, 101, 102, 0, 0, 103, 28, 29, 104, 105, @@ -731,28 +746,28 @@ static const yytype_int16 yytable[] = 44, 0, 109, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, 110, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 0, 0, 0, 0, 199, 0, 0, 0, 0, 0, + 0, 529, 200, 201, 202, 0, 0, 0, 55, 56, + 0, 57, 0, 58, 59, 0, 0, 0, 0, 0, + 0, 60, 0, 206, 0, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 0, 0, 0, 0, 223, 0, 0, 224, 225, + 226, 227, 228, 88, 0, 0, 0, 0, 0, 568, + 569, 0, 18, 86, 559, 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, 581, 99, 100, 101, 102, 0, 0, 103, 28, + 29, 104, 105, 106, 30, 31, 107, 32, 33, 34, + 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, + 108, 117, 0, 44, 0, 109, 45, 46, 47, 48, + 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, + 0, 0, 0, 110, 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, 0, 0, 0, 0, 0, 88, 55, 56, - 0, 57, 0, 58, 59, 0, 18, 86, 474, 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, 100, 101, 102, - 0, 0, 103, 28, 29, 104, 105, 106, 30, 31, - 107, 32, 33, 34, 35, 36, 37, 0, 38, 39, - 40, 41, 42, 43, 108, 117, 0, 44, 0, 109, - 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, - 52, 53, 0, 0, 0, 0, 0, 110, 0, 0, - 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, - 0, 199, 0, 0, 0, 0, 0, 0, 529, 200, - 201, 202, 0, 0, 0, 55, 56, 0, 57, 0, - 58, 59, 0, 0, 0, 0, 0, 0, 60, 0, - 206, 0, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 0, 0, - 0, 0, 223, 0, 0, 224, 225, 226, 227, 228, - 88, 0, 0, 0, 0, 0, 567, 568, 0, 18, - 86, 559, 19, 0, 0, 20, 0, 0, 21, 22, + 88, 55, 56, 0, 57, 0, 58, 59, 0, 18, + 86, 629, 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, 580, 99, + 93, 94, 0, 0, 95, 96, 97, 98, 0, 99, 100, 101, 102, 0, 0, 103, 28, 29, 104, 105, 106, 30, 31, 107, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 108, 117, 0, @@ -761,7 +776,7 @@ static const yytype_int16 yytable[] = 110, 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, 628, 19, + 0, 57, 0, 58, 59, 0, 18, 86, 633, 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, 100, 101, 102, @@ -773,7 +788,7 @@ static const yytype_int16 yytable[] = 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, 632, 19, 0, 60, 20, + 58, 59, 0, 18, 86, 648, 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, 100, 101, 102, 0, 0, 103, @@ -785,7 +800,7 @@ 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, 647, 19, 0, 60, 20, 0, 0, 21, + 18, 86, 652, 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, 100, 101, 102, 0, 0, 103, 28, 29, 104, @@ -796,7 +811,7 @@ static const yytype_int16 yytable[] = 0, 110, 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, 651, + 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, 100, 101, @@ -804,7 +819,7 @@ static const yytype_int16 yytable[] = 31, 107, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 108, 117, 0, 44, 0, 109, 45, 46, 47, 48, 49, 50, 0, 0, 0, - 51, 52, 53, 0, 0, 0, 0, 0, 110, 0, + 51, 52, 53, 0, 0, 673, 0, 0, 110, 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, @@ -816,7 +831,7 @@ static const yytype_int16 yytable[] = 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 108, 117, 0, 44, 0, 109, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, - 0, 0, 672, 0, 0, 110, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 110, 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, @@ -826,52 +841,16 @@ static const yytype_int16 yytable[] = 0, 99, 100, 101, 102, 0, 0, 103, 28, 29, 104, 105, 106, 30, 31, 107, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 108, - 117, 0, 44, 0, 109, 45, 46, 47, 48, 49, - 50, 0, 0, 0, 51, 52, 53, 0, 0, 0, - 0, 0, 110, 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, 100, - 101, 102, 0, 0, 103, 28, 29, 104, 105, 106, - 30, 31, 107, 32, 33, 34, 35, 36, 37, 0, - 38, 39, 40, 41, 42, 43, 108, 0, 0, 44, - 0, 109, 45, 46, 47, 48, 49, 50, 0, 0, - 0, 51, 52, 53, 0, 88, 0, 0, 0, 110, - 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, 0, 0, - 60, 28, 29, 0, 0, 0, 30, 31, 0, 32, - 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, - 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, - 47, 48, 49, 50, 0, 0, 88, 51, 52, 53, - 0, 0, 0, 0, 0, 18, 0, 0, 19, 0, - 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, - 25, 0, 0, 0, 26, 27, 0, 0, 0, 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, 0, 44, 0, 0, 45, - 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, - 53, 0, 0, 0, 0, 0, 18, 86, 0, 19, - 0, 0, 20, 54, 0, 21, 22, 23, 0, 0, - 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, - 0, 0, 0, 0, 55, 56, 0, 57, 0, 58, - 59, 0, 0, 28, 29, 0, -19, 60, 30, 31, - 0, 32, 165, 34, 35, 36, 37, 127, 38, 39, - 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, - 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, - 52, 53, 0, 0, 0, 0, 0, 18, 86, 0, - 19, 0, 0, 20, 54, 0, 21, 22, 23, 0, + 0, 0, 44, 0, 109, 45, 46, 47, 48, 49, + 50, 0, 0, 0, 51, 52, 53, 0, 88, 0, + 0, 0, 110, 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, - 0, 0, 0, 0, 0, 55, 56, 0, 57, 0, - 58, 59, 0, 0, 28, 29, 0, 0, 60, 30, + 55, 56, 0, 57, 0, 58, 59, 0, 0, 0, + 0, 0, 0, 60, 28, 29, 0, 0, 0, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, - 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, + 0, 45, 46, 47, 48, 49, 50, 0, 0, 88, 51, 52, 53, 0, 0, 0, 0, 0, 18, 0, 0, 19, 0, 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, @@ -881,35 +860,35 @@ static const yytype_int16 yytable[] = 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, 18, - 0, 0, 19, 0, 0, 20, 54, 0, 21, 22, + 86, 0, 19, 0, 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, - 57, 0, 58, 59, 0, 0, 28, 29, 0, 183, - 60, 30, 31, 0, 32, 33, 34, 35, 36, 37, - 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, + 57, 0, 58, 59, 0, 0, 28, 29, 0, -19, + 60, 30, 31, 0, 32, 165, 34, 35, 36, 37, + 127, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, - 18, 0, 0, 19, 0, 0, 20, 54, 0, 21, + 18, 86, 0, 19, 0, 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 57, 0, 58, 59, 0, 0, 28, 29, 0, - 296, 60, 30, 31, 0, 32, 33, 34, 35, 36, + 0, 60, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, - 0, -343, 230, 0, 231, 0, 0, -343, 54, 0, - -343, -343, -343, 0, 0, -343, -343, 0, 0, 0, - -343, -343, 0, 0, 0, 0, 0, 0, 0, 55, - 56, 0, 57, 0, 58, 59, 0, 0, -343, -343, - 0, 314, 60, -343, -343, 0, -343, -343, -343, -343, - -343, -343, 0, -343, -343, -343, -343, -343, -343, 0, - 0, 0, -343, 0, 0, -343, -343, -343, -343, -343, - -343, 0, 0, 0, -343, -343, -343, 0, 0, 0, - 0, 0, 18, 0, 0, 19, 0, 0, 20, -343, + 0, 18, 0, 0, 19, 0, 0, 20, 54, 0, + 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, + 26, 27, 0, 0, 0, 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, 0, 44, 0, 0, 45, 46, 47, 48, 49, + 50, 0, 0, 0, 51, 52, 53, 0, 0, 0, + 0, 0, 18, 0, 0, 19, 0, 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, - -343, -343, 0, -343, 0, -343, -343, 0, 0, 28, - 29, 0, 0, -343, 30, 31, 0, 32, 33, 34, + 55, 56, 0, 57, 0, 58, 59, 0, 0, 28, + 29, 0, 183, 60, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, 0, 0, @@ -917,23 +896,23 @@ static const yytype_int16 yytable[] = 54, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 57, 0, 58, 59, 0, 0, - 28, 29, 0, 332, 60, 30, 31, 0, 32, 33, + 28, 29, 0, 296, 60, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, 0, - 0, 0, 0, 0, 18, 0, 0, 19, 0, 0, - 20, 54, 0, 21, 22, 23, 0, 0, 24, 25, - 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -344, 230, 0, 231, 0, 0, + -344, 54, 0, -344, -344, -344, 0, 0, -344, -344, + 0, 0, 0, -344, -344, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 57, 0, 58, 59, 0, - 0, 28, 29, 0, 374, 60, 30, 31, 0, 32, - 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, - 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, - 47, 48, 49, 50, 0, 0, 0, 51, 52, 53, + 0, -344, -344, 0, 314, 60, -344, -344, 0, -344, + -344, -344, -344, -344, -344, 0, -344, -344, -344, -344, + -344, -344, 0, 0, 0, -344, 0, 0, -344, -344, + -344, -344, -344, -344, 0, 0, 0, -344, -344, -344, 0, 0, 0, 0, 0, 18, 0, 0, 19, 0, - 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, + 0, 20, -344, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, - 0, 0, 0, 55, 56, 0, 57, 0, 58, 59, - 0, 0, 28, 29, 0, 429, 60, 30, 31, 0, + 0, 0, 0, -344, -344, 0, -344, 0, -344, -344, + 0, 0, 28, 29, 0, 0, -344, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, 52, @@ -941,7 +920,7 @@ static const yytype_int16 yytable[] = 0, 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 57, 0, 58, - 59, 0, 0, 28, 29, 0, 463, 60, 30, 31, + 59, 0, 0, 28, 29, 0, 332, 60, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, 51, @@ -949,160 +928,196 @@ static const yytype_int16 yytable[] = 19, 0, 0, 20, 54, 0, 21, 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 57, 0, - 58, 59, 0, 0, 28, 29, 0, 0, 60, 30, + 58, 59, 0, 0, 28, 29, 0, 374, 60, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, 0, - 51, 52, 53, 0, 0, 0, 0, 0, -342, 0, - 0, -342, 0, 0, -342, 54, 0, -342, -342, -342, - 0, 0, -342, -342, 0, 0, 0, -342, -342, 0, + 51, 52, 53, 0, 0, 0, 0, 0, 18, 0, + 0, 19, 0, 0, 20, 54, 0, 21, 22, 23, + 0, 0, 24, 25, 0, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 57, - 0, 58, 59, 0, 0, -342, -342, 0, 0, 290, - -342, -342, 0, -342, -342, -342, -342, -342, -342, 0, - -342, -342, -342, -342, -342, -342, 0, 0, 0, -342, - 0, 0, -342, -342, -342, -342, -342, -342, 0, 0, - 0, -342, -342, -342, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -342, 0, 0, 0, - 0, 0, 0, 0, 199, 0, 0, 0, 0, 0, - 0, 0, 200, 201, 202, 0, 0, -342, -342, 0, - -342, 0, -342, -342, 0, 203, 0, 0, 0, 0, - -342, 204, 205, 206, 453, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 0, 0, 0, 0, 223, 199, 0, 224, 225, - 226, 227, 228, 0, 200, 201, 202, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 203, 0, 0, - 0, 0, 0, 204, 205, 206, 0, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 0, 0, 0, 0, 223, 199, 0, - 224, 225, 226, 227, 228, 0, 200, 201, 202, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, -344, - 0, 0, 0, 0, 0, 204, 205, 206, 0, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 0, 0, 0, 0, 223, - 199, 0, 224, 225, 226, 227, 228, 0, 200, 201, - 202, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 204, 205, 206, - 0, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 0, 0, 0, - 0, 223, -344, 0, 224, 225, 226, 227, 228, 0, - 200, 201, 202, 0, 0, 0, 0, 0, 0, 0, + 0, 58, 59, 0, 0, 28, 29, 0, 429, 60, + 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, + 38, 39, 40, 41, 42, 43, 0, 0, 0, 44, + 0, 0, 45, 46, 47, 48, 49, 50, 0, 0, + 0, 51, 52, 53, 0, 0, 0, 0, 0, 18, + 0, 0, 19, 0, 0, 20, 54, 0, 21, 22, + 23, 0, 0, 24, 25, 0, 0, 0, 26, 27, + 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, + 57, 0, 58, 59, 0, 0, 28, 29, 0, 463, + 60, 30, 31, 0, 32, 33, 34, 35, 36, 37, + 0, 38, 39, 40, 41, 42, 43, 0, 0, 0, + 44, 0, 0, 45, 46, 47, 48, 49, 50, 0, + 0, 0, 51, 52, 53, 0, 0, 0, 0, 0, + 18, 0, 0, 19, 0, 0, 20, 54, 0, 21, + 22, 23, 0, 0, 24, 25, 0, 0, 0, 26, + 27, 0, 0, 0, 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, + 0, 44, 0, 0, 45, 46, 47, 48, 49, 50, + 0, 0, 0, 51, 52, 53, 0, 0, 0, 0, + 0, -343, 0, 0, -343, 0, 0, -343, 54, 0, + -343, -343, -343, 0, 0, -343, -343, 0, 0, 0, + -343, -343, 0, 0, 0, 0, 0, 0, 0, 55, + 56, 0, 57, 0, 58, 59, 0, 0, -343, -343, + 0, 0, 290, -343, -343, 0, -343, -343, -343, -343, + -343, -343, 0, -343, -343, -343, -343, -343, -343, 0, + 0, 0, -343, 0, 0, -343, -343, -343, -343, -343, + -343, 0, 0, 0, -343, -343, -343, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -343, + 0, 0, 0, 0, 0, 0, 0, 199, 0, 0, + 0, 0, 0, 0, 0, 200, 201, 202, 0, 0, + -343, -343, 0, -343, 0, -343, -343, 0, 203, 0, + 0, 0, 0, -343, 204, 205, 206, 453, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 0, 0, 0, 0, 223, 199, + 0, 224, 225, 226, 227, 228, 0, 200, 201, 202, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 200, - 201, 202, 0, 223, 0, 0, 224, 225, 226, 227, - 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 200, 201, 202, 210, 211, 212, 213, 214, + 203, 0, 0, 0, 0, 0, 204, 205, 206, 0, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 0, 0, 0, 0, + 223, 199, 0, 224, 225, 226, 227, 228, 0, 200, + 201, 202, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -345, 0, 0, 0, 0, 0, 204, 205, + 206, 0, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 0, 0, - 0, 0, 223, 0, 0, 224, 225, 226, 227, 228, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 200, 201, 202, 0, 223, 0, 0, 224, 225, - 226, 227, 228, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 200, 201, 202, 0, 0, 0, 0, 0, + 0, 0, 223, 199, 0, 224, 225, 226, 227, 228, + 0, 200, 201, 202, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 204, 205, 206, 0, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 0, 200, 201, 202, 223, 0, 0, 224, 225, 226, - 227, 228, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 200, 201, 202, 0, 223, 0, 0, 224, 225, - 226, 227, 228, 216, 217, 218, 219, 220, 221, 222, - 200, 201, 202, 0, 223, 0, 0, 224, 225, 226, - 227, 228, 0, 0, 0, 218, 219, 220, 221, 222, - 200, 201, 202, 0, 223, 0, 0, 224, 225, 226, - 227, 228, 0, 0, -344, 219, 220, 221, 222, 200, - 201, 202, 0, 223, 0, 0, 224, 225, 226, 227, - 228, 0, 0, 0, 0, 219, 220, 221, 222, 0, - 0, 0, 0, 223, 0, 0, 224, 225, 226, 227, - 228, 0, 0, 0, 0, 220, 221, 222, 0, 0, - 0, 0, 223, 0, 0, 224, 225, 226, 227, 228 + 0, 0, 0, 0, 223, -345, 0, 224, 225, 226, + 227, 228, 0, 200, 201, 202, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 200, 201, 202, 0, 223, 0, 0, 224, + 225, 226, 227, 228, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 200, 201, 202, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 0, 0, 0, 0, 223, 0, 0, 224, 225, + 226, 227, 228, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 200, 201, 202, 0, 223, 0, + 0, 224, 225, 226, 227, 228, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 200, 201, 202, 0, 0, + 0, 0, 0, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 0, 200, 201, 202, 223, 0, 0, + 224, 225, 226, 227, 228, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 200, 201, 202, 0, 223, 0, + 0, 224, 225, 226, 227, 228, 216, 217, 218, 219, + 220, 221, 222, 200, 201, 202, 0, 223, 0, 0, + 224, 225, 226, 227, 228, 0, 0, 0, -345, 219, + 220, 221, 222, 200, 201, 202, 0, 223, 0, 0, + 224, 225, 226, 227, 228, 0, 0, 0, 219, 220, + 221, 222, 0, 0, 0, 0, 223, 0, 0, 224, + 225, 226, 227, 228, 0, 0, 0, 0, 0, 220, + 221, 222, 0, 0, 0, 0, 223, 0, 0, 224, + 225, 226, 227, 228 }; static const yytype_int16 yycheck[] = { 10, 17, 19, 49, 27, 27, 403, 11, 54, 19, - 150, 306, 582, 151, 18, 16, 20, 12, 22, 10, - 24, 25, 110, 103, 13, 29, 11, 105, 19, 30, - 34, 35, 16, 111, 11, 52, 13, 556, 176, 49, - 13, 15, 52, 22, 48, 49, 50, 51, 16, 23, - 112, 113, 20, 0, 56, 89, 24, 11, 18, 61, - 20, 52, 22, 11, 24, 25, 11, 27, 22, 60, - 93, 93, 25, 13, 34, 35, 31, 22, 393, 18, - 59, 132, 11, 22, 13, 24, 25, 42, 403, 49, - 11, 51, 13, 408, 409, 34, 35, 101, 132, 669, - 132, 9, 112, 56, 11, 151, 13, 132, 61, 14, - 49, 15, 51, 86, 124, 112, 139, 139, 11, 132, - 13, 122, 117, 32, 170, 171, 35, 36, 37, 38, - 176, 132, 41, 93, 110, 111, 96, 656, 148, 149, - 150, 151, 129, 130, 161, 162, 86, 132, 132, 140, - 11, 161, 162, 157, 122, 132, 11, 86, 162, 11, - 110, 13, 302, 154, 132, 86, 176, 33, 34, 160, - 161, 162, 14, 261, 96, 97, 264, 14, 86, 139, - 11, 496, 13, 56, 14, 94, 95, 96, 97, 94, - 95, 96, 97, 86, 185, 186, 187, 188, 56, 190, - 191, 192, 162, 10, 11, 132, 13, 16, 16, 16, - 11, 20, 20, 20, 14, 24, 24, 24, 25, 132, - 132, 237, 131, 162, 22, 248, 248, 14, 238, 132, - 132, 241, 14, 132, 549, 550, 39, 22, 229, 230, - 231, 232, 233, 234, 235, 236, 22, 11, 388, 13, - 57, 587, 94, 95, 96, 97, 14, 94, 95, 96, - 97, 265, 86, 309, 94, 95, 96, 97, 228, 666, - 14, 566, 86, 11, 589, 13, 83, 70, 269, 270, - 271, 272, 273, 274, 362, 621, 622, 623, 248, 132, - 22, 308, 302, 89, 94, 95, 96, 97, 308, 290, - 615, 637, 638, 22, 442, 131, 131, 94, 95, 96, - 97, 22, 94, 95, 96, 97, 22, 308, 13, 56, - 635, 657, 56, 56, 86, 132, 11, 318, 122, 665, - 132, 16, 323, 61, 22, 44, 15, 245, 246, 247, - 25, 249, 250, 59, 252, 253, 254, 255, 22, 59, - 94, 95, 96, 97, 11, 94, 95, 96, 97, 16, - 90, 365, 94, 95, 96, 97, 22, 12, 131, 13, - 510, 56, 363, 364, 25, 25, 61, 25, 388, 25, - 371, 404, 404, 94, 95, 96, 97, 132, 94, 95, - 96, 97, 131, 403, 410, 18, 442, 59, 99, 56, - 22, 392, 393, 132, 61, 365, 94, 95, 96, 97, - 99, 11, 403, 80, 81, 406, 407, 408, 409, 56, - 94, 95, 96, 97, 564, 563, 436, 99, 132, 131, - 440, 12, 442, 132, 12, 395, 12, 12, 94, 95, - 96, 97, 270, 271, 404, 273, 274, 12, 465, 131, - 117, 118, 16, 131, 131, 465, 123, 132, 449, 126, - 127, 128, 129, 130, 544, 545, 10, 94, 95, 96, - 97, 551, 16, 131, 465, 22, 20, 557, 558, 32, - 24, 11, 35, 36, 37, 38, 30, 56, 41, 94, - 95, 96, 97, 503, 132, 505, 131, 405, 131, 131, - 510, 11, 90, 411, 131, 496, 414, 12, 22, 15, - 590, 591, 592, 530, 131, 131, 596, 563, 132, 131, - 530, 22, 131, 131, 131, 485, 434, 88, 132, 609, - 521, 94, 95, 96, 97, 131, 616, 617, 22, 530, - 132, 94, 95, 96, 97, 94, 95, 96, 97, 565, - 22, 131, 45, 563, 564, 17, 87, 80, 549, 550, - 640, 131, 578, 131, 131, 131, 13, 475, 131, 477, - 588, 581, 582, 653, 117, 666, 283, 587, 292, 406, - 488, 505, 131, 428, 664, 516, 598, 434, 604, 139, - -1, 404, 608, 248, 674, 118, 606, 588, 589, -1, - 123, -1, -1, 126, 127, 128, 129, 130, -1, -1, - -1, 621, 622, 623, 80, 94, 95, 96, 97, -1, - -1, -1, -1, 583, 615, -1, -1, 637, 638, -1, - -1, -1, -1, 541, -1, 595, -1, -1, -1, 649, - -1, 645, -1, -1, 635, 661, 21, 657, 23, -1, - -1, 26, 131, 28, 29, 665, 666, 123, -1, 669, - 126, 127, 128, 129, 130, -1, 41, -1, -1, 44, - -1, -1, -1, 48, -1, 0, 1, -1, -1, -1, - 55, 56, 57, 58, 59, 10, 11, -1, 13, -1, - 598, 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, 41, 42, 43, -1, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, - 65, 66, 67, 68, 69, -1, 71, -1, 73, 74, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, -1, -1, -1, 139, -1, 91, 94, 95, 96, - 97, -1, -1, 98, 94, 95, 96, 97, 94, 95, - 96, 97, 3, 4, 5, 6, 7, 8, 9, 126, - 127, 128, 129, 130, 119, 120, -1, 122, -1, 124, - 125, -1, -1, -1, 131, -1, -1, 132, -1, -1, - -1, 131, -1, -1, 189, 131, -1, -1, -1, -1, - 195, -1, -1, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 0, - 1, -1, 227, -1, -1, -1, -1, -1, -1, 10, - 11, -1, 13, -1, -1, 16, -1, -1, 19, 20, + 150, 306, 556, 151, 18, 12, 20, 105, 22, 10, + 24, 25, 11, 111, 13, 29, 110, 14, 19, 11, + 34, 35, 25, 13, 89, 52, 583, 0, 176, 49, + 16, 16, 52, 15, 48, 49, 50, 51, 16, 110, + 111, 23, 20, 22, 13, 30, 24, 11, 18, 13, + 20, 52, 22, 56, 24, 25, 11, 27, 61, 60, + 93, 93, 11, 13, 34, 35, 132, 132, 393, 11, + 11, 13, 13, 22, 11, 11, 13, 13, 403, 49, + 59, 51, 14, 408, 409, 56, 103, 101, 112, 113, + 61, 9, 112, 14, 132, 151, 86, 94, 95, 96, + 97, 96, 97, 657, 124, 18, 139, 139, 22, 22, + 117, 24, 25, 670, 170, 171, 11, 86, 13, 132, + 176, 34, 35, 93, 129, 130, 96, 11, 148, 149, + 150, 151, 16, 132, 161, 162, 49, 122, 51, 140, + 132, 161, 162, 157, 122, 86, 132, 132, 162, 86, + 86, 15, 302, 154, 132, 11, 176, 33, 34, 160, + 161, 162, 94, 95, 96, 97, 22, 261, 86, 139, + 264, 496, 56, 94, 95, 96, 97, 61, 112, 110, + 94, 95, 96, 97, 185, 186, 187, 188, 132, 190, + 191, 192, 162, 10, 11, 31, 13, 270, 271, 16, + 273, 274, 22, 20, 14, 11, 42, 24, 25, 11, + 16, 237, 11, 11, 13, 248, 248, 14, 238, 25, + 11, 241, 13, 56, 549, 550, 56, 132, 229, 230, + 231, 232, 233, 234, 235, 236, 132, 11, 388, 32, + 57, 132, 35, 36, 37, 38, 22, 132, 41, 162, + 56, 265, 132, 309, 132, 61, 22, 39, 228, 14, + 667, 566, 22, 14, 362, 590, 83, 14, 269, 270, + 271, 272, 273, 274, 94, 95, 96, 97, 248, 22, + 22, 308, 302, 14, 94, 95, 96, 97, 308, 290, + 86, 616, 22, 70, 442, 132, 86, 94, 95, 96, + 97, 94, 95, 96, 97, 22, 16, 308, 16, 89, + 20, 636, 20, 131, 24, 132, 24, 318, 94, 95, + 96, 97, 323, 588, 131, 22, 13, 245, 246, 247, + 56, 249, 250, 56, 252, 253, 254, 255, 131, 94, + 95, 96, 97, 94, 95, 96, 97, 94, 95, 96, + 97, 365, 94, 95, 96, 97, 56, 622, 623, 624, + 510, 86, 363, 364, 94, 95, 96, 97, 388, 122, + 371, 404, 404, 638, 639, 132, 15, 94, 95, 96, + 97, 44, 61, 403, 410, 59, 442, 94, 95, 96, + 97, 392, 393, 658, 32, 365, 90, 35, 36, 37, + 38, 666, 403, 41, 131, 406, 407, 408, 409, 94, + 95, 96, 97, 59, 564, 563, 436, 12, 25, 13, + 440, 25, 442, 25, 131, 395, 94, 95, 96, 97, + 132, 80, 81, 82, 404, 25, 18, 59, 465, 94, + 95, 96, 97, 99, 132, 465, 131, 56, 449, 22, + 11, 80, 81, 131, 99, 99, 94, 95, 96, 97, + 132, 12, 132, 131, 465, 114, 115, 116, 117, 118, + 94, 95, 96, 97, 123, 80, 131, 126, 127, 128, + 129, 130, 12, 503, 12, 505, 12, 405, 117, 118, + 510, 12, 16, 411, 123, 496, 414, 126, 127, 128, + 129, 130, 132, 530, 131, 131, 131, 563, 22, 132, + 530, 131, 131, 118, 131, 485, 434, 131, 123, 56, + 521, 126, 127, 128, 129, 130, 11, 544, 545, 530, + 94, 95, 96, 97, 551, 94, 95, 96, 97, 565, + 557, 558, 11, 563, 564, 90, 12, 131, 549, 550, + 22, 131, 15, 579, 132, 131, 131, 475, 132, 477, + 22, 131, 582, 583, 131, 88, 131, 131, 588, 22, + 488, 10, 131, 22, 591, 592, 593, 16, 132, 605, + 597, 20, 131, 609, 45, 24, 17, 607, 589, 590, + 131, 30, 131, 610, 94, 95, 96, 97, 131, 87, + 617, 618, 622, 623, 624, 94, 95, 96, 97, 126, + 127, 128, 129, 130, 584, 616, 80, 13, 638, 639, + 131, 117, 589, 541, 641, 406, 596, 667, 505, 283, + 650, 131, 646, 292, 428, 636, 662, 654, 658, 599, + 139, 516, 131, 404, -1, 434, 666, 667, 665, 21, + 670, 23, 248, -1, 26, -1, 28, 29, 675, 123, + -1, -1, 126, 127, 128, 129, 130, -1, -1, 41, + -1, -1, 44, -1, -1, -1, 48, -1, 0, 1, + -1, 599, -1, 55, 56, 57, 58, 59, 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, 41, + 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, + 62, 63, 64, 65, 66, 67, 68, 69, -1, 71, + -1, 73, 74, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, -1, -1, -1, 139, -1, 91, + -1, -1, -1, -1, -1, -1, 98, 3, 4, 5, + 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, + 122, -1, 124, 125, -1, -1, -1, -1, -1, -1, + 132, -1, -1, -1, -1, -1, -1, 189, -1, -1, + -1, -1, -1, 195, -1, -1, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 0, 1, -1, 227, -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, 41, 42, 43, -1, -1, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, + 68, 69, -1, 71, -1, 73, 74, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, + -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1, 119, 120, -1, 122, -1, 124, 125, -1, 10, + 11, 12, 13, -1, 132, 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, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, @@ -1111,28 +1126,28 @@ static const yytype_int16 yycheck[] = 71, -1, 73, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, 98, -1, -1, + -1, -1, -1, -1, 72, -1, -1, -1, -1, -1, + -1, 453, 80, 81, 82, -1, -1, -1, 119, 120, + -1, 122, -1, 124, 125, -1, -1, -1, -1, -1, + -1, 132, -1, 101, -1, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, -1, -1, -1, -1, 123, -1, -1, 126, 127, + 128, 129, 130, 1, -1, -1, -1, -1, -1, 511, + 512, -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, 543, 40, 41, 42, 43, -1, -1, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, + 68, 69, -1, 71, -1, 73, 74, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, + -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1, 119, 120, - -1, 122, -1, 124, 125, -1, 10, 11, 12, 13, - -1, 132, 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, 41, 42, 43, - -1, -1, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, -1, 62, 63, - 64, 65, 66, 67, 68, 69, -1, 71, -1, 73, - 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, - 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, - -1, -1, -1, -1, 98, -1, -1, -1, -1, -1, - -1, 72, -1, -1, -1, -1, -1, -1, 453, 80, - 81, 82, -1, -1, -1, 119, 120, -1, 122, -1, - 124, 125, -1, -1, -1, -1, -1, -1, 132, -1, - 101, -1, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, -1, -1, - -1, -1, 123, -1, -1, 126, 127, 128, 129, 130, - 1, -1, -1, -1, -1, -1, 511, 512, -1, 10, - 11, 12, 13, -1, -1, 16, -1, -1, 19, 20, + 1, 119, 120, -1, 122, -1, 124, 125, -1, 10, + 11, 12, 13, -1, 132, 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, 26, 27, 28, 29, 30, - 31, 32, -1, -1, 35, 36, 37, 38, 543, 40, + 31, 32, -1, -1, 35, 36, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, 68, 69, -1, @@ -1176,7 +1191,7 @@ static const yytype_int16 yycheck[] = -1, 91, -1, -1, -1, -1, -1, -1, 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 119, - 120, -1, 122, -1, 124, 125, -1, 10, 11, 12, + 120, -1, 122, -1, 124, 125, -1, 10, 11, -1, 13, -1, 132, 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, 41, 42, @@ -1184,7 +1199,7 @@ static const yytype_int16 yycheck[] = 53, 54, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, 68, 69, -1, 71, -1, 73, 74, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, -1, -1, -1, -1, -1, 91, -1, + 83, 84, 85, -1, -1, 88, -1, -1, 91, -1, -1, -1, -1, -1, -1, 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 119, 120, -1, 122, @@ -1196,7 +1211,7 @@ static const yytype_int16 yycheck[] = 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, 68, 69, -1, 71, -1, 73, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, - -1, -1, 88, -1, -1, 91, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 119, 120, -1, 122, -1, 124, 125, @@ -1206,52 +1221,16 @@ static const yytype_int16 yycheck[] = -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, 68, - 69, -1, 71, -1, 73, 74, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, -1, -1, -1, - -1, -1, 91, -1, -1, -1, -1, -1, -1, 98, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, - 119, 120, -1, 122, -1, 124, 125, -1, 10, 11, - -1, 13, -1, 132, 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, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, - 62, 63, 64, 65, 66, 67, 68, -1, -1, 71, - -1, 73, 74, 75, 76, 77, 78, 79, -1, -1, - -1, 83, 84, 85, -1, 1, -1, -1, -1, 91, - -1, -1, -1, -1, 10, -1, 98, 13, -1, -1, - 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, - -1, -1, -1, 29, 30, -1, -1, 119, 120, -1, - 122, -1, 124, 125, -1, -1, -1, -1, -1, -1, - 132, 47, 48, -1, -1, -1, 52, 53, -1, 55, - 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, - 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, - 76, 77, 78, 79, -1, -1, 1, 83, 84, 85, - -1, -1, -1, -1, -1, 10, -1, -1, 13, -1, - -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, - 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, - -1, -1, -1, 119, 120, -1, 122, -1, 124, 125, - -1, -1, 47, 48, -1, -1, 132, 52, 53, -1, - 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, - 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, -1, -1, -1, -1, -1, 10, 11, -1, 13, - -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, - 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, - -1, -1, -1, -1, 119, 120, -1, 122, -1, 124, - 125, -1, -1, 47, 48, -1, 131, 132, 52, 53, - -1, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, - 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, - 84, 85, -1, -1, -1, -1, -1, 10, 11, -1, - 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, + -1, -1, 71, -1, 73, 74, 75, 76, 77, 78, + 79, -1, -1, -1, 83, 84, 85, -1, 1, -1, + -1, -1, 91, -1, -1, -1, -1, 10, -1, 98, + 13, -1, -1, 16, -1, -1, 19, 20, 21, 22, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, - -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, - 124, 125, -1, -1, 47, 48, -1, -1, 132, 52, + 119, 120, -1, 122, -1, 124, 125, -1, -1, -1, + -1, -1, -1, 132, 47, 48, -1, -1, -1, 52, 53, -1, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, - -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, + -1, 74, 75, 76, 77, 78, 79, -1, -1, 1, 83, 84, 85, -1, -1, -1, -1, -1, 10, -1, -1, 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, @@ -1261,27 +1240,27 @@ static const yytype_int16 yycheck[] = 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, -1, -1, -1, 10, - -1, -1, 13, -1, -1, 16, 98, -1, 19, 20, + 11, -1, 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, 124, 125, -1, -1, 47, 48, -1, 131, 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, - -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, + 61, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, -1, -1, -1, - 10, -1, -1, 13, -1, -1, 16, 98, -1, 19, + 10, 11, -1, 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, 124, 125, -1, -1, 47, 48, -1, - 131, 132, 52, 53, -1, 55, 56, 57, 58, 59, + -1, 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, -1, -1, - -1, 10, 11, -1, 13, -1, -1, 16, 98, -1, + -1, 10, -1, -1, 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, 124, 125, -1, -1, 47, 48, - -1, 131, 132, 52, 53, -1, 55, 56, 57, 58, + -1, -1, 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, -1, @@ -1289,7 +1268,7 @@ static const yytype_int16 yycheck[] = -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, 124, 125, -1, -1, 47, - 48, -1, -1, 132, 52, 53, -1, 55, 56, 57, + 48, -1, 131, 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, -1, -1, @@ -1301,7 +1280,7 @@ static const yytype_int16 yycheck[] = 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, -1, - -1, -1, -1, -1, 10, -1, -1, 13, -1, -1, + -1, -1, -1, -1, 10, 11, -1, 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, 124, 125, -1, @@ -1313,7 +1292,7 @@ static const yytype_int16 yycheck[] = -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, 124, 125, - -1, -1, 47, 48, -1, 131, 132, 52, 53, -1, + -1, -1, 47, 48, -1, -1, 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, @@ -1329,7 +1308,7 @@ static const yytype_int16 yycheck[] = 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, -1, - 124, 125, -1, -1, 47, 48, -1, -1, 132, 52, + 124, 125, -1, -1, 47, 48, -1, 131, 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, -1, @@ -1337,61 +1316,84 @@ static const yytype_int16 yycheck[] = -1, 13, -1, -1, 16, 98, -1, 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, 122, - -1, 124, 125, -1, -1, 47, 48, -1, -1, 132, + -1, 124, 125, -1, -1, 47, 48, -1, 131, 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, -1, - -1, 83, 84, 85, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 98, -1, -1, -1, - -1, -1, -1, -1, 72, -1, -1, -1, -1, -1, - -1, -1, 80, 81, 82, -1, -1, 119, 120, -1, - 122, -1, 124, 125, -1, 93, -1, -1, -1, -1, - 132, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, -1, -1, -1, -1, 123, 72, -1, 126, 127, - 128, 129, 130, -1, 80, 81, 82, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 93, -1, -1, - -1, -1, -1, 99, 100, 101, -1, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, -1, -1, -1, -1, 123, 72, -1, - 126, 127, 128, 129, 130, -1, 80, 81, 82, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 93, - -1, -1, -1, -1, -1, 99, 100, 101, -1, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, -1, -1, -1, -1, 123, - 72, -1, 126, 127, 128, 129, 130, -1, 80, 81, - 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 99, 100, 101, - -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, -1, -1, - -1, 123, 72, -1, 126, 127, 128, 129, 130, -1, - 80, 81, 82, -1, -1, -1, -1, -1, -1, -1, + -1, 83, 84, 85, -1, -1, -1, -1, -1, 10, + -1, -1, 13, -1, -1, 16, 98, -1, 19, 20, + 21, -1, -1, 24, 25, -1, -1, -1, 29, 30, + -1, -1, -1, -1, -1, -1, -1, 119, 120, -1, + 122, -1, 124, 125, -1, -1, 47, 48, -1, 131, + 132, 52, 53, -1, 55, 56, 57, 58, 59, 60, + -1, 62, 63, 64, 65, 66, 67, -1, -1, -1, + 71, -1, -1, 74, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, -1, -1, -1, -1, -1, + 10, -1, -1, 13, -1, -1, 16, 98, -1, 19, + 20, 21, -1, -1, 24, 25, -1, -1, -1, 29, + 30, -1, -1, -1, -1, -1, -1, -1, 119, 120, + -1, 122, -1, 124, 125, -1, -1, 47, 48, -1, + -1, 132, 52, 53, -1, 55, 56, 57, 58, 59, + 60, -1, 62, 63, 64, 65, 66, 67, -1, -1, + -1, 71, -1, -1, 74, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, -1, -1, -1, -1, + -1, 10, -1, -1, 13, -1, -1, 16, 98, -1, + 19, 20, 21, -1, -1, 24, 25, -1, -1, -1, + 29, 30, -1, -1, -1, -1, -1, -1, -1, 119, + 120, -1, 122, -1, 124, 125, -1, -1, 47, 48, + -1, -1, 132, 52, 53, -1, 55, 56, 57, 58, + 59, 60, -1, 62, 63, 64, 65, 66, 67, -1, + -1, -1, 71, -1, -1, 74, 75, 76, 77, 78, + 79, -1, -1, -1, 83, 84, 85, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 98, + -1, -1, -1, -1, -1, -1, -1, 72, -1, -1, + -1, -1, -1, -1, -1, 80, 81, 82, -1, -1, + 119, 120, -1, 122, -1, 124, 125, -1, 93, -1, + -1, -1, -1, 132, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, -1, -1, -1, -1, 123, 72, + -1, 126, 127, 128, 129, 130, -1, 80, 81, 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 80, - 81, 82, -1, 123, -1, -1, 126, 127, 128, 129, - 130, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 80, 81, 82, 106, 107, 108, 109, 110, + 93, -1, -1, -1, -1, -1, 99, 100, 101, -1, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, -1, -1, -1, -1, + 123, 72, -1, 126, 127, 128, 129, 130, -1, 80, + 81, 82, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 93, -1, -1, -1, -1, -1, 99, 100, + 101, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, -1, -1, - -1, -1, 123, -1, -1, 126, 127, 128, 129, 130, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 80, 81, 82, -1, 123, -1, -1, 126, 127, - 128, 129, 130, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 80, 81, 82, -1, -1, -1, -1, -1, + -1, -1, 123, 72, -1, 126, 127, 128, 129, 130, + -1, 80, 81, 82, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 99, 100, 101, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 80, 81, 82, 123, -1, -1, 126, 127, 128, - 129, 130, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 80, 81, 82, -1, 123, -1, -1, 126, 127, - 128, 129, 130, 112, 113, 114, 115, 116, 117, 118, - 80, 81, 82, -1, 123, -1, -1, 126, 127, 128, - 129, 130, -1, -1, -1, 114, 115, 116, 117, 118, - 80, 81, 82, -1, 123, -1, -1, 126, 127, 128, - 129, 130, -1, -1, 114, 115, 116, 117, 118, 80, - 81, 82, -1, 123, -1, -1, 126, 127, 128, 129, - 130, -1, -1, -1, -1, 115, 116, 117, 118, -1, - -1, -1, -1, 123, -1, -1, 126, 127, 128, 129, - 130, -1, -1, -1, -1, 116, 117, 118, -1, -1, - -1, -1, 123, -1, -1, 126, 127, 128, 129, 130 + -1, -1, -1, -1, 123, 72, -1, 126, 127, 128, + 129, 130, -1, 80, 81, 82, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 80, 81, 82, -1, 123, -1, -1, 126, + 127, 128, 129, 130, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 80, 81, 82, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, -1, -1, -1, -1, 123, -1, -1, 126, 127, + 128, 129, 130, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 80, 81, 82, -1, 123, -1, + -1, 126, 127, 128, 129, 130, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 80, 81, 82, -1, -1, + -1, -1, -1, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 80, 81, 82, 123, -1, -1, + 126, 127, 128, 129, 130, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 80, 81, 82, -1, 123, -1, + -1, 126, 127, 128, 129, 130, 112, 113, 114, 115, + 116, 117, 118, 80, 81, 82, -1, 123, -1, -1, + 126, 127, 128, 129, 130, -1, -1, -1, 114, 115, + 116, 117, 118, 80, 81, 82, -1, 123, -1, -1, + 126, 127, 128, 129, 130, -1, -1, -1, 115, 116, + 117, 118, -1, -1, -1, -1, 123, -1, -1, 126, + 127, 128, 129, 130, -1, -1, -1, -1, -1, 116, + 117, 118, -1, -1, -1, -1, 123, -1, -1, 126, + 127, 128, 129, 130 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -1404,68 +1406,68 @@ static const yytype_uint8 yystos[] = 52, 53, 55, 56, 57, 58, 59, 60, 62, 63, 64, 65, 66, 67, 71, 74, 75, 76, 77, 78, 79, 83, 84, 85, 98, 119, 120, 122, 124, 125, - 132, 144, 205, 206, 207, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 221, 228, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 11, 143, 1, 22, + 132, 144, 206, 207, 208, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 222, 229, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 11, 143, 1, 22, 26, 27, 28, 31, 32, 35, 36, 37, 38, 40, 41, 42, 43, 46, 49, 50, 51, 54, 68, 73, - 91, 142, 143, 156, 170, 205, 225, 69, 154, 155, - 156, 144, 152, 198, 199, 152, 56, 61, 143, 237, - 245, 228, 245, 219, 245, 219, 245, 245, 219, 122, - 132, 222, 237, 238, 239, 219, 143, 219, 182, 182, - 183, 245, 245, 220, 13, 132, 219, 182, 219, 132, - 132, 89, 132, 143, 219, 56, 144, 206, 227, 237, - 245, 143, 245, 228, 56, 61, 185, 206, 219, 219, - 219, 219, 219, 131, 205, 94, 95, 96, 97, 15, + 91, 142, 143, 156, 170, 206, 226, 69, 154, 155, + 156, 144, 152, 199, 200, 152, 56, 61, 143, 238, + 246, 229, 246, 220, 246, 220, 246, 246, 220, 122, + 132, 223, 238, 239, 240, 220, 143, 220, 182, 182, + 183, 246, 246, 221, 13, 132, 220, 182, 220, 132, + 132, 89, 132, 143, 220, 56, 144, 207, 228, 238, + 246, 143, 246, 229, 56, 61, 185, 207, 220, 220, + 220, 220, 220, 131, 206, 94, 95, 96, 97, 15, 11, 13, 132, 112, 113, 112, 110, 111, 110, 72, 80, 81, 82, 93, 99, 100, 101, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 123, 126, 127, 128, 129, 130, 132, 11, 13, 11, 13, 11, 13, 11, 146, 184, 56, - 56, 223, 237, 238, 239, 132, 132, 30, 122, 132, - 235, 237, 132, 132, 132, 132, 143, 11, 147, 147, + 56, 224, 238, 239, 240, 132, 132, 30, 122, 132, + 236, 238, 132, 132, 132, 132, 143, 11, 147, 147, 181, 185, 22, 181, 185, 39, 144, 172, 22, 32, 35, 36, 37, 38, 41, 22, 155, 156, 154, 16, - 20, 24, 144, 190, 191, 192, 193, 194, 195, 14, - 132, 219, 222, 237, 238, 239, 131, 205, 86, 188, - 70, 144, 186, 86, 144, 187, 187, 227, 132, 89, - 205, 131, 143, 131, 131, 205, 228, 228, 245, 206, - 206, 22, 227, 13, 131, 205, 205, 205, 205, 219, - 205, 205, 131, 205, 219, 219, 219, 219, 219, 219, - 219, 219, 219, 219, 219, 219, 219, 219, 219, 219, - 219, 219, 219, 219, 219, 219, 219, 219, 219, 219, - 219, 219, 10, 11, 13, 16, 20, 24, 25, 57, - 83, 132, 209, 237, 131, 205, 205, 205, 205, 205, - 205, 205, 205, 152, 56, 144, 180, 56, 56, 86, - 144, 224, 146, 146, 122, 146, 30, 233, 234, 236, - 237, 238, 239, 146, 146, 132, 146, 146, 146, 146, - 148, 44, 160, 181, 159, 181, 143, 169, 205, 169, - 169, 177, 205, 169, 169, 61, 189, 189, 15, 131, - 205, 188, 131, 59, 187, 59, 146, 203, 203, 228, - 206, 14, 208, 131, 90, 131, 205, 12, 205, 13, - 22, 14, 131, 102, 25, 185, 205, 205, 25, 25, - 25, 25, 25, 131, 205, 132, 131, 22, 14, 22, + 20, 24, 144, 190, 191, 192, 194, 195, 196, 14, + 132, 220, 223, 238, 239, 240, 131, 206, 86, 188, + 70, 144, 186, 86, 144, 187, 187, 228, 132, 89, + 206, 131, 143, 131, 131, 206, 229, 229, 246, 207, + 207, 22, 228, 13, 131, 206, 206, 206, 206, 220, + 206, 206, 131, 206, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 10, 11, 13, 16, 20, 24, 25, 57, + 83, 132, 210, 238, 131, 206, 206, 206, 206, 206, + 206, 206, 206, 152, 56, 144, 180, 56, 56, 86, + 144, 225, 146, 146, 122, 146, 30, 234, 235, 237, + 238, 239, 240, 146, 146, 132, 146, 146, 146, 146, + 148, 44, 160, 181, 159, 181, 143, 169, 206, 169, + 169, 177, 206, 169, 169, 61, 189, 189, 15, 131, + 206, 188, 131, 59, 187, 59, 146, 204, 204, 229, + 207, 14, 209, 131, 90, 131, 206, 12, 206, 13, + 22, 14, 131, 102, 25, 185, 206, 206, 25, 25, + 25, 25, 25, 131, 206, 132, 131, 22, 14, 22, 14, 22, 14, 22, 12, 18, 145, 11, 22, 187, - 59, 99, 178, 205, 178, 132, 230, 237, 132, 144, - 170, 175, 178, 179, 205, 233, 146, 177, 176, 205, - 178, 178, 152, 146, 56, 157, 22, 146, 200, 201, - 158, 99, 99, 193, 131, 201, 132, 144, 196, 197, - 131, 23, 144, 229, 227, 131, 14, 205, 12, 219, - 132, 22, 14, 131, 228, 12, 12, 12, 12, 146, - 146, 11, 22, 226, 131, 131, 231, 232, 237, 132, + 59, 99, 178, 206, 178, 132, 231, 238, 132, 144, + 170, 175, 178, 179, 206, 234, 146, 177, 176, 206, + 178, 178, 152, 146, 56, 157, 22, 146, 201, 202, + 158, 99, 99, 194, 131, 202, 132, 144, 197, 198, + 131, 23, 144, 230, 228, 131, 14, 206, 12, 220, + 132, 22, 14, 131, 229, 12, 12, 12, 12, 146, + 146, 11, 22, 227, 131, 131, 232, 233, 238, 132, 146, 131, 22, 163, 178, 131, 131, 131, 131, 12, - 132, 144, 149, 56, 186, 11, 187, 219, 219, 198, - 11, 205, 90, 14, 228, 12, 131, 22, 165, 146, - 219, 147, 147, 15, 131, 178, 178, 147, 161, 132, - 131, 174, 174, 147, 147, 150, 164, 227, 187, 152, - 22, 202, 203, 131, 204, 131, 88, 152, 166, 33, - 34, 144, 171, 171, 237, 132, 131, 131, 172, 176, - 178, 147, 147, 147, 237, 147, 22, 200, 12, 152, - 144, 153, 12, 152, 147, 132, 178, 147, 147, 22, - 131, 172, 172, 172, 151, 45, 173, 12, 22, 59, - 167, 12, 178, 131, 172, 172, 162, 147, 131, 143, - 17, 87, 144, 168, 131, 147, 174, 172, 152, 147, - 172, 179, 88, 171, 131, 147 + 132, 144, 149, 56, 186, 11, 187, 193, 220, 220, + 199, 11, 206, 90, 14, 229, 12, 131, 22, 165, + 146, 220, 147, 147, 15, 131, 178, 178, 147, 161, + 132, 131, 174, 174, 147, 147, 150, 164, 228, 187, + 152, 22, 203, 204, 131, 205, 131, 88, 152, 166, + 33, 34, 144, 171, 171, 238, 132, 131, 131, 172, + 176, 178, 147, 147, 147, 238, 147, 22, 201, 12, + 152, 144, 153, 12, 152, 147, 132, 178, 147, 147, + 22, 131, 172, 172, 172, 151, 45, 173, 12, 22, + 59, 167, 12, 178, 131, 172, 172, 162, 147, 131, + 143, 17, 87, 144, 168, 131, 147, 174, 172, 152, + 147, 172, 179, 88, 171, 131, 147 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ @@ -1483,29 +1485,29 @@ static const yytype_uint8 yyr1[] = 171, 171, 172, 172, 173, 173, 174, 175, 175, 176, 176, 177, 178, 179, 180, 180, 181, 182, 183, 184, 185, 185, 186, 186, 187, 187, 187, 188, 188, 189, - 189, 190, 190, 191, 191, 191, 192, 192, 192, 193, - 193, 194, 194, 194, 195, 195, 196, 196, 197, 199, - 198, 200, 200, 201, 202, 202, 204, 203, 205, 205, - 205, 205, 205, 206, 206, 206, 207, 207, 207, 207, - 207, 207, 207, 207, 207, 207, 207, 207, 208, 207, - 209, 209, 210, 210, 210, 210, 210, 210, 210, 210, - 210, 210, 210, 210, 210, 210, 211, 211, 211, 211, - 211, 211, 211, 211, 211, 211, 211, 211, 211, 211, - 211, 211, 211, 211, 211, 211, 211, 211, 212, 212, - 212, 212, 212, 213, 213, 214, 214, 214, 214, 215, - 215, 216, 216, 216, 216, 216, 216, 216, 216, 216, - 217, 217, 217, 217, 217, 217, 217, 217, 218, 218, - 219, 219, 219, 219, 219, 219, 219, 219, 219, 219, - 219, 219, 219, 219, 219, 219, 219, 219, 219, 219, - 219, 219, 219, 219, 219, 219, 219, 219, 219, 219, - 219, 219, 219, 219, 219, 219, 219, 219, 219, 219, - 219, 219, 219, 219, 219, 219, 219, 219, 220, 219, - 219, 219, 219, 221, 221, 221, 221, 222, 222, 222, - 222, 222, 223, 223, 223, 224, 224, 224, 225, 226, - 225, 227, 227, 228, 228, 229, 229, 230, 231, 231, - 231, 232, 233, 233, 233, 234, 234, 235, 235, 236, - 237, 238, 239, 240, 240, 241, 242, 242, 243, 243, - 244, 244, 245, 245, 245, 245 + 189, 190, 190, 191, 191, 191, 192, 192, 193, 193, + 194, 194, 195, 195, 195, 196, 196, 197, 197, 198, + 200, 199, 201, 201, 202, 203, 203, 205, 204, 206, + 206, 206, 206, 206, 207, 207, 207, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 209, + 208, 210, 210, 211, 211, 211, 211, 211, 211, 211, + 211, 211, 211, 211, 211, 211, 211, 212, 212, 212, + 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, + 212, 212, 212, 212, 212, 212, 212, 212, 212, 213, + 213, 213, 213, 213, 214, 214, 215, 215, 215, 215, + 216, 216, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 218, 218, 218, 218, 218, 218, 218, 218, 219, + 219, 220, 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, 220, 220, + 220, 220, 220, 220, 220, 220, 220, 220, 220, 221, + 220, 220, 220, 220, 222, 222, 222, 222, 223, 223, + 223, 223, 223, 224, 224, 224, 225, 225, 225, 226, + 227, 226, 228, 228, 229, 229, 230, 230, 231, 232, + 232, 232, 233, 234, 234, 234, 235, 235, 236, 236, + 237, 238, 239, 240, 241, 241, 242, 243, 243, 244, + 244, 245, 245, 246, 246, 246, 246 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -1523,29 +1525,29 @@ static const yytype_int8 yyr2[] = 2, 6, 1, 2, 0, 2, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 0, - 1, 1, 1, 2, 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, 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, 3, 4, 3, 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 + 1, 1, 1, 2, 3, 4, 2, 4, 0, 1, + 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, 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, 3, 4, 3, 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 { @@ -1591,19 +1593,20 @@ static const toketypes yy_type_tab[] = toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_ival, toketype_ival, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_ival, + toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, - toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_opval, + toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_opval, toketype_opval, - toketype_opval, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, - toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, - toketype_opval, toketype_ival, toketype_opval, toketype_opval, toketype_pval, toketype_opval, - toketype_opval, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, + toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, + toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_opval, toketype_opval, + toketype_pval, toketype_opval, toketype_opval, toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, - toketype_ival, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, - toketype_opval, toketype_opval, toketype_opval, toketype_opval + toketype_opval, toketype_opval, toketype_opval, toketype_ival, toketype_opval, + toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, toketype_opval, + toketype_opval }; /* Generated from: - * a66533df84b2ea4db3ab085ffee3685d0e63a6946a65e9ce91b2621b7bd4e01e perly.y + * c36bc8f06e0d028fe375ec5042a868f1249c42d01a2da5b7be104611f300ff06 perly.y * f13e9c08cea6302f0c1d1f467405bd0e0880d0ea92d0669901017a7f7e94ab28 regen_perly.pl * ex: set ro ft=c: */ diff --git a/perly.y b/perly.y index 63b1faf9b787..5af726410676 100644 --- a/perly.y +++ b/perly.y @@ -115,7 +115,7 @@ %type termbinop termunop anonymous termdo %type termrelop relopchain termeqop eqopchain %type sigslurpsigil sigvar -%type sigscalarelem sigslurpelem +%type sigscalarelem optsigscalardefault sigslurpelem %type sigelem siglist optsiglist subsigguts subsignature optsubsignature %type subbody optsubbody sigsubbody optsigsubbody %type formstmtseq formline formarg @@ -857,18 +857,19 @@ sigscalarelem: subsignature_append_positional($sigvar, 0, NULL); $$ = NULL; } - | PERLY_DOLLAR sigvar ASSIGNOP + | PERLY_DOLLAR sigvar ASSIGNOP optsigscalardefault { - subsignature_append_positional($sigvar, $ASSIGNOP, newOP(OP_NULL, 0)); - $$ = NULL; - } - | PERLY_DOLLAR sigvar ASSIGNOP term[defop] - { - subsignature_append_positional($sigvar, $ASSIGNOP, $defop); + subsignature_append_positional($sigvar, $ASSIGNOP, $optsigscalardefault); $$ = NULL; } ; +optsigscalardefault: + %empty + { $$ = newOP(OP_NULL, 0); } + | term + ; + /* subroutine signature element: e.g. '$x = $default' or '%h' */ sigelem: sigscalarelem From 2bc615d5216e8ef43a53ae1517a8ef521da33e04 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Thu, 17 Oct 2024 15:41:04 +0100 Subject: [PATCH 3/5] pp.c: Refactor some behaviours into helper functions These two new helper functions will be useful for sharing behaviour with upcoming code, when adding OP_MULTIPARAM. --- pp.c | 61 +++++++++++++++++++++++++++++++++--------------------------- 1 file changed, 34 insertions(+), 27 deletions(-) diff --git a/pp.c b/pp.c index 3540fe7a6879..7110a1dbf06f 100644 --- a/pp.c +++ b/pp.c @@ -7635,6 +7635,23 @@ PP(pp_anonconst) } +/* Helper function for use during signature argument handling from @_. + * Replaces elements in an AV with a new SV cloned from the original value + * at each position from startix onwards until endix. + */ +#define av_refresh_elements_range(av, startix, endix) S_av_refresh_elements_range(aTHX_ av, startix, endix) +STATIC void +S_av_refresh_elements_range(pTHX_ AV *av, IV startix, IV endix) +{ + for(IV ix = startix; ix < endix; ix++) { + SV **svp = av_fetch(av, ix, FALSE); + SV *newsv = newSVsv_flags(svp ? *svp : &PL_sv_undef, + (SV_DO_COW_SVSETSV|SV_NOSTEAL)); + if(!av_store(av, ix, newsv)) + SvREFCNT_dec_NN(newsv); + } +} + /* process one subroutine argument - typically when the sub has a signature: * introduce PL_curpad[op_targ] and assign to it the value * for $: (OPf_STACKED ? *sp : $_[N]) @@ -7713,13 +7730,7 @@ PP_wrapped(pp_argelem, * to avoid the equivalent of @a = ($a[0]) prematurely freeing * elements. See similar code in pp_aassign. */ - for (i = 0; i < argc; i++) { - SV **svp = av_fetch(defav, ix + i, FALSE); - SV *newsv = newSVsv_flags(svp ? *svp : &PL_sv_undef, - (SV_DO_COW_SVSETSV|SV_NOSTEAL)); - if (!av_store(defav, ix + i, newsv)) - SvREFCNT_dec_NN(newsv); - } + av_refresh_elements_range(defav, ix, ix + argc); av_clear((AV*)targ); } @@ -7745,13 +7756,7 @@ PP_wrapped(pp_argelem, if (SvRMAGICAL(targ) || HvUSEDKEYS((HV*)targ)) { /* see "target should usually be empty" comment above */ - for (i = 0; i < argc; i++) { - SV **svp = av_fetch(defav, ix + i, FALSE); - SV *newsv = newSVsv_flags(svp ? *svp : &PL_sv_undef, - (SV_DO_COW_SVSETSV|SV_NOSTEAL)); - if (!av_store(defav, ix + i, newsv)) - SvREFCNT_dec_NN(newsv); - } + av_refresh_elements_range(defav, ix, ix + argc); hv_clear((HV*)targ); } @@ -7842,20 +7847,10 @@ S_find_runcv_name(void) * signatured subs. */ -PP(pp_argcheck) +static void +S_check_argc(pTHX_ UV argc, UV params, UV opt_params, char slurpy) { - OP * const o = PL_op; - struct op_argcheck_aux *aux = (struct op_argcheck_aux *)cUNOP_AUXo->op_aux; - UV params = aux->params; - UV opt_params = aux->opt_params; - char slurpy = aux->slurpy; - AV *defav = GvAV(PL_defgv); /* @_ */ - UV argc; - bool too_few; - - assert(!SvMAGICAL(defav)); - argc = (UV)(AvFILLp(defav) + 1); - too_few = (argc < (params - opt_params)); + bool too_few = (argc < (params - opt_params)); if (UNLIKELY(too_few || (!slurpy && argc > params))) @@ -7874,6 +7869,18 @@ PP(pp_argcheck) /* diag_listed_as: Odd name/value argument for subroutine '%s' */ Perl_croak_caller("Odd name/value argument for subroutine '%" SVf "'", S_find_runcv_name()); +} + +PP(pp_argcheck) +{ + OP * const o = PL_op; + struct op_argcheck_aux *aux = (struct op_argcheck_aux *)cUNOP_AUXo->op_aux; + AV *defav = GvAV(PL_defgv); /* @_ */ + + assert(!SvMAGICAL(defav)); + UV argc = (UV)(AvFILLp(defav) + 1); + + S_check_argc(aTHX_ argc, aux->params, aux->opt_params, aux->slurpy); return NORMAL; } From 907ada1d667d4cd04e7288e1a38d6379b687f909 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Thu, 16 Jan 2025 15:09:33 +0000 Subject: [PATCH 4/5] t/op/signatures.t: Nuke the tests of modifying @_ during signature argument processing The specific behaviour of this obscure modification case is not documented or relied upon elsewhere in code. Rather than attempt to preserve this cornercase, it's easier just to no longer test for it, as upcoming changes will alter the values that are visible. --- t/op/signatures.t | 40 ++-------------------------------------- 1 file changed, 2 insertions(+), 38 deletions(-) diff --git a/t/op/signatures.t b/t/op/signatures.t index 7f4e6ff1e0cd..41b17241c60a 100644 --- a/t/op/signatures.t +++ b/t/op/signatures.t @@ -1399,20 +1399,8 @@ is scalar(t145()), undef; } is ref(t149()), "ARRAY", "t149: closure can make new lexical a ref"; - # Quiet the 'use of @_ is experimental' warnings - no warnings 'experimental::args_array_with_signatures'; - - sub t150 ($a = do {@_ = qw(a b c); 1}, $b = 2) { - is $a, 1, "t150: a: growing \@_"; - is $b, "b", "t150: b: growing \@_"; - } - t150(); - - sub t151 ($a = do {tie @_, 'Tie::StdArray'; @_ = qw(a b c); 1}, $b = 2) { - is $a, 1, "t151: a: tied \@_"; - is $b, "b", "t151: b: tied \@_"; - } - t151(); + # Tests t150, t151, t156 to t159 were related to modifying @_ during + # signature handling. This is no longer supported sub t152 ($a = t152x(), @b) { sub t152x { @b = qw(a b c); 1 } @@ -1438,30 +1426,6 @@ is scalar(t145()), undef; } is t155(), "1-", "t155: closure can make new lexical hash tied"; - sub t156 ($a = do {@_ = qw(a b c); 1}, @b) { - is $a, 1, "t156: a: growing \@_"; - is "@b", "b c", "t156: b: growing \@_"; - } - t156(); - - sub t157 ($a = do {@_ = qw(a b c); 1}, %b) { - is $a, 1, "t157: a: growing \@_"; - is join(':', sort %b), "b:c", "t157: b: growing \@_"; - } - t157(); - - sub t158 ($a = do {tie @_, 'Tie::StdArray'; @_ = qw(a b c); 1}, @b) { - is $a, 1, "t158: a: tied \@_"; - is "@b", "b c", "t158: b: tied \@_"; - } - t158(); - - sub t159 ($a = do {tie @_, 'Tie::StdArray'; @_ = qw(a b c); 1}, %b) { - is $a, 1, "t159: a: tied \@_"; - is join(':', sort %b), "b:c", "t159: b: tied \@_"; - } - t159(); - # see if we can handle the equivalent of @a = ($a[1], $a[0]) sub t160 ($s, @a) { From 5d789947979a3f443d7f91dce25f4154533c9453 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Tue, 6 May 2025 17:21:11 +0100 Subject: [PATCH 5/5] Create new `OP_MULTIPARAM` to implement subroutine signatures Creates a new UNOP_AUX op type, `OP_MULTIPARAM`, that handles all of the initial behaviour of assigning values to parameters of a subroutine signature out of values passed by the caller. This is created in a similar style to other multi-ops like `OP_MULTIDEREF` and `OP_MULTICONCAT` where the op's aux structure contains a sub-program of sorts, which describes all of the small details of operation. Also adds a LOGOP, `OP_PARAMTEST` and UNOP `OP_PARAMSTORE` which are responsible for implementing the default expressions of optional parameters. These use the `SvPADSTALE` flag set on pad lexicals used as parameters to remember whether assignment has happened, ensuring that missing vs present-but-undef can be detected in a way that does not depend on counting arguments on the stack. This change is carefully designed to support two future ideas: * Named parameters as per PPC0024 https://github.com/Perl/PPCs/blob/main/ppcs/ppc0024-signature-named-parameters.md * "no-snails"; the performance optimisation that avoids storing incoming argument values in the `@_` AV and instead consumes them directly from the stack --- dump.c | 30 ++++ ext/B/B.pm | 2 +- ext/B/B.xs | 14 ++ ext/Opcode/Opcode.pm | 3 +- ext/XS-APItest/APItest.pm | 2 +- ext/XS-APItest/APItest.xs | 23 +++ ext/XS-APItest/t/subsignature.t | 10 +- lib/B/Deparse.pm | 94 +++++++++- lib/B/Op_private.pm | 9 + op.c | 292 +++++++++++++++++++++++--------- op.h | 10 ++ opcode.h | 27 ++- opnames.h | 5 +- peep.c | 1 + pp.c | 138 +++++++++++++++ pp_proto.h | 3 + regen/op_private | 6 + regen/opcodes | 4 + t/op/signatures.t | 8 +- t/perf/opcount.t | 57 +++++++ 20 files changed, 645 insertions(+), 93 deletions(-) diff --git a/dump.c b/dump.c index 08220bc22b5a..c4ccd350a881 100644 --- a/dump.c +++ b/dump.c @@ -1665,6 +1665,7 @@ S_do_op_dump_bar(pTHX_ I32 level, UV bar, PerlIO *file, const OP *o, case OP_ENTERWHEN: case OP_ENTERTRY: case OP_ONCE: + case OP_PARAMTEST: S_opdump_indent(aTHX_ o, level, bar, file, "OTHER"); S_opdump_link(aTHX_ o, cLOGOPo->op_other, file); break; @@ -1782,6 +1783,35 @@ S_do_op_dump_bar(pTHX_ I32 level, UV bar, PerlIO *file, const OP *o, break; } + case OP_MULTIPARAM: + { + struct op_multiparam_aux *aux = (struct op_multiparam_aux *)cUNOP_AUXo->op_aux; + UV min_args = aux->min_args; + UV n_positional = aux->n_positional; + if(n_positional > min_args) + S_opdump_indent(aTHX_ o, level, bar, file, "ARGS = %" UVuf " .. %" UVuf "\n", + min_args, n_positional); + else + S_opdump_indent(aTHX_ o, level, bar, file, "ARGS = %" UVuf "\n", + min_args); + + for(Size_t i = 0; i < n_positional; i++) { + PADOFFSET padix = aux->param_padix[i]; + if(padix) + S_opdump_indent(aTHX_ o, level, bar, file, " PARAM [%zd] PADIX = %" UVuf "%s\n", + i, aux->param_padix[i], i >= min_args ? " OPT" : ""); + else + S_opdump_indent(aTHX_ o, level, bar, file, " PARAM [%zd] ANON\n", + i); + } + + if(aux->slurpy) + S_opdump_indent(aTHX_ o, level, bar, file, "SLURPY = '%c' PADIX = %" UVuf "\n", + aux->slurpy, aux->slurpy_padix); + + break; + } + case OP_CUSTOM: { void (*custom_dumper)(pTHX_ const OP *o, struct Perl_OpDumpContext *ctx) = diff --git a/ext/B/B.pm b/ext/B/B.pm index b39385b35e81..5464549d4f83 100644 --- a/ext/B/B.pm +++ b/ext/B/B.pm @@ -20,7 +20,7 @@ sub import { # walkoptree comes from B.xs BEGIN { - $B::VERSION = '1.89'; + $B::VERSION = '1.90'; @B::EXPORT_OK = (); # Our BOOT code needs $VERSION set, and will append to @EXPORT_OK. diff --git a/ext/B/B.xs b/ext/B/B.xs index 0b8ef47cf21d..c36a4f200395 100644 --- a/ext/B/B.xs +++ b/ext/B/B.xs @@ -1393,6 +1393,20 @@ aux_list(o, cv) XSRETURN(len); } /* OP_MULTIDEREF */ + + case OP_MULTIPARAM: + { + struct op_multiparam_aux *p = (struct op_multiparam_aux *)aux; + UV nparams = p->n_positional; + EXTEND(SP, (IV)(3 + nparams + 1)); + mPUSHu(p->min_args); + mPUSHu(p->n_positional); + PUSHs(sv_2mortal(p->slurpy ? newSVpvf("%c", p->slurpy) : &PL_sv_no)); + for(UV parami = 0; parami < nparams; parami++) + mPUSHu(p->param_padix[parami]); + mPUSHu(p->slurpy_padix); + XSRETURN(3 + nparams + 1); + } } /* switch */ diff --git a/ext/Opcode/Opcode.pm b/ext/Opcode/Opcode.pm index 0bab44788aae..d55e46813d25 100644 --- a/ext/Opcode/Opcode.pm +++ b/ext/Opcode/Opcode.pm @@ -1,4 +1,4 @@ -package Opcode 1.69; +package Opcode 1.70; use strict; @@ -309,6 +309,7 @@ invert_opset function. rv2hv helem hslice kvhslice each values keys exists delete aeach akeys avalues multideref argelem argdefelem argcheck + multiparam paramtest paramstore preinc i_preinc predec i_predec postinc i_postinc postdec i_postdec int hex oct abs pow multiply i_multiply diff --git a/ext/XS-APItest/APItest.pm b/ext/XS-APItest/APItest.pm index 2ff6b1ecb7b3..7f0a902db9d7 100644 --- a/ext/XS-APItest/APItest.pm +++ b/ext/XS-APItest/APItest.pm @@ -4,7 +4,7 @@ use strict; use warnings; use Carp; -our $VERSION = '1.44'; +our $VERSION = '1.45'; require XSLoader; diff --git a/ext/XS-APItest/APItest.xs b/ext/XS-APItest/APItest.xs index 9d82dfdd014d..51842f35fea4 100644 --- a/ext/XS-APItest/APItest.xs +++ b/ext/XS-APItest/APItest.xs @@ -1200,6 +1200,29 @@ static OP *THX_parse_keyword_subsignature(pTHX) newSVpvf(kid->op_flags & OPf_KIDS ? "argelem:%s:d" : "argelem:%s", namepv))); break; } + case OP_MULTIPARAM: { + struct op_multiparam_aux *p = + (struct op_multiparam_aux *)(cUNOP_AUXx(kid)->op_aux); + PADNAMELIST *names = PadlistNAMES(CvPADLIST(find_runcv(0))); + SV *retsv = newSVpvf("multiparam:%" UVuf "..%" UVuf ":%c", + p->min_args, p->n_positional, p->slurpy ? p->slurpy : '-'); + for (UV paramidx = 0; paramidx < p->n_positional; paramidx++) { + char *namepv = PadnamePV(padnamelist_fetch(names, p->param_padix[paramidx])); + if(namepv) + sv_catpvf(retsv, ":%s=%" UVf, namepv, paramidx); + else + sv_catpvf(retsv, ":(anon)=%" UVf, paramidx); + if(paramidx >= p->min_args) + sv_catpvs(retsv, "?"); + } + if (p->slurpy_padix) + sv_catpvf(retsv, ":%s=*", + PadnamePV(padnamelist_fetch(names, p->slurpy_padix))); + retop = op_append_list(OP_LIST, retop, newSVOP(OP_CONST, 0, retsv)); + break; + } + case OP_PARAMTEST: + break; default: fprintf(stderr, "TODO: examine kid %p (optype=%s)\n", kid, PL_op_name[kid->op_type]); break; diff --git a/ext/XS-APItest/t/subsignature.t b/ext/XS-APItest/t/subsignature.t index f7d0e25bce08..b5c9fd941e59 100644 --- a/ext/XS-APItest/t/subsignature.t +++ b/ext/XS-APItest/t/subsignature.t @@ -19,11 +19,11 @@ eval q{ }; is $@, ""; is_deeply \@t, [ - ['nextstate:4', 'argcheck:2:0:-', 'argelem:$x', 'argelem:$y'], - ['nextstate:5', 'argcheck:2:0:-', 'argelem:$z',], - ['nextstate:6', 'argcheck:0:0:@', 'argelem:@rest'], - ['nextstate:7', 'argcheck:0:0:%', 'argelem:%rest'], - ['nextstate:8', 'argcheck:1:1:-', 'argelem:$one:d'], + ['nextstate:4', 'multiparam:2..2:-:$x=0:$y=1' ], + ['nextstate:5', 'multiparam:2..2:-:$z=0:(anon)=1',], + ['nextstate:6', 'multiparam:0..0:@:@rest=*'], + ['nextstate:7', 'multiparam:0..0:%:%rest=*'], + ['nextstate:8', 'multiparam:0..1:-:$one=0?'], ]; done_testing; diff --git a/lib/B/Deparse.pm b/lib/B/Deparse.pm index 30243477b7f3..6b52d6757be3 100644 --- a/lib/B/Deparse.pm +++ b/lib/B/Deparse.pm @@ -7,7 +7,7 @@ # This is based on the module of the same name by Malcolm Beattie, # but essentially none of his code remains. -package B::Deparse 1.86; +package B::Deparse 1.87; use strict; use Carp; use B qw(class main_root main_start main_cv svref_2object opnumber perlstring @@ -26,6 +26,7 @@ use B qw(class main_root main_start main_cv svref_2object opnumber perlstring OPpMULTICONCAT_APPEND OPpMULTICONCAT_STRINGIFY OPpMULTICONCAT_FAKE OPpTRUEBOOL OPpINDEX_BOOLNEG OPpDEFER_FINALLY OPpARG_IF_UNDEF OPpARG_IF_FALSE + OPpPARAM_IF_UNDEF OPpPARAM_IF_FALSE SVf_IOK SVf_NOK SVf_ROK SVf_POK SVf_FAKE SVs_RMG SVs_SMG SVs_PADTMP CVf_NOWARN_AMBIGUOUS CVf_LVALUE CVf_IsMETHOD @@ -1180,6 +1181,94 @@ sub pad_subs { } +# deparse_multiparam(): deparse, if possible, a sequence of ops into a +# subroutine signature. If possible, returns a string representing the +# signature syntax, minus the surrounding parentheses. + +sub deparse_multiparam { + my ($self, $topop, $cv) = @_; + + $topop = $topop->first; + return unless $$topop and $topop->name eq 'lineseq'; + + # last op should be nextstate + my $last = $topop->last; + return unless $$last + and ( _op_is_or_was($last, OP_NEXTSTATE) + or _op_is_or_was($last, OP_DBSTATE)); + + # first OP_NEXTSTATE + + my $o = $topop->first; + return unless $$o; + return if $o->label; + + # OP_MULTIPARAM + + $o = $o->sibling; + return unless $$o and $o->name eq 'multiparam'; + + my ($min_args, $max_args, $slurpy, @rest) = $o->aux_list($cv); + my $nparams = $max_args; + my @param_padix = splice @rest, 0, $nparams, (); + my ($slurpy_padix) = @rest; + + my @sig; + my %parami_for_padix; + + # Initial scalars + foreach my $parami ( 0 .. $max_args-1 ) { + my $padix = $param_padix[$parami]; + $sig[$parami] = $self->padname($padix) || '$'; + $parami_for_padix{$padix} = $parami; + } + + $o = $o->sibling; + for (; $o and !null $o; $o = $o->sibling) { + # Look for OP_NULL[OP_PARAMTEST[OP_PARAMSTORE]] + my $ofirst; + if ($o->name eq 'null' and $o->flags & OPf_KIDS and + ($ofirst = $o->first)->name eq 'paramtest' and + $ofirst->first->name eq 'paramstore') { + # A defaulting expression + + my $parami = $parami_for_padix{$ofirst->targ}; + + my $assign = "="; + $assign = "//=" if $ofirst->private == OPpPARAM_IF_UNDEF; + $assign = "||=" if $ofirst->private == OPpPARAM_IF_FALSE; + + length $sig[$parami] > 1 ? + ( $sig[$parami] .= ' ' ) : + ( $sig[$parami] = '$' ); # intentionally no trailing space + + my $defop = $ofirst->first->first; + if ($defop->name eq "stub") { + $sig[$parami] .= "$assign"; + } + else { + my $def = $self->deparse($defop, 7); + $def = "($def)" if $defop->flags & OPf_PARENS; + + $sig[$parami] .= "$assign $def"; + } + } + } + + if ($cv->CvFLAGS & CVf_IsMETHOD) { + # Remove the implied `$self` argument + warn "Expected first signature argument to be named \$self" + unless @sig and $sig[0] eq '$self'; + shift @sig; + } + + if ($slurpy) { + push @sig, $slurpy_padix ? $self->padname($slurpy_padix) : $slurpy; + } + + return join(", ", @sig); +} + # deparse_argops(): deparse, if possible, a sequence of argcheck + argelem # ops into a subroutine signature. If successful, return the first op # following the signature ops plus the signature string; else return the @@ -1377,7 +1466,8 @@ Carp::confess("SPECIAL in deparse_sub") if $cv->isa("B::SPECIAL"); and $firstop->name eq 'null' and $firstop->targ == OP_ARGCHECK ) { - my ($mysig) = $self->deparse_argops($firstop, $cv); + my ($mysig) = $self->deparse_multiparam($firstop, $cv) // + $self->deparse_argops($firstop, $cv); if (defined $mysig) { $sig = $mysig; $firstop = $is_list ? $firstop->sibling : undef; diff --git a/lib/B/Op_private.pm b/lib/B/Op_private.pm index d8ef55c303e6..002c2cc26343 100644 --- a/lib/B/Op_private.pm +++ b/lib/B/Op_private.pm @@ -482,6 +482,7 @@ $bits{method_super}{0} = $bf[0]; @{$bits{msgsnd}}{3,2,1,0} = ($bf[5], $bf[5], $bf[5], $bf[5]); @{$bits{multiconcat}}{6,5,3,0} = ('OPpMULTICONCAT_APPEND', 'OPpMULTICONCAT_FAKE', 'OPpMULTICONCAT_STRINGIFY', $bf[0]); @{$bits{multideref}}{5,4,0} = ('OPpMULTIDEREF_DELETE', 'OPpMULTIDEREF_EXISTS', $bf[0]); +$bits{multiparam}{0} = $bf[0]; @{$bits{multiply}}{1,0} = ($bf[1], $bf[1]); @{$bits{ncmp}}{1,0} = ($bf[1], $bf[1]); @{$bits{ne}}{1,0} = ($bf[1], $bf[1]); @@ -500,6 +501,8 @@ $bits{padhv}{0} = 'OPpPADHV_ISKEYS'; @{$bits{padrange}}{6,5,4,3,2,1,0} = ($bf[6], $bf[6], $bf[6], $bf[6], $bf[6], $bf[6], $bf[6]); @{$bits{padsv}}{5,4} = ($bf[9], $bf[9]); $bits{padsv_store}{0} = $bf[0]; +$bits{paramstore}{0} = $bf[0]; +@{$bits{paramtest}}{7,6,0} = ('OPpPARAM_IF_UNDEF', 'OPpPARAM_IF_FALSE', $bf[0]); @{$bits{pipe_op}}{3,2,1,0} = ($bf[5], $bf[5], $bf[5], $bf[5]); $bits{pop}{0} = $bf[0]; $bits{pos}{0} = $bf[0]; @@ -726,6 +729,8 @@ our %defines = ( OPpPADRANGE_COUNTMASK => 127, OPpPADRANGE_COUNTSHIFT => 7, OPpPAD_STATE => 64, + OPpPARAM_IF_FALSE => 64, + OPpPARAM_IF_UNDEF => 128, OPpPV_IS_UTF8 => 128, OPpREFCOUNTED => 64, OPpREPEAT_DOLIST => 64, @@ -848,6 +853,8 @@ our %labels = ( OPpOUR_INTRO => 'OURINTR', OPpPADHV_ISKEYS => 'KEYS', OPpPAD_STATE => 'STATE', + OPpPARAM_IF_FALSE => 'IF_FALSE', + OPpPARAM_IF_UNDEF => 'IF_UNDEF', OPpPV_IS_UTF8 => 'UTF', OPpREFCOUNTED => 'REFC', OPpREPEAT_DOLIST => 'DOLIST', @@ -925,6 +932,7 @@ our %ops_using = ( OPpOUR_INTRO => [qw(enteriter gvsv rv2av rv2hv rv2sv split)], OPpPADHV_ISKEYS => [qw(padhv)], OPpPAD_STATE => [qw(emptyavhv lvavref lvref padav padhv padsv padsv_store pushmark refassign undef)], + OPpPARAM_IF_FALSE => [qw(paramtest)], OPpPV_IS_UTF8 => [qw(dump goto last next redo)], OPpREFCOUNTED => [qw(leave leaveeval leavesub leavesublv leavewrite)], OPpREPEAT_DOLIST => [qw(repeat)], @@ -971,6 +979,7 @@ $ops_using{OPpMULTIDEREF_EXISTS} = $ops_using{OPpMULTIDEREF_DELETE}; $ops_using{OPpOPEN_IN_RAW} = $ops_using{OPpOPEN_IN_CRLF}; $ops_using{OPpOPEN_OUT_CRLF} = $ops_using{OPpOPEN_IN_CRLF}; $ops_using{OPpOPEN_OUT_RAW} = $ops_using{OPpOPEN_IN_CRLF}; +$ops_using{OPpPARAM_IF_UNDEF} = $ops_using{OPpPARAM_IF_FALSE}; $ops_using{OPpSELF_IN_PAD} = $ops_using{OPpINITFIELDS}; $ops_using{OPpSLICE} = $ops_using{OPpKVSLICE}; $ops_using{OPpSORT_INPLACE} = $ops_using{OPpSORT_DESCEND}; diff --git a/op.c b/op.c index 17c2d46f66d2..06f2339139f1 100644 --- a/op.c +++ b/op.c @@ -1226,6 +1226,10 @@ Perl_op_clear(pTHX_ OP *o) PerlMemShared_free(cUNOP_AUXo->op_aux); break; + case OP_MULTIPARAM: + PerlMemShared_free(cUNOP_AUXo->op_aux); + break; + case OP_MULTICONCAT: { UNOP_AUX_item *aux = cUNOP_AUXo->op_aux; @@ -16557,6 +16561,14 @@ Perl_rcpv_copy(pTHX_ char *pv) { /* Subroutine signature parsing */ +struct yy_parser_signature_param { + UV argix; /* positional index of the param */ + PADOFFSET padix; /* pad index of the var holding the param */ + OP *defcop; + OPCODE defmode; + OP *defexpr; +}; + struct yy_parser_signature { /* A note on terminology. We call each variable that appears in a * signature a "parameter", and each scalar value the caller passes in at @@ -16569,7 +16581,12 @@ struct yy_parser_signature { UV next_argix; /* the argument index of the next parameter we add */ UV opt_params; /* number of optional scalar parameters */ char slurpy; /* the sigil of the slurpy var (or null) */ - OP *elemops; /* NULL, or an OP_LINESEQ of individual element and fence ops */ + + UV nparams; /* number of elements of the following array that are in use */ + UV params_size; /* number of elements we could store in the following array */ + struct yy_parser_signature_param *params; + + OP *fenceops; /* NULL, or an OP_LINESEQ containing the ops */ }; static void @@ -16577,12 +16594,48 @@ destroy_subsignature_context(pTHX_ void *p) { yy_parser_signature *signature = (yy_parser_signature *)p; - if(signature->elemops) - op_free(signature->elemops); + if(signature->params) { + for(UV parami = 0; parami < signature->nparams; parami++) { + struct yy_parser_signature_param *param = signature->params + parami; + + if(param->defcop) + op_free(param->defcop); + if(param->defexpr) + op_free(param->defexpr); + } + Safefree(signature->params); + } + + if(signature->fenceops) + op_free(signature->fenceops); Safefree(signature); } +#define subsignature_push_param() S_subsignature_push_param(aTHX) +static struct yy_parser_signature_param * +S_subsignature_push_param(pTHX) +{ + assert(PL_parser); + yy_parser_signature *signature = PL_parser->signature; + assert(signature); + + if(signature->nparams >= signature->params_size) { + signature->params_size *= 2; + Renew(signature->params, signature->params_size, struct yy_parser_signature_param); + } + struct yy_parser_signature_param *param = signature->params + signature->nparams; + signature->nparams++; + + param->argix = 0; + param->padix = 0; + param->defcop = NULL; + param->defmode = 0; + param->defexpr = NULL; + + return param; +} + /* Called from perly.y on encountering the '(' of a subroutine signature. * Does not return anything useful, but sets up the memory structure in * `PL_parser->signature` that the following functions make use of. @@ -16595,14 +16648,14 @@ Perl_subsignature_start(pTHX) assert(PL_parser); yy_parser_signature *signature; - Newx(signature, 1, yy_parser_signature); + Newxz(signature, 1, yy_parser_signature); SAVEDESTRUCTOR_X(&destroy_subsignature_context, signature); - signature->next_argix = 0; - signature->opt_params = 0; - signature->slurpy = 0; - - signature->elemops = NULL; + /* Most signatured subs probably won't have more than 4 params. If they do + * we'll just realloc anyway + */ + signature->params_size = 4; + Newxz(signature->params, signature->params_size, struct yy_parser_signature_param); SAVEVPTR(PL_parser->signature); PL_parser->signature = signature; @@ -16634,8 +16687,10 @@ Perl_subsignature_append_fence_op(pTHX_ OP *o) yy_parser_signature *signature = PL_parser->signature; assert(signature); - signature->elemops = op_append_elem(OP_LINESEQ, signature->elemops, - o); + if(signature->fenceops) + op_append_elem(OP_LINESEQ, signature->fenceops, o); + else + signature->fenceops = newLISTOP(OP_LINESEQ, 0, o, NULL); } /* Appends another positional scalar parameter to the accumulated set of @@ -16654,21 +16709,37 @@ Perl_subsignature_append_positional(pTHX_ PADOFFSET padix, OPCODE defmode, OP *d yy_parser_signature *signature = PL_parser->signature; assert(signature); - if(signature->slurpy) + if(signature->slurpy) { yyerror("Slurpy parameter not last"); + return; + } + + if(!defexpr && signature->opt_params) { + yyerror("Mandatory parameter follows optional parameter"); + return; + } UV argix = signature->next_argix; signature->next_argix++; - OP *varop = NULL; + if(!padix && !defexpr) + /* This param has no var and no defaulting expression. There's + * nothing else for us to do here. + */ + return; + + struct yy_parser_signature_param *param = subsignature_push_param(); + param->argix = argix; + if(padix) { assert(PadnamePV(PadnamelistARRAY(PL_comppad_name)[padix])[0] == '$'); - varop = newUNOP_AUX(OP_ARGELEM, 0, NULL, NULL); - varop->op_private |= OPpARGELEM_SV; - varop->op_targ = padix; - cUNOP_AUXx(varop)->op_aux = INT2PTR(UNOP_AUX_item *, argix); + param->padix = padix; + + intro_my(); /* introduce the new pad variable now */ } + else + param->padix = 0; if(defexpr) { signature->opt_params++; @@ -16678,46 +16749,30 @@ Perl_subsignature_append_positional(pTHX_ PADOFFSET padix, OPCODE defmode, OP *d /* caller passed in newOP(OP_NULL, 0), so we should not leak it */ op_free(defexpr); + defexpr = newOP(OP_STUB, OPf_WANT_SCALAR); + /* handle '$=' special case */ - if(varop) + if(padix) yyerror("Optional parameter lacks default expression"); } - else { - I32 flags = 0; - if(defmode == OP_DORASSIGN) - flags |= OPpARG_IF_UNDEF << 8; - if(defmode == OP_ORASSIGN) - flags |= OPpARG_IF_FALSE << 8; - - /* a normal '=default' expression */ - OP *defop = newARGDEFELEMOP(flags, defexpr, argix); - - if(varop) { - varop->op_flags |= OPf_STACKED; - (void)op_sibling_splice(varop, NULL, 0, defop); - scalar(defop); - } - else - varop = newUNOP(OP_NULL, 0, defop); - LINKLIST(varop); - /* NB: normally the first child of a logop is executed before the - * logop, and it pushes a boolean result ready for the logop. For - * ARGDEFELEM, the op itself does the boolean calculation, so set - * the first op to it instead. + /* generate the COP here so the line number is correct */ + param->defcop = newSTATEOP(0, NULL, NULL); + + param->defmode = defmode; + param->defexpr = defexpr; + scalar(defexpr); + + if(!padix) { + /* A defaulting expression with anonymous var still needs to be + * conditional. We'll just have to allocate a pad temporary to + * store the value in anyway, so OP_PARAMTEST can check it. */ - varop->op_next = defop; - defexpr->op_next = varop; + param->padix = pad_add_name_pvn("$", 1, padadd_NO_DUP_CHECK, NULL, NULL); } } - else - if(signature->opt_params) - yyerror("Mandatory parameter follows optional parameter"); - if(varop) { - signature->elemops = op_append_list(OP_LINESEQ, signature->elemops, - newSTATEOP(0, NULL, varop)); - } + assert(param->padix || param->defexpr); } /* Appends a final slurpy parameter to the accumulated set of subroutine @@ -16743,20 +16798,16 @@ Perl_subsignature_append_slurpy(pTHX_ I32 sigil, PADOFFSET padix) signature->slurpy = (char)sigil; - if(padix) { - assert(PadnamePV(PadnamelistARRAY(PL_comppad_name)[padix])[0] == sigil); + if(!padix) + return; - OP *varop = newUNOP_AUX(OP_ARGELEM, 0, NULL, NULL); - if(sigil == '@') - varop->op_private |= OPpARGELEM_AV; - if(sigil == '%') - varop->op_private |= OPpARGELEM_HV; - varop->op_targ = padix; - cUNOP_AUXx(varop)->op_aux = INT2PTR(UNOP_AUX_item *, argix); + struct yy_parser_signature_param *param = subsignature_push_param(); - signature->elemops = op_append_list(OP_LINESEQ, signature->elemops, - newSTATEOP(0, NULL, varop)); - } + param->argix = argix; + + assert(PadnamePV(PadnamelistARRAY(PL_comppad_name)[padix])[0] == sigil); + + param->padix = padix; } /* Called from perly.y on encountering the closing `)` of a subroutine @@ -16773,26 +16824,115 @@ Perl_subsignature_finish(pTHX) yy_parser_signature *signature = PL_parser->signature; assert(signature); - OP *sigops = signature->elemops; - signature->elemops = NULL; + OP *sigops = NULL; - struct op_argcheck_aux *aux = (struct op_argcheck_aux *) - PerlMemShared_malloc( sizeof(struct op_argcheck_aux)); + /* a nextstate right at the beginning */ + sigops = op_append_elem(OP_LINESEQ, sigops, + newSTATEOP(0, NULL, NULL)); - aux->params = signature->next_argix; - aux->opt_params = signature->opt_params; - aux->slurpy = signature->slurpy; + UV end_argix = signature->next_argix; - OP *check = newUNOP_AUX(OP_ARGCHECK, 0, NULL, (UNOP_AUX_item *)aux); + struct op_multiparam_aux *aux = (struct op_multiparam_aux *)PerlMemShared_malloc( + sizeof(struct op_multiparam_aux) + (end_argix * sizeof(PADOFFSET))); + aux->param_padix = (PADOFFSET *)((char *)aux + sizeof(struct op_multiparam_aux)); - sigops = op_prepend_elem(OP_LINESEQ, - check, - sigops); + aux->min_args = end_argix - signature->opt_params; + aux->n_positional = end_argix; + aux->slurpy = signature->slurpy; + aux->slurpy_padix = 0; - /* a nextstate right at the beginning */ - sigops = op_prepend_elem(OP_LINESEQ, - newSTATEOP(0, NULL, NULL), - sigops); + OP *multiparam = newUNOP_AUX(OP_MULTIPARAM, 0, NULL, (UNOP_AUX_item *)aux); + + sigops = op_append_elem(OP_LINESEQ, sigops, + multiparam); + + if(signature->fenceops) { + LISTOP *fenceops = cLISTOPx(signature->fenceops); + + /* Move the entire chain of kid ops in one go */ + OpMORESIB_set(cLISTOPx(sigops)->op_last, fenceops->op_first); + cLISTOPx(sigops)->op_last = fenceops->op_last; + OpLASTSIB_set(cLISTOPx(sigops)->op_last, sigops); + + fenceops->op_first = fenceops->op_last = NULL; + fenceops->op_flags &= ~OPf_KIDS; + op_free((OP *)fenceops); + signature->fenceops = NULL; + } + + struct yy_parser_signature_param *params = signature->params; + UV max_argix = 0; + + for(UV parami = 0; parami < signature->nparams; parami++) { + struct yy_parser_signature_param *param = params + parami; + + UV argix = param->argix; + PADOFFSET padix = param->padix; + + while(max_argix < argix) { + aux->param_padix[max_argix] = 0; + max_argix++; + } + + if(argix < aux->min_args) { + /* This is a mandatory param */ + aux->param_padix[argix] = padix; + } + else if(argix < aux->n_positional) { + /* This is an optional param */ + assert(padix); + + aux->param_padix[argix] = padix; + + OP *defexpr = param->defexpr; + assert(defexpr); + OP *defexpr_start = LINKLIST(defexpr); + + /* Need to build OP_PARAMTEST[ other: OP_PARAMSTORE[ default-expr ] ] */ + OP *paramstore; + OP *paramtest = (OP *)alloc_LOGOP(OP_PARAMTEST, + paramstore = newUNOP(OP_PARAMSTORE, 0, defexpr), + defexpr_start); + + paramtest->op_flags |= OPf_WANT_VOID; + paramtest->op_targ = paramstore->op_targ = padix; + + if(param->defmode == OP_DORASSIGN) + paramtest->op_private |= OPpPARAM_IF_UNDEF; + if(param->defmode == OP_ORASSIGN) + paramtest->op_private |= OPpPARAM_IF_FALSE; + + defexpr->op_next = paramstore; + + /* Wrap both in an outer OP_NULL so we can point both ->op_next + * pointers within into it + */ + OP *o = newUNOP(OP_NULL, 0, paramtest); + + paramstore->op_next = o; + paramtest->op_next = o; + o->op_next = paramtest; /* set start of o */ + + sigops = op_append_elem(OP_LINESEQ, sigops, + param->defcop); + param->defcop = NULL; + + sigops = op_append_elem(OP_LINESEQ, sigops, + o); + param->defexpr = NULL; + } + else { + /* This is the final slurpy */ + aux->slurpy_padix = padix; + } + + max_argix = argix + 1; + } + + while(max_argix < end_argix) { + aux->param_padix[max_argix] = 0; + max_argix++; + } /* a nextstate at the end handles context correctly for an empty sub body */ sigops = op_append_elem(OP_LINESEQ, sigops, diff --git a/op.h b/op.h index 8fdde6a11f3f..dd542e0a922c 100644 --- a/op.h +++ b/op.h @@ -1189,6 +1189,16 @@ struct op_argcheck_aux { char slurpy; /* presence of slurpy: may be '\0', '@' or '%' */ }; +/* for OP_MULTIPARAM */ + +struct op_multiparam_aux { + UV min_args; /* = the number of mandatory scalar parameters */ + UV n_positional; /* = the number of mandatory + optional scalar parameters, not counting a final slurpy */ + char slurpy; + PADOFFSET *param_padix; /* points at storage allocated along with the struct itself, immediately following */ + PADOFFSET slurpy_padix; +}; + #define MI_INIT_WORKAROUND_PACK "Module::Install::DSL" diff --git a/opcode.h b/opcode.h index 670fbf9dd407..6ea99b620dfa 100644 --- a/opcode.h +++ b/opcode.h @@ -574,6 +574,9 @@ EXTCONST char* const PL_op_name[] INIT({ "methstart", "initfield", "classname", + "multiparam", + "paramtest", + "paramstore", "freed", }); @@ -1004,6 +1007,9 @@ EXTCONST char* const PL_op_desc[] INIT({ "method start", "initialise field", "class name", + "signature processing", + "signature argument value test", + "signature parameter default expression", "freed op", }); @@ -1439,6 +1445,9 @@ INIT({ Perl_pp_methstart, Perl_pp_initfield, Perl_pp_classname, + Perl_pp_multiparam, + Perl_pp_paramtest, + Perl_pp_paramstore, }); EXT Perl_check_t PL_check[] /* or perlvars.h */ @@ -1869,6 +1878,9 @@ INIT({ Perl_ck_null, /* methstart */ Perl_ck_null, /* initfield */ Perl_ck_classname, /* classname */ + Perl_ck_null, /* multiparam */ + Perl_ck_null, /* paramtest */ + Perl_ck_null, /* paramstore */ }); EXTCONST U32 PL_opargs[] INIT({ @@ -2298,6 +2310,9 @@ EXTCONST U32 PL_opargs[] INIT({ 0x00000f00, /* methstart */ 0x00000f00, /* initfield */ 0x00000008, /* classname */ + 0x00000f00, /* multiparam */ + 0x00000300, /* paramtest */ + 0x00000100, /* paramstore */ }); END_EXTERN_C @@ -2413,6 +2428,7 @@ END_EXTERN_C #define OPpOPEN_OUT_RAW 0x40 #define OPpOUR_INTRO 0x40 #define OPpPAD_STATE 0x40 +#define OPpPARAM_IF_FALSE 0x40 #define OPpREFCOUNTED 0x40 #define OPpREPEAT_DOLIST 0x40 #define OPpSELF_IN_PAD 0x40 @@ -2431,6 +2447,7 @@ END_EXTERN_C #define OPpLVAL_INTRO 0x80 #define OPpOFFBYONE 0x80 #define OPpOPEN_OUT_CRLF 0x80 +#define OPpPARAM_IF_UNDEF 0x80 #define OPpPV_IS_UTF8 0x80 #define OPpTRANS_DELETE 0x80 #define OPpCONST_TOKEN_MASK 0xc0 @@ -3031,6 +3048,9 @@ EXTCONST I16 PL_op_private_bitdef_ix[] = { 267, /* methstart */ 270, /* initfield */ -1, /* classname */ + 0, /* multiparam */ + 194, /* paramtest */ + 0, /* paramstore */ }; @@ -3049,7 +3069,7 @@ EXTCONST I16 PL_op_private_bitdef_ix[] = { */ EXTCONST U16 PL_op_private_bitdefs[] = { - 0x0003, /* scalar, prototype, refgen, srefgen, readline, regcmaybe, regcreset, regcomp, substcont, chop, schop, defined, study, preinc, i_preinc, predec, i_predec, postinc, i_postinc, postdec, i_postdec, not, ucfirst, lcfirst, uc, lc, quotemeta, aeach, avalues, each, pop, shift, grepstart, anywhile, mapstart, mapwhile, range, and, or, dor, andassign, orassign, dorassign, argcheck, entergiven, leavegiven, enterwhen, leavewhen, untie, tied, dbmclose, getsockname, getpeername, lstat, stat, readlink, readdir, telldir, rewinddir, closedir, localtime, alarm, require, dofile, entertry, ghbyname, gnbyname, gpbyname, shostent, snetent, sprotoent, sservent, gpwnam, gpwuid, ggrnam, ggrgid, lock, once, fc, anonconst, cmpchain_and, cmpchain_dup, entertrycatch, catch, is_bool, is_weak, weaken, unweaken, is_tainted */ + 0x0003, /* scalar, prototype, refgen, srefgen, readline, regcmaybe, regcreset, regcomp, substcont, chop, schop, defined, study, preinc, i_preinc, predec, i_predec, postinc, i_postinc, postdec, i_postdec, not, ucfirst, lcfirst, uc, lc, quotemeta, aeach, avalues, each, pop, shift, grepstart, anywhile, mapstart, mapwhile, range, and, or, dor, andassign, orassign, dorassign, argcheck, entergiven, leavegiven, enterwhen, leavewhen, untie, tied, dbmclose, getsockname, getpeername, lstat, stat, readlink, readdir, telldir, rewinddir, closedir, localtime, alarm, require, dofile, entertry, ghbyname, gnbyname, gpbyname, shostent, snetent, sprotoent, sservent, gpwnam, gpwuid, ggrnam, ggrgid, lock, once, fc, anonconst, cmpchain_and, cmpchain_dup, entertrycatch, catch, is_bool, is_weak, weaken, unweaken, is_tainted, multiparam, paramstore */ 0x3cfc, 0x54f9, /* pushmark */ 0x00bd, /* wantarray, runcv */ 0x077e, 0x0554, 0x1b70, 0x55ac, 0x5148, 0x4225, /* const */ @@ -3106,7 +3126,7 @@ EXTCONST U16 PL_op_private_bitdefs[] = { 0x3cfc, 0x1198, 0x04f6, 0x014c, 0x58a8, 0x55a4, 0x2cc1, /* entersub */ 0x4b98, 0x0003, /* leavesub, leavesublv, leavewrite, leaveeval */ 0x03ca, 0x0003, /* argelem */ - 0x2adc, 0x29b8, 0x0003, /* argdefelem */ + 0x2adc, 0x29b8, 0x0003, /* argdefelem, paramtest */ 0x00bc, 0x02af, /* caller */ 0x27f5, /* nextstate, dbstate */ 0x3b9c, 0x4b99, /* leave */ @@ -3566,6 +3586,9 @@ EXTCONST U8 PL_op_private_valid[] = { /* METHSTART */ (OPpARG1_MASK|OPpSELF_IN_PAD|OPpINITFIELDS), /* INITFIELD */ (OPpARG1_MASK|OPpINITFIELD_AV|OPpINITFIELD_HV), /* CLASSNAME */ (0), + /* MULTIPARAM */ (OPpARG1_MASK), + /* PARAMTEST */ (OPpARG1_MASK|OPpPARAM_IF_FALSE|OPpPARAM_IF_UNDEF), + /* PARAMSTORE */ (OPpARG1_MASK), }; diff --git a/opnames.h b/opnames.h index 53040e6ceb7a..f234c328dde7 100644 --- a/opnames.h +++ b/opnames.h @@ -440,6 +440,9 @@ typedef enum opcode { OP_METHSTART = 423, OP_INITFIELD = 424, OP_CLASSNAME = 425, + OP_MULTIPARAM = 426, + OP_PARAMTEST = 427, + OP_PARAMSTORE = 428, OP_max } opcode; @@ -450,7 +453,7 @@ An enum of all the legal Perl opcodes, defined in F =cut */ -#define MAXO 426 +#define MAXO 429 #define OP_FREED MAXO /* the OP_IS_* macros are optimized to a simple range check because diff --git a/peep.c b/peep.c index 99c7cb6bd9f7..b7df9e6b7360 100644 --- a/peep.c +++ b/peep.c @@ -3634,6 +3634,7 @@ Perl_rpeep(pTHX_ OP *o) case OP_RANGE: case OP_ONCE: case OP_ARGDEFELEM: + case OP_PARAMTEST: while (cLOGOP->op_other->op_type == OP_NULL) cLOGOP->op_other = cLOGOP->op_other->op_next; DEFER(cLOGOP->op_other); diff --git a/pp.c b/pp.c index 7110a1dbf06f..93d90c047538 100644 --- a/pp.c +++ b/pp.c @@ -7885,6 +7885,144 @@ PP(pp_argcheck) return NORMAL; } +PP(pp_multiparam) +{ + struct op_multiparam_aux *aux = (struct op_multiparam_aux *)cUNOP_AUX->op_aux; + UV nparams = aux->n_positional; + char slurpy = aux->slurpy; + PADOFFSET *param_padix = aux->param_padix; + AV *defav = GvAV(PL_defgv); /* @_ */ + + assert(!SvMAGICAL(defav)); + UV argc = (UV)(AvFILLp(defav) + 1); + + S_check_argc(aTHX_ argc, nparams, nparams - aux->min_args, slurpy); + + UV parami; + for(parami = 0; parami < nparams; parami++) { + PADOFFSET padix = param_padix[parami]; + if(!padix) { + if(argc) + argc--; + continue; + } + + SV **padentry = &PAD_SVl(padix); + save_clearsv(padentry); + + if(!argc) { + /* Ran out of arg values for this param. It must be a missing + * optional. Remark that it's missing so a subsequent OP_PARAMTEST + * knows */ + SvPADSTALE_on(*padentry); + continue; + } + + SV **valp = av_fetch(defav, parami, FALSE); + SV *val = valp ? *valp : &PL_sv_undef; + argc--; + + assert(TAINTING_get || !TAINT_get); + if (UNLIKELY(TAINT_get) && !SvTAINTED(val)) + TAINT_NOT; + + SvSetMagicSV(*padentry, val); + } + + if(!slurpy || !aux->slurpy_padix) + return PL_op->op_next; + + /* Now we know we have a slurpy */ + SV **padentry = &PAD_SVl(aux->slurpy_padix); + save_clearsv(padentry); + + if(slurpy == '@') { + AV *av = (AV *)*padentry; + assert(SvTYPE(av) == SVt_PVAV); + + if(av_count(av)) { + /* see "target should be empty" comments in pp_argelem above */ + av_refresh_elements_range(defav, parami, parami + argc); + av_clear(av); + } + + av_extend(av, argc); + + IV avidx = 0; + for(; argc; parami++, argc--) { + SV **valp = av_fetch(defav, parami, FALSE); + SV *val = valp ? *valp : &PL_sv_undef; + + assert(TAINTING_get || !TAINT_get); + if (UNLIKELY(TAINT_get) && !SvTAINTED(val)) + TAINT_NOT; + + av_store(av, avidx++, newSVsv(val)); + } + } + else if(slurpy == '%') { + HV *hv = (HV *)*padentry; + assert(SvTYPE(hv) == SVt_PVHV); + + if(SvRMAGICAL(hv) || HvUSEDKEYS(hv) > 0) { + /* see "target should be empty" comments in pp_argelem above */ + av_refresh_elements_range(defav, parami, parami + argc); + hv_clear(hv); + } + + assert((argc % 2) == 0); + + while(argc) { + SV **svp; + + svp = av_fetch(defav, parami, FALSE); parami++; + SV *key = svp ? *svp : &PL_sv_undef; + svp = av_fetch(defav, parami, FALSE); parami++; + SV *val = svp ? *svp : &PL_sv_undef; + argc -= 2; + + if (UNLIKELY(SvGMAGICAL(key))) + key = sv_mortalcopy(key); + + hv_store_ent(hv, key, newSVsv(val), 0); + if (UNLIKELY(TAINT_get) && !SvTAINTED(val)) + TAINT_NOT; + } + } + + return PL_op->op_next; +} + +PP(pp_paramtest) +{ + dTARGET; + U8 priv = PL_op->op_private; + + bool ok = TARG && !SvPADSTALE(TARG); + + if (ok && (priv & OPpPARAM_IF_UNDEF) && !SvOK(TARG)) + ok = false; + if (ok && (priv & OPpPARAM_IF_FALSE) && !SvTRUE(TARG)) + ok = false; + + if(!ok) + return cLOGOP->op_other; + + return PL_op->op_next; +} + +PP_wrapped(pp_paramstore, 1, 0) +{ + dSP; + dTARGET; + SV *value = POPs; + + SvPADSTALE_off(TARG); + SvSetMagicSV(TARG, value); + + RETURN; +} + PP_wrapped(pp_isa, 2, 0) { dSP; diff --git a/pp_proto.h b/pp_proto.h index 4921c2e636f1..8c30976c5208 100644 --- a/pp_proto.h +++ b/pp_proto.h @@ -183,6 +183,7 @@ PERL_CALLCONV PP(pp_mkdir) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_modulo) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_multiconcat) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_multideref) __attribute__visibility__("hidden"); +PERL_CALLCONV PP(pp_multiparam) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_multiply) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_nbit_and) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_nbit_or) __attribute__visibility__("hidden"); @@ -207,6 +208,8 @@ PERL_CALLCONV PP(pp_padhv) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_padrange) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_padsv) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_padsv_store) __attribute__visibility__("hidden"); +PERL_CALLCONV PP(pp_paramstore) __attribute__visibility__("hidden"); +PERL_CALLCONV PP(pp_paramtest) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_pipe_op) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_poptry) __attribute__visibility__("hidden"); PERL_CALLCONV PP(pp_pos) __attribute__visibility__("hidden"); diff --git a/regen/op_private b/regen/op_private index b8cff44dbaa5..704fb1d79198 100644 --- a/regen/op_private +++ b/regen/op_private @@ -925,6 +925,12 @@ addbits('argdefelem', 6 => qw(OPpARG_IF_FALSE IF_FALSE), ); +# These paramtest bits must be in the same place as argdefelem +addbits('paramtest', + 7 => qw(OPpPARAM_IF_UNDEF IF_UNDEF), + 6 => qw(OPpPARAM_IF_FALSE IF_FALSE), +); + addbits('helemexistsor', 7 => qw(OPpHELEMEXISTSOR_DELETE DELETE), ); diff --git a/regen/opcodes b/regen/opcodes index f7267a4e3a95..a5c9e051fb21 100644 --- a/regen/opcodes +++ b/regen/opcodes @@ -611,3 +611,7 @@ methstart method start ck_null + initfield initialise field ck_null + classname class name ck_classname 0t + +multiparam signature processing ck_null + +paramtest signature argument value test ck_null | +paramstore signature parameter default expression ck_null 1 diff --git a/t/op/signatures.t b/t/op/signatures.t index 41b17241c60a..6edb4066d4d2 100644 --- a/t/op/signatures.t +++ b/t/op/signatures.t @@ -1406,25 +1406,25 @@ is scalar(t145()), undef; sub t152x { @b = qw(a b c); 1 } $a . '-' . join(':', @b); } - is t152(), "1-", "t152: closure can make new lexical array non-empty"; + is t152(), "1-a:b:c", "t152: closure can make new lexical array non-empty"; sub t153 ($a = t153x(), %b) { sub t153x { %b = qw(a 10 b 20); 1 } $a . '-' . join(':', sort %b); } - is t153(), "1-", "t153: closure can make new lexical hash non-empty"; + is t153(), "1-10:20:a:b", "t153: closure can make new lexical hash non-empty"; sub t154 ($a = t154x(), @b) { sub t154x { tie @b, 'Tie::StdArray'; @b = qw(a b c); 1 } $a . '-' . join(':', @b); } - is t154(), "1-", "t154: closure can make new lexical array tied"; + is t154(), "1-a:b:c", "t154: closure can make new lexical array tied"; sub t155 ($a = t155x(), %b) { sub t155x { tie %b, 'Tie::StdHash'; %b = qw(a 10 b 20); 1 } $a . '-' . join(':', sort %b); } - is t155(), "1-", "t155: closure can make new lexical hash tied"; + is t155(), "1-10:20:a:b", "t155: closure can make new lexical hash tied"; # see if we can handle the equivalent of @a = ($a[1], $a[0]) diff --git a/t/perf/opcount.t b/t/perf/opcount.t index dd16447bae1c..469d4fc92b26 100644 --- a/t/perf/opcount.t +++ b/t/perf/opcount.t @@ -1146,6 +1146,63 @@ test_opcount(0, "foreach 2 lexicals on imported indexed LIST", enteriter => 1, iter => 1, }); +{ + use feature qw( signatures ); + + test_opcount(0, "Zero-arg empty subroutine uses OP_MULTIPARAM", + sub () {}, + { + multiparam => 1, + argcheck => 0, + }); + + test_opcount(0, "Zero-arg subroutine uses OP_MULTIPARAM", + sub () { return; }, + { + multiparam => 1, + argcheck => 0, + }); + + test_opcount(0, "Two-arg subroutine uses OP_MULTIPARAM", + sub ($x, $y) { return; }, + { + multiparam => 1, + argcheck => 0, + argelem => 0, + }); + + test_opcount(0, "Two-arg one-optional subroutine uses OP_MULTIPARAM", + sub ($x, $y = "default") { return; }, + { + multiparam => 1, + argcheck => 0, + argelem => 0, + }); + + test_opcount(0, "Two-arg one-anon subroutine uses OP_MULTIPARAM", + sub ($, $y) { return; }, + { + multiparam => 1, + argcheck => 0, + argelem => 0, + }); + + test_opcount(0, "One-arg plus slurpy array subroutine uses OP_MULTIPARAM", + sub ($x, @rest) { return; }, + { + multiparam => 1, + argcheck => 0, + argelem => 0, + }); + + test_opcount(0, "One-arg plus slurpy hash subroutine uses OP_MULTIPARAM", + sub ($x, %rest) { return; }, + { + multiparam => 1, + argcheck => 0, + argelem => 0, + }); +} # substr with const zero offset and "" replacements test_opcount(0, "substr with const zero offset and '' repl (void)",