source: trunk/src/generated/easymesh-parser.cpp @ 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.

  • Property svn:keywords set to Id
File size: 43.2 KB
Line 
1/* A Bison parser, made by GNU Bison 2.4.2.  */
2
3/* Skeleton implementation 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// Take the name prefix into account.
34#define yylex   lollex
35
36/* First part of user declarations.  */
37
38/* Line 310 of lalr1.cc  */
39#line 1 "easymesh/easymesh-parser.y"
40
41//
42// Lol Engine
43//
44// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>
45//            (c) 2009-2013 Cédric Lecacheur <jordx@free.fr>
46//            (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
47//   This program is free software; you can redistribute it and/or
48//   modify it under the terms of the Do What The Fuck You Want To
49//   Public License, Version 2, as published by Sam Hocevar. See
50//   http://www.wtfpl.net/ for more details.
51//
52
53#if defined HAVE_CONFIG_H
54#   include "config.h"
55#endif
56
57#include "core.h"
58#include "easymesh/easymesh.h"
59
60#include <string>
61
62
63
64/* Line 310 of lalr1.cc  */
65#line 66 "generated/easymesh-parser.cpp"
66
67
68#include "easymesh-parser.h"
69
70/* User implementation prologue.  */
71
72/* Line 316 of lalr1.cc  */
73#line 66 "easymesh/easymesh-parser.y"
74
75#include "easymesh/easymesh-compiler.h"
76
77#undef yylex
78#define yylex mc.m_lexer->lex
79
80
81/* Line 316 of lalr1.cc  */
82#line 83 "generated/easymesh-parser.cpp"
83
84#ifndef YY_
85# if defined YYENABLE_NLS && YYENABLE_NLS
86#  if ENABLE_NLS
87#   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
88#   define YY_(msgid) dgettext ("bison-runtime", msgid)
89#  endif
90# endif
91# ifndef YY_
92#  define YY_(msgid) msgid
93# endif
94#endif
95
96/* Suppress unused-variable warnings by "using" E.  */
97#define YYUSE(e) ((void) (e))
98
99/* Enable debugging if requested.  */
100#if YYDEBUG
101
102/* A pseudo ostream that takes yydebug_ into account.  */
103# define YYCDEBUG if (yydebug_) (*yycdebug_)
104
105# define YY_SYMBOL_PRINT(Title, Type, Value, Location)  \
106do {                                                    \
107  if (yydebug_)                                         \
108    {                                                   \
109      *yycdebug_ << Title << ' ';                       \
110      yy_symbol_print_ ((Type), (Value), (Location));   \
111      *yycdebug_ << std::endl;                          \
112    }                                                   \
113} while (false)
114
115# define YY_REDUCE_PRINT(Rule)          \
116do {                                    \
117  if (yydebug_)                         \
118    yy_reduce_print_ (Rule);            \
119} while (false)
120
121# define YY_STACK_PRINT()               \
122do {                                    \
123  if (yydebug_)                         \
124    yystack_print_ ();                  \
125} while (false)
126
127#else /* !YYDEBUG */
128
129# define YYCDEBUG if (false) std::cerr
130# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
131# define YY_REDUCE_PRINT(Rule)
132# define YY_STACK_PRINT()
133
134#endif /* !YYDEBUG */
135
136#define yyerrok         (yyerrstatus_ = 0)
137#define yyclearin       (yychar = yyempty_)
138
139#define YYACCEPT        goto yyacceptlab
140#define YYABORT         goto yyabortlab
141#define YYERROR         goto yyerrorlab
142#define YYRECOVERING()  (!!yyerrstatus_)
143
144
145namespace lol {
146
147/* Line 379 of lalr1.cc  */
148#line 149 "generated/easymesh-parser.cpp"
149#if YYERROR_VERBOSE
150
151  /* Return YYSTR after stripping away unnecessary quotes and
152     backslashes, so that it's suitable for yyerror.  The heuristic is
153     that double-quoting is unnecessary unless the string contains an
154     apostrophe, a comma, or backslash (other than backslash-backslash).
155     YYSTR is taken from yytname.  */
156  std::string
157  EasyMeshParser::yytnamerr_ (const char *yystr)
158  {
159    if (*yystr == '"')
160      {
161        std::string yyr = "";
162        char const *yyp = yystr;
163
164        for (;;)
165          switch (*++yyp)
166            {
167            case '\'':
168            case ',':
169              goto do_not_strip_quotes;
170
171            case '\\':
172              if (*++yyp != '\\')
173                goto do_not_strip_quotes;
174              /* Fall through.  */
175            default:
176              yyr += *yyp;
177              break;
178
179            case '"':
180              return yyr;
181            }
182      do_not_strip_quotes: ;
183      }
184
185    return yystr;
186  }
187
188#endif
189
190  /// Build a parser object.
191  EasyMeshParser::EasyMeshParser (class EasyMeshCompiler& mc_yyarg)
192    :
193#if YYDEBUG
194      yydebug_ (false),
195      yycdebug_ (&std::cerr),
196#endif
197      mc (mc_yyarg)
198  {
199  }
200
201  EasyMeshParser::~EasyMeshParser ()
202  {
203  }
204
205#if YYDEBUG
206  /*--------------------------------.
207  | Print this symbol on YYOUTPUT.  |
208  `--------------------------------*/
209
210  inline void
211  EasyMeshParser::yy_symbol_value_print_ (int yytype,
212                           const semantic_type* yyvaluep, const location_type* yylocationp)
213  {
214    YYUSE (yylocationp);
215    YYUSE (yyvaluep);
216    switch (yytype)
217      {
218         default:
219          break;
220      }
221  }
222
223
224  void
225  EasyMeshParser::yy_symbol_print_ (int yytype,
226                           const semantic_type* yyvaluep, const location_type* yylocationp)
227  {
228    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
229               << ' ' << yytname_[yytype] << " ("
230               << *yylocationp << ": ";
231    yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
232    *yycdebug_ << ')';
233  }
234#endif
235
236  void
237  EasyMeshParser::yydestruct_ (const char* yymsg,
238                           int yytype, semantic_type* yyvaluep, location_type* yylocationp)
239  {
240    YYUSE (yylocationp);
241    YYUSE (yymsg);
242    YYUSE (yyvaluep);
243
244    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
245
246    switch (yytype)
247      {
248 
249        default:
250          break;
251      }
252  }
253
254  void
255  EasyMeshParser::yypop_ (unsigned int n)
256  {
257    yystate_stack_.pop (n);
258    yysemantic_stack_.pop (n);
259    yylocation_stack_.pop (n);
260  }
261
262#if YYDEBUG
263  std::ostream&
264  EasyMeshParser::debug_stream () const
265  {
266    return *yycdebug_;
267  }
268
269  void
270  EasyMeshParser::set_debug_stream (std::ostream& o)
271  {
272    yycdebug_ = &o;
273  }
274
275
276  EasyMeshParser::debug_level_type
277  EasyMeshParser::debug_level () const
278  {
279    return yydebug_;
280  }
281
282  void
283  EasyMeshParser::set_debug_level (debug_level_type l)
284  {
285    yydebug_ = l;
286  }
287#endif
288
289  int
290  EasyMeshParser::parse ()
291  {
292    /// Lookahead and lookahead in internal form.
293    int yychar = yyempty_;
294    int yytoken = 0;
295
296    /* State.  */
297    int yyn;
298    int yylen = 0;
299    int yystate = 0;
300
301    /* Error handling.  */
302    int yynerrs_ = 0;
303    int yyerrstatus_ = 0;
304
305    /// Semantic value of the lookahead.
306    semantic_type yylval;
307    /// Location of the lookahead.
308    location_type yylloc;
309    /// The locations where the error started and ended.
310    location_type yyerror_range[2];
311
312    /// $$.
313    semantic_type yyval;
314    /// @$.
315    location_type yyloc;
316
317    int yyresult;
318
319    YYCDEBUG << "Starting parse" << std::endl;
320
321
322    /* Initialize the stacks.  The initial state will be pushed in
323       yynewstate, since the latter expects the semantical and the
324       location values to have been already stored, initialize these
325       stacks with a primary value.  */
326    yystate_stack_ = state_stack_type (0);
327    yysemantic_stack_ = semantic_stack_type (0);
328    yylocation_stack_ = location_stack_type (0);
329    yysemantic_stack_.push (yylval);
330    yylocation_stack_.push (yylloc);
331
332    /* New state.  */
333  yynewstate:
334    yystate_stack_.push (yystate);
335    YYCDEBUG << "Entering state " << yystate << std::endl;
336
337    /* Accept?  */
338    if (yystate == yyfinal_)
339      goto yyacceptlab;
340
341    goto yybackup;
342
343    /* Backup.  */
344  yybackup:
345
346    /* Try to take a decision without lookahead.  */
347    yyn = yypact_[yystate];
348    if (yyn == yypact_ninf_)
349      goto yydefault;
350
351    /* Read a lookahead token.  */
352    if (yychar == yyempty_)
353      {
354        YYCDEBUG << "Reading a token: ";
355        yychar = yylex (&yylval, &yylloc);
356      }
357
358
359    /* Convert token to internal form.  */
360    if (yychar <= yyeof_)
361      {
362        yychar = yytoken = yyeof_;
363        YYCDEBUG << "Now at end of input." << std::endl;
364      }
365    else
366      {
367        yytoken = yytranslate_ (yychar);
368        YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
369      }
370
371    /* If the proper action on seeing token YYTOKEN is to reduce or to
372       detect an error, take that action.  */
373    yyn += yytoken;
374    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
375      goto yydefault;
376
377    /* Reduce or error.  */
378    yyn = yytable_[yyn];
379    if (yyn <= 0)
380      {
381        if (yyn == 0 || yyn == yytable_ninf_)
382        goto yyerrlab;
383        yyn = -yyn;
384        goto yyreduce;
385      }
386
387    /* Shift the lookahead token.  */
388    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
389
390    /* Discard the token being shifted.  */
391    yychar = yyempty_;
392
393    yysemantic_stack_.push (yylval);
394    yylocation_stack_.push (yylloc);
395
396    /* Count tokens shifted since error; after three, turn off error
397       status.  */
398    if (yyerrstatus_)
399      --yyerrstatus_;
400
401    yystate = yyn;
402    goto yynewstate;
403
404  /*-----------------------------------------------------------.
405  | yydefault -- do the default action for the current state.  |
406  `-----------------------------------------------------------*/
407  yydefault:
408    yyn = yydefact_[yystate];
409    if (yyn == 0)
410      goto yyerrlab;
411    goto yyreduce;
412
413  /*-----------------------------.
414  | yyreduce -- Do a reduction.  |
415  `-----------------------------*/
416  yyreduce:
417    yylen = yyr2_[yyn];
418    /* If YYLEN is nonzero, implement the default value of the action:
419       `$$ = $1'.  Otherwise, use the top of the stack.
420
421       Otherwise, the following line sets YYVAL to garbage.
422       This behavior is undocumented and Bison
423       users should not rely upon it.  */
424    if (yylen)
425      yyval = yysemantic_stack_[yylen - 1];
426    else
427      yyval = yysemantic_stack_[0];
428
429    {
430      slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
431      YYLLOC_DEFAULT (yyloc, slice, yylen);
432    }
433    YY_REDUCE_PRINT (yyn);
434    switch (yyn)
435      {
436          case 7:
437
438/* Line 677 of lalr1.cc  */
439#line 90 "easymesh/easymesh-parser.y"
440    { mc.m_mesh.OpenBrace(); }
441    break;
442
443  case 8:
444
445/* Line 677 of lalr1.cc  */
446#line 94 "easymesh/easymesh-parser.y"
447    { mc.m_mesh.CloseBrace(); }
448    break;
449
450  case 14:
451
452/* Line 677 of lalr1.cc  */
453#line 109 "easymesh/easymesh-parser.y"
454    { mc.m_mesh.SetCurColor(vec4((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3)); }
455    break;
456
457  case 15:
458
459/* Line 677 of lalr1.cc  */
460#line 110 "easymesh/easymesh-parser.y"
461    { uint32_t x = (yysemantic_stack_[(2) - (2)].u32val);
462                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
463                      mc.m_mesh.SetCurColor(vec4(v) * (1. / 255)); }
464    break;
465
466  case 16:
467
468/* Line 677 of lalr1.cc  */
469#line 113 "easymesh/easymesh-parser.y"
470    { mc.m_mesh.SetCurColor2(vec4((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3)); }
471    break;
472
473  case 17:
474
475/* Line 677 of lalr1.cc  */
476#line 114 "easymesh/easymesh-parser.y"
477    { uint32_t x = (yysemantic_stack_[(2) - (2)].u32val);
478                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
479                      mc.m_mesh.SetCurColor2(vec4(v) * (1. / 255)); }
480    break;
481
482  case 18:
483
484/* Line 677 of lalr1.cc  */
485#line 120 "easymesh/easymesh-parser.y"
486    { mc.m_mesh.Chamfer((yysemantic_stack_[(2) - (2)].args).f0); }
487    break;
488
489  case 19:
490
491/* Line 677 of lalr1.cc  */
492#line 121 "easymesh/easymesh-parser.y"
493    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, 0, 0)); }
494    break;
495
496  case 20:
497
498/* Line 677 of lalr1.cc  */
499#line 122 "easymesh/easymesh-parser.y"
500    { mc.m_mesh.Translate(vec3(0, (yysemantic_stack_[(2) - (2)].args).f0, 0)); }
501    break;
502
503  case 21:
504
505/* Line 677 of lalr1.cc  */
506#line 123 "easymesh/easymesh-parser.y"
507    { mc.m_mesh.Translate(vec3(0, 0, (yysemantic_stack_[(2) - (2)].args).f0)); }
508    break;
509
510  case 22:
511
512/* Line 677 of lalr1.cc  */
513#line 124 "easymesh/easymesh-parser.y"
514    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
515    break;
516
517  case 23:
518
519/* Line 677 of lalr1.cc  */
520#line 125 "easymesh/easymesh-parser.y"
521    { mc.m_mesh.RotateX((yysemantic_stack_[(2) - (2)].args).f0); }
522    break;
523
524  case 24:
525
526/* Line 677 of lalr1.cc  */
527#line 126 "easymesh/easymesh-parser.y"
528    { mc.m_mesh.RotateY((yysemantic_stack_[(2) - (2)].args).f0); }
529    break;
530
531  case 25:
532
533/* Line 677 of lalr1.cc  */
534#line 127 "easymesh/easymesh-parser.y"
535    { mc.m_mesh.RotateZ((yysemantic_stack_[(2) - (2)].args).f0); }
536    break;
537
538  case 26:
539
540/* Line 677 of lalr1.cc  */
541#line 128 "easymesh/easymesh-parser.y"
542    { mc.m_mesh.TaperX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
543    break;
544
545  case 27:
546
547/* Line 677 of lalr1.cc  */
548#line 129 "easymesh/easymesh-parser.y"
549    { mc.m_mesh.TaperY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
550    break;
551
552  case 28:
553
554/* Line 677 of lalr1.cc  */
555#line 130 "easymesh/easymesh-parser.y"
556    { mc.m_mesh.TaperZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
557    break;
558
559  case 29:
560
561/* Line 677 of lalr1.cc  */
562#line 131 "easymesh/easymesh-parser.y"
563    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, 1.0, 1.0)); }
564    break;
565
566  case 30:
567
568/* Line 677 of lalr1.cc  */
569#line 132 "easymesh/easymesh-parser.y"
570    { mc.m_mesh.Scale(vec3(1.0, (yysemantic_stack_[(2) - (2)].args).f0, 1.0)); }
571    break;
572
573  case 31:
574
575/* Line 677 of lalr1.cc  */
576#line 133 "easymesh/easymesh-parser.y"
577    { mc.m_mesh.Scale(vec3(1.0, 1.0, (yysemantic_stack_[(2) - (2)].args).f0)); }
578    break;
579
580  case 32:
581
582/* Line 677 of lalr1.cc  */
583#line 134 "easymesh/easymesh-parser.y"
584    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
585    break;
586
587  case 33:
588
589/* Line 677 of lalr1.cc  */
590#line 135 "easymesh/easymesh-parser.y"
591    { mc.m_mesh.MirrorX(); }
592    break;
593
594  case 34:
595
596/* Line 677 of lalr1.cc  */
597#line 136 "easymesh/easymesh-parser.y"
598    { mc.m_mesh.MirrorY(); }
599    break;
600
601  case 35:
602
603/* Line 677 of lalr1.cc  */
604#line 137 "easymesh/easymesh-parser.y"
605    { mc.m_mesh.MirrorZ(); }
606    break;
607
608  case 36:
609
610/* Line 677 of lalr1.cc  */
611#line 138 "easymesh/easymesh-parser.y"
612    { mc.m_mesh.ToggleScaleWinding(); }
613    break;
614
615  case 37:
616
617/* Line 677 of lalr1.cc  */
618#line 139 "easymesh/easymesh-parser.y"
619    { mc.m_mesh.CsgUnion(); }
620    break;
621
622  case 38:
623
624/* Line 677 of lalr1.cc  */
625#line 140 "easymesh/easymesh-parser.y"
626    { mc.m_mesh.CsgSubstract(); }
627    break;
628
629  case 39:
630
631/* Line 677 of lalr1.cc  */
632#line 141 "easymesh/easymesh-parser.y"
633    { mc.m_mesh.CsgAnd(); }
634    break;
635
636  case 40:
637
638/* Line 677 of lalr1.cc  */
639#line 142 "easymesh/easymesh-parser.y"
640    { mc.m_mesh.CsgXor(); }
641    break;
642
643  case 41:
644
645/* Line 677 of lalr1.cc  */
646#line 146 "easymesh/easymesh-parser.y"
647    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
648                                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3,
649                                                 (int)(yysemantic_stack_[(2) - (2)].args).f4, (int)(yysemantic_stack_[(2) - (2)].args).f5); }
650    break;
651
652  case 42:
653
654/* Line 677 of lalr1.cc  */
655#line 149 "easymesh/easymesh-parser.y"
656    { mc.m_mesh.AppendBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
657    break;
658
659  case 43:
660
661/* Line 677 of lalr1.cc  */
662#line 150 "easymesh/easymesh-parser.y"
663    { mc.m_mesh.AppendSmoothChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
664                                                            (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
665    break;
666
667  case 44:
668
669/* Line 677 of lalr1.cc  */
670#line 152 "easymesh/easymesh-parser.y"
671    { mc.m_mesh.AppendFlatChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
672                                                          (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
673    break;
674
675  case 45:
676
677/* Line 677 of lalr1.cc  */
678#line 154 "easymesh/easymesh-parser.y"
679    { mc.m_mesh.AppendSphere((yysemantic_stack_[(2) - (2)].args).f0,
680                                               vec3((yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3)); }
681    break;
682
683  case 46:
684
685/* Line 677 of lalr1.cc  */
686#line 156 "easymesh/easymesh-parser.y"
687    { mc.m_mesh.AppendCapsule((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
688    break;
689
690  case 47:
691
692/* Line 677 of lalr1.cc  */
693#line 157 "easymesh/easymesh-parser.y"
694    { mc.m_mesh.AppendTorus((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
695    break;
696
697  case 48:
698
699/* Line 677 of lalr1.cc  */
700#line 158 "easymesh/easymesh-parser.y"
701    { mc.m_mesh.AppendStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2,
702                                             (int)(yysemantic_stack_[(2) - (2)].args).f3, (int)(yysemantic_stack_[(2) - (2)].args).f4); }
703    break;
704
705  case 49:
706
707/* Line 677 of lalr1.cc  */
708#line 160 "easymesh/easymesh-parser.y"
709    { mc.m_mesh.AppendExpandedStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
710                                                     (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
711    break;
712
713  case 50:
714
715/* Line 677 of lalr1.cc  */
716#line 162 "easymesh/easymesh-parser.y"
717    { mc.m_mesh.AppendDisc((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (int)(yysemantic_stack_[(2) - (2)].args).f2); }
718    break;
719
720  case 51:
721
722/* Line 677 of lalr1.cc  */
723#line 163 "easymesh/easymesh-parser.y"
724    { mc.m_mesh.AppendSimpleTriangle((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
725    break;
726
727  case 52:
728
729/* Line 677 of lalr1.cc  */
730#line 164 "easymesh/easymesh-parser.y"
731    { mc.m_mesh.AppendSimpleQuad((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
732    break;
733
734  case 53:
735
736/* Line 677 of lalr1.cc  */
737#line 165 "easymesh/easymesh-parser.y"
738    { mc.m_mesh.AppendCog((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
739                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3, (yysemantic_stack_[(2) - (2)].args).f4, (yysemantic_stack_[(2) - (2)].args).f5, (yysemantic_stack_[(2) - (2)].args).f6,
740                                 (yysemantic_stack_[(2) - (2)].args).f7, (yysemantic_stack_[(2) - (2)].args).f8, (int)(yysemantic_stack_[(2) - (2)].args).f9); }
741    break;
742
743  case 54:
744
745/* Line 677 of lalr1.cc  */
746#line 170 "easymesh/easymesh-parser.y"
747    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
748    break;
749
750  case 55:
751
752/* Line 677 of lalr1.cc  */
753#line 171 "easymesh/easymesh-parser.y"
754    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(2) - (2)].fval); }
755    break;
756
757  case 56:
758
759/* Line 677 of lalr1.cc  */
760#line 172 "easymesh/easymesh-parser.y"
761    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(2) - (2)].fval); }
762    break;
763
764  case 57:
765
766/* Line 677 of lalr1.cc  */
767#line 173 "easymesh/easymesh-parser.y"
768    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f3 = (yysemantic_stack_[(2) - (2)].fval); }
769    break;
770
771  case 58:
772
773/* Line 677 of lalr1.cc  */
774#line 174 "easymesh/easymesh-parser.y"
775    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f4 = (yysemantic_stack_[(2) - (2)].fval); }
776    break;
777
778  case 59:
779
780/* Line 677 of lalr1.cc  */
781#line 175 "easymesh/easymesh-parser.y"
782    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f5 = (yysemantic_stack_[(2) - (2)].fval); }
783    break;
784
785  case 60:
786
787/* Line 677 of lalr1.cc  */
788#line 176 "easymesh/easymesh-parser.y"
789    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f6 = (yysemantic_stack_[(2) - (2)].fval); }
790    break;
791
792  case 61:
793
794/* Line 677 of lalr1.cc  */
795#line 177 "easymesh/easymesh-parser.y"
796    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f7 = (yysemantic_stack_[(2) - (2)].fval); }
797    break;
798
799  case 62:
800
801/* Line 677 of lalr1.cc  */
802#line 178 "easymesh/easymesh-parser.y"
803    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f8 = (yysemantic_stack_[(2) - (2)].fval); }
804    break;
805
806  case 63:
807
808/* Line 677 of lalr1.cc  */
809#line 179 "easymesh/easymesh-parser.y"
810    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f9 = (yysemantic_stack_[(2) - (2)].fval); }
811    break;
812
813  case 64:
814
815/* Line 677 of lalr1.cc  */
816#line 182 "easymesh/easymesh-parser.y"
817    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
818    break;
819
820  case 65:
821
822/* Line 677 of lalr1.cc  */
823#line 183 "easymesh/easymesh-parser.y"
824    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
825    break;
826
827
828
829/* Line 677 of lalr1.cc  */
830#line 831 "generated/easymesh-parser.cpp"
831        default:
832          break;
833      }
834    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
835
836    yypop_ (yylen);
837    yylen = 0;
838    YY_STACK_PRINT ();
839
840    yysemantic_stack_.push (yyval);
841    yylocation_stack_.push (yyloc);
842
843    /* Shift the result of the reduction.  */
844    yyn = yyr1_[yyn];
845    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
846    if (0 <= yystate && yystate <= yylast_
847        && yycheck_[yystate] == yystate_stack_[0])
848      yystate = yytable_[yystate];
849    else
850      yystate = yydefgoto_[yyn - yyntokens_];
851    goto yynewstate;
852
853  /*------------------------------------.
854  | yyerrlab -- here on detecting error |
855  `------------------------------------*/
856  yyerrlab:
857    /* If not already recovering from an error, report this error.  */
858    if (!yyerrstatus_)
859      {
860        ++yynerrs_;
861        error (yylloc, yysyntax_error_ (yystate, yytoken));
862      }
863
864    yyerror_range[0] = yylloc;
865    if (yyerrstatus_ == 3)
866      {
867        /* If just tried and failed to reuse lookahead token after an
868         error, discard it.  */
869
870        if (yychar <= yyeof_)
871          {
872          /* Return failure if at end of input.  */
873          if (yychar == yyeof_)
874            YYABORT;
875          }
876        else
877          {
878            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
879            yychar = yyempty_;
880          }
881      }
882
883    /* Else will try to reuse lookahead token after shifting the error
884       token.  */
885    goto yyerrlab1;
886
887
888  /*---------------------------------------------------.
889  | yyerrorlab -- error raised explicitly by YYERROR.  |
890  `---------------------------------------------------*/
891  yyerrorlab:
892
893    /* Pacify compilers like GCC when the user code never invokes
894       YYERROR and the label yyerrorlab therefore never appears in user
895       code.  */
896    if (false)
897      goto yyerrorlab;
898
899    yyerror_range[0] = yylocation_stack_[yylen - 1];
900    /* Do not reclaim the symbols of the rule which action triggered
901       this YYERROR.  */
902    yypop_ (yylen);
903    yylen = 0;
904    yystate = yystate_stack_[0];
905    goto yyerrlab1;
906
907  /*-------------------------------------------------------------.
908  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
909  `-------------------------------------------------------------*/
910  yyerrlab1:
911    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
912
913    for (;;)
914      {
915        yyn = yypact_[yystate];
916        if (yyn != yypact_ninf_)
917        {
918          yyn += yyterror_;
919          if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
920            {
921              yyn = yytable_[yyn];
922              if (0 < yyn)
923                break;
924            }
925        }
926
927        /* Pop the current state because it cannot handle the error token.  */
928        if (yystate_stack_.height () == 1)
929        YYABORT;
930
931        yyerror_range[0] = yylocation_stack_[0];
932        yydestruct_ ("Error: popping",
933                     yystos_[yystate],
934                     &yysemantic_stack_[0], &yylocation_stack_[0]);
935        yypop_ ();
936        yystate = yystate_stack_[0];
937        YY_STACK_PRINT ();
938      }
939
940    yyerror_range[1] = yylloc;
941    // Using YYLLOC is tempting, but would change the location of
942    // the lookahead.  YYLOC is available though.
943    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
944    yysemantic_stack_.push (yylval);
945    yylocation_stack_.push (yyloc);
946
947    /* Shift the error token.  */
948    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
949                     &yysemantic_stack_[0], &yylocation_stack_[0]);
950
951    yystate = yyn;
952    goto yynewstate;
953
954    /* Accept.  */
955  yyacceptlab:
956    yyresult = 0;
957    goto yyreturn;
958
959    /* Abort.  */
960  yyabortlab:
961    yyresult = 1;
962    goto yyreturn;
963
964  yyreturn:
965    if (yychar != yyempty_)
966      yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
967
968    /* Do not reclaim the symbols of the rule which action triggered
969       this YYABORT or YYACCEPT.  */
970    yypop_ (yylen);
971    while (yystate_stack_.height () != 1)
972      {
973        yydestruct_ ("Cleanup: popping",
974                   yystos_[yystate_stack_[0]],
975                   &yysemantic_stack_[0],
976                   &yylocation_stack_[0]);
977        yypop_ ();
978      }
979
980    return yyresult;
981  }
982
983  // Generate an error message.
984  std::string
985  EasyMeshParser::yysyntax_error_ (int yystate, int tok)
986  {
987    std::string res;
988    YYUSE (yystate);
989#if YYERROR_VERBOSE
990    int yyn = yypact_[yystate];
991    if (yypact_ninf_ < yyn && yyn <= yylast_)
992      {
993        /* Start YYX at -YYN if negative to avoid negative indexes in
994           YYCHECK.  */
995        int yyxbegin = yyn < 0 ? -yyn : 0;
996
997        /* Stay within bounds of both yycheck and yytname.  */
998        int yychecklim = yylast_ - yyn + 1;
999        int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1000        int count = 0;
1001        for (int x = yyxbegin; x < yyxend; ++x)
1002          if (yycheck_[x + yyn] == x && x != yyterror_)
1003            ++count;
1004
1005        // FIXME: This method of building the message is not compatible
1006        // with internationalization.  It should work like yacc.c does it.
1007        // That is, first build a string that looks like this:
1008        // "syntax error, unexpected %s or %s or %s"
1009        // Then, invoke YY_ on this string.
1010        // Finally, use the string as a format to output
1011        // yytname_[tok], etc.
1012        // Until this gets fixed, this message appears in English only.
1013        res = "syntax error, unexpected ";
1014        res += yytnamerr_ (yytname_[tok]);
1015        if (count < 5)
1016          {
1017            count = 0;
1018            for (int x = yyxbegin; x < yyxend; ++x)
1019              if (yycheck_[x + yyn] == x && x != yyterror_)
1020                {
1021                  res += (!count++) ? ", expecting " : " or ";
1022                  res += yytnamerr_ (yytname_[x]);
1023                }
1024          }
1025      }
1026    else
1027#endif
1028      res = YY_("syntax error");
1029    return res;
1030  }
1031
1032
1033  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1034     STATE-NUM.  */
1035  const signed char EasyMeshParser::yypact_ninf_ = -10;
1036  const signed char
1037  EasyMeshParser::yypact_[] =
1038  {
1039        -3,    18,    27,    16,    16,    16,    16,   -10,    16,    16,
1040      16,    16,   -10,    16,    16,    16,    16,   -10,    16,    16,
1041     -10,   -10,   -10,   -10,   -10,    16,    16,    16,    16,    16,
1042      16,    16,    16,    16,    16,    16,    16,    16,    16,   -10,
1043      40,    48,    -3,    -3,    79,   -10,   -10,   -10,   -10,   -10,
1044     -10,    16,    16,    16,    16,   -10,   -10,   -10,   -10,   -10,
1045     -10,   -10,   -10,   -10,   -10,   -10,   -10,   -10,   -10,   -10,
1046     -10,   -10,   -10,   -10,    16,    16,   -10,   -10,   -10,   -10,
1047     -10,   -10,   -10,   -10,   -10,   -10,   -10,    16,    16,    16,
1048      16,   -10,   -10,   -10,   -10,   -10,     5,   -10,   -10,   -10,
1049     -10,   -10,   -10,   -10,   -10,   -10,   -10,   -10,   -10,   -10
1050  };
1051
1052  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
1053     doesn't specify something else to do.  Zero means the default is an
1054     error.  */
1055  const unsigned char
1056  EasyMeshParser::yydefact_[] =
1057  {
1058         0,     0,     0,     0,     0,     0,     0,    33,     0,     0,
1059       0,     0,    34,     0,     0,     0,     0,    35,     0,     0,
1060      36,    37,    38,    39,    40,     0,     0,     0,     0,     0,
1061       0,     0,     0,     0,     0,     0,     0,     0,     0,     7,
1062       0,     0,     3,     0,     5,     9,    11,    12,    13,    64,
1063      15,     0,     0,     0,     0,    14,    54,    17,    16,    19,
1064      23,    26,    29,    20,    24,    27,    30,    21,    25,    28,
1065      31,    22,    32,    18,     0,     0,    41,    42,    43,    44,
1066      45,    46,    48,    49,    50,    51,    52,     0,     0,     0,
1067       0,    53,    47,     1,     2,     4,     0,    10,    65,    55,
1068      56,    57,    58,    59,    60,    61,    62,    63,     8,     6
1069  };
1070
1071  /* YYPGOTO[NTERM-NUM].  */
1072  const signed char
1073  EasyMeshParser::yypgoto_[] =
1074  {
1075       -10,   -10,    -4,   -10,   -10,   -10,   -10,     9,   -10,   -10,
1076     -10,    43,    36,   115,   122,    23,    26,   -10,   -10,   -10,
1077     -10,    -9
1078  };
1079
1080  /* YYDEFGOTO[NTERM-NUM].  */
1081  const signed char
1082  EasyMeshParser::yydefgoto_[] =
1083  {
1084        -1,    40,    41,    42,    43,   109,    44,    45,    46,    47,
1085      48,    52,    53,    54,    74,    75,    76,    88,    89,    90,
1086      91,    56
1087  };
1088
1089  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1090     positive, shift that token.  If negative, reduce the rule which
1091     number is the opposite.  If zero, do what YYDEFACT says.  */
1092  const signed char EasyMeshParser::yytable_ninf_ = -1;
1093  const unsigned char
1094  EasyMeshParser::yytable_[] =
1095  {
1096         1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
1097      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
1098      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
1099      31,    32,    33,    34,    35,    36,    37,    38,    95,    96,
1100      93,    39,    98,    99,   100,   101,    59,    60,    94,    62,
1101     108,    63,    64,    97,    66,    82,    67,    68,    49,    70,
1102      49,    50,    51,    87,    51,   102,   103,     0,    73,    49,
1103      57,    85,    86,    51,     0,     0,     0,     0,   104,   105,
1104     106,   107,     1,     2,     3,     4,     5,     6,     7,     8,
1105       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
1106      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
1107      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
1108      61,     0,     0,    55,    58,    65,     0,     0,     0,     0,
1109      69,     0,     0,    71,    72,     0,     0,     0,     0,     0,
1110       0,     0,    77,     0,     0,     0,    81,     0,     0,    84,
1111      78,    79,    80,    92,     0,    83
1112  };
1113
1114  /* YYCHECK.  */
1115  const signed char
1116  EasyMeshParser::yycheck_[] =
1117  {
1118         3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
1119      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
1120      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
1121      33,    34,    35,    36,    37,    38,    39,    40,    42,    43,
1122       0,    44,    51,    52,    53,    54,     3,     4,     0,     6,
1123      45,     8,     9,    44,    11,    32,    13,    14,    42,    16,
1124      42,    43,    46,    37,    46,    74,    75,    -1,    25,    42,
1125      43,    35,    36,    46,    -1,    -1,    -1,    -1,    87,    88,
1126      89,    90,     3,     4,     5,     6,     7,     8,     9,    10,
1127      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
1128      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
1129      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
1130       5,    -1,    -1,     1,     2,    10,    -1,    -1,    -1,    -1,
1131      15,    -1,    -1,    18,    19,    -1,    -1,    -1,    -1,    -1,
1132      -1,    -1,    27,    -1,    -1,    -1,    31,    -1,    -1,    34,
1133      28,    29,    30,    38,    -1,    33
1134  };
1135
1136  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1137     symbol of state STATE-NUM.  */
1138  const unsigned char
1139  EasyMeshParser::yystos_[] =
1140  {
1141         0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
1142      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1143      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1144      32,    33,    34,    35,    36,    37,    38,    39,    40,    44,
1145      48,    49,    50,    51,    53,    54,    55,    56,    57,    42,
1146      43,    46,    58,    59,    60,    61,    68,    43,    61,    58,
1147      58,    60,    58,    58,    58,    60,    58,    58,    58,    60,
1148      58,    60,    60,    58,    61,    62,    63,    60,    61,    61,
1149      61,    60,    62,    61,    60,    59,    59,    63,    64,    65,
1150      66,    67,    60,     0,     0,    49,    49,    54,    68,    68,
1151      68,    68,    68,    68,    68,    68,    68,    68,    45,    52
1152  };
1153
1154#if YYDEBUG
1155  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1156     to YYLEX-NUM.  */
1157  const unsigned short int
1158  EasyMeshParser::yytoken_number_[] =
1159  {
1160         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1161     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1162     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1163     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1164     295,   296,   297,   298,    91,    93,    45
1165  };
1166#endif
1167
1168  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1169  const unsigned char
1170  EasyMeshParser::yyr1_[] =
1171  {
1172         0,    47,    48,    49,    49,    50,    50,    51,    52,    53,
1173      53,    54,    54,    54,    55,    55,    55,    55,    56,    56,
1174      56,    56,    56,    56,    56,    56,    56,    56,    56,    56,
1175      56,    56,    56,    56,    56,    56,    56,    56,    56,    56,
1176      56,    57,    57,    57,    57,    57,    57,    57,    57,    57,
1177      57,    57,    57,    57,    58,    59,    60,    61,    62,    63,
1178      64,    65,    66,    67,    68,    68
1179  };
1180
1181  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1182  const unsigned char
1183  EasyMeshParser::yyr2_[] =
1184  {
1185         0,     2,     2,     1,     2,     1,     3,     1,     1,     1,
1186       2,     1,     1,     1,     2,     2,     2,     2,     2,     2,
1187       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1188       2,     2,     2,     1,     1,     1,     1,     1,     1,     1,
1189       1,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1190       2,     2,     2,     2,     1,     2,     2,     2,     2,     2,
1191       2,     2,     2,     2,     1,     2
1192  };
1193
1194#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1195  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1196     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
1197  const char*
1198  const EasyMeshParser::yytname_[] =
1199  {
1200    "T_END", "error", "$undefined", "T_COLOR", "T_BGCOLOR", "T_TRANSLATEX",
1201  "T_ROTATEX", "T_TAPERX", "T_SCALEX", "T_MIRRORX", "T_TRANSLATEY",
1202  "T_ROTATEY", "T_TAPERY", "T_SCALEY", "T_MIRRORY", "T_TRANSLATEZ",
1203  "T_ROTATEZ", "T_TAPERZ", "T_SCALEZ", "T_MIRRORZ", "T_TRANSLATE",
1204  "T_SCALE", "T_TOGGLESCALEWINDING", "T_CSGUNION", "T_CSGSUBSTRACT",
1205  "T_CSGAND", "T_CSGXOR", "T_CHAMFER", "T_CYLINDER", "T_BOX",
1206  "T_SMOOTHCHAMFBOX", "T_FLATCHAMFBOX", "T_SPHERE", "T_CAPSULE", "T_STAR",
1207  "T_EXPANDEDSTAR", "T_DISC", "T_TRIANGLE", "T_QUAD", "T_COG", "T_TORUS",
1208  "T_ERROR", "NUMBER", "COLOR", "'['", "']'", "'-'", "$accept",
1209  "mesh_description", "mesh_expression_list", "mesh_expression",
1210  "mesh_open", "mesh_close", "mesh_command_list", "mesh_command",
1211  "color_command", "transform_command", "primitive_command", "args1",
1212  "args2", "args3", "args4", "args5", "args6", "args7", "args8", "args9",
1213  "args10", "number", 0
1214  };
1215#endif
1216
1217#if YYDEBUG
1218  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1219  const EasyMeshParser::rhs_number_type
1220  EasyMeshParser::yyrhs_[] =
1221  {
1222        48,     0,    -1,    49,     0,    -1,    50,    -1,    50,    49,
1223      -1,    53,    -1,    51,    49,    52,    -1,    44,    -1,    45,
1224      -1,    54,    -1,    53,    54,    -1,    55,    -1,    56,    -1,
1225      57,    -1,     3,    61,    -1,     3,    43,    -1,     4,    61,
1226      -1,     4,    43,    -1,    27,    58,    -1,     5,    58,    -1,
1227      10,    58,    -1,    15,    58,    -1,    20,    60,    -1,     6,
1228      58,    -1,    11,    58,    -1,    16,    58,    -1,     7,    60,
1229      -1,    12,    60,    -1,    17,    60,    -1,     8,    58,    -1,
1230      13,    58,    -1,    18,    58,    -1,    21,    60,    -1,     9,
1231      -1,    14,    -1,    19,    -1,    22,    -1,    23,    -1,    24,
1232      -1,    25,    -1,    26,    -1,    28,    63,    -1,    29,    60,
1233      -1,    30,    61,    -1,    31,    61,    -1,    32,    61,    -1,
1234      33,    60,    -1,    40,    60,    -1,    34,    62,    -1,    35,
1235      61,    -1,    36,    60,    -1,    37,    59,    -1,    38,    59,
1236      -1,    39,    67,    -1,    68,    -1,    58,    68,    -1,    59,
1237      68,    -1,    60,    68,    -1,    61,    68,    -1,    62,    68,
1238      -1,    63,    68,    -1,    64,    68,    -1,    65,    68,    -1,
1239      66,    68,    -1,    42,    -1,    46,    68,    -1
1240  };
1241
1242  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1243     YYRHS.  */
1244  const unsigned char
1245  EasyMeshParser::yyprhs_[] =
1246  {
1247         0,     0,     3,     6,     8,    11,    13,    17,    19,    21,
1248      23,    26,    28,    30,    32,    35,    38,    41,    44,    47,
1249      50,    53,    56,    59,    62,    65,    68,    71,    74,    77,
1250      80,    83,    86,    89,    91,    93,    95,    97,    99,   101,
1251     103,   105,   108,   111,   114,   117,   120,   123,   126,   129,
1252     132,   135,   138,   141,   144,   146,   149,   152,   155,   158,
1253     161,   164,   167,   170,   173,   175
1254  };
1255
1256  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
1257  const unsigned char
1258  EasyMeshParser::yyrline_[] =
1259  {
1260         0,    76,    76,    80,    81,    85,    86,    90,    94,    98,
1261      99,   103,   104,   105,   109,   110,   113,   114,   120,   121,
1262     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
1263     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
1264     142,   146,   149,   150,   152,   154,   156,   157,   158,   160,
1265     162,   163,   164,   165,   170,   171,   172,   173,   174,   175,
1266     176,   177,   178,   179,   182,   183
1267  };
1268
1269  // Print the state stack on the debug stream.
1270  void
1271  EasyMeshParser::yystack_print_ ()
1272  {
1273    *yycdebug_ << "Stack now";
1274    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1275         i != yystate_stack_.end (); ++i)
1276      *yycdebug_ << ' ' << *i;
1277    *yycdebug_ << std::endl;
1278  }
1279
1280  // Report on the debug stream that the rule \a yyrule is going to be reduced.
1281  void
1282  EasyMeshParser::yy_reduce_print_ (int yyrule)
1283  {
1284    unsigned int yylno = yyrline_[yyrule];
1285    int yynrhs = yyr2_[yyrule];
1286    /* Print the symbols being reduced, and their result.  */
1287    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1288               << " (line " << yylno << "):" << std::endl;
1289    /* The symbols being reduced.  */
1290    for (int yyi = 0; yyi < yynrhs; yyi++)
1291      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1292                       yyrhs_[yyprhs_[yyrule] + yyi],
1293                       &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1294                       &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1295  }
1296#endif // YYDEBUG
1297
1298  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1299  EasyMeshParser::token_number_type
1300  EasyMeshParser::yytranslate_ (int t)
1301  {
1302    static
1303    const token_number_type
1304    translate_table[] =
1305    {
1306           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1307       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1308       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1309       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1310       2,     2,     2,     2,     2,    46,     2,     2,     2,     2,
1311       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1312       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1313       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1314       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1315       2,    44,     2,    45,     2,     2,     2,     2,     2,     2,
1316       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1317       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1318       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1319       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1320       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1321       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1322       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1323       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1324       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1325       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1326       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1327       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1328       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1329       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1330       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1331       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1332       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1333      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1334      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1335      35,    36,    37,    38,    39,    40,    41,    42,    43
1336    };
1337    if ((unsigned int) t <= yyuser_token_number_max_)
1338      return translate_table[t];
1339    else
1340      return yyundef_token_;
1341  }
1342
1343  const int EasyMeshParser::yyeof_ = 0;
1344  const int EasyMeshParser::yylast_ = 155;
1345  const int EasyMeshParser::yynnts_ = 22;
1346  const int EasyMeshParser::yyempty_ = -2;
1347  const int EasyMeshParser::yyfinal_ = 93;
1348  const int EasyMeshParser::yyterror_ = 1;
1349  const int EasyMeshParser::yyerrcode_ = 256;
1350  const int EasyMeshParser::yyntokens_ = 47;
1351
1352  const unsigned int EasyMeshParser::yyuser_token_number_max_ = 298;
1353  const EasyMeshParser::token_number_type EasyMeshParser::yyundef_token_ = 2;
1354
1355
1356} // lol
1357
1358/* Line 1053 of lalr1.cc  */
1359#line 1360 "generated/easymesh-parser.cpp"
1360
1361
1362/* Line 1055 of lalr1.cc  */
1363#line 186 "easymesh/easymesh-parser.y"
1364
1365
1366void lol::EasyMeshParser::error(const EasyMeshParser::location_type& l,
1367                                const std::string& m)
1368{
1369    mc.Error(l, m);
1370}
1371
1372
Note: See TracBrowser for help on using the repository browser.