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

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

easymesh : Added SplitTriangles function to multiply triangles for triangle MADNESS !

  • Property svn:keywords set to Id
File size: 53.0 KB
Line 
1/* A Bison parser, made by GNU Bison 2.4.2.  */
2
3/* Skeleton implementation for Bison LALR(1) parsers in C++
4   
5      Copyright (C) 2002-2010 Free Software Foundation, Inc.
6   
7   This program is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation, either version 3 of the License, or
10   (at your option) any later version.
11   
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16   
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20/* As a special exception, you may create a larger work that contains
21   part or all of the Bison parser skeleton and distribute that work
22   under terms of your choice, so long as that work isn't itself a
23   parser generator using the skeleton or a modified version thereof
24   as a parser skeleton.  Alternatively, if you modify or redistribute
25   the parser skeleton itself, you may (at your option) remove this
26   special exception, which will cause the skeleton and the resulting
27   Bison output files to be licensed under the GNU General Public
28   License without this special exception.
29   
30   This special exception was added by the Free Software Foundation in
31   version 2.2 of Bison.  */
32
33// Take the name prefix into account.
34#define yylex   lollex
35
36/* First part of user declarations.  */
37
38/* Line 310 of lalr1.cc  */
39#line 1 "easymesh/easymesh-parser.y"
40
41//
42// Lol Engine
43//
44// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>
45//            (c) 2009-2013 Cédric Lecacheur <jordx@free.fr>
46//            (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
47//   This program is free software; you can redistribute it and/or
48//   modify it under the terms of the Do What The Fuck You Want To
49//   Public License, Version 2, as published by Sam Hocevar. See
50//   http://www.wtfpl.net/ for more details.
51//
52
53#if defined HAVE_CONFIG_H
54#   include "config.h"
55#endif
56
57#include "core.h"
58#include "easymesh/easymesh.h"
59
60#include <string>
61
62
63
64/* Line 310 of lalr1.cc  */
65#line 66 "generated/easymesh-parser.cpp"
66
67
68#include "easymesh-parser.h"
69
70/* User implementation prologue.  */
71
72/* Line 316 of lalr1.cc  */
73#line 66 "easymesh/easymesh-parser.y"
74
75#include "easymesh/easymesh-compiler.h"
76
77#undef yylex
78#define yylex mc.m_lexer->lex
79
80
81/* Line 316 of lalr1.cc  */
82#line 83 "generated/easymesh-parser.cpp"
83
84#ifndef YY_
85# if defined YYENABLE_NLS && YYENABLE_NLS
86#  if ENABLE_NLS
87#   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
88#   define YY_(msgid) dgettext ("bison-runtime", msgid)
89#  endif
90# endif
91# ifndef YY_
92#  define YY_(msgid) msgid
93# endif
94#endif
95
96/* 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
145namespace lol {
146
147/* Line 379 of lalr1.cc  */
148#line 149 "generated/easymesh-parser.cpp"
149#if YYERROR_VERBOSE
150
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
157  EasyMeshParser::yytnamerr_ (const char *yystr)
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
188#endif
189
190  /// Build a parser object.
191  EasyMeshParser::EasyMeshParser (class EasyMeshCompiler& mc_yyarg)
192    :
193#if YYDEBUG
194      yydebug_ (false),
195      yycdebug_ (&std::cerr),
196#endif
197      mc (mc_yyarg)
198  {
199  }
200
201  EasyMeshParser::~EasyMeshParser ()
202  {
203  }
204
205#if YYDEBUG
206  /*--------------------------------.
207  | Print this symbol on YYOUTPUT.  |
208  `--------------------------------*/
209
210  inline void
211  EasyMeshParser::yy_symbol_value_print_ (int yytype,
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
225  EasyMeshParser::yy_symbol_print_ (int yytype,
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
237  EasyMeshParser::yydestruct_ (const char* yymsg,
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
255  EasyMeshParser::yypop_ (unsigned int n)
256  {
257    yystate_stack_.pop (n);
258    yysemantic_stack_.pop (n);
259    yylocation_stack_.pop (n);
260  }
261
262#if YYDEBUG
263  std::ostream&
264  EasyMeshParser::debug_stream () const
265  {
266    return *yycdebug_;
267  }
268
269  void
270  EasyMeshParser::set_debug_stream (std::ostream& o)
271  {
272    yycdebug_ = &o;
273  }
274
275
276  EasyMeshParser::debug_level_type
277  EasyMeshParser::debug_level () const
278  {
279    return yydebug_;
280  }
281
282  void
283  EasyMeshParser::set_debug_level (debug_level_type l)
284  {
285    yydebug_ = l;
286  }
287#endif
288
289  int
290  EasyMeshParser::parse ()
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.
310    location_type yyerror_range[2];
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];
348    if (yyn == yypact_ninf_)
349      goto yydefault;
350
351    /* Read a lookahead token.  */
352    if (yychar == yyempty_)
353      {
354        YYCDEBUG << "Reading a token: ";
355        yychar = yylex (&yylval, &yylloc);
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      {
381        if (yyn == 0 || yyn == yytable_ninf_)
382        goto yyerrlab;
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      {
436          case 7:
437
438/* Line 677 of lalr1.cc  */
439#line 90 "easymesh/easymesh-parser.y"
440    { mc.m_mesh.OpenBrace(); }
441    break;
442
443  case 8:
444
445/* Line 677 of lalr1.cc  */
446#line 94 "easymesh/easymesh-parser.y"
447    { mc.m_mesh.CloseBrace(); }
448    break;
449
450  case 14:
451
452/* Line 677 of lalr1.cc  */
453#line 109 "easymesh/easymesh-parser.y"
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)); }
455    break;
456
457  case 15:
458
459/* Line 677 of lalr1.cc  */
460#line 110 "easymesh/easymesh-parser.y"
461    { uint32_t x = (yysemantic_stack_[(2) - (2)].u32val);
462                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
463                      mc.m_mesh.SetCurColor(vec4(v) * (1.f / 255)); }
464    break;
465
466  case 16:
467
468/* Line 677 of lalr1.cc  */
469#line 113 "easymesh/easymesh-parser.y"
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)); }
471    break;
472
473  case 17:
474
475/* Line 677 of lalr1.cc  */
476#line 114 "easymesh/easymesh-parser.y"
477    { uint32_t x = (yysemantic_stack_[(2) - (2)].u32val);
478                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
479                      mc.m_mesh.SetCurColor2(vec4(v) * (1.f / 255)); }
480    break;
481
482  case 18:
483
484/* Line 677 of lalr1.cc  */
485#line 120 "easymesh/easymesh-parser.y"
486    { mc.m_mesh.Chamfer((yysemantic_stack_[(2) - (2)].args).f0); }
487    break;
488
489  case 19:
490
491/* Line 677 of lalr1.cc  */
492#line 121 "easymesh/easymesh-parser.y"
493    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, 0, 0)); }
494    break;
495
496  case 20:
497
498/* Line 677 of lalr1.cc  */
499#line 122 "easymesh/easymesh-parser.y"
500    { mc.m_mesh.Translate(vec3(0, (yysemantic_stack_[(2) - (2)].args).f0, 0)); }
501    break;
502
503  case 21:
504
505/* Line 677 of lalr1.cc  */
506#line 123 "easymesh/easymesh-parser.y"
507    { mc.m_mesh.Translate(vec3(0, 0, (yysemantic_stack_[(2) - (2)].args).f0)); }
508    break;
509
510  case 22:
511
512/* Line 677 of lalr1.cc  */
513#line 124 "easymesh/easymesh-parser.y"
514    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
515    break;
516
517  case 23:
518
519/* Line 677 of lalr1.cc  */
520#line 125 "easymesh/easymesh-parser.y"
521    { mc.m_mesh.RotateX((yysemantic_stack_[(2) - (2)].args).f0); }
522    break;
523
524  case 24:
525
526/* Line 677 of lalr1.cc  */
527#line 126 "easymesh/easymesh-parser.y"
528    { mc.m_mesh.RotateY((yysemantic_stack_[(2) - (2)].args).f0); }
529    break;
530
531  case 25:
532
533/* Line 677 of lalr1.cc  */
534#line 127 "easymesh/easymesh-parser.y"
535    { mc.m_mesh.RotateZ((yysemantic_stack_[(2) - (2)].args).f0); }
536    break;
537
538  case 26:
539
540/* Line 677 of lalr1.cc  */
541#line 128 "easymesh/easymesh-parser.y"
542    { mc.m_mesh.TaperX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
543    break;
544
545  case 27:
546
547/* Line 677 of lalr1.cc  */
548#line 129 "easymesh/easymesh-parser.y"
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); }
550    break;
551
552  case 28:
553
554/* Line 677 of lalr1.cc  */
555#line 130 "easymesh/easymesh-parser.y"
556    { mc.m_mesh.TaperY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
557    break;
558
559  case 29:
560
561/* Line 677 of lalr1.cc  */
562#line 131 "easymesh/easymesh-parser.y"
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); }
564    break;
565
566  case 30:
567
568/* Line 677 of lalr1.cc  */
569#line 132 "easymesh/easymesh-parser.y"
570    { mc.m_mesh.TaperZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
571    break;
572
573  case 31:
574
575/* Line 677 of lalr1.cc  */
576#line 133 "easymesh/easymesh-parser.y"
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); }
578    break;
579
580  case 32:
581
582/* Line 677 of lalr1.cc  */
583#line 134 "easymesh/easymesh-parser.y"
584    { mc.m_mesh.TwistX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
585    break;
586
587  case 33:
588
589/* Line 677 of lalr1.cc  */
590#line 135 "easymesh/easymesh-parser.y"
591    { mc.m_mesh.TwistY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
592    break;
593
594  case 34:
595
596/* Line 677 of lalr1.cc  */
597#line 136 "easymesh/easymesh-parser.y"
598    { mc.m_mesh.TwistZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
599    break;
600
601  case 35:
602
603/* Line 677 of lalr1.cc  */
604#line 137 "easymesh/easymesh-parser.y"
605    { mc.m_mesh.ShearX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
606    break;
607
608  case 36:
609
610/* Line 677 of lalr1.cc  */
611#line 138 "easymesh/easymesh-parser.y"
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); }
613    break;
614
615  case 37:
616
617/* Line 677 of lalr1.cc  */
618#line 139 "easymesh/easymesh-parser.y"
619    { mc.m_mesh.ShearY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
620    break;
621
622  case 38:
623
624/* Line 677 of lalr1.cc  */
625#line 140 "easymesh/easymesh-parser.y"
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); }
627    break;
628
629  case 39:
630
631/* Line 677 of lalr1.cc  */
632#line 141 "easymesh/easymesh-parser.y"
633    { mc.m_mesh.ShearZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
634    break;
635
636  case 40:
637
638/* Line 677 of lalr1.cc  */
639#line 142 "easymesh/easymesh-parser.y"
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); }
641    break;
642
643  case 41:
644
645/* Line 677 of lalr1.cc  */
646#line 143 "easymesh/easymesh-parser.y"
647    { mc.m_mesh.StretchX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
648    break;
649
650  case 42:
651
652/* Line 677 of lalr1.cc  */
653#line 144 "easymesh/easymesh-parser.y"
654    { mc.m_mesh.StretchY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
655    break;
656
657  case 43:
658
659/* Line 677 of lalr1.cc  */
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  */
681#line 148 "easymesh/easymesh-parser.y"
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"
766    { mc.m_mesh.SplitTriangles((yysemantic_stack_[(2) - (2)].args).f0); }
767    break;
768
769  case 59:
770
771/* Line 677 of lalr1.cc  */
772#line 161 "easymesh/easymesh-parser.y"
773    { mc.m_mesh.ToggleScaleWinding(); }
774    break;
775
776  case 60:
777
778/* Line 677 of lalr1.cc  */
779#line 162 "easymesh/easymesh-parser.y"
780    { mc.m_mesh.CsgUnion(); }
781    break;
782
783  case 61:
784
785/* Line 677 of lalr1.cc  */
786#line 163 "easymesh/easymesh-parser.y"
787    { mc.m_mesh.CsgSubstract(); }
788    break;
789
790  case 62:
791
792/* Line 677 of lalr1.cc  */
793#line 164 "easymesh/easymesh-parser.y"
794    { mc.m_mesh.CsgSubstractLoss(); }
795    break;
796
797  case 63:
798
799/* Line 677 of lalr1.cc  */
800#line 165 "easymesh/easymesh-parser.y"
801    { mc.m_mesh.CsgAnd(); }
802    break;
803
804  case 64:
805
806/* Line 677 of lalr1.cc  */
807#line 166 "easymesh/easymesh-parser.y"
808    { mc.m_mesh.CsgXor(); }
809    break;
810
811  case 65:
812
813/* Line 677 of lalr1.cc  */
814#line 170 "easymesh/easymesh-parser.y"
815    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
816                                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3,
817                                                 (int)(yysemantic_stack_[(2) - (2)].args).f4, (int)(yysemantic_stack_[(2) - (2)].args).f5, 0); }
818    break;
819
820  case 66:
821
822/* Line 677 of lalr1.cc  */
823#line 173 "easymesh/easymesh-parser.y"
824    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
825                                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3,
826                                                 (int)(yysemantic_stack_[(2) - (2)].args).f4, (int)(yysemantic_stack_[(2) - (2)].args).f5, (int)(yysemantic_stack_[(2) - (2)].args).f6); }
827    break;
828
829  case 67:
830
831/* Line 677 of lalr1.cc  */
832#line 176 "easymesh/easymesh-parser.y"
833    { mc.m_mesh.AppendBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
834    break;
835
836  case 68:
837
838/* Line 677 of lalr1.cc  */
839#line 177 "easymesh/easymesh-parser.y"
840    { mc.m_mesh.AppendSmoothChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
841                                                            (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
842    break;
843
844  case 69:
845
846/* Line 677 of lalr1.cc  */
847#line 179 "easymesh/easymesh-parser.y"
848    { mc.m_mesh.AppendFlatChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
849                                                          (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
850    break;
851
852  case 70:
853
854/* Line 677 of lalr1.cc  */
855#line 181 "easymesh/easymesh-parser.y"
856    { mc.m_mesh.AppendSphere((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1); }
857    break;
858
859  case 71:
860
861/* Line 677 of lalr1.cc  */
862#line 182 "easymesh/easymesh-parser.y"
863    { mc.m_mesh.AppendCapsule((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
864    break;
865
866  case 72:
867
868/* Line 677 of lalr1.cc  */
869#line 183 "easymesh/easymesh-parser.y"
870    { mc.m_mesh.AppendTorus((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
871    break;
872
873  case 73:
874
875/* Line 677 of lalr1.cc  */
876#line 184 "easymesh/easymesh-parser.y"
877    { mc.m_mesh.AppendStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2,
878                                             (int)(yysemantic_stack_[(2) - (2)].args).f3, (int)(yysemantic_stack_[(2) - (2)].args).f4); }
879    break;
880
881  case 74:
882
883/* Line 677 of lalr1.cc  */
884#line 186 "easymesh/easymesh-parser.y"
885    { mc.m_mesh.AppendExpandedStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
886                                                     (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
887    break;
888
889  case 75:
890
891/* Line 677 of lalr1.cc  */
892#line 188 "easymesh/easymesh-parser.y"
893    { mc.m_mesh.AppendDisc((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (int)(yysemantic_stack_[(2) - (2)].args).f2); }
894    break;
895
896  case 76:
897
898/* Line 677 of lalr1.cc  */
899#line 189 "easymesh/easymesh-parser.y"
900    { mc.m_mesh.AppendSimpleTriangle((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
901    break;
902
903  case 77:
904
905/* Line 677 of lalr1.cc  */
906#line 190 "easymesh/easymesh-parser.y"
907    { mc.m_mesh.AppendSimpleQuad((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
908    break;
909
910  case 78:
911
912/* Line 677 of lalr1.cc  */
913#line 191 "easymesh/easymesh-parser.y"
914    { mc.m_mesh.AppendCog((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
915                                 (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,
916                                 (yysemantic_stack_[(2) - (2)].args).f7, (yysemantic_stack_[(2) - (2)].args).f8, (int)(yysemantic_stack_[(2) - (2)].args).f9); }
917    break;
918
919  case 79:
920
921/* Line 677 of lalr1.cc  */
922#line 196 "easymesh/easymesh-parser.y"
923    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
924    break;
925
926  case 80:
927
928/* Line 677 of lalr1.cc  */
929#line 197 "easymesh/easymesh-parser.y"
930    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(2) - (2)].fval); }
931    break;
932
933  case 81:
934
935/* Line 677 of lalr1.cc  */
936#line 198 "easymesh/easymesh-parser.y"
937    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(2) - (2)].fval); }
938    break;
939
940  case 82:
941
942/* Line 677 of lalr1.cc  */
943#line 199 "easymesh/easymesh-parser.y"
944    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f3 = (yysemantic_stack_[(2) - (2)].fval); }
945    break;
946
947  case 83:
948
949/* Line 677 of lalr1.cc  */
950#line 200 "easymesh/easymesh-parser.y"
951    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f4 = (yysemantic_stack_[(2) - (2)].fval); }
952    break;
953
954  case 84:
955
956/* Line 677 of lalr1.cc  */
957#line 201 "easymesh/easymesh-parser.y"
958    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f5 = (yysemantic_stack_[(2) - (2)].fval); }
959    break;
960
961  case 85:
962
963/* Line 677 of lalr1.cc  */
964#line 202 "easymesh/easymesh-parser.y"
965    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f6 = (yysemantic_stack_[(2) - (2)].fval); }
966    break;
967
968  case 86:
969
970/* Line 677 of lalr1.cc  */
971#line 203 "easymesh/easymesh-parser.y"
972    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f7 = (yysemantic_stack_[(2) - (2)].fval); }
973    break;
974
975  case 87:
976
977/* Line 677 of lalr1.cc  */
978#line 204 "easymesh/easymesh-parser.y"
979    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f8 = (yysemantic_stack_[(2) - (2)].fval); }
980    break;
981
982  case 88:
983
984/* Line 677 of lalr1.cc  */
985#line 205 "easymesh/easymesh-parser.y"
986    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f9 = (yysemantic_stack_[(2) - (2)].fval); }
987    break;
988
989  case 89:
990
991/* Line 677 of lalr1.cc  */
992#line 208 "easymesh/easymesh-parser.y"
993    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
994    break;
995
996  case 90:
997
998/* Line 677 of lalr1.cc  */
999#line 209 "easymesh/easymesh-parser.y"
1000    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
1001    break;
1002
1003
1004
1005/* Line 677 of lalr1.cc  */
1006#line 1007 "generated/easymesh-parser.cpp"
1007        default:
1008          break;
1009      }
1010    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
1011
1012    yypop_ (yylen);
1013    yylen = 0;
1014    YY_STACK_PRINT ();
1015
1016    yysemantic_stack_.push (yyval);
1017    yylocation_stack_.push (yyloc);
1018
1019    /* Shift the result of the reduction.  */
1020    yyn = yyr1_[yyn];
1021    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
1022    if (0 <= yystate && yystate <= yylast_
1023        && yycheck_[yystate] == yystate_stack_[0])
1024      yystate = yytable_[yystate];
1025    else
1026      yystate = yydefgoto_[yyn - yyntokens_];
1027    goto yynewstate;
1028
1029  /*------------------------------------.
1030  | yyerrlab -- here on detecting error |
1031  `------------------------------------*/
1032  yyerrlab:
1033    /* If not already recovering from an error, report this error.  */
1034    if (!yyerrstatus_)
1035      {
1036        ++yynerrs_;
1037        error (yylloc, yysyntax_error_ (yystate, yytoken));
1038      }
1039
1040    yyerror_range[0] = yylloc;
1041    if (yyerrstatus_ == 3)
1042      {
1043        /* If just tried and failed to reuse lookahead token after an
1044         error, discard it.  */
1045
1046        if (yychar <= yyeof_)
1047          {
1048          /* Return failure if at end of input.  */
1049          if (yychar == yyeof_)
1050            YYABORT;
1051          }
1052        else
1053          {
1054            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
1055            yychar = yyempty_;
1056          }
1057      }
1058
1059    /* Else will try to reuse lookahead token after shifting the error
1060       token.  */
1061    goto yyerrlab1;
1062
1063
1064  /*---------------------------------------------------.
1065  | yyerrorlab -- error raised explicitly by YYERROR.  |
1066  `---------------------------------------------------*/
1067  yyerrorlab:
1068
1069    /* Pacify compilers like GCC when the user code never invokes
1070       YYERROR and the label yyerrorlab therefore never appears in user
1071       code.  */
1072    if (false)
1073      goto yyerrorlab;
1074
1075    yyerror_range[0] = yylocation_stack_[yylen - 1];
1076    /* Do not reclaim the symbols of the rule which action triggered
1077       this YYERROR.  */
1078    yypop_ (yylen);
1079    yylen = 0;
1080    yystate = yystate_stack_[0];
1081    goto yyerrlab1;
1082
1083  /*-------------------------------------------------------------.
1084  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1085  `-------------------------------------------------------------*/
1086  yyerrlab1:
1087    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
1088
1089    for (;;)
1090      {
1091        yyn = yypact_[yystate];
1092        if (yyn != yypact_ninf_)
1093        {
1094          yyn += yyterror_;
1095          if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
1096            {
1097              yyn = yytable_[yyn];
1098              if (0 < yyn)
1099                break;
1100            }
1101        }
1102
1103        /* Pop the current state because it cannot handle the error token.  */
1104        if (yystate_stack_.height () == 1)
1105        YYABORT;
1106
1107        yyerror_range[0] = yylocation_stack_[0];
1108        yydestruct_ ("Error: popping",
1109                     yystos_[yystate],
1110                     &yysemantic_stack_[0], &yylocation_stack_[0]);
1111        yypop_ ();
1112        yystate = yystate_stack_[0];
1113        YY_STACK_PRINT ();
1114      }
1115
1116    yyerror_range[1] = yylloc;
1117    // Using YYLLOC is tempting, but would change the location of
1118    // the lookahead.  YYLOC is available though.
1119    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1120    yysemantic_stack_.push (yylval);
1121    yylocation_stack_.push (yyloc);
1122
1123    /* Shift the error token.  */
1124    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
1125                     &yysemantic_stack_[0], &yylocation_stack_[0]);
1126
1127    yystate = yyn;
1128    goto yynewstate;
1129
1130    /* Accept.  */
1131  yyacceptlab:
1132    yyresult = 0;
1133    goto yyreturn;
1134
1135    /* Abort.  */
1136  yyabortlab:
1137    yyresult = 1;
1138    goto yyreturn;
1139
1140  yyreturn:
1141    if (yychar != yyempty_)
1142      yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
1143
1144    /* Do not reclaim the symbols of the rule which action triggered
1145       this YYABORT or YYACCEPT.  */
1146    yypop_ (yylen);
1147    while (yystate_stack_.height () != 1)
1148      {
1149        yydestruct_ ("Cleanup: popping",
1150                   yystos_[yystate_stack_[0]],
1151                   &yysemantic_stack_[0],
1152                   &yylocation_stack_[0]);
1153        yypop_ ();
1154      }
1155
1156    return yyresult;
1157  }
1158
1159  // Generate an error message.
1160  std::string
1161  EasyMeshParser::yysyntax_error_ (int yystate, int tok)
1162  {
1163    std::string res;
1164    YYUSE (yystate);
1165#if YYERROR_VERBOSE
1166    int yyn = yypact_[yystate];
1167    if (yypact_ninf_ < yyn && yyn <= yylast_)
1168      {
1169        /* Start YYX at -YYN if negative to avoid negative indexes in
1170           YYCHECK.  */
1171        int yyxbegin = yyn < 0 ? -yyn : 0;
1172
1173        /* Stay within bounds of both yycheck and yytname.  */
1174        int yychecklim = yylast_ - yyn + 1;
1175        int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1176        int count = 0;
1177        for (int x = yyxbegin; x < yyxend; ++x)
1178          if (yycheck_[x + yyn] == x && x != yyterror_)
1179            ++count;
1180
1181        // FIXME: This method of building the message is not compatible
1182        // with internationalization.  It should work like yacc.c does it.
1183        // That is, first build a string that looks like this:
1184        // "syntax error, unexpected %s or %s or %s"
1185        // Then, invoke YY_ on this string.
1186        // Finally, use the string as a format to output
1187        // yytname_[tok], etc.
1188        // Until this gets fixed, this message appears in English only.
1189        res = "syntax error, unexpected ";
1190        res += yytnamerr_ (yytname_[tok]);
1191        if (count < 5)
1192          {
1193            count = 0;
1194            for (int x = yyxbegin; x < yyxend; ++x)
1195              if (yycheck_[x + yyn] == x && x != yyterror_)
1196                {
1197                  res += (!count++) ? ", expecting " : " or ";
1198                  res += yytnamerr_ (yytname_[x]);
1199                }
1200          }
1201      }
1202    else
1203#endif
1204      res = YY_("syntax error");
1205    return res;
1206  }
1207
1208
1209  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1210     STATE-NUM.  */
1211  const signed char EasyMeshParser::yypact_ninf_ = -70;
1212  const signed char
1213  EasyMeshParser::yypact_[] =
1214  {
1215        61,   -41,   -24,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1216     -48,   -48,   -70,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1217     -48,   -48,   -70,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1218     -48,   -48,   -70,   -48,   -48,   -70,   -48,   -48,   -70,   -70,
1219     -70,   -70,   -70,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1220     -48,   -48,   -48,   -48,   -48,   -48,   -48,   -70,     4,     6,
1221      61,    61,   121,   -70,   -70,   -70,   -70,   -70,   -70,   -48,
1222     -48,   -48,   -48,   -70,   -70,   -70,   -70,   -70,   -70,   -48,
1223     -70,   -70,   -48,   -70,   -70,   -70,   -70,   -70,   -70,   -70,
1224     -48,   -70,   -70,   -48,   -70,   -70,   -70,   -70,   -70,   -70,
1225     -70,   -48,   -70,   -70,   -48,   -70,   -70,   -70,   -70,   -70,
1226     -70,   -70,   -70,   -70,   -70,   -48,   -48,   -48,   -70,   -70,
1227     -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,   -48,
1228     -48,   -48,   -48,   -70,   -70,   -70,   -70,   -70,   -54,   -70,
1229     -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,
1230     -70,   -70
1231  };
1232
1233  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
1234     doesn't specify something else to do.  Zero means the default is an
1235     error.  */
1236  const unsigned char
1237  EasyMeshParser::yydefact_[] =
1238  {
1239         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1240       0,     0,    54,     0,     0,     0,     0,     0,     0,     0,
1241       0,     0,    55,     0,     0,     0,     0,     0,     0,     0,
1242       0,     0,    56,     0,     0,    59,     0,     0,    60,    61,
1243      62,    63,    64,     0,     0,     0,     0,     0,     0,     0,
1244       0,     0,     0,     0,     0,     0,     0,     7,     0,     0,
1245       3,     0,     5,     9,    11,    12,    13,    89,    15,     0,
1246       0,     0,     0,    14,    79,    17,    16,    19,    23,    26,
1247      27,    32,    35,    36,    41,    44,    45,    50,    20,    24,
1248      28,    29,    33,    37,    38,    42,    46,    47,    51,    21,
1249      25,    30,    31,    34,    39,    40,    43,    48,    49,    52,
1250      22,    53,    57,    58,    18,     0,     0,    65,    66,    67,
1251      68,    69,    70,    71,    73,    74,    75,    76,    77,     0,
1252       0,     0,     0,    78,    72,     1,     2,     4,     0,    10,
1253      90,    80,    81,    82,    83,    84,    85,    86,    87,    88,
1254       8,     6
1255  };
1256
1257  /* YYPGOTO[NTERM-NUM].  */
1258  const short int
1259  EasyMeshParser::yypgoto_[] =
1260  {
1261       -70,   -70,   -31,   -70,   -70,   -70,   -70,   -51,   -70,   -70,
1262     -70,   228,   181,     0,   179,   -36,   -33,   -29,   -70,   -70,
1263     -70,   -69
1264  };
1265
1266  /* YYDEFGOTO[NTERM-NUM].  */
1267  const short int
1268  EasyMeshParser::yydefgoto_[] =
1269  {
1270        -1,    58,    59,    60,    61,   151,    62,    63,    64,    65,
1271      66,    70,    71,    72,   115,   116,   117,   118,   131,   132,
1272     133,    74
1273  };
1274
1275  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1276     positive, shift that token.  If negative, reduce the rule which
1277     number is the opposite.  If zero, do what YYDEFACT says.  */
1278  const signed char EasyMeshParser::yytable_ninf_ = -1;
1279  const unsigned char
1280  EasyMeshParser::yytable_[] =
1281  {
1282       140,   141,   142,   143,   135,    79,   136,    82,    84,   150,
1283     143,   139,    67,   143,   124,    90,    69,    93,    95,    67,
1284      68,   143,   129,    69,   143,   101,   130,   104,   106,   137,
1285     138,     0,   143,   110,   111,   143,    67,    75,     0,     0,
1286      69,     0,     0,     0,     0,   119,   144,   145,   146,   123,
1287       0,     0,   126,     0,     0,     0,   134,     0,     0,     0,
1288     146,   147,   148,   149,     1,     2,     3,     4,     5,     6,
1289       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1290      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
1291      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
1292      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1293      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
1294       0,     0,     0,    57,     1,     2,     3,     4,     5,     6,
1295       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1296      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
1297      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
1298      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1299      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
1300      73,    76,     0,     0,    80,     0,    83,    81,     0,     0,
1301      85,    86,     0,     0,    91,     0,    94,    92,     0,     0,
1302      96,    97,     0,     0,   102,     0,   105,   103,     0,     0,
1303     107,   108,     0,     0,     0,     0,     0,     0,     0,     0,
1304       0,     0,     0,     0,     0,   120,   121,     0,     0,   122,
1305     125,    77,    78,     0,   127,   128,     0,     0,     0,    87,
1306       0,    88,    89,     0,     0,     0,     0,     0,     0,    98,
1307       0,    99,   100,     0,     0,     0,     0,     0,     0,   109,
1308       0,     0,     0,     0,   112,   113,     0,     0,     0,     0,
1309       0,   114
1310  };
1311
1312  /* YYCHECK.  */
1313  const short int
1314  EasyMeshParser::yycheck_[] =
1315  {
1316        69,    70,    71,    72,     0,     5,     0,     7,     8,    63,
1317      79,    62,    60,    82,    50,    15,    64,    17,    18,    60,
1318      61,    90,    55,    64,    93,    25,    55,    27,    28,    60,
1319      61,    -1,   101,    33,    34,   104,    60,    61,    -1,    -1,
1320      64,    -1,    -1,    -1,    -1,    45,   115,   116,   117,    49,
1321      -1,    -1,    52,    -1,    -1,    -1,    56,    -1,    -1,    -1,
1322     129,   130,   131,   132,     3,     4,     5,     6,     7,     8,
1323       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
1324      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
1325      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
1326      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
1327      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
1328      -1,    -1,    -1,    62,     3,     4,     5,     6,     7,     8,
1329       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
1330      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
1331      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
1332      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
1333      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
1334       1,     2,    -1,    -1,     5,    -1,     7,     6,    -1,    -1,
1335       9,    10,    -1,    -1,    15,    -1,    17,    16,    -1,    -1,
1336      19,    20,    -1,    -1,    25,    -1,    27,    26,    -1,    -1,
1337      29,    30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1338      -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    -1,    48,
1339      51,     3,     4,    -1,    53,    54,    -1,    -1,    -1,    11,
1340      -1,    13,    14,    -1,    -1,    -1,    -1,    -1,    -1,    21,
1341      -1,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    31,
1342      -1,    -1,    -1,    -1,    36,    37,    -1,    -1,    -1,    -1,
1343      -1,    43
1344  };
1345
1346  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1347     symbol of state STATE-NUM.  */
1348  const unsigned char
1349  EasyMeshParser::yystos_[] =
1350  {
1351         0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
1352      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1353      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1354      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
1355      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
1356      52,    53,    54,    55,    56,    57,    58,    62,    66,    67,
1357      68,    69,    71,    72,    73,    74,    75,    60,    61,    64,
1358      76,    77,    78,    79,    86,    61,    79,    76,    76,    78,
1359      79,    77,    78,    79,    78,    77,    77,    76,    76,    76,
1360      78,    79,    77,    78,    79,    78,    77,    77,    76,    76,
1361      76,    78,    79,    77,    78,    79,    78,    77,    77,    76,
1362      78,    78,    76,    76,    76,    79,    80,    81,    82,    78,
1363      79,    79,    77,    78,    80,    79,    78,    77,    77,    81,
1364      82,    83,    84,    85,    78,     0,     0,    67,    67,    72,
1365      86,    86,    86,    86,    86,    86,    86,    86,    86,    86,
1366      63,    70
1367  };
1368
1369#if YYDEBUG
1370  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1371     to YYLEX-NUM.  */
1372  const unsigned short int
1373  EasyMeshParser::yytoken_number_[] =
1374  {
1375         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1376     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1377     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1378     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1379     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1380     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
1381     315,   316,    91,    93,    45
1382  };
1383#endif
1384
1385  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1386  const unsigned char
1387  EasyMeshParser::yyr1_[] =
1388  {
1389         0,    65,    66,    67,    67,    68,    68,    69,    70,    71,
1390      71,    72,    72,    72,    73,    73,    73,    73,    74,    74,
1391      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
1392      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
1393      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
1394      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
1395      74,    74,    74,    74,    74,    75,    75,    75,    75,    75,
1396      75,    75,    75,    75,    75,    75,    75,    75,    75,    76,
1397      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
1398      86
1399  };
1400
1401  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1402  const unsigned char
1403  EasyMeshParser::yyr2_[] =
1404  {
1405         0,     2,     2,     1,     2,     1,     3,     1,     1,     1,
1406       2,     1,     1,     1,     2,     2,     2,     2,     2,     2,
1407       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1408       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1409       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1410       2,     2,     2,     2,     1,     1,     1,     2,     2,     1,
1411       1,     1,     1,     1,     1,     2,     2,     2,     2,     2,
1412       2,     2,     2,     2,     2,     2,     2,     2,     2,     1,
1413       2,     2,     2,     2,     2,     2,     2,     2,     2,     1,
1414       2
1415  };
1416
1417#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1418  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1419     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
1420  const char*
1421  const EasyMeshParser::yytname_[] =
1422  {
1423    "T_END", "error", "$undefined", "T_COLOR", "T_BGCOLOR", "T_TRANSLATEX",
1424  "T_ROTATEX", "T_TAPERX", "T_TWISTX", "T_SHEARX", "T_STRETCHX",
1425  "T_BENDXY", "T_BENDXZ", "T_SCALEX", "T_MIRRORX", "T_TRANSLATEY",
1426  "T_ROTATEY", "T_TAPERY", "T_TWISTY", "T_SHEARY", "T_STRETCHY",
1427  "T_BENDYX", "T_BENDYZ", "T_SCALEY", "T_MIRRORY", "T_TRANSLATEZ",
1428  "T_ROTATEZ", "T_TAPERZ", "T_TWISTZ", "T_SHEARZ", "T_STRETCHZ",
1429  "T_BENDZX", "T_BENDZY", "T_SCALEZ", "T_MIRRORZ", "T_TRANSLATE",
1430  "T_SCALE", "T_TOGGLESCALEWINDING", "T_RADIALJITTER", "T_SPLITTRIANGLE",
1431  "T_CSGUNION", "T_CSGSUBSTRACT", "T_CSGSUBSTRACTLOSS", "T_CSGAND",
1432  "T_CSGXOR", "T_CHAMFER", "T_CYLINDER", "T_BOX", "T_SMOOTHCHAMFBOX",
1433  "T_FLATCHAMFBOX", "T_SPHERE", "T_CAPSULE", "T_STAR", "T_EXPANDEDSTAR",
1434  "T_DISC", "T_TRIANGLE", "T_QUAD", "T_COG", "T_TORUS", "T_ERROR",
1435  "NUMBER", "COLOR", "'['", "']'", "'-'", "$accept", "mesh_description",
1436  "mesh_expression_list", "mesh_expression", "mesh_open", "mesh_close",
1437  "mesh_command_list", "mesh_command", "color_command",
1438  "transform_command", "primitive_command", "args1", "args2", "args3",
1439  "args4", "args5", "args6", "args7", "args8", "args9", "args10", "number", 0
1440  };
1441#endif
1442
1443#if YYDEBUG
1444  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1445  const EasyMeshParser::rhs_number_type
1446  EasyMeshParser::yyrhs_[] =
1447  {
1448        66,     0,    -1,    67,     0,    -1,    68,    -1,    68,    67,
1449      -1,    71,    -1,    69,    67,    70,    -1,    62,    -1,    63,
1450      -1,    72,    -1,    71,    72,    -1,    73,    -1,    74,    -1,
1451      75,    -1,     3,    79,    -1,     3,    61,    -1,     4,    79,
1452      -1,     4,    61,    -1,    45,    76,    -1,     5,    76,    -1,
1453      15,    76,    -1,    25,    76,    -1,    35,    78,    -1,     6,
1454      76,    -1,    16,    76,    -1,    26,    76,    -1,     7,    78,
1455      -1,     7,    79,    -1,    17,    78,    -1,    17,    79,    -1,
1456      27,    78,    -1,    27,    79,    -1,     8,    77,    -1,    18,
1457      77,    -1,    28,    77,    -1,     9,    78,    -1,     9,    79,
1458      -1,    19,    78,    -1,    19,    79,    -1,    29,    78,    -1,
1459      29,    79,    -1,    10,    78,    -1,    20,    78,    -1,    30,
1460      78,    -1,    11,    77,    -1,    12,    77,    -1,    21,    77,
1461      -1,    22,    77,    -1,    31,    77,    -1,    32,    77,    -1,
1462      13,    76,    -1,    23,    76,    -1,    33,    76,    -1,    36,
1463      78,    -1,    14,    -1,    24,    -1,    34,    -1,    38,    76,
1464      -1,    39,    76,    -1,    37,    -1,    40,    -1,    41,    -1,
1465      42,    -1,    43,    -1,    44,    -1,    46,    81,    -1,    46,
1466      82,    -1,    47,    78,    -1,    48,    79,    -1,    49,    79,
1467      -1,    50,    77,    -1,    51,    78,    -1,    58,    78,    -1,
1468      52,    80,    -1,    53,    79,    -1,    54,    78,    -1,    55,
1469      77,    -1,    56,    77,    -1,    57,    85,    -1,    86,    -1,
1470      76,    86,    -1,    77,    86,    -1,    78,    86,    -1,    79,
1471      86,    -1,    80,    86,    -1,    81,    86,    -1,    82,    86,
1472      -1,    83,    86,    -1,    84,    86,    -1,    60,    -1,    64,
1473      86,    -1
1474  };
1475
1476  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1477     YYRHS.  */
1478  const unsigned char
1479  EasyMeshParser::yyprhs_[] =
1480  {
1481         0,     0,     3,     6,     8,    11,    13,    17,    19,    21,
1482      23,    26,    28,    30,    32,    35,    38,    41,    44,    47,
1483      50,    53,    56,    59,    62,    65,    68,    71,    74,    77,
1484      80,    83,    86,    89,    92,    95,    98,   101,   104,   107,
1485     110,   113,   116,   119,   122,   125,   128,   131,   134,   137,
1486     140,   143,   146,   149,   152,   154,   156,   158,   161,   164,
1487     166,   168,   170,   172,   174,   176,   179,   182,   185,   188,
1488     191,   194,   197,   200,   203,   206,   209,   212,   215,   218,
1489     220,   223,   226,   229,   232,   235,   238,   241,   244,   247,
1490     249
1491  };
1492
1493  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
1494  const unsigned char
1495  EasyMeshParser::yyrline_[] =
1496  {
1497         0,    76,    76,    80,    81,    85,    86,    90,    94,    98,
1498      99,   103,   104,   105,   109,   110,   113,   114,   120,   121,
1499     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
1500     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
1501     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
1502     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
1503     162,   163,   164,   165,   166,   170,   173,   176,   177,   179,
1504     181,   182,   183,   184,   186,   188,   189,   190,   191,   196,
1505     197,   198,   199,   200,   201,   202,   203,   204,   205,   208,
1506     209
1507  };
1508
1509  // Print the state stack on the debug stream.
1510  void
1511  EasyMeshParser::yystack_print_ ()
1512  {
1513    *yycdebug_ << "Stack now";
1514    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1515         i != yystate_stack_.end (); ++i)
1516      *yycdebug_ << ' ' << *i;
1517    *yycdebug_ << std::endl;
1518  }
1519
1520  // Report on the debug stream that the rule \a yyrule is going to be reduced.
1521  void
1522  EasyMeshParser::yy_reduce_print_ (int yyrule)
1523  {
1524    unsigned int yylno = yyrline_[yyrule];
1525    int yynrhs = yyr2_[yyrule];
1526    /* Print the symbols being reduced, and their result.  */
1527    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1528               << " (line " << yylno << "):" << std::endl;
1529    /* The symbols being reduced.  */
1530    for (int yyi = 0; yyi < yynrhs; yyi++)
1531      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1532                       yyrhs_[yyprhs_[yyrule] + yyi],
1533                       &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1534                       &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1535  }
1536#endif // YYDEBUG
1537
1538  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1539  EasyMeshParser::token_number_type
1540  EasyMeshParser::yytranslate_ (int t)
1541  {
1542    static
1543    const token_number_type
1544    translate_table[] =
1545    {
1546           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1547       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1548       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1549       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1550       2,     2,     2,     2,     2,    64,     2,     2,     2,     2,
1551       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1552       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1553       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1554       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1555       2,    62,     2,    63,     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,
1558       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
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,
1563       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
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,     1,     2,     3,     4,
1572       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1573      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1574      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1575      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1576      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1577      55,    56,    57,    58,    59,    60,    61
1578    };
1579    if ((unsigned int) t <= yyuser_token_number_max_)
1580      return translate_table[t];
1581    else
1582      return yyundef_token_;
1583  }
1584
1585  const int EasyMeshParser::yyeof_ = 0;
1586  const int EasyMeshParser::yylast_ = 271;
1587  const int EasyMeshParser::yynnts_ = 22;
1588  const int EasyMeshParser::yyempty_ = -2;
1589  const int EasyMeshParser::yyfinal_ = 135;
1590  const int EasyMeshParser::yyterror_ = 1;
1591  const int EasyMeshParser::yyerrcode_ = 256;
1592  const int EasyMeshParser::yyntokens_ = 65;
1593
1594  const unsigned int EasyMeshParser::yyuser_token_number_max_ = 316;
1595  const EasyMeshParser::token_number_type EasyMeshParser::yyundef_token_ = 2;
1596
1597
1598} // lol
1599
1600/* Line 1053 of lalr1.cc  */
1601#line 1602 "generated/easymesh-parser.cpp"
1602
1603
1604/* Line 1055 of lalr1.cc  */
1605#line 212 "easymesh/easymesh-parser.y"
1606
1607
1608void lol::EasyMeshParser::error(const EasyMeshParser::location_type& l,
1609                                const std::string& m)
1610{
1611    mc.Error(l, m);
1612}
1613
1614
Note: See TracBrowser for help on using the repository browser.