logo

live-bootstrap

Mirror of <https://github.com/fosslinux/live-bootstrap>

parse-gram.y (28943B)

    

  1. // SPDX-License-Identifier: GPL-3.0-or-later
  3. /* Bison Grammar Parser                             -*- C -*-
  5.    Copyright (C) 2002-2015, 2018-2019 Free Software Foundation, Inc.
  7.    This file is part of Bison, the GNU Compiler Compiler.
  9.    This program is free software: you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation, either version 3 of the License, or
  12.    (at your option) any later version.
  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.
  19.    You should have received a copy of the GNU General Public License
  20.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22. /*
  23.  * This file is identical to the file parse-gram.y distributed with
  24.  * GNU Bison 3.4.1, except that all %printer and %destructor
  25.  * directives were removed (and this comment was added). It thus
  26.  * accepts the same grammar and produce the same actions, although it
  27.  * won't clean up things properly and it will have partially impaired
  28.  * printing.
  29.  *
  30.  * It was produced by Giovanni Mascellani <gio@debian.org> on 26th
  31.  * March 2020. Since the modifications are so trivial, no copyright is
  32.  * claimed.
  33.  */
  35. %code requires
  36. {
  37.   #include "symlist.h"
  38.   #include "symtab.h"
  39. }
  41. %code top
  42. {
  43.   /* On column 0 to please syntax-check.  */
  44. #include <config.h>
  45. }
  47. %code
  48. {
  49.   #include "system.h"
  50.   #include <errno.h>
  52.   #include "c-ctype.h"
  53.   #include "complain.h"
  54.   #include "conflicts.h"
  55.   #include "files.h"
  56.   #include "getargs.h"
  57.   #include "gram.h"
  58.   #include "named-ref.h"
  59.   #include "quotearg.h"
  60.   #include "reader.h"
  61.   #include "scan-code.h"
  62.   #include "scan-gram.h"
  63.   #include "vasnprintf.h"
  64.   #include "xmemdup0.h"
  66.   static int current_prec = 0;
  67.   static location current_lhs_loc;
  68.   static named_ref *current_lhs_named_ref;
  69.   static symbol *current_lhs_symbol;
  70.   static symbol_class current_class = unknown_sym;
  72.   /** Set the new current left-hand side symbol, possibly common
  73.    * to several right-hand side parts of rule.
  74.    */
  75.   static void current_lhs (symbol *sym, location loc, named_ref *ref);
  77.   #define YYLLOC_DEFAULT(Current, Rhs, N)         \
  78.     (Current) = lloc_default (Rhs, N)
  79.   static YYLTYPE lloc_default (YYLTYPE const *, int);
  81.   #define YY_LOCATION_PRINT(File, Loc)            \
  82.     location_print (Loc, File)
  84.   /* Strip initial '{' and final '}' (must be first and last characters).
  85.      Return the result.  */
  86.   static char *strip_braces (char *code);
  88.   /* Convert CODE by calling code_props_plain_init if PLAIN, otherwise
  89.      code_props_symbol_action_init.  Call
  90.      gram_scanner_last_string_free to release the latest string from
  91.      the scanner (should be CODE). */
  92.   static char const *translate_code (char *code, location loc, bool plain);
  94.   /* Convert CODE by calling code_props_plain_init after having
  95.      stripped the first and last characters (expected to be '{', and
  96.      '}').  Call gram_scanner_last_string_free to release the latest
  97.      string from the scanner (should be CODE). */
  98.   static char const *translate_code_braceless (char *code, location loc);
  100.   /* Handle a %error-verbose directive.  */
  101.   static void handle_error_verbose (location const *loc, char const *directive);
  103.   /* Handle a %file-prefix directive.  */
  104.   static void handle_file_prefix (location const *loc,
  105.                                   location const *dir_loc,
  106.                                   char const *directive, char const *value);
  108.   /* Handle a %name-prefix directive.  */
  109.   static void handle_name_prefix (location const *loc,
  110.                                   char const *directive, char const *value);
  112.   /* Handle a %pure-parser directive.  */
  113.   static void handle_pure_parser (location const *loc, char const *directive);
  115.   /* Handle a %require directive.  */
  116.   static void handle_require (location const *loc, char const *version);
  118.   /* Handle a %skeleton directive.  */
  119.   static void handle_skeleton (location const *loc, char const *skel);
  121.   /* Handle a %yacc directive.  */
  122.   static void handle_yacc (location const *loc, char const *directive);
  124.   static void gram_error (location const *, char const *);
  126.   /* A string that describes a char (e.g., 'a' -> "'a'").  */
  127.   static char const *char_name (char);
  129.   #define YYTYPE_INT16 int_fast16_t
  130.   #define YYTYPE_INT8 int_fast8_t
  131.   #define YYTYPE_UINT16 uint_fast16_t
  132.   #define YYTYPE_UINT8 uint_fast8_t
  134.   /* Add style to semantic values in traces.  */
  135.   static void tron (FILE *yyo);
  136.   static void troff (FILE *yyo);
  137. }
  139. %define api.header.include {"parse-gram.h"}
  140. %define api.prefix {gram_}
  141. %define api.pure full
  142. %define api.value.type union
  143. %define locations
  144. %define parse.error verbose
  145. %define parse.lac full
  146. %define parse.trace
  147. %defines
  148. %expect 0
  149. %verbose
  151. %initial-action
  152. {
  153.   /* Bison's grammar can initial empty locations, hence a default
  154.      location is needed. */
  155.   boundary_set (&@$.start, current_file, 1, 1, 1);
  156.   boundary_set (&@$.end, current_file, 1, 1, 1);
  157. }
  159. /* Define the tokens together with their human representation.  */
  160. %token GRAM_EOF 0 "end of file"
  161. %token STRING     "string"
  163. %token PERCENT_TOKEN       "%token"
  164. %token PERCENT_NTERM       "%nterm"
  166. %token PERCENT_TYPE        "%type"
  167. %token PERCENT_DESTRUCTOR  "%destructor"
  168. %token PERCENT_PRINTER     "%printer"
  170. %token PERCENT_LEFT        "%left"
  171. %token PERCENT_RIGHT       "%right"
  172. %token PERCENT_NONASSOC    "%nonassoc"
  173. %token PERCENT_PRECEDENCE  "%precedence"
  175. %token PERCENT_PREC          "%prec"
  176. %token PERCENT_DPREC         "%dprec"
  177. %token PERCENT_MERGE         "%merge"
  179. /*----------------------.
  180. | Global Declarations.  |
  181. `----------------------*/
  183. %token
  184.   PERCENT_CODE            "%code"
  185.   PERCENT_DEFAULT_PREC    "%default-prec"
  186.   PERCENT_DEFINE          "%define"
  187.   PERCENT_DEFINES         "%defines"
  188.   PERCENT_ERROR_VERBOSE   "%error-verbose"
  189.   PERCENT_EXPECT          "%expect"
  190.   PERCENT_EXPECT_RR       "%expect-rr"
  191.   PERCENT_FLAG            "%<flag>"
  192.   PERCENT_FILE_PREFIX     "%file-prefix"
  193.   PERCENT_GLR_PARSER      "%glr-parser"
  194.   PERCENT_INITIAL_ACTION  "%initial-action"
  195.   PERCENT_LANGUAGE        "%language"
  196.   PERCENT_NAME_PREFIX     "%name-prefix"
  197.   PERCENT_NO_DEFAULT_PREC "%no-default-prec"
  198.   PERCENT_NO_LINES        "%no-lines"
  199.   PERCENT_NONDETERMINISTIC_PARSER
  200.                           "%nondeterministic-parser"
  201.   PERCENT_OUTPUT          "%output"
  202.   PERCENT_PURE_PARSER     "%pure-parser"
  203.   PERCENT_REQUIRE         "%require"
  204.   PERCENT_SKELETON        "%skeleton"
  205.   PERCENT_START           "%start"
  206.   PERCENT_TOKEN_TABLE     "%token-table"
  207.   PERCENT_VERBOSE         "%verbose"
  208.   PERCENT_YACC            "%yacc"
  209. ;
  211. %token BRACED_CODE     "{...}"
  212. %token BRACED_PREDICATE "%?{...}"
  213. %token BRACKETED_ID    "[identifier]"
  214. %token CHAR            "char"
  215. %token COLON           ":"
  216. %token EPILOGUE        "epilogue"
  217. %token EQUAL           "="
  218. %token ID              "identifier"
  219. %token ID_COLON        "identifier:"
  220. %token PERCENT_PERCENT "%%"
  221. %token PIPE            "|"
  222. %token PROLOGUE        "%{...%}"
  223. %token SEMICOLON       ";"
  224. %token TAG             "<tag>"
  225. %token TAG_ANY         "<*>"
  226. %token TAG_NONE        "<>"
  228.  /* Experimental feature, don't rely on it.  */
  229. %code pre-printer  {tron (yyo);}
  230. %code post-printer {troff (yyo);}
  232. %type <unsigned char> CHAR
  234. %type <char*> "{...}" "%?{...}" "%{...%}" EPILOGUE STRING
  236. %type <uniqstr>
  237.   BRACKETED_ID ID ID_COLON
  238.   PERCENT_ERROR_VERBOSE PERCENT_FILE_PREFIX PERCENT_FLAG PERCENT_NAME_PREFIX
  239.   PERCENT_PURE_PARSER PERCENT_YACC
  240.   TAG tag tag.opt variable
  242. %token <int> INT "integer"
  244. %type <symbol*> id id_colon string_as_id symbol token_decl token_decl_for_prec
  246. %type <assoc> precedence_declarator
  248. %type <named_ref*> named_ref.opt
  250. /*---------.
  251. | %param.  |
  252. `---------*/
  253. %code requires
  254. {
  255.   typedef enum
  256.   {
  257.     param_none   = 0,
  258.     param_lex    = 1 << 0,
  259.     param_parse  = 1 << 1,
  260.     param_both   = param_lex | param_parse
  261.   } param_type;
  262. };
  263. %code
  264. {
  265.   /** Add a lex-param and/or a parse-param.
  266.    *
  267.    * \param type  where to push this formal argument.
  268.    * \param decl  the formal argument.  Destroyed.
  269.    * \param loc   the location in the source.
  270.    */
  271.   static void add_param (param_type type, char *decl, location loc);
  272.   static param_type current_param = param_none;
  273. };
  274. %token <param_type> PERCENT_PARAM "%param";
  277.                      /*==========\
  278.                      | Grammar.  |
  279.                      \==========*/
  280. %%
  282. input:
  283.   prologue_declarations "%%" grammar epilogue.opt
  284. ;
  287.         /*------------------------------------.
  288.         | Declarations: before the first %%.  |
  289.         `------------------------------------*/
  291. prologue_declarations:
  292.   %empty
  293. | prologue_declarations prologue_declaration
  294. ;
  296. prologue_declaration:
  297.   grammar_declaration
  298. | "%{...%}"
  299.     {
  300.       muscle_code_grow (union_seen ? "post_prologue" : "pre_prologue",
  301.                         translate_code ($1, @1, true), @1);
  302.       code_scanner_last_string_free ();
  303.     }
  304. | "%<flag>"
  305.     {
  306.       muscle_percent_define_ensure ($1, @1, true);
  307.     }
  308. | "%define" variable value
  309.     {
  310.       muscle_percent_define_insert ($2, @$, $3.kind, $3.chars,
  311.                                     MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
  312.     }
  313. | "%defines"                       { defines_flag = true; }
  314. | "%defines" STRING
  315.     {
  316.       defines_flag = true;
  317.       spec_header_file = xstrdup ($2);
  318.     }
  319. | "%error-verbose"                 { handle_error_verbose (&@$, $1); }
  320. | "%expect" INT                    { expected_sr_conflicts = $2; }
  321. | "%expect-rr" INT                 { expected_rr_conflicts = $2; }
  322. | "%file-prefix" STRING            { handle_file_prefix (&@$, &@1, $1, $2); }
  323. | "%glr-parser"
  324.     {
  325.       nondeterministic_parser = true;
  326.       glr_parser = true;
  327.     }
  328. | "%initial-action" "{...}"
  329.     {
  330.       muscle_code_grow ("initial_action", translate_code ($2, @2, false), @2);
  331.       code_scanner_last_string_free ();
  332.     }
  333. | "%language" STRING            { language_argmatch ($2, grammar_prio, @1); }
  334. | "%name-prefix" STRING         { handle_name_prefix (&@$, $1, $2); }
  335. | "%no-lines"                   { no_lines_flag = true; }
  336. | "%nondeterministic-parser"    { nondeterministic_parser = true; }
  337. | "%output" STRING              { spec_outfile = $2; }
  338. | "%param" { current_param = $1; } params { current_param = param_none; }
  339. | "%pure-parser"                { handle_pure_parser (&@$, $1); }
  340. | "%require" STRING             { handle_require (&@2, $2); }
  341. | "%skeleton" STRING            { handle_skeleton (&@2, $2); }
  342. | "%token-table"                { token_table_flag = true; }
  343. | "%verbose"                    { report_flag |= report_states; }
  344. | "%yacc"                       { handle_yacc (&@$, $1); }
  345. | error ";"                     { current_class = unknown_sym; yyerrok; }
  346. | /*FIXME: Err?  What is this horror doing here? */ ";"
  347. ;
  349. params:
  350.    params "{...}"  { add_param (current_param, $2, @2); }
  351. | "{...}"          { add_param (current_param, $1, @1); }
  352. ;
  355. /*----------------------.
  356. | grammar_declaration.  |
  357. `----------------------*/
  359. grammar_declaration:
  360.   symbol_declaration
  361. | "%start" symbol
  362.     {
  363.       grammar_start_symbol_set ($2, @2);
  364.     }
  365. | code_props_type "{...}" generic_symlist
  366.     {
  367.       code_props code;
  368.       code_props_symbol_action_init (&code, $2, @2);
  369.       code_props_translate_code (&code);
  370.       {
  371.         for (symbol_list *list = $3; list; list = list->next)
  372.           symbol_list_code_props_set (list, $1, &code);
  373.         symbol_list_free ($3);
  374.       }
  375.     }
  376. | "%default-prec"
  377.     {
  378.       default_prec = true;
  379.     }
  380. | "%no-default-prec"
  381.     {
  382.       default_prec = false;
  383.     }
  384. | "%code" "{...}"
  385.     {
  386.       /* Do not invoke muscle_percent_code_grow here since it invokes
  387.          muscle_user_name_list_grow.  */
  388.       muscle_code_grow ("percent_code()",
  389.                         translate_code_braceless ($2, @2), @2);
  390.       code_scanner_last_string_free ();
  391.     }
  392. | "%code" ID "{...}"
  393.     {
  394.       muscle_percent_code_grow ($2, @2, translate_code_braceless ($3, @3), @3);
  395.       code_scanner_last_string_free ();
  396.     }
  397. ;
  399. %type <code_props_type> code_props_type;
  400. code_props_type:
  401.   "%destructor"  { $$ = destructor; }
  402. | "%printer"     { $$ = printer; }
  403. ;
  405. /*---------.
  406. | %union.  |
  407. `---------*/
  409. %token PERCENT_UNION "%union";
  411. union_name:
  412.   %empty {}
  413. | ID     { muscle_percent_define_insert ("api.value.union.name",
  414.                                          @1, muscle_keyword, $1,
  415.                                          MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE); }
  416. ;
  418. grammar_declaration:
  419.   "%union" union_name "{...}"
  420.     {
  421.       union_seen = true;
  422.       muscle_code_grow ("union_members", translate_code_braceless ($3, @3), @3);
  423.       code_scanner_last_string_free ();
  424.     }
  425. ;
  428. %type <symbol_list*> nterm_decls symbol_decls symbol_decl.1
  429.       token_decls token_decls_for_prec
  430.       token_decl.1 token_decl_for_prec.1;
  431. symbol_declaration:
  432.   "%nterm" { current_class = nterm_sym; } nterm_decls[syms]
  433.     {
  434.       current_class = unknown_sym;
  435.       symbol_list_free ($syms);
  436.     }
  437. | "%token" { current_class = token_sym; } token_decls[syms]
  438.     {
  439.       current_class = unknown_sym;
  440.       symbol_list_free ($syms);
  441.     }
  442. | "%type" symbol_decls[syms]
  443.     {
  444.       symbol_list_free ($syms);
  445.     }
  446. | precedence_declarator token_decls_for_prec[syms]
  447.     {
  448.       ++current_prec;
  449.       for (symbol_list *list = $syms; list; list = list->next)
  450.         symbol_precedence_set (list->content.sym, current_prec, $1, @1);
  451.       symbol_list_free ($syms);
  452.     }
  453. ;
  455. precedence_declarator:
  456.   "%left"       { $$ = left_assoc; }
  457. | "%right"      { $$ = right_assoc; }
  458. | "%nonassoc"   { $$ = non_assoc; }
  459. | "%precedence" { $$ = precedence_assoc; }
  460. ;
  462. tag.opt:
  463.   %empty { $$ = NULL; }
  464. | TAG    { $$ = $1; }
  465. ;
  467. %type <symbol_list*> generic_symlist generic_symlist_item;
  468. generic_symlist:
  469.   generic_symlist_item
  470. | generic_symlist generic_symlist_item   { $$ = symbol_list_append ($1, $2); }
  471. ;
  473. generic_symlist_item:
  474.   symbol    { $$ = symbol_list_sym_new ($1, @1); }
  475. | tag       { $$ = symbol_list_type_new ($1, @1); }
  476. ;
  478. tag:
  479.   TAG
  480. | "<*>" { $$ = uniqstr_new ("*"); }
  481. | "<>"  { $$ = uniqstr_new (""); }
  482. ;
  484. /*-----------------------.
  485. | nterm_decls (%nterm).  |
  486. `-----------------------*/
  488. // A non empty list of possibly tagged symbols for %nterm.
  489. //
  490. // Can easily be defined like symbol_decls but restricted to ID, but
  491. // using token_decls allows to reudce the number of rules, and also to
  492. // make nicer error messages on "%nterm 'a'" or '%nterm FOO "foo"'.
  493. nterm_decls:
  494.   token_decls
  495. ;
  497. /*-----------------------------------.
  498. | token_decls (%token, and %nterm).  |
  499. `-----------------------------------*/
  501. // A non empty list of possibly tagged symbols for %token or %nterm.
  502. token_decls:
  503.   token_decl.1[syms]
  504.     {
  505.       $$ = $syms;
  506.     }
  507. | TAG token_decl.1[syms]
  508.     {
  509.       $$ = symbol_list_type_set ($syms, $TAG, @TAG);
  510.     }
  511. | token_decls TAG token_decl.1[syms]
  512.     {
  513.       $$ = symbol_list_append ($1, symbol_list_type_set ($syms, $TAG, @TAG));
  514.     }
  515. ;
  517. // One or more symbol declarations for %token or %nterm.
  518. token_decl.1:
  519.   token_decl                { $$ = symbol_list_sym_new ($1, @1); }
  520. | token_decl.1 token_decl   { $$ = symbol_list_append ($1, symbol_list_sym_new ($2, @2)); }
  522. // One symbol declaration for %token or %nterm.
  523. token_decl:
  524.   id int.opt[num] string_as_id.opt[alias]
  525.     {
  526.       $$ = $id;
  527.       symbol_class_set ($id, current_class, @id, true);
  528.       if (0 <= $num)
  529.         symbol_user_token_number_set ($id, $num, @num);
  530.       if ($alias)
  531.         symbol_make_alias ($id, $alias, @alias);
  532.     }
  533. ;
  535. %type <int> int.opt;
  536. int.opt:
  537.   %empty  { $$ = -1; }
  538. | INT
  539. ;
  541. /*-------------------------------------.
  542. | token_decls_for_prec (%left, etc.).  |
  543. `-------------------------------------*/
  545. // A non empty list of possibly tagged tokens for precedence declaration.
  546. //
  547. // Similar to %token (token_decls), but in '%left FOO 1 "foo"', it treats
  548. // FOO and "foo" as two different symbols instead of aliasing them.
  549. token_decls_for_prec:
  550.   token_decl_for_prec.1[syms]
  551.     {
  552.       $$ = $syms;
  553.     }
  554. | TAG token_decl_for_prec.1[syms]
  555.     {
  556.       $$ = symbol_list_type_set ($syms, $TAG, @TAG);
  557.     }
  558. | token_decls_for_prec TAG token_decl_for_prec.1[syms]
  559.     {
  560.       $$ = symbol_list_append ($1, symbol_list_type_set ($syms, $TAG, @TAG));
  561.     }
  562. ;
  564. // One or more token declarations for precedence declaration.
  565. token_decl_for_prec.1:
  566.   token_decl_for_prec
  567.     { $$ = symbol_list_sym_new ($1, @1); }
  568. | token_decl_for_prec.1 token_decl_for_prec
  569.     { $$ = symbol_list_append ($1, symbol_list_sym_new ($2, @2)); }
  571. // One token declaration for precedence declaration.
  572. token_decl_for_prec:
  573.   id int.opt[num]
  574.     {
  575.       $$ = $id;
  576.       symbol_class_set ($id, token_sym, @id, false);
  577.       if (0 <= $num)
  578.         symbol_user_token_number_set ($id, $num, @num);
  579.     }
  580. | string_as_id
  581. ;
  584. /*-----------------------.
  585. | symbol_decls (%type).  |
  586. `-----------------------*/
  588. // A non empty list of typed symbols.
  589. symbol_decls:
  590.   symbol_decl.1[syms]
  591.     {
  592.       $$ = $syms;
  593.     }
  594. | TAG symbol_decl.1[syms]
  595.     {
  596.       $$ = symbol_list_type_set ($syms, $TAG, @TAG);
  597.     }
  598. | symbol_decls TAG symbol_decl.1[syms]
  599.     {
  600.       $$ = symbol_list_append ($1, symbol_list_type_set ($syms, $TAG, @TAG));
  601.     }
  602. ;
  604. // One or more token declarations.
  605. symbol_decl.1:
  606.   symbol                { $$ = symbol_list_sym_new ($1, @1); }
  607. | symbol_decl.1 symbol  { $$ = symbol_list_append ($1, symbol_list_sym_new ($2, @2)); }
  608. ;
  610.         /*------------------------------------------.
  611.         | The grammar section: between the two %%.  |
  612.         `------------------------------------------*/
  614. grammar:
  615.   rules_or_grammar_declaration
  616. | grammar rules_or_grammar_declaration
  617. ;
  619. /* As a Bison extension, one can use the grammar declarations in the
  620.    body of the grammar.  */
  621. rules_or_grammar_declaration:
  622.   rules
  623. | grammar_declaration ";"
  624. | error ";"
  625.     {
  626.       yyerrok;
  627.     }
  628. ;
  630. rules:
  631.   id_colon named_ref.opt { current_lhs ($1, @1, $2); } ":" rhses.1
  632.     {
  633.       /* Free the current lhs. */
  634.       current_lhs (0, @1, 0);
  635.     }
  636. ;
  638. rhses.1:
  639.   rhs                { grammar_current_rule_end (@rhs); }
  640. | rhses.1 "|" rhs    { grammar_current_rule_end (@rhs); }
  641. | rhses.1 ";"
  642. ;
  644. %token PERCENT_EMPTY "%empty";
  645. rhs:
  646.   %empty
  647.     { grammar_current_rule_begin (current_lhs_symbol, current_lhs_loc,
  648.                                   current_lhs_named_ref); }
  649. | rhs symbol named_ref.opt
  650.     { grammar_current_rule_symbol_append ($2, @2, $3); }
  651. | rhs tag.opt "{...}"[act] named_ref.opt[name]
  652.     { grammar_current_rule_action_append ($act, @act, $name, $[tag.opt]); }
  653. | rhs "%?{...}"
  654.     { grammar_current_rule_predicate_append ($2, @2); }
  655. | rhs "%empty"
  656.     { grammar_current_rule_empty_set (@2); }
  657. | rhs "%prec" symbol
  658.     { grammar_current_rule_prec_set ($3, @3); }
  659. | rhs "%dprec" INT
  660.     { grammar_current_rule_dprec_set ($3, @3); }
  661. | rhs "%merge" TAG
  662.     { grammar_current_rule_merge_set ($3, @3); }
  663. | rhs "%expect" INT
  664.     { grammar_current_rule_expect_sr ($3, @3); }
  665. | rhs "%expect-rr" INT
  666.     { grammar_current_rule_expect_rr ($3, @3); }
  667. ;
  669. named_ref.opt:
  670.   %empty         { $$ = NULL; }
  671. | BRACKETED_ID   { $$ = named_ref_new ($1, @1); }
  672. ;
  675. /*---------------------.
  676. | variable and value.  |
  677. `---------------------*/
  679. variable:
  680.   ID
  681. ;
  683. /* Some content or empty by default. */
  684. %code requires {
  685.   #include "muscle-tab.h"
  686.   typedef struct
  687.   {
  688.     char const *chars;
  689.     muscle_kind kind;
  690.   } value_type;
  691. };
  692. %type <value_type> value;
  694. value:
  695.   %empty  { $$.kind = muscle_keyword; $$.chars = ""; }
  696. | ID      { $$.kind = muscle_keyword; $$.chars = $1; }
  697. | STRING  { $$.kind = muscle_string;  $$.chars = $1; }
  698. | "{...}" { $$.kind = muscle_code;    $$.chars = strip_braces ($1); }
  699. ;
  702. /*--------------.
  703. | Identifiers.  |
  704. `--------------*/
  706. /* Identifiers are returned as uniqstr values by the scanner.
  707.    Depending on their use, we may need to make them genuine symbols.  */
  709. id:
  710.   ID
  711.     { $$ = symbol_from_uniqstr ($1, @1); }
  712. | CHAR
  713.     {
  714.       if (current_class == nterm_sym)
  715.         {
  716.           gram_error (&@1,
  717.                       _("character literals cannot be nonterminals"));
  718.           YYERROR;
  719.         }
  720.       $$ = symbol_get (char_name ($1), @1);
  721.       symbol_class_set ($$, token_sym, @1, false);
  722.       symbol_user_token_number_set ($$, $1, @1);
  723.     }
  724. ;
  726. id_colon:
  727.   ID_COLON { $$ = symbol_from_uniqstr ($1, @1); }
  728. ;
  731. symbol:
  732.   id
  733. | string_as_id
  734. ;
  736. /* A string used as an ID: quote it.  */
  737. string_as_id:
  738.   STRING
  739.     {
  740.       $$ = symbol_get (quotearg_style (c_quoting_style, $1), @1);
  741.       symbol_class_set ($$, token_sym, @1, false);
  742.     }
  743. ;
  745. %type <symbol*> string_as_id.opt;
  746. string_as_id.opt:
  747.   %empty             { $$ = NULL; }
  748. | string_as_id
  749. ;
  751. epilogue.opt:
  752.   %empty
  753. | "%%" EPILOGUE
  754.     {
  755.       muscle_code_grow ("epilogue", translate_code ($2, @2, true), @2);
  756.       code_scanner_last_string_free ();
  757.     }
  758. ;
  760. %%
  762. /* Return the location of the left-hand side of a rule whose
  763.    right-hand side is RHS[1] ... RHS[N].  Ignore empty nonterminals in
  764.    the right-hand side, and return an empty location equal to the end
  765.    boundary of RHS[0] if the right-hand side is empty.  */
  767. static YYLTYPE
  768. lloc_default (YYLTYPE const *rhs, int n)
  769. {
  770.   YYLTYPE loc;
  772.   /* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;".
  773.      The bug is fixed in 7.4.2m, but play it safe for now.  */
  774.   loc.start = rhs[n].end;
  775.   loc.end = rhs[n].end;
  777.   /* Ignore empty nonterminals the start of the right-hand side.
  778.      Do not bother to ignore them at the end of the right-hand side,
  779.      since empty nonterminals have the same end as their predecessors.  */
  780.   for (int i = 1; i <= n; i++)
  781.     if (! equal_boundaries (rhs[i].start, rhs[i].end))
  782.       {
  783.         loc.start = rhs[i].start;
  784.         break;
  785.       }
  787.   return loc;
  788. }
  790. static
  791. char *strip_braces (char *code)
  792. {
  793.   code[strlen (code) - 1] = 0;
  794.   return code + 1;
  795. }
  797. static
  798. char const *
  799. translate_code (char *code, location loc, bool plain)
  800. {
  801.   code_props plain_code;
  802.   if (plain)
  803.     code_props_plain_init (&plain_code, code, loc);
  804.   else
  805.     code_props_symbol_action_init (&plain_code, code, loc);
  806.   code_props_translate_code (&plain_code);
  807.   gram_scanner_last_string_free ();
  808.   return plain_code.code;
  809. }
  811. static
  812. char const *
  813. translate_code_braceless (char *code, location loc)
  814. {
  815.   return translate_code (strip_braces (code), loc, true);
  816. }
  818. static void
  819. add_param (param_type type, char *decl, location loc)
  820. {
  821.   static char const alphanum[26 + 26 + 1 + 10 + 1] =
  822.     "abcdefghijklmnopqrstuvwxyz"
  823.     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  824.     "_"
  825.     "0123456789";
  827.   char const *name_start = NULL;
  828.   {
  829.     char *p;
  830.     /* Stop on last actual character.  */
  831.     for (p = decl; p[1]; p++)
  832.       if ((p == decl
  833.            || ! memchr (alphanum, p[-1], sizeof alphanum - 1))
  834.           && memchr (alphanum, p[0], sizeof alphanum - 10 - 1))
  835.         name_start = p;
  837.     /* Strip the surrounding '{' and '}', and any blanks just inside
  838.        the braces.  */
  839.     --p;
  840.     while (c_isspace ((unsigned char) *p))
  841.       --p;
  842.     p[1] = '\0';
  843.     ++decl;
  844.     while (c_isspace ((unsigned char) *decl))
  845.       ++decl;
  846.   }
  848.   if (! name_start)
  849.     complain (&loc, complaint, _("missing identifier in parameter declaration"));
  850.   else
  851.     {
  852.       char *name = xmemdup0 (name_start, strspn (name_start, alphanum));
  853.       if (type & param_lex)
  854.         muscle_pair_list_grow ("lex_param", decl, name);
  855.       if (type & param_parse)
  856.         muscle_pair_list_grow ("parse_param", decl, name);
  857.       free (name);
  858.     }
  860.   gram_scanner_last_string_free ();
  861. }
  864. static void
  865. handle_error_verbose (location const *loc, char const *directive)
  866. {
  867.   bison_directive (loc, directive);
  868.   muscle_percent_define_insert (directive, *loc, muscle_keyword, "",
  869.                                 MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
  870. }
  873. static void
  874. handle_file_prefix (location const *loc,
  875.                     location const *dir_loc,
  876.                     char const *directive, char const *value)
  877. {
  878.   bison_directive (loc, directive);
  879.   bool warned = false;
  881.   if (location_empty (spec_file_prefix_loc))
  882.     {
  883.       spec_file_prefix_loc = *loc;
  884.       spec_file_prefix = value;
  885.     }
  886.   else
  887.     {
  888.       duplicate_directive (directive, spec_file_prefix_loc, *loc);
  889.       warned = true;
  890.     }
  892.   if (!warned
  893.       && STRNEQ (directive, "%file-prefix"))
  894.     deprecated_directive (dir_loc, directive, "%file-prefix");
  895. }
  898. static void
  899. handle_name_prefix (location const *loc,
  900.                     char const *directive, char const *value)
  901. {
  902.   bison_directive (loc, directive);
  904.   char buf1[1024];
  905.   size_t len1 = sizeof (buf1);
  906.   char *old = asnprintf (buf1, &len1, "%s\"%s\"", directive, value);
  907.   if (!old)
  908.     xalloc_die ();
  910.   if (location_empty (spec_name_prefix_loc))
  911.     {
  912.       spec_name_prefix = value;
  913.       spec_name_prefix_loc = *loc;
  915.       char buf2[1024];
  916.       size_t len2 = sizeof (buf2);
  917.       char *new = asnprintf (buf2, &len2, "%%define api.prefix {%s}", value);
  918.       if (!new)
  919.         xalloc_die ();
  920.       deprecated_directive (loc, old, new);
  921.       if (new != buf2)
  922.         free (new);
  923.     }
  924.   else
  925.     duplicate_directive (old, spec_file_prefix_loc, *loc);
  927.   if (old != buf1)
  928.     free (old);
  929. }
  932. static void
  933. handle_pure_parser (location const *loc, char const *directive)
  934. {
  935.   bison_directive (loc, directive);
  936.   deprecated_directive (loc, directive, "%define api.pure");
  937.   muscle_percent_define_insert ("api.pure", *loc, muscle_keyword, "",
  938.                                 MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
  939. }
  942. static void
  943. handle_require (location const *loc, char const *version)
  944. {
  945.   /* Changes of behavior are only on minor version changes, so "3.0.5"
  946.      is the same as "3.0". */
  947.   errno = 0;
  948.   char* cp = NULL;
  949.   unsigned long major = strtoul (version, &cp, 10);
  950.   if (errno || *cp != '.')
  951.     {
  952.       complain (loc, complaint, _("invalid version requirement: %s"),
  953.                 version);
  954.       return;
  955.     }
  956.   ++cp;
  957.   unsigned long minor = strtoul (cp, NULL, 10);
  958.   if (errno)
  959.     {
  960.       complain (loc, complaint, _("invalid version requirement: %s"),
  961.                 version);
  962.       return;
  963.     }
  964.   required_version = major * 100 + minor;
  965.   /* Pretend to be at least 3.4, to check features published in 3.4
  966.      while developping it.  */
  967.   const char* api_version = "3.4";
  968.   const char* package_version =
  969.     strverscmp (api_version, PACKAGE_VERSION) > 0
  970.     ? api_version : PACKAGE_VERSION;
  971.   if (strverscmp (version, package_version) > 0)
  972.     {
  973.       complain (loc, complaint, _("require bison %s, but have %s"),
  974.                 version, package_version);
  975.       exit (EX_MISMATCH);
  976.     }
  977. }
  979. static void
  980. handle_skeleton (location const *loc, char const *skel)
  981. {
  982.   char const *skeleton_user = skel;
  983.   if (strchr (skeleton_user, '/'))
  984.     {
  985.       size_t dir_length = strlen (current_file);
  986.       while (dir_length && current_file[dir_length - 1] != '/')
  987.         --dir_length;
  988.       while (dir_length && current_file[dir_length - 1] == '/')
  989.         --dir_length;
  990.       char *skeleton_build =
  991.         xmalloc (dir_length + 1 + strlen (skeleton_user) + 1);
  992.       if (dir_length > 0)
  993.         {
  994.           memcpy (skeleton_build, current_file, dir_length);
  995.           skeleton_build[dir_length++] = '/';
  996.         }
  997.       strcpy (skeleton_build + dir_length, skeleton_user);
  998.       skeleton_user = uniqstr_new (skeleton_build);
  999.       free (skeleton_build);
  1000.     }
  1001.   skeleton_arg (skeleton_user, grammar_prio, *loc);
  1002. }
  1005. static void
  1006. handle_yacc (location const *loc, char const *directive)
  1007. {
  1008.   bison_directive (loc, directive);
  1009.   bool warned = false;
  1011.   if (location_empty (yacc_loc))
  1012.     yacc_loc = *loc;
  1013.   else
  1014.     {
  1015.       duplicate_directive (directive, yacc_loc, *loc);
  1016.       warned = true;
  1017.     }
  1019.   if (!warned
  1020.       && STRNEQ (directive, "%fixed-output-files")
  1021.       && STRNEQ (directive, "%yacc"))
  1022.     deprecated_directive (loc, directive, "%fixed-output-files");
  1023. }
  1026. static void
  1027. gram_error (location const *loc, char const *msg)
  1028. {
  1029.   complain (loc, complaint, "%s", msg);
  1030. }
  1032. static char const *
  1033. char_name (char c)
  1034. {
  1035.   if (c == '\'')
  1036.     return "'\\''";
  1037.   else
  1038.     {
  1039.       char buf[4];
  1040.       buf[0] = '\''; buf[1] = c; buf[2] = '\''; buf[3] = '\0';
  1041.       return quotearg_style (escape_quoting_style, buf);
  1042.     }
  1043. }
  1045. static
  1046. void
  1047. current_lhs (symbol *sym, location loc, named_ref *ref)
  1048. {
  1049.   current_lhs_symbol = sym;
  1050.   current_lhs_loc = loc;
  1051.   if (sym)
  1052.     symbol_location_as_lhs_set (sym, loc);
  1053.   /* In order to simplify memory management, named references for lhs
  1054.      are always assigned by deep copy into the current symbol_list
  1055.      node.  This is because a single named-ref in the grammar may
  1056.      result in several uses when the user factors lhs between several
  1057.      rules using "|".  Therefore free the parser's original copy.  */
  1058.   free (current_lhs_named_ref);
  1059.   current_lhs_named_ref = ref;
  1060. }
  1062. static void tron (FILE *yyo)
  1063. {
  1064.   begin_use_class ("value", yyo);
  1065. }
  1067. static void troff (FILE *yyo)
  1068. {
  1069.   end_use_class ("value", yyo);
  1070. }