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

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

orbital: allow hexadecimal colour values.

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