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

Last change on this file since 2410 was 2410, checked in by touky, 7 years ago

easymesh : Added SmoothMesh operation, works well with triangle, not well with a box.

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