From edf6aa7d3b2ff60abcdb8170e755eea0593b3f9a Mon Sep 17 00:00:00 2001 From: Akim Demaille Date: Sat, 5 Dec 2020 08:54:39 +0100 Subject: [PATCH] tests: glr: prepare for more languages * tests/glr-regression.at: Wrap each test in an AT_TEST. Call it with glr.c. --- tests/glr-regression.at | 492 ++++++++++++++++++++++++++-------------- 1 file changed, 318 insertions(+), 174 deletions(-) diff --git a/tests/glr-regression.at b/tests/glr-regression.at index 8b58795a..7da4c30a 100644 --- a/tests/glr-regression.at +++ b/tests/glr-regression.at @@ -22,28 +22,28 @@ AT_BANNER([[GLR Regression Tests]]) ## Badly Collapsed GLR States. ## ## ---------------------------- ## -AT_SETUP([Badly Collapsed GLR States]) +m4_pushdef([AT_TEST], +[AT_SETUP([Badly Collapsed GLR States: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr1.y], [[/* Regression Test: Improper state compression */ /* Reported by Scott McPeak */ -%{ -#include -#include +%define api.value.type {int} + +%code { #include -#define YYSTYPE int static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1); ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ -%} - +} %define parse.assert %glr-parser %expect 1 +]$1[ /* -------- productions ------ */ %% @@ -80,9 +80,9 @@ main (int argc, const char* argv[]) ]AT_YYERROR_DEFINE[ -int -yylex (void) +]AT_YYLEX_PROTOTYPE[ { + ]AT_USE_LEX_ARGS[ return *input++; } ]]) @@ -98,25 +98,32 @@ E -> 'B' E -> E 'P' E E -> E 'P' E -]], []) +]]) AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + + ## -------------------------------------------------------------- ## ## Improper handling of embedded actions and $-N in GLR parsers. ## ## -------------------------------------------------------------- ## -AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers]) +m4_pushdef([AT_TEST], +[AT_SETUP([Improper handling of embedded actions and dollar(-N) in GLR parsers: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr2a.y], [[/* Regression Test: Improper handling of embedded actions and $-N */ /* Reported by S. Eken */ -%{ - #define YYSTYPE char * - +%define api.value.type {char *} +%code { #include #include #include @@ -124,39 +131,40 @@ AT_DATA_GRAMMAR([glr-regr2a.y], #include ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ -%} +} %define parse.assert %glr-parser %expect 2 +]$1[ %% command: 's' var 't' - { printf ("Variable: '%s'\n", $2); } + { printf ("Variable: '%s'\n", $][2); } 'v' 'x' 'q' - { free ($2); } + { free ($][2); } | 's' var_list 't' 'e' - { printf ("Varlist: '%s'\n", $2); free ($2); } + { printf ("Varlist: '%s'\n", $][2); free ($][2); } | 's' var 't' var_printer 'x' - { free ($2); } + { free ($][2); } ; var: 'V' - { $$ = $1; } + { $$ = $][1; } ; var_list: var - { $$ = $1; } + { $$ = $][1; } | var ',' var_list { - char *s = YY_CAST (char *, realloc ($1, strlen ($1) + 1 + strlen ($3) + 1)); + char *s = YY_CAST (char *, realloc ($][1, strlen ($][1) + 1 + strlen ($][3) + 1)); strcat (s, ","); - strcat (s, $3); - free ($3); + strcat (s, $][3); + free ($][3); $$ = s; } ; @@ -168,10 +176,10 @@ var_printer: 'v' ]AT_YYERROR_DEFINE[ FILE *input; -int -yylex (void) +]AT_YYLEX_PROTOTYPE[ { char buf[50]; + ]AT_USE_LEX_ARGS[ assert (!feof (stdin)); switch (fscanf (input, " %1[a-z,]", buf)) { @@ -233,24 +241,28 @@ AT_PARSER_CHECK([[glr-regr2a input3.txt]], 0, [[Variable: 'VARIABLE_3' ]]) - AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## --------------------------------------------- ## ## Improper merging of GLR delayed action sets. ## ## --------------------------------------------- ## -AT_SETUP([Improper merging of GLR delayed action sets]) +m4_pushdef([AT_TEST], +[AT_SETUP([Improper merging of GLR delayed action sets: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr3.y], [[/* Regression Test: Improper merging of GLR delayed action sets. */ /* Reported by M. Rosien */ -%{ -#include -#include +%code { #include #include @@ -260,19 +272,20 @@ static int MergeRule (int x0, int x1); #define RULE(x) (1 << (x)) -%} +} %define parse.assert %glr-parser %expect 1 %expect-rr 2 +]$1[ %token BAD_CHAR %token P1 P2 T1 T2 T3 T4 O1 O2 %% -S : P1 T4 O2 NT6 P2 { printf ("Result: %x\n", $4); } +S : P1 T4 O2 NT6 P2 { printf ("Result: %x\n", $][4); } ; NT1 : P1 T1 O1 T2 P2 { $$ = RULE(2); } %merge @@ -294,8 +307,8 @@ NT4 : NT3 { $$ = RULE(7); } %merge NT5 : NT4 { $$ = RULE(10); } %merge ; -NT6 : P1 NT1 O1 T3 P2 { $$ = RULE(11) | $2; } %merge - | NT5 { $$ = RULE(12) | $1; } %merge +NT6 : P1 NT1 O1 T3 P2 { $$ = RULE(11) | $][2; } %merge + | NT5 { $$ = RULE(12) | $][1; } %merge ; %% @@ -354,6 +367,11 @@ AT_PARSER_CHECK([[glr-regr3 input.txt]], AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) ## ---------------------------------------------------------------------- ## @@ -361,9 +379,10 @@ AT_CLEANUP ## . ## ## ---------------------------------------------------------------------- ## -AT_SETUP([Duplicate representation of merged trees]) +m4_pushdef([AT_TEST], +[AT_SETUP([Duplicate representation of merged trees: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr4.y], [[ %define parse.assert @@ -371,9 +390,9 @@ AT_DATA_GRAMMAR([glr-regr4.y], %type S A A1 A2 B %glr-parser %expect-rr 2 -%{ - #include - #include +]$1[ + +%code { #include static char *merge (YYSTYPE, YYSTYPE); static char *make_value (char const *, char const *); @@ -381,20 +400,20 @@ AT_DATA_GRAMMAR([glr-regr4.y], ]AT_YYLEX_DECLARE[ static char *ptrs[100]; static char **ptrs_next = ptrs; -%} +} %% -tree: S { printf ("%s\n", $1); } ; +tree: S { printf ("%s\n", $][1); } ; S: - A %merge { $$ = make_value ("S", $1); } - | B %merge { $$ = make_value ("S", $1); } + A %merge { $$ = make_value ("S", $][1); } + | B %merge { $$ = make_value ("S", $][1); } ; A: - A1 %merge { $$ = make_value ("A", $1); } - | A2 %merge { $$ = make_value ("A", $1); } + A1 %merge { $$ = make_value ("A", $][1); } + | A2 %merge { $$ = make_value ("A", $][1); } ; A1: 'a' { $$ = make_value ("A1", "'a'"); } ; @@ -443,6 +462,11 @@ AT_PARSER_CHECK([[glr-regr4]], 0, AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) ## ------------------------------------------------------------------------- ## @@ -450,23 +474,24 @@ AT_CLEANUP ## . ## ## ------------------------------------------------------------------------- ## -AT_SETUP([User destructor for unresolved GLR semantic value]) +m4_pushdef([AT_TEST], +[AT_SETUP([User destructor for unresolved GLR semantic value: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr5.y], [[ -%{ - #include - #include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ enum { MAGIC_VALUE = -1057808125 }; /* originally chosen at random */ -%} +} %define parse.assert %glr-parser %expect 0 %expect-rr 1 +]$1[ + %union { int value; } %type start @@ -499,6 +524,12 @@ AT_PARSER_CHECK([[glr-regr5]], 1, [], AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------------------------- ## @@ -506,21 +537,22 @@ AT_CLEANUP ## . ## ## ------------------------------------------------------------------------- ## -AT_SETUP([User destructor after an error during a split parse]) +m4_pushdef([AT_TEST], +[AT_SETUP([User destructor after an error during a split parse: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr6.y], [[ -%{ - #include - #include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ -%} +} %define parse.assert %glr-parser %expect-rr 1 +]$1[ + %union { int value; } %type 'a' @@ -548,6 +580,12 @@ AT_PARSER_CHECK([[glr-regr6]], 1, AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------------------------- ## @@ -555,27 +593,31 @@ AT_CLEANUP ## . ## ## ------------------------------------------------------------------------- ## -AT_SETUP([Duplicated user destructor for lookahead]) +m4_pushdef([AT_TEST], +[AT_SETUP([Duplicated user destructor for lookahead: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr7.y], [[ -%{ - #include - #include - ]AT_YYERROR_DECLARE[ - ]AT_YYLEX_DECLARE[ - #define YYSTACKEXPANDABLE 0 +%code requires { typedef struct count_node { int count; struct count_node *prev; } count_node; +} + +%code { + ]AT_YYERROR_DECLARE[ + ]AT_YYLEX_DECLARE[ + #define YYSTACKEXPANDABLE 0 static count_node *tail; -%} +} %define parse.assert %glr-parser %expect-rr 2 +]$1[ + %union { count_node *node; } %type 'a' @@ -634,6 +676,12 @@ AT_PARSER_CHECK([[glr-regr7]], 2, [], AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------------------------- ## @@ -643,25 +691,25 @@ AT_CLEANUP ## http://lists.gnu.org/archive/html/bug-bison/2005-10/msg00072.html ## ## ------------------------------------------------------------------------- ## -AT_SETUP([Incorrectly initialized location for empty right-hand side in GLR]) +m4_pushdef([AT_TEST], +[AT_SETUP([Incorrectly initialized location for empty right-hand side in GLR: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr8.y], [[ -%{ - #include - #include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ -%} - -%token T_CONSTANT -%token T_PORT -%token T_SIGNAL +} %define parse.assert %glr-parser %expect-rr 1 +]$1[ + +%token T_CONSTANT +%token T_PORT +%token T_SIGNAL %% @@ -724,6 +772,12 @@ AT_PARSER_CHECK([[glr-regr8]], 0, AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------------------------- ## @@ -731,25 +785,26 @@ AT_CLEANUP ## . ## ## ------------------------------------------------------------------------- ## -AT_SETUP([No users destructors if stack 0 deleted]) +m4_pushdef([AT_TEST], +[AT_SETUP([No users destructors if stack 0 deleted: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr9.y], [[ -%{ -# include -# include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ # define YYSTACKEXPANDABLE 0 static int tokens = 0; static int destructors = 0; # define USE(Var) -%} +} %define parse.assert %glr-parser %expect-rr 2 +]$1[ + %union { int dummy; } %type 'a' @@ -760,7 +815,7 @@ AT_DATA_GRAMMAR([glr-regr9.y], %% start: - ambig0 'a' { destructors += 2; USE ($2); } + ambig0 'a' { destructors += 2; USE ($][2); } | ambig1 start { destructors += 1; } | ambig2 start { destructors += 1; } ; @@ -801,29 +856,36 @@ AT_PARSER_CHECK([[glr-regr9]], 0, [], AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------ ## ## Corrupted semantic options if user action cuts parse. ## ## ------------------------------------------------------ ## -AT_SETUP([Corrupted semantic options if user action cuts parse]) +m4_pushdef([AT_TEST], +[AT_SETUP([Corrupted semantic options if user action cuts parse: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr10.y], [[ -%{ -# include -# include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ #define GARBAGE_SIZE 50 static char garbage[GARBAGE_SIZE]; -%} +} %define parse.assert %glr-parser %expect-rr 1 +]$1[ + %union { char *ptr; } %type start @@ -854,28 +916,36 @@ AT_PARSER_CHECK([[glr-regr10]], 0, [], []) AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## --------------------------------------------------- ## ## Undesirable destructors if user action cuts parse. ## ## --------------------------------------------------- ## -AT_SETUP([Undesirable destructors if user action cuts parse]) +m4_pushdef([AT_TEST], +[AT_SETUP([Undesirable destructors if user action cuts parse: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr11.y], [[ -%{ -# include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ static int destructors = 0; # define USE(val) -%} +} %define parse.assert %glr-parser %expect-rr 1 +]$1[ + %union { int dummy; } %type 'a' %destructor { destructors += 1; } 'a' @@ -883,8 +953,8 @@ AT_DATA_GRAMMAR([glr-regr11.y], %% start: - 'a' %dprec 2 { USE ($1); destructors += 1; YYACCEPT; } - | 'a' %dprec 1 { USE ($1); destructors += 1; YYACCEPT; } + 'a' %dprec 2 { USE ($][1); destructors += 1; YYACCEPT; } + | 'a' %dprec 1 { USE ($][1); destructors += 1; YYACCEPT; } ; %% @@ -911,21 +981,30 @@ AT_PARSER_CHECK([[glr-regr11]], 0, [], []) AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## -------------------------------------------------- ## ## Leaked semantic values if user action cuts parse. ## ## -------------------------------------------------- ## -AT_SETUP([Leaked semantic values if user action cuts parse]) +m4_pushdef([AT_TEST], +[AT_SETUP([Leaked semantic values if user action cuts parse: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr12.y], [[ %define parse.assert %glr-parser %expect 1 %expect-rr 1 +]$1[ + %union { int dummy; } %token PARENT_RHS_AFTER %type parent_rhs_before merged PARENT_RHS_AFTER @@ -933,8 +1012,7 @@ AT_DATA_GRAMMAR([glr-regr12.y], %destructor { merged_value = 0; } merged %destructor { parent_rhs_after_value = 0; } PARENT_RHS_AFTER -%{ -# include +%code { # include static int merge (YYSTYPE, YYSTYPE); ]AT_YYERROR_DECLARE[ @@ -943,7 +1021,7 @@ AT_DATA_GRAMMAR([glr-regr12.y], static int merged_value = 0; static int parent_rhs_after_value = 0; # define USE(val) -%} +} %% @@ -954,14 +1032,14 @@ start: alt1: PARENT_RHS_AFTER { - USE ($1); + USE ($][1); parent_rhs_after_value = 0; } ; alt2: parent_rhs_before merged PARENT_RHS_AFTER { - USE (($1, $2, $3)); + USE (($][1, $][2, $][3)); parent_rhs_before_value = 0; merged_value = 0; parent_rhs_after_value = 0; @@ -1031,6 +1109,12 @@ AT_PARSER_CHECK([[glr-regr12]], 0, [], []) AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------------------------- ## @@ -1039,9 +1123,10 @@ AT_CLEANUP ## . ## ## ------------------------------------------------------------------------- ## -AT_SETUP([Incorrect lookahead during deterministic GLR]) +m4_pushdef([AT_TEST], +[AT_SETUP([Incorrect lookahead during deterministic GLR: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr13.y], [[ /* Tests: @@ -1051,26 +1136,27 @@ AT_DATA_GRAMMAR([glr-regr13.y], - Defaulted state after shift: yychar == YYEMPTY. - User action changing the lookahead. */ -%{ - #include +%code { #include ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ static void print_lookahead (char const *); #define USE(value) -%} +} %define parse.assert +%locations +%glr-parser +]$1[ + %union { char value; } %type 'a' 'b' -%glr-parser -%locations %% start: defstate_init defstate_shift 'b' change_lookahead 'a' { - USE ($3); + USE ($][3); print_lookahead ("start <- defstate_init defstate_shift 'b'"); } ; @@ -1081,7 +1167,7 @@ defstate_init: ; defstate_shift: nondefstate defstate_look 'a' { - USE ($3); + USE ($][3); print_lookahead ("defstate_shift <- nondefstate defstate_look 'a'"); } ; @@ -1095,7 +1181,7 @@ nondefstate: print_lookahead ("nondefstate <- empty string"); } | 'b' { - USE ($1); + USE ($][1); print_lookahead ("nondefstate <- 'b'"); } ; @@ -1157,15 +1243,22 @@ start <- defstate_init defstate_shift 'b': AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------- ## ## Incorrect lookahead during nondeterministic GLR. ## ## ------------------------------------------------- ## -AT_SETUP([Incorrect lookahead during nondeterministic GLR]) +m4_pushdef([AT_TEST], +[AT_SETUP([Incorrect lookahead during nondeterministic GLR: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr14.y], [[ /* Tests: @@ -1187,31 +1280,30 @@ AT_DATA_GRAMMAR([glr-regr14.y], - If only defaulted states are entered, there are no conflicts, so nondeterministic operation does not start. */ +%define parse.assert +%type 'a' 'b' 'c' 'd' stack_explosion +%glr-parser +%expect 0 +%expect-rr 5 +]$1[ +%locations + %union { char value; } -%{ - #include - #include +%code { #include ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ static void print_lookahead (char const *); static char merge (union YYSTYPE, union YYSTYPE); #define USE(value) -%} - -%define parse.assert -%type 'a' 'b' 'c' 'd' stack_explosion -%glr-parser -%expect 0 -%expect-rr 5 -%locations +} %% start: merge 'c' stack_explosion { - USE ($2); USE ($3); + USE ($][2); USE ($][3); print_lookahead ("start <- merge 'c' stack_explosion"); } ; @@ -1219,11 +1311,11 @@ start: /* When merging the 2 deferred actions, the lookahead needs are different. */ merge: nonconflict1 'a' 'b' nonconflict2 %dprec 1 { - USE ($2); USE ($3); + USE ($][2); USE ($][3); print_lookahead ("merge <- nonconflict1 'a' 'b' nonconflict2"); } | conflict defstate_look 'a' nonconflict2 'b' defstate_shift %dprec 2 { - USE ($3); USE ($5); + USE ($][3); USE ($][5); print_lookahead ("merge <- conflict defstate_look 'a' nonconflict2 'b'" " defstate_shift"); } @@ -1239,7 +1331,7 @@ nonconflict2: print_lookahead ("nonconflict2 <- empty string"); } | 'a' { - USE ($1); + USE ($][1); print_lookahead ("nonconflict2 <- 'a'"); } ; @@ -1263,13 +1355,13 @@ defstate_shift: stack_explosion: { $$ = '\0'; } - | alt1 stack_explosion %merge { $$ = $2; } - | alt2 stack_explosion %merge { $$ = $2; } - | alt3 stack_explosion %merge { $$ = $2; } + | alt1 stack_explosion %merge { $$ = $][2; } + | alt2 stack_explosion %merge { $$ = $][2; } + | alt3 stack_explosion %merge { $$ = $][2; } ; alt1: 'd' no_look { - USE ($1); + USE ($][1); if (yychar != 'd' && yychar != YYEOF) { fprintf (stderr, "Incorrect lookahead during stack explosion.\n"); @@ -1278,7 +1370,7 @@ alt1: ; alt2: 'd' no_look { - USE ($1); + USE ($][1); if (yychar != 'd' && yychar != YYEOF) { fprintf (stderr, "Incorrect lookahead during stack explosion.\n"); @@ -1287,7 +1379,7 @@ alt2: ; alt3: 'd' no_look { - USE ($1); + USE ($][1); if (yychar != 'd' && yychar != YYEOF) { fprintf (stderr, "Incorrect lookahead during stack explosion.\n"); @@ -1373,30 +1465,38 @@ start <- merge 'c' stack_explosion: AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------- ## ## Leaked semantic values when reporting ambiguity. ## ## ------------------------------------------------- ## -AT_SETUP([Leaked semantic values when reporting ambiguity]) +m4_pushdef([AT_TEST], +[AT_SETUP([Leaked semantic values when reporting ambiguity: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr15.y], [[ %define parse.assert %glr-parser %expect 0 %expect-rr 2 +]$1[ + %destructor { parent_rhs_before_value = 0; } parent_rhs_before -%{ -# include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ static int parent_rhs_before_value = 0; # define USE(val) -%} +} %% @@ -1414,7 +1514,7 @@ alt1: ; alt2: parent_rhs_before ambiguity { - USE ($1); + USE ($][1); parent_rhs_before_value = 0; } ; @@ -1455,31 +1555,39 @@ AT_PARSER_CHECK([[glr-regr15]], 0, [], AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------------ ## ## Leaked lookahead after nondeterministic parse syntax error. ## ## ------------------------------------------------------------ ## -AT_SETUP([Leaked lookahead after nondeterministic parse syntax error]) +m4_pushdef([AT_TEST], +[AT_SETUP([Leaked lookahead after nondeterministic parse syntax error: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr16.y], [[ %define parse.assert %glr-parser %expect 0 %expect-rr 1 +]$1[ + %destructor { lookahead_value = 0; } 'b' -%{ -# include +%code { # include ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ static int lookahead_value = 0; # define USE(val) -%} +} %% @@ -1515,15 +1623,22 @@ AT_PARSER_CHECK([[glr-regr16]], 0, [], AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------- ## ## Uninitialized location when reporting ambiguity. ## ## ------------------------------------------------- ## -AT_SETUP([Uninitialized location when reporting ambiguity]) +m4_pushdef([AT_TEST], +[AT_SETUP([Uninitialized location when reporting ambiguity: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations %define api.pure]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser %locations %define api.pure $1]) AT_DATA_GRAMMAR([glr-regr17.y], [[ @@ -1531,16 +1646,17 @@ AT_DATA_GRAMMAR([glr-regr17.y], %glr-parser %expect 0 %expect-rr 3 +]$1[ %locations %define api.pure %define parse.error verbose %union { int dummy; } -%{ +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ -%} +} %% @@ -1589,24 +1705,31 @@ AT_PARSER_CHECK([[glr-regr17]], 1, [], AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------------------------------------------------- ## ## Missed %merge type warnings when LHS type is declared later. ## ## ------------------------------------------------------------- ## -AT_SETUP([Missed %merge type warnings when LHS type is declared later]) +m4_pushdef([AT_TEST], +[AT_SETUP([Missed %merge type warnings when LHS type is declared later: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([glr-regr18.y], [[%define parse.assert %glr-parser +]$1[ -%{ - #include +%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ -%} +} %union { int type1; @@ -1615,8 +1738,8 @@ AT_DATA_GRAMMAR([glr-regr18.y], } %% -sym1: sym2 %merge { $$ = $1; } ; -sym2: sym3 %merge { $$ = $1; } ; +sym1: sym2 %merge { $$ = $][1; } ; +sym2: sym3 %merge { $$ = $][1; } ; sym3: %merge { $$ = 0; } ; %type sym1; @@ -1638,36 +1761,43 @@ glr-regr18.y:28.18-24: note: previous declaration AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ------------------- ## ## Ambiguity reports. ## ## ------------------- ## -AT_SETUP([Ambiguity reports]) +m4_pushdef([AT_TEST], +[AT_SETUP([Ambiguity reports: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser %debug]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser %debug $1]) AT_DATA_GRAMMAR([input.y], -[[%{ - #include - #include +[[%code { ]AT_YYERROR_DECLARE[ ]AT_YYLEX_DECLARE[ -%} +} %define parse.assert %debug %glr-parser %expect 0 %expect-rr 1 +]$1[ %% + start: 'a' b 'c' d | 'a' b 'c' d ; b: 'b'; -d: /* nada. */; +d: %empty; %% ]AT_YYERROR_DEFINE[ ]AT_YYLEX_DEFINE(["abc"])[ @@ -1688,15 +1818,15 @@ Next token is token 'b' () Shifting token 'b' () Entering state 3 Reducing stack 0 by rule 3 (line 29): - $1 = token 'b' () --> $$ = nterm b () + $][1 = token 'b' () +-> $][$ = nterm b () Entering state 4 Reading a token Next token is token 'c' () Shifting token 'c' () Entering state 6 Reducing stack 0 by rule 4 (line 30): --> $$ = nterm d () +-> $][$ = nterm d () Entering state 7 Reading a token Now at end of input. @@ -1740,6 +1870,12 @@ Cleanup: popping token 'a' () AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST]) + ## ----------------------------------------------------------------- ## @@ -1749,14 +1885,17 @@ AT_CLEANUP ## http://lists.gnu.org/archive/html/bug-bison/2018-05/msg00033.html ## ## ----------------------------------------------------------------- ## -AT_SETUP([Predicates]) +m4_pushdef([AT_TEST], +[AT_SETUP([Predicates: $1]) -AT_BISON_OPTION_PUSHDEFS([%glr-parser]) +AT_BISON_OPTION_PUSHDEFS([%glr-parser $1]) AT_DATA_GRAMMAR([input.y], [[%define parse.assert %glr-parser %define parse.error verbose %expect-rr 1 +]$1[ + %code requires { #include @@ -1805,3 +1944,8 @@ AT_PARSER_CHECK([[input Nwio]], [1], [], [[syntax error, unexpected 'o', expecti AT_BISON_OPTION_POPDEFS AT_CLEANUP +]) + +AT_TEST([%skeleton "glr.c"]) + +m4_popdef([AT_TEST])