logo

live-bootstrap

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

parse-gram.c (29442B)

    

  1. // SPDX-License-Identifier: GPL-3.0-or-later
  3. /*
  4.  * This file is based on parse-gram.y from GNU Bison 3.4.1. It
  5.  * implements a subset of the grammar described by parse-gram.y, just
  6.  * enough to provide a bootstrapping path for Bison.
  7.  *
  8.  * Copyright (c) 2020, Giovanni Mascellani <gio@debian.org>
  9.  *
  10.  * The copyright notice of the original file follows. This file is
  11.  * distributed under the same license and with the same conditions.
  12.  */
  14. /* Bison Grammar Parser                             -*- C -*-
  16.    Copyright (C) 2002-2015, 2018-2019 Free Software Foundation, Inc.
  18.    This file is part of Bison, the GNU Compiler Compiler.
  20.    This program is free software: you can redistribute it and/or modify
  21.    it under the terms of the GNU General Public License as published by
  22.    the Free Software Foundation, either version 3 of the License, or
  23.    (at your option) any later version.
  25.    This program is distributed in the hope that it will be useful,
  26.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.    GNU General Public License for more details.
  30.    You should have received a copy of the GNU General Public License
  31.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  33. /*
  34.  * Since this code is intended to provide a bootstrapping path for GNU
  35.  * Bison, it is important that it is as easy to understand as
  36.  * possible. Fortunately Bison's grammar is rather simple. I believe
  37.  * that if you know how Bison works, you should not find it hard to
  38.  * follow the logic in this file and compare it with the original
  39.  * grammar.
  40.  *
  41.  * Apart from the code literally copied from the grammar file
  42.  * (prologues and epilogue), this file basically contains a few
  43.  * wrappers over the lexer interface (the functions gram_*), basically
  44.  * adding the feature to give back one lexeme and a lot of functions
  45.  * parse_* or maybe_parse_*, parsing the corresponding grammar
  46.  * rule. Functions maybe_parse_* are allowed to fail, and return
  47.  * accordingly.
  48.  *
  49.  * Error checking is very simple and just made of assertions. This is
  50.  * just boostrapping code, not meant for end users, so it should not
  51.  * be a problem.
  52.  */
  54. /* %code top */
  55.   /* On column 0 to please syntax-check.  */
  56. #include <config.h>
  58. #include <assert.h>
  60. #define YYLTYPE GRAM_LTYPE
  62. #include "parse-gram.h"
  64. /* %code */
  65.   #include "system.h"
  66.   #include <errno.h>
  68.   #include "c-ctype.h"
  69.   #include "complain.h"
  70.   #include "conflicts.h"
  71.   #include "files.h"
  72.   #include "getargs.h"
  73.   #include "gram.h"
  74.   #include "named-ref.h"
  75.   #include "quotearg.h"
  76.   #include "reader.h"
  77.   #include "scan-code.h"
  78.   #include "scan-gram.h"
  79.   #include "vasnprintf.h"
  80.   #include "xmemdup0.h"
  82.   static int current_prec = 0;
  83.   static location current_lhs_loc;
  84.   static named_ref *current_lhs_named_ref;
  85.   static symbol *current_lhs_symbol;
  86.   static symbol_class current_class = unknown_sym;
  88.   /** Set the new current left-hand side symbol, possibly common
  89.    * to several right-hand side parts of rule.
  90.    */
  91.   static void current_lhs (symbol *sym, location loc, named_ref *ref);
  93.   #define YYLLOC_DEFAULT(Current, Rhs, N)         \
  94.     (Current) = lloc_default (Rhs, N)
  95.   static YYLTYPE lloc_default (YYLTYPE const *, int);
  97.   #define YY_LOCATION_PRINT(File, Loc)            \
  98.     location_print (Loc, File)
  100.   /* Strip initial '{' and final '}' (must be first and last characters).
  101.      Return the result.  */
  102.   static char *strip_braces (char *code);
  104.   /* Convert CODE by calling code_props_plain_init if PLAIN, otherwise
  105.      code_props_symbol_action_init.  Call
  106.      gram_scanner_last_string_free to release the latest string from
  107.      the scanner (should be CODE). */
  108.   static char const *translate_code (char *code, location loc, bool plain);
  110.   /* Convert CODE by calling code_props_plain_init after having
  111.      stripped the first and last characters (expected to be '{', and
  112.      '}').  Call gram_scanner_last_string_free to release the latest
  113.      string from the scanner (should be CODE). */
  114.   static char const *translate_code_braceless (char *code, location loc);
  116.   /* Handle a %error-verbose directive.  */
  117.   static void handle_error_verbose (location const *loc, char const *directive);
  119.   /* Handle a %file-prefix directive.  */
  120.   static void handle_file_prefix (location const *loc,
  121.                                   location const *dir_loc,
  122.                                   char const *directive, char const *value);
  124.   /* Handle a %name-prefix directive.  */
  125.   static void handle_name_prefix (location const *loc,
  126.                                   char const *directive, char const *value);
  128.   /* Handle a %pure-parser directive.  */
  129.   static void handle_pure_parser (location const *loc, char const *directive);
  131.   /* Handle a %require directive.  */
  132.   static void handle_require (location const *loc, char const *version);
  134.   /* Handle a %skeleton directive.  */
  135.   static void handle_skeleton (location const *loc, char const *skel);
  137.   /* Handle a %yacc directive.  */
  138.   static void handle_yacc (location const *loc, char const *directive);
  140.   static void gram_error (location const *, char const *);
  142.   /* A string that describes a char (e.g., 'a' -> "'a'").  */
  143.   static char const *char_name (char);
  145.   #define YYTYPE_INT16 int_fast16_t
  146.   #define YYTYPE_INT8 int_fast8_t
  147.   #define YYTYPE_UINT16 uint_fast16_t
  148.   #define YYTYPE_UINT8 uint_fast8_t
  150.   /* Add style to semantic values in traces.  */
  151.   static void tron (FILE *yyo);
  152.   static void troff (FILE *yyo);
  154. int gram_debug;
  156. typedef struct {
  157.     GRAM_STYPE s;
  158.     GRAM_LTYPE l;
  159.     int t;
  160. } gram_lex_ctx;
  162. static int gram_lex_wrap(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  163.     int type;
  164.     if (ctx->t == 0) {
  165.         type = gram_lex(&ctx->s, &ctx->l);
  166.     } else {
  167.         type = ctx->t;
  168.     }
  169.     /*fprintf(stderr, "%s %d from %s:%d:%d:%d to %s:%d:%d:%d\n",
  170.             ctx->t == 0 ? "Scanned" : "Rescanned", type,
  171.             ctx->l.start.file, ctx->l.start.line, ctx->l.start.column, ctx->l.start.byte,
  172.             ctx->l.end.file, ctx->l.end.line, ctx->l.end.column, ctx->l.end.byte);*/
  173.     ctx->t = 0;
  174.     if (sx) *sx = ctx->s;
  175.     if (lx) *lx = ctx->l;
  176.     return type;
  177. }
  179. static int gram_unlex_wrap(gram_lex_ctx *ctx, int t, GRAM_STYPE *s, GRAM_LTYPE *l) {
  180.     assert(ctx->t == 0);
  181.     ctx->t = t;
  182.     ctx->s = *s;
  183.     ctx->l = *l;
  184.     /*fprintf(stderr, "Unscanned %d from %s:%d:%d:%d to %s:%d:%d:%d\n",
  185.             t,
  186.             ctx->l.start.file, ctx->l.start.line, ctx->l.start.column, ctx->l.start.byte,
  187.             ctx->l.end.file, ctx->l.end.line, ctx->l.end.column, ctx->l.end.byte);*/
  188. }
  190. static void gram_get_last_loc(gram_lex_ctx *ctx, GRAM_LTYPE *l) {
  191.     *l = ctx->l;
  192. }
  194. static void parse_value(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  195.     GRAM_STYPE s[2];
  196.     GRAM_LTYPE l[2];
  197.     gram_get_last_loc(ctx, &l[0]);
  198.     int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  199.     switch (t) {
  200.     case ID:
  201.         YYLLOC_DEFAULT(*lx, l, 1);
  202.         sx->value.kind = muscle_keyword;
  203.         sx->value.chars = s[1].ID;
  204.         break;
  205.     case STRING:
  206.         YYLLOC_DEFAULT(*lx, l, 1);
  207.         sx->value.kind = muscle_string;
  208.         sx->value.chars = s[1].STRING;
  209.         break;
  210.     case BRACED_CODE:
  211.         YYLLOC_DEFAULT(*lx, l, 1);
  212.         sx->value.kind = muscle_code;
  213.         sx->value.chars = strip_braces(s[1].BRACED_CODE);
  214.         break;
  215.     default:
  216.         gram_unlex_wrap(ctx, t, &s[1], &l[1]);
  217.         YYLLOC_DEFAULT(*lx, l, 0);
  218.         sx->value.kind = muscle_keyword;
  219.         sx->value.chars = "";
  220.         break;
  221.     }
  222. }
  224. static void parse_int_opt(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  225.     GRAM_STYPE s[2];
  226.     GRAM_LTYPE l[2];
  227.     gram_get_last_loc(ctx, &l[0]);
  228.     int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  229.     if (t == INT) {
  230.         YYLLOC_DEFAULT(*lx, l, 1);
  231.         sx->int_opt = s[1].INT;
  232.     } else {
  233.         gram_unlex_wrap(ctx, t, &s[1], &l[1]);
  234.         YYLLOC_DEFAULT(*lx, l, 0);
  235.         sx->int_opt = -1;
  236.     }
  237. }
  239. static int maybe_parse_string_as_id(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  240.     GRAM_STYPE s[2];
  241.     GRAM_LTYPE l[2];
  242.     int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  243.     if (t == STRING) {
  244.         YYLLOC_DEFAULT(*lx, l, 1);
  245.         sx->string_as_id = symbol_get(quotearg_style(c_quoting_style, s[1].STRING), l[1]);
  246.         symbol_class_set(sx->string_as_id, token_sym, l[1], false);
  247.         return 1;
  248.     } else {
  249.         gram_unlex_wrap(ctx, t, &s[1], &l[1]);
  250.         return 0;
  251.     }
  252. }
  254. static void parse_string_as_id(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  255.     int x = maybe_parse_string_as_id(ctx, sx, lx);
  256.     assert(x);
  257. }
  259. static void parse_string_as_id_opt(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  260.     GRAM_STYPE s[2];
  261.     GRAM_LTYPE l[2];
  262.     gram_get_last_loc(ctx, &l[0]);
  263.     int x = maybe_parse_string_as_id(ctx, &s[1], &l[1]);
  264.     if (x) {
  265.         YYLLOC_DEFAULT(*lx, l, 1);
  266.         sx->string_as_id_opt = s[1].string_as_id;
  267.     } else {
  268.         YYLLOC_DEFAULT(*lx, l, 0);
  269.         sx->string_as_id_opt = NULL;
  270.     }
  271. }
  273. static int maybe_parse_id(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  274.     GRAM_STYPE s[2];
  275.     GRAM_LTYPE l[2];
  276.     gram_get_last_loc(ctx, &l[0]);
  277.     int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  278.     if (t == ID) {
  279.         YYLLOC_DEFAULT(*lx, l, 1);
  280.         sx->id = symbol_from_uniqstr(s[1].ID, l[1]);
  281.         return 1;
  282.     } else {
  283.         gram_unlex_wrap(ctx, t, &s[1], &l[1]);
  284.         return 0;
  285.     }
  286. }
  288. static void parse_id(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  289.     int x = maybe_parse_id(ctx, sx, lx);
  290.     assert(x);
  291. }
  293. static void parse_token_decl(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  294.     GRAM_STYPE s[4];
  295.     GRAM_LTYPE l[4];
  296.     parse_id(ctx, &s[1], &l[1]);
  297.     parse_int_opt(ctx, &s[2], &l[2]);
  298.     parse_string_as_id_opt(ctx, &s[3], &l[3]);
  299.     YYLLOC_DEFAULT(*lx, l, 3);
  300.     sx->token_decl = s[1].id;
  301.     symbol_class_set(s[1].id, current_class, l[1], true);
  302.     if (0 <= s[2].int_opt)
  303.         symbol_user_token_number_set(s[1].id, s[2].int_opt, l[2]);
  304.     if (s[3].string_as_id_opt)
  305.         symbol_make_alias(s[1].id, s[3].string_as_id_opt, l[3]);
  306. }
  308. static int maybe_parse_token_decl_1(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  309.     GRAM_STYPE s[3];
  310.     GRAM_LTYPE l[3];
  311.     int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  312.     gram_unlex_wrap(ctx, t, &s[1], &l[1]);
  313.     if (t != ID) {
  314.         return 0;
  315.     }
  316.     parse_token_decl(ctx, &s[1], &l[1]);
  317.     YYLLOC_DEFAULT(*lx, l, 1);
  318.     sx->token_decl_1 = symbol_list_sym_new(s[1].token_decl, l[1]);
  319.     while (1) {
  320.         int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  321.         gram_unlex_wrap(ctx, t, &s[1], &l[1]);
  322.         if (t != ID) {
  323.             return 1;
  324.         }
  325.         s[1] = *sx;
  326.         l[1] = *lx;
  327.         parse_token_decl(ctx, &s[2], &l[2]);
  328.         YYLLOC_DEFAULT(*lx, l, 2);
  329.         sx->token_decl_1 = symbol_list_append(s[1].token_decl_1, symbol_list_sym_new(s[2].token_decl, l[2]));
  330.     }
  331. }
  333. static void parse_token_decl_1(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  334.     int x = maybe_parse_token_decl_1(ctx, sx, lx);
  335.     assert(x);
  336. }
  338. static void parse_token_decls(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  339.     GRAM_STYPE s[4];
  340.     GRAM_LTYPE l[4];
  341.     int begin_with_tokens = maybe_parse_token_decl_1(ctx, &s[1], &l[1]);
  342.     if (begin_with_tokens) {
  343.         YYLLOC_DEFAULT(*lx, l, 1);
  344.         sx->token_decls = s[1].token_decl_1;
  345.     } else {
  346.         int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  347.         assert(t == TAG);
  348.         parse_token_decl_1(ctx, &s[2], &l[2]);
  349.         YYLLOC_DEFAULT(*lx, l, 2);
  350.         sx->token_decls = symbol_list_type_set(s[2].token_decl_1, s[1].TAG, l[1]);
  351.     }
  352.     while (1) {
  353.         s[1] = *sx;
  354.         l[1] = *lx;
  355.         int t = gram_lex_wrap(ctx, &s[2], &l[2]);
  356.         if (t != TAG) {
  357.             gram_unlex_wrap(ctx, t, &s[2], &l[2]);
  358.             return;
  359.         }
  360.         parse_token_decl_1(ctx, &s[3], &l[3]);
  361.         YYLLOC_DEFAULT(*lx, l, 3);
  362.         sx->token_decls = symbol_list_append(s[1].token_decls, symbol_list_type_set(s[3].token_decl_1, s[2].TAG, l[2]));
  363.     }
  364. }
  366. static int maybe_parse_symbol(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  367.     GRAM_STYPE s[2];
  368.     GRAM_LTYPE l[2];
  369.     int x = maybe_parse_string_as_id(ctx, &s[1], &l[1]);
  370.     if (x) {
  371.         YYLLOC_DEFAULT(*lx, l, 1);
  372.         sx->symbol = s[1].string_as_id;
  373.         return 1;
  374.     }
  375.     x = maybe_parse_id(ctx, &s[1], &l[1]);
  376.     if (x) {
  377.         YYLLOC_DEFAULT(*lx, l, 1);
  378.         sx->symbol = s[1].id;
  379.         return 1;
  380.     }
  381.     return 0;
  382. }
  384. static void parse_symbol(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  385.     int x = maybe_parse_symbol(ctx, sx, lx);
  386.     assert(x);
  387. }
  389. static int maybe_parse_symbol_decl_1(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  390.     GRAM_STYPE s[3];
  391.     GRAM_LTYPE l[3];
  392.     int x = maybe_parse_symbol(ctx, &s[1], &l[1]);
  393.     if (!x) {
  394.         return 0;
  395.     }
  396.     YYLLOC_DEFAULT(*lx, l, 1);
  397.     sx->symbol_decl_1 = symbol_list_sym_new(s[1].symbol, l[1]);
  398.     while (1) {
  399.         s[1] = *sx;
  400.         l[1] = *lx;
  401.         x = maybe_parse_symbol(ctx, &s[2], &l[2]);
  402.         if (!x) {
  403.             return 1;
  404.         }
  405.         YYLLOC_DEFAULT(*lx, l, 2);
  406.         sx->symbol_decl_1 = symbol_list_append(s[1].symbol_decl_1, symbol_list_sym_new(s[2].symbol, l[2]));
  407.     }
  408. }
  410. static void parse_symbol_decl_1(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  411.     int x = maybe_parse_symbol_decl_1(ctx, sx, lx);
  412.     assert(x);
  413. }
  415. static void parse_symbol_decls(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  416.     GRAM_STYPE s[4];
  417.     GRAM_LTYPE l[4];
  418.     int begin_with_tokens = maybe_parse_symbol_decl_1(ctx, &s[1], &l[1]);
  419.     if (begin_with_tokens) {
  420.         YYLLOC_DEFAULT(*lx, l, 1);
  421.         sx->symbol_decls = s[1].symbol_decl_1;
  422.     } else {
  423.         int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  424.         assert(t == TAG);
  425.         parse_symbol_decl_1(ctx, &s[2], &l[2]);
  426.         YYLLOC_DEFAULT(*lx, l, 2);
  427.         sx->symbol_decls = symbol_list_type_set(s[2].symbol_decl_1, s[1].TAG, l[1]);
  428.     }
  429.     while (1) {
  430.         s[1] = *sx;
  431.         l[1] = *lx;
  432.         int t = gram_lex_wrap(ctx, &s[2], &l[2]);
  433.         if (t != TAG) {
  434.             gram_unlex_wrap(ctx, t, &s[2], &l[2]);
  435.             return;
  436.         }
  437.         parse_symbol_decl_1(ctx, &s[3], &l[3]);
  438.         YYLLOC_DEFAULT(*lx, l, 3);
  439.         sx->symbol_decls = symbol_list_append(s[1].symbol_decls, symbol_list_type_set(s[3].symbol_decl_1, s[2].TAG, l[2]));
  440.     }
  441. }
  443. static int maybe_parse_declaration(gram_lex_ctx *ctx, int prologue) {
  444.     GRAM_STYPE s[4];
  445.     GRAM_LTYPE l[4];
  446.     int t[4];
  447.     t[1] = gram_lex_wrap(ctx, &s[1], &l[1]);
  448.     if (prologue) {
  449.         switch (t[1]) {
  450.             /* Prologue declarations */
  451.         case PERCENT_DEFINE:
  452.             t[2] = gram_lex_wrap(ctx, &s[2], &l[2]);
  453.             assert(t[2] == ID);
  454.             parse_value(ctx, &s[3], &l[3]);
  455.             YYLLOC_DEFAULT(l[0], l, 3);
  456.             muscle_percent_define_insert(s[2].ID, l[0], s[3].value.kind, s[3].value.chars,
  457.                                          MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
  458.             return 1;
  459.         case PERCENT_DEFINES:
  460.             defines_flag = true;
  461.             return 1;
  462.         case PERCENT_EXPECT:
  463.             t[2] = gram_lex_wrap(ctx, &s[2], &l[2]);
  464.             assert(t[2] == INT);
  465.             expected_sr_conflicts = s[2].INT;
  466.             return 1;
  467.         case PERCENT_INITIAL_ACTION:
  468.             t[2] = gram_lex_wrap(ctx, &s[2], &l[2]);
  469.             assert(t[2] == BRACED_CODE);
  470.             muscle_code_grow("initial_action", translate_code(s[2].BRACED_CODE, l[2], false), l[2]);
  471.             code_scanner_last_string_free();
  472.             return 1;
  473.         case PERCENT_VERBOSE:
  474.             report_flag |= report_states;
  475.             return 1;
  476.         case SEMICOLON:
  477.             return 1;
  478.         }
  479.     }
  481.     switch (t[1]) {
  482.         /* Grammar declarations */
  483.     case PERCENT_CODE:
  484.         t[2] = gram_lex_wrap(ctx, &s[2], &l[2]);
  485.         if (t[2] == ID) {
  486.             t[3] = gram_lex_wrap(ctx, &s[3], &l[3]);
  487.             assert(t[3] == BRACED_CODE);
  488.             muscle_percent_code_grow(s[2].ID, l[2], translate_code_braceless(s[3].BRACED_CODE, l[3]), l[3]);
  489.             code_scanner_last_string_free();
  490.         } else {
  491.             assert(t[2] == BRACED_CODE);
  492.             muscle_code_grow("percent_code()", translate_code_braceless(s[2].BRACED_CODE, l[2]), l[2]);
  493.             code_scanner_last_string_free();
  494.         }
  495.         return 1;
  497.         /* Symbol declarations */
  498.     case PERCENT_TOKEN:
  499.         current_class = token_sym;
  500.         parse_token_decls(ctx, &s[2], &l[2]);
  501.         current_class = unknown_sym;
  502.         symbol_list_free(s[2].token_decls);
  503.         return 1;
  504.     case PERCENT_TYPE:
  505.         parse_symbol_decls(ctx, &s[2], &l[2]);
  506.         symbol_list_free(s[2].symbol_decls);
  507.         return 1;
  508.     case PERCENT_PERCENT:
  509.         return 2;
  510.     default:
  511.         gram_unlex_wrap(ctx, t[1], &s[1], &l[1]);
  512.         return 0;
  513.     }
  514. }
  516. static void parse_prologue_declarations(gram_lex_ctx *ctx) {
  517.     while (1) {
  518.         int x = maybe_parse_declaration(ctx, 1);
  519.         assert(x);
  520.         if (x == 2) {
  521.             return;
  522.         }
  523.     }
  524. }
  526. static void parse_id_colon(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  527.     GRAM_STYPE s[2];
  528.     GRAM_LTYPE l[2];
  529.     int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  530.     assert(t == ID_COLON);
  531.     YYLLOC_DEFAULT(*lx, l, 1);
  532.     sx->id_colon = symbol_from_uniqstr(s[1].ID_COLON, l[1]);
  533. }
  535. static void parse_named_ref_opt(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  536.     GRAM_STYPE s[2];
  537.     GRAM_LTYPE l[2];
  538.     gram_get_last_loc(ctx, &l[0]);
  539.     int t = gram_lex_wrap(ctx, &s[1], &l[1]);
  540.     if (t == BRACKETED_ID) {
  541.         YYLLOC_DEFAULT(*lx, l, 1);
  542.         sx->named_ref_opt = named_ref_new(s[1].BRACKETED_ID, l[1]);
  543.     } else {
  544.         gram_unlex_wrap(ctx, t, &s[1], &l[1]);
  545.         YYLLOC_DEFAULT(*lx, l, 0);
  546.         sx->named_ref_opt = NULL;
  547.     }
  548. }
  550. static void parse_rhs(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  551.     GRAM_STYPE s[5];
  552.     GRAM_LTYPE l[5];
  553.     gram_get_last_loc(ctx, &l[0]);
  554.     YYLLOC_DEFAULT(*lx, l, 0);
  555.     grammar_current_rule_begin(current_lhs_symbol, current_lhs_loc, current_lhs_named_ref);
  556.     while (1) {
  557.         s[1] = *sx;
  558.         l[1] = *lx;
  559.         int x = maybe_parse_symbol(ctx, &s[2], &l[2]);
  560.         if (x) {
  561.             parse_named_ref_opt(ctx, &s[3], &l[3]);
  562.             YYLLOC_DEFAULT(*lx, l, 3);
  563.             grammar_current_rule_symbol_append(s[2].symbol, l[2], s[3].named_ref_opt);
  564.         } else {
  565.             int t = gram_lex_wrap(ctx, &s[2], &l[2]);
  566.             switch (t) {
  567.             case BRACED_CODE:
  568.                 /* Probably good */
  569.                 s[3] = s[2];
  570.                 l[3] = l[2];
  571.                 s[2].tag_opt = NULL;
  572.                 l[2] = l[1];
  573.                 parse_named_ref_opt(ctx, &s[4], &l[4]);
  574.                 YYLLOC_DEFAULT(*lx, l, 4);
  575.                 grammar_current_rule_action_append(s[3].BRACED_CODE, l[3], s[4].named_ref_opt, s[2].tag_opt);
  576.                 break;
  577.             case PERCENT_EMPTY:
  578.                 YYLLOC_DEFAULT(*lx, l, 2);
  579.                 grammar_current_rule_empty_set(l[2]);
  580.                 break;
  581.             default:
  582.                 gram_unlex_wrap(ctx, t, &s[2], &l[2]);
  583.                 return;
  584.             }
  585.         }
  586.     }
  587. }
  589. static void parse_rhses_1(gram_lex_ctx *ctx, GRAM_STYPE *sx, GRAM_LTYPE *lx) {
  590.     GRAM_STYPE s[4];
  591.     GRAM_LTYPE l[4];
  592.     parse_rhs(ctx, &s[1], &l[1]);
  593.     YYLLOC_DEFAULT(*lx, l, 1);
  594.     grammar_current_rule_end(l[1]);
  595.     while (1) {
  596.         s[1] = *sx;
  597.         l[1] = *lx;
  598.         int t = gram_lex_wrap(ctx, &s[2], &l[2]);
  599.         switch (t) {
  600.         case PIPE:
  601.             parse_rhs(ctx, &s[3], &l[3]);
  602.             YYLLOC_DEFAULT(*lx, l, 3);
  603.             grammar_current_rule_end(l[3]);
  604.             break;
  605.         case SEMICOLON:
  606.             YYLLOC_DEFAULT(*lx, l, 2);
  607.             break;
  608.         default:
  609.             gram_unlex_wrap(ctx, t, &s[2], &l[2]);
  610.             return;
  611.         }
  612.     }
  613. }
  615. static void parse_rules(gram_lex_ctx *ctx) {
  616.     GRAM_STYPE s[6];
  617.     GRAM_LTYPE l[6];
  618.     parse_id_colon(ctx, &s[1], &l[1]);
  619.     parse_named_ref_opt(ctx, &s[2], &l[2]);
  620.     gram_get_last_loc(ctx, &l[3]);
  621.     current_lhs(s[1].id_colon, l[1], s[2].named_ref_opt);
  622.     int t = gram_lex_wrap(ctx, &s[4], &l[4]);
  623.     assert(t == COLON);
  624.     parse_rhses_1(ctx, &s[5], &l[5]);
  625.     current_lhs(0, l[1], 0);
  626. }
  628. static void parse_grammar(gram_lex_ctx *ctx) {
  629.     while (1) {
  630.         int x = maybe_parse_declaration(ctx, 0);
  631.         if (x == 1) {
  632.             int t = gram_lex_wrap(ctx, NULL, NULL);
  633.             assert(t == SEMICOLON);
  634.         } if (x == 2) {
  635.             return;
  636.         } else if (x == 0) {
  637.             parse_rules(ctx);
  638.         }
  639.     }
  640. }
  642. static void parse_epilogue(gram_lex_ctx *ctx) {
  643.     GRAM_STYPE s;
  644.     GRAM_LTYPE l;
  645.     int t = gram_lex_wrap(ctx, &s, &l);
  646.     assert(t == EPILOGUE);
  647.     muscle_code_grow("epilogue", translate_code(s.EPILOGUE, l, true), l);
  648.     code_scanner_last_string_free();
  649. }
  651. int gram_parse(void) {
  652.     gram_lex_ctx ctx = {};
  653.     boundary_set(&ctx.l.start, current_file, 1, 1, 1);
  654.     boundary_set(&ctx.l.end, current_file, 1, 1, 1);
  655.     parse_prologue_declarations(&ctx);
  656.     parse_grammar(&ctx);
  657.     parse_epilogue(&ctx);
  658.     assert(gram_lex_wrap(&ctx, NULL, NULL) == 0);
  659.     return 0;
  660. }
  662. // Epilogue
  664. /* Return the location of the left-hand side of a rule whose
  665.    right-hand side is RHS[1] ... RHS[N].  Ignore empty nonterminals in
  666.    the right-hand side, and return an empty location equal to the end
  667.    boundary of RHS[0] if the right-hand side is empty.  */
  669. static YYLTYPE
  670. lloc_default (YYLTYPE const *rhs, int n)
  671. {
  672.   YYLTYPE loc;
  674.   /* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;".
  675.      The bug is fixed in 7.4.2m, but play it safe for now.  */
  676.   loc.start = rhs[n].end;
  677.   loc.end = rhs[n].end;
  679.   /* Ignore empty nonterminals the start of the right-hand side.
  680.      Do not bother to ignore them at the end of the right-hand side,
  681.      since empty nonterminals have the same end as their predecessors.  */
  682.   for (int i = 1; i <= n; i++)
  683.     if (! equal_boundaries (rhs[i].start, rhs[i].end))
  684.       {
  685.         loc.start = rhs[i].start;
  686.         break;
  687.       }
  689.   return loc;
  690. }
  692. static
  693. char *strip_braces (char *code)
  694. {
  695.   code[strlen (code) - 1] = 0;
  696.   return code + 1;
  697. }
  699. static
  700. char const *
  701. translate_code (char *code, location loc, bool plain)
  702. {
  703.   code_props plain_code;
  704.   if (plain)
  705.     code_props_plain_init (&plain_code, code, loc);
  706.   else
  707.     code_props_symbol_action_init (&plain_code, code, loc);
  708.   code_props_translate_code (&plain_code);
  709.   gram_scanner_last_string_free ();
  710.   return plain_code.code;
  711. }
  713. static
  714. char const *
  715. translate_code_braceless (char *code, location loc)
  716. {
  717.   return translate_code (strip_braces (code), loc, true);
  718. }
  720. static void
  721. add_param (param_type type, char *decl, location loc)
  722. {
  723.   static char const alphanum[26 + 26 + 1 + 10 + 1] =
  724.     "abcdefghijklmnopqrstuvwxyz"
  725.     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  726.     "_"
  727.     "0123456789";
  729.   char const *name_start = NULL;
  730.   {
  731.     char *p;
  732.     /* Stop on last actual character.  */
  733.     for (p = decl; p[1]; p++)
  734.       if ((p == decl
  735.            || ! memchr (alphanum, p[-1], sizeof alphanum - 1))
  736.           && memchr (alphanum, p[0], sizeof alphanum - 10 - 1))
  737.         name_start = p;
  739.     /* Strip the surrounding '{' and '}', and any blanks just inside
  740.        the braces.  */
  741.     --p;
  742.     while (c_isspace ((unsigned char) *p))
  743.       --p;
  744.     p[1] = '\0';
  745.     ++decl;
  746.     while (c_isspace ((unsigned char) *decl))
  747.       ++decl;
  748.   }
  750.   if (! name_start)
  751.     complain (&loc, complaint, _("missing identifier in parameter declaration"));
  752.   else
  753.     {
  754.       char *name = xmemdup0 (name_start, strspn (name_start, alphanum));
  755.       if (type & param_lex)
  756.         muscle_pair_list_grow ("lex_param", decl, name);
  757.       if (type & param_parse)
  758.         muscle_pair_list_grow ("parse_param", decl, name);
  759.       free (name);
  760.     }
  762.   gram_scanner_last_string_free ();
  763. }
  766. static void
  767. handle_error_verbose (location const *loc, char const *directive)
  768. {
  769.   bison_directive (loc, directive);
  770.   muscle_percent_define_insert (directive, *loc, muscle_keyword, "",
  771.                                 MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
  772. }
  775. static void
  776. handle_file_prefix (location const *loc,
  777.                     location const *dir_loc,
  778.                     char const *directive, char const *value)
  779. {
  780.   bison_directive (loc, directive);
  781.   bool warned = false;
  783.   if (location_empty (spec_file_prefix_loc))
  784.     {
  785.       spec_file_prefix_loc = *loc;
  786.       spec_file_prefix = value;
  787.     }
  788.   else
  789.     {
  790.       duplicate_directive (directive, spec_file_prefix_loc, *loc);
  791.       warned = true;
  792.     }
  794.   if (!warned
  795.       && STRNEQ (directive, "%file-prefix"))
  796.     deprecated_directive (dir_loc, directive, "%file-prefix");
  797. }
  800. static void
  801. handle_name_prefix (location const *loc,
  802.                     char const *directive, char const *value)
  803. {
  804.   bison_directive (loc, directive);
  806.   char buf1[1024];
  807.   size_t len1 = sizeof (buf1);
  808.   char *old = asnprintf (buf1, &len1, "%s\"%s\"", directive, value);
  809.   if (!old)
  810.     xalloc_die ();
  812.   if (location_empty (spec_name_prefix_loc))
  813.     {
  814.       spec_name_prefix = value;
  815.       spec_name_prefix_loc = *loc;
  817.       char buf2[1024];
  818.       size_t len2 = sizeof (buf2);
  819.       char *new = asnprintf (buf2, &len2, "%%define api.prefix {%s}", value);
  820.       if (!new)
  821.         xalloc_die ();
  822.       deprecated_directive (loc, old, new);
  823.       if (new != buf2)
  824.         free (new);
  825.     }
  826.   else
  827.     duplicate_directive (old, spec_file_prefix_loc, *loc);
  829.   if (old != buf1)
  830.     free (old);
  831. }
  834. static void
  835. handle_pure_parser (location const *loc, char const *directive)
  836. {
  837.   bison_directive (loc, directive);
  838.   deprecated_directive (loc, directive, "%define api.pure");
  839.   muscle_percent_define_insert ("api.pure", *loc, muscle_keyword, "",
  840.                                 MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
  841. }
  844. static void
  845. handle_require (location const *loc, char const *version)
  846. {
  847.   /* Changes of behavior are only on minor version changes, so "3.0.5"
  848.      is the same as "3.0". */
  849.   errno = 0;
  850.   char* cp = NULL;
  851.   unsigned long major = strtoul (version, &cp, 10);
  852.   if (errno || *cp != '.')
  853.     {
  854.       complain (loc, complaint, _("invalid version requirement: %s"),
  855.                 version);
  856.       return;
  857.     }
  858.   ++cp;
  859.   unsigned long minor = strtoul (cp, NULL, 10);
  860.   if (errno)
  861.     {
  862.       complain (loc, complaint, _("invalid version requirement: %s"),
  863.                 version);
  864.       return;
  865.     }
  866.   required_version = major * 100 + minor;
  867.   /* Pretend to be at least 3.4, to check features published in 3.4
  868.      while developping it.  */
  869.   const char* api_version = "3.4";
  870.   const char* package_version =
  871.     strverscmp (api_version, PACKAGE_VERSION) > 0
  872.     ? api_version : PACKAGE_VERSION;
  873.   if (strverscmp (version, package_version) > 0)
  874.     {
  875.       complain (loc, complaint, _("require bison %s, but have %s"),
  876.                 version, package_version);
  877.       exit (EX_MISMATCH);
  878.     }
  879. }
  881. static void
  882. handle_skeleton (location const *loc, char const *skel)
  883. {
  884.   char const *skeleton_user = skel;
  885.   if (strchr (skeleton_user, '/'))
  886.     {
  887.       size_t dir_length = strlen (current_file);
  888.       while (dir_length && current_file[dir_length - 1] != '/')
  889.         --dir_length;
  890.       while (dir_length && current_file[dir_length - 1] == '/')
  891.         --dir_length;
  892.       char *skeleton_build =
  893.         xmalloc (dir_length + 1 + strlen (skeleton_user) + 1);
  894.       if (dir_length > 0)
  895.         {
  896.           memcpy (skeleton_build, current_file, dir_length);
  897.           skeleton_build[dir_length++] = '/';
  898.         }
  899.       strcpy (skeleton_build + dir_length, skeleton_user);
  900.       skeleton_user = uniqstr_new (skeleton_build);
  901.       free (skeleton_build);
  902.     }
  903.   skeleton_arg (skeleton_user, grammar_prio, *loc);
  904. }
  907. static void
  908. handle_yacc (location const *loc, char const *directive)
  909. {
  910.   bison_directive (loc, directive);
  911.   bool warned = false;
  913.   if (location_empty (yacc_loc))
  914.     yacc_loc = *loc;
  915.   else
  916.     {
  917.       duplicate_directive (directive, yacc_loc, *loc);
  918.       warned = true;
  919.     }
  921.   if (!warned
  922.       && STRNEQ (directive, "%fixed-output-files")
  923.       && STRNEQ (directive, "%yacc"))
  924.     deprecated_directive (loc, directive, "%fixed-output-files");
  925. }
  928. static void
  929. gram_error (location const *loc, char const *msg)
  930. {
  931.   complain (loc, complaint, "%s", msg);
  932. }
  934. static char const *
  935. char_name (char c)
  936. {
  937.   if (c == '\'')
  938.     return "'\\''";
  939.   else
  940.     {
  941.       char buf[4];
  942.       buf[0] = '\''; buf[1] = c; buf[2] = '\''; buf[3] = '\0';
  943.       return quotearg_style (escape_quoting_style, buf);
  944.     }
  945. }
  947. static
  948. void
  949. current_lhs (symbol *sym, location loc, named_ref *ref)
  950. {
  951.   current_lhs_symbol = sym;
  952.   current_lhs_loc = loc;
  953.   if (sym)
  954.     symbol_location_as_lhs_set (sym, loc);
  955.   /* In order to simplify memory management, named references for lhs
  956.      are always assigned by deep copy into the current symbol_list
  957.      node.  This is because a single named-ref in the grammar may
  958.      result in several uses when the user factors lhs between several
  959.      rules using "|".  Therefore free the parser's original copy.  */
  960.   free (current_lhs_named_ref);
  961.   current_lhs_named_ref = ref;
  962. }
  964. static void tron (FILE *yyo)
  965. {
  966.   begin_use_class ("value", yyo);
  967. }
  969. static void troff (FILE *yyo)
  970. {
  971.   end_use_class ("value", yyo);
  972. }