diff options
Diffstat (limited to 'gnuwin32/bin/data/glr.cc')
| -rw-r--r-- | gnuwin32/bin/data/glr.cc | 345 |
1 files changed, 345 insertions, 0 deletions
diff --git a/gnuwin32/bin/data/glr.cc b/gnuwin32/bin/data/glr.cc new file mode 100644 index 00000000..e57308bd --- /dev/null +++ b/gnuwin32/bin/data/glr.cc @@ -0,0 +1,345 @@ +# C++ GLR skeleton for Bison + +# 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 +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# 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, see <http://www.gnu.org/licenses/>. + + +# This skeleton produces a C++ class that encapsulates a C glr parser. +# This is in order to reduce the maintenance burden. The glr.c +# skeleton is clean and pure enough so that there are no real +# problems. The C++ interface is the same as that of lalr1.cc. In +# fact, glr.c can replace yacc.c without the user noticing any +# difference, and similarly for glr.cc replacing lalr1.cc. +# +# The passing of parse-params +# +# The additional arguments are stored as members of the parser +# object, yyparser. The C routines need to carry yyparser +# 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 +# (and c.m4 strips one level of quotes). This is a PITA, and +# explains why there are so many levels of quotes. +# +# The locations +# +# We use location.cc just like lalr1.cc, but because glr.c stores +# 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. +m4_define([b4_pure_flag], [1]) + +m4_include(b4_pkgdatadir/[c++.m4]) +b4_bison_locations_if([m4_include(b4_pkgdatadir/[location.cc])]) + +m4_define([b4_parser_class_name], + [b4_percent_define_get([[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_define +# ------------------------- +# Bypass the default implementation to generate the "yy_symbol_print" +# and "yy_symbol_value_print" functions. +m4_define([b4_yy_symbol_print_define], +[[ +/*--------------------. +| Print this symbol. | +`--------------------*/ + +]b4_function_define([yy_symbol_print], + [static void], + [[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])[); +} +]])[ + +# 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])]))])[ + +# 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]])]) + + +#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_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 (]b4_locations_if([[*yylocationp, ]])[msg); +} + + +]b4_namespace_open[ +]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 ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + { + } + + ]b4_parser_class_name::~b4_parser_class_name[ () + { + } + + int + ]b4_parser_class_name[::parse () + { + return ::yyparse (*this]b4_user_args[); + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------. + | Print this symbol. | + `--------------------*/ + + inline void + ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, + 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); + ]b4_symbol_actions([printer])[ + } + + + void + ]b4_parser_class_name[::yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) + { + *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm") + << ' ' << yytname[yytype] << " ("]b4_locations_if([[ + << *yylocationp << ": "]])[; + yy_symbol_value_print_ (yytype, yyvaluep]b4_locations_if([[, yylocationp]])[); + *yycdebug_ << ')'; + } + + std::ostream& + ]b4_parser_class_name[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class_name[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class_name[::debug_level_type + ]b4_parser_class_name[::debug_level () const + { + return yydebug; + } + + void + ]b4_parser_class_name[::set_debug_level (debug_level_type l) + { + // Actually, it is yydebug which is really used. + yydebug = l; + } + +#endif +]m4_popdef([b4_parse_param])dnl +b4_namespace_close +]) + +# 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 <stdexcept> +#include <string> +#include <iostream>]b4_defines_if([ +b4_bison_locations_if([[#include "location.hh"]])])[ + +]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: +]b4_public_types_declare[ + + /// Build a parser object. + ]b4_parser_class_name[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class_name[ (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); + + public: + /// 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 (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + +# 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.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_value_print_ (int yytype, + 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.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[); + private: + // Debugging. + std::ostream* yycdebug_; +#endif + +]b4_parse_param_vars[ + }; + +]dnl Redirections for glr.c. +b4_percent_define_flag_if([[global_tokens_and_yystype]], +[b4_token_defines]) +[ +#ifndef ]b4_api_PREFIX[STYPE +# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type +#endif +#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_defines_if( +[b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2013])[ + +// 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]) |