Rule length is unsigned.
[bison.git] / data / glr.cc
0 / 375 (  0%)
CommitLineData
1# C++ GLR skeleton for Bison
2# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation,
3# Inc.
4
5# This program is free software: you can redistribute it and/or modify
6# it under the terms of the GNU General Public License as published by
7# the Free Software Foundation, either version 3 of the License, or
8# (at your option) any later version.
9#
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.
14#
15# You should have received a copy of the GNU General Public License
16# along with this program. If not, see <http://www.gnu.org/licenses/>.
17
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
30# throughout the C parser; that easy: just let yyparser become an
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
40# the locations in a (C++) union, the position and location classes
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
46# We require a pure interface using locations.
47m4_define([b4_locations_flag], [1])
48m4_define([b4_pure_flag], [1])
49
50# The header is mandatory.
51b4_defines_if([],
52 [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
53
54m4_include(b4_pkgdatadir/[c++.m4])
55m4_include(b4_pkgdatadir/[location.cc])
56
57m4_define([b4_parser_class_name],
58 [b4_percent_define_get([[parser_class_name]])])
59
60# Save the parse parameters.
61m4_define([b4_parse_param_orig], m4_defn([b4_parse_param]))
62
63
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],
69[[
70/*--------------------.
71| Print this symbol. |
72`--------------------*/
73
74]b4_c_ansi_function_def([yy_symbol_print],
75 [static void],
76 [[FILE *], []],
77 [[int yytype], [yytype]],
78 [[const b4_namespace_ref::b4_parser_class_name::semantic_type *yyvaluep],
79 [yyvaluep]],
80 [[const b4_namespace_ref::b4_parser_class_name::location_type *yylocationp],
81 [yylocationp]],
82 b4_parse_param)[
83{
84]b4_parse_param_use[]dnl
85[ yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[);
86}
87]])
88
89
90# Declare yyerror.
91m4_append([b4_post_prologue],
92[b4_syncline([@oline@], [@ofile@])
93
94b4_c_ansi_function_decl([yyerror],
95 [static void],
96 [[b4_namespace_ref::b4_parser_class_name::location_type *yylocationp], [yylocationp]],
97 b4_parse_param,
98 [[const char* msg], [msg]])])
99
100
101# Define yyerror.
102m4_append([b4_epilogue],
103[b4_syncline([@oline@], [@ofile@])[
104/*------------------.
105| Report an error. |
106`------------------*/
107
108]b4_c_ansi_function_def([yyerror],
109 [static void],
110 [[b4_namespace_ref::b4_parser_class_name::location_type *yylocationp], [yylocationp]],
111 b4_parse_param,
112 [[const char* msg], [msg]])[
113{
114]b4_parse_param_use[]dnl
115[ yyparser.error (*yylocationp, msg);
116}
117
118
119]b4_namespace_open[
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.
123 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
124 :])[
125#if YYDEBUG
126 ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false),
127 yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
128#endif]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
200]m4_popdef([b4_parse_param])dnl
201b4_namespace_close[
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_ref::b4_parser_class_name& yyparser], [[yyparser]]],]
210m4_defn([b4_parse_param])))],
211[m4_pushdef([b4_parse_param],
212 [[[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]]]])
213])
214m4_include(b4_pkgdatadir/[glr.c])
215m4_popdef([b4_parse_param])
216
217m4_divert_push(0)
218@output(b4_spec_defines_file@)@
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]b4_percent_code_get([[requires]])[
228
229#include <string>
230#include <iostream>
231
232/* Using locations. */
233#define YYLSP_NEEDED ]b4_locations_flag[
234
235]b4_namespace_open[
236 class position;
237 class location;
238]b4_namespace_close[
239
240#include "location.hh"
241
242/* Enabling traces. */
243#ifndef YYDEBUG
244# define YYDEBUG ]b4_debug_flag[
245#endif
246
247/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
248 If N is 0, then set CURRENT to the empty location which ends
249 the previous symbol: RHS[0] (always defined). */
250
251#ifndef YYLLOC_DEFAULT
252# define YYLLOC_DEFAULT(Current, Rhs, N) \
253 do \
254 if (N) \
255 { \
256 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
257 (Current).end = YYRHSLOC (Rhs, N).end; \
258 } \
259 else \
260 { \
261 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
262 } \
263 while (/*CONSTCOND*/ 0)
264#endif
265
266]b4_namespace_open[
267 /// A Bison parser.
268 class ]b4_parser_class_name[
269 {
270 public:
271 /// Symbol semantic values.
272#ifndef YYSTYPE
273]m4_ifdef([b4_stype],
274[ union semantic_type
275 {
276b4_user_stype
277 };],
278[m4_if(b4_tag_seen_flag, 0,
279[[ typedef int semantic_type;]],
280[[ typedef YYSTYPE semantic_type;]])])[
281#else
282 typedef YYSTYPE semantic_type;
283#endif
284 /// Symbol locations.
285 typedef ]b4_percent_define_get([[location_type]])[ location_type;
286 /// Tokens.
287 struct token
288 {
289 ]b4_token_enums(b4_tokens)[
290 };
291 /// Token type.
292 typedef token::yytokentype token_type;
293
294 /// Build a parser object.
295 ]b4_parser_class_name[ (]b4_parse_param_decl[);
296 virtual ~]b4_parser_class_name[ ();
297
298 /// Parse.
299 /// \returns 0 iff parsing succeeded.
300 virtual int parse ();
301
302 /// The current debugging stream.
303 std::ostream& debug_stream () const;
304 /// Set the current debugging stream.
305 void set_debug_stream (std::ostream &);
306
307 /// Type for debugging levels.
308 typedef int debug_level_type;
309 /// The current debugging level.
310 debug_level_type debug_level () const;
311 /// Set the current debugging level.
312 void set_debug_level (debug_level_type l);
313
314 private:
315
316 public:
317 /// Report a syntax error.
318 /// \param loc where the syntax error is found.
319 /// \param msg a description of the syntax error.
320 virtual void error (const location_type& loc, const std::string& msg);
321 private:
322
323#if YYDEBUG
324 public:
325 /// \brief Report a symbol value on the debug stream.
326 /// \param yytype The token type.
327 /// \param yyvaluep Its semantic value.
328 /// \param yylocationp Its location.
329 virtual void yy_symbol_value_print_ (int yytype,
330 const semantic_type* yyvaluep,
331 const location_type* yylocationp);
332 /// \brief Report a symbol on the debug stream.
333 /// \param yytype The token type.
334 /// \param yyvaluep Its semantic value.
335 /// \param yylocationp Its location.
336 virtual void yy_symbol_print_ (int yytype,
337 const semantic_type* yyvaluep,
338 const location_type* yylocationp);
339 private:
340 /* Debugging. */
341 int yydebug_;
342 std::ostream* yycdebug_;
343#endif
344
345
346 /// \brief Reclaim the memory associated to a symbol.
347 /// \param yymsg Why this token is reclaimed.
348 /// \param yytype The symbol type.
349 /// \param yyvaluep Its semantic value.
350 /// \param yylocationp Its location.
351 inline void yydestruct_ (const char* yymsg,
352 int yytype,
353 semantic_type* yyvaluep,
354 location_type* yylocationp);
355
356]b4_parse_param_vars[
357 };
358
359]dnl Redirections for glr.c.
360b4_percent_define_flag_if([[global_tokens_and_yystype]],
361[b4_token_defines(b4_tokens)])
362[
363#ifndef YYSTYPE
364# define YYSTYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type
365#endif
366#ifndef YYLTYPE
367# define YYLTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type
368#endif
369
370]b4_namespace_close[
371
372]b4_percent_code_get([[provides]])[]dnl
373
374[#endif /* ! defined PARSER_HEADER_H */]
375m4_divert_pop(0)