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

Last change on this file since 1431 was 1431, checked in by sam, 9 years ago

orbital: add missing <stdint.h>.

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