@example
%@{
- #define YYSTYPE const char*
+ #include <stdio.h>
+ #define YYSTYPE char const *
+ int yylex (void);
+ void yyerror (char const *);
%@}
%token TYPENAME ID
and define the @code{stmtMerge} function as:
@example
-static YYSTYPE stmtMerge (YYSTYPE x0, YYSTYPE x1)
+static YYSTYPE
+stmtMerge (YYSTYPE x0, YYSTYPE x1)
@{
printf ("<OR> ");
return "";
@example
%@{
- #define YYSTYPE const char*
+ #define YYSTYPE char const *
static YYSTYPE stmtMerge (YYSTYPE x0, YYSTYPE x1);
%@}
@end example
@cindex @code{incline}
@cindex @acronym{GLR} parsers and @code{inline}
-Note that the @acronym{GLR} parsers require an ISO C89 compiler. In
-addition, they use the @code{inline} keyword, which is not C89, but a
-common extension. It is up to the user of these parsers to handle
+The @acronym{GLR} parsers require a compiler for @acronym{ISO} C89 or
+later. In addition, they use the @code{inline} keyword, which is not
+C89, but is C99 and is a common extension in pre-C99 compilers. It is
+up to the user of these parsers to handle
portability issues. For instance, if using Autoconf and the Autoconf
macro @code{AC_C_INLINE}, a mere
@example
%@{
-#include <config.h>
+ #include <config.h>
%@}
@end example
@example
%@{
-#if ! defined __GNUC__ && ! defined inline
-# define inline
-#endif
+ #if __STDC_VERSION__ < 199901 && ! defined __GNUC__ && ! defined inline
+ #define inline
+ #endif
%@}
@end example
The prologue may define types and variables used in the actions. You can
also use preprocessor commands to define macros used there, and use
@code{#include} to include header files that do any of these things.
+You need to declare the lexical analyzer @code{yylex} and the error
+printer @code{yyerror} here, along with any other global identifiers
+used by the actions in the grammar rules.
The Bison declarations declare the names of the terminal and nonterminal
symbols, and may also describe operator precedence and the data types of
The grammar rules define how to construct each nonterminal symbol from its
parts.
-The epilogue can contain any code you want to use. Often the definition of
-the lexical analyzer @code{yylex} goes here, plus subroutines called by the
-actions in the grammar rules. In a simple program, all the rest of the
-program can go here.
+The epilogue can contain any code you want to use. Often the
+definitions of functions declared in the prologue go here. In a
+simple program, all the rest of the program can go here.
@node Examples
@chapter Examples
/* Reverse polish notation calculator. */
%@{
-#define YYSTYPE double
-#include <math.h>
+ #define YYSTYPE double
+ #include <math.h>
+ int yylex (void);
+ void yyerror (char const *);
%@}
%token NUM
@end example
The declarations section (@pxref{Prologue, , The prologue}) contains two
-preprocessor directives.
+preprocessor directives and two forward declarations.
The @code{#define} directive defines the macro @code{YYSTYPE}, thus
specifying the C data type for semantic values of both tokens and
The @code{#include} directive is used to declare the exponentiation
function @code{pow}.
+The forward declarations for @code{yylex} and @code{yyerror} are
+needed because the C language requires that functions be declared
+before they are used. These functions will be defined in the
+epilogue, but the parser calls them so they must be declared in the
+prologue.
+
The second section, Bison declarations, provides information to Bison
about the token types (@pxref{Bison Declarations, ,The Bison
Declarations Section}). Each terminal symbol that is not a
When @code{yyparse} detects a syntax error, it calls the error reporting
function @code{yyerror} to print an error message (usually but not
-always @code{"parse error"}). It is up to the programmer to supply
+always @code{"syntax error"}). It is up to the programmer to supply
@code{yyerror} (@pxref{Interface, ,Parser C-Language Interface}), so
here is the definition we will use:
@group
#include <stdio.h>
+/* Called by yyparse on error. */
void
-yyerror (const char *s) /* Called by yyparse on error. */
+yyerror (char const *s)
@{
printf ("%s\n", s);
@}
@file{calc.y}, an infix desk-top calculator.
@example
-/* Infix notation calculator--calc */
+/* Infix notation calculator. */
%@{
-#define YYSTYPE double
-#include <math.h>
+ #define YYSTYPE double
+ #include <math.h>
+ #include <stdio.h>
+ int yylex (void);
+ void yyerror (char const *);
%@}
-/* Bison Declarations */
+/* Bison declarations. */
%token NUM
%left '-' '+'
%left '*' '/'
%left NEG /* negation--unary minus */
-%right '^' /* exponentiation */
+%right '^' /* exponentiation */
-/* Grammar follows */
-%%
-input: /* empty string */
+%% /* The grammar follows. */
+input: /* empty */
| input line
;
@end example
This addition to the grammar allows for simple error recovery in the
-event of a parse error. If an expression that cannot be evaluated is
+event of a syntax error. If an expression that cannot be evaluated is
read, the error will be recognized by the third rule for @code{line},
and parsing will continue. (The @code{yyerror} function is still called
upon to print its message as well.) The action executes the statement
/* Location tracking calculator. */
%@{
-#define YYSTYPE int
-#include <math.h>
+ #define YYSTYPE int
+ #include <math.h>
+ int yylex (void);
+ void yyerror (char const *);
%@}
/* Bison declarations. */
%left NEG
%right '^'
-%% /* Grammar follows */
+%% /* The grammar follows. */
@end example
@noindent
@smallexample
@group
%@{
-#include <math.h> /* For math functions, cos(), sin(), etc. */
-#include "calc.h" /* Contains definition of `symrec' */
+ #include <math.h> /* For math functions, cos(), sin(), etc. */
+ #include "calc.h" /* Contains definition of `symrec'. */
+ int yylex (void);
+ void yyerror (char const *);
%@}
@end group
@group
%union @{
- double val; /* For returning numbers. */
- symrec *tptr; /* For returning symbol-table pointers. */
+ double val; /* For returning numbers. */
+ symrec *tptr; /* For returning symbol-table pointers. */
@}
@end group
-%token <val> NUM /* Simple double precision number. */
-%token <tptr> VAR FNCT /* Variable and Function. */
+%token <val> NUM /* Simple double precision number. */
+%token <tptr> VAR FNCT /* Variable and Function. */
%type <val> exp
@group
%right '='
%left '-' '+'
%left '*' '/'
-%left NEG /* Negation--unary minus */
-%right '^' /* Exponentiation */
+%left NEG /* negation--unary minus */
+%right '^' /* exponentiation */
@end group
-/* Grammar follows */
-%%
+%% /* The grammar follows. */
@end smallexample
The above grammar introduces only two new features of the Bison language.
| '(' exp ')' @{ $$ = $2; @}
;
@end group
-/* End of grammar */
+/* End of grammar. */
%%
@end smallexample
@smallexample
@group
-/* Function type. */
+/* Function type. */
typedef double (*func_t) (double);
@end group
@group
-/* Data type for links in the chain of symbols. */
+/* Data type for links in the chain of symbols. */
struct symrec
@{
- char *name; /* name of symbol */
+ char *name; /* name of symbol */
int type; /* type of symbol: either VAR or FNCT */
union
@{
- double var; /* value of a VAR */
- func_t fnctptr; /* value of a FNCT */
+ double var; /* value of a VAR */
+ func_t fnctptr; /* value of a FNCT */
@} value;
- struct symrec *next; /* link field */
+ struct symrec *next; /* link field */
@};
@end group
@group
typedef struct symrec symrec;
-/* The symbol table: a chain of `struct symrec'. */
+/* The symbol table: a chain of `struct symrec'. */
extern symrec *sym_table;
-symrec *putsym (const char *, func_t);
-symrec *getsym (const char *);
+symrec *putsym (char const *, func_t);
+symrec *getsym (char const *);
@end group
@end smallexample
#include <stdio.h>
@group
-int
-main (void)
-@{
- init_table ();
- return yyparse ();
-@}
-@end group
-
-@group
+/* Called by yyparse on error. */
void
-yyerror (const char *s) /* Called by yyparse on error. */
+yyerror (char const *s)
@{
printf ("%s\n", s);
@}
@group
struct init
@{
- char *fname;
- double (*fnct)(double);
+ char const *fname;
+ double (*fnct) (double);
@};
@end group
@group
-struct init arith_fncts[] =
+struct init const arith_fncts[] =
@{
"sin", sin,
"cos", cos,
@group
/* The symbol table: a chain of `struct symrec'. */
-symrec *sym_table = (symrec *) 0;
+symrec *sym_table;
@end group
@group
@}
@}
@end group
+
+@group
+int
+main (void)
+@{
+ init_table ();
+ return yyparse ();
+@}
+@end group
@end smallexample
By simply editing the initialization list and adding the necessary include
@smallexample
symrec *
-putsym (char *sym_name, int sym_type)
+putsym (char const *sym_name, int sym_type)
@{
symrec *ptr;
ptr = (symrec *) malloc (sizeof (symrec));
@}
symrec *
-getsym (const char *sym_name)
+getsym (char const *sym_name)
@{
symrec *ptr;
for (ptr = sym_table; ptr != (symrec *) 0;
@example
%@{
-@var{Prologue}
+ @var{Prologue}
%@}
@var{Bison declarations}
* Epilogue:: Syntax and usage of the epilogue.
@end menu
-@node Prologue, Bison Declarations, , Grammar Outline
+@node Prologue
@subsection The prologue
@cindex declarations section
@cindex Prologue
@smallexample
%@{
-#include <stdio.h>
-#include "ptypes.h"
+ #include <stdio.h>
+ #include "ptypes.h"
%@}
%union @{
@}
%@{
-static void yyprint(FILE *, int, YYSTYPE);
-#define YYPRINT(F, N, L) yyprint(F, N, L)
+ static void print_token_value (FILE *, int, YYSTYPE);
+ #define YYPRINT(F, N, L) print_token_value (F, N, L)
%@}
@dots{}
@samp{%%} (which precedes the grammar rules) may never be omitted even
if it is the first thing in the file.
-@node Epilogue, , Grammar Rules, Grammar Outline
+@node Epilogue
@subsection The epilogue
@cindex additional C code section
@cindex epilogue
the @var{Prologue} is copied to the beginning. This is the most convenient
place to put anything that you want to have in the parser file but which need
not come before the definition of @code{yyparse}. For example, the
-definitions of @code{yylex} and @code{yyerror} often go here.
+definitions of @code{yylex} and @code{yyerror} often go here. Because
+C requires functions to be declared before being used, you often need
+to declare functions like @code{yylex} and @code{yyerror} in the Prologue,
+even if you define them int he Epilogue.
@xref{Interface, ,Parser C-Language Interface}.
If the last section is empty, you may omit the @samp{%%} that separates it
from the grammar rules.
-The Bison parser itself contains many static variables whose names start
-with @samp{yy} and many macros whose names start with @samp{YY}. It is a
+The Bison parser itself contains many macros and identifiers whose
+names start with @samp{yy} or @samp{YY}, so it is a
good idea to avoid using any such names (except those documented in this
manual) in the epilogue of the grammar file.
,Special Features for Use in Actions}). This mode is enabled as soon as
the grammar uses the special @samp{@@@var{n}} tokens, but if your
grammar does not use it, using @samp{%locations} allows for more
-accurate parse error messages.
+accurate syntax error messages.
@end deffn
@deffn {Directive} %name-prefix="@var{prefix}"
parameter information to it in a reentrant way. To do so, use the
declaration @code{%parse-param}:
-@deffn {Directive} %parse-param @var{argument-declaration} @var{argument-name}
+@deffn {Directive} %parse-param @{@var{argument-declaration}@}
@findex %parse-param
-Declare that @code{argument-name} is an additional @code{yyparse}
-argument. This argument is also passed to @code{yyerror}. The
-@var{argument-declaration} is used when declaring functions or
-prototypes.
+Declare that an argument declared by @code{argument-declaration} is an
+additional @code{yyparse} argument. This argument is also passed to
+@code{yyerror}. The @var{argument-declaration} is used when declaring
+functions or prototypes. The last identifier in
+@var{argument-declaration} must be the argument name.
@end deffn
Here's an example. Write this in the parser:
@example
-%parse-param "int *nastiness" "nastiness"
-%parse-param "int *randomness" "randomness"
+%parse-param @{int *nastiness@}
+%parse-param @{int *randomness@}
@end example
@noindent
@code{%lex-param} just like @code{%parse-param} (@pxref{Parser
Function}).
-@deffn {Directive} lex-param @var{argument-declaration} @var{argument-name}
+@deffn {Directive} lex-param @{@var{argument-declaration}@}
@findex %lex-param
-Declare that @code{argument-name} is an additional @code{yylex}
-argument.
+Declare that @code{argument-declaration} is an additional @code{yylex}
+argument declaration.
@end deffn
For instance:
@example
-%parse-param "int *nastiness" "nastiness"
-%lex-param "int *nastiness" "nastiness"
-%parse-param "int *randomness" "randomness"
+%parse-param @{int *nastiness@}
+%lex-param @{int *nastiness@}
+%parse-param @{int *randomness@}
@end example
@noindent
@cindex parse error
@cindex syntax error
-The Bison parser detects a @dfn{parse error} or @dfn{syntax error}
+The Bison parser detects a @dfn{syntax error} or @dfn{parse error}
whenever it reads a token which cannot satisfy any syntax rule. An
action in the grammar can also explicitly proclaim an error, using the
macro @code{YYERROR} (@pxref{Action Features, ,Special Features for Use
The Bison parser expects to report the error by calling an error
reporting function named @code{yyerror}, which you must supply. It is
called by @code{yyparse} whenever a syntax error is found, and it
-receives one argument. For a parse error, the string is normally
-@w{@code{"parse error"}}.
+receives one argument. For a syntax error, the string is normally
+@w{@code{"syntax error"}}.
@findex %error-verbose
If you invoke the directive @code{%error-verbose} in the Bison
declarations section (@pxref{Bison Declarations, ,The Bison Declarations
Section}), then Bison provides a more verbose and specific error message
-string instead of just plain @w{@code{"parse error"}}.
+string instead of just plain @w{@code{"syntax error"}}.
The parser can detect one other kind of error: stack overflow. This
happens when the input contains constructions that are very deeply
@example
@group
void
-yyerror (const char *s)
+yyerror (char const *s)
@{
@end group
@group
@code{yyerror} are:
@example
-void yyerror (const char *msg); /* Yacc parsers. */
-void yyerror (YYLTYPE *locp, const char *msg); /* GLR parsers. */
+void yyerror (char const *msg); /* Yacc parsers. */
+void yyerror (YYLTYPE *locp, char const *msg); /* GLR parsers. */
@end example
-If @samp{%parse-param "int *nastiness" "nastiness"} is used, then:
+If @samp{%parse-param @{int *nastiness@}} is used, then:
@example
-void yyerror (int *randomness, const char *msg); /* Yacc parsers. */
-void yyerror (int *randomness, const char *msg); /* GLR parsers. */
+void yyerror (int *randomness, char const *msg); /* Yacc parsers. */
+void yyerror (int *randomness, char const *msg); /* GLR parsers. */
@end example
Finally, GLR and Yacc parsers share the same @code{yyerror} calling
%locations
/* Pure yylex. */
%pure-parser
-%lex-param "int *nastiness" "nastiness"
+%lex-param @{int *nastiness@}
/* Pure yyparse. */
-%parse-param "int *nastiness" "nastiness"
-%parse-param "int *randomness" "randomness"
+%parse-param @{int *nastiness@}
+%parse-param @{int *randomness@}
@end example
@noindent
int yyparse (int *nastiness, int *randomness);
void yyerror (YYLTYPE *locp,
int *nastiness, int *randomness,
- const char *msg);
+ char const *msg);
@end example
@noindent
-Please, note that the prototypes are only indications of how the code
-produced by Bison will use @code{yyerror}; you still have freedom on the
-exit value, and even on making @code{yyerror} a variadic function. It
-is precisely to enable this that the message is always passed last.
+The prototypes are only indications of how the code produced by Bison
+uses @code{yyerror}. Bison-generated code always ignores the returned
+value, so @code{yyerror} can return any type, including @code{void}.
+Also, @code{yyerror} can be a variadic function; that is why the
+message is always passed last.
+
+Traditionally @code{yyerror} returns an @code{int} that is always
+ignored, but this is purely for historical reasons, and @code{void} is
+preferable since it more accurately describes the return type for
+@code{yyerror}.
@vindex yynerrs
The variable @code{yynerrs} contains the number of syntax errors
@cindex error recovery
@cindex recovery from errors
-It is not usually acceptable to have a program terminate on a parse
+It is not usually acceptable to have a program terminate on a syntax
error. For example, a compiler should recover sufficiently to parse the
rest of the input file and check it for errors; a calculator should accept
another expression.
this token. Write the statement @samp{yyclearin;} in the error rule's
action.
-For example, suppose that on a parse error, an error handling routine is
+For example, suppose that on a syntax error, an error handling routine is
called that advances the input stream to some point where parsing should
once again commence. The next symbol returned by the lexical scanner is
probably correct. The previous look-ahead token ought to be discarded
@example
@group
%@{
-int hexflag;
+ int hexflag;
+ int yylex (void);
+ void yyerror (char const *);
%@}
%%
@dots{}
flow jumps to state 2. If there is no such transition on a nonterminal
symbol, and the lookahead is a @code{NUM}, then this token is shifted on
the parse stack, and the control flow jumps to state 1. Any other
-lookahead triggers a parse error.''
+lookahead triggers a syntax error.''
@cindex core, item set
@cindex item set core
@samp{+}, it will be shifted on the parse stack, and the automaton
control will jump to state 4, corresponding to the item @samp{exp -> exp
'+' . exp}. Since there is no default action, any other token than
-those listed above will trigger a parse error.
+those listed above will trigger a syntax error.
The state 3 is named the @dfn{final state}, or the @dfn{accepting
state}:
calculator (@pxref{Mfcalc Decl, ,Declarations for @code{mfcalc}}):
@smallexample
-#define YYPRINT(file, type, value) yyprint (file, type, value)
+%@{
+ static void print_token_value (FILE *, int, YYSTYPE);
+ #define YYPRINT(file, type, value) print_token_value (file, type, value)
+%@}
+
+@dots{} %% @dots{} %% @dots{}
static void
-yyprint (FILE *file, int type, YYSTYPE value)
+print_token_value (FILE *file, int type, YYSTYPE value)
@{
if (type == VAR)
- fprintf (file, " %s", value.tptr->name);
+ fprintf (file, "%s", value.tptr->name);
else if (type == NUM)
- fprintf (file, " %d", value.val);
+ fprintf (file, "%d", value.val);
@}
@end smallexample
A token name reserved for error recovery. This token may be used in
grammar rules so as to allow the Bison parser to recognize an error in
the grammar without halting the process. In effect, a sentence
-containing an error may be recognized as valid. On a parse error, the
+containing an error may be recognized as valid. On a syntax error, the
token @code{error} becomes the current look-ahead token. Actions
corresponding to @code{error} are then executed, and the look-ahead
token is reset to the token that originally caused the violation.
@deffn {Macro} yyerrok
Macro to cause parser to recover immediately to its normal mode
-after a parse error. @xref{Error Recovery}.
+after a syntax error. @xref{Error Recovery}.
@end deffn
@deffn {Function} yyerror
-User-supplied function to be called by @code{yyparse} on error. The
-function receives one argument, a pointer to a character string
-containing an error message. @xref{Error Reporting, ,The Error
+User-supplied function to be called by @code{yyparse} on error.
+@xref{Error Reporting, ,The Error
Reporting Function @code{yyerror}}.
@end deffn
@end deffn
@deffn {Variable} yynerrs
-Global variable which Bison increments each time there is a parse error.
+Global variable which Bison increments each time there is a syntax error.
(In a pure parser, it is a local variable within @code{yyparse}.)
@xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
@end deffn
@xref{Precedence Decl, ,Operator Precedence}.
@end deffn
-@deffn {Directive} %lex-param "@var{argument-declaration}" "@var{argument-name}"
+@deffn {Directive} %lex-param @{@var{argument-declaration}@}
Bison declaration to specifying an additional parameter that
@code{yylex} should accept. @xref{Pure Calling,, Calling Conventions
for Pure Parsers}.
Summary}.
@end deffn
-@deffn {Directive} %parse-param "@var{argument-declaration}" "@var{argument-name}"
+@deffn {Directive} %parse-param @{@var{argument-declaration}@}
Bison declaration to specifying an additional parameter that
@code{yyparse} should accept. @xref{Parser Function,, The Parser
Function @code{yyparse}}.
be expressed through rules in terms of smaller constructs; in other
words, a construct that is not a token. @xref{Symbols}.
-@item Parse error
-An error encountered during parsing of an input stream due to invalid
-syntax. @xref{Error Recovery}.
-
@item Parser
A function that recognizes valid sentences of a language by analyzing
the syntax structure of a set of tokens passed to it from a lexical
during parsing to allow for recognition and use of existing
information in repeated uses of a symbol. @xref{Multi-function Calc}.
+@item Syntax error
+An error encountered during parsing of an input stream due to invalid
+syntax. @xref{Error Recovery}.
+
@item Token
A basic, grammatically indivisible unit of a language. The symbol
that describes a token in the grammar is a terminal symbol.
projects / bison.git / blobdiff