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

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

orbital: make sure to include "config.h" in all compiled files.

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