source: trunk/orbital/generated/mesh-parser.cpp @ 1437

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

orbital: build the scanners and parsers with more recent flex/bison.

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