source: trunk/src/generated/easymesh-parser.cpp @ 1835

Last change on this file since 1835 was 1835, checked in by sam, 8 years ago

easymesh: fix an data corruption with scaling along a single axis.

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