%{
#include <stdio.h>
+#include <stdlib.h>
#define YYSTYPE int
static YYSTYPE exprMerge (YYSTYPE x0, YYSTYPE x1);
{
for (;;)
{
- int ch = getchar ();
+ int ch;
+ if (feof (stdin))
+ abort ();
+ ch = getchar ();
if (ch == EOF)
return 0;
else if (ch == 'B' || ch == 'P')
%%
-FILE *input = NULL;
+FILE *input;
int
yylex (void)
{
char buf[50];
char *s;
+ if (feof (stdin))
+ abort ();
switch (fscanf (input, " %1[a-z,]", buf)) {
case 1:
return buf[0];
%{
#include <stdio.h>
+#include <stdlib.h>
#include <stdarg.h>
static int MergeRule (int x0, int x1);
int yylex (void)
{
char inp[3];
+ if (feof (stdin))
+ abort ();
if (fscanf (input, "%2s", inp) == EOF)
return 0;
switch (inp[0])
static int
yylex (void)
{
- static char const *input = "a";
- return *input++;
+ static char const input[] = "a";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
+ return input[toknum++];
}
int
static int
yylex (void)
{
- static char const *input = "a";
- return *input++;
+ static char const input[] = "a";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
+ return input[toknum++];
}
static void
static int
yylex (void)
{
- static char const *input = "a";
- return *input++;
+ static char const input[] = "a";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
+ return input[toknum++];
}
static void
lexIndex += 1;
switch (lexIndex)
{
+ default:
+ abort ();
case 1:
yylloc.first_column = 1;
yylloc.last_column = 9;
yylloc.first_column = 13;
yylloc.last_column = 17;
return T_PORT;
- default:
+ case 3:
return 0;
}
}
AT_DATA_GRAMMAR([glr-regr10.y],
[[
%{
+# include <stdlib.h>
# include <stdio.h>
static void yyerror (char const *);
static int yylex (void);
static int
yylex (void)
{
+ static int called;
+ if (called++)
+ abort ();
return 0;
}
static int
yylex (void)
{
- static char const *input = "a";
- return *input++;
+ static char const input[] = "a";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
+ return input[toknum++];
}
int
start:
alt1 %dprec 1
| alt2 %dprec 2
- ;
+ ;
alt1:
PARENT_RHS_AFTER {
yylex (void)
{
static int const input[] = { PARENT_RHS_AFTER, 0 };
- static const int *inputp = input;
- if (*inputp == PARENT_RHS_AFTER)
+ static size_t toknum;
+ if (! (toknum < sizeof input / sizeof *input))
+ abort ();
+ if (input[toknum] == PARENT_RHS_AFTER)
parent_rhs_after_value = 1;
- return *inputp++;
+ return input[toknum++];
}
int
#include <stdio.h>
static void yyerror (char const *);
static int yylex (void);
- static void print_look_ahead (char const *);
+ static void print_lookahead (char const *);
#define USE(value)
%}
start:
defstate_init defstate_shift 'b' change_lookahead 'a' {
USE ($3);
- print_look_ahead ("start <- defstate_init defstate_shift 'b'");
+ print_lookahead ("start <- defstate_init defstate_shift 'b'");
}
;
defstate_init:
{
- print_look_ahead ("defstate_init <- empty string");
+ print_lookahead ("defstate_init <- empty string");
}
;
defstate_shift:
nondefstate defstate_look 'a' {
USE ($3);
- print_look_ahead ("defstate_shift <- nondefstate defstate_look 'a'");
+ print_lookahead ("defstate_shift <- nondefstate defstate_look 'a'");
}
;
defstate_look:
{
- print_look_ahead ("defstate_look <- empty string");
+ print_lookahead ("defstate_look <- empty string");
}
;
nondefstate:
{
- print_look_ahead ("nondefstate <- empty string");
+ print_lookahead ("nondefstate <- empty string");
}
| 'b' {
USE ($1);
- print_look_ahead ("nondefstate <- 'b'");
+ print_lookahead ("nondefstate <- 'b'");
}
;
change_lookahead:
static int
yylex (void)
{
- static char const *input = "ab";
- static int i = 0;
+ static char const input[] = "ab";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
yylloc.first_line = yylloc.last_line = 1;
- yylloc.first_column = yylloc.last_column = i + 1;
- yylval.value = input[i] + 'A' - 'a';
- return input[i++];
+ yylloc.first_column = yylloc.last_column = toknum + 1;
+ yylval.value = input[toknum] + 'A' - 'a';
+ return input[toknum++];
}
static void
-print_look_ahead (char const *reduction)
+print_lookahead (char const *reduction)
{
printf ("%s:\n yychar=", reduction);
if (yychar == YYEMPTY)
%union { char value; }
%{
+ #include <stdlib.h>
#include <stdio.h>
static void yyerror (char const *);
static int yylex (void);
- static void print_look_ahead (char const *);
+ static void print_lookahead (char const *);
static char merge (union YYSTYPE, union YYSTYPE);
#define USE(value)
%}
start:
merge 'c' stack_explosion {
USE ($2); USE ($3);
- print_look_ahead ("start <- merge 'c' stack_explosion");
+ print_lookahead ("start <- merge 'c' stack_explosion");
}
;
merge:
nonconflict1 'a' 'b' nonconflict2 %dprec 1 {
USE ($2); USE ($3);
- print_look_ahead ("merge <- nonconflict1 'a' 'b' nonconflict2");
+ print_lookahead ("merge <- nonconflict1 'a' 'b' nonconflict2");
}
| conflict defstate_look 'a' nonconflict2 'b' defstate_shift %dprec 2 {
USE ($3); USE ($5);
- print_look_ahead ("merge <- conflict defstate_look 'a' nonconflict2 'b'"
+ print_lookahead ("merge <- conflict defstate_look 'a' nonconflict2 'b'"
" defstate_shift");
}
;
nonconflict1:
{
- print_look_ahead ("nonconflict1 <- empty string");
+ print_lookahead ("nonconflict1 <- empty string");
}
;
nonconflict2:
{
- print_look_ahead ("nonconflict2 <- empty string");
+ print_lookahead ("nonconflict2 <- empty string");
}
| 'a' {
USE ($1);
- print_look_ahead ("nonconflict2 <- 'a'");
+ print_lookahead ("nonconflict2 <- 'a'");
}
;
conflict:
{
- print_look_ahead ("conflict <- empty string");
+ print_lookahead ("conflict <- empty string");
}
;
defstate_look:
{
- print_look_ahead ("defstate_look <- empty string");
+ print_lookahead ("defstate_look <- empty string");
}
;
/* yychar != YYEMPTY but lookahead need is yyfalse. */
defstate_shift:
{
- print_look_ahead ("defstate_shift <- empty string");
+ print_lookahead ("defstate_shift <- empty string");
}
;
static int
yylex (void)
{
- static char const *input = "abcdddd";
- static int i = 0;
+ static char const input[] = "abcdddd";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
yylloc.first_line = yylloc.last_line = 1;
- yylloc.first_column = yylloc.last_column = i + 1;
- yylval.value = input[i] + 'A' - 'a';
- return input[i++];
+ yylloc.first_column = yylloc.last_column = toknum + 1;
+ yylval.value = input[toknum] + 'A' - 'a';
+ return input[toknum++];
}
static void
-print_look_ahead (char const *reduction)
+print_lookahead (char const *reduction)
{
printf ("%s:\n yychar=", reduction);
if (yychar == YYEMPTY)
static int
yylex (void)
{
+ static int called;
+ if (called++)
+ abort ();
return 0;
}
static int
yylex (void)
{
- static const char *input = "ab";
- if (*input == 'b')
+ static char const input[] = "ab";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
+ if (input[toknum] == 'b')
lookahead_value = 1;
- return *input++;
+ return input[toknum++];
}
int
])
AT_CLEANUP
+
+
+## ------------------------------------------------------------------------- ##
+## Uninitialized location when reporting ambiguity. ##
+## ------------------------------------------------------------------------- ##
+
+AT_SETUP([Uninitialized location when reporting ambiguity])
+AT_DATA_GRAMMAR([glr-regr17.y],
+[[
+%glr-parser
+%locations
+%pure-parser
+%error-verbose
+
+%union { int dummy; }
+
+%{
+ static void yyerror (YYLTYPE *, char const *);
+ static int yylex (YYSTYPE *, YYLTYPE *);
+%}
+
+%initial-action {
+ @$.first_line = 1;
+ @$.first_column = 1;
+ @$.last_line = 1;
+ @$.last_column = 1;
+}
+
+%%
+
+/* Tests the case of an empty RHS that has inherited the location of the
+ previous nonterminal, which is unresolved. That location is reported as the
+ last position of the ambiguity. */
+start: ambig1 empty1 | ambig2 empty2 ;
+
+/* Tests multiple levels of yyresolveLocations recursion. */
+ambig1: sub_ambig1 | sub_ambig2 ;
+ambig2: sub_ambig1 | sub_ambig2 ;
+
+/* Tests the case of a non-empty RHS as well as the case of an empty RHS that
+ has inherited the initial location. The empty RHS's location is reported as
+ the first position in the ambiguity. */
+sub_ambig1: empty1 'a' 'b' ;
+sub_ambig2: empty2 'a' 'b' ;
+empty1: ;
+empty2: ;
+
+%%
+
+static void
+yyerror (YYLTYPE *locp, char const *msg)
+{
+ fprintf (stderr, "Error at %d.%d-%d.%d: %s.\n", locp->first_line,
+ locp->first_column, locp->last_line, locp->last_column, msg);
+}
+
+static int
+yylex (YYSTYPE *lvalp, YYLTYPE *llocp)
+{
+ static char const input[] = "ab";
+ static size_t toknum;
+ if (! (toknum < sizeof input))
+ abort ();
+ lvalp->dummy = 0;
+ llocp->first_line = llocp->last_line = 2;
+ llocp->first_column = toknum + 1;
+ llocp->last_column = llocp->first_column + 1;
+ return input[toknum++];
+}
+
+int
+main (void)
+{
+ return yyparse () != 1;
+}
+]])
+
+AT_CHECK([[bison -o glr-regr17.c glr-regr17.y]], 0, [],
+[glr-regr17.y: conflicts: 3 reduce/reduce
+])
+AT_COMPILE([glr-regr17])
+
+AT_CHECK([[./glr-regr17]], 0, [],
+[Error at 1.1-2.3: syntax is ambiguous.
+])
+
+AT_CLEANUP
+
+
+## -------------------------------------------------------------##
+## Missed %merge type warnings when LHS type is declared later. ##
+## -------------------------------------------------------------##
+
+AT_SETUP([Missed %merge type warnings when LHS type is declared later])
+AT_DATA_GRAMMAR([glr-regr18.y],
+[[%glr-parser
+
+%{
+ #include <stdlib.h>
+ static void yyerror (char const *);
+ static int yylex ();
+%}
+
+%union {
+ int type1;
+ int type2;
+ int type3;
+}
+
+%%
+
+sym1: sym2 %merge<merge> { $$ = $1; } ;
+sym2: sym3 %merge<merge> { $$ = $1; } ;
+sym3: %merge<merge> { $$ = 0; } ;
+
+%type <type1> sym1;
+%type <type2> sym2;
+%type <type3> sym3;
+
+%%
+
+static void
+yyerror (char const *msg)
+{
+ fprintf (stderr, "%s\n", msg);
+}
+
+static int
+yylex ()
+{
+ static int called;
+ if (called++)
+ abort ();
+ return 0;
+}
+
+int
+main (void)
+{
+ return yyparse ();
+}
+]])
+
+AT_CHECK([[bison -o glr-regr18.c glr-regr18.y]], 1, [],
+[glr-regr18.y:26.18-24: result type clash on merge function `merge': <type2> != <type1>
+glr-regr18.y:25.18-24: previous declaration
+glr-regr18.y:27.13-19: result type clash on merge function `merge': <type3> != <type2>
+glr-regr18.y:26.18-24: previous declaration
+])
+
+AT_CLEANUP
projects / bison.git / blobdiff