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