X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/021a7cfb3eed5c992db326210dbff9054c43b587..66c209cf435b5bfc5cf982d8df9cc3ef05b4546b:/data/glr.cc diff --git a/data/glr.cc b/data/glr.cc index f5f0f447..0afceeac 100644 --- a/data/glr.cc +++ b/data/glr.cc @@ -1,8 +1,6 @@ - -*- C -*- - # C++ GLR skeleton for Bison -# Copyright (C) 2002-2012 Free Software Foundation, Inc. +# Copyright (C) 2002-2013 Free Software Foundation, Inc. # 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 @@ -29,7 +27,7 @@ # # The additional arguments are stored as members of the parser # object, yyparser. The C routines need to carry yyparser -# throughout the C parser; that easy: just let yyparser become an +# throughout the C parser; that's easy: make yyparser an # additional parse-param. But because the C++ skeleton needs to # know the "real" original parse-param, we save them # (b4_parse_param_orig). Note that b4_parse_param is overquoted @@ -39,23 +37,23 @@ # The locations # # We use location.cc just like lalr1.cc, but because glr.c stores -# the locations in a (C++) union, the position and location classes +# the locations in a union, the position and location classes # must not have a constructor. Therefore, contrary to lalr1.cc, we # must not define "b4_location_constructors". As a consequence the # user must initialize the first positions (in particular the # filename member). -# We require a pure interface using locations. -m4_define([b4_locations_flag], [1]) -m4_define([b4_pure_flag], [1]) +b4_token_ctor_if([b4_variant_if([], + [b4_fatal_at(b4_percent_define_get_loc(api.token.constructor), + [cannot use '%s' without '%s'], + [%define api.token.constructor], + [%define api.value.type variant]))])]) -# The header is mandatory. -b4_defines_if([], - [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) +# We require a pure interface. +m4_define([b4_pure_flag], [1]) m4_include(b4_pkgdatadir/[c++.m4]) -b4_percent_define_ifdef([[location_type]], [], - [m4_include(b4_pkgdatadir/[location.cc])]) +b4_bison_locations_if([m4_include(b4_pkgdatadir/[location.cc])]) m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) @@ -63,73 +61,109 @@ m4_define([b4_parser_class_name], # Save the parse parameters. m4_define([b4_parse_param_orig], m4_defn([b4_parse_param])) +# b4_parse_param_wrap +# ------------------- +# New ones. +m4_ifset([b4_parse_param], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]],] +m4_defn([b4_parse_param]))], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]]]) +]) + -# b4_yy_symbol_print_generate -# --------------------------- +# b4_yy_symbol_print_define +# ------------------------- # Bypass the default implementation to generate the "yy_symbol_print" # and "yy_symbol_value_print" functions. -m4_define([b4_yy_symbol_print_generate], +m4_define([b4_yy_symbol_print_define], [[ /*--------------------. | Print this symbol. | `--------------------*/ -]b4_c_ansi_function_def([yy_symbol_print], +]b4_function_define([yy_symbol_print], [static void], - [[FILE *], []], - [[int yytype], [yytype]], - [[const b4_namespace_ref::b4_parser_class_name::semantic_type *yyvaluep], - [yyvaluep]], - [[const b4_namespace_ref::b4_parser_class_name::location_type *yylocationp], - [yylocationp]], + [[FILE *], []], + [[int yytype], [yytype]], + [[const ]b4_namespace_ref::b4_parser_class_name[::semantic_type *yyvaluep], + [yyvaluep]][]dnl +b4_locations_if([, + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]]]), b4_parse_param)[ { ]b4_parse_param_use[]dnl [ yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[); } -]]) - +]])[ -# Declare yyerror. -m4_append([b4_post_prologue], -[b4_syncline([@oline@], [@ofile@]) +# Hijack the initial action to initialize the locations. +]b4_bison_locations_if([m4_define([b4_initial_action], +[yylloc.initialize ();]m4_ifdef([b4_initial_action], [ +m4_defn([b4_initial_action])]))])[ -b4_c_ansi_function_decl([yyerror], - [static void], - [[const b4_namespace_ref::b4_parser_class_name::location_type *yylocationp], - [yylocationp]], +# Hijack the post prologue to insert early definition of YYLLOC_DEFAULT +# and declaration of yyerror. +]m4_append([b4_post_prologue], +[b4_syncline([@oline@], [@ofile@])[ +]b4_yylloc_default_define[ +#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) +]b4_function_declare([yyerror], + [static void],b4_locations_if([ + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]],]) b4_parse_param, [[const char* msg], [msg]])]) -# Define yyerror. +#undef yynerrs +#undef yychar +#undef yylval]b4_locations_if([ +#undef yylloc]) + +m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug +]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])) + +# Hijack the epilogue to define implementations (yyerror, parser member +# functions etc.). m4_append([b4_epilogue], [b4_syncline([@oline@], [@ofile@])[ + /*------------------. | Report an error. | `------------------*/ -]b4_c_ansi_function_def([yyerror], - [static void], - [[const b4_namespace_ref::b4_parser_class_name::location_type *yylocationp], - [yylocationp]], +]b4_function_define([yyerror], + [static void],b4_locations_if([ + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]],]) b4_parse_param, [[const char* msg], [msg]])[ { ]b4_parse_param_use[]dnl -[ yyparser.error (*yylocationp, msg); +[ yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg); } ]b4_namespace_open[ -]dnl In this section, the parse param are the original parse_params. +]dnl In this section, the parse params are the original parse_params. m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl [ /// Build a parser object. ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ :])[ -#if YYDEBUG - ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false), - yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ #endif]b4_parse_param_cons[ { } @@ -144,39 +178,39 @@ m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl return ::yyparse (*this]b4_user_args[); } -#if YYDEBUG +#if ]b4_api_PREFIX[DEBUG /*--------------------. | Print this symbol. | `--------------------*/ inline void ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp) - { - YYUSE (yylocationp); + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) + {]b4_locations_if([[ + YYUSE (yylocationp);]])[ YYUSE (yyvaluep); std::ostream& yyoutput = debug_stream (); std::ostream& yyo = yyoutput; YYUSE (yyo); switch (yytype) { - ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl +]b4_symbol_foreach([b4_symbol_printer])dnl [ default: - break; + break; } } void ]b4_parser_class_name[::yy_symbol_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp) + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) { *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm") - << ' ' << yytname[yytype] << " (" - << *yylocationp << ": "; - yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); + << ' ' << yytname[yytype] << " ("]b4_locations_if([[ + << *yylocationp << ": "]])[; + yy_symbol_value_print_ (yytype, yyvaluep]b4_locations_if([[, yylocationp]])[); *yycdebug_ << ')'; } @@ -196,105 +230,46 @@ m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl ]b4_parser_class_name[::debug_level_type ]b4_parser_class_name[::debug_level () const { - return yydebug_; + return yydebug; } void ]b4_parser_class_name[::set_debug_level (debug_level_type l) { - yydebug_ = l; + // Actually, it is yydebug which is really used. + yydebug = l; } #endif ]m4_popdef([b4_parse_param])dnl -b4_namespace_close[ - -]]) - - -# Let glr.c believe that the user arguments include the parser itself. -m4_ifset([b4_parse_param], -[m4_pushdef([b4_parse_param], - m4_dquote([[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]],] -m4_defn([b4_parse_param])))], -[m4_pushdef([b4_parse_param], - [[[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]]]]) +b4_namespace_close ]) -m4_include(b4_pkgdatadir/[glr.c]) -m4_popdef([b4_parse_param]) - -m4_divert_push(0) -@output(b4_spec_defines_file@)@ -b4_copyright([Skeleton interface for Bison GLR parsers in C++], - [2002-2006, 2009-2012])[ - -/* C++ GLR parser skeleton written by Akim Demaille. */ - -#ifndef PARSER_HEADER_H -# define PARSER_HEADER_H -]b4_percent_code_get([[requires]])[ +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --defines) +# or open coded in the parser body. +m4_define([b4_shared_declarations], +[m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +b4_percent_code_get([[requires]])[ +#include #include -#include -]b4_percent_define_ifdef([[location_type]], [], - [[#include "location.hh"]])[ - -/* Using locations. */ -#define YYLSP_NEEDED ]b4_locations_flag[ - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ -#endif +#include ]b4_defines_if([ +b4_bison_locations_if([[#include "location.hh"]])])[ -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (N) \ - { \ - (Current).begin = YYRHSLOC (Rhs, 1).begin; \ - (Current).end = YYRHSLOC (Rhs, N).end; \ - } \ - else \ - { \ - (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ - } \ - while (/*CONSTCOND*/ 0) -#endif +]b4_YYDEBUG_define[ ]b4_namespace_open[ +]b4_defines_if([], +[b4_bison_locations_if([b4_position_define +b4_location_define])])[ + /// A Bison parser. class ]b4_parser_class_name[ { public: - /// Symbol semantic values. -#ifndef YYSTYPE -]m4_ifdef([b4_stype], -[ union semantic_type - { -b4_user_stype - };], -[m4_if(b4_tag_seen_flag, 0, -[[ typedef int semantic_type;]], -[[ typedef YYSTYPE semantic_type;]])])[ -#else - typedef YYSTYPE semantic_type; -#endif - /// Symbol locations. - typedef ]b4_percent_define_get([[location_type]], - [[location]])[ location_type; - /// Tokens. - struct token - { - ]b4_token_enums(b4_tokens)[ - }; - /// Token type. - typedef token::yytokentype token_type; +]b4_public_types_declare[ /// Build a parser object. ]b4_parser_class_name[ (]b4_parse_param_decl[); @@ -316,34 +291,30 @@ b4_user_stype /// Set the current debugging level. void set_debug_level (debug_level_type l); - private: - public: - /// Report a syntax error. - /// \param loc where the syntax error is found. + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ /// \param msg a description of the syntax error. - virtual void error (const location_type& loc, const std::string& msg); - private: + virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); -#if YYDEBUG +# if ]b4_api_PREFIX[DEBUG public: /// \brief Report a symbol value on the debug stream. /// \param yytype The token type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ virtual void yy_symbol_value_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp); + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[); /// \brief Report a symbol on the debug stream. /// \param yytype The token type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ virtual void yy_symbol_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp); + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[); private: - /* Debugging. */ - int yydebug_; + // Debugging. std::ostream* yycdebug_; #endif @@ -352,18 +323,34 @@ b4_user_stype ]dnl Redirections for glr.c. b4_percent_define_flag_if([[global_tokens_and_yystype]], -[b4_token_defines(b4_tokens)]) +[b4_token_defines]) [ -#ifndef YYSTYPE -# define YYSTYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type +#ifndef ]b4_api_PREFIX[STYPE +# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type #endif -#ifndef YYLTYPE -# define YYLTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type +#ifndef ]b4_api_PREFIX[LTYPE +# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type #endif ]b4_namespace_close[ +]b4_percent_code_get([[provides]])[ +]m4_popdef([b4_parse_param])dnl +]) -]b4_percent_code_get([[provides]])[]dnl +b4_defines_if( +[b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2013])[ -[#endif /* ! defined PARSER_HEADER_H */] -m4_divert_pop(0) +// C++ GLR parser skeleton written by Akim Demaille. + +]b4_cpp_guard_open([b4_spec_defines_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_defines_file])[ +]b4_output_end()]) + +# Let glr.c (and b4_shared_declarations) believe that the user +# arguments include the parser itself. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_wrap])) +m4_include(b4_pkgdatadir/[glr.c]) +m4_popdef([b4_parse_param])