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

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

easymesh: move the Mesh builder into the engine core.

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