]>
Commit | Line | Data |
---|---|---|
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 |
47 | m4_define([b4_locations_flag], [1]) |
48 | m4_define([b4_pure_flag], [1]) | |
49 | ||
50 | # The header is mandatory. | |
51 | b4_defines_if([], | |
5f340b48 | 52 | [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) |
42249483 AD |
53 | |
54 | m4_include(b4_pkgdatadir/[c++.m4]) | |
55 | m4_include(b4_pkgdatadir/[location.cc]) | |
56 | ||
6afc30cc | 57 | m4_define([b4_parser_class_name], |
a4e25e1d | 58 | [b4_percent_define_get([[parser_class_name]])]) |
42249483 | 59 | |
8f7e3cf9 AD |
60 | # Save the parse parameters. |
61 | m4_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. | |
68 | m4_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. | |
91 | m4_append([b4_post_prologue], | |
8ec0a172 | 92 | [b4_syncline([@oline@], [@ofile@]) |
8f7e3cf9 AD |
93 | |
94 | b4_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. | |
102 | m4_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. |
121 | m4_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 | 200 | b4_namespace_close[ |
42249483 AD |
201 | ]]) |
202 | ||
8f7e3cf9 AD |
203 | |
204 | # Let glr.c believe that the user arguments include the parser itself. | |
205 | m4_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 |
208 | m4_defn([b4_parse_param])))], |
209 | [m4_pushdef([b4_parse_param], | |
793fbca5 | 210 | [[[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]]]]) |
8f7e3cf9 | 211 | ]) |
42249483 | 212 | m4_include(b4_pkgdatadir/[glr.c]) |
8f7e3cf9 AD |
213 | m4_popdef([b4_parse_param]) |
214 | ||
08af01c2 | 215 | m4_divert_push(0) |
a0d4650a | 216 | @output(b4_spec_defines_file@)@ |
193d7c70 | 217 | b4_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 | 332 | b4_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 | 347 | m4_divert_pop(0) |