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

Last change on this file since 2779 was 2779, checked in by sam, 6 years ago

base: disable exceptions in Bison-generated parsers.

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