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