1m4_divert(-1) -*- C -*- 2 3# C++ GLR skeleton for Bison 4# Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 5 6# This program is free software; you can redistribute it and/or modify 7# it under the terms of the GNU General Public License as published by 8# the Free Software Foundation; either version 2 of the License, or 9# (at your option) any later version. 10 11# This program is distributed in the hope that it will be useful, 12# but WITHOUT ANY WARRANTY; without even the implied warranty of 13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14# GNU General Public License for more details. 15 16# You should have received a copy of the GNU General Public License 17# along with this program; if not, write to the Free Software 18# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19# 02110-1301 USA 20 21 22# This skeleton produces a C++ class that encapsulates a C glr parser. 23# This is in order to reduce the maintenance burden. The glr.c 24# skeleton is clean and pure enough so that there are no real 25# problems. The C++ interface is the same as that of lalr1.cc. In 26# fact, glr.c can replace yacc.c without the user noticing any 27# difference, and similarly for glr.cc replacing lalr1.cc. 28# 29# The passing of parse-params 30# 31# The additional arguments are stored as members of the parser 32# object, yyparser. The C routines need to carry yyparser 33# throughout the C parser; that easy: just let yyparser become an 34# additional parse-param. But because the C++ skeleton needs to 35# know the "real" original parse-param, we save them 36# (b4_parse_param_orig). Note that b4_parse_param is overquoted 37# (and c.m4 strips one level of quotes). This is a PITA, and 38# explains why there are so many levels of quotes. 39# 40# The locations 41# 42# We use location.cc just like lalr1.cc, but because glr.c stores 43# the locations in a (C++) union, the position and location classes 44# must not have a constructor. Therefore, contrary to lalr1.cc, we 45# must not define "b4_location_constructors". As a consequence the 46# user must initialize the first positions (in particular the 47# filename member). 48 49# We require a pure interface using locations. 50m4_define([b4_locations_flag], [1]) 51m4_define([b4_pure_flag], [1]) 52 53# The header is mandatory. 54b4_defines_if([], 55 [m4_fatal(b4_skeleton[: using %defines is mandatory])]) 56 57m4_include(b4_pkgdatadir/[c++.m4]) 58m4_include(b4_pkgdatadir/[location.cc]) 59 60 61# Save the parse parameters. 62m4_define([b4_parse_param_orig], m4_defn([b4_parse_param])) 63 64 65# b4_yy_symbol_print_generate 66# --------------------------- 67# Bypass the default implementation to generate the "yy_symbol_print" 68# and "yy_symbol_value_print" functions. 69m4_define([b4_yy_symbol_print_generate], 70[[ 71/*--------------------. 72| Print this symbol. | 73`--------------------*/ 74 75]b4_c_ansi_function_def([yy_symbol_print], 76 [static void], 77 [[FILE *], []], 78 [[int yytype], [yytype]], 79 [[const b4_namespace::b4_parser_class_name::semantic_type *yyvaluep], 80 [yyvaluep]], 81 [[const b4_namespace::b4_parser_class_name::location_type *yylocationp], 82 [yylocationp]], 83 b4_parse_param)[ 84{ 85]b4_parse_param_use[]dnl 86[ yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[); 87} 88]]) 89 90 91# Declare yyerror. 92m4_append([b4_post_prologue], 93[/* Line __line__ of glr.cc. */ 94b4_syncline([@oline@], [@ofile@]) 95 96b4_c_ansi_function_decl([yyerror], 97 [static void], 98 [[b4_namespace::b4_parser_class_name::location_type *yylocationp], [yylocationp]], 99 b4_parse_param, 100 [[const char* msg], [msg]])]) 101 102 103# Define yyerror. 104m4_append([b4_epilogue], 105[/* Line __line__ of glr.cc. */ 106b4_syncline([@oline@], [@ofile@])[ 107/*------------------. 108| Report an error. | 109`------------------*/ 110 111]b4_c_ansi_function_def([yyerror], 112 [static void], 113 [[b4_namespace::b4_parser_class_name::location_type *yylocationp], [yylocationp]], 114 b4_parse_param, 115 [[const char* msg], [msg]])[ 116{ 117]b4_parse_param_use[]dnl 118[ yyparser.error (*yylocationp, msg); 119} 120 121 122namespace ]b4_namespace[ 123{ 124]dnl In this section, the parse param are the original parse_params. 125m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl 126[ /// Build a parser object. 127 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[) 128 : yycdebug_ (&std::cerr)]b4_parse_param_cons[ 129 { 130 } 131 132 ]b4_parser_class_name::~b4_parser_class_name[ () 133 { 134 } 135 136 int 137 ]b4_parser_class_name[::parse () 138 { 139 return ::yyparse (*this]b4_user_args[); 140 } 141 142#if YYDEBUG 143 /*--------------------. 144 | Print this symbol. | 145 `--------------------*/ 146 147 inline void 148 ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, 149 const semantic_type* yyvaluep, const location_type* yylocationp) 150 { 151 /* Pacify ``unused variable'' warnings. */ 152 YYUSE (yyvaluep); 153 YYUSE (yylocationp); 154 switch (yytype) 155 { 156 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl 157[ default: 158 break; 159 } 160 } 161 162 163 void 164 ]b4_parser_class_name[::yy_symbol_print_ (int yytype, 165 const semantic_type* yyvaluep, const location_type* yylocationp) 166 { 167 *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm") 168 << ' ' << yytname[yytype] << " (" 169 << *yylocationp << ": "; 170 yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); 171 *yycdebug_ << ')'; 172 } 173 174 std::ostream& 175 ]b4_parser_class_name[::debug_stream () const 176 { 177 return *yycdebug_; 178 } 179 180 void 181 ]b4_parser_class_name[::set_debug_stream (std::ostream& o) 182 { 183 yycdebug_ = &o; 184 } 185 186 187 ]b4_parser_class_name[::debug_level_type 188 ]b4_parser_class_name[::debug_level () const 189 { 190 return ::yydebug; 191 } 192 193 void 194 ]b4_parser_class_name[::set_debug_level (debug_level_type l) 195 { 196 ::yydebug = l; 197 } 198 199#endif /* ! YYDEBUG */ 200]m4_popdef([b4_parse_param])dnl 201[} // namespace ]b4_namespace[ 202 203]]) 204 205 206# Let glr.c believe that the user arguments include the parser itself. 207m4_ifset([b4_parse_param], 208[m4_pushdef([b4_parse_param], 209 m4_dquote([[[b4_namespace::b4_parser_class_name& yyparser], [[yyparser]]],] 210m4_defn([b4_parse_param])))], 211[m4_pushdef([b4_parse_param], 212 [[[[b4_namespace::b4_parser_class_name& yyparser], [[yyparser]]]]]) 213]) 214m4_include(b4_pkgdatadir/[glr.c]) 215m4_popdef([b4_parse_param]) 216 217 218@output @output_header_name@ 219b4_copyright([Skeleton interface for Bison GLR parsers in C++], 220 [2002, 2003, 2004, 2005, 2006])[ 221 222/* C++ GLR parser skeleton written by Akim Demaille. */ 223 224#ifndef PARSER_HEADER_H 225# define PARSER_HEADER_H 226 227#include <string> 228#include <iostream> 229 230/* Using locations. */ 231#define YYLSP_NEEDED ]b4_locations_flag[ 232 233namespace ]b4_namespace[ 234{ 235 class position; 236 class location; 237} 238 239/* Copy the first part of user declarations. */ 240]b4_pre_prologue[ 241 242]/* Line __line__ of glr.cc. */ 243b4_syncline([@oline@], [@ofile@])[ 244 245#include "location.hh" 246 247/* Enabling traces. */ 248#ifndef YYDEBUG 249# define YYDEBUG ]b4_debug_flag[ 250#endif 251 252/* Enabling verbose error messages. */ 253#ifdef YYERROR_VERBOSE 254# undef YYERROR_VERBOSE 255# define YYERROR_VERBOSE 1 256#else 257# define YYERROR_VERBOSE ]b4_error_verbose_flag[ 258#endif 259 260/* Enabling the token table. */ 261#ifndef YYTOKEN_TABLE 262# define YYTOKEN_TABLE ]b4_token_table[ 263#endif 264 265/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 266 If N is 0, then set CURRENT to the empty location which ends 267 the previous symbol: RHS[0] (always defined). */ 268 269#ifndef YYLLOC_DEFAULT 270# define YYLLOC_DEFAULT(Current, Rhs, N) \ 271 do \ 272 if (N) \ 273 { \ 274 (Current).begin = YYRHSLOC (Rhs, 1).begin; \ 275 (Current).end = YYRHSLOC (Rhs, N).end; \ 276 } \ 277 else \ 278 { \ 279 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ 280 } \ 281 while (/*CONSTCOND*/ 0) 282#endif 283 284namespace ]b4_namespace[ 285{ 286 /// A Bison parser. 287 class ]b4_parser_class_name[ 288 { 289 public: 290 /// Symbol semantic values. 291#ifndef YYSTYPE 292]m4_ifdef([b4_stype], 293[ union semantic_type 294b4_stype 295/* Line __line__ of lalr1.cc. */ 296b4_syncline([@oline@], [@ofile@]) 297 ;], 298[ typedef int semantic_type;])[ 299#else 300 typedef YYSTYPE semantic_type; 301#endif 302 /// Symbol locations. 303 typedef ]b4_location_type[ location_type; 304 /// Tokens. 305 struct token 306 { 307 ]b4_token_enums(b4_tokens)[ 308 }; 309 /// Token type. 310 typedef token::yytokentype token_type; 311 312 /// Build a parser object. 313 ]b4_parser_class_name[ (]b4_parse_param_decl[); 314 virtual ~]b4_parser_class_name[ (); 315 316 /// Parse. 317 /// \returns 0 iff parsing succeeded. 318 virtual int parse (); 319 320 /// The current debugging stream. 321 std::ostream& debug_stream () const; 322 /// Set the current debugging stream. 323 void set_debug_stream (std::ostream &); 324 325 /// Type for debugging levels. 326 typedef int debug_level_type; 327 /// The current debugging level. 328 debug_level_type debug_level () const; 329 /// Set the current debugging level. 330 void set_debug_level (debug_level_type l); 331 332 private: 333 334 public: 335 /// Report a syntax error. 336 /// \param loc where the syntax error is found. 337 /// \param msg a description of the syntax error. 338 virtual void error (const location_type& loc, const std::string& msg); 339 private: 340 341#if YYDEBUG 342 public: 343 /// \brief Report a symbol value on the debug stream. 344 /// \param yytype The token type. 345 /// \param yyvaluep Its semantic value. 346 /// \param yylocationp Its location. 347 virtual void yy_symbol_value_print_ (int yytype, 348 const semantic_type* yyvaluep, 349 const location_type* yylocationp); 350 /// \brief Report a symbol on the debug stream. 351 /// \param yytype The token type. 352 /// \param yyvaluep Its semantic value. 353 /// \param yylocationp Its location. 354 virtual void yy_symbol_print_ (int yytype, 355 const semantic_type* yyvaluep, 356 const location_type* yylocationp); 357 private: 358#endif /* ! YYDEBUG */ 359 360 361 /// \brief Reclaim the memory associated to a symbol. 362 /// \param yymsg Why this token is reclaimed. 363 /// \param yytype The symbol type. 364 /// \param yyvaluep Its semantic value. 365 /// \param yylocationp Its location. 366 inline void yydestruct_ (const char* yymsg, 367 int yytype, 368 semantic_type* yyvaluep, 369 location_type* yylocationp); 370 371 /* Debugging. */ 372 std::ostream* yycdebug_; 373]b4_parse_param_vars[ 374 }; 375 376]dnl Redirections for glr.c. 377m4_ifset([b4_global_tokens_and_yystype], 378[b4_token_defines(b4_tokens)]) 379[ 380#ifndef YYSTYPE 381# define YYSTYPE ]b4_namespace[::]b4_parser_class_name[::semantic_type 382#endif 383#ifndef YYLTYPE 384# define YYLTYPE ]b4_namespace[::]b4_parser_class_name[::location_type 385#endif 386 387} 388 389#endif /* ! defined PARSER_HEADER_H */] 390