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

Last change on this file since 2116 was 2116, checked in by touky, 10 years ago

Added tsw (ToggleScaleWinding) command in EasyMesh Parser to make old-school celShading contour.

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