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

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

easymesh: motherfucking planetary gears demo.

  • Property svn:keywords set to Id
File size: 46.9 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-2012 Sam Hocevar <sam@hocevar.net>
45//            (c) 2009-2012 Cédric Lecacheur <jordx@free.fr>
46//            (c) 2009-2012 Benjamin 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://sam.zoy.org/projects/COPYING.WTFPL 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 65 "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 89 "easymesh/easymesh-parser.y"
470    { mc.m_mesh.OpenBrace(); }
471    break;
472
473  case 8:
474
475/* Line 690 of lalr1.cc  */
476#line 93 "easymesh/easymesh-parser.y"
477    { mc.m_mesh.CloseBrace(); }
478    break;
479
480  case 14:
481
482/* Line 690 of lalr1.cc  */
483#line 108 "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 109 "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. / 255)); }
494    break;
495
496  case 16:
497
498/* Line 690 of lalr1.cc  */
499#line 112 "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 113 "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. / 255)); }
510    break;
511
512  case 18:
513
514/* Line 690 of lalr1.cc  */
515#line 119 "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 120 "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 121 "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 122 "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 123 "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 124 "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 125 "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 126 "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 127 "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 128 "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 129 "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 130 "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 131 "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 132 "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 133 "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 134 "easymesh/easymesh-parser.y"
621    { mc.m_mesh.MirrorX(); }
622    break;
623
624  case 34:
625
626/* Line 690 of lalr1.cc  */
627#line 135 "easymesh/easymesh-parser.y"
628    { mc.m_mesh.MirrorY(); }
629    break;
630
631  case 35:
632
633/* Line 690 of lalr1.cc  */
634#line 136 "easymesh/easymesh-parser.y"
635    { mc.m_mesh.MirrorZ(); }
636    break;
637
638  case 36:
639
640/* Line 690 of lalr1.cc  */
641#line 137 "easymesh/easymesh-parser.y"
642    { mc.m_mesh.ToggleScaleWinding(); }
643    break;
644
645  case 37:
646
647/* Line 690 of lalr1.cc  */
648#line 141 "easymesh/easymesh-parser.y"
649    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
650                                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3,
651                                                 (int)(yysemantic_stack_[(2) - (2)].args).f4, (int)(yysemantic_stack_[(2) - (2)].args).f5); }
652    break;
653
654  case 38:
655
656/* Line 690 of lalr1.cc  */
657#line 144 "easymesh/easymesh-parser.y"
658    { mc.m_mesh.AppendBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
659    break;
660
661  case 39:
662
663/* Line 690 of lalr1.cc  */
664#line 145 "easymesh/easymesh-parser.y"
665    { mc.m_mesh.AppendSmoothChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
666                                                            (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
667    break;
668
669  case 40:
670
671/* Line 690 of lalr1.cc  */
672#line 147 "easymesh/easymesh-parser.y"
673    { mc.m_mesh.AppendFlatChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
674                                                          (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
675    break;
676
677  case 41:
678
679/* Line 690 of lalr1.cc  */
680#line 149 "easymesh/easymesh-parser.y"
681    { mc.m_mesh.AppendSphere((yysemantic_stack_[(2) - (2)].args).f0,
682                                               vec3((yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3)); }
683    break;
684
685  case 42:
686
687/* Line 690 of lalr1.cc  */
688#line 151 "easymesh/easymesh-parser.y"
689    { mc.m_mesh.AppendCapsule((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
690    break;
691
692  case 43:
693
694/* Line 690 of lalr1.cc  */
695#line 152 "easymesh/easymesh-parser.y"
696    { mc.m_mesh.AppendTorus((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
697    break;
698
699  case 44:
700
701/* Line 690 of lalr1.cc  */
702#line 153 "easymesh/easymesh-parser.y"
703    { mc.m_mesh.AppendStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2,
704                                             (int)(yysemantic_stack_[(2) - (2)].args).f3, (int)(yysemantic_stack_[(2) - (2)].args).f4); }
705    break;
706
707  case 45:
708
709/* Line 690 of lalr1.cc  */
710#line 155 "easymesh/easymesh-parser.y"
711    { mc.m_mesh.AppendExpandedStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
712                                                     (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
713    break;
714
715  case 46:
716
717/* Line 690 of lalr1.cc  */
718#line 157 "easymesh/easymesh-parser.y"
719    { mc.m_mesh.AppendDisc((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (int)(yysemantic_stack_[(2) - (2)].args).f2); }
720    break;
721
722  case 47:
723
724/* Line 690 of lalr1.cc  */
725#line 158 "easymesh/easymesh-parser.y"
726    { mc.m_mesh.AppendSimpleTriangle((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
727    break;
728
729  case 48:
730
731/* Line 690 of lalr1.cc  */
732#line 159 "easymesh/easymesh-parser.y"
733    { mc.m_mesh.AppendSimpleQuad((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
734    break;
735
736  case 49:
737
738/* Line 690 of lalr1.cc  */
739#line 160 "easymesh/easymesh-parser.y"
740    { mc.m_mesh.AppendCog((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
741                                 (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,
742                                 (yysemantic_stack_[(2) - (2)].args).f7, (yysemantic_stack_[(2) - (2)].args).f8, (int)(yysemantic_stack_[(2) - (2)].args).f9); }
743    break;
744
745  case 50:
746
747/* Line 690 of lalr1.cc  */
748#line 165 "easymesh/easymesh-parser.y"
749    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
750    break;
751
752  case 51:
753
754/* Line 690 of lalr1.cc  */
755#line 166 "easymesh/easymesh-parser.y"
756    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(2) - (2)].fval); }
757    break;
758
759  case 52:
760
761/* Line 690 of lalr1.cc  */
762#line 167 "easymesh/easymesh-parser.y"
763    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(2) - (2)].fval); }
764    break;
765
766  case 53:
767
768/* Line 690 of lalr1.cc  */
769#line 168 "easymesh/easymesh-parser.y"
770    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f3 = (yysemantic_stack_[(2) - (2)].fval); }
771    break;
772
773  case 54:
774
775/* Line 690 of lalr1.cc  */
776#line 169 "easymesh/easymesh-parser.y"
777    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f4 = (yysemantic_stack_[(2) - (2)].fval); }
778    break;
779
780  case 55:
781
782/* Line 690 of lalr1.cc  */
783#line 170 "easymesh/easymesh-parser.y"
784    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f5 = (yysemantic_stack_[(2) - (2)].fval); }
785    break;
786
787  case 56:
788
789/* Line 690 of lalr1.cc  */
790#line 171 "easymesh/easymesh-parser.y"
791    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f6 = (yysemantic_stack_[(2) - (2)].fval); }
792    break;
793
794  case 57:
795
796/* Line 690 of lalr1.cc  */
797#line 172 "easymesh/easymesh-parser.y"
798    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f7 = (yysemantic_stack_[(2) - (2)].fval); }
799    break;
800
801  case 58:
802
803/* Line 690 of lalr1.cc  */
804#line 173 "easymesh/easymesh-parser.y"
805    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f8 = (yysemantic_stack_[(2) - (2)].fval); }
806    break;
807
808  case 59:
809
810/* Line 690 of lalr1.cc  */
811#line 174 "easymesh/easymesh-parser.y"
812    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f9 = (yysemantic_stack_[(2) - (2)].fval); }
813    break;
814
815  case 60:
816
817/* Line 690 of lalr1.cc  */
818#line 177 "easymesh/easymesh-parser.y"
819    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
820    break;
821
822  case 61:
823
824/* Line 690 of lalr1.cc  */
825#line 178 "easymesh/easymesh-parser.y"
826    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
827    break;
828
829
830
831/* Line 690 of lalr1.cc  */
832#line 833 "generated/easymesh-parser.cpp"
833        default:
834          break;
835      }
836    /* User semantic actions sometimes alter yychar, and that requires
837       that yytoken be updated with the new translation.  We take the
838       approach of translating immediately before every use of yytoken.
839       One alternative is translating here after every semantic action,
840       but that translation would be missed if the semantic action
841       invokes YYABORT, YYACCEPT, or YYERROR immediately after altering
842       yychar.  In the case of YYABORT or YYACCEPT, an incorrect
843       destructor might then be invoked immediately.  In the case of
844       YYERROR, subsequent parser actions might lead to an incorrect
845       destructor call or verbose syntax error message before the
846       lookahead is translated.  */
847    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
848
849    yypop_ (yylen);
850    yylen = 0;
851    YY_STACK_PRINT ();
852
853    yysemantic_stack_.push (yyval);
854    yylocation_stack_.push (yyloc);
855
856    /* Shift the result of the reduction.  */
857    yyn = yyr1_[yyn];
858    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
859    if (0 <= yystate && yystate <= yylast_
860        && yycheck_[yystate] == yystate_stack_[0])
861      yystate = yytable_[yystate];
862    else
863      yystate = yydefgoto_[yyn - yyntokens_];
864    goto yynewstate;
865
866  /*------------------------------------.
867  | yyerrlab -- here on detecting error |
868  `------------------------------------*/
869  yyerrlab:
870    /* Make sure we have latest lookahead translation.  See comments at
871       user semantic actions for why this is necessary.  */
872    yytoken = yytranslate_ (yychar);
873
874    /* If not already recovering from an error, report this error.  */
875    if (!yyerrstatus_)
876      {
877        ++yynerrs_;
878        if (yychar == yyempty_)
879          yytoken = yyempty_;
880        error (yylloc, yysyntax_error_ (yystate, yytoken));
881      }
882
883    yyerror_range[1] = yylloc;
884    if (yyerrstatus_ == 3)
885      {
886        /* If just tried and failed to reuse lookahead token after an
887         error, discard it.  */
888
889        if (yychar <= yyeof_)
890          {
891          /* Return failure if at end of input.  */
892          if (yychar == yyeof_)
893            YYABORT;
894          }
895        else
896          {
897            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
898            yychar = yyempty_;
899          }
900      }
901
902    /* Else will try to reuse lookahead token after shifting the error
903       token.  */
904    goto yyerrlab1;
905
906
907  /*---------------------------------------------------.
908  | yyerrorlab -- error raised explicitly by YYERROR.  |
909  `---------------------------------------------------*/
910  yyerrorlab:
911
912    /* Pacify compilers like GCC when the user code never invokes
913       YYERROR and the label yyerrorlab therefore never appears in user
914       code.  */
915    if (false)
916      goto yyerrorlab;
917
918    yyerror_range[1] = yylocation_stack_[yylen - 1];
919    /* Do not reclaim the symbols of the rule which action triggered
920       this YYERROR.  */
921    yypop_ (yylen);
922    yylen = 0;
923    yystate = yystate_stack_[0];
924    goto yyerrlab1;
925
926  /*-------------------------------------------------------------.
927  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
928  `-------------------------------------------------------------*/
929  yyerrlab1:
930    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
931
932    for (;;)
933      {
934        yyn = yypact_[yystate];
935        if (!yy_pact_value_is_default_ (yyn))
936        {
937          yyn += yyterror_;
938          if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
939            {
940              yyn = yytable_[yyn];
941              if (0 < yyn)
942                break;
943            }
944        }
945
946        /* Pop the current state because it cannot handle the error token.  */
947        if (yystate_stack_.height () == 1)
948        YYABORT;
949
950        yyerror_range[1] = yylocation_stack_[0];
951        yydestruct_ ("Error: popping",
952                     yystos_[yystate],
953                     &yysemantic_stack_[0], &yylocation_stack_[0]);
954        yypop_ ();
955        yystate = yystate_stack_[0];
956        YY_STACK_PRINT ();
957      }
958
959    yyerror_range[2] = yylloc;
960    // Using YYLLOC is tempting, but would change the location of
961    // the lookahead.  YYLOC is available though.
962    YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
963    yysemantic_stack_.push (yylval);
964    yylocation_stack_.push (yyloc);
965
966    /* Shift the error token.  */
967    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
968                     &yysemantic_stack_[0], &yylocation_stack_[0]);
969
970    yystate = yyn;
971    goto yynewstate;
972
973    /* Accept.  */
974  yyacceptlab:
975    yyresult = 0;
976    goto yyreturn;
977
978    /* Abort.  */
979  yyabortlab:
980    yyresult = 1;
981    goto yyreturn;
982
983  yyreturn:
984    if (yychar != yyempty_)
985      {
986        /* Make sure we have latest lookahead translation.  See comments
987           at user semantic actions for why this is necessary.  */
988        yytoken = yytranslate_ (yychar);
989        yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
990                     &yylloc);
991      }
992
993    /* Do not reclaim the symbols of the rule which action triggered
994       this YYABORT or YYACCEPT.  */
995    yypop_ (yylen);
996    while (yystate_stack_.height () != 1)
997      {
998        yydestruct_ ("Cleanup: popping",
999                   yystos_[yystate_stack_[0]],
1000                   &yysemantic_stack_[0],
1001                   &yylocation_stack_[0]);
1002        yypop_ ();
1003      }
1004
1005    return yyresult;
1006  }
1007
1008  // Generate an error message.
1009  std::string
1010  EasyMeshParser::yysyntax_error_ (int yystate, int yytoken)
1011  {
1012    std::string yyres;
1013    // Number of reported tokens (one for the "unexpected", one per
1014    // "expected").
1015    size_t yycount = 0;
1016    // Its maximum.
1017    enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1018    // Arguments of yyformat.
1019    char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1020
1021    /* There are many possibilities here to consider:
1022       - If this state is a consistent state with a default action, then
1023         the only way this function was invoked is if the default action
1024         is an error action.  In that case, don't check for expected
1025         tokens because there are none.
1026       - The only way there can be no lookahead present (in yytoken) is
1027         if this state is a consistent state with a default action.
1028         Thus, detecting the absence of a lookahead is sufficient to
1029         determine that there is no unexpected or expected token to
1030         report.  In that case, just report a simple "syntax error".
1031       - Don't assume there isn't a lookahead just because this state is
1032         a consistent state with a default action.  There might have
1033         been a previous inconsistent state, consistent state with a
1034         non-default action, or user semantic action that manipulated
1035         yychar.
1036       - Of course, the expected token list depends on states to have
1037         correct lookahead information, and it depends on the parser not
1038         to perform extra reductions after fetching a lookahead from the
1039         scanner and before detecting a syntax error.  Thus, state
1040         merging (from LALR or IELR) and default reductions corrupt the
1041         expected token list.  However, the list is correct for
1042         canonical LR with one exception: it will still contain any
1043         token that will not be accepted due to an error action in a
1044         later state.
1045    */
1046    if (yytoken != yyempty_)
1047      {
1048        yyarg[yycount++] = yytname_[yytoken];
1049        int yyn = yypact_[yystate];
1050        if (!yy_pact_value_is_default_ (yyn))
1051          {
1052            /* Start YYX at -YYN if negative to avoid negative indexes in
1053               YYCHECK.  In other words, skip the first -YYN actions for
1054               this state because they are default actions.  */
1055            int yyxbegin = yyn < 0 ? -yyn : 0;
1056            /* Stay within bounds of both yycheck and yytname.  */
1057            int yychecklim = yylast_ - yyn + 1;
1058            int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1059            for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1060              if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
1061                  && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
1062                {
1063                  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1064                    {
1065                      yycount = 1;
1066                      break;
1067                    }
1068                  else
1069                    yyarg[yycount++] = yytname_[yyx];
1070                }
1071          }
1072      }
1073
1074    char const* yyformat = 0;
1075    switch (yycount)
1076      {
1077#define YYCASE_(N, S)                         \
1078        case N:                               \
1079          yyformat = S;                       \
1080        break
1081        YYCASE_(0, YY_("syntax error"));
1082        YYCASE_(1, YY_("syntax error, unexpected %s"));
1083        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1084        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1085        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1086        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1087#undef YYCASE_
1088      }
1089
1090    // Argument number.
1091    size_t yyi = 0;
1092    for (char const* yyp = yyformat; *yyp; ++yyp)
1093      if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1094        {
1095          yyres += yytnamerr_ (yyarg[yyi++]);
1096          ++yyp;
1097        }
1098      else
1099        yyres += *yyp;
1100    return yyres;
1101  }
1102
1103
1104  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1105     STATE-NUM.  */
1106  const signed char EasyMeshParser::yypact_ninf_ = -48;
1107  const signed char
1108  EasyMeshParser::yypact_[] =
1109  {
1110        37,   -27,    89,   -32,   -32,   -32,   -32,   -48,   -32,   -32,
1111     -32,   -32,   -48,   -32,   -32,   -32,   -32,   -48,   -32,   -32,
1112     -48,   -32,   -32,   -32,   -32,   -32,   -32,   -32,   -32,   -32,
1113     -32,   -32,   -32,   -32,   -32,   -48,     5,    13,    37,    37,
1114      75,   -48,   -48,   -48,   -48,   -48,   -48,   -32,   -32,   -32,
1115     -32,   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1116     -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1117     -32,   -32,   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1118     -48,   -48,   -48,   -32,   -32,   -32,   -32,   -48,   -48,   -48,
1119     -48,   -48,   -25,   -48,   -48,   -48,   -48,   -48,   -48,   -48,
1120     -48,   -48,   -48,   -48,   -48,   -48
1121  };
1122
1123  /* YYDEFACT[S] -- default reduction number in state S.  Performed when
1124     YYTABLE doesn't specify something else to do.  Zero means the
1125     default is an error.  */
1126  const unsigned char
1127  EasyMeshParser::yydefact_[] =
1128  {
1129         0,     0,     0,     0,     0,     0,     0,    33,     0,     0,
1130       0,     0,    34,     0,     0,     0,     0,    35,     0,     0,
1131      36,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1132       0,     0,     0,     0,     0,     7,     0,     0,     3,     0,
1133       5,     9,    11,    12,    13,    60,    15,     0,     0,     0,
1134       0,    14,    50,    17,    16,    19,    23,    26,    29,    20,
1135      24,    27,    30,    21,    25,    28,    31,    22,    32,    18,
1136       0,     0,    37,    38,    39,    40,    41,    42,    44,    45,
1137      46,    47,    48,     0,     0,     0,     0,    49,    43,     1,
1138       2,     4,     0,    10,    61,    51,    52,    53,    54,    55,
1139      56,    57,    58,    59,     8,     6
1140  };
1141
1142  /* YYPGOTO[NTERM-NUM].  */
1143  const signed char
1144  EasyMeshParser::yypgoto_[] =
1145  {
1146       -48,   -48,   -19,   -48,   -48,   -48,   -48,   -15,   -48,   -48,
1147     -48,   109,    -4,    -1,     6,    -7,     1,   -48,   -48,   -48,
1148     -48,   -47
1149  };
1150
1151  /* YYDEFGOTO[NTERM-NUM].  */
1152  const signed char
1153  EasyMeshParser::yydefgoto_[] =
1154  {
1155        -1,    36,    37,    38,    39,   105,    40,    41,    42,    43,
1156      44,    48,    49,    50,    70,    71,    72,    84,    85,    86,
1157      87,    52
1158  };
1159
1160  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1161     positive, shift that token.  If negative, reduce the rule which
1162     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
1163  const signed char EasyMeshParser::yytable_ninf_ = -1;
1164  const unsigned char
1165  EasyMeshParser::yytable_[] =
1166  {
1167        94,    95,    96,    97,    57,    89,    45,    51,    54,    61,
1168      47,    45,    46,    90,    65,    47,   104,    67,    68,    91,
1169      92,    78,    73,    98,    99,    93,    77,    81,    82,    80,
1170      74,    75,    76,    88,    83,    79,   100,   101,   102,   103,
1171       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
1172      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
1173      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
1174      31,    32,    33,    34,     0,     0,     0,    35,     1,     2,
1175       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
1176      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
1177      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
1178      33,    34,    55,    56,     0,    58,     0,    59,    60,     0,
1179      62,     0,    63,    64,     0,    66,     0,    45,    53,     0,
1180      69,    47
1181  };
1182
1183  /* YYCHECK.  */
1184  const signed char
1185  EasyMeshParser::yycheck_[] =
1186  {
1187        47,    48,    49,    50,     5,     0,    38,     1,     2,    10,
1188      42,    38,    39,     0,    15,    42,    41,    18,    19,    38,
1189      39,    28,    23,    70,    71,    40,    27,    31,    32,    30,
1190      24,    25,    26,    34,    33,    29,    83,    84,    85,    86,
1191       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
1192      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
1193      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
1194      33,    34,    35,    36,    -1,    -1,    -1,    40,     3,     4,
1195       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1196      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1197      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1198      35,    36,     3,     4,    -1,     6,    -1,     8,     9,    -1,
1199      11,    -1,    13,    14,    -1,    16,    -1,    38,    39,    -1,
1200      21,    42
1201  };
1202
1203  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1204     symbol of state STATE-NUM.  */
1205  const unsigned char
1206  EasyMeshParser::yystos_[] =
1207  {
1208         0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
1209      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1210      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1211      32,    33,    34,    35,    36,    40,    44,    45,    46,    47,
1212      49,    50,    51,    52,    53,    38,    39,    42,    54,    55,
1213      56,    57,    64,    39,    57,    54,    54,    56,    54,    54,
1214      54,    56,    54,    54,    54,    56,    54,    56,    56,    54,
1215      57,    58,    59,    56,    57,    57,    57,    56,    58,    57,
1216      56,    55,    55,    59,    60,    61,    62,    63,    56,     0,
1217       0,    45,    45,    50,    64,    64,    64,    64,    64,    64,
1218      64,    64,    64,    64,    41,    48
1219  };
1220
1221#if YYDEBUG
1222  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1223     to YYLEX-NUM.  */
1224  const unsigned short int
1225  EasyMeshParser::yytoken_number_[] =
1226  {
1227         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1228     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1229     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1230     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1231      91,    93,    45
1232  };
1233#endif
1234
1235  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1236  const unsigned char
1237  EasyMeshParser::yyr1_[] =
1238  {
1239         0,    43,    44,    45,    45,    46,    46,    47,    48,    49,
1240      49,    50,    50,    50,    51,    51,    51,    51,    52,    52,
1241      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
1242      52,    52,    52,    52,    52,    52,    52,    53,    53,    53,
1243      53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
1244      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
1245      64,    64
1246  };
1247
1248  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1249  const unsigned char
1250  EasyMeshParser::yyr2_[] =
1251  {
1252         0,     2,     2,     1,     2,     1,     3,     1,     1,     1,
1253       2,     1,     1,     1,     2,     2,     2,     2,     2,     2,
1254       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1255       2,     2,     2,     1,     1,     1,     1,     2,     2,     2,
1256       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1257       1,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1258       1,     2
1259  };
1260
1261#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1262  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1263     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
1264  const char*
1265  const EasyMeshParser::yytname_[] =
1266  {
1267    "T_END", "error", "$undefined", "T_COLOR", "T_BGCOLOR", "T_TRANSLATEX",
1268  "T_ROTATEX", "T_TAPERX", "T_SCALEX", "T_MIRRORX", "T_TRANSLATEY",
1269  "T_ROTATEY", "T_TAPERY", "T_SCALEY", "T_MIRRORY", "T_TRANSLATEZ",
1270  "T_ROTATEZ", "T_TAPERZ", "T_SCALEZ", "T_MIRRORZ", "T_TRANSLATE",
1271  "T_SCALE", "T_TOGGLESCALEWINDING", "T_CHAMFER", "T_CYLINDER", "T_BOX",
1272  "T_SMOOTHCHAMFBOX", "T_FLATCHAMFBOX", "T_SPHERE", "T_CAPSULE", "T_STAR",
1273  "T_EXPANDEDSTAR", "T_DISC", "T_TRIANGLE", "T_QUAD", "T_COG", "T_TORUS",
1274  "T_ERROR", "NUMBER", "COLOR", "'['", "']'", "'-'", "$accept",
1275  "mesh_description", "mesh_expression_list", "mesh_expression",
1276  "mesh_open", "mesh_close", "mesh_command_list", "mesh_command",
1277  "color_command", "transform_command", "primitive_command", "args1",
1278  "args2", "args3", "args4", "args5", "args6", "args7", "args8", "args9",
1279  "args10", "number", 0
1280  };
1281#endif
1282
1283#if YYDEBUG
1284  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1285  const EasyMeshParser::rhs_number_type
1286  EasyMeshParser::yyrhs_[] =
1287  {
1288        44,     0,    -1,    45,     0,    -1,    46,    -1,    46,    45,
1289      -1,    49,    -1,    47,    45,    48,    -1,    40,    -1,    41,
1290      -1,    50,    -1,    49,    50,    -1,    51,    -1,    52,    -1,
1291      53,    -1,     3,    57,    -1,     3,    39,    -1,     4,    57,
1292      -1,     4,    39,    -1,    23,    54,    -1,     5,    54,    -1,
1293      10,    54,    -1,    15,    54,    -1,    20,    56,    -1,     6,
1294      54,    -1,    11,    54,    -1,    16,    54,    -1,     7,    56,
1295      -1,    12,    56,    -1,    17,    56,    -1,     8,    54,    -1,
1296      13,    54,    -1,    18,    54,    -1,    21,    56,    -1,     9,
1297      -1,    14,    -1,    19,    -1,    22,    -1,    24,    59,    -1,
1298      25,    56,    -1,    26,    57,    -1,    27,    57,    -1,    28,
1299      57,    -1,    29,    56,    -1,    36,    56,    -1,    30,    58,
1300      -1,    31,    57,    -1,    32,    56,    -1,    33,    55,    -1,
1301      34,    55,    -1,    35,    63,    -1,    64,    -1,    54,    64,
1302      -1,    55,    64,    -1,    56,    64,    -1,    57,    64,    -1,
1303      58,    64,    -1,    59,    64,    -1,    60,    64,    -1,    61,
1304      64,    -1,    62,    64,    -1,    38,    -1,    42,    64,    -1
1305  };
1306
1307  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1308     YYRHS.  */
1309  const unsigned char
1310  EasyMeshParser::yyprhs_[] =
1311  {
1312         0,     0,     3,     6,     8,    11,    13,    17,    19,    21,
1313      23,    26,    28,    30,    32,    35,    38,    41,    44,    47,
1314      50,    53,    56,    59,    62,    65,    68,    71,    74,    77,
1315      80,    83,    86,    89,    91,    93,    95,    97,   100,   103,
1316     106,   109,   112,   115,   118,   121,   124,   127,   130,   133,
1317     136,   138,   141,   144,   147,   150,   153,   156,   159,   162,
1318     165,   167
1319  };
1320
1321  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
1322  const unsigned char
1323  EasyMeshParser::yyrline_[] =
1324  {
1325         0,    75,    75,    79,    80,    84,    85,    89,    93,    97,
1326      98,   102,   103,   104,   108,   109,   112,   113,   119,   120,
1327     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
1328     131,   132,   133,   134,   135,   136,   137,   141,   144,   145,
1329     147,   149,   151,   152,   153,   155,   157,   158,   159,   160,
1330     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
1331     177,   178
1332  };
1333
1334  // Print the state stack on the debug stream.
1335  void
1336  EasyMeshParser::yystack_print_ ()
1337  {
1338    *yycdebug_ << "Stack now";
1339    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1340         i != yystate_stack_.end (); ++i)
1341      *yycdebug_ << ' ' << *i;
1342    *yycdebug_ << std::endl;
1343  }
1344
1345  // Report on the debug stream that the rule \a yyrule is going to be reduced.
1346  void
1347  EasyMeshParser::yy_reduce_print_ (int yyrule)
1348  {
1349    unsigned int yylno = yyrline_[yyrule];
1350    int yynrhs = yyr2_[yyrule];
1351    /* Print the symbols being reduced, and their result.  */
1352    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1353               << " (line " << yylno << "):" << std::endl;
1354    /* The symbols being reduced.  */
1355    for (int yyi = 0; yyi < yynrhs; yyi++)
1356      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1357                       yyrhs_[yyprhs_[yyrule] + yyi],
1358                       &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1359                       &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1360  }
1361#endif // YYDEBUG
1362
1363  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1364  EasyMeshParser::token_number_type
1365  EasyMeshParser::yytranslate_ (int t)
1366  {
1367    static
1368    const token_number_type
1369    translate_table[] =
1370    {
1371           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1372       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1373       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1374       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1375       2,     2,     2,     2,     2,    42,     2,     2,     2,     2,
1376       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1377       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1378       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1379       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1380       2,    40,     2,    41,     2,     2,     2,     2,     2,     2,
1381       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1382       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1383       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1384       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1385       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1386       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1387       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1388       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1389       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1390       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1391       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1392       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1393       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1394       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1395       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1396       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1397       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1398      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1399      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1400      35,    36,    37,    38,    39
1401    };
1402    if ((unsigned int) t <= yyuser_token_number_max_)
1403      return translate_table[t];
1404    else
1405      return yyundef_token_;
1406  }
1407
1408  const int EasyMeshParser::yyeof_ = 0;
1409  const int EasyMeshParser::yylast_ = 131;
1410  const int EasyMeshParser::yynnts_ = 22;
1411  const int EasyMeshParser::yyempty_ = -2;
1412  const int EasyMeshParser::yyfinal_ = 89;
1413  const int EasyMeshParser::yyterror_ = 1;
1414  const int EasyMeshParser::yyerrcode_ = 256;
1415  const int EasyMeshParser::yyntokens_ = 43;
1416
1417  const unsigned int EasyMeshParser::yyuser_token_number_max_ = 294;
1418  const EasyMeshParser::token_number_type EasyMeshParser::yyundef_token_ = 2;
1419
1420
1421} // lol
1422
1423/* Line 1136 of lalr1.cc  */
1424#line 1425 "generated/easymesh-parser.cpp"
1425
1426
1427/* Line 1138 of lalr1.cc  */
1428#line 181 "easymesh/easymesh-parser.y"
1429
1430
1431void lol::EasyMeshParser::error(const EasyMeshParser::location_type& l,
1432                                const std::string& m)
1433{
1434    mc.Error(l, m);
1435}
1436
1437
Note: See TracBrowser for help on using the repository browser.