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

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

orbital: add "ch" command to create chamfers.

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