Changeset 1495


Ignore:
Timestamp:
Jun 18, 2012, 2:31:26 PM (8 years ago)
Author:
sam
Message:

orbital: allow 6- and 8-component hex colour values.

Location:
trunk/orbital
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/orbital/generated/gun-parser.cpp

    r1442 r1495  
    1 /* A Bison parser, made by GNU Bison 2.4.2.  */
     1/* A Bison parser, made by GNU Bison 2.5.  */
    22
    33/* Skeleton implementation for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2010 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2011 Free Software Foundation, Inc.
    66   
    77   This program is free software: you can redistribute it and/or modify
     
    3636/* First part of user declarations.  */
    3737
    38 /* Line 310 of lalr1.cc  */
     38/* Line 293 of lalr1.cc  */
    3939#line 1 "gun-parser.y"
    4040
     
    6161
    6262
    63 /* Line 310 of lalr1.cc  */
     63/* Line 293 of lalr1.cc  */
    6464#line 65 "generated/gun-parser.cpp"
    6565
     
    6969/* User implementation prologue.  */
    7070
    71 /* Line 316 of lalr1.cc  */
     71/* Line 299 of lalr1.cc  */
    7272#line 66 "gun-parser.y"
    7373
     
    7878
    7979
    80 /* Line 316 of lalr1.cc  */
     80/* Line 299 of lalr1.cc  */
    8181#line 82 "generated/gun-parser.cpp"
    8282
     
    9393#endif
    9494
     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
    95115/* Suppress unused-variable warnings by "using" E.  */
    96116#define YYUSE(e) ((void) (e))
     
    144164namespace orbital {
    145165
    146 /* Line 379 of lalr1.cc  */
    147 #line 148 "generated/gun-parser.cpp"
    148 #if YYERROR_VERBOSE
     166/* Line 382 of lalr1.cc  */
     167#line 168 "generated/gun-parser.cpp"
    149168
    150169  /* Return YYSTR after stripping away unnecessary quotes and
     
    185204  }
    186205
    187 #endif
    188206
    189207  /// Build a parser object.
     
    286304#endif
    287305
     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
    288318  int
    289319  GunParser::parse ()
     
    307337    location_type yylloc;
    308338    /// The locations where the error started and ended.
    309     location_type yyerror_range[2];
     339    location_type yyerror_range[3];
    310340
    311341    /// $$.
     
    345375    /* Try to take a decision without lookahead.  */
    346376    yyn = yypact_[yystate];
    347     if (yyn == yypact_ninf_)
     377    if (yy_pact_value_is_default_ (yyn))
    348378      goto yydefault;
    349379
     
    378408    if (yyn <= 0)
    379409      {
    380         if (yyn == 0 || yyn == yytable_ninf_)
    381         goto yyerrlab;
     410        if (yy_table_value_is_error_ (yyn))
     411          goto yyerrlab;
    382412        yyn = -yyn;
    383413        goto yyreduce;
     
    435465          case 5:
    436466
    437 /* Line 677 of lalr1.cc  */
     467/* Line 690 of lalr1.cc  */
    438468#line 85 "gun-parser.y"
    439469    { gc.m_gun.m_angle = gc.m_gun.AimActor(); }
     
    442472  case 6:
    443473
    444 /* Line 677 of lalr1.cc  */
     474/* Line 690 of lalr1.cc  */
    445475#line 86 "gun-parser.y"
    446476    { gc.m_gun.PreAimActor((yysemantic_stack_[(2) - (2)].args).f0); }
     
    449479  case 7:
    450480
    451 /* Line 677 of lalr1.cc  */
     481/* Line 690 of lalr1.cc  */
    452482#line 87 "gun-parser.y"
    453483    { gc.m_gun.m_pre_aim = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    456486  case 8:
    457487
    458 /* Line 677 of lalr1.cc  */
     488/* Line 690 of lalr1.cc  */
    459489#line 88 "gun-parser.y"
    460490    { gc.m_gun.m_angle = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    463493  case 9:
    464494
    465 /* Line 677 of lalr1.cc  */
     495/* Line 690 of lalr1.cc  */
    466496#line 89 "gun-parser.y"
    467497    { gc.m_gun.m_round_duration = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    470500  case 10:
    471501
    472 /* Line 677 of lalr1.cc  */
     502/* Line 690 of lalr1.cc  */
    473503#line 90 "gun-parser.y"
    474504    { gc.m_gun.m_angle_offset = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    477507  case 11:
    478508
    479 /* Line 677 of lalr1.cc  */
     509/* Line 690 of lalr1.cc  */
    480510#line 91 "gun-parser.y"
    481511    { gc.m_gun.m_radius = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    484514  case 12:
    485515
    486 /* Line 677 of lalr1.cc  */
     516/* Line 690 of lalr1.cc  */
    487517#line 92 "gun-parser.y"
    488518    { gc.m_gun.m_shoot_speed = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    491521  case 13:
    492522
    493 /* Line 677 of lalr1.cc  */
     523/* Line 690 of lalr1.cc  */
    494524#line 93 "gun-parser.y"
    495525    { /* FIXME: 1st modifier */ }
     
    498528  case 14:
    499529
    500 /* Line 677 of lalr1.cc  */
     530/* Line 690 of lalr1.cc  */
    501531#line 94 "gun-parser.y"
    502532    { /* FIXME: 2nd modifier */ }
     
    505535  case 15:
    506536
    507 /* Line 677 of lalr1.cc  */
     537/* Line 690 of lalr1.cc  */
    508538#line 95 "gun-parser.y"
    509539    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gc.m_gun.Shoot(1);
     
    514544  case 16:
    515545
    516 /* Line 677 of lalr1.cc  */
     546/* Line 690 of lalr1.cc  */
    517547#line 98 "gun-parser.y"
    518548    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gc.m_gun.Shoot(0);
     
    523553  case 17:
    524554
    525 /* Line 677 of lalr1.cc  */
     555/* Line 690 of lalr1.cc  */
    526556#line 101 "gun-parser.y"
    527557    { gc.m_gun.Shoot(1); gc.m_gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
     
    532562  case 18:
    533563
    534 /* Line 677 of lalr1.cc  */
     564/* Line 690 of lalr1.cc  */
    535565#line 104 "gun-parser.y"
    536566    { gc.m_gun.Shoot(0); gc.m_gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
     
    541571  case 19:
    542572
    543 /* Line 677 of lalr1.cc  */
     573/* Line 690 of lalr1.cc  */
    544574#line 107 "gun-parser.y"
    545575    { gc.m_gun.m_round_timer = gc.m_gun.m_round_duration * (yysemantic_stack_[(2) - (2)].args).f0;
     
    549579  case 20:
    550580
    551 /* Line 677 of lalr1.cc  */
     581/* Line 690 of lalr1.cc  */
    552582#line 109 "gun-parser.y"
    553583    { /* FIXME: loops */ }
     
    556586  case 21:
    557587
    558 /* Line 677 of lalr1.cc  */
     588/* Line 690 of lalr1.cc  */
    559589#line 112 "gun-parser.y"
    560590    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
     
    563593  case 22:
    564594
    565 /* Line 677 of lalr1.cc  */
     595/* Line 690 of lalr1.cc  */
    566596#line 113 "gun-parser.y"
    567597    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(3) - (3)].fval); }
     
    570600  case 23:
    571601
    572 /* Line 677 of lalr1.cc  */
     602/* Line 690 of lalr1.cc  */
    573603#line 114 "gun-parser.y"
    574604    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(3) - (3)].fval); }
     
    577607  case 24:
    578608
    579 /* Line 677 of lalr1.cc  */
     609/* Line 690 of lalr1.cc  */
    580610#line 117 "gun-parser.y"
    581611    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
     
    584614  case 25:
    585615
    586 /* Line 677 of lalr1.cc  */
     616/* Line 690 of lalr1.cc  */
    587617#line 118 "gun-parser.y"
    588618    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
     
    591621
    592622
    593 /* Line 677 of lalr1.cc  */
    594 #line 595 "generated/gun-parser.cpp"
     623/* Line 690 of lalr1.cc  */
     624#line 625 "generated/gun-parser.cpp"
    595625        default:
    596626          break;
    597627      }
     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.  */
    598639    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
    599640
     
    619660  `------------------------------------*/
    620661  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
    621666    /* If not already recovering from an error, report this error.  */
    622667    if (!yyerrstatus_)
    623668      {
    624669        ++yynerrs_;
     670        if (yychar == yyempty_)
     671          yytoken = yyempty_;
    625672        error (yylloc, yysyntax_error_ (yystate, yytoken));
    626673      }
    627674
    628     yyerror_range[0] = yylloc;
     675    yyerror_range[1] = yylloc;
    629676    if (yyerrstatus_ == 3)
    630677      {
     
    661708      goto yyerrorlab;
    662709
    663     yyerror_range[0] = yylocation_stack_[yylen - 1];
     710    yyerror_range[1] = yylocation_stack_[yylen - 1];
    664711    /* Do not reclaim the symbols of the rule which action triggered
    665712       this YYERROR.  */
     
    678725      {
    679726        yyn = yypact_[yystate];
    680         if (yyn != yypact_ninf_)
     727        if (!yy_pact_value_is_default_ (yyn))
    681728        {
    682729          yyn += yyterror_;
     
    693740        YYABORT;
    694741
    695         yyerror_range[0] = yylocation_stack_[0];
     742        yyerror_range[1] = yylocation_stack_[0];
    696743        yydestruct_ ("Error: popping",
    697744                     yystos_[yystate],
     
    702749      }
    703750
    704     yyerror_range[1] = yylloc;
     751    yyerror_range[2] = yylloc;
    705752    // Using YYLLOC is tempting, but would change the location of
    706753    // the lookahead.  YYLOC is available though.
    707     YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
     754    YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
    708755    yysemantic_stack_.push (yylval);
    709756    yylocation_stack_.push (yyloc);
     
    728775  yyreturn:
    729776    if (yychar != yyempty_)
    730       yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
     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      }
    731784
    732785    /* Do not reclaim the symbols of the rule which action triggered
     
    747800  // Generate an error message.
    748801  std::string
    749   GunParser::yysyntax_error_ (int yystate, int tok)
    750   {
    751     std::string res;
    752     YYUSE (yystate);
    753 #if YYERROR_VERBOSE
    754     int yyn = yypact_[yystate];
    755     if (yypact_ninf_ < yyn && yyn <= yylast_)
    756       {
    757         /* Start YYX at -YYN if negative to avoid negative indexes in
    758            YYCHECK.  */
    759         int yyxbegin = yyn < 0 ? -yyn : 0;
    760 
    761         /* Stay within bounds of both yycheck and yytname.  */
    762         int yychecklim = yylast_ - yyn + 1;
    763         int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
    764         int count = 0;
    765         for (int x = yyxbegin; x < yyxend; ++x)
    766           if (yycheck_[x + yyn] == x && x != yyterror_)
    767             ++count;
    768 
    769         // FIXME: This method of building the message is not compatible
    770         // with internationalization.  It should work like yacc.c does it.
    771         // That is, first build a string that looks like this:
    772         // "syntax error, unexpected %s or %s or %s"
    773         // Then, invoke YY_ on this string.
    774         // Finally, use the string as a format to output
    775         // yytname_[tok], etc.
    776         // Until this gets fixed, this message appears in English only.
    777         res = "syntax error, unexpected ";
    778         res += yytnamerr_ (yytname_[tok]);
    779         if (count < 5)
    780           {
    781             count = 0;
    782             for (int x = yyxbegin; x < yyxend; ++x)
    783               if (yycheck_[x + yyn] == x && x != yyterror_)
    784                 {
    785                   res += (!count++) ? ", expecting " : " or ";
    786                   res += yytnamerr_ (yytname_[x]);
    787                 }
    788           }
    789       }
    790     else
    791 #endif
    792       res = YY_("syntax error");
    793     return res;
     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;
    794893  }
    795894
     
    808907  };
    809908
    810   /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
    811      doesn't specify something else to do.  Zero means the default is an
    812      error.  */
     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.  */
    813912  const unsigned char
    814913  GunParser::yydefact_[] =
     
    837936  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    838937     positive, shift that token.  If negative, reduce the rule which
    839      number is the opposite.  If zero, do what YYDEFACT says.  */
     938     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
    840939  const signed char GunParser::yytable_ninf_ = -1;
    841940  const unsigned char
     
    10371136} // orbital
    10381137
    1039 /* Line 1053 of lalr1.cc  */
    1040 #line 1041 "generated/gun-parser.cpp"
    1041 
    1042 
    1043 /* Line 1055 of lalr1.cc  */
     1138/* Line 1136 of lalr1.cc  */
     1139#line 1140 "generated/gun-parser.cpp"
     1140
     1141
     1142/* Line 1138 of lalr1.cc  */
    10441143#line 121 "gun-parser.y"
    10451144
  • trunk/orbital/generated/gun-parser.h

    r1442 r1495  
    1 /* A Bison parser, made by GNU Bison 2.4.2.  */
     1/* A Bison parser, made by GNU Bison 2.5.  */
    22
    33/* Skeleton interface for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2010 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2011 Free Software Foundation, Inc.
    66   
    77   This program is free software: you can redistribute it and/or modify
     
    4141#include <iostream>
    4242#include "stack.hh"
    43 
    44 
    45 namespace orbital {
    46 
    47 /* Line 34 of lalr1.cc  */
    48 #line 49 "generated/gun-parser.h"
    49   class position;
    50   class location;
    51 
    52 } // orbital
    53 
    54 /* Line 34 of lalr1.cc  */
    55 #line 56 "generated/gun-parser.h"
    56 
    5743#include "location.hh"
    5844
     
    7561#endif
    7662
    77 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    78    If N is 0, then set CURRENT to the empty location which ends
    79    the previous symbol: RHS[0] (always defined).  */
    80 
    81 #ifndef YYLLOC_DEFAULT
    82 # define YYLLOC_DEFAULT(Current, Rhs, N)                \
    83 do {                                                    \
    84   if (N)                                                \
    85     {                                                   \
    86       (Current).begin = (Rhs)[1].begin;                 \
    87       (Current).end   = (Rhs)[N].end;                   \
    88     }                                                   \
    89   else                                                  \
    90     {                                                   \
    91       (Current).begin = (Current).end = (Rhs)[0].end;   \
    92     }                                                   \
    93 } while (false)
    94 #endif
    95 
    9663
    9764namespace orbital {
    9865
    99 /* Line 34 of lalr1.cc  */
    100 #line 101 "generated/gun-parser.h"
     66/* Line 35 of lalr1.cc  */
     67#line 68 "generated/gun-parser.h"
    10168
    10269  /// A Bison parser.
     
    10976    {
    11077
    111 /* Line 34 of lalr1.cc  */
     78/* Line 35 of lalr1.cc  */
    11279#line 35 "gun-parser.y"
    11380
     
    11784
    11885
    119 /* Line 34 of lalr1.cc  */
    120 #line 121 "generated/gun-parser.h"
     86/* Line 35 of lalr1.cc  */
     87#line 88 "generated/gun-parser.h"
    12188    };
    12289#else
     
    221188    location_stack_type yylocation_stack_;
    222189
     190    /// Whether the given \c yypact_ value indicates a defaulted state.
     191    /// \param yyvalue   the value to check
     192    static bool yy_pact_value_is_default_ (int yyvalue);
     193
     194    /// Whether the given \c yytable_ value indicates a syntax error.
     195    /// \param yyvalue   the value to check
     196    static bool yy_table_value_is_error_ (int yyvalue);
     197
    223198    /// Internal symbol numbers.
    224199    typedef unsigned char token_number_type;
     
    228203    static const signed char yypact_ninf_;
    229204
    230     /// For a state, default rule to reduce.
     205    /// For a state, default reduction number.
    231206    /// Unless\a  yytable_ specifies something else to do.
    232207    /// Zero means the default is an error.
     
    259234#endif
    260235
    261 #if YYERROR_VERBOSE
    262236    /// Convert the symbol name \a n to a form suitable for a diagnostic.
    263     virtual std::string yytnamerr_ (const char *n);
    264 #endif
     237    static std::string yytnamerr_ (const char *n);
    265238
    266239#if YYDEBUG
     
    320293} // orbital
    321294
    322 /* Line 34 of lalr1.cc  */
    323 #line 324 "generated/gun-parser.h"
     295/* Line 35 of lalr1.cc  */
     296#line 297 "generated/gun-parser.h"
    324297
    325298
  • trunk/orbital/generated/location.hh

    r1442 r1495  
    1 /* A Bison parser, made by GNU Bison 2.4.2.  */
     1/* A Bison parser, made by GNU Bison 2.5.  */
    22
    33/* Locations for Bison parsers in C++
    44   
    5       Copyright (C) 2002-2007, 2009-2010 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2007, 2009-2011 Free Software Foundation, Inc.
    66   
    77   This program is free software: you can redistribute it and/or modify
  • trunk/orbital/generated/mesh-parser.cpp

    r1442 r1495  
    1 /* A Bison parser, made by GNU Bison 2.4.2.  */
     1/* A Bison parser, made by GNU Bison 2.5.  */
    22
    33/* Skeleton implementation for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2010 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2011 Free Software Foundation, Inc.
    66   
    77   This program is free software: you can redistribute it and/or modify
     
    3636/* First part of user declarations.  */
    3737
    38 /* Line 310 of lalr1.cc  */
     38/* Line 293 of lalr1.cc  */
    3939#line 1 "mesh-parser.y"
    4040
     
    6161
    6262
    63 /* Line 310 of lalr1.cc  */
     63/* Line 293 of lalr1.cc  */
    6464#line 65 "generated/mesh-parser.cpp"
    6565
     
    6969/* User implementation prologue.  */
    7070
    71 /* Line 316 of lalr1.cc  */
     71/* Line 299 of lalr1.cc  */
    7272#line 63 "mesh-parser.y"
    7373
     
    7878
    7979
    80 /* Line 316 of lalr1.cc  */
     80/* Line 299 of lalr1.cc  */
    8181#line 82 "generated/mesh-parser.cpp"
    8282
     
    9393#endif
    9494
     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
    95115/* Suppress unused-variable warnings by "using" E.  */
    96116#define YYUSE(e) ((void) (e))
     
    144164namespace orbital {
    145165
    146 /* Line 379 of lalr1.cc  */
    147 #line 148 "generated/mesh-parser.cpp"
    148 #if YYERROR_VERBOSE
     166/* Line 382 of lalr1.cc  */
     167#line 168 "generated/mesh-parser.cpp"
    149168
    150169  /* Return YYSTR after stripping away unnecessary quotes and
     
    185204  }
    186205
    187 #endif
    188206
    189207  /// Build a parser object.
     
    286304#endif
    287305
     306  inline bool
     307  MeshParser::yy_pact_value_is_default_ (int yyvalue)
     308  {
     309    return yyvalue == yypact_ninf_;
     310  }
     311
     312  inline bool
     313  MeshParser::yy_table_value_is_error_ (int yyvalue)
     314  {
     315    return yyvalue == yytable_ninf_;
     316  }
     317
    288318  int
    289319  MeshParser::parse ()
     
    307337    location_type yylloc;
    308338    /// The locations where the error started and ended.
    309     location_type yyerror_range[2];
     339    location_type yyerror_range[3];
    310340
    311341    /// $$.
     
    345375    /* Try to take a decision without lookahead.  */
    346376    yyn = yypact_[yystate];
    347     if (yyn == yypact_ninf_)
     377    if (yy_pact_value_is_default_ (yyn))
    348378      goto yydefault;
    349379
     
    378408    if (yyn <= 0)
    379409      {
    380         if (yyn == 0 || yyn == yytable_ninf_)
    381         goto yyerrlab;
     410        if (yy_table_value_is_error_ (yyn))
     411          goto yyerrlab;
    382412        yyn = -yyn;
    383413        goto yyreduce;
     
    435465          case 7:
    436466
    437 /* Line 677 of lalr1.cc  */
     467/* Line 690 of lalr1.cc  */
    438468#line 87 "mesh-parser.y"
    439469    { mc.m_mesh.OpenBrace(); }
     
    442472  case 8:
    443473
    444 /* Line 677 of lalr1.cc  */
     474/* Line 690 of lalr1.cc  */
    445475#line 91 "mesh-parser.y"
    446476    { mc.m_mesh.CloseBrace(); }
     
    449479  case 14:
    450480
    451 /* Line 677 of lalr1.cc  */
     481/* Line 690 of lalr1.cc  */
    452482#line 106 "mesh-parser.y"
    453483    { 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)); }
     
    456486  case 15:
    457487
    458 /* Line 677 of lalr1.cc  */
     488/* Line 690 of lalr1.cc  */
    459489#line 107 "mesh-parser.y"
    460     { uint16_t x = (uint16_t)(yysemantic_stack_[(2) - (2)].u32val);
    461                       vec4 v(x >> 12, (x >> 8) & 0xf, (x >> 4) & 0xf, x & 0xf);
    462                       mc.m_mesh.SetCurColor(vec4(v) * (1. / 15)); }
     490    { uint32_t x = (yysemantic_stack_[(2) - (2)].u32val);
     491                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
     492                      mc.m_mesh.SetCurColor(vec4(v) * (1. / 255)); }
    463493    break;
    464494
    465495  case 16:
    466496
    467 /* Line 677 of lalr1.cc  */
     497/* Line 690 of lalr1.cc  */
    468498#line 110 "mesh-parser.y"
    469499    { 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)); }
     
    472502  case 17:
    473503
    474 /* Line 677 of lalr1.cc  */
     504/* Line 690 of lalr1.cc  */
    475505#line 111 "mesh-parser.y"
    476     { uint16_t x = (uint16_t)(yysemantic_stack_[(2) - (2)].u32val);
    477                       vec4 v(x >> 12, (x >> 8) & 0xf, (x >> 4) & 0xf, x & 0xf);
    478                       mc.m_mesh.SetCurColor2(vec4(v) * (1. / 15)); }
     506    { uint32_t x = (yysemantic_stack_[(2) - (2)].u32val);
     507                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
     508                      mc.m_mesh.SetCurColor2(vec4(v) * (1. / 255)); }
    479509    break;
    480510
    481511  case 18:
    482512
    483 /* Line 677 of lalr1.cc  */
     513/* Line 690 of lalr1.cc  */
    484514#line 117 "mesh-parser.y"
    485515    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, 0, 0)); }
     
    488518  case 19:
    489519
    490 /* Line 677 of lalr1.cc  */
     520/* Line 690 of lalr1.cc  */
    491521#line 118 "mesh-parser.y"
    492522    { mc.m_mesh.Translate(vec3(0, (yysemantic_stack_[(2) - (2)].args).f0, 0)); }
     
    495525  case 20:
    496526
    497 /* Line 677 of lalr1.cc  */
     527/* Line 690 of lalr1.cc  */
    498528#line 119 "mesh-parser.y"
    499529    { mc.m_mesh.Translate(vec3(0, 0, (yysemantic_stack_[(2) - (2)].args).f0)); }
     
    502532  case 21:
    503533
    504 /* Line 677 of lalr1.cc  */
     534/* Line 690 of lalr1.cc  */
    505535#line 120 "mesh-parser.y"
    506536    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
     
    509539  case 22:
    510540
    511 /* Line 677 of lalr1.cc  */
     541/* Line 690 of lalr1.cc  */
    512542#line 121 "mesh-parser.y"
    513543    { mc.m_mesh.RotateX((yysemantic_stack_[(2) - (2)].args).f0); }
     
    516546  case 23:
    517547
    518 /* Line 677 of lalr1.cc  */
     548/* Line 690 of lalr1.cc  */
    519549#line 122 "mesh-parser.y"
    520550    { mc.m_mesh.RotateY((yysemantic_stack_[(2) - (2)].args).f0); }
     
    523553  case 24:
    524554
    525 /* Line 677 of lalr1.cc  */
     555/* Line 690 of lalr1.cc  */
    526556#line 123 "mesh-parser.y"
    527557    { mc.m_mesh.RotateZ((yysemantic_stack_[(2) - (2)].args).f0); }
     
    530560  case 25:
    531561
    532 /* Line 677 of lalr1.cc  */
     562/* Line 690 of lalr1.cc  */
    533563#line 124 "mesh-parser.y"
    534564    { mc.m_mesh.TaperX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
     
    537567  case 26:
    538568
    539 /* Line 677 of lalr1.cc  */
     569/* Line 690 of lalr1.cc  */
    540570#line 125 "mesh-parser.y"
    541571    { mc.m_mesh.TaperY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
     
    544574  case 27:
    545575
    546 /* Line 677 of lalr1.cc  */
     576/* Line 690 of lalr1.cc  */
    547577#line 126 "mesh-parser.y"
    548578    { mc.m_mesh.TaperZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
     
    551581  case 28:
    552582
    553 /* Line 677 of lalr1.cc  */
     583/* Line 690 of lalr1.cc  */
    554584#line 127 "mesh-parser.y"
    555585    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, 0, 0)); }
     
    558588  case 29:
    559589
    560 /* Line 677 of lalr1.cc  */
     590/* Line 690 of lalr1.cc  */
    561591#line 128 "mesh-parser.y"
    562592    { mc.m_mesh.Scale(vec3(0, (yysemantic_stack_[(2) - (2)].args).f0, 0)); }
     
    565595  case 30:
    566596
    567 /* Line 677 of lalr1.cc  */
     597/* Line 690 of lalr1.cc  */
    568598#line 129 "mesh-parser.y"
    569599    { mc.m_mesh.Scale(vec3(0, 0, (yysemantic_stack_[(2) - (2)].args).f0)); }
     
    572602  case 31:
    573603
    574 /* Line 677 of lalr1.cc  */
     604/* Line 690 of lalr1.cc  */
    575605#line 130 "mesh-parser.y"
    576606    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
     
    579609  case 32:
    580610
    581 /* Line 677 of lalr1.cc  */
     611/* Line 690 of lalr1.cc  */
    582612#line 131 "mesh-parser.y"
    583613    { mc.m_mesh.MirrorX(); }
     
    586616  case 33:
    587617
    588 /* Line 677 of lalr1.cc  */
     618/* Line 690 of lalr1.cc  */
    589619#line 132 "mesh-parser.y"
    590620    { mc.m_mesh.MirrorY(); }
     
    593623  case 34:
    594624
    595 /* Line 677 of lalr1.cc  */
     625/* Line 690 of lalr1.cc  */
    596626#line 133 "mesh-parser.y"
    597627    { mc.m_mesh.MirrorZ(); }
     
    600630  case 35:
    601631
    602 /* Line 677 of lalr1.cc  */
     632/* Line 690 of lalr1.cc  */
    603633#line 137 "mesh-parser.y"
    604634    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
     
    609639  case 36:
    610640
    611 /* Line 677 of lalr1.cc  */
     641/* Line 690 of lalr1.cc  */
    612642#line 140 "mesh-parser.y"
    613643    { mc.m_mesh.AppendBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
     
    616646  case 37:
    617647
    618 /* Line 677 of lalr1.cc  */
     648/* Line 690 of lalr1.cc  */
    619649#line 141 "mesh-parser.y"
    620650    { mc.m_mesh.AppendSmoothChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
     
    624654  case 38:
    625655
    626 /* Line 677 of lalr1.cc  */
     656/* Line 690 of lalr1.cc  */
    627657#line 143 "mesh-parser.y"
    628658    { mc.m_mesh.AppendFlatChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
     
    632662  case 39:
    633663
    634 /* Line 677 of lalr1.cc  */
     664/* Line 690 of lalr1.cc  */
    635665#line 145 "mesh-parser.y"
    636666    { mc.m_mesh.AppendSphere((yysemantic_stack_[(2) - (2)].args).f0,
     
    640670  case 40:
    641671
    642 /* Line 677 of lalr1.cc  */
     672/* Line 690 of lalr1.cc  */
    643673#line 147 "mesh-parser.y"
    644674    { mc.m_mesh.AppendStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2,
     
    648678  case 41:
    649679
    650 /* Line 677 of lalr1.cc  */
     680/* Line 690 of lalr1.cc  */
    651681#line 149 "mesh-parser.y"
    652682    { mc.m_mesh.AppendExpandedStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
     
    656686  case 42:
    657687
    658 /* Line 677 of lalr1.cc  */
     688/* Line 690 of lalr1.cc  */
    659689#line 151 "mesh-parser.y"
    660690    { mc.m_mesh.AppendDisc((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (int)(yysemantic_stack_[(2) - (2)].args).f2); }
     
    663693  case 43:
    664694
    665 /* Line 677 of lalr1.cc  */
     695/* Line 690 of lalr1.cc  */
    666696#line 152 "mesh-parser.y"
    667697    { mc.m_mesh.AppendSimpleTriangle((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
     
    670700  case 44:
    671701
    672 /* Line 677 of lalr1.cc  */
     702/* Line 690 of lalr1.cc  */
    673703#line 153 "mesh-parser.y"
    674704    { mc.m_mesh.AppendSimpleQuad((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
     
    677707  case 45:
    678708
    679 /* Line 677 of lalr1.cc  */
     709/* Line 690 of lalr1.cc  */
    680710#line 154 "mesh-parser.y"
    681711    { 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,
     
    685715  case 46:
    686716
    687 /* Line 677 of lalr1.cc  */
     717/* Line 690 of lalr1.cc  */
    688718#line 158 "mesh-parser.y"
    689719    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
     
    692722  case 47:
    693723
    694 /* Line 677 of lalr1.cc  */
     724/* Line 690 of lalr1.cc  */
    695725#line 159 "mesh-parser.y"
    696726    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(2) - (2)].fval); }
     
    699729  case 48:
    700730
    701 /* Line 677 of lalr1.cc  */
     731/* Line 690 of lalr1.cc  */
    702732#line 160 "mesh-parser.y"
    703733    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(2) - (2)].fval); }
     
    706736  case 49:
    707737
    708 /* Line 677 of lalr1.cc  */
     738/* Line 690 of lalr1.cc  */
    709739#line 161 "mesh-parser.y"
    710740    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f3 = (yysemantic_stack_[(2) - (2)].fval); }
     
    713743  case 50:
    714744
    715 /* Line 677 of lalr1.cc  */
     745/* Line 690 of lalr1.cc  */
    716746#line 162 "mesh-parser.y"
    717747    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f4 = (yysemantic_stack_[(2) - (2)].fval); }
     
    720750  case 51:
    721751
    722 /* Line 677 of lalr1.cc  */
     752/* Line 690 of lalr1.cc  */
    723753#line 163 "mesh-parser.y"
    724754    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f5 = (yysemantic_stack_[(2) - (2)].fval); }
     
    727757  case 52:
    728758
    729 /* Line 677 of lalr1.cc  */
     759/* Line 690 of lalr1.cc  */
    730760#line 164 "mesh-parser.y"
    731761    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f6 = (yysemantic_stack_[(2) - (2)].fval); }
     
    734764  case 53:
    735765
    736 /* Line 677 of lalr1.cc  */
     766/* Line 690 of lalr1.cc  */
    737767#line 165 "mesh-parser.y"
    738768    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f7 = (yysemantic_stack_[(2) - (2)].fval); }
     
    741771  case 54:
    742772
    743 /* Line 677 of lalr1.cc  */
     773/* Line 690 of lalr1.cc  */
    744774#line 168 "mesh-parser.y"
    745775    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
     
    748778  case 55:
    749779
    750 /* Line 677 of lalr1.cc  */
     780/* Line 690 of lalr1.cc  */
    751781#line 169 "mesh-parser.y"
    752782    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
     
    755785
    756786
    757 /* Line 677 of lalr1.cc  */
    758 #line 759 "generated/mesh-parser.cpp"
     787/* Line 690 of lalr1.cc  */
     788#line 789 "generated/mesh-parser.cpp"
    759789        default:
    760790          break;
    761791      }
     792    /* User semantic actions sometimes alter yychar, and that requires
     793       that yytoken be updated with the new translation.  We take the
     794       approach of translating immediately before every use of yytoken.
     795       One alternative is translating here after every semantic action,
     796       but that translation would be missed if the semantic action
     797       invokes YYABORT, YYACCEPT, or YYERROR immediately after altering
     798       yychar.  In the case of YYABORT or YYACCEPT, an incorrect
     799       destructor might then be invoked immediately.  In the case of
     800       YYERROR, subsequent parser actions might lead to an incorrect
     801       destructor call or verbose syntax error message before the
     802       lookahead is translated.  */
    762803    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
    763804
     
    783824  `------------------------------------*/
    784825  yyerrlab:
     826    /* Make sure we have latest lookahead translation.  See comments at
     827       user semantic actions for why this is necessary.  */
     828    yytoken = yytranslate_ (yychar);
     829
    785830    /* If not already recovering from an error, report this error.  */
    786831    if (!yyerrstatus_)
    787832      {
    788833        ++yynerrs_;
     834        if (yychar == yyempty_)
     835          yytoken = yyempty_;
    789836        error (yylloc, yysyntax_error_ (yystate, yytoken));
    790837      }
    791838
    792     yyerror_range[0] = yylloc;
     839    yyerror_range[1] = yylloc;
    793840    if (yyerrstatus_ == 3)
    794841      {
     
    825872      goto yyerrorlab;
    826873
    827     yyerror_range[0] = yylocation_stack_[yylen - 1];
     874    yyerror_range[1] = yylocation_stack_[yylen - 1];
    828875    /* Do not reclaim the symbols of the rule which action triggered
    829876       this YYERROR.  */
     
    842889      {
    843890        yyn = yypact_[yystate];
    844         if (yyn != yypact_ninf_)
     891        if (!yy_pact_value_is_default_ (yyn))
    845892        {
    846893          yyn += yyterror_;
     
    857904        YYABORT;
    858905
    859         yyerror_range[0] = yylocation_stack_[0];
     906        yyerror_range[1] = yylocation_stack_[0];
    860907        yydestruct_ ("Error: popping",
    861908                     yystos_[yystate],
     
    866913      }
    867914
    868     yyerror_range[1] = yylloc;
     915    yyerror_range[2] = yylloc;
    869916    // Using YYLLOC is tempting, but would change the location of
    870917    // the lookahead.  YYLOC is available though.
    871     YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
     918    YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
    872919    yysemantic_stack_.push (yylval);
    873920    yylocation_stack_.push (yyloc);
     
    892939  yyreturn:
    893940    if (yychar != yyempty_)
    894       yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
     941      {
     942        /* Make sure we have latest lookahead translation.  See comments
     943           at user semantic actions for why this is necessary.  */
     944        yytoken = yytranslate_ (yychar);
     945        yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
     946                     &yylloc);
     947      }
    895948
    896949    /* Do not reclaim the symbols of the rule which action triggered
     
    911964  // Generate an error message.
    912965  std::string
    913   MeshParser::yysyntax_error_ (int yystate, int tok)
    914   {
    915     std::string res;
    916     YYUSE (yystate);
    917 #if YYERROR_VERBOSE
    918     int yyn = yypact_[yystate];
    919     if (yypact_ninf_ < yyn && yyn <= yylast_)
    920       {
    921         /* Start YYX at -YYN if negative to avoid negative indexes in
    922            YYCHECK.  */
    923         int yyxbegin = yyn < 0 ? -yyn : 0;
    924 
    925         /* Stay within bounds of both yycheck and yytname.  */
    926         int yychecklim = yylast_ - yyn + 1;
    927         int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
    928         int count = 0;
    929         for (int x = yyxbegin; x < yyxend; ++x)
    930           if (yycheck_[x + yyn] == x && x != yyterror_)
    931             ++count;
    932 
    933         // FIXME: This method of building the message is not compatible
    934         // with internationalization.  It should work like yacc.c does it.
    935         // That is, first build a string that looks like this:
    936         // "syntax error, unexpected %s or %s or %s"
    937         // Then, invoke YY_ on this string.
    938         // Finally, use the string as a format to output
    939         // yytname_[tok], etc.
    940         // Until this gets fixed, this message appears in English only.
    941         res = "syntax error, unexpected ";
    942         res += yytnamerr_ (yytname_[tok]);
    943         if (count < 5)
    944           {
    945             count = 0;
    946             for (int x = yyxbegin; x < yyxend; ++x)
    947               if (yycheck_[x + yyn] == x && x != yyterror_)
    948                 {
    949                   res += (!count++) ? ", expecting " : " or ";
    950                   res += yytnamerr_ (yytname_[x]);
    951                 }
    952           }
    953       }
    954     else
    955 #endif
    956       res = YY_("syntax error");
    957     return res;
     966  MeshParser::yysyntax_error_ (int yystate, int yytoken)
     967  {
     968    std::string yyres;
     969    // Number of reported tokens (one for the "unexpected", one per
     970    // "expected").
     971    size_t yycount = 0;
     972    // Its maximum.
     973    enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
     974    // Arguments of yyformat.
     975    char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
     976
     977    /* There are many possibilities here to consider:
     978       - If this state is a consistent state with a default action, then
     979         the only way this function was invoked is if the default action
     980         is an error action.  In that case, don't check for expected
     981         tokens because there are none.
     982       - The only way there can be no lookahead present (in yytoken) is
     983         if this state is a consistent state with a default action.
     984         Thus, detecting the absence of a lookahead is sufficient to
     985         determine that there is no unexpected or expected token to
     986         report.  In that case, just report a simple "syntax error".
     987       - Don't assume there isn't a lookahead just because this state is
     988         a consistent state with a default action.  There might have
     989         been a previous inconsistent state, consistent state with a
     990         non-default action, or user semantic action that manipulated
     991         yychar.
     992       - Of course, the expected token list depends on states to have
     993         correct lookahead information, and it depends on the parser not
     994         to perform extra reductions after fetching a lookahead from the
     995         scanner and before detecting a syntax error.  Thus, state
     996         merging (from LALR or IELR) and default reductions corrupt the
     997         expected token list.  However, the list is correct for
     998         canonical LR with one exception: it will still contain any
     999         token that will not be accepted due to an error action in a
     1000         later state.
     1001    */
     1002    if (yytoken != yyempty_)
     1003      {
     1004        yyarg[yycount++] = yytname_[yytoken];
     1005        int yyn = yypact_[yystate];
     1006        if (!yy_pact_value_is_default_ (yyn))
     1007          {
     1008            /* Start YYX at -YYN if negative to avoid negative indexes in
     1009               YYCHECK.  In other words, skip the first -YYN actions for
     1010               this state because they are default actions.  */
     1011            int yyxbegin = yyn < 0 ? -yyn : 0;
     1012            /* Stay within bounds of both yycheck and yytname.  */
     1013            int yychecklim = yylast_ - yyn + 1;
     1014            int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
     1015            for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
     1016              if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
     1017                  && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
     1018                {
     1019                  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
     1020                    {
     1021                      yycount = 1;
     1022                      break;
     1023                    }
     1024                  else
     1025                    yyarg[yycount++] = yytname_[yyx];
     1026                }
     1027          }
     1028      }
     1029
     1030    char const* yyformat = 0;
     1031    switch (yycount)
     1032      {
     1033#define YYCASE_(N, S)                         \
     1034        case N:                               \
     1035          yyformat = S;                       \
     1036        break
     1037        YYCASE_(0, YY_("syntax error"));
     1038        YYCASE_(1, YY_("syntax error, unexpected %s"));
     1039        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
     1040        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
     1041        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
     1042        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
     1043#undef YYCASE_
     1044      }
     1045
     1046    // Argument number.
     1047    size_t yyi = 0;
     1048    for (char const* yyp = yyformat; *yyp; ++yyp)
     1049      if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
     1050        {
     1051          yyres += yytnamerr_ (yyarg[yyi++]);
     1052          ++yyp;
     1053        }
     1054      else
     1055        yyres += *yyp;
     1056    return yyres;
    9581057  }
    9591058
     
    9771076  };
    9781077
    979   /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
    980      doesn't specify something else to do.  Zero means the default is an
    981      error.  */
     1078  /* YYDEFACT[S] -- default reduction number in state S.  Performed when
     1079     YYTABLE doesn't specify something else to do.  Zero means the
     1080     default is an error.  */
    9821081  const unsigned char
    9831082  MeshParser::yydefact_[] =
     
    10131112  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    10141113     positive, shift that token.  If negative, reduce the rule which
    1015      number is the opposite.  If zero, do what YYDEFACT says.  */
     1114     number is the opposite.  If YYTABLE_NINF_, syntax error.  */
    10161115  const signed char MeshParser::yytable_ninf_ = -1;
    10171116  const unsigned char
     
    12631362} // orbital
    12641363
    1265 /* Line 1053 of lalr1.cc  */
    1266 #line 1267 "generated/mesh-parser.cpp"
    1267 
    1268 
    1269 /* Line 1055 of lalr1.cc  */
     1364/* Line 1136 of lalr1.cc  */
     1365#line 1366 "generated/mesh-parser.cpp"
     1366
     1367
     1368/* Line 1138 of lalr1.cc  */
    12701369#line 172 "mesh-parser.y"
    12711370
  • trunk/orbital/generated/mesh-parser.h

    r1442 r1495  
    1 /* A Bison parser, made by GNU Bison 2.4.2.  */
     1/* A Bison parser, made by GNU Bison 2.5.  */
    22
    33/* Skeleton interface for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2010 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2011 Free Software Foundation, Inc.
    66   
    77   This program is free software: you can redistribute it and/or modify
     
    4141#include <iostream>
    4242#include "stack.hh"
    43 
    44 
    45 namespace orbital {
    46 
    47 /* Line 34 of lalr1.cc  */
    48 #line 49 "generated/mesh-parser.h"
    49   class position;
    50   class location;
    51 
    52 } // orbital
    53 
    54 /* Line 34 of lalr1.cc  */
    55 #line 56 "generated/mesh-parser.h"
    56 
    5743#include "location.hh"
    5844
     
    7561#endif
    7662
    77 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    78    If N is 0, then set CURRENT to the empty location which ends
    79    the previous symbol: RHS[0] (always defined).  */
    80 
    81 #ifndef YYLLOC_DEFAULT
    82 # define YYLLOC_DEFAULT(Current, Rhs, N)                \
    83 do {                                                    \
    84   if (N)                                                \
    85     {                                                   \
    86       (Current).begin = (Rhs)[1].begin;                 \
    87       (Current).end   = (Rhs)[N].end;                   \
    88     }                                                   \
    89   else                                                  \
    90     {                                                   \
    91       (Current).begin = (Current).end = (Rhs)[0].end;   \
    92     }                                                   \
    93 } while (false)
    94 #endif
    95 
    9663
    9764namespace orbital {
    9865
    99 /* Line 34 of lalr1.cc  */
    100 #line 101 "generated/mesh-parser.h"
     66/* Line 35 of lalr1.cc  */
     67#line 68 "generated/mesh-parser.h"
    10168
    10269  /// A Bison parser.
     
    10976    {
    11077
    111 /* Line 34 of lalr1.cc  */
     78/* Line 35 of lalr1.cc  */
    11279#line 35 "mesh-parser.y"
    11380
     
    11986
    12087
    121 /* Line 34 of lalr1.cc  */
    122 #line 123 "generated/mesh-parser.h"
     88/* Line 35 of lalr1.cc  */
     89#line 90 "generated/mesh-parser.h"
    12390    };
    12491#else
     
    239206    location_stack_type yylocation_stack_;
    240207
     208    /// Whether the given \c yypact_ value indicates a defaulted state.
     209    /// \param yyvalue   the value to check
     210    static bool yy_pact_value_is_default_ (int yyvalue);
     211
     212    /// Whether the given \c yytable_ value indicates a syntax error.
     213    /// \param yyvalue   the value to check
     214    static bool yy_table_value_is_error_ (int yyvalue);
     215
    241216    /// Internal symbol numbers.
    242217    typedef unsigned char token_number_type;
     
    246221    static const signed char yypact_ninf_;
    247222
    248     /// For a state, default rule to reduce.
     223    /// For a state, default reduction number.
    249224    /// Unless\a  yytable_ specifies something else to do.
    250225    /// Zero means the default is an error.
     
    277252#endif
    278253
    279 #if YYERROR_VERBOSE
    280254    /// Convert the symbol name \a n to a form suitable for a diagnostic.
    281     virtual std::string yytnamerr_ (const char *n);
    282 #endif
     255    static std::string yytnamerr_ (const char *n);
    283256
    284257#if YYDEBUG
     
    338311} // orbital
    339312
    340 /* Line 34 of lalr1.cc  */
    341 #line 342 "generated/mesh-parser.h"
     313/* Line 35 of lalr1.cc  */
     314#line 315 "generated/mesh-parser.h"
    342315
    343316
  • trunk/orbital/generated/mesh-scanner.cpp

    r1442 r1495  
    331331        (yy_c_buf_p) = yy_cp;
    332332
    333 #define YY_NUM_RULES 40
    334 #define YY_END_OF_BUFFER 41
     333#define YY_NUM_RULES 42
     334#define YY_END_OF_BUFFER 43
    335335/* This struct is not used in this scanner,
    336336   but its presence is necessary. */
     
    340340        flex_int32_t yy_nxt;
    341341        };
    342 static yyconst flex_int16_t yy_accept[64] =
     342static yyconst flex_int16_t yy_accept[68] =
    343343    {   0,
    344         0,    0,   41,   39,   38,   37,   39,   39,   34,   39,
    345        33,   35,   36,   39,   39,   39,   16,    6,    0,    0,
    346        33,   33,    0,   21,   20,   27,    0,    0,   29,   25,
     344        0,    0,   43,   41,   40,   39,   41,   41,   36,   41,
     345       35,   37,   38,   41,   41,   41,   16,    6,    0,    0,
     346       35,   35,    0,   21,   20,   27,    0,    0,   29,   25,
    347347       28,   17,   18,   19,    7,    8,    9,    1,   13,   14,
    348        15,    0,    3,    4,    5,    0,    0,   33,   30,   26,
     348       15,    0,    3,    4,    5,    0,    0,   35,   30,   26,
    349349        0,    0,    0,    2,   10,   11,   12,   31,   23,   22,
    350        24,   32,    0
     350       24,   32,    0,   33,    0,   34,    0
    351351    } ;
    352352
     
    390390    } ;
    391391
    392 static yyconst flex_int16_t yy_base[68] =
     392static yyconst flex_int16_t yy_base[76] =
    393393    {   0,
    394         0,    0,   89,   90,   90,   90,    0,   22,   24,   80,
    395        26,   90,   90,   30,   10,   13,   34,   37,    0,   79,
    396        50,   59,   45,   90,   68,   90,   61,   70,   90,   55,
    397        90,   90,   90,   90,   90,   90,   90,   70,   90,   90,
    398        90,   44,   90,   90,   90,    0,   74,   73,   90,   90,
    399        67,   66,   59,   90,   90,   90,   90,    0,   90,   90,
    400        90,   90,   90,   75,   72,   71,   54
     394        0,    0,   93,   94,   94,   94,    0,   22,   24,   84,
     395       26,   94,   94,   30,   10,   13,   34,   37,    0,   83,
     396       50,   59,   45,   94,   72,   94,   65,   74,   94,   55,
     397       94,   94,   94,   94,   94,   94,   94,   74,   94,   94,
     398       94,   44,   94,   94,   94,    0,   78,   77,   94,   94,
     399       71,   70,   63,   94,   94,   94,   94,    0,   94,   94,
     400       94,    0,    0,    0,    0,   94,   94,   79,   78,   77,
     401       76,   75,   72,   71,   54
    401402    } ;
    402403
    403 static yyconst flex_int16_t yy_def[68] =
     404static yyconst flex_int16_t yy_def[76] =
    404405    {   0,
    405        63,    1,   63,   63,   63,   63,   64,   63,   63,   63,
    406        63,   63,   63,   63,   63,   63,   63,   63,   65,   63,
    407        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
    408        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
    409        63,   63,   63,   63,   63,   66,   63,   63,   63,   63,
    410        63,   63,   63,   63,   63,   63,   63,   67,   63,   63,
    411        63,   63,    0,   63,   63,   63,   63
     406       67,    1,   67,   67,   67,   67,   68,   67,   67,   67,
     407       67,   67,   67,   67,   67,   67,   67,   67,   69,   67,
     408       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
     409       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
     410       67,   67,   67,   67,   67,   70,   67,   67,   67,   67,
     411       67,   67,   67,   67,   67,   67,   67,   71,   67,   67,
     412       67,   72,   73,   74,   75,   67,    0,   67,   67,   67,
     413       67,   67,   67,   67,   67
    412414    } ;
    413415
    414 static yyconst flex_int16_t yy_nxt[119] =
     416static yyconst flex_int16_t yy_nxt[123] =
    415417    {   0,
    416418        4,    5,    6,    7,    8,    9,   10,   11,    4,   12,
     
    419421       20,   21,   20,   21,   23,   32,   33,   34,   35,   36,
    420422       37,   23,   24,   25,   26,   27,   28,   38,   42,   47,
    421        47,   29,   48,   30,   31,   62,   20,   21,   23,   39,
     423       47,   29,   48,   30,   31,   66,   20,   21,   23,   39,
    422424       40,   41,   43,   44,   45,   23,   22,   23,   52,   55,
    423        56,   57,   58,   46,   23,   53,   19,   61,   60,   59,
    424        48,   48,   54,   51,   50,   49,   22,   22,   63,    3,
    425        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
    426 
    427        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
    428        63,   63,   63,   63,   63,   63,   63,   63
     425       56,   57,   65,   64,   23,   53,   63,   62,   58,   46,
     426       19,   61,   60,   59,   48,   48,   54,   51,   50,   49,
     427       22,   22,   67,    3,   67,   67,   67,   67,   67,   67,
     428
     429       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
     430       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
     431       67,   67
    429432    } ;
    430433
    431 static yyconst flex_int16_t yy_chk[119] =
     434static yyconst flex_int16_t yy_chk[123] =
    432435    {   0,
    433436        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     
    436439        9,    9,   11,   11,   11,   15,   15,   15,   16,   16,
    437440       16,   11,   14,   14,   14,   14,   14,   17,   18,   23,
    438        23,   14,   23,   14,   14,   67,   21,   21,   21,   17,
     441       23,   14,   23,   14,   14,   75,   21,   21,   21,   17,
    439442       17,   17,   18,   18,   18,   21,   22,   22,   30,   42,
    440        42,   42,   66,   65,   22,   30,   64,   53,   52,   51,
    441        48,   47,   38,   28,   27,   25,   20,   10,    3,   63,
    442        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
    443 
    444        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
    445        63,   63,   63,   63,   63,   63,   63,   63
     443       42,   42,   74,   73,   22,   30,   72,   71,   70,   69,
     444       68,   53,   52,   51,   48,   47,   38,   28,   27,   25,
     445       20,   10,    3,   67,   67,   67,   67,   67,   67,   67,
     446
     447       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
     448       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
     449       67,   67
    446450    } ;
    447451
     
    486490#define YY_NO_UNISTD_H
    487491#define YY_USER_ACTION yylloc->columns(yyleng);
    488 #line 489 "generated/mesh-scanner.cpp"
     492#line 493 "generated/mesh-scanner.cpp"
    489493
    490494#define INITIAL 0
     
    599603
    600604
    601 #line 602 "generated/mesh-scanner.cpp"
     605#line 606 "generated/mesh-scanner.cpp"
    602606
    603607        if ( !(yy_init) )
     
    652656                                {
    653657                                yy_current_state = (int) yy_def[yy_current_state];
    654                                 if ( yy_current_state >= 64 )
     658                                if ( yy_current_state >= 68 )
    655659                                        yy_c = yy_meta[(unsigned int) yy_c];
    656660                                }
     
    658662                        ++yy_cp;
    659663                        }
    660                 while ( yy_current_state != 63 );
     664                while ( yy_current_state != 67 );
    661665                yy_cp = (yy_last_accepting_cpos);
    662666                yy_current_state = (yy_last_accepting_state);
     
    832836#line 78 "mesh-scanner.l"
    833837{
    834         yylval->u32val = 0xf + 0x10 * strtol(yytext + 1, NULL, 16);
     838        uint32_t tmp = strtol(yytext + 1, NULL, 16);
     839        yylval->u32val = 0x11000000u * (tmp >> 8)
     840                       | 0x00110000u * ((tmp >> 4) & 0xf)
     841                       | 0x00001100u * (tmp & 0xf)
     842                       | 0x000000ffu;
    835843        return token::COLOR; }
    836844        YY_BREAK
    837845case 32:
    838846YY_RULE_SETUP
    839 #line 81 "mesh-scanner.l"
    840 {
    841         yylval->u32val = strtol(yytext + 1, NULL, 16);
     847#line 85 "mesh-scanner.l"
     848{
     849        uint32_t tmp = strtol(yytext + 1, NULL, 16);
     850        yylval->u32val = 0x11000000u * (tmp >> 12)
     851                       | 0x00110000u * ((tmp >> 8) & 0xf)
     852                       | 0x00001100u * ((tmp >> 4) & 0xf)
     853                       | 0x00000011u * (tmp & 0xf);
    842854        return token::COLOR; }
    843855        YY_BREAK
    844856case 33:
    845857YY_RULE_SETUP
    846 #line 84 "mesh-scanner.l"
     858#line 92 "mesh-scanner.l"
     859{
     860        yylval->u32val = 0xffu
     861                       | 0x100u * (uint32_t)strtol(yytext + 1, NULL, 16);
     862        return token::COLOR; }
     863        YY_BREAK
     864case 34:
     865YY_RULE_SETUP
     866#line 96 "mesh-scanner.l"
     867{
     868        yylval->u32val = (uint32_t)strtol(yytext + 1, NULL, 16);
     869        return token::COLOR; }
     870        YY_BREAK
     871case 35:
     872YY_RULE_SETUP
     873#line 99 "mesh-scanner.l"
    847874{
    848875        yylval->fval = atof(yytext); return token::NUMBER; }
    849876        YY_BREAK
    850 case 34:
    851 YY_RULE_SETUP
    852 #line 86 "mesh-scanner.l"
     877case 36:
     878YY_RULE_SETUP
     879#line 101 "mesh-scanner.l"
    853880{ return token_type('-'); }
    854881        YY_BREAK
    855 case 35:
    856 YY_RULE_SETUP
    857 #line 87 "mesh-scanner.l"
     882case 37:
     883YY_RULE_SETUP
     884#line 102 "mesh-scanner.l"
    858885{ return token_type('['); }
    859886        YY_BREAK
    860 case 36:
    861 YY_RULE_SETUP
    862 #line 88 "mesh-scanner.l"
     887case 38:
     888YY_RULE_SETUP
     889#line 103 "mesh-scanner.l"
    863890{ return token_type(']'); }
    864891        YY_BREAK
    865 case 37:
    866 YY_RULE_SETUP
    867 #line 89 "mesh-scanner.l"
     892case 39:
     893YY_RULE_SETUP
     894#line 104 "mesh-scanner.l"
    868895{ /* ignore this */ }
    869896        YY_BREAK
    870 case 38:
    871 /* rule 38 can match eol */
    872 YY_RULE_SETUP
    873 #line 90 "mesh-scanner.l"
     897case 40:
     898/* rule 40 can match eol */
     899YY_RULE_SETUP
     900#line 105 "mesh-scanner.l"
    874901{ /* ignore this */ }
    875902        YY_BREAK
    876 case 39:
    877 YY_RULE_SETUP
    878 #line 91 "mesh-scanner.l"
     903case 41:
     904YY_RULE_SETUP
     905#line 106 "mesh-scanner.l"
    879906{ return token::T_ERROR; }
    880907        YY_BREAK
    881 case 40:
    882 YY_RULE_SETUP
    883 #line 93 "mesh-scanner.l"
     908case 42:
     909YY_RULE_SETUP
     910#line 108 "mesh-scanner.l"
    884911ECHO;
    885912        YY_BREAK
    886 #line 887 "generated/mesh-scanner.cpp"
     913#line 914 "generated/mesh-scanner.cpp"
    887914case YY_STATE_EOF(INITIAL):
    888915        yyterminate();
     
    12661293                        {
    12671294                        yy_current_state = (int) yy_def[yy_current_state];
    1268                         if ( yy_current_state >= 64 )
     1295                        if ( yy_current_state >= 68 )
    12691296                                yy_c = yy_meta[(unsigned int) yy_c];
    12701297                        }
     
    12941321                {
    12951322                yy_current_state = (int) yy_def[yy_current_state];
    1296                 if ( yy_current_state >= 64 )
     1323                if ( yy_current_state >= 68 )
    12971324                        yy_c = yy_meta[(unsigned int) yy_c];
    12981325                }
    12991326        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    1300         yy_is_jam = (yy_current_state == 63);
     1327        yy_is_jam = (yy_current_state == 67);
    13011328
    13021329        return yy_is_jam ? 0 : yy_current_state;
     
    17851812#define YYTABLES_NAME "yytables"
    17861813
    1787 #line 93 "mesh-scanner.l"
     1814#line 108 "mesh-scanner.l"
    17881815
    17891816
  • trunk/orbital/generated/position.hh

    r1442 r1495  
    1 /* A Bison parser, made by GNU Bison 2.4.2.  */
     1/* A Bison parser, made by GNU Bison 2.5.  */
    22
    33/* Positions for Bison parsers in C++
    44   
    5       Copyright (C) 2002-2007, 2009-2010 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2007, 2009-2011 Free Software Foundation, Inc.
    66   
    77   This program is free software: you can redistribute it and/or modify
  • trunk/orbital/generated/stack.hh

    r1442 r1495  
    1 /* A Bison parser, made by GNU Bison 2.4.2.  */
     1/* A Bison parser, made by GNU Bison 2.5.  */
    22
    33/* Stack handling for Bison parsers in C++
    44   
    5       Copyright (C) 2002-2010 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2011 Free Software Foundation, Inc.
    66   
    77   This program is free software: you can redistribute it and/or modify
     
    3939namespace orbital {
    4040
    41 /* Line 1066 of lalr1.cc  */
     41/* Line 1149 of lalr1.cc  */
    4242#line 43 "generated/stack.hh"
    4343  template <class T, class S = std::deque<T> >
     
    129129} // orbital
    130130
    131 /* Line 1152 of lalr1.cc  */
     131/* Line 1235 of lalr1.cc  */
    132132#line 133 "generated/stack.hh"
    133133
  • trunk/orbital/mesh-parser.y

    r1442 r1495  
    105105color_command:
    106106    T_COLOR args4   { mc.m_mesh.SetCurColor(vec4($2.f0, $2.f1, $2.f2, $2.f3)); }
    107   | T_COLOR COLOR   { uint16_t x = (uint16_t)$2;
    108                       vec4 v(x >> 12, (x >> 8) & 0xf, (x >> 4) & 0xf, x & 0xf);
    109                       mc.m_mesh.SetCurColor(vec4(v) * (1. / 15)); }
     107  | T_COLOR COLOR   { uint32_t x = $2;
     108                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
     109                      mc.m_mesh.SetCurColor(vec4(v) * (1. / 255)); }
    110110  | T_BGCOLOR args4 { mc.m_mesh.SetCurColor2(vec4($2.f0, $2.f1, $2.f2, $2.f3)); }
    111   | T_BGCOLOR COLOR { uint16_t x = (uint16_t)$2;
    112                       vec4 v(x >> 12, (x >> 8) & 0xf, (x >> 4) & 0xf, x & 0xf);
    113                       mc.m_mesh.SetCurColor2(vec4(v) * (1. / 15)); }
     111  | T_BGCOLOR COLOR { uint32_t x = $2;
     112                      vec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
     113                      mc.m_mesh.SetCurColor2(vec4(v) * (1. / 255)); }
    114114    ;
    115115
  • trunk/orbital/mesh-scanner.l

    r1442 r1495  
    7777
    7878#[0-9a-f]{3} {
    79         yylval->u32val = 0xf + 0x10 * strtol(yytext + 1, NULL, 16);
     79        uint32_t tmp = strtol(yytext + 1, NULL, 16);
     80        yylval->u32val = 0x11000000u * (tmp >> 8)
     81                       | 0x00110000u * ((tmp >> 4) & 0xf)
     82                       | 0x00001100u * (tmp & 0xf)
     83                       | 0x000000ffu;
    8084        return token::COLOR; }
    8185#[0-9a-f]{4} {
    82         yylval->u32val = strtol(yytext + 1, NULL, 16);
     86        uint32_t tmp = strtol(yytext + 1, NULL, 16);
     87        yylval->u32val = 0x11000000u * (tmp >> 12)
     88                       | 0x00110000u * ((tmp >> 8) & 0xf)
     89                       | 0x00001100u * ((tmp >> 4) & 0xf)
     90                       | 0x00000011u * (tmp & 0xf);
     91        return token::COLOR; }
     92#[0-9a-f]{6} {
     93        yylval->u32val = 0xffu
     94                       | 0x100u * (uint32_t)strtol(yytext + 1, NULL, 16);
     95        return token::COLOR; }
     96#[0-9a-f]{8} {
     97        yylval->u32val = (uint32_t)strtol(yytext + 1, NULL, 16);
    8398        return token::COLOR; }
    8499[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)? {
Note: See TracChangeset for help on using the changeset viewer.