source: trunk/orbital/generated/gun-parser.cpp @ 1437

Last change on this file since 1437 was 1437, checked in by sam, 8 years ago

orbital: build the scanners and parsers with more recent flex/bison.

  • Property svn:keywords set to Id
File size: 33.6 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 "gun-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 "../gun.h"
59
60#include <string>
61
62
63/* Line 293 of lalr1.cc  */
64#line 65 "generated/gun-parser.cpp"
65
66
67#include "gun-parser.h"
68
69/* User implementation prologue.  */
70
71/* Line 299 of lalr1.cc  */
72#line 66 "gun-parser.y"
73
74#include "../gun-compiler.h"
75
76#undef yylex
77#define yylex gc.m_lexer->lex
78
79
80/* Line 299 of lalr1.cc  */
81#line 82 "generated/gun-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/gun-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  GunParser::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  GunParser::GunParser (class GunCompiler& gc_yyarg)
209    :
210#if YYDEBUG
211      yydebug_ (false),
212      yycdebug_ (&std::cerr),
213#endif
214      gc (gc_yyarg)
215  {
216  }
217
218  GunParser::~GunParser ()
219  {
220  }
221
222#if YYDEBUG
223  /*--------------------------------.
224  | Print this symbol on YYOUTPUT.  |
225  `--------------------------------*/
226
227  inline void
228  GunParser::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  GunParser::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  GunParser::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  GunParser::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  GunParser::debug_stream () const
282  {
283    return *yycdebug_;
284  }
285
286  void
287  GunParser::set_debug_stream (std::ostream& o)
288  {
289    yycdebug_ = &o;
290  }
291
292
293  GunParser::debug_level_type
294  GunParser::debug_level () const
295  {
296    return yydebug_;
297  }
298
299  void
300  GunParser::set_debug_level (debug_level_type l)
301  {
302    yydebug_ = l;
303  }
304#endif
305
306  inline bool
307  GunParser::yy_pact_value_is_default_ (int yyvalue)
308  {
309    return yyvalue == yypact_ninf_;
310  }
311
312  inline bool
313  GunParser::yy_table_value_is_error_ (int yyvalue)
314  {
315    return yyvalue == yytable_ninf_;
316  }
317
318  int
319  GunParser::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 5:
466
467/* Line 690 of lalr1.cc  */
468#line 85 "gun-parser.y"
469    { gc.m_gun.m_angle = gc.m_gun.AimActor(); }
470    break;
471
472  case 6:
473
474/* Line 690 of lalr1.cc  */
475#line 86 "gun-parser.y"
476    { gc.m_gun.PreAimActor((yysemantic_stack_[(2) - (2)].args).f0); }
477    break;
478
479  case 7:
480
481/* Line 690 of lalr1.cc  */
482#line 87 "gun-parser.y"
483    { gc.m_gun.m_pre_aim = (yysemantic_stack_[(2) - (2)].args).f0; }
484    break;
485
486  case 8:
487
488/* Line 690 of lalr1.cc  */
489#line 88 "gun-parser.y"
490    { gc.m_gun.m_angle = (yysemantic_stack_[(2) - (2)].args).f0; }
491    break;
492
493  case 9:
494
495/* Line 690 of lalr1.cc  */
496#line 89 "gun-parser.y"
497    { gc.m_gun.m_round_duration = (yysemantic_stack_[(2) - (2)].args).f0; }
498    break;
499
500  case 10:
501
502/* Line 690 of lalr1.cc  */
503#line 90 "gun-parser.y"
504    { gc.m_gun.m_angle_offset = (yysemantic_stack_[(2) - (2)].args).f0; }
505    break;
506
507  case 11:
508
509/* Line 690 of lalr1.cc  */
510#line 91 "gun-parser.y"
511    { gc.m_gun.m_radius = (yysemantic_stack_[(2) - (2)].args).f0; }
512    break;
513
514  case 12:
515
516/* Line 690 of lalr1.cc  */
517#line 92 "gun-parser.y"
518    { gc.m_gun.m_shoot_speed = (yysemantic_stack_[(2) - (2)].args).f0; }
519    break;
520
521  case 13:
522
523/* Line 690 of lalr1.cc  */
524#line 93 "gun-parser.y"
525    { /* FIXME: 1st modifier */ }
526    break;
527
528  case 14:
529
530/* Line 690 of lalr1.cc  */
531#line 94 "gun-parser.y"
532    { /* FIXME: 2nd modifier */ }
533    break;
534
535  case 15:
536
537/* Line 690 of lalr1.cc  */
538#line 95 "gun-parser.y"
539    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gc.m_gun.Shoot(1);
540                      gc.m_gun.m_shoot_type = 1;
541                      gc.m_gun.m_round_timer = gc.m_gun.m_round_duration; }
542    break;
543
544  case 16:
545
546/* Line 690 of lalr1.cc  */
547#line 98 "gun-parser.y"
548    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gc.m_gun.Shoot(0);
549                      gc.m_gun.m_shoot_type = 0;
550                      gc.m_gun.m_round_timer = gc.m_gun.m_round_duration; }
551    break;
552
553  case 17:
554
555/* Line 690 of lalr1.cc  */
556#line 101 "gun-parser.y"
557    { gc.m_gun.Shoot(1); gc.m_gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
558                      gc.m_gun.m_shoot_type = 1;
559                      gc.m_gun.m_round_timer = gc.m_gun.m_round_duration; }
560    break;
561
562  case 18:
563
564/* Line 690 of lalr1.cc  */
565#line 104 "gun-parser.y"
566    { gc.m_gun.Shoot(0); gc.m_gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
567                      gc.m_gun.m_shoot_type = 0;
568                      gc.m_gun.m_round_timer = gc.m_gun.m_round_duration; }
569    break;
570
571  case 19:
572
573/* Line 690 of lalr1.cc  */
574#line 107 "gun-parser.y"
575    { gc.m_gun.m_round_timer = gc.m_gun.m_round_duration * (yysemantic_stack_[(2) - (2)].args).f0;
576                      /* FIXME: modifiers */ }
577    break;
578
579  case 20:
580
581/* Line 690 of lalr1.cc  */
582#line 109 "gun-parser.y"
583    { /* FIXME: loops */ }
584    break;
585
586  case 21:
587
588/* Line 690 of lalr1.cc  */
589#line 112 "gun-parser.y"
590    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
591    break;
592
593  case 22:
594
595/* Line 690 of lalr1.cc  */
596#line 113 "gun-parser.y"
597    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(3) - (3)].fval); }
598    break;
599
600  case 23:
601
602/* Line 690 of lalr1.cc  */
603#line 114 "gun-parser.y"
604    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(3) - (3)].fval); }
605    break;
606
607  case 24:
608
609/* Line 690 of lalr1.cc  */
610#line 117 "gun-parser.y"
611    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
612    break;
613
614  case 25:
615
616/* Line 690 of lalr1.cc  */
617#line 118 "gun-parser.y"
618    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
619    break;
620
621
622
623/* Line 690 of lalr1.cc  */
624#line 625 "generated/gun-parser.cpp"
625        default:
626          break;
627      }
628    /* User semantic actions sometimes alter yychar, and that requires
629       that yytoken be updated with the new translation.  We take the
630       approach of translating immediately before every use of yytoken.
631       One alternative is translating here after every semantic action,
632       but that translation would be missed if the semantic action
633       invokes YYABORT, YYACCEPT, or YYERROR immediately after altering
634       yychar.  In the case of YYABORT or YYACCEPT, an incorrect
635       destructor might then be invoked immediately.  In the case of
636       YYERROR, subsequent parser actions might lead to an incorrect
637       destructor call or verbose syntax error message before the
638       lookahead is translated.  */
639    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
640
641    yypop_ (yylen);
642    yylen = 0;
643    YY_STACK_PRINT ();
644
645    yysemantic_stack_.push (yyval);
646    yylocation_stack_.push (yyloc);
647
648    /* Shift the result of the reduction.  */
649    yyn = yyr1_[yyn];
650    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
651    if (0 <= yystate && yystate <= yylast_
652        && yycheck_[yystate] == yystate_stack_[0])
653      yystate = yytable_[yystate];
654    else
655      yystate = yydefgoto_[yyn - yyntokens_];
656    goto yynewstate;
657
658  /*------------------------------------.
659  | yyerrlab -- here on detecting error |
660  `------------------------------------*/
661  yyerrlab:
662    /* Make sure we have latest lookahead translation.  See comments at
663       user semantic actions for why this is necessary.  */
664    yytoken = yytranslate_ (yychar);
665
666    /* If not already recovering from an error, report this error.  */
667    if (!yyerrstatus_)
668      {
669        ++yynerrs_;
670        if (yychar == yyempty_)
671          yytoken = yyempty_;
672        error (yylloc, yysyntax_error_ (yystate, yytoken));
673      }
674
675    yyerror_range[1] = yylloc;
676    if (yyerrstatus_ == 3)
677      {
678        /* If just tried and failed to reuse lookahead token after an
679         error, discard it.  */
680
681        if (yychar <= yyeof_)
682          {
683          /* Return failure if at end of input.  */
684          if (yychar == yyeof_)
685            YYABORT;
686          }
687        else
688          {
689            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
690            yychar = yyempty_;
691          }
692      }
693
694    /* Else will try to reuse lookahead token after shifting the error
695       token.  */
696    goto yyerrlab1;
697
698
699  /*---------------------------------------------------.
700  | yyerrorlab -- error raised explicitly by YYERROR.  |
701  `---------------------------------------------------*/
702  yyerrorlab:
703
704    /* Pacify compilers like GCC when the user code never invokes
705       YYERROR and the label yyerrorlab therefore never appears in user
706       code.  */
707    if (false)
708      goto yyerrorlab;
709
710    yyerror_range[1] = yylocation_stack_[yylen - 1];
711    /* Do not reclaim the symbols of the rule which action triggered
712       this YYERROR.  */
713    yypop_ (yylen);
714    yylen = 0;
715    yystate = yystate_stack_[0];
716    goto yyerrlab1;
717
718  /*-------------------------------------------------------------.
719  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
720  `-------------------------------------------------------------*/
721  yyerrlab1:
722    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
723
724    for (;;)
725      {
726        yyn = yypact_[yystate];
727        if (!yy_pact_value_is_default_ (yyn))
728        {
729          yyn += yyterror_;
730          if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
731            {
732              yyn = yytable_[yyn];
733              if (0 < yyn)
734                break;
735            }
736        }
737
738        /* Pop the current state because it cannot handle the error token.  */
739        if (yystate_stack_.height () == 1)
740        YYABORT;
741
742        yyerror_range[1] = yylocation_stack_[0];
743        yydestruct_ ("Error: popping",
744                     yystos_[yystate],
745                     &yysemantic_stack_[0], &yylocation_stack_[0]);
746        yypop_ ();
747        yystate = yystate_stack_[0];
748        YY_STACK_PRINT ();
749      }
750
751    yyerror_range[2] = yylloc;
752    // Using YYLLOC is tempting, but would change the location of
753    // the lookahead.  YYLOC is available though.
754    YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
755    yysemantic_stack_.push (yylval);
756    yylocation_stack_.push (yyloc);
757
758    /* Shift the error token.  */
759    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
760                     &yysemantic_stack_[0], &yylocation_stack_[0]);
761
762    yystate = yyn;
763    goto yynewstate;
764
765    /* Accept.  */
766  yyacceptlab:
767    yyresult = 0;
768    goto yyreturn;
769
770    /* Abort.  */
771  yyabortlab:
772    yyresult = 1;
773    goto yyreturn;
774
775  yyreturn:
776    if (yychar != yyempty_)
777      {
778        /* Make sure we have latest lookahead translation.  See comments
779           at user semantic actions for why this is necessary.  */
780        yytoken = yytranslate_ (yychar);
781        yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
782                     &yylloc);
783      }
784
785    /* Do not reclaim the symbols of the rule which action triggered
786       this YYABORT or YYACCEPT.  */
787    yypop_ (yylen);
788    while (yystate_stack_.height () != 1)
789      {
790        yydestruct_ ("Cleanup: popping",
791                   yystos_[yystate_stack_[0]],
792                   &yysemantic_stack_[0],
793                   &yylocation_stack_[0]);
794        yypop_ ();
795      }
796
797    return yyresult;
798  }
799
800  // Generate an error message.
801  std::string
802  GunParser::yysyntax_error_ (int yystate, int yytoken)
803  {
804    std::string yyres;
805    // Number of reported tokens (one for the "unexpected", one per
806    // "expected").
807    size_t yycount = 0;
808    // Its maximum.
809    enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
810    // Arguments of yyformat.
811    char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
812
813    /* There are many possibilities here to consider:
814       - If this state is a consistent state with a default action, then
815         the only way this function was invoked is if the default action
816         is an error action.  In that case, don't check for expected
817         tokens because there are none.
818       - The only way there can be no lookahead present (in yytoken) is
819         if this state is a consistent state with a default action.
820         Thus, detecting the absence of a lookahead is sufficient to
821         determine that there is no unexpected or expected token to
822         report.  In that case, just report a simple "syntax error".
823       - Don't assume there isn't a lookahead just because this state is
824         a consistent state with a default action.  There might have
825         been a previous inconsistent state, consistent state with a
826         non-default action, or user semantic action that manipulated
827         yychar.
828       - Of course, the expected token list depends on states to have
829         correct lookahead information, and it depends on the parser not
830         to perform extra reductions after fetching a lookahead from the
831         scanner and before detecting a syntax error.  Thus, state
832         merging (from LALR or IELR) and default reductions corrupt the
833         expected token list.  However, the list is correct for
834         canonical LR with one exception: it will still contain any
835         token that will not be accepted due to an error action in a
836         later state.
837    */
838    if (yytoken != yyempty_)
839      {
840        yyarg[yycount++] = yytname_[yytoken];
841        int yyn = yypact_[yystate];
842        if (!yy_pact_value_is_default_ (yyn))
843          {
844            /* Start YYX at -YYN if negative to avoid negative indexes in
845               YYCHECK.  In other words, skip the first -YYN actions for
846               this state because they are default actions.  */
847            int yyxbegin = yyn < 0 ? -yyn : 0;
848            /* Stay within bounds of both yycheck and yytname.  */
849            int yychecklim = yylast_ - yyn + 1;
850            int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
851            for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
852              if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
853                  && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
854                {
855                  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
856                    {
857                      yycount = 1;
858                      break;
859                    }
860                  else
861                    yyarg[yycount++] = yytname_[yyx];
862                }
863          }
864      }
865
866    char const* yyformat = 0;
867    switch (yycount)
868      {
869#define YYCASE_(N, S)                         \
870        case N:                               \
871          yyformat = S;                       \
872        break
873        YYCASE_(0, YY_("syntax error"));
874        YYCASE_(1, YY_("syntax error, unexpected %s"));
875        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
876        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
877        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
878        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
879#undef YYCASE_
880      }
881
882    // Argument number.
883    size_t yyi = 0;
884    for (char const* yyp = yyformat; *yyp; ++yyp)
885      if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
886        {
887          yyres += yytnamerr_ (yyarg[yyi++]);
888          ++yyp;
889        }
890      else
891        yyres += *yyp;
892    return yyres;
893  }
894
895
896  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
897     STATE-NUM.  */
898  const signed char GunParser::yypact_ninf_ = -23;
899  const signed char
900  GunParser::yypact_[] =
901  {
902        -1,   -23,    19,    19,    19,    19,    19,    19,    19,    19,
903      19,    19,    19,    19,    19,    19,   -23,    18,     1,   -23,
904     -23,    19,   -23,   -23,   -23,   -23,   -23,   -23,   -23,   -23,
905       0,    11,   -23,   -23,   -23,   -23,   -23,   -23,   -23,   -23,
906     -23,    -1,   -23,    19,    19,   -23,   -23,   -23
907  };
908
909  /* YYDEFACT[S] -- default reduction number in state S.  Performed when
910     YYTABLE doesn't specify something else to do.  Zero means the
911     default is an error.  */
912  const unsigned char
913  GunParser::yydefact_[] =
914  {
915         0,     5,     0,     0,     0,     0,     0,     0,     0,     0,
916       0,     0,     0,     0,     0,     0,    20,     0,     0,     3,
917      24,     0,     6,    21,     7,     8,     9,    10,    11,    12,
918       0,     0,    13,    14,    15,    16,    17,    18,    19,     1,
919       2,     0,    25,     0,     0,     4,    22,    23
920  };
921
922  /* YYPGOTO[NTERM-NUM].  */
923  const signed char
924  GunParser::yypgoto_[] =
925  {
926       -23,   -23,   -23,   -22,    22,   -23,    29,   -21
927  };
928
929  /* YYDEFGOTO[NTERM-NUM].  */
930  const signed char
931  GunParser::yydefgoto_[] =
932  {
933        -1,    17,    18,    19,    30,    31,    32,    23
934  };
935
936  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
937     positive, shift that token.  If negative, reduce the rule which
938     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
939  const signed char GunParser::yytable_ninf_ = -1;
940  const unsigned char
941  GunParser::yytable_[] =
942  {
943        42,    40,     1,     2,     3,     4,     5,     6,     7,     8,
944       9,    10,    11,    12,    13,    14,    15,    16,    39,    45,
945      43,    41,    46,    47,    22,    24,    25,    26,    27,    28,
946      29,    44,     0,    34,    35,    36,    37,    38,    20,    33,
947      21
948  };
949
950  /* YYCHECK.  */
951  const signed char
952  GunParser::yycheck_[] =
953  {
954        21,     0,     3,     4,     5,     6,     7,     8,     9,    10,
955      11,    12,    13,    14,    15,    16,    17,    18,     0,    41,
956      20,    20,    43,    44,     2,     3,     4,     5,     6,     7,
957       8,    20,    -1,    11,    12,    13,    14,    15,    19,    10,
958      21
959  };
960
961  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
962     symbol of state STATE-NUM.  */
963  const unsigned char
964  GunParser::yystos_[] =
965  {
966         0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
967      12,    13,    14,    15,    16,    17,    18,    23,    24,    25,
968      19,    21,    26,    29,    26,    26,    26,    26,    26,    26,
969      26,    27,    28,    28,    26,    26,    26,    26,    26,     0,
970       0,    20,    29,    20,    20,    25,    29,    29
971  };
972
973#if YYDEBUG
974  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
975     to YYLEX-NUM.  */
976  const unsigned short int
977  GunParser::yytoken_number_[] =
978  {
979         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
980     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
981      44,    45
982  };
983#endif
984
985  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
986  const unsigned char
987  GunParser::yyr1_[] =
988  {
989         0,    22,    23,    24,    24,    25,    25,    25,    25,    25,
990      25,    25,    25,    25,    25,    25,    25,    25,    25,    25,
991      25,    26,    27,    28,    29,    29
992  };
993
994  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
995  const unsigned char
996  GunParser::yyr2_[] =
997  {
998         0,     2,     2,     1,     3,     1,     2,     2,     2,     2,
999       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1000       1,     1,     3,     3,     1,     2
1001  };
1002
1003#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1004  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1005     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
1006  const char*
1007  const GunParser::yytname_[] =
1008  {
1009    "T_END", "error", "$undefined", "T_AI", "T_PAI", "T_CA", "T_SA",
1010  "T_TIM", "T_SO", "T_RD", "T_SPD", "T_MODA", "T_MODB", "T_FFB", "T_FFP",
1011  "T_FB", "T_FP", "T_SK", "T_LOOP", "NUMBER", "','", "'-'", "$accept",
1012  "gun_description", "gun_command_list", "gun_command", "args1", "args2",
1013  "args3", "number", 0
1014  };
1015#endif
1016
1017#if YYDEBUG
1018  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1019  const GunParser::rhs_number_type
1020  GunParser::yyrhs_[] =
1021  {
1022        23,     0,    -1,    24,     0,    -1,    25,    -1,    24,    20,
1023      25,    -1,     3,    -1,     4,    26,    -1,     5,    26,    -1,
1024       6,    26,    -1,     7,    26,    -1,     8,    26,    -1,     9,
1025      26,    -1,    10,    26,    -1,    11,    28,    -1,    12,    28,
1026      -1,    13,    26,    -1,    14,    26,    -1,    15,    26,    -1,
1027      16,    26,    -1,    17,    26,    -1,    18,    -1,    29,    -1,
1028      26,    20,    29,    -1,    27,    20,    29,    -1,    19,    -1,
1029      21,    29,    -1
1030  };
1031
1032  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1033     YYRHS.  */
1034  const unsigned char
1035  GunParser::yyprhs_[] =
1036  {
1037         0,     0,     3,     6,     8,    12,    14,    17,    20,    23,
1038      26,    29,    32,    35,    38,    41,    44,    47,    50,    53,
1039      56,    58,    60,    64,    68,    70
1040  };
1041
1042  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
1043  const unsigned char
1044  GunParser::yyrline_[] =
1045  {
1046         0,    76,    76,    80,    81,    85,    86,    87,    88,    89,
1047      90,    91,    92,    93,    94,    95,    98,   101,   104,   107,
1048     109,   112,   113,   114,   117,   118
1049  };
1050
1051  // Print the state stack on the debug stream.
1052  void
1053  GunParser::yystack_print_ ()
1054  {
1055    *yycdebug_ << "Stack now";
1056    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1057         i != yystate_stack_.end (); ++i)
1058      *yycdebug_ << ' ' << *i;
1059    *yycdebug_ << std::endl;
1060  }
1061
1062  // Report on the debug stream that the rule \a yyrule is going to be reduced.
1063  void
1064  GunParser::yy_reduce_print_ (int yyrule)
1065  {
1066    unsigned int yylno = yyrline_[yyrule];
1067    int yynrhs = yyr2_[yyrule];
1068    /* Print the symbols being reduced, and their result.  */
1069    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1070               << " (line " << yylno << "):" << std::endl;
1071    /* The symbols being reduced.  */
1072    for (int yyi = 0; yyi < yynrhs; yyi++)
1073      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
1074                       yyrhs_[yyprhs_[yyrule] + yyi],
1075                       &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1076                       &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1077  }
1078#endif // YYDEBUG
1079
1080  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1081  GunParser::token_number_type
1082  GunParser::yytranslate_ (int t)
1083  {
1084    static
1085    const token_number_type
1086    translate_table[] =
1087    {
1088           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1089       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1090       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1091       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1092       2,     2,     2,     2,    20,    21,     2,     2,     2,     2,
1093       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1094       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1095       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1096       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1097       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1098       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1099       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1100       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1101       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1102       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1103       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1104       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1105       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1106       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1107       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1108       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1109       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1110       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1111       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1112       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1113       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1114       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1115      15,    16,    17,    18,    19
1116    };
1117    if ((unsigned int) t <= yyuser_token_number_max_)
1118      return translate_table[t];
1119    else
1120      return yyundef_token_;
1121  }
1122
1123  const int GunParser::yyeof_ = 0;
1124  const int GunParser::yylast_ = 40;
1125  const int GunParser::yynnts_ = 8;
1126  const int GunParser::yyempty_ = -2;
1127  const int GunParser::yyfinal_ = 39;
1128  const int GunParser::yyterror_ = 1;
1129  const int GunParser::yyerrcode_ = 256;
1130  const int GunParser::yyntokens_ = 22;
1131
1132  const unsigned int GunParser::yyuser_token_number_max_ = 274;
1133  const GunParser::token_number_type GunParser::yyundef_token_ = 2;
1134
1135
1136} // orbital
1137
1138/* Line 1136 of lalr1.cc  */
1139#line 1140 "generated/gun-parser.cpp"
1140
1141
1142/* Line 1138 of lalr1.cc  */
1143#line 121 "gun-parser.y"
1144
1145
1146void orbital::GunParser::error(const GunParser::location_type& l,
1147                               const std::string& m)
1148{
1149    gc.Error(l, m);
1150}
1151
1152
Note: See TracBrowser for help on using the repository browser.