X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/9280d3ef893b90b36c89fa7737512f2d640e41d9..c0cac722f7e5d7498528a67a37477cdf9ed1745c:/tests/actions.at diff --git a/tests/actions.at b/tests/actions.at index 2c614874..ff230918 100644 --- a/tests/actions.at +++ b/tests/actions.at @@ -73,8 +73,8 @@ main (void) ]]) AT_CHECK([bison input.y -d -v -o input.c]) -AT_CHECK([$CC $CFLAGS $CPPFLAGS input.c -o input], 0, [], [ignore]) -AT_CHECK([./input], 0, +AT_COMPILE([input]) +AT_PARSER_CHECK([./input], 0, [[0123456789 ]]) @@ -144,8 +144,8 @@ main (void) ]]) AT_CHECK([bison input.y -d -v -o input.c]) -AT_CHECK([$CC $CFLAGS $CPPFLAGS input.c -o input], 0, [], [ignore]) -AT_CHECK([./input], 0, +AT_COMPILE([input]) +AT_PARSER_CHECK([./input], 0, [[15 ]]) @@ -153,11 +153,11 @@ AT_CLEANUP -## ------------- ## -## Destructors. ## -## ------------- ## +## -------------------------- ## +## Printers and Destructors. ## +## -------------------------- ## -AT_SETUP([Destructors]) +AT_SETUP([Printers and Destructors]) # Make sure complex $n work. @@ -169,74 +169,116 @@ AT_DATA([[input.y]], #define YYERROR_VERBOSE 1 #define YYDEBUG 1 -/* #define YYPRINT yyprint */ - -static int yylex (void); -static void yyerror (const char *msg); -static void yyprint (FILE *out, int toknum, int tokval); %} - +%verbose %union { int ival; } -%type thing 'x' -%destructor { printf ("Freeing thing %d\n", $$); } thing -%destructor { printf ("Freeing 'x' %d\n", $$); } 'x' +%type 'x' thing line input + +%printer { fprintf (yyout, "%d from %d", $$, @$.first_line); } + input line thing 'x' + +%destructor + { + fprintf (stdout, "Freeing "); + /* FIXME: Ouch: INTERNAL DETAILS EXPOSED HERE. */ + /* Cannot use $$ which is the union member, not the union itself. */ + yysymprint (stdout, yytype, yyvalue, @$); + fprintf (stdout, "\n"); + } + input line thing 'x' + +%{ +static int yylex (void); +static void yyerror (const char *msg); +%} + %% input: /* Nothing. */ -| input line + { + $$ = 0; + printf ("input(%d): /* Nothing */';'\n", $$); + } +| line input /* Right recursive to load the stack so that popping at + EOF can be exercised. */ + { + $$ = 2; + printf ("input(%d): line(%d) input(%d)';'\n", $$, $1, $2); + } ; line: thing thing thing ';' - { printf ("input: thing(%d) thing(%d) thing(%d) ';'\n", $1, $2, $3); } + { + $$ = $1; + printf ("line(%d): thing(%d) thing(%d) thing(%d) ';'\n", $$, $1, $2, $3); + } | thing thing ';' - { printf ("input: thing(%d) thing(%d) ';'\n", $1, $2); } + { + $$ = $1; + printf ("line(%d): thing(%d) thing(%d) ';'\n", $$, $1, $2); + } | thing ';' - { printf ("input: thing(%d) ';'\n", $1); } + { + $$ = $1; + printf ("line(%d): thing(%d) ';'\n", $$, $1); + } | error ';' - { printf ("input: error ';'\n"); } + { + $$ = -1; + printf ("line(%d): error ';'\n", $$); + } ; thing: - 'x' { printf ("thing: 'x' (%d)\n", $1); $$ = $1; } + 'x' + { + $$ = $1; + printf ("thing(%d): 'x'(%d)\n", $$, $1); + } ; %% static int yylex (void) { - static const int input[] = + static const unsigned int input[] = { + /* Exericise the discarding of stack top and input until `error' + can be reduced. */ 'x', 'x', 'x', 'x', 'x', 'x', ';', + + /* Load the stack and provoke an error that cannot be caught by + the grammar, to check that the stack is cleared. */ 'x', 'x', ';', 'x', ';', - 'x', 'y', ';' + 'y' }; - static int counter = 0; + static unsigned int counter = 0; if (counter < (sizeof(input) / sizeof (input[0]))) { yylval.ival = counter; - return input[counter++]; + /* As in BASIC, line numbers go from 10 to 10. */ + yylloc.first_line = 10 * counter; + printf ("sending: '%c' (value = %d, line %d)\n", + input[counter], yylval.ival, yylloc.first_line); + return (int) input[counter++]; } else - return EOF; + { + printf ("sending: EOF\n"); + return EOF; + } } static void yyerror (const char *msg) { - fprintf (stdout, "%s\n", msg); -} - -static void -yyprint (FILE *out, int toknum, int tokval) -{ - if (0 < toknum && toknum < 256) - fprintf (out, " = %d", tokval); + fprintf (stdout, "%d: %s\n", yylloc.first_line, msg); } int @@ -253,30 +295,44 @@ main (void) } ]]) -AT_CHECK([bison input.y -d -v -o input.c]) -AT_CHECK([$CC $CFLAGS $CPPFLAGS input.c -o input], 0, [], [ignore]) -AT_CHECK([./input], 0, -[[thing: 'x' (0) -thing: 'x' (1) -thing: 'x' (2) -parse error, unexpected 'x', expecting ';' -Freeing thing 2 -Freeing thing 1 -Freeing thing 0 -Freeing 'x' 3 -Freeing 'x' 4 -Freeing 'x' 5 -input: error ';' -thing: 'x' (7) -thing: 'x' (8) -input: thing(7) thing(8) ';' -thing: 'x' (10) -input: thing(10) ';' -thing: 'x' (12) -parse error, unexpected $undefined., expecting 'x' or ';' -Freeing thing 12 -input: error ';' -Successful parse. +AT_CHECK([bison input.y --location -d -v -o input.c]) +AT_COMPILE([input]) +AT_PARSER_CHECK([./input], 1, +[[sending: 'x' (value = 0, line 0) +thing(0): 'x'(0) +sending: 'x' (value = 1, line 10) +thing(1): 'x'(1) +sending: 'x' (value = 2, line 20) +thing(2): 'x'(2) +sending: 'x' (value = 3, line 30) +30: parse error, unexpected 'x', expecting ';' +Freeing nterm thing (2 from 20) +Freeing nterm thing (1 from 10) +Freeing nterm thing (0 from 0) +Freeing token 'x' (3 from 30) +sending: 'x' (value = 4, line 40) +Freeing token 'x' (4 from 40) +sending: 'x' (value = 5, line 50) +Freeing token 'x' (5 from 50) +sending: ';' (value = 6, line 60) +line(-1): error ';' +sending: 'x' (value = 7, line 70) +thing(7): 'x'(7) +sending: 'x' (value = 8, line 80) +thing(8): 'x'(8) +sending: ';' (value = 9, line 90) +line(7): thing(7) thing(8) ';' +sending: 'x' (value = 10, line 100) +thing(10): 'x'(10) +sending: ';' (value = 11, line 110) +line(10): thing(10) ';' +sending: 'y' (value = 12, line 120) +120: parse error, unexpected $undefined, expecting $end or 'x' +sending: EOF +Freeing nterm line (10 from 100) +Freeing nterm line (7 from 70) +Freeing nterm line (-1 from 50) +Parsing FAILED. ]]) AT_CLEANUP