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

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

orbital: some improvements to the mesh parser and error reporting.

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