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

Last change on this file since 2318 was 2318, checked in by sam, 8 years ago

build: fix all vector/scalar type mismatches such as "vec2 * double"
instead of "vec2 * float".

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