source: trunk/src/generated/easymesh-parser.h @ 2318

Last change on this file since 2318 was 2318, checked in by sam, 7 years ago

build: fix all vector/scalar type mismatches such as "vec2 * double"
instead of "vec2 * float".

File size: 9.5 KB
Line 
1/* A Bison parser, made by GNU Bison 2.5.  */
2
3/* Skeleton interface for Bison LALR(1) parsers in C++
4   
5      Copyright (C) 2002-2011 Free Software Foundation, 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/* As a special exception, you may create a larger work that contains
21   part or all of the Bison parser skeleton and distribute that work
22   under terms of your choice, so long as that work isn't itself a
23   parser generator using the skeleton or a modified version thereof
24   as a parser skeleton.  Alternatively, if you modify or redistribute
25   the parser skeleton itself, you may (at your option) remove this
26   special exception, which will cause the skeleton and the resulting
27   Bison output files to be licensed under the GNU General Public
28   License without this special exception.
29   
30   This special exception was added by the Free Software Foundation in
31   version 2.2 of Bison.  */
32
33/* C++ LALR(1) parser skeleton written by Akim Demaille.  */
34
35#ifndef PARSER_HEADER_H
36# define PARSER_HEADER_H
37
38
39
40#include <string>
41#include <iostream>
42#include "stack.hh"
43#include "location.hh"
44
45/* Enabling traces.  */
46#ifndef YYDEBUG
47# define YYDEBUG 1
48#endif
49
50/* Enabling verbose error messages.  */
51#ifdef YYERROR_VERBOSE
52# undef YYERROR_VERBOSE
53# define YYERROR_VERBOSE 1
54#else
55# define YYERROR_VERBOSE 1
56#endif
57
58/* Enabling the token table.  */
59#ifndef YYTOKEN_TABLE
60# define YYTOKEN_TABLE 0
61#endif
62
63
64namespace lol {
65
66/* Line 35 of lalr1.cc  */
67#line 68 "generated/easymesh-parser.h"
68
69  /// A Bison parser.
70  class EasyMeshParser
71  {
72  public:
73    /// Symbol semantic values.
74#ifndef YYSTYPE
75    union semantic_type
76    {
77
78/* Line 35 of lalr1.cc  */
79#line 36 "easymesh/easymesh-parser.y"
80
81    float fval;
82    /* Can't use uin32_t here for some reason */
83    unsigned u32val;
84    struct { float f0, f1, f2, f3, f4, f5, f6, f7, f8, f9; } args;
85
86
87
88/* Line 35 of lalr1.cc  */
89#line 90 "generated/easymesh-parser.h"
90    };
91#else
92    typedef YYSTYPE semantic_type;
93#endif
94    /// Symbol locations.
95    typedef location location_type;
96    /// Tokens.
97    struct token
98    {
99      /* Tokens.  */
100   enum yytokentype {
101     T_END = 0,
102     T_COLOR = 258,
103     T_BGCOLOR = 259,
104     T_TRANSLATEX = 260,
105     T_ROTATEX = 261,
106     T_TAPERX = 262,
107     T_SCALEX = 263,
108     T_MIRRORX = 264,
109     T_TRANSLATEY = 265,
110     T_ROTATEY = 266,
111     T_TAPERY = 267,
112     T_SCALEY = 268,
113     T_MIRRORY = 269,
114     T_TRANSLATEZ = 270,
115     T_ROTATEZ = 271,
116     T_TAPERZ = 272,
117     T_SCALEZ = 273,
118     T_MIRRORZ = 274,
119     T_TRANSLATE = 275,
120     T_SCALE = 276,
121     T_TOGGLESCALEWINDING = 277,
122     T_RADIALJITTER = 278,
123     T_CSGUNION = 279,
124     T_CSGSUBSTRACT = 280,
125     T_CSGAND = 281,
126     T_CSGXOR = 282,
127     T_CHAMFER = 283,
128     T_CYLINDER = 284,
129     T_BOX = 285,
130     T_SMOOTHCHAMFBOX = 286,
131     T_FLATCHAMFBOX = 287,
132     T_SPHERE = 288,
133     T_CAPSULE = 289,
134     T_STAR = 290,
135     T_EXPANDEDSTAR = 291,
136     T_DISC = 292,
137     T_TRIANGLE = 293,
138     T_QUAD = 294,
139     T_COG = 295,
140     T_TORUS = 296,
141     T_ERROR = 297,
142     NUMBER = 298,
143     COLOR = 299
144   };
145
146    };
147    /// Token type.
148    typedef token::yytokentype token_type;
149
150    /// Build a parser object.
151    EasyMeshParser (class EasyMeshCompiler& mc_yyarg);
152    virtual ~EasyMeshParser ();
153
154    /// Parse.
155    /// \returns  0 iff parsing succeeded.
156    virtual int parse ();
157
158#if YYDEBUG
159    /// The current debugging stream.
160    std::ostream& debug_stream () const;
161    /// Set the current debugging stream.
162    void set_debug_stream (std::ostream &);
163
164    /// Type for debugging levels.
165    typedef int debug_level_type;
166    /// The current debugging level.
167    debug_level_type debug_level () const;
168    /// Set the current debugging level.
169    void set_debug_level (debug_level_type l);
170#endif
171
172  private:
173    /// Report a syntax error.
174    /// \param loc    where the syntax error is found.
175    /// \param msg    a description of the syntax error.
176    virtual void error (const location_type& loc, const std::string& msg);
177
178    /// Generate an error message.
179    /// \param state   the state where the error occurred.
180    /// \param tok     the lookahead token.
181    virtual std::string yysyntax_error_ (int yystate, int tok);
182
183#if YYDEBUG
184    /// \brief Report a symbol value on the debug stream.
185    /// \param yytype       The token type.
186    /// \param yyvaluep     Its semantic value.
187    /// \param yylocationp  Its location.
188    virtual void yy_symbol_value_print_ (int yytype,
189                                         const semantic_type* yyvaluep,
190                                         const location_type* yylocationp);
191    /// \brief Report a symbol on the debug stream.
192    /// \param yytype       The token type.
193    /// \param yyvaluep     Its semantic value.
194    /// \param yylocationp  Its location.
195    virtual void yy_symbol_print_ (int yytype,
196                                   const semantic_type* yyvaluep,
197                                   const location_type* yylocationp);
198#endif
199
200
201    /// State numbers.
202    typedef int state_type;
203    /// State stack type.
204    typedef stack<state_type>    state_stack_type;
205    /// Semantic value stack type.
206    typedef stack<semantic_type> semantic_stack_type;
207    /// location stack type.
208    typedef stack<location_type> location_stack_type;
209
210    /// The state stack.
211    state_stack_type yystate_stack_;
212    /// The semantic value stack.
213    semantic_stack_type yysemantic_stack_;
214    /// The location stack.
215    location_stack_type yylocation_stack_;
216
217    /// Whether the given \c yypact_ value indicates a defaulted state.
218    /// \param yyvalue   the value to check
219    static bool yy_pact_value_is_default_ (int yyvalue);
220
221    /// Whether the given \c yytable_ value indicates a syntax error.
222    /// \param yyvalue   the value to check
223    static bool yy_table_value_is_error_ (int yyvalue);
224
225    /// Internal symbol numbers.
226    typedef unsigned char token_number_type;
227    /* Tables.  */
228    /// For a state, the index in \a yytable_ of its portion.
229    static const signed char yypact_[];
230    static const signed char yypact_ninf_;
231
232    /// For a state, default reduction number.
233    /// Unless\a  yytable_ specifies something else to do.
234    /// Zero means the default is an error.
235    static const unsigned char yydefact_[];
236
237    static const signed char yypgoto_[];
238    static const signed char yydefgoto_[];
239
240    /// What to do in a state.
241    /// \a yytable_[yypact_[s]]: what to do in state \a s.
242    /// - if positive, shift that token.
243    /// - if negative, reduce the rule which number is the opposite.
244    /// - if zero, do what YYDEFACT says.
245    static const unsigned char yytable_[];
246    static const signed char yytable_ninf_;
247
248    static const signed char yycheck_[];
249
250    /// For a state, its accessing symbol.
251    static const unsigned char yystos_[];
252
253    /// For a rule, its LHS.
254    static const unsigned char yyr1_[];
255    /// For a rule, its RHS length.
256    static const unsigned char yyr2_[];
257
258#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
259    /// For a symbol, its name in clear.
260    static const char* const yytname_[];
261#endif
262
263    /// Convert the symbol name \a n to a form suitable for a diagnostic.
264    static std::string yytnamerr_ (const char *n);
265
266#if YYDEBUG
267    /// A type to store symbol numbers and -1.
268    typedef signed char rhs_number_type;
269    /// A `-1'-separated list of the rules' RHS.
270    static const rhs_number_type yyrhs_[];
271    /// For each rule, the index of the first RHS symbol in \a yyrhs_.
272    static const unsigned char yyprhs_[];
273    /// For each rule, its source line number.
274    static const unsigned char yyrline_[];
275    /// For each scanner token number, its symbol number.
276    static const unsigned short int yytoken_number_[];
277    /// Report on the debug stream that the rule \a r is going to be reduced.
278    virtual void yy_reduce_print_ (int r);
279    /// Print the state stack on the debug stream.
280    virtual void yystack_print_ ();
281
282    /* Debugging.  */
283    int yydebug_;
284    std::ostream* yycdebug_;
285#endif
286
287    /// Convert a scanner token number \a t to a symbol number.
288    token_number_type yytranslate_ (int t);
289
290    /// \brief Reclaim the memory associated to a symbol.
291    /// \param yymsg        Why this token is reclaimed.
292    /// \param yytype       The symbol type.
293    /// \param yyvaluep     Its semantic value.
294    /// \param yylocationp  Its location.
295    inline void yydestruct_ (const char* yymsg,
296                             int yytype,
297                             semantic_type* yyvaluep,
298                             location_type* yylocationp);
299
300    /// Pop \a n symbols the three stacks.
301    inline void yypop_ (unsigned int n = 1);
302
303    /* Constants.  */
304    static const int yyeof_;
305    /* LAST_ -- Last index in TABLE_.  */
306    static const int yylast_;
307    static const int yynnts_;
308    static const int yyempty_;
309    static const int yyfinal_;
310    static const int yyterror_;
311    static const int yyerrcode_;
312    static const int yyntokens_;
313    static const unsigned int yyuser_token_number_max_;
314    static const token_number_type yyundef_token_;
315
316    /* User arguments.  */
317    class EasyMeshCompiler& mc;
318  };
319
320} // lol
321
322/* Line 35 of lalr1.cc  */
323#line 324 "generated/easymesh-parser.h"
324
325
326
327#endif /* ! defined PARSER_HEADER_H */
Note: See TracBrowser for help on using the repository browser.