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

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

orbital: parser for the gun commands... fails to link because of flex.

  • Property svn:keywords set to Id
File size: 28.4 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
34/* First part of user declarations.  */
35
36
37/* Line 293 of lalr1.cc  */
38#line 39 "generated/gun-parser.cpp"
39
40
41#include "gun-parser.hpp"
42
43/* User implementation prologue.  */
44
45
46/* Line 299 of lalr1.cc  */
47#line 48 "generated/gun-parser.cpp"
48/* Unqualified %code blocks.  */
49
50/* Line 300 of lalr1.cc  */
51#line 18 "gun.yy"
52
53#define YY_DECL \
54    yy::GunParser::token_type \
55    yylex(yy::GunParser::semantic_type* yylval, \
56          yy::GunParser::location_type* yylloc, \
57          Gun& gun, \
58          void *yyscanner)
59YY_DECL;
60
61
62
63/* Line 300 of lalr1.cc  */
64#line 65 "generated/gun-parser.cpp"
65
66#ifndef YY_
67# if defined YYENABLE_NLS && YYENABLE_NLS
68#  if ENABLE_NLS
69#   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
70#   define YY_(msgid) dgettext ("bison-runtime", msgid)
71#  endif
72# endif
73# ifndef YY_
74#  define YY_(msgid) msgid
75# endif
76#endif
77
78/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
79   If N is 0, then set CURRENT to the empty location which ends
80   the previous symbol: RHS[0] (always defined).  */
81
82#define YYRHSLOC(Rhs, K) ((Rhs)[K])
83#ifndef YYLLOC_DEFAULT
84# define YYLLOC_DEFAULT(Current, Rhs, N)                               \
85 do                                                                    \
86   if (N)                                                              \
87     {                                                                 \
88       (Current).begin = YYRHSLOC (Rhs, 1).begin;                      \
89       (Current).end   = YYRHSLOC (Rhs, N).end;                        \
90     }                                                                 \
91   else                                                                \
92     {                                                                 \
93       (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end;        \
94     }                                                                 \
95 while (false)
96#endif
97
98/* Suppress unused-variable warnings by "using" E.  */
99#define YYUSE(e) ((void) (e))
100
101/* Enable debugging if requested.  */
102#if YYDEBUG
103
104/* A pseudo ostream that takes yydebug_ into account.  */
105# define YYCDEBUG if (yydebug_) (*yycdebug_)
106
107# define YY_SYMBOL_PRINT(Title, Type, Value, Location)  \
108do {                                                    \
109  if (yydebug_)                                         \
110    {                                                   \
111      *yycdebug_ << Title << ' ';                       \
112      yy_symbol_print_ ((Type), (Value), (Location));   \
113      *yycdebug_ << std::endl;                          \
114    }                                                   \
115} while (false)
116
117# define YY_REDUCE_PRINT(Rule)          \
118do {                                    \
119  if (yydebug_)                         \
120    yy_reduce_print_ (Rule);            \
121} while (false)
122
123# define YY_STACK_PRINT()               \
124do {                                    \
125  if (yydebug_)                         \
126    yystack_print_ ();                  \
127} while (false)
128
129#else /* !YYDEBUG */
130
131# define YYCDEBUG if (false) std::cerr
132# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
133# define YY_REDUCE_PRINT(Rule)
134# define YY_STACK_PRINT()
135
136#endif /* !YYDEBUG */
137
138#define yyerrok         (yyerrstatus_ = 0)
139#define yyclearin       (yychar = yyempty_)
140
141#define YYACCEPT        goto yyacceptlab
142#define YYABORT         goto yyabortlab
143#define YYERROR         goto yyerrorlab
144#define YYRECOVERING()  (!!yyerrstatus_)
145
146
147namespace yy {
148
149/* Line 382 of lalr1.cc  */
150#line 151 "generated/gun-parser.cpp"
151
152  /// Build a parser object.
153  GunParser::GunParser (Gun &gun_yyarg, void *yyscanner_yyarg)
154    :
155#if YYDEBUG
156      yydebug_ (false),
157      yycdebug_ (&std::cerr),
158#endif
159      gun (gun_yyarg),
160      yyscanner (yyscanner_yyarg)
161  {
162  }
163
164  GunParser::~GunParser ()
165  {
166  }
167
168#if YYDEBUG
169  /*--------------------------------.
170  | Print this symbol on YYOUTPUT.  |
171  `--------------------------------*/
172
173  inline void
174  GunParser::yy_symbol_value_print_ (int yytype,
175                           const semantic_type* yyvaluep, const location_type* yylocationp)
176  {
177    YYUSE (yylocationp);
178    YYUSE (yyvaluep);
179    switch (yytype)
180      {
181         default:
182          break;
183      }
184  }
185
186
187  void
188  GunParser::yy_symbol_print_ (int yytype,
189                           const semantic_type* yyvaluep, const location_type* yylocationp)
190  {
191    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
192               << ' ' << yytname_[yytype] << " ("
193               << *yylocationp << ": ";
194    yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
195    *yycdebug_ << ')';
196  }
197#endif
198
199  void
200  GunParser::yydestruct_ (const char* yymsg,
201                           int yytype, semantic_type* yyvaluep, location_type* yylocationp)
202  {
203    YYUSE (yylocationp);
204    YYUSE (yymsg);
205    YYUSE (yyvaluep);
206
207    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
208
209    switch (yytype)
210      {
211 
212        default:
213          break;
214      }
215  }
216
217  void
218  GunParser::yypop_ (unsigned int n)
219  {
220    yystate_stack_.pop (n);
221    yysemantic_stack_.pop (n);
222    yylocation_stack_.pop (n);
223  }
224
225#if YYDEBUG
226  std::ostream&
227  GunParser::debug_stream () const
228  {
229    return *yycdebug_;
230  }
231
232  void
233  GunParser::set_debug_stream (std::ostream& o)
234  {
235    yycdebug_ = &o;
236  }
237
238
239  GunParser::debug_level_type
240  GunParser::debug_level () const
241  {
242    return yydebug_;
243  }
244
245  void
246  GunParser::set_debug_level (debug_level_type l)
247  {
248    yydebug_ = l;
249  }
250#endif
251
252  inline bool
253  GunParser::yy_pact_value_is_default_ (int yyvalue)
254  {
255    return yyvalue == yypact_ninf_;
256  }
257
258  inline bool
259  GunParser::yy_table_value_is_error_ (int yyvalue)
260  {
261    return yyvalue == yytable_ninf_;
262  }
263
264  int
265  GunParser::parse ()
266  {
267    /// Lookahead and lookahead in internal form.
268    int yychar = yyempty_;
269    int yytoken = 0;
270
271    /* State.  */
272    int yyn;
273    int yylen = 0;
274    int yystate = 0;
275
276    /* Error handling.  */
277    int yynerrs_ = 0;
278    int yyerrstatus_ = 0;
279
280    /// Semantic value of the lookahead.
281    semantic_type yylval;
282    /// Location of the lookahead.
283    location_type yylloc;
284    /// The locations where the error started and ended.
285    location_type yyerror_range[3];
286
287    /// $$.
288    semantic_type yyval;
289    /// @$.
290    location_type yyloc;
291
292    int yyresult;
293
294    YYCDEBUG << "Starting parse" << std::endl;
295
296
297    /* Initialize the stacks.  The initial state will be pushed in
298       yynewstate, since the latter expects the semantical and the
299       location values to have been already stored, initialize these
300       stacks with a primary value.  */
301    yystate_stack_ = state_stack_type (0);
302    yysemantic_stack_ = semantic_stack_type (0);
303    yylocation_stack_ = location_stack_type (0);
304    yysemantic_stack_.push (yylval);
305    yylocation_stack_.push (yylloc);
306
307    /* New state.  */
308  yynewstate:
309    yystate_stack_.push (yystate);
310    YYCDEBUG << "Entering state " << yystate << std::endl;
311
312    /* Accept?  */
313    if (yystate == yyfinal_)
314      goto yyacceptlab;
315
316    goto yybackup;
317
318    /* Backup.  */
319  yybackup:
320
321    /* Try to take a decision without lookahead.  */
322    yyn = yypact_[yystate];
323    if (yy_pact_value_is_default_ (yyn))
324      goto yydefault;
325
326    /* Read a lookahead token.  */
327    if (yychar == yyempty_)
328      {
329        YYCDEBUG << "Reading a token: ";
330        yychar = yylex (&yylval, &yylloc, gun, yyscanner);
331      }
332
333
334    /* Convert token to internal form.  */
335    if (yychar <= yyeof_)
336      {
337        yychar = yytoken = yyeof_;
338        YYCDEBUG << "Now at end of input." << std::endl;
339      }
340    else
341      {
342        yytoken = yytranslate_ (yychar);
343        YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
344      }
345
346    /* If the proper action on seeing token YYTOKEN is to reduce or to
347       detect an error, take that action.  */
348    yyn += yytoken;
349    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
350      goto yydefault;
351
352    /* Reduce or error.  */
353    yyn = yytable_[yyn];
354    if (yyn <= 0)
355      {
356        if (yy_table_value_is_error_ (yyn))
357          goto yyerrlab;
358        yyn = -yyn;
359        goto yyreduce;
360      }
361
362    /* Shift the lookahead token.  */
363    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
364
365    /* Discard the token being shifted.  */
366    yychar = yyempty_;
367
368    yysemantic_stack_.push (yylval);
369    yylocation_stack_.push (yylloc);
370
371    /* Count tokens shifted since error; after three, turn off error
372       status.  */
373    if (yyerrstatus_)
374      --yyerrstatus_;
375
376    yystate = yyn;
377    goto yynewstate;
378
379  /*-----------------------------------------------------------.
380  | yydefault -- do the default action for the current state.  |
381  `-----------------------------------------------------------*/
382  yydefault:
383    yyn = yydefact_[yystate];
384    if (yyn == 0)
385      goto yyerrlab;
386    goto yyreduce;
387
388  /*-----------------------------.
389  | yyreduce -- Do a reduction.  |
390  `-----------------------------*/
391  yyreduce:
392    yylen = yyr2_[yyn];
393    /* If YYLEN is nonzero, implement the default value of the action:
394       `$$ = $1'.  Otherwise, use the top of the stack.
395
396       Otherwise, the following line sets YYVAL to garbage.
397       This behavior is undocumented and Bison
398       users should not rely upon it.  */
399    if (yylen)
400      yyval = yysemantic_stack_[yylen - 1];
401    else
402      yyval = yysemantic_stack_[0];
403
404    {
405      slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
406      YYLLOC_DEFAULT (yyloc, slice, yylen);
407    }
408    YY_REDUCE_PRINT (yyn);
409    switch (yyn)
410      {
411          case 5:
412
413/* Line 690 of lalr1.cc  */
414#line 73 "gun.yy"
415    { gun.m_angle = gun.AimActor(); }
416    break;
417
418  case 6:
419
420/* Line 690 of lalr1.cc  */
421#line 74 "gun.yy"
422    { gun.PreAimActor((yysemantic_stack_[(2) - (2)].args).f0); }
423    break;
424
425  case 7:
426
427/* Line 690 of lalr1.cc  */
428#line 75 "gun.yy"
429    { gun.m_pre_aim = (yysemantic_stack_[(2) - (2)].args).f0; }
430    break;
431
432  case 8:
433
434/* Line 690 of lalr1.cc  */
435#line 76 "gun.yy"
436    { gun.m_angle = (yysemantic_stack_[(2) - (2)].args).f0; }
437    break;
438
439  case 9:
440
441/* Line 690 of lalr1.cc  */
442#line 77 "gun.yy"
443    { gun.m_round_duration = (yysemantic_stack_[(2) - (2)].args).f0; }
444    break;
445
446  case 10:
447
448/* Line 690 of lalr1.cc  */
449#line 78 "gun.yy"
450    { gun.m_angle_offset = (yysemantic_stack_[(2) - (2)].args).f0; }
451    break;
452
453  case 11:
454
455/* Line 690 of lalr1.cc  */
456#line 79 "gun.yy"
457    { gun.m_radius = (yysemantic_stack_[(2) - (2)].args).f0; }
458    break;
459
460  case 12:
461
462/* Line 690 of lalr1.cc  */
463#line 80 "gun.yy"
464    { gun.m_shoot_speed = (yysemantic_stack_[(2) - (2)].args).f0; }
465    break;
466
467  case 13:
468
469/* Line 690 of lalr1.cc  */
470#line 81 "gun.yy"
471    { /* FIXME: 1st modifier */ }
472    break;
473
474  case 14:
475
476/* Line 690 of lalr1.cc  */
477#line 82 "gun.yy"
478    { /* FIXME: 2nd modifier */ }
479    break;
480
481  case 15:
482
483/* Line 690 of lalr1.cc  */
484#line 83 "gun.yy"
485    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gun.Shoot(1);
486                      gun.m_shoot_type = 1;
487                      gun.m_round_timer = gun.m_round_duration; }
488    break;
489
490  case 16:
491
492/* Line 690 of lalr1.cc  */
493#line 86 "gun.yy"
494    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gun.Shoot(0);
495                      gun.m_shoot_type = 0;
496                      gun.m_round_timer = gun.m_round_duration; }
497    break;
498
499  case 17:
500
501/* Line 690 of lalr1.cc  */
502#line 89 "gun.yy"
503    { gun.Shoot(1); gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
504                      gun.m_shoot_type = 1;
505                      gun.m_round_timer = gun.m_round_duration; }
506    break;
507
508  case 18:
509
510/* Line 690 of lalr1.cc  */
511#line 92 "gun.yy"
512    { gun.Shoot(0); gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
513                      gun.m_shoot_type = 0;
514                      gun.m_round_timer = gun.m_round_duration; }
515    break;
516
517  case 19:
518
519/* Line 690 of lalr1.cc  */
520#line 95 "gun.yy"
521    { gun.m_round_timer = gun.m_round_duration * (yysemantic_stack_[(2) - (2)].args).f0;
522                      /* FIXME: modifiers */ }
523    break;
524
525  case 20:
526
527/* Line 690 of lalr1.cc  */
528#line 97 "gun.yy"
529    { /* FIXME: loops */ }
530    break;
531
532  case 21:
533
534/* Line 690 of lalr1.cc  */
535#line 100 "gun.yy"
536    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
537    break;
538
539  case 22:
540
541/* Line 690 of lalr1.cc  */
542#line 101 "gun.yy"
543    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(3) - (3)].fval); }
544    break;
545
546  case 23:
547
548/* Line 690 of lalr1.cc  */
549#line 102 "gun.yy"
550    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(3) - (3)].fval); }
551    break;
552
553  case 24:
554
555/* Line 690 of lalr1.cc  */
556#line 110 "gun.yy"
557    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
558    break;
559
560  case 25:
561
562/* Line 690 of lalr1.cc  */
563#line 111 "gun.yy"
564    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
565    break;
566
567
568
569/* Line 690 of lalr1.cc  */
570#line 571 "generated/gun-parser.cpp"
571        default:
572          break;
573      }
574    /* User semantic actions sometimes alter yychar, and that requires
575       that yytoken be updated with the new translation.  We take the
576       approach of translating immediately before every use of yytoken.
577       One alternative is translating here after every semantic action,
578       but that translation would be missed if the semantic action
579       invokes YYABORT, YYACCEPT, or YYERROR immediately after altering
580       yychar.  In the case of YYABORT or YYACCEPT, an incorrect
581       destructor might then be invoked immediately.  In the case of
582       YYERROR, subsequent parser actions might lead to an incorrect
583       destructor call or verbose syntax error message before the
584       lookahead is translated.  */
585    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
586
587    yypop_ (yylen);
588    yylen = 0;
589    YY_STACK_PRINT ();
590
591    yysemantic_stack_.push (yyval);
592    yylocation_stack_.push (yyloc);
593
594    /* Shift the result of the reduction.  */
595    yyn = yyr1_[yyn];
596    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
597    if (0 <= yystate && yystate <= yylast_
598        && yycheck_[yystate] == yystate_stack_[0])
599      yystate = yytable_[yystate];
600    else
601      yystate = yydefgoto_[yyn - yyntokens_];
602    goto yynewstate;
603
604  /*------------------------------------.
605  | yyerrlab -- here on detecting error |
606  `------------------------------------*/
607  yyerrlab:
608    /* Make sure we have latest lookahead translation.  See comments at
609       user semantic actions for why this is necessary.  */
610    yytoken = yytranslate_ (yychar);
611
612    /* If not already recovering from an error, report this error.  */
613    if (!yyerrstatus_)
614      {
615        ++yynerrs_;
616        if (yychar == yyempty_)
617          yytoken = yyempty_;
618        error (yylloc, yysyntax_error_ (yystate, yytoken));
619      }
620
621    yyerror_range[1] = yylloc;
622    if (yyerrstatus_ == 3)
623      {
624        /* If just tried and failed to reuse lookahead token after an
625         error, discard it.  */
626
627        if (yychar <= yyeof_)
628          {
629          /* Return failure if at end of input.  */
630          if (yychar == yyeof_)
631            YYABORT;
632          }
633        else
634          {
635            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
636            yychar = yyempty_;
637          }
638      }
639
640    /* Else will try to reuse lookahead token after shifting the error
641       token.  */
642    goto yyerrlab1;
643
644
645  /*---------------------------------------------------.
646  | yyerrorlab -- error raised explicitly by YYERROR.  |
647  `---------------------------------------------------*/
648  yyerrorlab:
649
650    /* Pacify compilers like GCC when the user code never invokes
651       YYERROR and the label yyerrorlab therefore never appears in user
652       code.  */
653    if (false)
654      goto yyerrorlab;
655
656    yyerror_range[1] = yylocation_stack_[yylen - 1];
657    /* Do not reclaim the symbols of the rule which action triggered
658       this YYERROR.  */
659    yypop_ (yylen);
660    yylen = 0;
661    yystate = yystate_stack_[0];
662    goto yyerrlab1;
663
664  /*-------------------------------------------------------------.
665  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
666  `-------------------------------------------------------------*/
667  yyerrlab1:
668    yyerrstatus_ = 3;   /* Each real token shifted decrements this.  */
669
670    for (;;)
671      {
672        yyn = yypact_[yystate];
673        if (!yy_pact_value_is_default_ (yyn))
674        {
675          yyn += yyterror_;
676          if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
677            {
678              yyn = yytable_[yyn];
679              if (0 < yyn)
680                break;
681            }
682        }
683
684        /* Pop the current state because it cannot handle the error token.  */
685        if (yystate_stack_.height () == 1)
686        YYABORT;
687
688        yyerror_range[1] = yylocation_stack_[0];
689        yydestruct_ ("Error: popping",
690                     yystos_[yystate],
691                     &yysemantic_stack_[0], &yylocation_stack_[0]);
692        yypop_ ();
693        yystate = yystate_stack_[0];
694        YY_STACK_PRINT ();
695      }
696
697    yyerror_range[2] = yylloc;
698    // Using YYLLOC is tempting, but would change the location of
699    // the lookahead.  YYLOC is available though.
700    YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
701    yysemantic_stack_.push (yylval);
702    yylocation_stack_.push (yyloc);
703
704    /* Shift the error token.  */
705    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
706                     &yysemantic_stack_[0], &yylocation_stack_[0]);
707
708    yystate = yyn;
709    goto yynewstate;
710
711    /* Accept.  */
712  yyacceptlab:
713    yyresult = 0;
714    goto yyreturn;
715
716    /* Abort.  */
717  yyabortlab:
718    yyresult = 1;
719    goto yyreturn;
720
721  yyreturn:
722    if (yychar != yyempty_)
723      {
724        /* Make sure we have latest lookahead translation.  See comments
725           at user semantic actions for why this is necessary.  */
726        yytoken = yytranslate_ (yychar);
727        yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
728                     &yylloc);
729      }
730
731    /* Do not reclaim the symbols of the rule which action triggered
732       this YYABORT or YYACCEPT.  */
733    yypop_ (yylen);
734    while (yystate_stack_.height () != 1)
735      {
736        yydestruct_ ("Cleanup: popping",
737                   yystos_[yystate_stack_[0]],
738                   &yysemantic_stack_[0],
739                   &yylocation_stack_[0]);
740        yypop_ ();
741      }
742
743    return yyresult;
744  }
745
746  // Generate an error message.
747  std::string
748  GunParser::yysyntax_error_ (int, int)
749  {
750    return YY_("syntax error");
751  }
752
753
754  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
755     STATE-NUM.  */
756  const signed char GunParser::yypact_ninf_ = -23;
757  const signed char
758  GunParser::yypact_[] =
759  {
760        -1,   -23,    19,    19,    19,    19,    19,    19,    19,    19,
761      19,    19,    19,    19,    19,    19,   -23,    18,     1,   -23,
762     -23,    19,   -23,   -23,   -23,   -23,   -23,   -23,   -23,   -23,
763       0,    11,   -23,   -23,   -23,   -23,   -23,   -23,   -23,   -23,
764     -23,    -1,   -23,    19,    19,   -23,   -23,   -23
765  };
766
767  /* YYDEFACT[S] -- default reduction number in state S.  Performed when
768     YYTABLE doesn't specify something else to do.  Zero means the
769     default is an error.  */
770  const unsigned char
771  GunParser::yydefact_[] =
772  {
773         0,     5,     0,     0,     0,     0,     0,     0,     0,     0,
774       0,     0,     0,     0,     0,     0,    20,     0,     0,     3,
775      24,     0,     6,    21,     7,     8,     9,    10,    11,    12,
776       0,     0,    13,    14,    15,    16,    17,    18,    19,     1,
777       2,     0,    25,     0,     0,     4,    22,    23
778  };
779
780  /* YYPGOTO[NTERM-NUM].  */
781  const signed char
782  GunParser::yypgoto_[] =
783  {
784       -23,   -23,   -23,   -22,    22,   -23,    29,   -21
785  };
786
787  /* YYDEFGOTO[NTERM-NUM].  */
788  const signed char
789  GunParser::yydefgoto_[] =
790  {
791        -1,    17,    18,    19,    30,    31,    32,    23
792  };
793
794  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
795     positive, shift that token.  If negative, reduce the rule which
796     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
797  const signed char GunParser::yytable_ninf_ = -1;
798  const unsigned char
799  GunParser::yytable_[] =
800  {
801        42,    40,     1,     2,     3,     4,     5,     6,     7,     8,
802       9,    10,    11,    12,    13,    14,    15,    16,    39,    45,
803      43,    41,    46,    47,    22,    24,    25,    26,    27,    28,
804      29,    44,     0,    34,    35,    36,    37,    38,    20,    33,
805      21
806  };
807
808  /* YYCHECK.  */
809  const signed char
810  GunParser::yycheck_[] =
811  {
812        21,     0,     3,     4,     5,     6,     7,     8,     9,    10,
813      11,    12,    13,    14,    15,    16,    17,    18,     0,    41,
814      20,    20,    43,    44,     2,     3,     4,     5,     6,     7,
815       8,    20,    -1,    11,    12,    13,    14,    15,    19,    10,
816      21
817  };
818
819  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
820     symbol of state STATE-NUM.  */
821  const unsigned char
822  GunParser::yystos_[] =
823  {
824         0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
825      12,    13,    14,    15,    16,    17,    18,    23,    24,    25,
826      19,    21,    26,    29,    26,    26,    26,    26,    26,    26,
827      26,    27,    28,    28,    26,    26,    26,    26,    26,     0,
828       0,    20,    29,    20,    20,    25,    29,    29
829  };
830
831#if YYDEBUG
832  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
833     to YYLEX-NUM.  */
834  const unsigned short int
835  GunParser::yytoken_number_[] =
836  {
837         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
838     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
839      44,    45
840  };
841#endif
842
843  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
844  const unsigned char
845  GunParser::yyr1_[] =
846  {
847         0,    22,    23,    24,    24,    25,    25,    25,    25,    25,
848      25,    25,    25,    25,    25,    25,    25,    25,    25,    25,
849      25,    26,    27,    28,    29,    29
850  };
851
852  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
853  const unsigned char
854  GunParser::yyr2_[] =
855  {
856         0,     2,     2,     1,     3,     1,     2,     2,     2,     2,
857       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
858       1,     1,     3,     3,     1,     2
859  };
860
861#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
862  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
863     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
864  const char*
865  const GunParser::yytname_[] =
866  {
867    "T_END", "error", "$undefined", "T_AI", "T_PAI", "T_CA", "T_SA",
868  "T_TIM", "T_SO", "T_RD", "T_SPD", "T_MODA", "T_MODB", "T_FFB", "T_FFP",
869  "T_FB", "T_FP", "T_SK", "T_LOOP", "NUMBER", "','", "'-'", "$accept",
870  "gun_description", "gun_command_list", "gun_command", "args1", "args2",
871  "args3", "number", 0
872  };
873#endif
874
875#if YYDEBUG
876  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
877  const GunParser::rhs_number_type
878  GunParser::yyrhs_[] =
879  {
880        23,     0,    -1,    24,     0,    -1,    25,    -1,    24,    20,
881      25,    -1,     3,    -1,     4,    26,    -1,     5,    26,    -1,
882       6,    26,    -1,     7,    26,    -1,     8,    26,    -1,     9,
883      26,    -1,    10,    26,    -1,    11,    28,    -1,    12,    28,
884      -1,    13,    26,    -1,    14,    26,    -1,    15,    26,    -1,
885      16,    26,    -1,    17,    26,    -1,    18,    -1,    29,    -1,
886      26,    20,    29,    -1,    27,    20,    29,    -1,    19,    -1,
887      21,    29,    -1
888  };
889
890  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
891     YYRHS.  */
892  const unsigned char
893  GunParser::yyprhs_[] =
894  {
895         0,     0,     3,     6,     8,    12,    14,    17,    20,    23,
896      26,    29,    32,    35,    38,    41,    44,    47,    50,    53,
897      56,    58,    60,    64,    68,    70
898  };
899
900  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
901  const unsigned char
902  GunParser::yyrline_[] =
903  {
904         0,    64,    64,    68,    69,    73,    74,    75,    76,    77,
905      78,    79,    80,    81,    82,    83,    86,    89,    92,    95,
906      97,   100,   101,   102,   110,   111
907  };
908
909  // Print the state stack on the debug stream.
910  void
911  GunParser::yystack_print_ ()
912  {
913    *yycdebug_ << "Stack now";
914    for (state_stack_type::const_iterator i = yystate_stack_.begin ();
915         i != yystate_stack_.end (); ++i)
916      *yycdebug_ << ' ' << *i;
917    *yycdebug_ << std::endl;
918  }
919
920  // Report on the debug stream that the rule \a yyrule is going to be reduced.
921  void
922  GunParser::yy_reduce_print_ (int yyrule)
923  {
924    unsigned int yylno = yyrline_[yyrule];
925    int yynrhs = yyr2_[yyrule];
926    /* Print the symbols being reduced, and their result.  */
927    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
928               << " (line " << yylno << "):" << std::endl;
929    /* The symbols being reduced.  */
930    for (int yyi = 0; yyi < yynrhs; yyi++)
931      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
932                       yyrhs_[yyprhs_[yyrule] + yyi],
933                       &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
934                       &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
935  }
936#endif // YYDEBUG
937
938  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
939  GunParser::token_number_type
940  GunParser::yytranslate_ (int t)
941  {
942    static
943    const token_number_type
944    translate_table[] =
945    {
946           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
947       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
948       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
949       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
950       2,     2,     2,     2,    20,    21,     2,     2,     2,     2,
951       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
952       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
953       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
954       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
955       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
956       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
957       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
958       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
959       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
960       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
961       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
962       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
963       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
964       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
965       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
966       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
967       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
968       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
969       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
970       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
971       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
972       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
973      15,    16,    17,    18,    19
974    };
975    if ((unsigned int) t <= yyuser_token_number_max_)
976      return translate_table[t];
977    else
978      return yyundef_token_;
979  }
980
981  const int GunParser::yyeof_ = 0;
982  const int GunParser::yylast_ = 40;
983  const int GunParser::yynnts_ = 8;
984  const int GunParser::yyempty_ = -2;
985  const int GunParser::yyfinal_ = 39;
986  const int GunParser::yyterror_ = 1;
987  const int GunParser::yyerrcode_ = 256;
988  const int GunParser::yyntokens_ = 22;
989
990  const unsigned int GunParser::yyuser_token_number_max_ = 274;
991  const GunParser::token_number_type GunParser::yyundef_token_ = 2;
992
993
994} // yy
995
996/* Line 1136 of lalr1.cc  */
997#line 998 "generated/gun-parser.cpp"
998
999
1000/* Line 1138 of lalr1.cc  */
1001#line 114 "gun.yy"
1002
1003
1004void yy::GunParser::error(const yy::GunParser::location_type& l, const std::string &m)
1005{
1006    /* FIXME: do something */
1007    std::cerr << "ERROR: " << m << std::endl;
1008}
1009
1010
Note: See TracBrowser for help on using the repository browser.