src/parse-gram.y

%{/* Bison Grammar Parser                             -*- C -*-

   Copyright (C) 2002, 2003, 2004, 2005, 2006 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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   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., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301  USA
*/

#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 "quotearg.h"
#include "reader.h"
#include "symlist.h"
#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)
static void gram_error (location const *, char 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 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;

#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
%defines
%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);
}

%union
{
  symbol *symbol;
  symbol_list *list;
  int integer;
  char const *chars;
  char *code;
  assoc assoc;
  uniqstr uniqstr;
  unsigned char character;
};

/* Define the tokens together with their human representation.  */
%token GRAM_EOF 0 "end of file"
%token STRING     "string"
%token INT        "integer"

%token PERCENT_TOKEN       "%token"
%token PERCENT_NTERM       "%nterm"

%token PERCENT_TYPE        "%type"
%token PERCENT_DESTRUCTOR  "%destructor"
%token PERCENT_PRINTER     "%printer"

%token PERCENT_LEFT        "%left"
%token PERCENT_RIGHT       "%right"
%token PERCENT_NONASSOC    "%nonassoc"

%token PERCENT_PREC          "%prec"
%token PERCENT_DPREC         "%dprec"
%token PERCENT_MERGE         "%merge"


/*----------------------.
| Global Declarations.  |
`----------------------*/

%token
  PERCENT_CODE            "%code"
  PERCENT_CODE_TOP        "%code-top"
  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_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_PROVIDES        "%provides"
  PERCENT_PURE_PARSER     "%pure-parser"
  PERCENT_PUSH_PARSER     "%push-parser"
  PERCENT_REQUIRE	  "%require"
  PERCENT_REQUIRES        "%requires"
  PERCENT_SKELETON        "%skeleton"
  PERCENT_START           "%start"
  PERCENT_TOKEN_TABLE     "%token-table"
  PERCENT_VERBOSE         "%verbose"
  PERCENT_YACC            "%yacc"
;

%token BRACED_CODE     "{...}"
%token CHAR            "char"
%token EPILOGUE        "epilogue"
%token EQUAL           "="
%token ID              "identifier"
%token ID_COLON        "identifier:"
%token PERCENT_PERCENT "%%"
%token PIPE            "|"
%token PROLOGUE        "%{...%}"
%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 translate_code. */
%type <chars> STRING "%{...%}" EPILOGUE braceless content content.opt
%type <code> "{...}"
%printer { fputs (quotearg_style (c_quoting_style, $$), stderr); }
	 STRING
%printer { fprintf (stderr, "{\n%s\n}", $$); }
	 braceless content content.opt "{...}" "%{...%}" EPILOGUE

%type <uniqstr> TYPE ID ID_COLON
%printer { fprintf (stderr, "<%s>", $$); } TYPE
%printer { fputs ($$, stderr); } ID
%printer { fprintf (stderr, "%s:", $$); } ID_COLON

%type <integer> INT
%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 generic_symlist generic_symlist_item
%%

input:
  prologue_declarations "%%" grammar epilogue.opt
;


	/*------------------------------------.
	| Declarations: before the first %%.  |
	`------------------------------------*/

prologue_declarations:
  /* Nothing */
| prologue_declarations prologue_declaration
;

prologue_declaration:
  grammar_declaration
| "%{...%}"     { prologue_augment (translate_code ($1, @1), @1, union_seen); }
| "%debug"                         { debug_flag = true; }
| "%define" STRING content.opt     { muscle_insert ($2, $3); }
| "%defines"                       { defines_flag = true; }
| "%error-verbose"                 { error_verbose = true; }
| "%expect" INT                    { expected_sr_conflicts = $2; }
| "%expect-rr" INT		   { expected_rr_conflicts = $2; }
| "%file-prefix" "=" STRING        { spec_file_prefix = $3; }
| "%glr-parser"
    {
      nondeterministic_parser = true;
      glr_parser = true;
    }
| "%initial-action" "{...}"
    {
      muscle_code_grow ("initial_action", translate_symbol_action ($2, @2), @2);
    }
| "%lex-param" "{...}"		{ add_param ("lex_param", $2, @2); }
| "%locations"                  { locations_flag = true; }
| "%name-prefix" "=" STRING     { spec_name_prefix = $3; }
| "%no-lines"                   { no_lines_flag = true; }
| "%nondeterministic-parser"	{ nondeterministic_parser = true; }
| "%output" "=" STRING          { spec_outfile = $3; }
| "%parse-param" "{...}"	{ add_param ("parse_param", $2, @2); }
| "%pure-parser"                { pure_parser = true; }
| "%push-parser"                { push_parser = true; }
| "%require" STRING             { version_check (&@2, $2); }
| "%skeleton" STRING            { skeleton = $2; }
| "%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:
  precedence_declaration
