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

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

orbital: allow 6- and 8-component hex colour values.

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