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

Last change on this file since 2116 was 2116, checked in by touky, 8 years ago

Added tsw (ToggleScaleWinding) command in EasyMesh Parser to make old-school celShading contour.

File size: 9.8 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; } 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_CHAMFER = 278,
156     T_CYLINDER = 279,
157     T_BOX = 280,
158     T_SMOOTHCHAMFBOX = 281,
159     T_FLATCHAMFBOX = 282,
160     T_SPHERE = 283,
161     T_CAPSULE = 284,
162     T_STAR = 285,
163     T_EXPANDEDSTAR = 286,
164     T_DISC = 287,
165     T_TRIANGLE = 288,
166     T_QUAD = 289,
167     T_COG = 290,
168     T_TORUS = 291,
169     T_ERROR = 292,
170     NUMBER = 293,
171     COLOR = 294
172   };
173
174    };
175    /// Token type.
176    typedef token::yytokentype token_type;
177
178    /// Build a parser object.
179    EasyMeshParser (class EasyMeshCompiler& mc_yyarg);
180    virtual ~EasyMeshParser ();
181
182    /// Parse.
183    /// \returns  0 iff parsing succeeded.
184    virtual int parse ();
185
186#if YYDEBUG
187    /// The current debugging stream.
188    std::ostream& debug_stream () const;
189    /// Set the current debugging stream.
190    void set_debug_stream (std::ostream &);
191
192    /// Type for debugging levels.
193    typedef int debug_level_type;
194    /// The current debugging level.
195    debug_level_type debug_level () const;
196    /// Set the current debugging level.
197    void set_debug_level (debug_level_type l);
198#endif
199
200  private:
201    /// Report a syntax error.
202    /// \param loc    where the syntax error is found.
203    /// \param msg    a description of the syntax error.
204    virtual void error (const location_type& loc, const std::string& msg);
205
206    /// Generate an error message.
207    /// \param state   the state where the error occurred.
208    /// \param tok     the lookahead token.
209    virtual std::string yysyntax_error_ (int yystate, int tok);
210
211#if YYDEBUG
212    /// \brief Report a symbol value on the debug stream.
213    /// \param yytype       The token type.
214    /// \param yyvaluep     Its semantic value.
215    /// \param yylocationp  Its location.
216    virtual void yy_symbol_value_print_ (int yytype,
217                                         const semantic_type* yyvaluep,
218                                         const location_type* yylocationp);
219    /// \brief Report a symbol on the debug stream.
220    /// \param yytype       The token type.
221    /// \param yyvaluep     Its semantic value.
222    /// \param yylocationp  Its location.
223    virtual void yy_symbol_print_ (int yytype,
224                                   const semantic_type* yyvaluep,
225                                   const location_type* yylocationp);
226#endif
227
228
229    /// State numbers.
230    typedef int state_type;
231    /// State stack type.
232    typedef stack<state_type>    state_stack_type;
233    /// Semantic value stack type.
234    typedef stack<semantic_type> semantic_stack_type;
235    /// location stack type.
236    typedef stack<location_type> location_stack_type;
237
238    /// The state stack.
239    state_stack_type yystate_stack_;
240    /// The semantic value stack.
241    semantic_stack_type yysemantic_stack_;
242    /// The location stack.
243    location_stack_type yylocation_stack_;
244
245    /// Internal symbol numbers.
246    typedef unsigned char token_number_type;
247    /* Tables.  */
248    /// For a state, the index in \a yytable_ of its portion.
249    static const signed char yypact_[];
250    static const signed char yypact_ninf_;
251
252    /// For a state, default rule to reduce.
253    /// Unless\a  yytable_ specifies something else to do.
254    /// Zero means the default is an error.
255    static const unsigned char yydefact_[];
256
257    static const signed char yypgoto_[];
258    static const signed char yydefgoto_[];
259
260    /// What to do in a state.
261    /// \a yytable_[yypact_[s]]: what to do in state \a s.
262    /// - if positive, shift that token.
263    /// - if negative, reduce the rule which number is the opposite.
264    /// - if zero, do what YYDEFACT says.
265    static const unsigned char yytable_[];
266    static const signed char yytable_ninf_;
267
268    static const signed char yycheck_[];
269
270    /// For a state, its accessing symbol.
271    static const unsigned char yystos_[];
272
273    /// For a rule, its LHS.
274    static const unsigned char yyr1_[];
275    /// For a rule, its RHS length.
276    static const unsigned char yyr2_[];
277
278#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
279    /// For a symbol, its name in clear.
280    static const char* const yytname_[];
281#endif
282
283#if YYERROR_VERBOSE
284    /// Convert the symbol name \a n to a form suitable for a diagnostic.
285    virtual std::string yytnamerr_ (const char *n);
286#endif
287
288#if YYDEBUG
289    /// A type to store symbol numbers and -1.
290    typedef signed char rhs_number_type;
291    /// A `-1'-separated list of the rules' RHS.
292    static const rhs_number_type yyrhs_[];
293    /// For each rule, the index of the first RHS symbol in \a yyrhs_.
294    static const unsigned char yyprhs_[];
295    /// For each rule, its source line number.
296    static const unsigned char yyrline_[];
297    /// For each scanner token number, its symbol number.
298    static const unsigned short int yytoken_number_[];
299    /// Report on the debug stream that the rule \a r is going to be reduced.
300    virtual void yy_reduce_print_ (int r);
301    /// Print the state stack on the debug stream.
302    virtual void yystack_print_ ();
303
304    /* Debugging.  */
305    int yydebug_;
306    std::ostream* yycdebug_;
307#endif
308
309    /// Convert a scanner token number \a t to a symbol number.
310    token_number_type yytranslate_ (int t);
311
312    /// \brief Reclaim the memory associated to a symbol.
313    /// \param yymsg        Why this token is reclaimed.
314    /// \param yytype       The symbol type.
315    /// \param yyvaluep     Its semantic value.
316    /// \param yylocationp  Its location.
317    inline void yydestruct_ (const char* yymsg,
318                             int yytype,
319                             semantic_type* yyvaluep,
320                             location_type* yylocationp);
321
322    /// Pop \a n symbols the three stacks.
323    inline void yypop_ (unsigned int n = 1);
324
325    /* Constants.  */
326    static const int yyeof_;
327    /* LAST_ -- Last index in TABLE_.  */
328    static const int yylast_;
329    static const int yynnts_;
330    static const int yyempty_;
331    static const int yyfinal_;
332    static const int yyterror_;
333    static const int yyerrcode_;
334    static const int yyntokens_;
335    static const unsigned int yyuser_token_number_max_;
336    static const token_number_type yyundef_token_;
337
338    /* User arguments.  */
339    class EasyMeshCompiler& mc;
340  };
341
342} // lol
343
344/* Line 34 of lalr1.cc  */
345#line 346 "generated/easymesh-parser.h"
346
347
348
349#endif /* ! defined PARSER_HEADER_H */
Note: See TracBrowser for help on using the repository browser.