| symbol_declaration
| "%start" symbol
    {
      grammar_start_symbol_set ($2, @2);
    }
| "%destructor" "{...}" generic_symlist
    {
      symbol_list *list;
      const char *action = translate_symbol_action ($2, @2);
      for (list = $3; list; list = list->next)
	symbol_list_destructor_set (list, action, @2);
      symbol_list_free ($3);
    }
| "%printer" "{...}" generic_symlist
    {
      symbol_list *list;
      const char *action = translate_symbol_action ($2, @2);
      for (list = $3; list; list = list->next)
	symbol_list_printer_set (list, action, @2);
      symbol_list_free ($3);
    }
| "%default-prec"
    {
      default_prec = true;
    }
| "%no-default-prec"
    {
      default_prec = false;
    }
| "%code" braceless      { prologue_augment ($2, @2, true); }
| "%code-top" braceless  { prologue_augment ($2, @2, false); }
| "%provides" braceless  { muscle_code_grow ("provides", $2, @2); }
| "%requires" braceless  { muscle_code_grow ("requires", $2, @2); }
;


/*----------*
 | %union.  |
 *----------*/

%token PERCENT_UNION "%union";

union_name:
  /* Nothing. */ {}
| ID             { muscle_code_grow ("union_name", $1, @1); }
;

grammar_declaration:
  "%union" union_name "{...}"
    {
      char const *body = $3;

      /* Concatenate the %union bodies.  If this is the first %union, make sure
	 the synchronization line appears after the opening '{' so as not to
	 confuse Doxygen.  Otherwise, turn the previous %union's trailing '}'
	 into '\n', and omit the new %union's leading '{'.  */
      if (!union_seen)
	{
	  muscle_grow ("stype", "{", "");
	}
      else
	{
	  char *code = muscle_find ("stype");
	  code[strlen (code) - 1] = '\n';
	}
      body++;

      union_seen = true;
      muscle_code_grow ("stype", body, @3);
    }
;


symbol_declaration:
  "%nterm" { current_class = nterm_sym; } symbol_defs.1
    {
      current_class = unknown_sym;
      current_type = NULL;
    }
| "%token" { current_class = token_sym; } symbol_defs.1
    {
      current_class = unknown_sym;
      current_type = NULL;
    }
| "%type" TYPE symbols.1
    {
      symbol_list *list;
      tag_seen = true;
      for (list = $3; list; list = list->next)
	symbol_type_set (list->content.sym, $2, @2);
      symbol_list_free ($3);
    }
;

