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

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

easymesh: first shot at a simple, flat shaded torus.

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