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

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

base: start removing occurrences of NULL on our long journey to nullptr.

  • Property svn:keywords set to Id
File size: 58.4 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-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 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 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 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 90 "easymesh/easymesh-parser.y"
470    { mc.m_mesh.OpenBrace(); }
471    break;
472
473  case 8:
474
475/* Line 690 of lalr1.cc  */
476#line 94 "easymesh/easymesh-parser.y"
477    { mc.m_mesh.CloseBrace(); }
478    break;
479
480  case 14:
481
482/* Line 690 of lalr1.cc  */
483#line 109 "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 110 "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.f / 255)); }
494    break;
495
496  case 16:
497
498/* Line 690 of lalr1.cc  */
499#line 113 "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 114 "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.f / 255)); }
510    break;
511
512  case 18:
513
514/* Line 690 of lalr1.cc  */
515#line 120 "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 121 "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 122 "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 123 "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 124 "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 125 "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 126 "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 127 "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 128 "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 129 "easymesh/easymesh-parser.y"
579    { mc.m_mesh.TaperX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
580    break;
581
582  case 28:
583
584/* Line 690 of lalr1.cc  */
585#line 130 "easymesh/easymesh-parser.y"
586    { mc.m_mesh.TaperY((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 131 "easymesh/easymesh-parser.y"
593    { mc.m_mesh.TaperY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
594    break;
595
596  case 30:
597
598/* Line 690 of lalr1.cc  */
599#line 132 "easymesh/easymesh-parser.y"
600    { mc.m_mesh.TaperZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
601    break;
602
603  case 31:
604
605/* Line 690 of lalr1.cc  */
606#line 133 "easymesh/easymesh-parser.y"
607    { mc.m_mesh.TaperZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
608    break;
609
610  case 32:
611
612/* Line 690 of lalr1.cc  */
613#line 134 "easymesh/easymesh-parser.y"
614    { mc.m_mesh.TwistX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
615    break;
616
617  case 33:
618
619/* Line 690 of lalr1.cc  */
620#line 135 "easymesh/easymesh-parser.y"
621    { mc.m_mesh.TwistY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
622    break;
623
624  case 34:
625
626/* Line 690 of lalr1.cc  */
627#line 136 "easymesh/easymesh-parser.y"
628    { mc.m_mesh.TwistZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
629    break;
630
631  case 35:
632
633/* Line 690 of lalr1.cc  */
634#line 137 "easymesh/easymesh-parser.y"
635    { mc.m_mesh.ShearX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
636    break;
637
638  case 36:
639
640/* Line 690 of lalr1.cc  */
641#line 138 "easymesh/easymesh-parser.y"
642    { mc.m_mesh.ShearX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
643    break;
644
645  case 37:
646
647/* Line 690 of lalr1.cc  */
648#line 139 "easymesh/easymesh-parser.y"
649    { mc.m_mesh.ShearY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
650    break;
651
652  case 38:
653
654/* Line 690 of lalr1.cc  */
655#line 140 "easymesh/easymesh-parser.y"
656    { mc.m_mesh.ShearY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
657    break;
658
659  case 39:
660
661/* Line 690 of lalr1.cc  */
662#line 141 "easymesh/easymesh-parser.y"
663    { mc.m_mesh.ShearZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
664    break;
665
666  case 40:
667
668/* Line 690 of lalr1.cc  */
669#line 142 "easymesh/easymesh-parser.y"
670    { mc.m_mesh.ShearZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
671    break;
672
673  case 41:
674
675/* Line 690 of lalr1.cc  */
676#line 143 "easymesh/easymesh-parser.y"
677    { mc.m_mesh.StretchX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
678    break;
679
680  case 42:
681
682/* Line 690 of lalr1.cc  */
683#line 144 "easymesh/easymesh-parser.y"
684    { mc.m_mesh.StretchY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
685    break;
686
687  case 43:
688
689/* Line 690 of lalr1.cc  */
690#line 145 "easymesh/easymesh-parser.y"
691    { mc.m_mesh.StretchZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
692    break;
693
694  case 44:
695
696/* Line 690 of lalr1.cc  */
697#line 146 "easymesh/easymesh-parser.y"
698    { mc.m_mesh.BendXY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
699    break;
700
701  case 45:
702
703/* Line 690 of lalr1.cc  */
704#line 147 "easymesh/easymesh-parser.y"
705    { mc.m_mesh.BendXZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
706    break;
707
708  case 46:
709
710/* Line 690 of lalr1.cc  */
711#line 148 "easymesh/easymesh-parser.y"
712    { mc.m_mesh.BendYX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
713    break;
714
715  case 47:
716
717/* Line 690 of lalr1.cc  */
718#line 149 "easymesh/easymesh-parser.y"
719    { mc.m_mesh.BendYZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
720    break;
721
722  case 48:
723
724/* Line 690 of lalr1.cc  */
725#line 150 "easymesh/easymesh-parser.y"
726    { mc.m_mesh.BendZX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
727    break;
728
729  case 49:
730
731/* Line 690 of lalr1.cc  */
732#line 151 "easymesh/easymesh-parser.y"
733    { mc.m_mesh.BendZY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
734    break;
735
736  case 50:
737
738/* Line 690 of lalr1.cc  */
739#line 152 "easymesh/easymesh-parser.y"
740    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, 1.0, 1.0)); }
741    break;
742
743  case 51:
744
745/* Line 690 of lalr1.cc  */
746#line 153 "easymesh/easymesh-parser.y"
747    { mc.m_mesh.Scale(vec3(1.0, (yysemantic_stack_[(2) - (2)].args).f0, 1.0)); }
748    break;
749
750  case 52:
751
752/* Line 690 of lalr1.cc  */
753#line 154 "easymesh/easymesh-parser.y"
754    { mc.m_mesh.Scale(vec3(1.0, 1.0, (yysemantic_stack_[(2) - (2)].args).f0)); }
755    break;
756
757  case 53:
758
759/* Line 690 of lalr1.cc  */
760#line 155 "easymesh/easymesh-parser.y"
761    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
762    break;
763
764  case 54:
765
766/* Line 690 of lalr1.cc  */
767#line 156 "easymesh/easymesh-parser.y"
768    { mc.m_mesh.MirrorX(); }
769    break;
770
771  case 55:
772
773/* Line 690 of lalr1.cc  */
774#line 157 "easymesh/easymesh-parser.y"
775    { mc.m_mesh.MirrorY(); }
776    break;
777
778  case 56:
779
780/* Line 690 of lalr1.cc  */
781#line 158 "easymesh/easymesh-parser.y"
782    { mc.m_mesh.MirrorZ(); }
783    break;
784
785  case 57:
786
787/* Line 690 of lalr1.cc  */
788#line 159 "easymesh/easymesh-parser.y"
789    { mc.m_mesh.RadialJitter((yysemantic_stack_[(2) - (2)].args).f0); }
790    break;
791
792  case 58:
793
794/* Line 690 of lalr1.cc  */
795#line 160 "easymesh/easymesh-parser.y"
796    { mc.m_mesh.SplitTriangles((yysemantic_stack_[(2) - (2)].args).f0); }
797    break;
798
799  case 59:
800
801/* Line 690 of lalr1.cc  */
802#line 161 "easymesh/easymesh-parser.y"
803    { mc.m_mesh.SmoothMesh((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
804    break;
805
806  case 60:
807
808/* Line 690 of lalr1.cc  */
809#line 162 "easymesh/easymesh-parser.y"
810    { mc.m_mesh.ToggleScaleWinding(); }
811    break;
812
813  case 61:
814
815/* Line 690 of lalr1.cc  */
816#line 163 "easymesh/easymesh-parser.y"
817    { mc.m_mesh.CsgUnion(); }
818    break;
819
820  case 62:
821
822/* Line 690 of lalr1.cc  */
823#line 164 "easymesh/easymesh-parser.y"
824    { mc.m_mesh.CsgSubstract(); }
825    break;
826
827  case 63:
828
829/* Line 690 of lalr1.cc  */
830#line 165 "easymesh/easymesh-parser.y"
831    { mc.m_mesh.CsgSubstractLoss(); }
832    break;
833
834  case 64:
835
836/* Line 690 of lalr1.cc  */
837#line 166 "easymesh/easymesh-parser.y"
838    { mc.m_mesh.CsgAnd(); }
839    break;
840
841  case 65:
842
843/* Line 690 of lalr1.cc  */
844#line 167 "easymesh/easymesh-parser.y"
845    { mc.m_mesh.CsgXor(); }
846    break;
847
848  case 66:
849
850/* Line 690 of lalr1.cc  */
851#line 171 "easymesh/easymesh-parser.y"
852    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
853                                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3,
854                                                 (int)(yysemantic_stack_[(2) - (2)].args).f4, (int)(yysemantic_stack_[(2) - (2)].args).f5, 0); }
855    break;
856
857  case 67:
858
859/* Line 690 of lalr1.cc  */
860#line 174 "easymesh/easymesh-parser.y"
861    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
862                                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3,
863                                                 (int)(yysemantic_stack_[(2) - (2)].args).f4, (int)(yysemantic_stack_[(2) - (2)].args).f5, (int)(yysemantic_stack_[(2) - (2)].args).f6); }
864    break;
865
866  case 68:
867
868/* Line 690 of lalr1.cc  */
869#line 177 "easymesh/easymesh-parser.y"
870    { mc.m_mesh.AppendBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
871    break;
872
873  case 69:
874
875/* Line 690 of lalr1.cc  */
876#line 178 "easymesh/easymesh-parser.y"
877    { mc.m_mesh.AppendSmoothChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
878                                                            (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
879    break;
880
881  case 70:
882
883/* Line 690 of lalr1.cc  */
884#line 180 "easymesh/easymesh-parser.y"
885    { mc.m_mesh.AppendFlatChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
886                                                          (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
887    break;
888
889  case 71:
890
891/* Line 690 of lalr1.cc  */
892#line 182 "easymesh/easymesh-parser.y"
893    { mc.m_mesh.AppendSphere((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
894    break;
895
896  case 72:
897
898/* Line 690 of lalr1.cc  */
899#line 183 "easymesh/easymesh-parser.y"
900    { mc.m_mesh.AppendCapsule((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
901    break;
902
903  case 73:
904
905/* Line 690 of lalr1.cc  */
906#line 184 "easymesh/easymesh-parser.y"
907    { mc.m_mesh.AppendTorus((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
908    break;
909
910  case 74:
911
912/* Line 690 of lalr1.cc  */
913#line 185 "easymesh/easymesh-parser.y"
914    { mc.m_mesh.AppendStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2,
915                                             (int)(yysemantic_stack_[(2) - (2)].args).f3, (int)(yysemantic_stack_[(2) - (2)].args).f4); }
916    break;
917
918  case 75:
919
920/* Line 690 of lalr1.cc  */
921#line 187 "easymesh/easymesh-parser.y"
922    { mc.m_mesh.AppendExpandedStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
923                                                     (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
924    break;
925
926  case 76:
927
928/* Line 690 of lalr1.cc  */
929#line 189 "easymesh/easymesh-parser.y"
930    { mc.m_mesh.AppendDisc((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (int)(yysemantic_stack_[(2) - (2)].args).f2); }
931    break;
932
933  case 77:
934
935/* Line 690 of lalr1.cc  */
936#line 190 "easymesh/easymesh-parser.y"
937    { mc.m_mesh.AppendSimpleTriangle((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
938    break;
939
940  case 78:
941
942/* Line 690 of lalr1.cc  */
943#line 191 "easymesh/easymesh-parser.y"
944    { mc.m_mesh.AppendSimpleQuad((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
945    break;
946
947  case 79:
948
949/* Line 690 of lalr1.cc  */
950#line 192 "easymesh/easymesh-parser.y"
951    { mc.m_mesh.AppendCog((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
952                                 (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,
953                                 (yysemantic_stack_[(2) - (2)].args).f7, (yysemantic_stack_[(2) - (2)].args).f8, (int)(yysemantic_stack_[(2) - (2)].args).f9); }
954    break;
955
956  case 80:
957
958/* Line 690 of lalr1.cc  */
959#line 197 "easymesh/easymesh-parser.y"
960    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
961    break;
962
963  case 81:
964
965/* Line 690 of lalr1.cc  */
966#line 198 "easymesh/easymesh-parser.y"
967    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(2) - (2)].fval); }
968    break;
969
970  case 82:
971
972/* Line 690 of lalr1.cc  */
973#line 199 "easymesh/easymesh-parser.y"
974    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(2) - (2)].fval); }
975    break;
976
977  case 83:
978
979/* Line 690 of lalr1.cc  */
980#line 200 "easymesh/easymesh-parser.y"
981    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f3 = (yysemantic_stack_[(2) - (2)].fval); }
982    break;
983
984  case 84:
985
986/* Line 690 of lalr1.cc  */
987#line 201 "easymesh/easymesh-parser.y"
988    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f4 = (yysemantic_stack_[(2) - (2)].fval); }
989    break;
990
991  case 85:
992
993/* Line 690 of lalr1.cc  */
994#line 202 "easymesh/easymesh-parser.y"
995    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f5 = (yysemantic_stack_[(2) - (2)].fval); }
996    break;
997
998  case 86:
999
1000/* Line 690 of lalr1.cc  */
1001#line 203 "easymesh/easymesh-parser.y"
1002    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f6 = (yysemantic_stack_[(2) - (2)].fval); }
1003    break;
1004
1005  case 87:
1006
1007/* Line 690 of lalr1.cc  */
1008#line 204 "easymesh/easymesh-parser.y"
1009    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f7 = (yysemantic_stack_[(2) - (2)].fval); }
1010    break;
1011
1012  case 88:
1013
1014/* Line 690 of lalr1.cc  */
1015#line 205 "easymesh/easymesh-parser.y"
1016    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f8 = (yysemantic_stack_[(2) - (2)].fval); }
1017    break;
1018
1019  case 89:
1020
1021/* Line 690 of lalr1.cc  */
1022#line 206 "easymesh/easymesh-parser.y"
1023    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f9 = (yysemantic_stack_[(2) - (2)].fval); }
1024    break;
1025
1026  case 90:
1027
1028/* Line 690 of lalr1.cc  */
1029#line 209 "easymesh/easymesh-parser.y"
1030    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
1031    break;
1032
1033  case 91:
1034
1035/* Line 690 of lalr1.cc  */
1036#line 210 "easymesh/easymesh-parser.y"
1037    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
1038    break;
1039
1040
1041
1042/* Line 690 of lalr1.cc  */
1043#line 1044 "generated/easymesh-parser.cpp"
1044        default:
1045          break;
1046      }
1047    /* User semantic actions sometimes alter yychar, and that requires
1048       that yytoken be updated with the new translation.  We take the
1049       approach of translating immediately before every use of yytoken.
1050       One alternative is translating here after every semantic action,
1051       but that translation would be missed if the semantic action
1052       invokes YYABORT, YYACCEPT, or YYERROR immediately after altering
1053       yychar.  In the case of YYABORT or YYACCEPT, an incorrect
1054       destructor might then be invoked immediately.  In the case of
1055       YYERROR, subsequent parser actions might lead to an incorrect
1056       destructor call or verbose syntax error message before the
1057       lookahead is translated.  */
1058    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
1059
1060    yypop_ (yylen);
1061    yylen = 0;
1062    YY_STACK_PRINT ();
1063
1064    yysemantic_stack_.push (yyval);
1065    yylocation_stack_.push (yyloc);
1066
1067    /* Shift the result of the reduction.  */
1068    yyn = yyr1_[yyn];
1069    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
1070    if (0 <= yystate && yystate <= yylast_
1071        && yycheck_[yystate] == yystate_stack_[0])
1072      yystate = yytable_[yystate];
1073    else
1074      yystate = yydefgoto_[yyn - yyntokens_];
1075    goto yynewstate;
1076
1077  /*------------------------------------.
1078  | yyerrlab -- here on detecting error |
1079  `------------------------------------*/
1080  yyerrlab:
1081    /* Make sure we have latest lookahead translation.  See comments at
1082       user semantic actions for why this is necessary.  */
1083    yytoken = yytranslate_ (yychar);
1084
1085    /* If not already recovering from an error, report this error.  */
1086    if (!yyerrstatus_)
1087      {
1088        ++yynerrs_;
1089        if (yychar == yyempty_)
1090          yytoken = yyempty_;
1091        error (yylloc, yysyntax_error_ (yystate, yytoken));
1092      }
1093
1094    yyerror_range[1] = yylloc;
1095    if (yyerrstatus_ == 3)
1096      {
1097        /* If just tried and failed to reuse lookahead token after an
1098         error, discard it.  */
1099
1100        if (yychar <= yyeof_)
1101          {
1102          /* Return failure if at end of input.  */
1103          if (yychar == yyeof_)
1104            YYABORT;
1105          }
1106        else
1107          {
1108            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
1109            yychar = yyempty_;
1110          }
1111      }
1112
1113    /* Else will try to reuse lookahead token after shifting the error
1114       token.  */
1115    goto yyerrlab1;
1116
1117
1118  /*---------------------------------------------------.
1119  | yyerrorlab -- error raised explicitly by YYERROR.  |
1120  `---------------------------------------------------*/
1121  yyerrorlab:
1122
1123    /* Pacify compilers like GCC when the user code never invokes
1124       YYERROR and the label yyerrorlab therefore never appears in user
1125       code.  */
1126    if (false)
1127      goto yyerrorlab;
1128
1129    yyerror_range[1] = yylocation_stack_[yylen - 1];
1130    /* Do not reclaim the symbols of the rule which action triggered
1131       this YYERROR.  */
1132    yypop_ (yylen);
1133    yylen = 0;
1134    yystate = yystate_stack_[0];
1135    goto yyerrlab1;
1136
1137  /*-------------------------------------------------------------.
1138  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1139  `-------------------------------------------------------------*/
1140  yyerrlab1:
1141    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
1142
1143    for (;;)
1144      {
1145        yyn = yypact_[yystate];
1146        if (!yy_pact_value_is_default_ (yyn))
1147        {
1148          yyn += yyterror_;
1149          if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
1150            {
1151              yyn = yytable_[yyn];
1152              if (0 < yyn)
1153                break;
1154            }
1155        }
1156
1157        /* Pop the current state because it cannot handle the error token.  */
1158        if (yystate_stack_.height () == 1)
1159        YYABORT;
1160
1161        yyerror_range[1] = yylocation_stack_[0];
1162        yydestruct_ ("Error: popping",
1163                     yystos_[yystate],
1164                     &yysemantic_stack_[0], &yylocation_stack_[0]);
1165        yypop_ ();
1166        yystate = yystate_stack_[0];
1167        YY_STACK_PRINT ();
1168      }
1169
1170    yyerror_range[2] = yylloc;
1171    // Using YYLLOC is tempting, but would change the location of
1172    // the lookahead.  YYLOC is available though.
1173    YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
1174    yysemantic_stack_.push (yylval);
1175    yylocation_stack_.push (yyloc);
1176
1177    /* Shift the error token.  */
1178    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
1179                     &yysemantic_stack_[0], &yylocation_stack_[0]);
1180
1181    yystate = yyn;
1182    goto yynewstate;
1183
1184    /* Accept.  */
1185  yyacceptlab:
1186    yyresult = 0;
1187    goto yyreturn;
1188
1189    /* Abort.  */
1190  yyabortlab:
1191    yyresult = 1;
1192    goto yyreturn;
1193
1194  yyreturn:
1195    if (yychar != yyempty_)
1196      {
1197        /* Make sure we have latest lookahead translation.  See comments
1198           at user semantic actions for why this is necessary.  */
1199        yytoken = yytranslate_ (yychar);
1200        yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
1201                     &yylloc);
1202      }
1203
1204    /* Do not reclaim the symbols of the rule which action triggered
1205       this YYABORT or YYACCEPT.  */
1206    yypop_ (yylen);
1207    while (yystate_stack_.height () != 1)
1208      {
1209        yydestruct_ ("Cleanup: popping",
1210                   yystos_[yystate_stack_[0]],
1211                   &yysemantic_stack_[0],
1212                   &yylocation_stack_[0]);
1213        yypop_ ();
1214      }
1215
1216    return yyresult;
1217  }
1218
1219  // Generate an error message.
1220  std::string
1221  EasyMeshParser::yysyntax_error_ (int yystate, int yytoken)
1222  {
1223    std::string yyres;
1224    // Number of reported tokens (one for the "unexpected", one per
1225    // "expected").
1226    size_t yycount = 0;
1227    // Its maximum.
1228    enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1229    // Arguments of yyformat.
1230    char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1231
1232    /* There are many possibilities here to consider:
1233       - If this state is a consistent state with a default action, then
1234         the only way this function was invoked is if the default action
1235         is an error action.  In that case, don't check for expected
1236         tokens because there are none.
1237       - The only way there can be no lookahead present (in yytoken) is
1238         if this state is a consistent state with a default action.
1239         Thus, detecting the absence of a lookahead is sufficient to
1240         determine that there is no unexpected or expected token to
1241         report.  In that case, just report a simple "syntax error".
1242       - Don't assume there isn't a lookahead just because this state is
1243         a consistent state with a default action.  There might have
1244         been a previous inconsistent state, consistent state with a
1245         non-default action, or user semantic action that manipulated
1246         yychar.
1247       - Of course, the expected token list depends on states to have
1248         correct lookahead information, and it depends on the parser not
1249         to perform extra reductions after fetching a lookahead from the
1250         scanner and before detecting a syntax error.  Thus, state
1251         merging (from LALR or IELR) and default reductions corrupt the
1252         expected token list.  However, the list is correct for
1253         canonical LR with one exception: it will still contain any
1254         token that will not be accepted due to an error action in a
1255         later state.
1256    */
1257    if (yytoken != yyempty_)
1258      {
1259        yyarg[yycount++] = yytname_[yytoken];
1260        int yyn = yypact_[yystate];
1261        if (!yy_pact_value_is_default_ (yyn))
1262          {
1263            /* Start YYX at -YYN if negative to avoid negative indexes in
1264               YYCHECK.  In other words, skip the first -YYN actions for
1265               this state because they are default actions.  */
1266            int yyxbegin = yyn < 0 ? -yyn : 0;
1267            /* Stay within bounds of both yycheck and yytname.  */
1268            int yychecklim = yylast_ - yyn + 1;
1269            int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1270            for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1271              if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
1272                  && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
1273                {
1274                  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1275                    {
1276                      yycount = 1;
1277                      break;
1278                    }
1279                  else
1280                    yyarg[yycount++] = yytname_[yyx];
1281                }
1282          }
1283      }
1284
1285    char const* yyformat = 0;
1286    switch (yycount)
1287      {
1288#define YYCASE_(N, S)                         \
1289        case N:                               \
1290          yyformat = S;                       \
1291        break
1292        YYCASE_(0, YY_("syntax error"));
1293        YYCASE_(1, YY_("syntax error, unexpected %s"));
1294        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1295        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1296        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1297        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1298#undef YYCASE_
1299      }
1300
1301    // Argument number.
1302    size_t yyi = 0;
1303    for (char const* yyp = yyformat; *yyp; ++yyp)
1304      if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1305        {
1306          yyres += yytnamerr_ (yyarg[yyi++]);
1307          ++yyp;
1308        }
1309      else
1310        yyres += *yyp;
1311    return yyres;
1312  }
1313
1314
1315  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1316     STATE-NUM.  */
1317  const signed char EasyMeshParser::yypact_ninf_ = -71;
1318  const signed char
1319  EasyMeshParser::yypact_[] =
1320  {
1321        62,   -42,   -25,   -49,   -49,   -49,   -49,   -49,   -49,   -49,
1322     -49,   -49,   -71,   -49,   -49,   -49,   -49,   -49,   -49,   -49,
1323     -49,   -49,   -71,   -49,   -49,   -49,   -49,   -49,   -49,   -49,
1324     -49,   -49,   -71,   -49,   -49,   -71,   -49,   -49,   -49,   -71,
1325     -71,   -71,   -71,   -71,   -49,   -49,   -49,   -49,   -49,   -49,
1326     -49,   -49,   -49,   -49,   -49,   -49,   -49,   -49,   -71,     4,
1327       6,    62,    62,   123,   -71,   -71,   -71,   -71,   -71,   -71,
1328     -49,   -49,   -49,   -49,   -71,   -71,   -71,   -71,   -71,   -71,
1329     -49,   -71,   -71,   -49,   -71,   -71,   -71,   -71,   -71,   -71,
1330     -71,   -49,   -71,   -71,   -49,   -71,   -71,   -71,   -71,   -71,
1331     -71,   -71,   -49,   -71,   -71,   -49,   -71,   -71,   -71,   -71,
1332     -71,   -71,   -71,   -71,   -71,   -71,   -71,   -49,   -49,   -49,
1333     -71,   -71,   -71,   -71,   -71,   -71,   -71,   -71,   -71,   -71,
1334     -71,   -49,   -49,   -49,   -49,   -71,   -71,   -71,   -71,   -71,
1335     -55,   -71,   -71,   -71,   -71,   -71,   -71,   -71,   -71,   -71,
1336     -71,   -71,   -71,   -71
1337  };
1338
1339  /* YYDEFACT[S] -- default reduction number in state S.  Performed when
1340     YYTABLE doesn't specify something else to do.  Zero means the
1341     default is an error.  */
1342  const unsigned char
1343  EasyMeshParser::yydefact_[] =
1344  {
1345         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1346       0,     0,    54,     0,     0,     0,     0,     0,     0,     0,
1347       0,     0,    55,     0,     0,     0,     0,     0,     0,     0,
1348       0,     0,    56,     0,     0,    60,     0,     0,     0,    61,
1349      62,    63,    64,    65,     0,     0,     0,     0,     0,     0,
1350       0,     0,     0,     0,     0,     0,     0,     0,     7,     0,
1351       0,     3,     0,     5,     9,    11,    12,    13,    90,    15,
1352       0,     0,     0,     0,    14,    80,    17,    16,    19,    23,
1353      26,    27,    32,    35,    36,    41,    44,    45,    50,    20,
1354      24,    28,    29,    33,    37,    38,    42,    46,    47,    51,
1355      21,    25,    30,    31,    34,    39,    40,    43,    48,    49,
1356      52,    22,    53,    57,    58,    59,    18,     0,     0,    66,
1357      67,    68,    69,    70,    71,    72,    74,    75,    76,    77,
1358      78,     0,     0,     0,     0,    79,    73,     1,     2,     4,
1359       0,    10,    91,    81,    82,    83,    84,    85,    86,    87,
1360      88,    89,     8,     6
1361  };
1362
1363  /* YYPGOTO[NTERM-NUM].  */
1364  const short int
1365  EasyMeshParser::yypgoto_[] =
1366  {
1367       -71,   -71,   -32,   -71,   -71,   -71,   -71,   -52,   -71,   -71,
1368     -71,   232,   184,     0,   182,   -37,   -34,   -30,   -71,   -71,
1369     -71,   -70
1370  };
1371
1372  /* YYDEFGOTO[NTERM-NUM].  */
1373  const short int
1374  EasyMeshParser::yydefgoto_[] =
1375  {
1376        -1,    59,    60,    61,    62,   153,    63,    64,    65,    66,
1377      67,    71,    72,    73,   117,   118,   119,   120,   133,   134,
1378     135,    75
1379  };
1380
1381  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1382     positive, shift that token.  If negative, reduce the rule which
1383     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
1384  const signed char EasyMeshParser::yytable_ninf_ = -1;
1385  const unsigned char
1386  EasyMeshParser::yytable_[] =
1387  {
1388       142,   143,   144,   145,   137,    80,   138,    83,    85,   152,
1389     145,   141,    68,   145,   126,    91,    70,    94,    96,    68,
1390      69,   145,   131,    70,   145,   102,   132,   105,   107,   139,
1391     140,     0,   145,   111,   112,   145,    68,    76,   115,     0,
1392      70,     0,     0,     0,     0,     0,   121,   146,   147,   148,
1393     125,     0,     0,   128,     0,     0,     0,   136,     0,     0,
1394       0,   148,   149,   150,   151,     1,     2,     3,     4,     5,
1395       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
1396      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
1397      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
1398      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
1399      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
1400      56,    57,     0,     0,     0,    58,     1,     2,     3,     4,
1401       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1402      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1403      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1404      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1405      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1406      55,    56,    57,    74,    77,     0,     0,    81,     0,    84,
1407      82,     0,     0,    86,    87,     0,     0,    92,     0,    95,
1408      93,     0,     0,    97,    98,     0,     0,   103,     0,   106,
1409     104,     0,     0,   108,   109,     0,     0,     0,     0,     0,
1410       0,     0,     0,     0,     0,     0,     0,     0,     0,   122,
1411     123,     0,     0,   124,   127,    78,    79,     0,   129,   130,
1412       0,     0,     0,    88,     0,    89,    90,     0,     0,     0,
1413       0,     0,     0,    99,     0,   100,   101,     0,     0,     0,
1414       0,     0,     0,   110,     0,     0,     0,     0,   113,   114,
1415       0,     0,     0,     0,     0,     0,   116
1416  };
1417
1418  /* YYCHECK.  */
1419  const short int
1420  EasyMeshParser::yycheck_[] =
1421  {
1422        70,    71,    72,    73,     0,     5,     0,     7,     8,    64,
1423      80,    63,    61,    83,    51,    15,    65,    17,    18,    61,
1424      62,    91,    56,    65,    94,    25,    56,    27,    28,    61,
1425      62,    -1,   102,    33,    34,   105,    61,    62,    38,    -1,
1426      65,    -1,    -1,    -1,    -1,    -1,    46,   117,   118,   119,
1427      50,    -1,    -1,    53,    -1,    -1,    -1,    57,    -1,    -1,
1428      -1,   131,   132,   133,   134,     3,     4,     5,     6,     7,
1429       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
1430      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
1431      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
1432      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
1433      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
1434      58,    59,    -1,    -1,    -1,    63,     3,     4,     5,     6,
1435       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1436      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
1437      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
1438      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1439      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
1440      57,    58,    59,     1,     2,    -1,    -1,     5,    -1,     7,
1441       6,    -1,    -1,     9,    10,    -1,    -1,    15,    -1,    17,
1442      16,    -1,    -1,    19,    20,    -1,    -1,    25,    -1,    27,
1443      26,    -1,    -1,    29,    30,    -1,    -1,    -1,    -1,    -1,
1444      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    47,
1445      48,    -1,    -1,    49,    52,     3,     4,    -1,    54,    55,
1446      -1,    -1,    -1,    11,    -1,    13,    14,    -1,    -1,    -1,
1447      -1,    -1,    -1,    21,    -1,    23,    24,    -1,    -1,    -1,
1448      -1,    -1,    -1,    31,    -1,    -1,    -1,    -1,    36,    37,
1449      -1,    -1,    -1,    -1,    -1,    -1,    44
1450  };
1451
1452  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1453     symbol of state STATE-NUM.  */
1454  const unsigned char
1455  EasyMeshParser::yystos_[] =
1456  {
1457         0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
1458      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1459      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1460      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
1461      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
1462      52,    53,    54,    55,    56,    57,    58,    59,    63,    67,
1463      68,    69,    70,    72,    73,    74,    75,    76,    61,    62,
1464      65,    77,    78,    79,    80,    87,    62,    80,    77,    77,
1465      79,    80,    78,    79,    80,    79,    78,    78,    77,    77,
1466      77,    79,    80,    78,    79,    80,    79,    78,    78,    77,
1467      77,    77,    79,    80,    78,    79,    80,    79,    78,    78,
1468      77,    79,    79,    77,    77,    79,    77,    80,    81,    82,
1469      83,    79,    80,    80,    78,    79,    81,    80,    79,    78,
1470      78,    82,    83,    84,    85,    86,    79,     0,     0,    68,
1471      68,    73,    87,    87,    87,    87,    87,    87,    87,    87,
1472      87,    87,    64,    71
1473  };
1474
1475#if YYDEBUG
1476  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1477     to YYLEX-NUM.  */
1478  const unsigned short int
1479  EasyMeshParser::yytoken_number_[] =
1480  {
1481         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1482     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1483     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1484     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1485     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1486     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
1487     315,   316,   317,    91,    93,    45
1488  };
1489#endif
1490
1491  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1492  const unsigned char
1493  EasyMeshParser::yyr1_[] =
1494  {
1495         0,    66,    67,    68,    68,    69,    69,    70,    71,    72,
1496      72,    73,    73,    73,    74,    74,    74,    74,    75,    75,
1497      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
1498      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
1499      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
1500      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
1501      75,    75,    75,    75,    75,    75,    76,    76,    76,    76,
1502      76,    76,    76,    76,    76,    76,    76,    76,    76,    76,
1503      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
1504      87,    87
1505  };
1506
1507  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1508  const unsigned char
1509  EasyMeshParser::yyr2_[] =
1510  {
1511         0,     2,     2,     1,     2,     1,     3,     1,     1,     1,
1512       2,     1,     1,     1,     2,     2,     2,     2,     2,     2,
1513       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1514       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1515       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1516       2,     2,     2,     2,     1,     1,     1,     2,     2,     2,
1517       1,     1,     1,     1,     1,     1,     2,     2,     2,     2,
1518       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1519       1,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1520       1,     2
1521  };
1522
1523#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1524  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1525     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
1526  const char*
1527  const EasyMeshParser::yytname_[] =
1528  {
1529    "T_END", "error", "$undefined", "T_COLOR", "T_BGCOLOR", "T_TRANSLATEX",
1530  "T_ROTATEX", "T_TAPERX", "T_TWISTX", "T_SHEARX", "T_STRETCHX",
1531  "T_BENDXY", "T_BENDXZ", "T_SCALEX", "T_MIRRORX", "T_TRANSLATEY",
1532  "T_ROTATEY", "T_TAPERY", "T_TWISTY", "T_SHEARY", "T_STRETCHY",
1533  "T_BENDYX", "T_BENDYZ", "T_SCALEY", "T_MIRRORY", "T_TRANSLATEZ",
1534  "T_ROTATEZ", "T_TAPERZ", "T_TWISTZ", "T_SHEARZ", "T_STRETCHZ",
1535  "T_BENDZX", "T_BENDZY", "T_SCALEZ", "T_MIRRORZ", "T_TRANSLATE",
1536  "T_SCALE", "T_TOGGLESCALEWINDING", "T_RADIALJITTER", "T_SPLITTRIANGLE",
1537  "T_SMOOTHMESH", "T_CSGUNION", "T_CSGSUBSTRACT", "T_CSGSUBSTRACTLOSS",
1538  "T_CSGAND", "T_CSGXOR", "T_CHAMFER", "T_CYLINDER", "T_BOX",
1539  "T_SMOOTHCHAMFBOX", "T_FLATCHAMFBOX", "T_SPHERE", "T_CAPSULE", "T_STAR",
1540  "T_EXPANDEDSTAR", "T_DISC", "T_TRIANGLE", "T_QUAD", "T_COG", "T_TORUS",
1541  "T_ERROR", "NUMBER", "COLOR", "'['", "']'", "'-'", "$accept",
1542  "mesh_description", "mesh_expression_list", "mesh_expression",
1543  "mesh_open", "mesh_close", "mesh_command_list", "mesh_command",
1544  "color_command", "transform_command", "primitive_command", "args1",
1545  "args2", "args3", "args4", "args5", "args6", "args7", "args8", "args9",
1546  "args10", "number", 0
1547  };
1548#endif
1549
1550#if YYDEBUG
1551  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1552  const EasyMeshParser::rhs_number_type
1553  EasyMeshParser::yyrhs_[] =
1554  {
1555        67,     0,    -1,    68,     0,    -1,    69,    -1,    69,    68,
1556      -1,    72,    -1,    70,    68,    71,    -1,    63,    -1,    64,
1557      -1,    73,    -1,    72,    73,    -1,    74,    -1,    75,    -1,
1558      76,    -1,     3,    80,    -1,     3,    62,    -1,     4,    80,
1559      -1,     4,    62,    -1,    46,    77,    -1,     5,    77,    -1,
1560      15,    77,    -1,    25,    77,    -1,    35,    79,    -1,     6,
1561      77,    -1,    16,    77,    -1,    26,    77,    -1,     7,    79,
1562      -1,     7,    80,    -1,    17,    79,    -1,    17,    80,    -1,
1563      27,    79,    -1,    27,    80,    -1,     8,    78,    -1,    18,
1564      78,    -1,    28,    78,    -1,     9,    79,    -1,     9,    80,
1565      -1,    19,    79,    -1,    19,    80,    -1,    29,    79,    -1,
1566      29,    80,    -1,    10,    79,    -1,    20,    79,    -1,    30,
1567      79,    -1,    11,    78,    -1,    12,    78,    -1,    21,    78,
1568      -1,    22,    78,    -1,    31,    78,    -1,    32,    78,    -1,
1569      13,    77,    -1,    23,    77,    -1,    33,    77,    -1,    36,
1570      79,    -1,    14,    -1,    24,    -1,    34,    -1,    38,    77,
1571      -1,    39,    77,    -1,    40,    79,    -1,    37,    -1,    41,
1572      -1,    42,    -1,    43,    -1,    44,    -1,    45,    -1,    47,
1573      82,    -1,    47,    83,    -1,    48,    79,    -1,    49,    80,
1574      -1,    50,    80,    -1,    51,    78,    -1,    52,    79,    -1,
1575      59,    79,    -1,    53,    81,    -1,    54,    80,    -1,    55,
1576      79,    -1,    56,    78,    -1,    57,    78,    -1,    58,    86,
1577      -1,    87,    -1,    77,    87,    -1,    78,    87,    -1,    79,
1578      87,    -1,    80,    87,    -1,    81,    87,    -1,    82,    87,
1579      -1,    83,    87,    -1,    84,    87,    -1,    85,    87,    -1,
1580      61,    -1,    65,    87,    -1
1581  };
1582
1583  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1584     YYRHS.  */
1585  const unsigned char
1586  EasyMeshParser::yyprhs_[] =
1587  {
1588         0,     0,     3,     6,     8,    11,    13,    17,    19,    21,
1589      23,    26,    28,    30,    32,    35,    38,    41,    44,    47,
1590      50,    53,    56,    59,    62,    65,    68,    71,    74,    77,
1591      80,    83,    86,    89,    92,    95,    98,   101,   104,   107,
1592     110,   113,   116,   119,   122,   125,   128,   131,   134,   137,
1593     140,   143,   146,   149,   152,   154,   156,   158,   161,   164,
1594     167,   169,   171,   173,   175,   177,   179,   182,   185,   188,
1595     191,   194,   197,   200,   203,   206,   209,   212,   215,   218,
1596     221,   223,   226,   229,   232,   235,   238,   241,   244,   247,
1597     250,   252
1598  };
1599
1600  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
1601  const unsigned char
1602  EasyMeshParser::yyrline_[] =
1603  {
1604         0,    76,    76,    80,    81,    85,    86,    90,    94,    98,
1605      99,   103,   104,   105,   109,   110,   113,   114,   120,   121,
1606     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
1607     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
1608     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
1609     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
1610     162,   163,   164,   165,   166,   167,   171,   174,   177,   178,
1611     180,   182,   183,   184,   185,   187,   189,   190,   191,   192,
1612     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
1613     209,   210
1614  };
1615
1616  // Print the state stack on the debug stream.
1617  void
1618  EasyMeshParser::yystack_print_ ()
1619  {
1620    *yycdebug_ << "Stack now";
1621    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1622         i != yystate_stack_.end (); ++i)
1623      *yycdebug_ << ' ' << *i;
1624    *yycdebug_ << std::endl;
1625  }
1626
1627  // Report on the debug stream that the rule \a yyrule is going to be reduced.
1628  void
1629  EasyMeshParser::yy_reduce_print_ (int yyrule)
1630  {
1631    unsigned int yylno = yyrline_[yyrule];
1632    int yynrhs = yyr2_[yyrule];
1633    /* Print the symbols being reduced, and their result.  */
1634    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1635               << " (line " << yylno << "):" << std::endl;
1636    /* The symbols being reduced.  */
1637    for (int yyi = 0; yyi < yynrhs; yyi++)
1638      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1639                       yyrhs_[yyprhs_[yyrule] + yyi],
1640                       &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1641                       &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1642  }
1643#endif // YYDEBUG
1644
1645  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1646  EasyMeshParser::token_number_type
1647  EasyMeshParser::yytranslate_ (int t)
1648  {
1649    static
1650    const token_number_type
1651    translate_table[] =
1652    {
1653           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1654       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1655       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1656       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1657       2,     2,     2,     2,     2,    65,     2,     2,     2,     2,
1658       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1659       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1660       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1661       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1662       2,    63,     2,    64,     2,     2,     2,     2,     2,     2,
1663       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1664       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1665       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1666       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1667       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1668       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1669       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1670       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1671       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1672       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1673       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1674       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1675       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1676       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1677       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1678       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1679       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1680      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1681      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1682      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1683      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1684      55,    56,    57,    58,    59,    60,    61,    62
1685    };
1686    if ((unsigned int) t <= yyuser_token_number_max_)
1687      return translate_table[t];
1688    else
1689      return yyundef_token_;
1690  }
1691
1692  const int EasyMeshParser::yyeof_ = 0;
1693  const int EasyMeshParser::yylast_ = 276;
1694  const int EasyMeshParser::yynnts_ = 22;
1695  const int EasyMeshParser::yyempty_ = -2;
1696  const int EasyMeshParser::yyfinal_ = 137;
1697  const int EasyMeshParser::yyterror_ = 1;
1698  const int EasyMeshParser::yyerrcode_ = 256;
1699  const int EasyMeshParser::yyntokens_ = 66;
1700
1701  const unsigned int EasyMeshParser::yyuser_token_number_max_ = 317;
1702  const EasyMeshParser::token_number_type EasyMeshParser::yyundef_token_ = 2;
1703
1704
1705} // lol
1706
1707/* Line 1136 of lalr1.cc  */
1708#line 1709 "generated/easymesh-parser.cpp"
1709
1710
1711/* Line 1138 of lalr1.cc  */
1712#line 213 "easymesh/easymesh-parser.y"
1713
1714
1715void lol::EasyMeshParser::error(const EasyMeshParser::location_type& l,
1716                                const std::string& m)
1717{
1718    mc.Error(l, m);
1719}
1720
1721
Note: See TracBrowser for help on using the repository browser.