1 m4_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. 50 m4_define([b4_locations_flag], [1]) 51 m4_define([b4_pure_flag], [1]) 52 53 # The header is mandatory. 54 b4_defines_if([], 55 [m4_fatal(b4_skeleton[: using %defines is mandatory])]) 56 57 m4_include(b4_pkgdatadir/[c++.m4]) 58 m4_include(b4_pkgdatadir/[location.cc]) 59 60 61 # Save the parse parameters. 62 m4_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. 69 m4_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. 92 m4_append([b4_post_prologue], 93 [/* Line __line__ of glr.cc. */ 94 b4_syncline([@oline@], [@ofile@]) 95 96 b4_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. 104 m4_append([b4_epilogue], 105 [/* Line __line__ of glr.cc. */ 106 b4_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 122 namespace ]b4_namespace[ 123 { 124 ]dnl In this section, the parse param are the original parse_params. 125 m4_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. 207 m4_ifset([b4_parse_param], 208 [m4_pushdef([b4_parse_param], 209 m4_dquote([[[b4_namespace::b4_parser_class_name& yyparser], [[yyparser]]],] 210 m4_defn([b4_parse_param])))], 211 [m4_pushdef([b4_parse_param], 212 [[[[b4_namespace::b4_parser_class_name& yyparser], [[yyparser]]]]]) 213 ]) 214 m4_include(b4_pkgdatadir/[glr.c]) 215 m4_popdef([b4_parse_param]) 216 217 218 @output @output_header_name@ 219 b4_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 233 namespace ]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. */ 243 b4_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 284 namespace ]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 294 b4_stype 295 /* Line __line__ of lalr1.cc. */ 296 b4_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. 377 m4_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
