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

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

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

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