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

Last change on this file since 1434 was 1434, checked in by sam, 11 years ago

orbital: enhance the language with [] contexts.

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