precedence_declaration:
  precedence_declarator type.opt symbols.1
    {
      symbol_list *list;
      ++current_prec;
      for (list = $3; list; list = list->next)
	{
	  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;
    }
;

precedence_declarator:
  "%left"     { $$ = left_assoc; }
| "%right"    { $$ = right_assoc; }
| "%nonassoc" { $$ = non_assoc; }
;

type.opt:
  /* Nothing. */ { current_type = NULL; }
| TYPE           { current_type = $1; tag_seen = true; }
;

/* One or more symbols to be %typed. */
symbols.1:
  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.  */
symbol_def:
  TYPE
     {
       current_type = $1;
       tag_seen = true;
     }
| id
     {
       symbol_class_set ($1, current_class, @1, true);
       symbol_type_set ($1, current_type, @1);
     }
| id INT
    {
      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
    {
      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
    {
      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, @$);
    }
;

/* One or more symbol definitions. */
symbol_defs.1:
  symbol_def
| symbol_defs.1 symbol_def
;


	/*------------------------------------------.
	| The grammar section: between the two %%.  |
	`------------------------------------------*/

grammar:
  rules_or_grammar_declaration
| grammar rules_or_grammar_declaration
;

/* As a Bison extension, one can use the grammar declarations in the
   body of the grammar.  */
rules_or_grammar_declaration:
  rules
| grammar_declaration ";"
| error ";"
    {
      yyerrok;
    }
;

rules:
  id_colon { current_lhs = $1; current_lhs_location = @1; } rhses.1
;

rhses.1:
  rhs                { grammar_current_rule_end (@1); }
| rhses.1 "|" rhs    { grammar_current_rule_end (@3); }
| rhses.1 ";"
;

rhs:
  /* Nothing.  */
    { grammar_current_rule_begin (current_lhs, current_lhs_location); }
| rhs symbol
    { grammar_current_rule_symbol_append ($2, @2); }
| rhs "{...}"
    { grammar_current_rule_action_append ($2, @2); }
| rhs "%prec" symbol
    { grammar_current_rule_prec_set ($3, @3); }
| rhs "%dprec" INT
    { grammar_current_rule_dprec_set ($3, @3); }
| rhs "%merge" TYPE
    { grammar_current_rule_merge_set ($3, @3); }
;


/*-----------*
 | content.  |
 *-----------*/

content:
  STRING
| braceless
;

/* Some content or "1" by default. */
content.opt:
  /* Nothing. */
    {
      static char one[] = "1";
      $$ = one;
    }
| content
;


braceless:
  "{...}"
    {
      $1[strlen ($1) - 1] = '\n';
      $$ = translate_code ($1 + 1, @1);
    }
;


/*---------------*
 | Identifiers.  |
 *---------------*/

/* Identifiers are returned as uniqstr values by the scanner.
   Depending on their use, we may need to make them genuine symbols.  */

id:
  ID
    { $$ = symbol_from_uniqstr ($1, @1); }
| CHAR
    {
      $$ = 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
    {
      muscle_code_grow ("epilogue", translate_code ($2, @2), @2);
      gram_scanner_last_string_free ();
    }
;

%%


/* Return the location of the left-hand side of a rule whose
   right-hand side is RHS[1] ... RHS[N].  Ignore empty nonterminals in
   the right-hand side, and return an empty location equal to the end
   boundary of RHS[0] if the right-hand side is empty.  */

static YYLTYPE
lloc_default (YYLTYPE const *rhs, int n)
{
  int i;
  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))
      {
	loc.start = rhs[i].start;
	break;
      }

  return loc;
}


/* Add a lex-param or a parse-param (depending on TYPE) with
   declaration DECL and location LOC.  */

static void
add_param (char const *type, char *decl, location loc)
{
  static char const alphanum[26 + 26 + 1 + 10] =
    "abcdefghijklmnopqrstuvwxyz"
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "_"
    "0123456789";
  char const *name_start = NULL;
  char *p;

  /* 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
    {
      char *name;
      size_t name_len;

      for (name_len = 1;
	   memchr (alphanum, name_start[name_len], sizeof alphanum);
	   name_len++)
	continue;

      name = xmalloc (name_len + 1);
      memcpy (name, name_start, name_len);
      name[name_len] = '\0';
      muscle_pair_list_grow (type, decl, name);
      free (name);
    }

  gram_scanner_last_string_free ();
}


static void
version_check (location const *loc, char const *version)
{
  if (strverscmp (version, PACKAGE_VERSION) > 0)
    {
      complain_at (*loc, "require bison %s, but have %s",
		   version, PACKAGE_VERSION);
      exit (63);
    }
}

static void
gram_error (location const *loc, char const *msg)
{
  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);
    }
}
Commit	Line	Data
	1	%{/* Bison Grammar Parser -- C --
	2
	3	Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
	4
	5	This file is part of Bison, the GNU Compiler Compiler.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	20	02110-1301 USA
	21	*/
	22
	23	#include <config.h>
	24	#include "system.h"
	25
	26	#include <strverscmp.h>
	27
	28	#include "complain.h"
	29	#include "conflicts.h"
	30	#include "files.h"
	31	#include "getargs.h"
	32	#include "gram.h"
	33	#include "muscle_tab.h"
	34	#include "quotearg.h"
	35	#include "reader.h"
	36	#include "symlist.h"
	37	#include "scan-gram.h"
	38	#include "scan-code.h"
	39
	40	#define YYLLOC_DEFAULT(Current, Rhs, N) (Current) = lloc_default (Rhs, N)
	41	static YYLTYPE lloc_default (YYLTYPE const *, int);
	42
	43	#define YY_LOCATION_PRINT(File, Loc) \
	44	location_print (File, Loc)
	45
	46	static void version_check (location const loc, char const version);
	47
	48	/* Request detailed syntax error messages, and pass them to GRAM_ERROR.
	49	FIXME: depends on the undocumented availability of YYLLOC. */
	50	#undef yyerror
	51	#define yyerror(Msg) \
	52	gram_error (&yylloc, Msg)
	53	static void gram_error (location const , char const );
	54
	55	static char const *char_name (char);
	56
	57	/** Add a lex-param or a parse-param.
	58	*
	59	* \param type \a lex_param or \a parse_param
	60	* \param decl the formal argument
	61	* \param loc the location in the source.
	62	*/
	63	static void add_param (char const type, char decl, location loc);
	64
	65
	66	static symbol_class current_class = unknown_sym;
	67	static uniqstr current_type = NULL;
	68	static symbol *current_lhs;
	69	static location current_lhs_location;
	70	static int current_prec = 0;
	71
	72	#define YYTYPE_INT16 int_fast16_t
	73	#define YYTYPE_INT8 int_fast8_t
	74	#define YYTYPE_UINT16 uint_fast16_t
	75	#define YYTYPE_UINT8 uint_fast8_t
	76	%}
	77
	78	%debug
	79	%verbose
	80	%defines
	81	%locations
	82	%pure-parser
	83	%error-verbose
	84	%defines
	85	%name-prefix="gram_"
	86	%expect 0
	87
	88	%initial-action
	89	{
	90	/* Bison's grammar can initial empty locations, hence a default
	91	location is needed. */
	92	boundary_set (&@$.start, current_file, 1, 1);
	93	boundary_set (&@$.end, current_file, 1, 1);
	94	}
	95
	96	%union
	97	{
	98	symbol *symbol;
	99	symbol_list *list;
	100	int integer;
	101	char const *chars;
	102	char *code;
	103	assoc assoc;
	104	uniqstr uniqstr;
	105	unsigned char character;
	106	};
	107
	108	/* Define the tokens together with their human representation. */
	109	%token GRAM_EOF 0 "end of file"
	110	%token STRING "string"
	111	%token INT "integer"
	112
	113	%token PERCENT_TOKEN "%token"
	114	%token PERCENT_NTERM "%nterm"
	115
	116	%token PERCENT_TYPE "%type"
	117	%token PERCENT_DESTRUCTOR "%destructor"
	118	%token PERCENT_PRINTER "%printer"
	119
	120	%token PERCENT_LEFT "%left"
	121	%token PERCENT_RIGHT "%right"
	122	%token PERCENT_NONASSOC "%nonassoc"
	123
	124	%token PERCENT_PREC "%prec"
	125	%token PERCENT_DPREC "%dprec"
	126	%token PERCENT_MERGE "%merge"
	127
	128
	129	/*----------------------.
	130	\| Global Declarations. \|
	131	`----------------------*/
	132
	133	%token
	134	PERCENT_CODE "%code"
	135	PERCENT_CODE_TOP "%code-top"
	136	PERCENT_DEBUG "%debug"
	137	PERCENT_DEFAULT_PREC "%default-prec"
	138	PERCENT_DEFINE "%define"
	139	PERCENT_DEFINES "%defines"
	140	PERCENT_ERROR_VERBOSE "%error-verbose"
	141	PERCENT_EXPECT "%expect"
	142	PERCENT_EXPECT_RR "%expect-rr"
	143	PERCENT_FILE_PREFIX "%file-prefix"
	144	PERCENT_GLR_PARSER "%glr-parser"
	145	PERCENT_INITIAL_ACTION "%initial-action"
	146	PERCENT_LEX_PARAM "%lex-param"
	147	PERCENT_LOCATIONS "%locations"
	148	PERCENT_NAME_PREFIX "%name-prefix"
	149	PERCENT_NO_DEFAULT_PREC "%no-default-prec"
	150	PERCENT_NO_LINES "%no-lines"
	151	PERCENT_NONDETERMINISTIC_PARSER
	152	"%nondeterministic-parser"
	153	PERCENT_OUTPUT "%output"
	154	PERCENT_PARSE_PARAM "%parse-param"
	155	PERCENT_PROVIDES "%provides"
	156	PERCENT_PURE_PARSER "%pure-parser"
	157	PERCENT_PUSH_PARSER "%push-parser"
	158	PERCENT_REQUIRE "%require"
	159	PERCENT_REQUIRES "%requires"
	160	PERCENT_SKELETON "%skeleton"
	161	PERCENT_START "%start"
	162	PERCENT_TOKEN_TABLE "%token-table"
	163	PERCENT_VERBOSE "%verbose"
	164	PERCENT_YACC "%yacc"
	165	;
	166
	167	%token BRACED_CODE "{...}"
	168	%token CHAR "char"
	169	%token EPILOGUE "epilogue"
	170	%token EQUAL "="
	171	%token ID "identifier"
	172	%token ID_COLON "identifier:"
	173	%token PERCENT_PERCENT "%%"
	174	%token PIPE "\|"
	175	%token PROLOGUE "%{...%}"
	176	%token SEMICOLON ";"
	177	%token TYPE "type"
	178	%token TYPE_TAG_ANY "<*>"
	179	%token TYPE_TAG_NONE "<!>"
	180
	181	%type <character> CHAR
	182	%printer { fputs (char_name ($$), stderr); } CHAR
	183
	184	/* braceless is not to be used for rule or symbol actions, as it
	185	calls translate_code. */
	186	%type <chars> STRING "%{...%}" EPILOGUE braceless content content.opt
	187	%type <code> "{...}"
	188	%printer { fputs (quotearg_style (c_quoting_style, $$), stderr); }
	189	STRING
	190	%printer { fprintf (stderr, "{\n%s\n}", $$); }
	191	braceless content content.opt "{...}" "%{...%}" EPILOGUE
	192
	193	%type <uniqstr> TYPE ID ID_COLON
	194	%printer { fprintf (stderr, "<%s>", $$); } TYPE
	195	%printer { fputs ($$, stderr); } ID
	196	%printer { fprintf (stderr, "%s:", $$); } ID_COLON
	197
	198	%type <integer> INT
	199	%printer { fprintf (stderr, "%d", $$); } INT
	200
	201	%type <symbol> id id_colon symbol string_as_id
	202	%printer { fprintf (stderr, "%s", $$->tag); } id symbol string_as_id
	203	%printer { fprintf (stderr, "%s:", $$->tag); } id_colon
	204
	205	%type <assoc> precedence_declarator
	206	%type <list> symbols.1 generic_symlist generic_symlist_item
	207	%%
	208
	209	input:
	210	prologue_declarations "%%" grammar epilogue.opt
	211	;
	212
	213
	214	/*------------------------------------.
	215	\| Declarations: before the first %%. \|
	216	`------------------------------------*/
	217
	218	prologue_declarations:
	219	/* Nothing */
	220	\| prologue_declarations prologue_declaration
	221	;
	222
	223	prologue_declaration:
	224	grammar_declaration
	225	\| "%{...%}" { prologue_augment (translate_code ($1, @1), @1, union_seen); }
	226	\| "%debug" { debug_flag = true; }
	227	\| "%define" STRING content.opt { muscle_insert ($2, $3); }
	228	\| "%defines" { defines_flag = true; }
	229	\| "%error-verbose" { error_verbose = true; }
	230	\| "%expect" INT { expected_sr_conflicts = $2; }
	231	\| "%expect-rr" INT { expected_rr_conflicts = $2; }
	232	\| "%file-prefix" "=" STRING { spec_file_prefix = $3; }
	233	\| "%glr-parser"
	234	{
	235	nondeterministic_parser = true;
	236	glr_parser = true;
	237	}
	238	\| "%initial-action" "{...}"
	239	{
	240	muscle_code_grow ("initial_action", translate_symbol_action ($2, @2), @2);
	241	}
	242	\| "%lex-param" "{...}" { add_param ("lex_param", $2, @2); }
	243	\| "%locations" { locations_flag = true; }
	244	\| "%name-prefix" "=" STRING { spec_name_prefix = $3; }
	245	\| "%no-lines" { no_lines_flag = true; }
	246	\| "%nondeterministic-parser" { nondeterministic_parser = true; }
	247	\| "%output" "=" STRING { spec_outfile = $3; }
	248	\| "%parse-param" "{...}" { add_param ("parse_param", $2, @2); }
	249	\| "%pure-parser" { pure_parser = true; }
	250	\| "%push-parser" { push_parser = true; }
	251	\| "%require" STRING { version_check (&@2, $2); }
	252	\| "%skeleton" STRING { skeleton = $2; }
	253	\| "%token-table" { token_table_flag = true; }
	254	\| "%verbose" { report_flag = report_states; }
	255	\| "%yacc" { yacc_flag = true; }
	256	\| /FIXME: Err? What is this horror doing here? / ";"
	257	;
	258
	259	grammar_declaration:
	260	precedence_declaration
	261	\| symbol_declaration
	262	\| "%start" symbol
	263	{
	264	grammar_start_symbol_set ($2, @2);
	265	}
	266	\| "%destructor" "{...}" generic_symlist
	267	{
	268	symbol_list *list;
	269	const char *action = translate_symbol_action ($2, @2);
	270	for (list = $3; list; list = list->next)
	271	symbol_list_destructor_set (list, action, @2);
	272	symbol_list_free ($3);
	273	}
	274	\| "%printer" "{...}" generic_symlist
	275	{
	276	symbol_list *list;
	277	const char *action = translate_symbol_action ($2, @2);
	278	for (list = $3; list; list = list->next)
	279	symbol_list_printer_set (list, action, @2);
	280	symbol_list_free ($3);
	281	}
	282	\| "%default-prec"
	283	{
	284	default_prec = true;
	285	}
	286	\| "%no-default-prec"
	287	{
	288	default_prec = false;
	289	}
	290	\| "%code" braceless { prologue_augment ($2, @2, true); }
	291	\| "%code-top" braceless { prologue_augment ($2, @2, false); }
	292	\| "%provides" braceless { muscle_code_grow ("provides", $2, @2); }
	293	\| "%requires" braceless { muscle_code_grow ("requires", $2, @2); }
	294	;
	295
	296
	297	/----------
	298	\| %union. \|
	299	----------/
	300
	301	%token PERCENT_UNION "%union";
	302
	303	union_name:
	304	/* Nothing. */ {}
	305	\| ID { muscle_code_grow ("union_name", $1, @1); }
	306	;
	307
	308	grammar_declaration:
	309	"%union" union_name "{...}"
	310	{
	311	char const *body = $3;
	312
	313	/* Concatenate the %union bodies. If this is the first %union, make sure
	314	the synchronization line appears after the opening '{' so as not to
	315	confuse Doxygen. Otherwise, turn the previous %union's trailing '}'
	316	into '\n', and omit the new %union's leading '{'. */
	317	if (!union_seen)
	318	{
	319	muscle_grow ("stype", "{", "");
	320	}
	321	else
	322	{
	323	char *code = muscle_find ("stype");
	324	code[strlen (code) - 1] = '\n';
	325	}
	326	body++;
	327
	328	union_seen = true;
	329	muscle_code_grow ("stype", body, @3);
	330	}
	331	;
	332
	333
	334
	335
	336	symbol_declaration:
	337	"%nterm" { current_class = nterm_sym; } symbol_defs.1
	338	{
	339	current_class = unknown_sym;
	340	current_type = NULL;
	341	}
	342	\| "%token" { current_class = token_sym; } symbol_defs.1
	343	{
	344	current_class = unknown_sym;
	345	current_type = NULL;
	346	}
	347	\| "%type" TYPE symbols.1
	348	{
	349	symbol_list *list;
	350	tag_seen = true;
	351	for (list = $3; list; list = list->next)
	352	symbol_type_set (list->content.sym, $2, @2);
	353	symbol_list_free ($3);
	354	}
	355	;
	356
	357	precedence_declaration:
	358	precedence_declarator type.opt symbols.1
	359	{
	360	symbol_list *list;
	361	++current_prec;
	362	for (list = $3; list; list = list->next)
	363	{
	364	symbol_type_set (list->content.sym, current_type, @2);
	365	symbol_precedence_set (list->content.sym, current_prec, $1, @1);
	366	}
	367	symbol_list_free ($3);
	368	current_type = NULL;
	369	}
	370	;
	371
	372	precedence_declarator:
	373	"%left" { $$ = left_assoc; }
	374	\| "%right" { $$ = right_assoc; }
	375	\| "%nonassoc" { $$ = non_assoc; }
	376	;
	377
	378	type.opt:
	379	/* Nothing. */ { current_type = NULL; }
	380	\| TYPE { current_type = $1; tag_seen = true; }
	381	;
	382
	383	/* One or more symbols to be %typed. */
	384	symbols.1:
	385	symbol
	386	{ $$ = symbol_list_sym_new ($1, @1); }
	387	\| symbols.1 symbol
	388	{ $$ = symbol_list_prepend ($1, symbol_list_sym_new ($2, @2)); }
	389	;
	390
	391	generic_symlist:
	392	generic_symlist_item { $$ = $1; }
	393	\| generic_symlist generic_symlist_item { $$ = symbol_list_prepend ($1, $2); }
	394	;
	395
	396	generic_symlist_item:
	397	symbol { $$ = symbol_list_sym_new ($1, @1); }
	398	\| TYPE { $$ = symbol_list_type_new ($1, @1); }
	399	\| "<*>" { $$ = symbol_list_default_tagged_new (@1); }
	400	\| "<!>" { $$ = symbol_list_default_tagless_new (@1); }
	401	;
	402
	403	/* One token definition. */
	404	symbol_def:
	405	TYPE
	406	{
	407	current_type = $1;
	408	tag_seen = true;
	409	}
	410	\| id
	411	{
	412	symbol_class_set ($1, current_class, @1, true);
	413	symbol_type_set ($1, current_type, @1);
	414	}
	415	\| id INT
	416	{
	417	symbol_class_set ($1, current_class, @1, true);
	418	symbol_type_set ($1, current_type, @1);
	419	symbol_user_token_number_set ($1, $2, @2);
	420	}
	421	\| id string_as_id
	422	{
	423	symbol_class_set ($1, current_class, @1, true);
	424	symbol_type_set ($1, current_type, @1);
	425	symbol_make_alias ($1, $2, @$);
	426	}
	427	\| id INT string_as_id
	428	{
	429	symbol_class_set ($1, current_class, @1, true);
	430	symbol_type_set ($1, current_type, @1);
	431	symbol_user_token_number_set ($1, $2, @2);
	432	symbol_make_alias ($1, $3, @$);
	433	}
	434	;
	435
	436	/* One or more symbol definitions. */
	437	symbol_defs.1:
	438	symbol_def
	439	\| symbol_defs.1 symbol_def
	440	;
	441
	442
	443	/*------------------------------------------.
	444	\| The grammar section: between the two %%. \|
	445	`------------------------------------------*/
	446
	447	grammar:
	448	rules_or_grammar_declaration
	449	\| grammar rules_or_grammar_declaration
	450	;
	451
	452	/* As a Bison extension, one can use the grammar declarations in the
	453	body of the grammar. */
	454	rules_or_grammar_declaration:
	455	rules
	456	\| grammar_declaration ";"
	457	\| error ";"
	458	{
	459	yyerrok;
	460	}
	461	;
	462
	463	rules:
	464	id_colon { current_lhs = $1; current_lhs_location = @1; } rhses.1
	465	;
	466
	467	rhses.1:
	468	rhs { grammar_current_rule_end (@1); }
	469	\| rhses.1 "\|" rhs { grammar_current_rule_end (@3); }
	470	\| rhses.1 ";"
	471	;
	472
	473	rhs:
	474	/* Nothing. */
	475	{ grammar_current_rule_begin (current_lhs, current_lhs_location); }
	476	\| rhs symbol
	477	{ grammar_current_rule_symbol_append ($2, @2); }
	478	\| rhs "{...}"
	479	{ grammar_current_rule_action_append ($2, @2); }
	480	\| rhs "%prec" symbol
	481	{ grammar_current_rule_prec_set ($3, @3); }
	482	\| rhs "%dprec" INT
	483	{ grammar_current_rule_dprec_set ($3, @3); }
	484	\| rhs "%merge" TYPE
	485	{ grammar_current_rule_merge_set ($3, @3); }
	486	;
	487
	488
	489	/-----------
	490	\| content. \|
	491	-----------/
	492
	493	content:
	494	STRING
	495	\| braceless
	496	;
	497
	498	/* Some content or "1" by default. */
	499	content.opt:
	500	/* Nothing. */
	501	{
	502	static char one[] = "1";
	503	$$ = one;
	504	}
	505	\| content
	506	;
	507
	508
	509	braceless:
	510	"{...}"
	511	{
	512	$1[strlen ($1) - 1] = '\n';
	513	$$ = translate_code ($1 + 1, @1);
	514	}
	515	;
	516
	517
	518	/---------------
	519	\| Identifiers. \|
	520	---------------/
	521
	522	/* Identifiers are returned as uniqstr values by the scanner.
	523	Depending on their use, we may need to make them genuine symbols. */
	524
	525	id:
	526	ID
	527	{ $$ = symbol_from_uniqstr ($1, @1); }
	528	\| CHAR
	529	{
	530	$$ = symbol_get (char_name ($1), @1);
	531	symbol_class_set ($$, token_sym, @1, false);
	532	symbol_user_token_number_set ($$, $1, @1);
	533	}
	534	;
	535
	536	id_colon:
	537	ID_COLON { $$ = symbol_from_uniqstr ($1, @1); }
	538	;
	539
	540
	541	symbol:
	542	id
	543	\| string_as_id
	544	;
	545
	546	/* A string used as an ID: quote it. */
	547	string_as_id:
	548	STRING
	549	{
	550	$$ = symbol_get (quotearg_style (c_quoting_style, $1), @1);
	551	symbol_class_set ($$, token_sym, @1, false);
	552	}
	553	;
	554
	555	epilogue.opt:
	556	/* Nothing. */
	557	\| "%%" EPILOGUE
	558	{
	559	muscle_code_grow ("epilogue", translate_code ($2, @2), @2);
	560	gram_scanner_last_string_free ();
	561	}
	562	;
	563
	564	%%
	565
	566
	567	/* Return the location of the left-hand side of a rule whose
	568	right-hand side is RHS[1] ... RHS[N]. Ignore empty nonterminals in
	569	the right-hand side, and return an empty location equal to the end
	570	boundary of RHS[0] if the right-hand side is empty. */
	571
	572	static YYLTYPE
	573	lloc_default (YYLTYPE const *rhs, int n)
	574	{
	575	int i;
	576	YYLTYPE loc;
	577
	578	/* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;".
	579	The bug is fixed in 7.4.2m, but play it safe for now. */
	580	loc.start = rhs[n].end;
	581	loc.end = rhs[n].end;
	582
	583	/* Ignore empty nonterminals the start of the the right-hand side.
	584	Do not bother to ignore them at the end of the right-hand side,
	585	since empty nonterminals have the same end as their predecessors. */
	586	for (i = 1; i <= n; i++)
	587	if (! equal_boundaries (rhs[i].start, rhs[i].end))
	588	{
	589	loc.start = rhs[i].start;
	590	break;
	591	}
	592
	593	return loc;
	594	}
	595
	596
	597	/* Add a lex-param or a parse-param (depending on TYPE) with
	598	declaration DECL and location LOC. */
	599
	600	static void
	601	add_param (char const type, char decl, location loc)
	602	{
	603	static char const alphanum[26 + 26 + 1 + 10] =
	604	"abcdefghijklmnopqrstuvwxyz"
	605	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	606	"_"
	607	"0123456789";
	608	char const *name_start = NULL;
	609	char *p;
	610
	611	/* Stop on last actual character. */
	612	for (p = decl; p[1]; p++)
	613	if ((p == decl
	614	\|\| ! memchr (alphanum, p[-1], sizeof alphanum))
	615	&& memchr (alphanum, p[0], sizeof alphanum - 10))
	616	name_start = p;
	617
	618	/* Strip the surrounding '{' and '}', and any blanks just inside
	619	the braces. */
	620	while (--p == ' ' \|\| p == '\t')
	621	continue;
	622	p[1] = '\0';
	623	while (++decl == ' ' \|\| decl == '\t')
	624	continue;
	625
	626	if (! name_start)
	627	complain_at (loc, _("missing identifier in parameter declaration"));
	628	else
	629	{
	630	char *name;
	631	size_t name_len;
	632
	633	for (name_len = 1;
	634	memchr (alphanum, name_start[name_len], sizeof alphanum);
	635	name_len++)
	636	continue;
	637
	638	name = xmalloc (name_len + 1);
	639	memcpy (name, name_start, name_len);
	640	name[name_len] = '\0';
	641	muscle_pair_list_grow (type, decl, name);
	642	free (name);
	643	}
	644
	645	gram_scanner_last_string_free ();
	646	}
	647
	648
	649	static void
	650	version_check (location const loc, char const version)
	651	{
	652	if (strverscmp (version, PACKAGE_VERSION) > 0)
	653	{
	654	complain_at (*loc, "require bison %s, but have %s",
	655	version, PACKAGE_VERSION);
	656	exit (63);
	657	}
	658	}
	659
	660	static void
	661	gram_error (location const loc, char const msg)
	662	{
	663	complain_at (*loc, "%s", msg);
	664	}
	665
	666	char const *
	667	token_name (int type)
	668	{
	669	return yytname[YYTRANSLATE (type)];
	670	}
	671
	672	static char const *
	673	char_name (char c)
	674	{
	675	if (c == '\'')
	676	return "'\\''";
	677	else
	678	{
	679	char buf[4];
	680	buf[0] = '\''; buf[1] = c; buf[2] = '\''; buf[3] = '\0';
	681	return quotearg_style (escape_quoting_style, buf);
	682	}
	683	}