-/* Bison Grammar Parser -*- C -*-
- Copyright (C) 2002 Free Software Foundation, Inc.
+%{/* Bison Grammar Parser -*- C -*-
+
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation,
+ Inc.
This file is part of Bison, the GNU Compiler Compiler.
- This program is free software; you can redistribute it and/or modify
+ This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA
-*/
-
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
-%debug
-%defines
-%locations
-%pure-parser
-// %error-verbose
-%defines
-%name-prefix="gram_"
-
-%{
+#include <config.h>
#include "system.h"
+#include <strverscmp.h>
+
#include "complain.h"
#include "conflicts.h"
#include "files.h"
#include "getargs.h"
#include "gram.h"
#include "muscle_tab.h"
-#include "output.h"
+#include "quotearg.h"
#include "reader.h"
#include "symlist.h"
-
-/* Produce verbose syntax errors. */
-#define YYERROR_VERBOSE 1
+#include "scan-gram.h"
+#include "scan-code.h"
#define YYLLOC_DEFAULT(Current, Rhs, N) (Current) = lloc_default (Rhs, N)
static YYLTYPE lloc_default (YYLTYPE const *, int);
+#define YY_LOCATION_PRINT(File, Loc) \
+ location_print (File, Loc)
+
+static void version_check (location const *loc, char const *version);
+
/* Request detailed syntax error messages, and pass them to GRAM_ERROR.
FIXME: depends on the undocumented availability of YYLLOC. */
#undef yyerror
#define yyerror(Msg) \
- gram_error (&yylloc, Msg)
+ gram_error (&yylloc, Msg)
static void gram_error (location const *, char const *);
-#define YYPRINT(File, Type, Value) \
- print_token_value (File, Type, &Value)
-static void print_token_value (FILE *, int, YYSTYPE const *);
+static char const *char_name (char);
+
+/** Add a lex-param or a parse-param.
+ *
+ * \param type \a lex_param or \a parse_param
+ * \param decl the formal argument
+ * \param loc the location in the source.
+ */
+static void add_param (char const *type, char *decl, location loc);
+
-static void add_param (char const *, char const *, location);
+static symbol_class current_class = unknown_sym;
+static uniqstr current_type = NULL;
+static symbol *current_lhs;
+static location current_lhs_location;
+static int current_prec = 0;
-symbol_class current_class = unknown_sym;
-uniqstr current_type = 0;
-symbol *current_lhs;
-location current_lhs_location;
-assoc current_assoc;
-int current_prec = 0;
-braced_code current_braced_code = action_braced_code;
+#define YYTYPE_INT16 int_fast16_t
+#define YYTYPE_INT8 int_fast8_t
+#define YYTYPE_UINT16 uint_fast16_t
+#define YYTYPE_UINT8 uint_fast8_t
%}
+%debug
+%verbose
+%defines
+%locations
+%pure-parser
+%error-verbose
+%name-prefix="gram_"
+%expect 0
+
+%initial-action
+{
+ /* Bison's grammar can initial empty locations, hence a default
+ location is needed. */
+ boundary_set (&@$.start, current_file, 1, 1);
+ boundary_set (&@$.end, current_file, 1, 1);
+}
-/* Only NUMBERS have a value. */
%union
{
symbol *symbol;
symbol_list *list;
int integer;
- char *chars;
+ char const *chars;
+ char *code;
assoc assoc;
uniqstr uniqstr;
+ unsigned char character;
};
/* Define the tokens together with their human representation. */
%token PERCENT_DESTRUCTOR "%destructor"
%token PERCENT_PRINTER "%printer"
-%token PERCENT_UNION "%union"
-
%token PERCENT_LEFT "%left"
%token PERCENT_RIGHT "%right"
%token PERCENT_NONASSOC "%nonassoc"
`----------------------*/
%token
- PERCENT_DEBUG "%debug"
- PERCENT_DEFINE "%define"
- PERCENT_DEFINES "%defines"
- PERCENT_ERROR_VERBOSE "%error-verbose"
- PERCENT_EXPECT "%expect"
- PERCENT_FILE_PREFIX "%file-prefix"
- PERCENT_GLR_PARSER "%glr-parser"
- PERCENT_LEX_PARAM "%lex-param"
- PERCENT_LOCATIONS "%locations"
- PERCENT_NAME_PREFIX "%name-prefix"
- PERCENT_NO_LINES "%no-lines"
- PERCENT_OUTPUT "%output"
- PERCENT_PARSE_PARAM "%parse-param"
- PERCENT_PURE_PARSER "%pure-parser"
- PERCENT_SKELETON "%skeleton"
- PERCENT_START "%start"
- PERCENT_TOKEN_TABLE "%token-table"
- PERCENT_VERBOSE "%verbose"
- PERCENT_YACC "%yacc"
+ PERCENT_CODE "%code"
+ PERCENT_DEBUG "%debug"
+ PERCENT_DEFAULT_PREC "%default-prec"
+ PERCENT_DEFINE "%define"
+ PERCENT_DEFINES "%defines"
+ PERCENT_ERROR_VERBOSE "%error-verbose"
+ PERCENT_EXPECT "%expect"
+ PERCENT_EXPECT_RR "%expect-rr"
+ PERCENT_FILE_PREFIX "%file-prefix"
+ PERCENT_GLR_PARSER "%glr-parser"
+ PERCENT_INITIAL_ACTION "%initial-action"
+ PERCENT_LANGUAGE "%language"
+ PERCENT_LEX_PARAM "%lex-param"
+ PERCENT_LOCATIONS "%locations"
+ PERCENT_NAME_PREFIX "%name-prefix"
+ PERCENT_NO_DEFAULT_PREC "%no-default-prec"
+ PERCENT_NO_LINES "%no-lines"
+ PERCENT_NONDETERMINISTIC_PARSER
+ "%nondeterministic-parser"
+ PERCENT_OUTPUT "%output"
+ PERCENT_PARSE_PARAM "%parse-param"
+ PERCENT_PURE_PARSER "%pure-parser"
+ PERCENT_PUSH_PARSER "%push-parser"
+ PERCENT_PUSH_PULL_PARSER
+ "%push-pull-parser"
+ PERCENT_REQUIRE "%require"
+ PERCENT_SKELETON "%skeleton"
+ PERCENT_START "%start"
+ PERCENT_TOKEN_TABLE "%token-table"
+ PERCENT_VERBOSE "%verbose"
+ PERCENT_YACC "%yacc"
;
-%token TYPE "type"
+%token BRACED_CODE "{...}"
+%token CHAR "char"
+%token EPILOGUE "epilogue"
%token EQUAL "="
-%token SEMICOLON ";"
-%token PIPE "|"
%token ID "identifier"
%token ID_COLON "identifier:"
%token PERCENT_PERCENT "%%"
+%token PIPE "|"
%token PROLOGUE "%{...%}"
-%token EPILOGUE "epilogue"
-%token BRACED_CODE "{...}"
-
+%token SEMICOLON ";"
+%token TYPE "type"
+%token TYPE_TAG_ANY "<*>"
+%token TYPE_TAG_NONE "<>"
+
+%type <character> CHAR
+%printer { fputs (char_name ($$), stderr); } CHAR
+
+/* braceless is not to be used for rule or symbol actions, as it
+ calls code_props_plain_init. */
+%type <chars> STRING "%{...%}" EPILOGUE braceless content.opt
+%type <code> "{...}"
+%printer { fputs (quotearg_style (c_quoting_style, $$), stderr); }
+ STRING
+%printer { fprintf (stderr, "{\n%s\n}", $$); }
+ braceless content.opt "{...}" "%{...%}" EPILOGUE
+
+%type <uniqstr> TYPE ID ID_COLON variable
+%printer { fprintf (stderr, "<%s>", $$); } TYPE
+%printer { fputs ($$, stderr); } ID variable
+%printer { fprintf (stderr, "%s:", $$); } ID_COLON
-%type <chars> STRING string_content
- BRACED_CODE code_content action
- PROLOGUE EPILOGUE
-%type <uniqstr> TYPE
%type <integer> INT
-%type <symbol> ID ID_COLON symbol string_as_id
+%printer { fprintf (stderr, "%d", $$); } INT
+
+%type <symbol> id id_colon symbol string_as_id
+%printer { fprintf (stderr, "%s", $$->tag); } id symbol string_as_id
+%printer { fprintf (stderr, "%s:", $$->tag); } id_colon
+
%type <assoc> precedence_declarator
-%type <list> symbols.1
+%type <list> symbols.1 generic_symlist generic_symlist_item
%%
input:
- declarations "%%" grammar epilogue.opt
+ prologue_declarations "%%" grammar epilogue.opt
;
| Declarations: before the first %%. |
`------------------------------------*/
-declarations:
+prologue_declarations:
/* Nothing */
-| declarations declaration
+| prologue_declarations prologue_declaration
;
-declaration:
+prologue_declaration:
grammar_declaration
-| PROLOGUE { prologue_augment ($1, @1); }
-| "%debug" { debug_flag = 1; }
-| "%define" string_content string_content { muscle_insert ($2, $3); }
-| "%defines" { defines_flag = 1; }
-| "%error-verbose" { error_verbose = 1; }
-| "%expect" INT { expected_conflicts = $2; }
-| "%file-prefix" "=" string_content { spec_file_prefix = $3; }
-| "%glr-parser" { glr_parser = 1; }
-| "%lex-param" code_content { add_param ("lex_param", $2, @2); }
-| "%locations" { locations_flag = 1; }
-| "%name-prefix" "=" string_content { spec_name_prefix = $3; }
-| "%no-lines" { no_lines_flag = 1; }
-| "%output" "=" string_content { spec_outfile = $3; }
-| "%parse-param" code_content { add_param ("parse_param", $2, @2); }
-| "%pure-parser" { pure_parser = 1; }
-| "%skeleton" string_content { skeleton = $2; }
-| "%token-table" { token_table_flag = 1; }
-| "%verbose" { report_flag = 1; }
-| "%yacc" { yacc_flag = 1; }
-| ";"
+| "%{...%}"
+ {
+ code_props plain_code;
+ code_props_plain_init (&plain_code, $1, @1);
+ code_props_translate_code (&plain_code);
+ gram_scanner_last_string_free ();
+ muscle_code_grow (union_seen ? "post_prologue" : "pre_prologue",
+ plain_code.code, @1);
+ code_scanner_last_string_free ();
+ }
+| "%debug" { debug_flag = true; }
+| "%define" variable content.opt
+ {
+ muscle_percent_define_insert ($2, @2, $3);
+ }
+| "%defines" { defines_flag = true; }
+| "%defines" STRING
+ {
+ defines_flag = true;
+ spec_defines_file = xstrdup ($2);
+ }
+| "%error-verbose" { error_verbose = true; }
+| "%expect" INT { expected_sr_conflicts = $2; }
+| "%expect-rr" INT { expected_rr_conflicts = $2; }
+| "%file-prefix" STRING { spec_file_prefix = $2; }
+| "%file-prefix" "=" STRING { spec_file_prefix = $3; } /* deprecated */
+| "%glr-parser"
+ {
+ nondeterministic_parser = true;
+ glr_parser = true;
+ }
+| "%initial-action" "{...}"
+ {
+ code_props action;
+ code_props_symbol_action_init (&action, $2, @2);
+ code_props_translate_code (&action);
+ gram_scanner_last_string_free ();
+ muscle_code_grow ("initial_action", action.code, @2);
+ code_scanner_last_string_free ();
+ }
+| "%language" STRING { language_argmatch ($2, 1, &@1); }
+| "%lex-param" "{...}" { add_param ("lex_param", $2, @2); }
+| "%locations" { locations_flag = true; }
+| "%name-prefix" STRING { spec_name_prefix = $2; }
+| "%name-prefix" "=" STRING { spec_name_prefix = $3; } /* deprecated */
+| "%no-lines" { no_lines_flag = true; }
+| "%nondeterministic-parser" { nondeterministic_parser = true; }
+| "%output" STRING { spec_outfile = $2; }
+| "%output" "=" STRING { spec_outfile = $3; } /* deprecated */
+| "%parse-param" "{...}" { add_param ("parse_param", $2, @2); }
+| "%pure-parser" { pure_parser = true; }
+| "%push-parser" { push_parser = true; pull_parser = false; }
+| "%push-pull-parser" { push_parser = true; pull_parser = true; }
+| "%require" STRING { version_check (&@2, $2); }
+| "%skeleton" STRING
+ {
+ char const *skeleton_user = $2;
+ if (strchr (skeleton_user, '/'))
+ {
+ size_t dir_length = strlen (current_file);
+ char *skeleton_build;
+ while (dir_length && current_file[dir_length - 1] != '/')
+ --dir_length;
+ while (dir_length && current_file[dir_length - 1] == '/')
+ --dir_length;
+ skeleton_build =
+ xmalloc (dir_length + 1 + strlen (skeleton_user) + 1);
+ if (dir_length > 0)
+ {
+ strncpy (skeleton_build, current_file, dir_length);
+ skeleton_build[dir_length++] = '/';
+ }
+ strcpy (skeleton_build + dir_length, skeleton_user);
+ skeleton_user = uniqstr_new (skeleton_build);
+ free (skeleton_build);
+ }
+ skeleton_arg (skeleton_user, 1, &@1);
+ }
+| "%token-table" { token_table_flag = true; }
+| "%verbose" { report_flag = report_states; }
+| "%yacc" { yacc_flag = true; }
+| /*FIXME: Err? What is this horror doing here? */ ";"
;
grammar_declaration:
{
grammar_start_symbol_set ($2, @2);
}
-| "%union" BRACED_CODE
+| "%destructor" "{...}" generic_symlist
{
- typed = 1;
- MUSCLE_INSERT_INT ("stype_line", @2.start.line);
- muscle_insert ("stype", $2);
+ symbol_list *list;
+ for (list = $3; list; list = list->next)
+ symbol_list_destructor_set (list, $2, @2);
+ symbol_list_free ($3);
}
-| "%destructor"
- { current_braced_code = destructor_braced_code; }
- BRACED_CODE symbols.1
+| "%printer" "{...}" generic_symlist
{
symbol_list *list;
- for (list = $4; list; list = list->next)
- symbol_destructor_set (list->sym, $3, @3);
- symbol_list_free ($4);
- current_braced_code = action_braced_code;
+ for (list = $3; list; list = list->next)
+ symbol_list_printer_set (list, $2, @2);
+ symbol_list_free ($3);
}
-| "%printer"
- { current_braced_code = printer_braced_code; }
- BRACED_CODE symbols.1
+| "%default-prec"
{
- symbol_list *list;
- for (list = $4; list; list = list->next)
- symbol_printer_set (list->sym, $3, list->location);
- symbol_list_free ($4);
- current_braced_code = action_braced_code;
+ default_prec = true;
+ }
+| "%no-default-prec"
+ {
+ default_prec = false;
+ }
+| "%code" braceless
+ {
+ /* Do not invoke muscle_percent_code_grow here since it invokes
+ muscle_user_name_list_grow. */
+ muscle_code_grow ("percent_code()", $2, @2);
+ code_scanner_last_string_free ();
+ }
+| "%code" ID braceless
+ {
+ muscle_percent_code_grow ($2, @2, $3, @3);
+ code_scanner_last_string_free ();
}
;
+
+/*----------*
+ | %union. |
+ *----------*/
+
+%token PERCENT_UNION "%union";
+
+union_name:
+ /* Nothing. */ {}
+| ID { muscle_code_grow ("union_name", $1, @1); }
+;
+
+grammar_declaration:
+ "%union" union_name braceless
+ {
+ union_seen = true;
+ muscle_code_grow ("stype", $3, @3);
+ code_scanner_last_string_free ();
+ }
+;
+
+
+
+
symbol_declaration:
"%nterm" { current_class = nterm_sym; } symbol_defs.1
{
| "%type" TYPE symbols.1
{
symbol_list *list;
+ tag_seen = true;
for (list = $3; list; list = list->next)
- symbol_type_set (list->sym, $2, @2);
+ symbol_type_set (list->content.sym, $2, @2);
symbol_list_free ($3);
}
;
++current_prec;
for (list = $3; list; list = list->next)
{
- symbol_type_set (list->sym, current_type, @2);
- symbol_precedence_set (list->sym, current_prec, $1, @1);
+ symbol_type_set (list->content.sym, current_type, @2);
+ symbol_precedence_set (list->content.sym, current_prec, $1, @1);
}
symbol_list_free ($3);
current_type = NULL;
type.opt:
/* Nothing. */ { current_type = NULL; }
-| TYPE { current_type = $1; }
+| TYPE { current_type = $1; tag_seen = true; }
;
-/* One or more nonterminals to be %typed. */
-
+/* One or more symbols to be %typed. */
symbols.1:
- symbol { $$ = symbol_list_new ($1, @1); }
-| symbols.1 symbol { $$ = symbol_list_prepend ($1, $2, @2); }
+ symbol
+ { $$ = symbol_list_sym_new ($1, @1); }
+| symbols.1 symbol
+ { $$ = symbol_list_prepend ($1, symbol_list_sym_new ($2, @2)); }
+;
+
+generic_symlist:
+ generic_symlist_item { $$ = $1; }
+| generic_symlist generic_symlist_item { $$ = symbol_list_prepend ($1, $2); }
+;
+
+generic_symlist_item:
+ symbol { $$ = symbol_list_sym_new ($1, @1); }
+| TYPE { $$ = symbol_list_type_new ($1, @1); }
+| "<*>" { $$ = symbol_list_default_tagged_new (@1); }
+| "<>" { $$ = symbol_list_default_tagless_new (@1); }
;
/* One token definition. */
TYPE
{
current_type = $1;
+ tag_seen = true;
}
-| ID
+| id
{
- symbol_class_set ($1, current_class, @1);
+ symbol_class_set ($1, current_class, @1, true);
symbol_type_set ($1, current_type, @1);
}
-| ID INT
+| id INT
{
- symbol_class_set ($1, current_class, @1);
+ symbol_class_set ($1, current_class, @1, true);
symbol_type_set ($1, current_type, @1);
symbol_user_token_number_set ($1, $2, @2);
}
-| ID string_as_id
+| id string_as_id
{
- symbol_class_set ($1, current_class, @1);
+ symbol_class_set ($1, current_class, @1, true);
symbol_type_set ($1, current_type, @1);
symbol_make_alias ($1, $2, @$);
}
-| ID INT string_as_id
+| id INT string_as_id
{
- symbol_class_set ($1, current_class, @1);
+ symbol_class_set ($1, current_class, @1, true);
symbol_type_set ($1, current_type, @1);
symbol_user_token_number_set ($1, $2, @2);
symbol_make_alias ($1, $3, @$);
body of the grammar. */
rules_or_grammar_declaration:
rules
-| grammar_declaration
- {
- if (yacc_flag)
- complain_at (@$, _("POSIX forbids declarations in the grammar"));
- }
+| grammar_declaration ";"
| error ";"
{
yyerrok;
}
-| ";"
;
rules:
- ID_COLON { current_lhs = $1; current_lhs_location = @1; } rhses.1
+ id_colon { current_lhs = $1; current_lhs_location = @1; } rhses.1
;
rhses.1:
- rhs { grammar_rule_end (@1); }
-| rhses.1 "|" rhs { grammar_rule_end (@3); }
+ rhs { grammar_current_rule_end (@1); }
+| rhses.1 "|" rhs { grammar_current_rule_end (@3); }
+| rhses.1 ";"
;
rhs:
/* Nothing. */
- { grammar_rule_begin (current_lhs, current_lhs_location); }
+ { grammar_current_rule_begin (current_lhs, current_lhs_location); }
| rhs symbol
{ grammar_current_rule_symbol_append ($2, @2); }
-| rhs action
+| rhs "{...}"
{ grammar_current_rule_action_append ($2, @2); }
| rhs "%prec" symbol
{ grammar_current_rule_prec_set ($3, @3); }
{ grammar_current_rule_merge_set ($3, @3); }
;
-symbol:
- ID { $$ = $1; }
-| string_as_id { $$ = $1; }
-;
-action:
- BRACED_CODE
- { $$ = $1; }
-;
+/*----------------------------*
+ | variable and content.opt. |
+ *---------------------------*/
-/* A string used as an ID: we have to keep the quotes. */
-string_as_id:
- STRING
+variable:
+ ID
+ | STRING { $$ = uniqstr_new ($1); } /* deprecated and not M4-friendly */
+ ;
+
+/* Some content or empty by default. */
+content.opt:
+ /* Nothing. */
{
- $$ = symbol_get ($1, @1);
- symbol_class_set ($$, token_sym, @1);
+ $$ = "";
}
+| STRING
;
-/* A string used for its contents. Strip the quotes. */
-string_content:
- STRING
+
+/*-------------*
+ | braceless. |
+ *-------------*/
+
+braceless:
+ "{...}"
{
- $$ = $1 + 1;
- $$[strlen ($$) - 1] = '\0';
- };
+ code_props plain_code;
+ $1[strlen ($1) - 1] = '\n';
+ code_props_plain_init (&plain_code, $1+1, @1);
+ code_props_translate_code (&plain_code);
+ gram_scanner_last_string_free ();
+ $$ = plain_code.code;
+ }
+;
+
+
+/*---------------*
+ | Identifiers. |
+ *---------------*/
+/* Identifiers are returned as uniqstr values by the scanner.
+ Depending on their use, we may need to make them genuine symbols. */
-/* A BRACED_CODE used for its contents. Strip the braces. */
-code_content:
- BRACED_CODE
+id:
+ ID
+ { $$ = symbol_from_uniqstr ($1, @1); }
+| CHAR
{
- $$ = $1 + 1;
- $$[strlen ($$) - 1] = '\0';
- };
+ $$ = symbol_get (char_name ($1), @1);
+ symbol_class_set ($$, token_sym, @1, false);
+ symbol_user_token_number_set ($$, $1, @1);
+ }
+;
+
+id_colon:
+ ID_COLON { $$ = symbol_from_uniqstr ($1, @1); }
+;
+symbol:
+ id
+| string_as_id
+;
+
+/* A string used as an ID: quote it. */
+string_as_id:
+ STRING
+ {
+ $$ = symbol_get (quotearg_style (c_quoting_style, $1), @1);
+ symbol_class_set ($$, token_sym, @1, false);
+ }
+;
+
epilogue.opt:
/* Nothing. */
| "%%" EPILOGUE
{
- epilogue_augment ($2, @2);
- scanner_last_string_free ();
+ code_props plain_code;
+ code_props_plain_init (&plain_code, $2, @2);
+ code_props_translate_code (&plain_code);
+ gram_scanner_last_string_free ();
+ muscle_code_grow ("epilogue", plain_code.code, @2);
+ code_scanner_last_string_free ();
}
;
lloc_default (YYLTYPE const *rhs, int n)
{
int i;
- int j;
- YYLTYPE r;
- r.start = r.end = rhs[n].end;
+ YYLTYPE loc;
+ /* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;".
+ The bug is fixed in 7.4.2m, but play it safe for now. */
+ loc.start = rhs[n].end;
+ loc.end = rhs[n].end;
+
+ /* Ignore empty nonterminals the start of the the right-hand side.
+ Do not bother to ignore them at the end of the right-hand side,
+ since empty nonterminals have the same end as their predecessors. */
for (i = 1; i <= n; i++)
if (! equal_boundaries (rhs[i].start, rhs[i].end))
{
- r.start = rhs[i].start;
-
- for (j = n; i < j; j--)
- if (! equal_boundaries (rhs[j].start, rhs[j].end))
- break;
- r.end = rhs[j].end;
-
+ loc.start = rhs[i].start;
break;
}
- return r;
+ return loc;
}
declaration DECL and location LOC. */
static void
-add_param (char const *type, char const *decl, location loc)
+add_param (char const *type, char *decl, location loc)
{
- static char const alphanum[] =
- "0123456789"
+ static char const alphanum[26 + 26 + 1 + 10] =
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "_";
- char const *alpha = alphanum + 10;
+ "_"
+ "0123456789";
char const *name_start = NULL;
- char const *p;
+ char *p;
- for (p = decl; *p; p++)
- if ((p == decl || ! strchr (alphanum, p[-1])) && strchr (alpha, p[0]))
+ /* Stop on last actual character. */
+ for (p = decl; p[1]; p++)
+ if ((p == decl
+ || ! memchr (alphanum, p[-1], sizeof alphanum))
+ && memchr (alphanum, p[0], sizeof alphanum - 10))
name_start = p;
+ /* Strip the surrounding '{' and '}', and any blanks just inside
+ the braces. */
+ while (*--p == ' ' || *p == '\t')
+ continue;
+ p[1] = '\0';
+ while (*++decl == ' ' || *decl == '\t')
+ continue;
+
if (! name_start)
complain_at (loc, _("missing identifier in parameter declaration"));
else
size_t name_len;
for (name_len = 1;
- name_start[name_len] && strchr (alphanum, name_start[name_len]);
+ memchr (alphanum, name_start[name_len], sizeof alphanum);
name_len++)
continue;
free (name);
}
- scanner_last_string_free ();
+ gram_scanner_last_string_free ();
}
-/*------------------------------------------------------------------.
-| When debugging the parser, display tokens' locations and values. |
-`------------------------------------------------------------------*/
static void
-print_token_value (FILE *file, int type, YYSTYPE const *value)
+version_check (location const *loc, char const *version)
{
- fputc (' ', file);
- switch (type)
+ if (strverscmp (version, PACKAGE_VERSION) > 0)
{
- case ID:
- fprintf (file, " = %s", value->symbol->tag);
- break;
-
- case INT:
- fprintf (file, " = %d", value->integer);
- break;
-
- case STRING:
- fprintf (file, " = \"%s\"", value->chars);
- break;
-
- case TYPE:
- fprintf (file, " = <%s>", value->uniqstr);
- break;
-
- case BRACED_CODE:
- case PROLOGUE:
- case EPILOGUE:
- fprintf (file, " = {{ %s }}", value->chars);
- break;
-
- default:
- fprintf (file, "unknown token type");
- break;
+ complain_at (*loc, "require bison %s, but have %s",
+ version, PACKAGE_VERSION);
+ exit (63);
}
}
{
complain_at (*loc, "%s", msg);
}
+
+char const *
+token_name (int type)
+{
+ return yytname[YYTRANSLATE (type)];
+}
+
+static char const *
+char_name (char c)
+{
+ if (c == '\'')
+ return "'\\''";
+ else
+ {
+ char buf[4];
+ buf[0] = '\''; buf[1] = c; buf[2] = '\''; buf[3] = '\0';
+ return quotearg_style (escape_quoting_style, buf);
+ }
+}
projects / bison.git / blobdiff