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

Last change on this file since 2226 was 2226, checked in by touky, 7 years ago

Added CSG v0.001a : not optimized, too much operation makes it slow. triangle count is not optimized.
Useage : "...[.... csg*]" equals "current mesh -CSG- the mesh in the braces".
Keywords : CsgUnion<csgu>, CsgSubstract<csgs>, CsgAnd<csga>, CsgXor<csgx>
TODO : cleanup useless code.
TODO : Some bugs are still present, some face that disappear should not.
TODO : Correct epsilon useage (see geometry files).
TODO : Coplanar face are not handled -at all-.
TODO : Vertex count goes through the roof in case of a Xor.

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