Changeset 1434


Ignore:
Timestamp:
Jun 1, 2012, 7:42:36 PM (7 years ago)
Author:
sam
Message:

orbital: enhance the language with [] contexts.

Location:
trunk/orbital
Files:
19 edited

Legend:

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

    r1425 r1434  
    1 /* A Bison parser, made by GNU Bison 2.5.  */
     1/* A Bison parser, made by GNU Bison 2.4.2.  */
    22
    33/* Skeleton implementation for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2011 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2010 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 293 of lalr1.cc  */
     38/* Line 310 of lalr1.cc  */
    3939#line 1 "gun-parser.y"
    4040
     
    6161
    6262
    63 /* Line 293 of lalr1.cc  */
     63/* Line 310 of lalr1.cc  */
    6464#line 65 "generated/gun-parser.cpp"
    6565
     
    6969/* User implementation prologue.  */
    7070
    71 /* Line 299 of lalr1.cc  */
     71/* Line 316 of lalr1.cc  */
    7272#line 66 "gun-parser.y"
    7373
     
    7878
    7979
    80 /* Line 299 of lalr1.cc  */
     80/* Line 316 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 
    11595/* Suppress unused-variable warnings by "using" E.  */
    11696#define YYUSE(e) ((void) (e))
     
    164144namespace orbital {
    165145
    166 /* Line 382 of lalr1.cc  */
    167 #line 168 "generated/gun-parser.cpp"
     146/* Line 379 of lalr1.cc  */
     147#line 148 "generated/gun-parser.cpp"
     148#if YYERROR_VERBOSE
    168149
    169150  /* Return YYSTR after stripping away unnecessary quotes and
     
    204185  }
    205186
     187#endif
    206188
    207189  /// Build a parser object.
     
    304286#endif
    305287
    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 
    318288  int
    319289  GunParser::parse ()
     
    337307    location_type yylloc;
    338308    /// The locations where the error started and ended.
    339     location_type yyerror_range[3];
     309    location_type yyerror_range[2];
    340310
    341311    /// $$.
     
    375345    /* Try to take a decision without lookahead.  */
    376346    yyn = yypact_[yystate];
    377     if (yy_pact_value_is_default_ (yyn))
     347    if (yyn == yypact_ninf_)
    378348      goto yydefault;
    379349
     
    408378    if (yyn <= 0)
    409379      {
    410         if (yy_table_value_is_error_ (yyn))
    411           goto yyerrlab;
     380        if (yyn == 0 || yyn == yytable_ninf_)
     381        goto yyerrlab;
    412382        yyn = -yyn;
    413383        goto yyreduce;
     
    465435          case 5:
    466436
    467 /* Line 690 of lalr1.cc  */
     437/* Line 677 of lalr1.cc  */
    468438#line 85 "gun-parser.y"
    469439    { gc.m_gun.m_angle = gc.m_gun.AimActor(); }
     
    472442  case 6:
    473443
    474 /* Line 690 of lalr1.cc  */
     444/* Line 677 of lalr1.cc  */
    475445#line 86 "gun-parser.y"
    476446    { gc.m_gun.PreAimActor((yysemantic_stack_[(2) - (2)].args).f0); }
     
    479449  case 7:
    480450
    481 /* Line 690 of lalr1.cc  */
     451/* Line 677 of lalr1.cc  */
    482452#line 87 "gun-parser.y"
    483453    { gc.m_gun.m_pre_aim = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    486456  case 8:
    487457
    488 /* Line 690 of lalr1.cc  */
     458/* Line 677 of lalr1.cc  */
    489459#line 88 "gun-parser.y"
    490460    { gc.m_gun.m_angle = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    493463  case 9:
    494464
    495 /* Line 690 of lalr1.cc  */
     465/* Line 677 of lalr1.cc  */
    496466#line 89 "gun-parser.y"
    497467    { gc.m_gun.m_round_duration = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    500470  case 10:
    501471
    502 /* Line 690 of lalr1.cc  */
     472/* Line 677 of lalr1.cc  */
    503473#line 90 "gun-parser.y"
    504474    { gc.m_gun.m_angle_offset = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    507477  case 11:
    508478
    509 /* Line 690 of lalr1.cc  */
     479/* Line 677 of lalr1.cc  */
    510480#line 91 "gun-parser.y"
    511481    { gc.m_gun.m_radius = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    514484  case 12:
    515485
    516 /* Line 690 of lalr1.cc  */
     486/* Line 677 of lalr1.cc  */
    517487#line 92 "gun-parser.y"
    518488    { gc.m_gun.m_shoot_speed = (yysemantic_stack_[(2) - (2)].args).f0; }
     
    521491  case 13:
    522492
    523 /* Line 690 of lalr1.cc  */
     493/* Line 677 of lalr1.cc  */
    524494#line 93 "gun-parser.y"
    525495    { /* FIXME: 1st modifier */ }
     
    528498  case 14:
    529499
    530 /* Line 690 of lalr1.cc  */
     500/* Line 677 of lalr1.cc  */
    531501#line 94 "gun-parser.y"
    532502    { /* FIXME: 2nd modifier */ }
     
    535505  case 15:
    536506
    537 /* Line 690 of lalr1.cc  */
     507/* Line 677 of lalr1.cc  */
    538508#line 95 "gun-parser.y"
    539509    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gc.m_gun.Shoot(1);
     
    544514  case 16:
    545515
    546 /* Line 690 of lalr1.cc  */
     516/* Line 677 of lalr1.cc  */
    547517#line 98 "gun-parser.y"
    548518    { for (int i = 0; i < (int)(yysemantic_stack_[(2) - (2)].args).f0; i++) gc.m_gun.Shoot(0);
     
    553523  case 17:
    554524
    555 /* Line 690 of lalr1.cc  */
     525/* Line 677 of lalr1.cc  */
    556526#line 101 "gun-parser.y"
    557527    { gc.m_gun.Shoot(1); gc.m_gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
     
    562532  case 18:
    563533
    564 /* Line 690 of lalr1.cc  */
     534/* Line 677 of lalr1.cc  */
    565535#line 104 "gun-parser.y"
    566536    { gc.m_gun.Shoot(0); gc.m_gun.m_nbshoots = (int)(yysemantic_stack_[(2) - (2)].args).f0 - 1;
     
    571541  case 19:
    572542
    573 /* Line 690 of lalr1.cc  */
     543/* Line 677 of lalr1.cc  */
    574544#line 107 "gun-parser.y"
    575545    { gc.m_gun.m_round_timer = gc.m_gun.m_round_duration * (yysemantic_stack_[(2) - (2)].args).f0;
     
    579549  case 20:
    580550
    581 /* Line 690 of lalr1.cc  */
     551/* Line 677 of lalr1.cc  */
    582552#line 109 "gun-parser.y"
    583553    { /* FIXME: loops */ }
     
    586556  case 21:
    587557
    588 /* Line 690 of lalr1.cc  */
     558/* Line 677 of lalr1.cc  */
    589559#line 112 "gun-parser.y"
    590560    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
     
    593563  case 22:
    594564
    595 /* Line 690 of lalr1.cc  */
     565/* Line 677 of lalr1.cc  */
    596566#line 113 "gun-parser.y"
    597567    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(3) - (3)].fval); }
     
    600570  case 23:
    601571
    602 /* Line 690 of lalr1.cc  */
     572/* Line 677 of lalr1.cc  */
    603573#line 114 "gun-parser.y"
    604574    { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(3) - (3)].fval); }
     
    607577  case 24:
    608578
    609 /* Line 690 of lalr1.cc  */
     579/* Line 677 of lalr1.cc  */
    610580#line 117 "gun-parser.y"
    611581    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
     
    614584  case 25:
    615585
    616 /* Line 690 of lalr1.cc  */
     586/* Line 677 of lalr1.cc  */
    617587#line 118 "gun-parser.y"
    618588    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
     
    621591
    622592
    623 /* Line 690 of lalr1.cc  */
    624 #line 625 "generated/gun-parser.cpp"
     593/* Line 677 of lalr1.cc  */
     594#line 595 "generated/gun-parser.cpp"
    625595        default:
    626596          break;
    627597      }
    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.  */
    639598    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
    640599
     
    660619  `------------------------------------*/
    661620  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 
    666621    /* If not already recovering from an error, report this error.  */
    667622    if (!yyerrstatus_)
    668623      {
    669624        ++yynerrs_;
    670         if (yychar == yyempty_)
    671           yytoken = yyempty_;
    672625        error (yylloc, yysyntax_error_ (yystate, yytoken));
    673626      }
    674627
    675     yyerror_range[1] = yylloc;
     628    yyerror_range[0] = yylloc;
    676629    if (yyerrstatus_ == 3)
    677630      {
     
    708661      goto yyerrorlab;
    709662
    710     yyerror_range[1] = yylocation_stack_[yylen - 1];
     663    yyerror_range[0] = yylocation_stack_[yylen - 1];
    711664    /* Do not reclaim the symbols of the rule which action triggered
    712665       this YYERROR.  */
     
    725678      {
    726679        yyn = yypact_[yystate];
    727         if (!yy_pact_value_is_default_ (yyn))
     680        if (yyn != yypact_ninf_)
    728681        {
    729682          yyn += yyterror_;
     
    740693        YYABORT;
    741694
    742         yyerror_range[1] = yylocation_stack_[0];
     695        yyerror_range[0] = yylocation_stack_[0];
    743696        yydestruct_ ("Error: popping",
    744697                     yystos_[yystate],
     
    749702      }
    750703
    751     yyerror_range[2] = yylloc;
     704    yyerror_range[1] = yylloc;
    752705    // Using YYLLOC is tempting, but would change the location of
    753706    // the lookahead.  YYLOC is available though.
    754     YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
     707    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
    755708    yysemantic_stack_.push (yylval);
    756709    yylocation_stack_.push (yyloc);
     
    775728  yyreturn:
    776729    if (yychar != yyempty_)
    777       {
    778         /* Make sure we have latest lookahead translation.  See comments
    779            at user semantic actions for why this is necessary.  */
    780         yytoken = yytranslate_ (yychar);
    781         yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
    782                      &yylloc);
    783       }
     730      yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
    784731
    785732    /* Do not reclaim the symbols of the rule which action triggered
     
    800747  // Generate an error message.
    801748  std::string
    802   GunParser::yysyntax_error_ (int yystate, int yytoken)
    803   {
    804     std::string yyres;
    805     // Number of reported tokens (one for the "unexpected", one per
    806     // "expected").
    807     size_t yycount = 0;
    808     // Its maximum.
    809     enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
    810     // Arguments of yyformat.
    811     char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    812 
    813     /* There are many possibilities here to consider:
    814        - If this state is a consistent state with a default action, then
    815          the only way this function was invoked is if the default action
    816          is an error action.  In that case, don't check for expected
    817          tokens because there are none.
    818        - The only way there can be no lookahead present (in yytoken) is
    819          if this state is a consistent state with a default action.
    820          Thus, detecting the absence of a lookahead is sufficient to
    821          determine that there is no unexpected or expected token to
    822          report.  In that case, just report a simple "syntax error".
    823        - Don't assume there isn't a lookahead just because this state is
    824          a consistent state with a default action.  There might have
    825          been a previous inconsistent state, consistent state with a
    826          non-default action, or user semantic action that manipulated
    827          yychar.
    828        - Of course, the expected token list depends on states to have
    829          correct lookahead information, and it depends on the parser not
    830          to perform extra reductions after fetching a lookahead from the
    831          scanner and before detecting a syntax error.  Thus, state
    832          merging (from LALR or IELR) and default reductions corrupt the
    833          expected token list.  However, the list is correct for
    834          canonical LR with one exception: it will still contain any
    835          token that will not be accepted due to an error action in a
    836          later state.
    837     */
    838     if (yytoken != yyempty_)
    839       {
    840         yyarg[yycount++] = yytname_[yytoken];
    841         int yyn = yypact_[yystate];
    842         if (!yy_pact_value_is_default_ (yyn))
    843           {
    844             /* Start YYX at -YYN if negative to avoid negative indexes in
    845                YYCHECK.  In other words, skip the first -YYN actions for
    846                this state because they are default actions.  */
    847             int yyxbegin = yyn < 0 ? -yyn : 0;
    848             /* Stay within bounds of both yycheck and yytname.  */
    849             int yychecklim = yylast_ - yyn + 1;
    850             int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
    851             for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
    852               if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
    853                   && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
    854                 {
    855                   if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
    856                     {
    857                       yycount = 1;
    858                       break;
    859                     }
    860                   else
    861                     yyarg[yycount++] = yytname_[yyx];
    862                 }
    863           }
    864       }
    865 
    866     char const* yyformat = 0;
    867     switch (yycount)
    868       {
    869 #define YYCASE_(N, S)                         \
    870         case N:                               \
    871           yyformat = S;                       \
    872         break
    873         YYCASE_(0, YY_("syntax error"));
    874         YYCASE_(1, YY_("syntax error, unexpected %s"));
    875         YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
    876         YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
    877         YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
    878         YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
    879 #undef YYCASE_
    880       }
    881 
    882     // Argument number.
    883     size_t yyi = 0;
    884     for (char const* yyp = yyformat; *yyp; ++yyp)
    885       if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
    886         {
    887           yyres += yytnamerr_ (yyarg[yyi++]);
    888           ++yyp;
    889         }
    890       else
    891         yyres += *yyp;
    892     return yyres;
     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;
    893794  }
    894795
     
    907808  };
    908809
    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.  */
     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.  */
    912813  const unsigned char
    913814  GunParser::yydefact_[] =
     
    936837  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    937838     positive, shift that token.  If negative, reduce the rule which
    938      number is the opposite.  If YYTABLE_NINF_, syntax error.  */
     839     number is the opposite.  If zero, do what YYDEFACT says.  */
    939840  const signed char GunParser::yytable_ninf_ = -1;
    940841  const unsigned char
     
    11361037} // orbital
    11371038
    1138 /* Line 1136 of lalr1.cc  */
    1139 #line 1140 "generated/gun-parser.cpp"
    1140 
    1141 
    1142 /* Line 1138 of lalr1.cc  */
     1039/* Line 1053 of lalr1.cc  */
     1040#line 1041 "generated/gun-parser.cpp"
     1041
     1042
     1043/* Line 1055 of lalr1.cc  */
    11431044#line 121 "gun-parser.y"
    11441045
  • trunk/orbital/generated/gun-parser.h

    r1425 r1434  
    1 /* A Bison parser, made by GNU Bison 2.5.  */
     1/* A Bison parser, made by GNU Bison 2.4.2.  */
    22
    33/* Skeleton interface for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2011 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2010 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
     45namespace 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
    4357#include "location.hh"
    4458
     
    6175#endif
    6276
     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)                \
     83do {                                                    \
     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
    6396
    6497namespace orbital {
    6598
    66 /* Line 35 of lalr1.cc  */
    67 #line 68 "generated/gun-parser.h"
     99/* Line 34 of lalr1.cc  */
     100#line 101 "generated/gun-parser.h"
    68101
    69102  /// A Bison parser.
     
    76109    {
    77110
    78 /* Line 35 of lalr1.cc  */
     111/* Line 34 of lalr1.cc  */
    79112#line 35 "gun-parser.y"
    80113
     
    84117
    85118
    86 /* Line 35 of lalr1.cc  */
    87 #line 88 "generated/gun-parser.h"
     119/* Line 34 of lalr1.cc  */
     120#line 121 "generated/gun-parser.h"
    88121    };
    89122#else
     
    188221    location_stack_type yylocation_stack_;
    189222
    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 
    198223    /// Internal symbol numbers.
    199224    typedef unsigned char token_number_type;
     
    203228    static const signed char yypact_ninf_;
    204229
    205     /// For a state, default reduction number.
     230    /// For a state, default rule to reduce.
    206231    /// Unless\a  yytable_ specifies something else to do.
    207232    /// Zero means the default is an error.
     
    234259#endif
    235260
     261#if YYERROR_VERBOSE
    236262    /// Convert the symbol name \a n to a form suitable for a diagnostic.
    237     static std::string yytnamerr_ (const char *n);
     263    virtual std::string yytnamerr_ (const char *n);
     264#endif
    238265
    239266#if YYDEBUG
     
    293320} // orbital
    294321
    295 /* Line 35 of lalr1.cc  */
    296 #line 297 "generated/gun-parser.h"
     322/* Line 34 of lalr1.cc  */
     323#line 324 "generated/gun-parser.h"
    297324
    298325
  • trunk/orbital/generated/location.hh

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

    r1432 r1434  
    1 /* A Bison parser, made by GNU Bison 2.5.  */
     1/* A Bison parser, made by GNU Bison 2.4.2.  */
    22
    33/* Skeleton implementation for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2011 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2010 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 293 of lalr1.cc  */
     38/* Line 310 of lalr1.cc  */
    3939#line 1 "mesh-parser.y"
    4040
     
    6161
    6262
    63 /* Line 293 of lalr1.cc  */
     63/* Line 310 of lalr1.cc  */
    6464#line 65 "generated/mesh-parser.cpp"
    6565
     
    6969/* User implementation prologue.  */
    7070
    71 /* Line 299 of lalr1.cc  */
     71/* Line 316 of lalr1.cc  */
    7272#line 64 "mesh-parser.y"
    7373
     
    7878
    7979
    80 /* Line 299 of lalr1.cc  */
     80/* Line 316 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 
    11595/* Suppress unused-variable warnings by "using" E.  */
    11696#define YYUSE(e) ((void) (e))
     
    164144namespace orbital {
    165145
    166 /* Line 382 of lalr1.cc  */
    167 #line 168 "generated/mesh-parser.cpp"
     146/* Line 379 of lalr1.cc  */
     147#line 148 "generated/mesh-parser.cpp"
     148#if YYERROR_VERBOSE
    168149
    169150  /* Return YYSTR after stripping away unnecessary quotes and
     
    204185  }
    205186
     187#endif
    206188
    207189  /// Build a parser object.
     
    304286#endif
    305287
    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 
    318288  int
    319289  MeshParser::parse ()
     
    337307    location_type yylloc;
    338308    /// The locations where the error started and ended.
    339     location_type yyerror_range[3];
     309    location_type yyerror_range[2];
    340310
    341311    /// $$.
     
    375345    /* Try to take a decision without lookahead.  */
    376346    yyn = yypact_[yystate];
    377     if (yy_pact_value_is_default_ (yyn))
     347    if (yyn == yypact_ninf_)
    378348      goto yydefault;
    379349
     
    408378    if (yyn <= 0)
    409379      {
    410         if (yy_table_value_is_error_ (yyn))
    411           goto yyerrlab;
     380        if (yyn == 0 || yyn == yytable_ninf_)
     381        goto yyerrlab;
    412382        yyn = -yyn;
    413383        goto yyreduce;
     
    463433    switch (yyn)
    464434      {
    465           case 9:
    466 
    467 /* Line 690 of lalr1.cc  */
    468 #line 90 "mesh-parser.y"
    469     { mc.m_mesh.Flush(); }
    470     break;
    471 
    472   case 10:
    473 
    474 /* Line 690 of lalr1.cc  */
    475 #line 91 "mesh-parser.y"
     435          case 7:
     436
     437/* Line 677 of lalr1.cc  */
     438#line 88 "mesh-parser.y"
     439    { mc.m_mesh.OpenBrace(); }
     440    break;
     441
     442  case 8:
     443
     444/* Line 677 of lalr1.cc  */
     445#line 92 "mesh-parser.y"
     446    { mc.m_mesh.CloseBrace(); }
     447    break;
     448
     449  case 15:
     450
     451/* Line 677 of lalr1.cc  */
     452#line 108 "mesh-parser.y"
    476453    { mc.m_mesh.MeshConvert(); }
    477454    break;
    478455
    479   case 11:
    480 
    481 /* Line 690 of lalr1.cc  */
    482 #line 92 "mesh-parser.y"
     456  case 16:
     457
     458/* Line 677 of lalr1.cc  */
     459#line 109 "mesh-parser.y"
    483460    { /* TODO */ }
    484461    break;
    485462
    486   case 12:
    487 
    488 /* Line 690 of lalr1.cc  */
    489 #line 96 "mesh-parser.y"
     463  case 17:
     464
     465/* Line 677 of lalr1.cc  */
     466#line 113 "mesh-parser.y"
    490467    { 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)); }
    491468    break;
    492469
    493   case 13:
    494 
    495 /* Line 690 of lalr1.cc  */
    496 #line 97 "mesh-parser.y"
     470  case 18:
     471
     472/* Line 677 of lalr1.cc  */
     473#line 114 "mesh-parser.y"
    497474    { uint16_t x = (uint16_t)(yysemantic_stack_[(2) - (2)].u32val);
    498475                      vec4 v(x >> 12, (x >> 8) & 0xf, (x >> 4) & 0xf, x & 0xf);
     
    500477    break;
    501478
    502   case 14:
    503 
    504 /* Line 690 of lalr1.cc  */
    505 #line 100 "mesh-parser.y"
     479  case 19:
     480
     481/* Line 677 of lalr1.cc  */
     482#line 117 "mesh-parser.y"
    506483    { 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)); }
    507484    break;
    508485
    509   case 15:
    510 
    511 /* Line 690 of lalr1.cc  */
    512 #line 101 "mesh-parser.y"
     486  case 20:
     487
     488/* Line 677 of lalr1.cc  */
     489#line 118 "mesh-parser.y"
    513490    { uint16_t x = (uint16_t)(yysemantic_stack_[(2) - (2)].u32val);
    514491                      vec4 v(x >> 12, (x >> 8) & 0xf, (x >> 4) & 0xf, x & 0xf);
    515                       mc.m_mesh.SetCurColor(vec4(v) * (1. / 15)); }
    516     break;
    517 
    518   case 16:
    519 
    520 /* Line 690 of lalr1.cc  */
    521 #line 107 "mesh-parser.y"
     492                      mc.m_mesh.SetCurColor2(vec4(v) * (1. / 15)); }
     493    break;
     494
     495  case 21:
     496
     497/* Line 677 of lalr1.cc  */
     498#line 124 "mesh-parser.y"
    522499    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, 0, 0)); }
    523500    break;
    524501
    525   case 17:
    526 
    527 /* Line 690 of lalr1.cc  */
    528 #line 108 "mesh-parser.y"
     502  case 22:
     503
     504/* Line 677 of lalr1.cc  */
     505#line 125 "mesh-parser.y"
    529506    { mc.m_mesh.Translate(vec3(0, (yysemantic_stack_[(2) - (2)].args).f0, 0)); }
    530507    break;
    531508
    532   case 18:
    533 
    534 /* Line 690 of lalr1.cc  */
    535 #line 109 "mesh-parser.y"
     509  case 23:
     510
     511/* Line 677 of lalr1.cc  */
     512#line 126 "mesh-parser.y"
    536513    { mc.m_mesh.Translate(vec3(0, 0, (yysemantic_stack_[(2) - (2)].args).f0)); }
    537514    break;
    538515
    539   case 19:
    540 
    541 /* Line 690 of lalr1.cc  */
    542 #line 110 "mesh-parser.y"
     516  case 24:
     517
     518/* Line 677 of lalr1.cc  */
     519#line 127 "mesh-parser.y"
    543520    { mc.m_mesh.Translate(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
    544521    break;
    545522
    546   case 20:
    547 
    548 /* Line 690 of lalr1.cc  */
    549 #line 111 "mesh-parser.y"
     523  case 25:
     524
     525/* Line 677 of lalr1.cc  */
     526#line 128 "mesh-parser.y"
    550527    { mc.m_mesh.RotateX((yysemantic_stack_[(2) - (2)].args).f0); }
    551528    break;
    552529
    553   case 21:
    554 
    555 /* Line 690 of lalr1.cc  */
    556 #line 112 "mesh-parser.y"
     530  case 26:
     531
     532/* Line 677 of lalr1.cc  */
     533#line 129 "mesh-parser.y"
    557534    { mc.m_mesh.RotateY((yysemantic_stack_[(2) - (2)].args).f0); }
    558535    break;
    559536
    560   case 22:
    561 
    562 /* Line 690 of lalr1.cc  */
    563 #line 113 "mesh-parser.y"
     537  case 27:
     538
     539/* Line 677 of lalr1.cc  */
     540#line 130 "mesh-parser.y"
    564541    { mc.m_mesh.RotateZ((yysemantic_stack_[(2) - (2)].args).f0); }
    565542    break;
    566543
    567   case 23:
    568 
    569 /* Line 690 of lalr1.cc  */
    570 #line 114 "mesh-parser.y"
     544  case 28:
     545
     546/* Line 677 of lalr1.cc  */
     547#line 131 "mesh-parser.y"
    571548    { mc.m_mesh.TaperX((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
    572549    break;
    573550
    574   case 24:
    575 
    576 /* Line 690 of lalr1.cc  */
    577 #line 115 "mesh-parser.y"
     551  case 29:
     552
     553/* Line 677 of lalr1.cc  */
     554#line 132 "mesh-parser.y"
    578555    { mc.m_mesh.TaperY((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
    579556    break;
    580557
    581   case 25:
    582 
    583 /* Line 690 of lalr1.cc  */
    584 #line 116 "mesh-parser.y"
     558  case 30:
     559
     560/* Line 677 of lalr1.cc  */
     561#line 133 "mesh-parser.y"
    585562    { mc.m_mesh.TaperZ((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2); }
    586563    break;
    587564
    588   case 26:
    589 
    590 /* Line 690 of lalr1.cc  */
    591 #line 117 "mesh-parser.y"
     565  case 31:
     566
     567/* Line 677 of lalr1.cc  */
     568#line 134 "mesh-parser.y"
    592569    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, 0, 0)); }
    593570    break;
    594571
    595   case 27:
    596 
    597 /* Line 690 of lalr1.cc  */
    598 #line 118 "mesh-parser.y"
     572  case 32:
     573
     574/* Line 677 of lalr1.cc  */
     575#line 135 "mesh-parser.y"
    599576    { mc.m_mesh.Scale(vec3(0, (yysemantic_stack_[(2) - (2)].args).f0, 0)); }
    600577    break;
    601578
    602   case 28:
    603 
    604 /* Line 690 of lalr1.cc  */
    605 #line 119 "mesh-parser.y"
     579  case 33:
     580
     581/* Line 677 of lalr1.cc  */
     582#line 136 "mesh-parser.y"
    606583    { mc.m_mesh.Scale(vec3(0, 0, (yysemantic_stack_[(2) - (2)].args).f0)); }
    607584    break;
    608585
    609   case 29:
    610 
    611 /* Line 690 of lalr1.cc  */
    612 #line 120 "mesh-parser.y"
     586  case 34:
     587
     588/* Line 677 of lalr1.cc  */
     589#line 137 "mesh-parser.y"
    613590    { mc.m_mesh.Scale(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
    614591    break;
    615592
    616   case 30:
    617 
    618 /* Line 690 of lalr1.cc  */
    619 #line 121 "mesh-parser.y"
     593  case 35:
     594
     595/* Line 677 of lalr1.cc  */
     596#line 138 "mesh-parser.y"
    620597    { mc.m_mesh.MirrorX(); }
    621598    break;
    622599
    623   case 31:
    624 
    625 /* Line 690 of lalr1.cc  */
    626 #line 122 "mesh-parser.y"
     600  case 36:
     601
     602/* Line 677 of lalr1.cc  */
     603#line 139 "mesh-parser.y"
    627604    { mc.m_mesh.MirrorY(); }
    628605    break;
    629606
    630   case 32:
    631 
    632 /* Line 690 of lalr1.cc  */
    633 #line 123 "mesh-parser.y"
     607  case 37:
     608
     609/* Line 677 of lalr1.cc  */
     610#line 140 "mesh-parser.y"
    634611    { mc.m_mesh.MirrorZ(); }
    635612    break;
    636613
    637   case 33:
    638 
    639 /* Line 690 of lalr1.cc  */
    640 #line 127 "mesh-parser.y"
     614  case 38:
     615
     616/* Line 677 of lalr1.cc  */
     617#line 144 "mesh-parser.y"
    641618    { mc.m_mesh.AppendCylinder((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
    642619                                                 (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3,
     
    644621    break;
    645622
    646   case 34:
    647 
    648 /* Line 690 of lalr1.cc  */
    649 #line 130 "mesh-parser.y"
     623  case 39:
     624
     625/* Line 677 of lalr1.cc  */
     626#line 147 "mesh-parser.y"
    650627    { mc.m_mesh.AppendBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2)); }
    651628    break;
    652629
    653   case 35:
    654 
    655 /* Line 690 of lalr1.cc  */
    656 #line 131 "mesh-parser.y"
     630  case 40:
     631
     632/* Line 677 of lalr1.cc  */
     633#line 148 "mesh-parser.y"
    657634    { mc.m_mesh.AppendSmoothChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
    658635                                                            (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
    659636    break;
    660637
    661   case 36:
    662 
    663 /* Line 690 of lalr1.cc  */
    664 #line 133 "mesh-parser.y"
     638  case 41:
     639
     640/* Line 677 of lalr1.cc  */
     641#line 150 "mesh-parser.y"
    665642    { mc.m_mesh.AppendFlatChamfBox(vec3((yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
    666643                                                          (yysemantic_stack_[(2) - (2)].args).f2), (yysemantic_stack_[(2) - (2)].args).f3); }
    667644    break;
    668645
    669   case 37:
    670 
    671 /* Line 690 of lalr1.cc  */
    672 #line 135 "mesh-parser.y"
     646  case 42:
     647
     648/* Line 677 of lalr1.cc  */
     649#line 152 "mesh-parser.y"
    673650    { mc.m_mesh.AppendSphere((yysemantic_stack_[(2) - (2)].args).f0,
    674651                                               vec3((yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3)); }
    675652    break;
    676653
    677   case 38:
    678 
    679 /* Line 690 of lalr1.cc  */
    680 #line 137 "mesh-parser.y"
     654  case 43:
     655
     656/* Line 677 of lalr1.cc  */
     657#line 154 "mesh-parser.y"
    681658    { mc.m_mesh.AppendStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (yysemantic_stack_[(2) - (2)].args).f2,
    682659                                             (int)(yysemantic_stack_[(2) - (2)].args).f3, (int)(yysemantic_stack_[(2) - (2)].args).f4); }
    683660    break;
    684661
    685   case 39:
    686 
    687 /* Line 690 of lalr1.cc  */
    688 #line 139 "mesh-parser.y"
     662  case 44:
     663
     664/* Line 677 of lalr1.cc  */
     665#line 156 "mesh-parser.y"
    689666    { mc.m_mesh.AppendExpandedStar((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1,
    690667                                                     (yysemantic_stack_[(2) - (2)].args).f2, (yysemantic_stack_[(2) - (2)].args).f3); }
    691668    break;
    692669
    693   case 40:
    694 
    695 /* Line 690 of lalr1.cc  */
    696 #line 141 "mesh-parser.y"
     670  case 45:
     671
     672/* Line 677 of lalr1.cc  */
     673#line 158 "mesh-parser.y"
    697674    { mc.m_mesh.AppendDisc((int)(yysemantic_stack_[(2) - (2)].args).f0, (yysemantic_stack_[(2) - (2)].args).f1, (int)(yysemantic_stack_[(2) - (2)].args).f2); }
    698675    break;
    699676
    700   case 41:
    701 
    702 /* Line 690 of lalr1.cc  */
    703 #line 142 "mesh-parser.y"
     677  case 46:
     678
     679/* Line 677 of lalr1.cc  */
     680#line 159 "mesh-parser.y"
    704681    { mc.m_mesh.AppendSimpleTriangle((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
    705682    break;
    706683
    707   case 42:
    708 
    709 /* Line 690 of lalr1.cc  */
    710 #line 143 "mesh-parser.y"
     684  case 47:
     685
     686/* Line 677 of lalr1.cc  */
     687#line 160 "mesh-parser.y"
    711688    { mc.m_mesh.AppendSimpleQuad((yysemantic_stack_[(2) - (2)].args).f0, (int)(yysemantic_stack_[(2) - (2)].args).f1); }
    712689    break;
    713690
    714   case 43:
    715 
    716 /* Line 690 of lalr1.cc  */
    717 #line 144 "mesh-parser.y"
     691  case 48:
     692
     693/* Line 677 of lalr1.cc  */
     694#line 161 "mesh-parser.y"
    718695    { 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,
    719696                                            (yysemantic_stack_[(2) - (2)].args).f4, (yysemantic_stack_[(2) - (2)].args).f5, (yysemantic_stack_[(2) - (2)].args).f6, (int)(yysemantic_stack_[(2) - (2)].args).f7); }
    720697    break;
    721698
    722   case 44:
    723 
    724 /* Line 690 of lalr1.cc  */
    725 #line 148 "mesh-parser.y"
     699  case 49:
     700
     701/* Line 677 of lalr1.cc  */
     702#line 165 "mesh-parser.y"
    726703    { (yyval.args).f0 = (yysemantic_stack_[(1) - (1)].fval); }
    727704    break;
    728705
    729   case 45:
    730 
    731 /* Line 690 of lalr1.cc  */
    732 #line 149 "mesh-parser.y"
    733     { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(3) - (3)].fval); }
    734     break;
    735 
    736   case 46:
    737 
    738 /* Line 690 of lalr1.cc  */
    739 #line 150 "mesh-parser.y"
    740     { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(3) - (3)].fval); }
    741     break;
    742 
    743   case 47:
    744 
    745 /* Line 690 of lalr1.cc  */
    746 #line 151 "mesh-parser.y"
    747     { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f3 = (yysemantic_stack_[(3) - (3)].fval); }
    748     break;
    749 
    750   case 48:
    751 
    752 /* Line 690 of lalr1.cc  */
    753 #line 152 "mesh-parser.y"
    754     { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f4 = (yysemantic_stack_[(3) - (3)].fval); }
    755     break;
    756 
    757   case 49:
    758 
    759 /* Line 690 of lalr1.cc  */
    760 #line 153 "mesh-parser.y"
    761     { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f5 = (yysemantic_stack_[(3) - (3)].fval); }
    762     break;
    763 
    764706  case 50:
    765707
    766 /* Line 690 of lalr1.cc  */
    767 #line 154 "mesh-parser.y"
    768     { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f6 = (yysemantic_stack_[(3) - (3)].fval); }
     708/* Line 677 of lalr1.cc  */
     709#line 166 "mesh-parser.y"
     710    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f1 = (yysemantic_stack_[(2) - (2)].fval); }
    769711    break;
    770712
    771713  case 51:
    772714
    773 /* Line 690 of lalr1.cc  */
    774 #line 155 "mesh-parser.y"
    775     { (yyval.args) = (yysemantic_stack_[(3) - (1)].args); (yyval.args).f7 = (yysemantic_stack_[(3) - (3)].fval); }
     715/* Line 677 of lalr1.cc  */
     716#line 167 "mesh-parser.y"
     717    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f2 = (yysemantic_stack_[(2) - (2)].fval); }
    776718    break;
    777719
    778720  case 52:
    779721
    780 /* Line 690 of lalr1.cc  */
    781 #line 158 "mesh-parser.y"
     722/* Line 677 of lalr1.cc  */
     723#line 168 "mesh-parser.y"
     724    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f3 = (yysemantic_stack_[(2) - (2)].fval); }
     725    break;
     726
     727  case 53:
     728
     729/* Line 677 of lalr1.cc  */
     730#line 169 "mesh-parser.y"
     731    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f4 = (yysemantic_stack_[(2) - (2)].fval); }
     732    break;
     733
     734  case 54:
     735
     736/* Line 677 of lalr1.cc  */
     737#line 170 "mesh-parser.y"
     738    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f5 = (yysemantic_stack_[(2) - (2)].fval); }
     739    break;
     740
     741  case 55:
     742
     743/* Line 677 of lalr1.cc  */
     744#line 171 "mesh-parser.y"
     745    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f6 = (yysemantic_stack_[(2) - (2)].fval); }
     746    break;
     747
     748  case 56:
     749
     750/* Line 677 of lalr1.cc  */
     751#line 172 "mesh-parser.y"
     752    { (yyval.args) = (yysemantic_stack_[(2) - (1)].args); (yyval.args).f7 = (yysemantic_stack_[(2) - (2)].fval); }
     753    break;
     754
     755  case 57:
     756
     757/* Line 677 of lalr1.cc  */
     758#line 175 "mesh-parser.y"
    782759    { (yyval.fval) = (yysemantic_stack_[(1) - (1)].fval); }
    783760    break;
    784761
    785   case 53:
    786 
    787 /* Line 690 of lalr1.cc  */
    788 #line 159 "mesh-parser.y"
     762  case 58:
     763
     764/* Line 677 of lalr1.cc  */
     765#line 176 "mesh-parser.y"
    789766    { (yyval.fval) = -(yysemantic_stack_[(2) - (2)].fval); }
    790767    break;
     
    792769
    793770
    794 /* Line 690 of lalr1.cc  */
    795 #line 796 "generated/mesh-parser.cpp"
     771/* Line 677 of lalr1.cc  */
     772#line 773 "generated/mesh-parser.cpp"
    796773        default:
    797774          break;
    798775      }
    799     /* User semantic actions sometimes alter yychar, and that requires
    800        that yytoken be updated with the new translation.  We take the
    801        approach of translating immediately before every use of yytoken.
    802        One alternative is translating here after every semantic action,
    803        but that translation would be missed if the semantic action
    804        invokes YYABORT, YYACCEPT, or YYERROR immediately after altering
    805        yychar.  In the case of YYABORT or YYACCEPT, an incorrect
    806        destructor might then be invoked immediately.  In the case of
    807        YYERROR, subsequent parser actions might lead to an incorrect
    808        destructor call or verbose syntax error message before the
    809        lookahead is translated.  */
    810776    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
    811777
     
    831797  `------------------------------------*/
    832798  yyerrlab:
    833     /* Make sure we have latest lookahead translation.  See comments at
    834        user semantic actions for why this is necessary.  */
    835     yytoken = yytranslate_ (yychar);
    836 
    837799    /* If not already recovering from an error, report this error.  */
    838800    if (!yyerrstatus_)
    839801      {
    840802        ++yynerrs_;
    841         if (yychar == yyempty_)
    842           yytoken = yyempty_;
    843803        error (yylloc, yysyntax_error_ (yystate, yytoken));
    844804      }
    845805
    846     yyerror_range[1] = yylloc;
     806    yyerror_range[0] = yylloc;
    847807    if (yyerrstatus_ == 3)
    848808      {
     
    879839      goto yyerrorlab;
    880840
    881     yyerror_range[1] = yylocation_stack_[yylen - 1];
     841    yyerror_range[0] = yylocation_stack_[yylen - 1];
    882842    /* Do not reclaim the symbols of the rule which action triggered
    883843       this YYERROR.  */
     
    896856      {
    897857        yyn = yypact_[yystate];
    898         if (!yy_pact_value_is_default_ (yyn))
     858        if (yyn != yypact_ninf_)
    899859        {
    900860          yyn += yyterror_;
     
    911871        YYABORT;
    912872
    913         yyerror_range[1] = yylocation_stack_[0];
     873        yyerror_range[0] = yylocation_stack_[0];
    914874        yydestruct_ ("Error: popping",
    915875                     yystos_[yystate],
     
    920880      }
    921881
    922     yyerror_range[2] = yylloc;
     882    yyerror_range[1] = yylloc;
    923883    // Using YYLLOC is tempting, but would change the location of
    924884    // the lookahead.  YYLOC is available though.
    925     YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
     885    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
    926886    yysemantic_stack_.push (yylval);
    927887    yylocation_stack_.push (yyloc);
     
    946906  yyreturn:
    947907    if (yychar != yyempty_)
    948       {
    949         /* Make sure we have latest lookahead translation.  See comments
    950            at user semantic actions for why this is necessary.  */
    951         yytoken = yytranslate_ (yychar);
    952         yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval,
    953                      &yylloc);
    954       }
     908      yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
    955909
    956910    /* Do not reclaim the symbols of the rule which action triggered
     
    971925  // Generate an error message.
    972926  std::string
    973   MeshParser::yysyntax_error_ (int yystate, int yytoken)
    974   {
    975     std::string yyres;
    976     // Number of reported tokens (one for the "unexpected", one per
    977     // "expected").
    978     size_t yycount = 0;
    979     // Its maximum.
    980     enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
    981     // Arguments of yyformat.
    982     char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    983 
    984     /* There are many possibilities here to consider:
    985        - If this state is a consistent state with a default action, then
    986          the only way this function was invoked is if the default action
    987          is an error action.  In that case, don't check for expected
    988          tokens because there are none.
    989        - The only way there can be no lookahead present (in yytoken) is
    990          if this state is a consistent state with a default action.
    991          Thus, detecting the absence of a lookahead is sufficient to
    992          determine that there is no unexpected or expected token to
    993          report.  In that case, just report a simple "syntax error".
    994        - Don't assume there isn't a lookahead just because this state is
    995          a consistent state with a default action.  There might have
    996          been a previous inconsistent state, consistent state with a
    997          non-default action, or user semantic action that manipulated
    998          yychar.
    999        - Of course, the expected token list depends on states to have
    1000          correct lookahead information, and it depends on the parser not
    1001          to perform extra reductions after fetching a lookahead from the
    1002          scanner and before detecting a syntax error.  Thus, state
    1003          merging (from LALR or IELR) and default reductions corrupt the
    1004          expected token list.  However, the list is correct for
    1005          canonical LR with one exception: it will still contain any
    1006          token that will not be accepted due to an error action in a
    1007          later state.
    1008     */
    1009     if (yytoken != yyempty_)
     927  MeshParser::yysyntax_error_ (int yystate, int tok)
     928  {
     929    std::string res;
     930    YYUSE (yystate);
     931#if YYERROR_VERBOSE
     932    int yyn = yypact_[yystate];
     933    if (yypact_ninf_ < yyn && yyn <= yylast_)
    1010934      {
    1011         yyarg[yycount++] = yytname_[yytoken];
    1012         int yyn = yypact_[yystate];
    1013         if (!yy_pact_value_is_default_ (yyn))
    1014           {
    1015             /* Start YYX at -YYN if negative to avoid negative indexes in
    1016                YYCHECK.  In other words, skip the first -YYN actions for
    1017                this state because they are default actions.  */
    1018             int yyxbegin = yyn < 0 ? -yyn : 0;
    1019             /* Stay within bounds of both yycheck and yytname.  */
    1020             int yychecklim = yylast_ - yyn + 1;
    1021             int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
    1022             for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
    1023               if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
    1024                   && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
    1025                 {
    1026                   if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
    1027                     {
    1028                       yycount = 1;
    1029                       break;
    1030                     }
    1031                   else
    1032                     yyarg[yycount++] = yytname_[yyx];
    1033                 }
    1034           }
     935        /* Start YYX at -YYN if negative to avoid negative indexes in
     936           YYCHECK.  */
     937        int yyxbegin = yyn < 0 ? -yyn : 0;
     938
     939        /* Stay within bounds of both yycheck and yytname.  */
     940        int yychecklim = yylast_ - yyn + 1;
     941        int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
     942        int count = 0;
     943        for (int x = yyxbegin; x < yyxend; ++x)
     944          if (yycheck_[x + yyn] == x && x != yyterror_)
     945            ++count;
     946
     947        // FIXME: This method of building the message is not compatible
     948        // with internationalization.  It should work like yacc.c does it.
     949        // That is, first build a string that looks like this:
     950        // "syntax error, unexpected %s or %s or %s"
     951        // Then, invoke YY_ on this string.
     952        // Finally, use the string as a format to output
     953        // yytname_[tok], etc.
     954        // Until this gets fixed, this message appears in English only.
     955        res = "syntax error, unexpected ";
     956        res += yytnamerr_ (yytname_[tok]);
     957        if (count < 5)
     958          {
     959            count = 0;
     960            for (int x = yyxbegin; x < yyxend; ++x)
     961              if (yycheck_[x + yyn] == x && x != yyterror_)
     962                {
     963                  res += (!count++) ? ", expecting " : " or ";
     964                  res += yytnamerr_ (yytname_[x]);
     965                }
     966          }
    1035967      }
    1036 
    1037     char const* yyformat = 0;
    1038     switch (yycount)
    1039       {
    1040 #define YYCASE_(N, S)                         \
    1041         case N:                               \
    1042           yyformat = S;                       \
    1043         break
    1044         YYCASE_(0, YY_("syntax error"));
    1045         YYCASE_(1, YY_("syntax error, unexpected %s"));
    1046         YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
    1047         YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
    1048         YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
    1049         YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
    1050 #undef YYCASE_
    1051       }
    1052 
    1053     // Argument number.
    1054     size_t yyi = 0;
    1055     for (char const* yyp = yyformat; *yyp; ++yyp)
    1056       if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
    1057         {
    1058           yyres += yytnamerr_ (yyarg[yyi++]);
    1059           ++yyp;
    1060         }
    1061       else
    1062         yyres += *yyp;
    1063     return yyres;
     968    else
     969#endif
     970      res = YY_("syntax error");
     971    return res;
    1064972  }
    1065973
     
    1067975  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    1068976     STATE-NUM.  */
    1069   const signed char MeshParser::yypact_ninf_ = -44;
     977  const signed char MeshParser::yypact_ninf_ = -47;
    1070978  const signed char
    1071979  MeshParser::yypact_[] =
    1072980  {
    1073         -1,   -44,   -44,   -44,    14,    45,    16,    16,    16,    16,
    1074      -44,    16,    16,    16,    16,   -44,    16,    16,    16,    16,
    1075      -44,    16,    16,    16,    16,    16,    16,    16,    16,    16,
    1076       16,    16,    16,    16,    40,     1,   -44,   -44,   -44,   -44,
    1077      -44,   -44,   -44,    16,    10,    23,    26,   -44,   -44,   -44,
    1078      -44,   -44,   -44,   -44,   -44,   -44,   -44,   -44,   -44,   -44,
    1079      -44,   -44,   -44,   -44,   -44,    28,    36,   -44,   -44,   -44,
    1080      -44,   -44,   -44,   -44,   -44,   -44,   -44,    38,    47,   -44,
    1081      -44,   -44,    -1,   -44,    16,    16,    16,    16,    16,    16,
    1082       16,   -44,   -44,   -44,   -44,   -44,   -44,   -44,   -44
    1083   };
    1084 
    1085   /* YYDEFACT[S] -- default reduction number in state S.  Performed when
    1086      YYTABLE doesn't specify something else to do.  Zero means the
    1087      default is an error.  */
     981        33,   -47,   -47,    70,    75,   -11,   -11,   -11,   -11,   -47,
     982     -11,   -11,   -11,   -11,   -47,   -11,   -11,   -11,   -11,   -47,
     983     -11,   -11,   -11,   -11,   -11,   -11,   -11,   -11,   -11,   -11,
     984     -11,   -11,   -11,   -47,     6,     9,    33,    33,    68,   -47,
     985     -47,   -47,   -47,   -47,   -47,   -47,   -11,   -11,   -11,   -11,
     986     -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47,
     987     -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47,   -11,   -11,
     988     -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47,
     989     -11,   -11,   -47,   -47,   -47,   -47,   -27,   -47,   -47,   -47,
     990     -47,   -47,   -47,   -47,   -47,   -47,   -47,   -47
     991  };
     992
     993  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
     994     doesn't specify something else to do.  Zero means the default is an
     995     error.  */
    1088996  const unsigned char
    1089997  MeshParser::yydefact_[] =
    1090998  {
    1091          0,     9,    10,    11,     0,     0,     0,     0,     0,     0,
    1092       30,     0,     0,     0,     0,    31,     0,     0,     0,     0,
    1093       32,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1094        0,     0,     0,     0,     0,     0,     3,     5,     6,     7,
    1095        8,    52,    13,     0,     0,     0,     0,    12,    44,    15,
    1096       14,    16,    20,    23,    26,    17,    21,    24,    27,    18,
    1097       22,    25,    28,    19,    29,     0,     0,    33,    34,    35,
    1098       36,    37,    38,    39,    40,    41,    42,     0,     0,    43,
    1099        1,     2,     0,    53,     0,     0,     0,     0,     0,     0,
    1100        0,     4,    45,    46,    47,    48,    49,    50,    51
     999         0,    15,    16,     0,     0,     0,     0,     0,     0,    35,
     1000       0,     0,     0,     0,    36,     0,     0,     0,     0,    37,
     1001       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     1002       0,     0,     0,     7,     0,     0,     3,     0,     5,     9,
     1003      11,    12,    13,    14,    57,    18,     0,     0,     0,     0,
     1004      17,    49,    20,    19,    21,    25,    28,    31,    22,    26,
     1005      29,    32,    23,    27,    30,    33,    24,    34,     0,     0,
     1006      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
     1007       0,     0,    48,     1,     2,     4,     0,    10,    58,    50,
     1008      51,    52,    53,    54,    55,    56,     8,     6
    11011009  };
    11021010
     
    11051013  MeshParser::yypgoto_[] =
    11061014  {
    1107        -44,   -44,   -44,   -13,   -44,   -44,   -44,   -44,    61,     6,
    1108       41,    31,    51,    50,   -44,   -44,   -43
     1015       -47,   -47,    -6,   -47,   -47,   -47,   -47,   -24,   -47,   -47,
     1016     -47,   -47,     2,    38,    96,     1,    -8,   -16,   -47,   -47,
     1017     -46
    11091018  };
    11101019
     
    11131022  MeshParser::yydefgoto_[] =
    11141023  {
    1115         -1,    34,    35,    36,    37,    38,    39,    40,    44,    45,
    1116       46,    65,    66,    67,    78,    79,    48
     1024        -1,    34,    35,    36,    37,    97,    38,    39,    40,    41,
     1025      42,    43,    47,    48,    49,    68,    69,    70,    81,    82,
     1026      51
    11171027  };
    11181028
    11191029  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    11201030     positive, shift that token.  If negative, reduce the rule which
    1121      number is the opposite.  If YYTABLE_NINF_, syntax error.  */
     1031     number is the opposite.  If zero, do what YYDEFACT says.  */
    11221032  const signed char MeshParser::yytable_ninf_ = -1;
    11231033  const unsigned char
    11241034  MeshParser::yytable_[] =
    11251035  {
    1126         83,    81,     1,     2,     3,     4,     5,     6,     7,     8,
    1127        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    1128       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
    1129       29,    30,    31,    32,    33,    47,    50,    75,    76,    82,
    1130       80,    92,    93,    94,    95,    96,    97,    98,    84,    53,
    1131       41,    42,    41,    43,    57,    43,    69,    70,    71,    61,
    1132       73,    85,    63,    64,    86,    68,    87,    51,    52,    91,
    1133       54,    74,    55,    56,    88,    58,    89,    59,    60,    72,
    1134       62,    41,    49,    77,    43,    90
     1036        88,    89,    90,    91,    50,    53,    83,    54,    55,    84,
     1037      57,    96,    58,    59,    87,    61,    80,    62,    63,    75,
     1038      65,     0,    92,    93,    44,    72,    73,    74,    46,    76,
     1039      85,    86,     0,     0,    94,    95,     1,     2,     3,     4,
     1040       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
     1041      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     1042      25,    26,    27,    28,    29,    30,    31,    32,    78,    79,
     1043      33,     1,     2,     3,     4,     5,     6,     7,     8,     9,
     1044      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     1045      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
     1046      30,    31,    32,    56,     0,    44,    45,     0,    60,    46,
     1047      44,    52,     0,    64,    46,     0,    66,    67,     0,    71,
     1048       0,     0,     0,     0,     0,    77
    11351049  };
    11361050
    11371051  /* YYCHECK.  */
    1138   const unsigned char
     1052  const signed char
    11391053  MeshParser::yycheck_[] =
    11401054  {
    1141         43,     0,     3,     4,     5,     6,     7,     8,     9,    10,
    1142       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    1143       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
    1144       31,    32,    33,    34,    35,     4,     5,    31,    32,    38,
    1145        0,    84,    85,    86,    87,    88,    89,    90,    38,     8,
    1146       36,    37,    36,    39,    13,    39,    25,    26,    27,    18,
    1147       29,    38,    21,    22,    38,    24,    38,     6,     7,    82,
    1148        9,    30,    11,    12,    38,    14,    38,    16,    17,    28,
    1149       19,    36,    37,    33,    39,    38
     1055        46,    47,    48,    49,     3,     4,     0,     5,     6,     0,
     1056       8,    38,    10,    11,    38,    13,    32,    15,    16,    27,
     1057      18,    -1,    68,    69,    35,    24,    25,    26,    39,    28,
     1058      36,    37,    -1,    -1,    80,    81,     3,     4,     5,     6,
     1059       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     1060      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     1061      27,    28,    29,    30,    31,    32,    33,    34,    30,    31,
     1062      37,     3,     4,     5,     6,     7,     8,     9,    10,    11,
     1063      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     1064      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
     1065      32,    33,    34,     7,    -1,    35,    36,    -1,    12,    39,
     1066      35,    36,    -1,    17,    39,    -1,    20,    21,    -1,    23,
     1067      -1,    -1,    -1,    -1,    -1,    29
    11501068  };
    11511069
     
    11581076      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    11591077      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
    1160       32,    33,    34,    35,    41,    42,    43,    44,    45,    46,
    1161       47,    36,    37,    39,    48,    49,    50,    51,    56,    37,
    1162       51,    48,    48,    50,    48,    48,    48,    50,    48,    48,
    1163       48,    50,    48,    50,    50,    51,    52,    53,    50,    51,
    1164       51,    51,    52,    51,    50,    49,    49,    53,    54,    55,
    1165        0,     0,    38,    56,    38,    38,    38,    38,    38,    38,
    1166       38,    43,    56,    56,    56,    56,    56,    56,    56
     1078      32,    33,    34,    37,    41,    42,    43,    44,    46,    47,
     1079      48,    49,    50,    51,    35,    36,    39,    52,    53,    54,
     1080      55,    60,    36,    55,    52,    52,    54,    52,    52,    52,
     1081      54,    52,    52,    52,    54,    52,    54,    54,    55,    56,
     1082      57,    54,    55,    55,    55,    56,    55,    54,    53,    53,
     1083      57,    58,    59,     0,     0,    42,    42,    47,    60,    60,
     1084      60,    60,    60,    60,    60,    60,    38,    45
    11671085  };
    11681086
     
    11761094     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
    11771095     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
    1178      285,   286,   287,   288,   289,   290,   291,   292,    44,    45
     1096     285,   286,   287,   288,   289,   290,   291,    91,    93,    45
    11791097  };
    11801098#endif
     
    11841102  MeshParser::yyr1_[] =
    11851103  {
    1186          0,    40,    41,    42,    42,    43,    43,    43,    43,    44,
    1187       44,    44,    45,    45,    45,    45,    46,    46,    46,    46,
    1188       46,    46,    46,    46,    46,    46,    46,    46,    46,    46,
    1189       46,    46,    46,    47,    47,    47,    47,    47,    47,    47,
    1190       47,    47,    47,    47,    48,    49,    50,    51,    52,    53,
    1191       54,    55,    56,    56
     1104         0,    40,    41,    42,    42,    43,    43,    44,    45,    46,
     1105      46,    47,    47,    47,    47,    48,    48,    49,    49,    49,
     1106      49,    50,    50,    50,    50,    50,    50,    50,    50,    50,
     1107      50,    50,    50,    50,    50,    50,    50,    50,    51,    51,
     1108      51,    51,    51,    51,    51,    51,    51,    51,    51,    52,
     1109      53,    54,    55,    56,    57,    58,    59,    60,    60
    11921110  };
    11931111
     
    11961114  MeshParser::yyr2_[] =
    11971115  {
    1198          0,     2,     2,     1,     3,     1,     1,     1,     1,     1,
    1199        1,     1,     2,     2,     2,     2,     2,     2,     2,     2,
    1200        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    1201        1,     1,     1,     2,     2,     2,     2,     2,     2,     2,
    1202        2,     2,     2,     2,     1,     3,     3,     3,     3,     3,
    1203        3,     3,     1,     2
     1116         0,     2,     2,     1,     2,     1,     3,     1,     1,     1,
     1117       2,     1,     1,     1,     1,     1,     1,     2,     2,     2,
     1118       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     1119       2,     2,     2,     2,     2,     1,     1,     1,     2,     2,
     1120       2,     2,     2,     2,     2,     2,     2,     2,     2,     1,
     1121       2,     2,     2,     2,     2,     2,     2,     1,     2
    12041122  };
    12051123
     
    12101128  const MeshParser::yytname_[] =
    12111129  {
    1212     "T_END", "error", "$undefined", "T_FLUSH", "T_INITRB", "T_FREERB",
    1213   "T_COLOR", "T_BGCOLOR", "T_TRANSLATEX", "T_ROTATEX", "T_TAPERX",
    1214   "T_SCALEX", "T_MIRRORX", "T_TRANSLATEY", "T_ROTATEY", "T_TAPERY",
    1215   "T_SCALEY", "T_MIRRORY", "T_TRANSLATEZ", "T_ROTATEZ", "T_TAPERZ",
    1216   "T_SCALEZ", "T_MIRRORZ", "T_TRANSLATE", "T_SCALE", "T_CYLINDER", "T_BOX",
     1130    "T_END", "error", "$undefined", "T_INITRB", "T_FREERB", "T_COLOR",
     1131  "T_BGCOLOR", "T_TRANSLATEX", "T_ROTATEX", "T_TAPERX", "T_SCALEX",
     1132  "T_MIRRORX", "T_TRANSLATEY", "T_ROTATEY", "T_TAPERY", "T_SCALEY",
     1133  "T_MIRRORY", "T_TRANSLATEZ", "T_ROTATEZ", "T_TAPERZ", "T_SCALEZ",
     1134  "T_MIRRORZ", "T_TRANSLATE", "T_SCALE", "T_CYLINDER", "T_BOX",
    12171135  "T_SMOOTHCHAMFBOX", "T_FLATCHAMFBOX", "T_SPHERE", "T_STAR",
    12181136  "T_EXPANDEDSTAR", "T_DISC", "T_TRIANGLE", "T_QUAD", "T_COG", "NUMBER",
    1219   "COLOR", "','", "'-'", "$accept", "mesh_description",
     1137  "COLOR", "'['", "']'", "'-'", "$accept", "mesh_description",
     1138  "mesh_expression_list", "mesh_expression", "mesh_open", "mesh_close",
    12201139  "mesh_command_list", "mesh_command", "rb_command", "color_command",
    12211140  "transform_command", "primitive_command", "args1", "args2", "args3",
     
    12291148  MeshParser::yyrhs_[] =
    12301149  {
    1231         41,     0,    -1,    42,     0,    -1,    43,    -1,    42,    38,
    1232       43,    -1,    44,    -1,    45,    -1,    46,    -1,    47,    -1,
    1233        3,    -1,     4,    -1,     5,    -1,     6,    51,    -1,     6,
    1234       37,    -1,     7,    51,    -1,     7,    37,    -1,     8,    48,
    1235       -1,    13,    48,    -1,    18,    48,    -1,    23,    50,    -1,
    1236        9,    48,    -1,    14,    48,    -1,    19,    48,    -1,    10,
    1237       50,    -1,    15,    50,    -1,    20,    50,    -1,    11,    48,
    1238       -1,    16,    48,    -1,    21,    48,    -1,    24,    50,    -1,
    1239       12,    -1,    17,    -1,    22,    -1,    25,    53,    -1,    26,
    1240       50,    -1,    27,    51,    -1,    28,    51,    -1,    29,    51,
    1241       -1,    30,    52,    -1,    31,    51,    -1,    32,    50,    -1,
    1242       33,    49,    -1,    34,    49,    -1,    35,    55,    -1,    56,
    1243       -1,    48,    38,    56,    -1,    49,    38,    56,    -1,    50,
    1244       38,    56,    -1,    51,    38,    56,    -1,    52,    38,    56,
    1245       -1,    53,    38,    56,    -1,    54,    38,    56,    -1,    36,
    1246       -1,    39,    56,    -1
     1150        41,     0,    -1,    42,     0,    -1,    43,    -1,    43,    42,
     1151      -1,    46,    -1,    44,    42,    45,    -1,    37,    -1,    38,
     1152      -1,    47,    -1,    46,    47,    -1,    48,    -1,    49,    -1,
     1153      50,    -1,    51,    -1,     3,    -1,     4,    -1,     5,    55,
     1154      -1,     5,    36,    -1,     6,    55,    -1,     6,    36,    -1,
     1155       7,    52,    -1,    12,    52,    -1,    17,    52,    -1,    22,
     1156      54,    -1,     8,    52,    -1,    13,    52,    -1,    18,    52,
     1157      -1,     9,    54,    -1,    14,    54,    -1,    19,    54,    -1,
     1158      10,    52,    -1,    15,    52,    -1,    20,    52,    -1,    23,
     1159      54,    -1,    11,    -1,    16,    -1,    21,    -1,    24,    57,
     1160      -1,    25,    54,    -1,    26,    55,    -1,    27,    55,    -1,
     1161      28,    55,    -1,    29,    56,    -1,    30,    55,    -1,    31,
     1162      54,    -1,    32,    53,    -1,    33,    53,    -1,    34,    59,
     1163      -1,    60,    -1,    52,    60,    -1,    53,    60,    -1,    54,
     1164      60,    -1,    55,    60,    -1,    56,    60,    -1,    57,    60,
     1165      -1,    58,    60,    -1,    35,    -1,    39,    60,    -1
    12471166  };
    12481167
     
    12521171  MeshParser::yyprhs_[] =
    12531172  {
    1254          0,     0,     3,     6,     8,    12,    14,    16,    18,    20,
    1255       22,    24,    26,    29,    32,    35,    38,    41,    44,    47,
    1256       50,    53,    56,    59,    62,    65,    68,    71,    74,    77,
    1257       80,    82,    84,    86,    89,    92,    95,    98,   101,   104,
    1258      107,   110,   113,   116,   119,   121,   125,   129,   133,   137,
    1259      141,   145,   149,   151
     1173         0,     0,     3,     6,     8,    11,    13,    17,    19,    21,
     1174      23,    26,    28,    30,    32,    34,    36,    38,    41,    44,
     1175      47,    50,    53,    56,    59,    62,    65,    68,    71,    74,
     1176      77,    80,    83,    86,    89,    92,    94,    96,    98,   101,
     1177     104,   107,   110,   113,   116,   119,   122,   125,   128,   131,
     1178     133,   136,   139,   142,   145,   148,   151,   154,   156
    12601179  };
    12611180
     
    12641183  MeshParser::yyrline_[] =
    12651184  {
    1266          0,    74,    74,    78,    79,    83,    84,    85,    86,    90,
    1267       91,    92,    96,    97,   100,   101,   107,   108,   109,   110,
    1268      111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
    1269      121,   122,   123,   127,   130,   131,   133,   135,   137,   139,
    1270      141,   142,   143,   144,   148,   149,   150,   151,   152,   153,
    1271      154,   155,   158,   159
     1185         0,    74,    74,    78,    79,    83,    84,    88,    92,    96,
     1186      97,   101,   102,   103,   104,   108,   109,   113,   114,   117,
     1187     118,   124,   125,   126,   127,   128,   129,   130,   131,   132,
     1188     133,   134,   135,   136,   137,   138,   139,   140,   144,   147,
     1189     148,   150,   152,   154,   156,   158,   159,   160,   161,   165,
     1190     166,   167,   168,   169,   170,   171,   172,   175,   176
    12721191  };
    12731192
     
    13131232       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    13141233       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    1315        2,     2,     2,     2,    38,    39,     2,     2,     2,     2,
    1316        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    1317        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    1318        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    1319        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    1320        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     1234       2,     2,     2,     2,     2,    39,     2,     2,     2,     2,
     1235       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     1236       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     1237       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     1238       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     1239       2,    37,     2,    38,     2,     2,     2,     2,     2,     2,
    13211240       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    13221241       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     
    13381257      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    13391258      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    1340       35,    36,    37
     1259      35,    36
    13411260    };
    13421261    if ((unsigned int) t <= yyuser_token_number_max_)
     
    13471266
    13481267  const int MeshParser::yyeof_ = 0;
    1349   const int MeshParser::yylast_ = 85;
    1350   const int MeshParser::yynnts_ = 17;
     1268  const int MeshParser::yylast_ = 125;
     1269  const int MeshParser::yynnts_ = 21;
    13511270  const int MeshParser::yyempty_ = -2;
    1352   const int MeshParser::yyfinal_ = 80;
     1271  const int MeshParser::yyfinal_ = 83;
    13531272  const int MeshParser::yyterror_ = 1;
    13541273  const int MeshParser::yyerrcode_ = 256;
    13551274  const int MeshParser::yyntokens_ = 40;
    13561275
    1357   const unsigned int MeshParser::yyuser_token_number_max_ = 292;
     1276  const unsigned int MeshParser::yyuser_token_number_max_ = 291;
    13581277  const MeshParser::token_number_type MeshParser::yyundef_token_ = 2;
    13591278
     
    13611280} // orbital
    13621281
    1363 /* Line 1136 of lalr1.cc  */
    1364 #line 1365 "generated/mesh-parser.cpp"
    1365 
    1366 
    1367 /* Line 1138 of lalr1.cc  */
    1368 #line 162 "mesh-parser.y"
     1282/* Line 1053 of lalr1.cc  */
     1283#line 1284 "generated/mesh-parser.cpp"
     1284
     1285
     1286/* Line 1055 of lalr1.cc  */
     1287#line 179 "mesh-parser.y"
    13691288
    13701289
  • trunk/orbital/generated/mesh-parser.h

    r1432 r1434  
    1 /* A Bison parser, made by GNU Bison 2.5.  */
     1/* A Bison parser, made by GNU Bison 2.4.2.  */
    22
    33/* Skeleton interface for Bison LALR(1) parsers in C++
    44   
    5       Copyright (C) 2002-2011 Free Software Foundation, Inc.
     5      Copyright (C) 2002-2010 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
     45namespace 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
    4357#include "location.hh"
    4458
     
    6175#endif
    6276
     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)                \
     83do {                                                    \
     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
    6396
    6497namespace orbital {
    6598
    66 /* Line 35 of lalr1.cc  */
    67 #line 68 "generated/mesh-parser.h"
     99/* Line 34 of lalr1.cc  */
     100#line 101 "generated/mesh-parser.h"
    68101
    69102  /// A Bison parser.
     
    76109    {
    77110
    78 /* Line 35 of lalr1.cc  */
     111/* Line 34 of lalr1.cc  */
    79112#line 35 "mesh-parser.y"
    80113
     
    86119
    87120
    88 /* Line 35 of lalr1.cc  */
    89 #line 90 "generated/mesh-parser.h"
     121/* Line 34 of lalr1.cc  */
     122#line 123 "generated/mesh-parser.h"
    90123    };
    91124#else
     
    100133   enum yytokentype {
    101134     T_END = 0,
    102      T_FLUSH = 258,
    103      T_INITRB = 259,
    104      T_FREERB = 260,
    105      T_COLOR = 261,
    106      T_BGCOLOR = 262,
    107      T_TRANSLATEX = 263,
    108      T_ROTATEX = 264,
    109      T_TAPERX = 265,
    110      T_SCALEX = 266,
    111      T_MIRRORX = 267,
    112      T_TRANSLATEY = 268,
    113      T_ROTATEY = 269,
    114      T_TAPERY = 270,
    115      T_SCALEY = 271,
    116      T_MIRRORY = 272,
    117      T_TRANSLATEZ = 273,
    118      T_ROTATEZ = 274,
    119      T_TAPERZ = 275,
    120      T_SCALEZ = 276,
    121      T_MIRRORZ = 277,
    122      T_TRANSLATE = 278,
    123      T_SCALE = 279,
    124      T_CYLINDER = 280,
    125      T_BOX = 281,
    126      T_SMOOTHCHAMFBOX = 282,
    127      T_FLATCHAMFBOX = 283,
    128      T_SPHERE = 284,
    129      T_STAR = 285,
    130      T_EXPANDEDSTAR = 286,
    131      T_DISC = 287,
    132      T_TRIANGLE = 288,
    133      T_QUAD = 289,
    134      T_COG = 290,
    135      NUMBER = 291,
    136      COLOR = 292
     135     T_INITRB = 258,
     136     T_FREERB = 259,
     137     T_COLOR = 260,
     138     T_BGCOLOR = 261,
     139     T_TRANSLATEX = 262,
     140     T_ROTATEX = 263,
     141     T_TAPERX = 264,
     142     T_SCALEX = 265,
     143     T_MIRRORX = 266,
     144     T_TRANSLATEY = 267,
     145     T_ROTATEY = 268,
     146     T_TAPERY = 269,
     147     T_SCALEY = 270,
     148     T_MIRRORY = 271,
     149     T_TRANSLATEZ = 272,
     150     T_ROTATEZ = 273,
     151     T_TAPERZ = 274,
     152     T_SCALEZ = 275,
     153     T_MIRRORZ = 276,
     154     T_TRANSLATE = 277,
     155     T_SCALE = 278,
     156     T_CYLINDER = 279,
     157     T_BOX = 280,
     158     T_SMOOTHCHAMFBOX = 281,
     159     T_FLATCHAMFBOX = 282,
     160     T_SPHERE = 283,
     161     T_STAR = 284,
     162     T_EXPANDEDSTAR = 285,
     163     T_DISC = 286,
     164     T_TRIANGLE = 287,
     165     T_QUAD = 288,
     166     T_COG = 289,
     167     NUMBER = 290,
     168     COLOR = 291
    137169   };
    138170
     
    208240    location_stack_type yylocation_stack_;
    209241
    210     /// Whether the given \c yypact_ value indicates a defaulted state.
    211     /// \param yyvalue   the value to check
    212     static bool yy_pact_value_is_default_ (int yyvalue);
    213 
    214     /// Whether the given \c yytable_ value indicates a syntax error.
    215     /// \param yyvalue   the value to check
    216     static bool yy_table_value_is_error_ (int yyvalue);
    217 
    218242    /// Internal symbol numbers.
    219243    typedef unsigned char token_number_type;
     
    223247    static const signed char yypact_ninf_;
    224248
    225     /// For a state, default reduction number.
     249    /// For a state, default rule to reduce.
    226250    /// Unless\a  yytable_ specifies something else to do.
    227251    /// Zero means the default is an error.
     
    239263    static const signed char yytable_ninf_;
    240264
    241     static const unsigned char yycheck_[];
     265    static const signed char yycheck_[];
    242266
    243267    /// For a state, its accessing symbol.
     
    254278#endif
    255279
     280#if YYERROR_VERBOSE
    256281    /// Convert the symbol name \a n to a form suitable for a diagnostic.
    257     static std::string yytnamerr_ (const char *n);
     282    virtual std::string yytnamerr_ (const char *n);
     283#endif
    258284
    259285#if YYDEBUG
     
    313339} // orbital
    314340
    315 /* Line 35 of lalr1.cc  */
    316 #line 317 "generated/mesh-parser.h"
     341/* Line 34 of lalr1.cc  */
     342#line 343 "generated/mesh-parser.h"
    317343
    318344
  • trunk/orbital/generated/mesh-scanner.cpp

    r1430 r1434  
    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 41
     334#define YY_END_OF_BUFFER 42
    335335/* This struct is not used in this scanner,
    336336   but its presence is necessary. */
     
    342342static yyconst flex_int16_t yy_accept[69] =
    343343    {   0,
    344         0,    0,   41,   40,   39,   40,   40,   38,   37,   39,
    345        36,   40,   40,   40,   40,   40,   19,    9,    0,    0,
    346        36,   36,    0,   24,   23,   30,    0,    0,   32,   28,
    347        31,    1,    0,    0,   20,   21,   22,   10,   11,   12,
    348         4,   16,   17,   18,    0,    6,    7,    8,    0,    0,
    349        36,   33,   29,    0,    0,    0,    3,    2,    5,   13,
    350        14,   15,   34,   26,   25,   27,   35,    0
     344        0,    0,   42,   39,   40,   39,   39,   36,   39,   35,
     345       37,   38,   39,   39,   39,   39,   39,   18,    8,    0,
     346        0,   35,   35,    0,   23,   22,   29,    0,    0,   31,
     347       27,   30,    0,    0,   19,   20,   21,    9,   10,   11,
     348        3,   15,   16,   17,    0,    5,    6,    7,    0,    0,
     349       35,   32,   28,    0,    0,    0,    2,    1,    4,   12,
     350       13,   14,   33,   25,   24,   26,   34,    0
    351351    } ;
    352352
     
    357357        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    358358        1,    1,    1,    1,    3,    1,    1,    1,    1,    1,
    359         1,    1,    4,    5,    6,    7,    1,    8,    8,    8,
    360         8,    8,    8,    8,    8,    8,    8,    1,    1,    1,
    361         1,    1,    1,    1,    1,    1,    1,    1,    9,    1,
     359        1,    1,    4,    1,    5,    6,    1,    7,    7,    7,
     360        7,    7,    7,    7,    7,    7,    7,    1,    1,    1,
     361        1,    1,    1,    1,    1,    1,    1,    1,    8,    1,
    362362        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    363363        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    364         1,    1,    1,    1,    1,    1,   10,   11,   12,   13,
    365 
    366        14,   15,   16,   17,   18,    1,    1,   19,   20,    1,
     364        9,    1,   10,    1,    1,    1,   11,   12,   13,   14,
     365
     366       15,   16,   17,   18,   19,    1,    1,    1,   20,    1,
    367367        1,   21,   22,   23,   24,   25,    1,    1,    1,   26,
    368368       27,   28,    1,    1,    1,    1,    1,    1,    1,    1,
     
    385385static yyconst flex_int32_t yy_meta[29] =
    386386    {   0,
    387         1,    1,    1,    1,    1,    1,    1,    2,    1,    2,
    388         2,    2,    2,    2,    2,    1,    1,    1,    1,    1,
     387        1,    1,    1,    1,    1,    1,    2,    1,    1,    1,
     388        2,    2,    2,    2,    2,    2,    1,    1,    1,    1,
    389389        1,    1,    1,    1,    1,    1,    1,    1
    390390    } ;
     
    392392static yyconst flex_int16_t yy_base[73] =
    393393    {   0,
    394         0,    0,   94,   95,   95,    0,   22,   95,   24,   85,
    395        26,   30,   27,   69,   10,   21,   39,   43,    0,   83,
    396        49,   64,   56,   95,   74,   95,   65,   76,   95,   47,
    397        95,   95,   76,   75,   95,   95,   95,   95,   95,   95,
    398        74,   95,   95,   95,   48,   95,   95,   95,    0,   76,
    399        75,   95,   95,   71,   70,   63,   95,   95,   95,   95,
    400        95,   95,    0,   95,   95,   95,   95,   95,   77,   75,
    401        59,   37
     394        0,    0,   93,   94,   94,    0,   23,   25,   85,   27,
     395       94,   94,   31,   68,   67,   10,   13,   35,   38,    0,
     396       82,   44,   60,   53,   94,   71,   94,   63,   73,   94,
     397       56,   94,   73,   72,   94,   94,   94,   94,   94,   94,
     398       71,   94,   94,   94,   44,   94,   94,   94,    0,   75,
     399       74,   94,   94,   68,   67,   60,   94,   94,   94,   94,
     400       94,   94,    0,   94,   94,   94,   94,   94,   74,   72,
     401       71,   52
    402402    } ;
    403403
     
    405405    {   0,
    406406       68,    1,   68,   68,   68,   69,   68,   68,   68,   68,
    407        68,   68,   68,   68,   68,   68,   68,   68,   70,   68,
     407       68,   68,   68,   68,   68,   68,   68,   68,   68,   70,
    408408       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
    409409       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
     
    414414    } ;
    415415
    416 static yyconst flex_int16_t yy_nxt[124] =
     416static yyconst flex_int16_t yy_nxt[123] =
    417417    {   0,
    418         4,    5,    6,    7,    8,    9,   10,   11,    4,   12,
    419         4,    4,    4,    4,   13,    4,    4,   14,    4,   15,
    420         4,    4,   16,   17,   18,    4,    4,    4,   20,   21,
    421        20,   21,   20,   21,   23,   35,   36,   37,   67,   23,
    422        24,   25,   26,   27,   28,   32,   38,   39,   40,   33,
    423        41,   29,   45,   30,   31,   20,   21,   23,   55,   50,
    424        63,   50,   23,   51,   42,   43,   44,   56,   46,   47,
    425        48,   22,   23,   60,   61,   62,   49,   23,   19,   66,
    426        65,   64,   51,   51,   59,   58,   57,   54,   53,   52,
    427        22,   34,   22,   68,    3,   68,   68,   68,   68,   68,
     418        4,    5,    6,    7,    8,    9,   10,    4,   11,   12,
     419       13,    4,    4,    4,    4,   14,    4,    4,   15,   16,
     420        4,    4,   17,   18,   19,    4,    4,    4,   21,   22,
     421       21,   22,   21,   22,   24,   35,   36,   37,   38,   39,
     422       40,   24,   25,   26,   27,   28,   29,   41,   45,   21,
     423       22,   24,   30,   67,   31,   32,   50,   50,   24,   51,
     424       42,   43,   44,   46,   47,   48,   23,   24,   55,   60,
     425       61,   62,   63,   49,   24,   20,   56,   66,   65,   64,
     426       51,   51,   59,   58,   57,   54,   53,   52,   23,   34,
     427       33,   23,   68,    3,   68,   68,   68,   68,   68,   68,
    428428
    429429       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
    430430       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
    431        68,   68,   68
     431       68,   68
    432432    } ;
    433433
    434 static yyconst flex_int16_t yy_chk[124] =
     434static yyconst flex_int16_t yy_chk[123] =
    435435    {   0,
    436436        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    437437        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    438438        1,    1,    1,    1,    1,    1,    1,    1,    7,    7,
    439         9,    9,   11,   11,   11,   15,   15,   15,   72,   11,
    440        12,   12,   12,   12,   12,   13,   16,   16,   16,   13,
    441        17,   12,   18,   12,   12,   21,   21,   21,   30,   23,
    442        71,   23,   21,   23,   17,   17,   17,   30,   18,   18,
    443        18,   22,   22,   45,   45,   45,   70,   22,   69,   56,
    444        55,   54,   51,   50,   41,   34,   33,   28,   27,   25,
    445        20,   14,   10,    3,   68,   68,   68,   68,   68,   68,
     439        8,    8,   10,   10,   10,   16,   16,   16,   17,   17,
     440       17,   10,   13,   13,   13,   13,   13,   18,   19,   22,
     441       22,   22,   13,   72,   13,   13,   24,   24,   22,   24,
     442       18,   18,   18,   19,   19,   19,   23,   23,   31,   45,
     443       45,   45,   71,   70,   23,   69,   31,   56,   55,   54,
     444       51,   50,   41,   34,   33,   29,   28,   26,   21,   15,
     445       14,    9,    3,   68,   68,   68,   68,   68,   68,   68,
    446446
    447447       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
    448448       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
    449        68,   68,   68
     449       68,   68
    450450    } ;
    451451
     
    685685YY_RULE_SETUP
    686686#line 45 "mesh-scanner.l"
    687 { return token::T_FLUSH; }
     687{ return token::T_INITRB; }
    688688        YY_BREAK
    689689case 2:
    690690YY_RULE_SETUP
    691691#line 46 "mesh-scanner.l"
    692 { return token::T_INITRB; }
     692{ return token::T_FREERB; }
    693693        YY_BREAK
    694694case 3:
    695695YY_RULE_SETUP
    696 #line 47 "mesh-scanner.l"
    697 { return token::T_FREERB; }
     696#line 48 "mesh-scanner.l"
     697{ return token::T_COLOR; }
    698698        YY_BREAK
    699699case 4:
    700700YY_RULE_SETUP
    701701#line 49 "mesh-scanner.l"
    702 { return token::T_COLOR; }
     702{ return token::T_BGCOLOR; }
    703703        YY_BREAK
    704704case 5:
    705705YY_RULE_SETUP
    706 #line 50 "mesh-scanner.l"
    707 { return token::T_BGCOLOR; }
     706#line 51 "mesh-scanner.l"
     707{ return token::T_TRANSLATEX; }
    708708        YY_BREAK
    709709case 6:
    710710YY_RULE_SETUP
    711711#line 52 "mesh-scanner.l"
    712 { return token::T_TRANSLATEX; }
     712{ return token::T_TRANSLATEY; }
    713713        YY_BREAK
    714714case 7:
    715715YY_RULE_SETUP
    716716#line 53 "mesh-scanner.l"
    717 { return token::T_TRANSLATEY; }
     717{ return token::T_TRANSLATEZ; }
    718718        YY_BREAK
    719719case 8:
    720720YY_RULE_SETUP
    721721#line 54 "mesh-scanner.l"
    722 { return token::T_TRANSLATEZ; }
     722{ return token::T_TRANSLATE; }
    723723        YY_BREAK
    724724case 9:
    725725YY_RULE_SETUP
    726726#line 55 "mesh-scanner.l"
    727 { return token::T_TRANSLATE; }
     727{ return token::T_ROTATEX; }
    728728        YY_BREAK
    729729case 10:
    730730YY_RULE_SETUP
    731731#line 56 "mesh-scanner.l"
    732 { return token::T_ROTATEX; }
     732{ return token::T_ROTATEY; }
    733733        YY_BREAK
    734734case 11:
    735735YY_RULE_SETUP
    736736#line 57 "mesh-scanner.l"
    737 { return token::T_ROTATEY; }
     737{ return token::T_ROTATEZ; }
    738738        YY_BREAK
    739739case 12:
    740740YY_RULE_SETUP
    741741#line 58 "mesh-scanner.l"
    742 { return token::T_ROTATEZ; }
     742{ return token::T_TAPERX; }
    743743        YY_BREAK
    744744case 13:
    745745YY_RULE_SETUP
    746746#line 59 "mesh-scanner.l"
    747 { return token::T_TAPERX; }
     747{ return token::T_TAPERY; }
    748748        YY_BREAK
    749749case 14:
    750750YY_RULE_SETUP
    751751#line 60 "mesh-scanner.l"
    752 { return token::T_TAPERY; }
     752{ return token::T_TAPERZ; }
    753753        YY_BREAK
    754754case 15:
    755755YY_RULE_SETUP
    756756#line 61 "mesh-scanner.l"
    757 { return token::T_TAPERZ; }
     757{ return token::T_SCALEX; }
    758758        YY_BREAK
    759759case 16:
    760760YY_RULE_SETUP
    761761#line 62 "mesh-scanner.l"
    762 { return token::T_SCALEX; }
     762{ return token::T_SCALEY; }
    763763        YY_BREAK
    764764case 17:
    765765YY_RULE_SETUP
    766766#line 63 "mesh-scanner.l"
    767 { return token::T_SCALEY; }
     767{ return token::T_SCALEZ; }
    768768        YY_BREAK
    769769case 18:
    770770YY_RULE_SETUP
    771771#line 64 "mesh-scanner.l"
    772 { return token::T_SCALEZ; }
     772{ return token::T_SCALE; }
    773773        YY_BREAK
    774774case 19:
    775775YY_RULE_SETUP
    776776#line 65 "mesh-scanner.l"
    777 { return token::T_SCALE; }
     777{ return token::T_MIRRORX; }
    778778        YY_BREAK
    779779case 20:
    780780YY_RULE_SETUP
    781781#line 66 "mesh-scanner.l"
    782 { return token::T_MIRRORX; }
     782{ return token::T_MIRRORY; }
    783783        YY_BREAK
    784784case 21:
    785785YY_RULE_SETUP
    786786#line 67 "mesh-scanner.l"
    787 { return token::T_MIRRORY; }
     787{ return token::T_MIRRORZ; }
    788788        YY_BREAK
    789789case 22:
    790790YY_RULE_SETUP
    791 #line 68 "mesh-scanner.l"
    792 { return token::T_MIRRORZ; }
     791#line 69 "mesh-scanner.l"
     792{ return token::T_CYLINDER; }
    793793        YY_BREAK
    794794case 23:
    795795YY_RULE_SETUP
    796796#line 70 "mesh-scanner.l"
    797 { return token::T_CYLINDER; }
     797{ return token::T_BOX; }
    798798        YY_BREAK
    799799case 24:
    800800YY_RULE_SETUP
    801801#line 71 "mesh-scanner.l"
    802 { return token::T_BOX; }
     802{ return token::T_SMOOTHCHAMFBOX; }
    803803        YY_BREAK
    804804case 25:
    805805YY_RULE_SETUP
    806806#line 72 "mesh-scanner.l"
    807 { return token::T_SMOOTHCHAMFBOX; }
     807{ return token::T_FLATCHAMFBOX; }
    808808        YY_BREAK
    809809case 26:
    810810YY_RULE_SETUP
    811811#line 73 "mesh-scanner.l"
    812 { return token::T_FLATCHAMFBOX; }
     812{ return token::T_SPHERE; }
    813813        YY_BREAK
    814814case 27:
    815815YY_RULE_SETUP
    816816#line 74 "mesh-scanner.l"
    817 { return token::T_SPHERE; }
     817{ return token::T_STAR; }
    818818        YY_BREAK
    819819case 28:
    820820YY_RULE_SETUP
    821821#line 75 "mesh-scanner.l"
    822 { return token::T_STAR; }
     822{ return token::T_EXPANDEDSTAR; }
    823823        YY_BREAK
    824824case 29:
    825825YY_RULE_SETUP
    826826#line 76 "mesh-scanner.l"
    827 { return token::T_EXPANDEDSTAR; }
     827{ return token::T_DISC; }
    828828        YY_BREAK
    829829case 30:
    830830YY_RULE_SETUP
    831831#line 77 "mesh-scanner.l"
    832 { return token::T_DISC; }
     832{ return token::T_TRIANGLE; }
    833833        YY_BREAK
    834834case 31:
    835835YY_RULE_SETUP
    836836#line 78 "mesh-scanner.l"
    837 { return token::T_TRIANGLE; }
     837{ return token::T_QUAD; }
    838838        YY_BREAK
    839839case 32:
    840840YY_RULE_SETUP
    841841#line 79 "mesh-scanner.l"
    842 { return token::T_QUAD; }
     842{ return token::T_COG; }
    843843        YY_BREAK
    844844case 33:
    845845YY_RULE_SETUP
    846 #line 80 "mesh-scanner.l"
    847 { return token::T_COG; }
    848         YY_BREAK
    849 case 34:
    850 YY_RULE_SETUP
    851 #line 82 "mesh-scanner.l"
     846#line 81 "mesh-scanner.l"
    852847{
    853848        yylval->u32val = 0xf + 0x10 * strtol(yytext + 1, NULL, 16);
    854849        return token::COLOR; }
    855850        YY_BREAK
    856 case 35:
    857 YY_RULE_SETUP
    858 #line 85 "mesh-scanner.l"
     851case 34:
     852YY_RULE_SETUP
     853#line 84 "mesh-scanner.l"
    859854{
    860855        yylval->u32val = strtol(yytext + 1, NULL, 16);
    861856        return token::COLOR; }
    862857        YY_BREAK
     858case 35:
     859YY_RULE_SETUP
     860#line 87 "mesh-scanner.l"
     861{
     862        yylval->fval = atof(yytext); return token::NUMBER; }
     863        YY_BREAK
    863864case 36:
    864865YY_RULE_SETUP
    865 #line 88 "mesh-scanner.l"
    866 {
    867         yylval->fval = atof(yytext); return token::NUMBER; }
     866#line 89 "mesh-scanner.l"
     867{ return token_type('-'); }
    868868        YY_BREAK
    869869case 37:
    870870YY_RULE_SETUP
    871871#line 90 "mesh-scanner.l"
    872 { return token_type('-'); }
     872{ return token_type('['); }
    873873        YY_BREAK
    874874case 38:
    875875YY_RULE_SETUP
    876876#line 91 "mesh-scanner.l"
    877 { return token_type(','); }
     877{ return token_type(']'); }
    878878        YY_BREAK
    879879case 39:
    880 /* rule 39 can match eol */
    881880YY_RULE_SETUP
    882881#line 92 "mesh-scanner.l"
     
    884883        YY_BREAK
    885884case 40:
    886 YY_RULE_SETUP
    887 #line 94 "mesh-scanner.l"
     885/* rule 40 can match eol */
     886YY_RULE_SETUP
     887#line 93 "mesh-scanner.l"
     888{ /* ignore everything else */ }
     889        YY_BREAK
     890case 41:
     891YY_RULE_SETUP
     892#line 95 "mesh-scanner.l"
    888893ECHO;
    889894        YY_BREAK
    890 #line 891 "generated/mesh-scanner.cpp"
     895#line 896 "generated/mesh-scanner.cpp"
    891896case YY_STATE_EOF(INITIAL):
    892897        yyterminate();
     
    17891794#define YYTABLES_NAME "yytables"
    17901795
    1791 #line 94 "mesh-scanner.l"
     1796#line 95 "mesh-scanner.l"
    17921797
    17931798
  • trunk/orbital/generated/position.hh

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

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

    r1424 r1434  
    2727    m_lexer = &scanner;
    2828    GunParser parser(*this);
    29     return (parser.parse() == 0);
     29    if (parser.parse() != 0)
     30        return false;
     31    return true;
    3032}
    3133
  • trunk/orbital/mesh-compiler.cpp

    r1423 r1434  
    2727    m_lexer = &scanner;
    2828    MeshParser parser(*this);
    29     return (parser.parse() == 0);
     29    if (parser.parse() != 0)
     30        return false;
     31    return true;
    3032}
    3133
  • trunk/orbital/mesh-parser.y

    r1432 r1434  
    4242%start mesh_description
    4343
    44 %token T_FLUSH T_INITRB T_FREERB
     44%token T_INITRB T_FREERB
    4545
    4646%token T_COLOR T_BGCOLOR
     
    7272
    7373mesh_description:
    74     mesh_command_list T_END
     74    mesh_expression_list T_END
     75    ;
     76
     77mesh_expression_list:
     78    mesh_expression
     79  | mesh_expression mesh_expression_list
     80  ;
     81
     82mesh_expression:
     83    mesh_command_list
     84  | mesh_open mesh_expression_list mesh_close
     85    ;
     86
     87mesh_open:
     88    '['       { mc.m_mesh.OpenBrace(); }
     89    ;
     90
     91mesh_close:
     92    ']'       { mc.m_mesh.CloseBrace(); }
    7593    ;
    7694
    7795mesh_command_list:
    7896    mesh_command
    79   | mesh_command_list ',' mesh_command
     97  | mesh_command_list mesh_command
    8098    ;
    8199
     
    88106
    89107rb_command:
    90     T_FLUSH    { mc.m_mesh.Flush(); }
    91   | T_INITRB   { mc.m_mesh.MeshConvert(); }
     108    T_INITRB   { mc.m_mesh.MeshConvert(); }
    92109  | T_FREERB   { /* TODO */ }
    93110    ;
     
    101118  | T_BGCOLOR COLOR { uint16_t x = (uint16_t)$2;
    102119                      vec4 v(x >> 12, (x >> 8) & 0xf, (x >> 4) & 0xf, x & 0xf);
    103                       mc.m_mesh.SetCurColor(vec4(v) * (1. / 15)); }
     120                      mc.m_mesh.SetCurColor2(vec4(v) * (1. / 15)); }
    104121    ;
    105122
     
    147164
    148165args1: number { $$.f0 = $1; } ;
    149 args2: args1 ',' number { $$ = $1; $$.f1 = $3; } ;
    150 args3: args2 ',' number { $$ = $1; $$.f2 = $3; } ;
    151 args4: args3 ',' number { $$ = $1; $$.f3 = $3; } ;
    152 args5: args4 ',' number { $$ = $1; $$.f4 = $3; } ;
    153 args6: args5 ',' number { $$ = $1; $$.f5 = $3; } ;
    154 args7: args6 ',' number { $$ = $1; $$.f6 = $3; } ;
    155 args8: args7 ',' number { $$ = $1; $$.f7 = $3; } ;
     166args2: args1 number { $$ = $1; $$.f1 = $2; } ;
     167args3: args2 number { $$ = $1; $$.f2 = $2; } ;
     168args4: args3 number { $$ = $1; $$.f3 = $2; } ;
     169args5: args4 number { $$ = $1; $$.f4 = $2; } ;
     170args6: args5 number { $$ = $1; $$.f5 = $2; } ;
     171args7: args6 number { $$ = $1; $$.f6 = $2; } ;
     172args8: args7 number { $$ = $1; $$.f7 = $2; } ;
    156173
    157174number:
  • trunk/orbital/mesh-scanner.l

    r1430 r1434  
    4343%}
    4444
    45 fl    { return token::T_FLUSH; }
    4645irb   { return token::T_INITRB; }
    4746frb   { return token::T_FREERB; }
     
    8988        yylval->fval = atof(yytext); return token::NUMBER; }
    9089-     { return token_type('-'); }
    91 ,     { return token_type(','); }
    92 [.\n] { /* ignore everything else */ }
     90"["   { return token_type('['); }
     91"]"   { return token_type(']'); }
     92.     { /* ignore everything else */ }
     93[\n]  { /* ignore everything else */ }
    9394
    9495%%
  • trunk/orbital/mesh.h

    r1424 r1434  
    2121public:
    2222    Mesh()
    23       : m_color(0), m_color2(0),
    24         m_vert_cursor(0), m_quadidx_cursor(0), m_triidx_cursor(0)
    25     {}
     23      : m_color(0), m_color2(0)
     24    {
     25        m_cursors.Push(0, 0, 0);
     26    }
    2627
    2728    void SendCommand(char const *command);
    2829
    29     void Flush()
    30     {
    31         m_vert_cursor = m_vert.Count();
    32         m_quadidx_cursor = m_quadidx.Count();
    33         m_triidx_cursor = m_triidx.Count();
     30    void OpenBrace()
     31    {
     32        m_cursors.Push(m_vert.Count(), m_quadidx.Count(), m_triidx.Count());
     33    }
     34
     35    void CloseBrace()
     36    {
     37        m_cursors.Pop();
    3438    }
    3539
     
    187191    void SetVertColor(vec4 const &color)
    188192    {
    189         for (int i = m_vert_cursor; i < m_vert.Count(); i++)
     193        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    190194            m_vert[i].m3 = color;
    191195    }
     
    203207    void Translate(vec3 const &v)
    204208    {
    205         for (int i = m_vert_cursor; i < m_vert.Count(); i++)
     209        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    206210            m_vert[i].m1 += v;
    207211    }
     
    214218    {
    215219        mat3 m = mat3::rotate(t, axis);
    216         for (int i = m_vert_cursor; i < m_vert.Count(); i++)
     220        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    217221        {
    218222            m_vert[i].m1 = m * m_vert[i].m1;
     
    224228    {
    225229        /* FIXME: this code breaks normals! */
    226         for (int i = m_vert_cursor; i < m_vert.Count(); i++)
     230        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    227231        {
    228232            m_vert[i].m1.y *= 1.f + (y * m_vert[i].m1.x + xoff);
     
    233237    void TaperY(float x, float z, float yoff)
    234238    {
    235         for (int i = m_vert_cursor; i < m_vert.Count(); i++)
     239        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    236240        {
    237241            m_vert[i].m1.x *= 1.f + (x * m_vert[i].m1.y + yoff);
     
    242246    void TaperZ(float x, float y, float zoff)
    243247    {
    244         for (int i = m_vert_cursor; i < m_vert.Count(); i++)
     248        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    245249        {
    246250            m_vert[i].m1.x *= 1.f + (x * m_vert[i].m1.z + zoff);
     
    253257        vec3 const invs = vec3(1) / s;
    254258
    255         for (int i = m_vert_cursor; i < m_vert.Count(); i++)
     259        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    256260        {
    257261            m_vert[i].m1 *= s;
     
    262266        if (s.x * s.y * s.z < 0)
    263267        {
    264             for (int i = m_quadidx_cursor; i < m_quadidx.Count(); i += 2)
     268            for (int i = m_cursors.Last().m2; i < m_quadidx.Count(); i += 2)
    265269            {
    266270                uint16_t tmp = m_quadidx[i + 0];
     
    269273            }
    270274
    271             for (int i = m_triidx_cursor; i < m_triidx.Count(); i += 3)
     275            for (int i = m_cursors.Last().m3; i < m_triidx.Count(); i += 3)
    272276            {
    273277                uint16_t tmp = m_triidx[i + 0];
     
    278282    }
    279283
    280     void MirrorX() { Duplicate(); Scale(vec3(-1, 1, 1)); }
    281     void MirrorY() { Duplicate(); Scale(vec3(1, -1, 1)); }
    282     void MirrorZ() { Duplicate(); Scale(vec3(1, 1, -1)); }
    283 
    284     void Duplicate()
    285     {
    286         int vlen = m_vert.Count() - m_vert_cursor;
    287         int qlen = m_quadidx.Count() - m_quadidx_cursor;
    288         int tlen = m_triidx.Count() - m_triidx_cursor;
     284    void MirrorX() { DupAndScale(vec3(-1, 1, 1)); }
     285    void MirrorY() { DupAndScale(vec3(1, -1, 1)); }
     286    void MirrorZ() { DupAndScale(vec3(1, 1, -1)); }
     287
     288    void DupAndScale(vec3 const &s)
     289    {
     290        int vlen = m_vert.Count() - m_cursors.Last().m1;
     291        int qlen = m_quadidx.Count() - m_cursors.Last().m2;
     292        int tlen = m_triidx.Count() - m_cursors.Last().m3;
    289293
    290294        for (int i = 0; i < vlen; i++)
    291             m_vert << m_vert[m_vert_cursor++];
     295            m_vert << m_vert[m_cursors.Last().m1++];
    292296
    293297        for (int i = 0; i < qlen; i++)
    294             m_quadidx << m_quadidx[m_quadidx_cursor++] + vlen;
     298            m_quadidx << m_quadidx[m_cursors.Last().m2++] + vlen;
    295299
    296300        for (int i = 0; i < tlen; i++)
    297             m_triidx << m_triidx[m_triidx_cursor++] + vlen;
     301            m_triidx << m_triidx[m_cursors.Last().m3++] + vlen;
     302
     303        Scale(s);
     304
     305        m_cursors.Last().m1 -= vlen;
     306        m_cursors.Last().m2 -= qlen;
     307        m_cursors.Last().m3 -= tlen;
    298308    }
    299309
     
    677687    Array<uint16_t> m_triidx, m_quadidx;
    678688    Array<vec3, vec3, vec4> m_vert;
    679     int m_vert_cursor, m_quadidx_cursor, m_triidx_cursor;
     689    Array<int, int, int> m_cursors;
    680690
    681691    /* FIXME: put this in a separate class so that we can copy meshes. */
  • trunk/orbital/orbital.cpp

    r1423 r1434  
    6363
    6464    /* Grey/red bonus */
    65     m.SendCommand("sc0.6,0.7,0.8,1,afcb7,4,7,0.6,sc1,0,0.3,1,afcb4,7,4,0.6");
    66     m.SendCommand("t-40,20,-30,fl");
     65    m.SendCommand("[sc#9ac afcb7 4 7 0.6 sc#f04 afcb4 7 4 0.6 t-40 20 -30]");
    6766
    6867#if 0
  • trunk/orbital/particlesystem.h

    r1423 r1434  
    1919        m_ready(false)
    2020    {
    21         m_mesh.SendCommand("sc.8,.8,.8,1,acg8,2,5,5,1.5,1.5,.1,0,rx15");
    22         m_mesh.SendCommand("t0,-100,-30,fl");
     21        m_mesh.SendCommand("[sc#ccc acg8 2 5 5 1.5 1.5 .1 0 rx15 t0 -100 -30]");
    2322
    2423        for (int i = 0; i < 200; i++)
  • trunk/orbital/player.h

    r1433 r1434  
    2929        if (type == 0)
    3030        {
    31             m_ship_mesh.SendCommand(color[type]);
    32             m_ship_mesh.SendCommand("afcb3,6,7,.4,t0,0,7,sc1,1,1,1,afcb3,4,4,.4,t4,0,-4,mx,fl");
    33             m_ship_mesh.SendCommand(color[type]);
    34             m_ship_mesh.SendCommand("afcb3,6,5,.4,sc1,1,1,1,afcb2,3,9,.4,fl");
    35             m_ship_mesh.SendCommand("scb1,1,1,1,ac4,15,.2,.6,1,1,tz-2,ac4,15,.2,.6,1,1,rx90,t0,-2,-7,fl");
    36 
    37             m_exhaust_mesh.SendCommand("sc0,1,1,1,scb0,0,0,1,ac5,15,0,1.5,0,1,ac7,35,1.1,4,0,1,rx90,t0,0,27,fl");
     31            /* Ship centre */
     32            m_ship_mesh.SendCommand("[sc#c32 afcb3 6 7 .4 t0 0 7 sc#fff afcb3 4 4 .4 t4 0 -4 mx]");
     33            /* Sides */
     34            m_ship_mesh.SendCommand("[sc#c32 afcb3 6 5 .4 sc#fff afcb2 3 9 .4]");
     35            m_ship_mesh.SendCommand("[sc#fff ac4 15 .2 .6 1 1 tz-2 ac4 15 .2 .6 1 1 rx90 t0 -2 -7]");
     36
     37            m_exhaust_mesh.SendCommand("[sc#0ff scb#000 ac5 15 0 1.5 0 1 ac7 35 1.1 4 0 1 rx90 tz27]");
    3838        }
    3939        //Blue Mesh
    4040        else
    4141        {
    42             m_ship_mesh.SendCommand("sc1,1,1,1,scb1,1,1,1,ac4,15,.2,.6,1,1,t0,0,-4,ac4,1.5,.2,.6,1,1,rx90,t1.3,-2,-6,afcb3,6,5,.4,t0,0,-7");
    43             m_ship_mesh.SendCommand(color[type]);
    44             m_ship_mesh.SendCommand("afcb3,4,7,.4,t4,0,0,mx,fl,afcb3,6,5,.4,sc1,1,1,1,afcb2,3,9,.4");
    45 
    46             m_exhaust_mesh.SendCommand("sc0,1,1,1,scb0,0,0,1,ac5,10,0,1.5,0,1,ac7,25,1.1,4,0,1,rx90,t0,0,19");
     42            /* Sides */
     43            m_ship_mesh.SendCommand("[sc#fff scb#fff ac4 15 .2 .6 1 1 t0 0 -4 ac4 1.5 .2 .6 1 1 rx90 t1.3 -2 -6 afcb3 6 5 .4 t0 0 -7 sc#229 afcb3 4 7 .4 t4 0 0 mx]");
     44            /* Ship centre */
     45            m_ship_mesh.SendCommand("[afcb3 6 5 .4 sc#fff afcb2 3 9 .4]");
     46
     47            m_exhaust_mesh.SendCommand("[sc#0ff scb#000 ac5 10 0 1.5 0 1 ac7 25 1.1 4 0 1 rx90 tz19]");
    4748        }
    4849
    4950        m_option_mesh.SendCommand(color[type]);
    50         m_option_mesh.SendCommand("afcb5,1,3,0.6,fl,sc1,1,1,1,afcb1,5,3,0.6,tz-1,fl");
    51 
    52         m_laser_mesh.SendCommand("sc1,1,1,1,scb0,0,0,1,aq8,1,sx0.25,tx-3,sc1,0,0,1,scb0,0,0,1,aq8,1,tx4,sz50,sx0.3,tz-200,mx,as10,12,8,1,1,fl");
     51        m_option_mesh.SendCommand("[afcb5 1 3 0.6]sc#fff[afcb1 5 3 0.6 tz-1]");
     52
     53        m_laser_mesh.SendCommand("[sc#fff scb#000 aq8 1 sx0.25 tx-3 sc#f00 aq8 1 tx4 sz50 sx0.3 tz-200 mx as10 12 8 1 1]");
    5354
    5455        m_position = vec3(0.f + type * 80.f, 3.5f + 50.f, 0.f);
  • trunk/orbital/snake.h

    r1433 r1434  
    2020        m_ready(false)
    2121    {
    22         m_head.SendCommand("sc#d91,"
    23                            "afcb30,3,3,.8,fl,"
    24                            "sc#cca,"
    25                            "afcb10,10,10,1,fl,"
    26                            "afcb.4,.4,12,.4,tz3,tx8,mx,fl,"
    27                            "afcb.4,.4,12,.4,tz3,tx12,mx,fl,"
    28                            "sc#69c9,"
    29                            "afcb5,8,8,1,ty3,tz3,fl");
     22        m_head.SendCommand("sc#d91"
     23                           "[afcb30 3 3 .8]"
     24                           "sc#cca"
     25                           "[afcb10 10 10 1]"
     26                           "[afcb.4 .4 12 .4 tz3 tx8 mx]"
     27                           "[afcb.4 .4 12 .4 tz3 tx12 mx]"
     28                           "sc#69c9"
     29                           "[afcb5 8 8 1 ty3 tz3]");
    3030
    31         m_body.SendCommand("sc#d91,"
    32                            "afcb3,20,3,.8,afcb20,3,3,.8,fl,"
    33                            "sc#cca,"
    34                            "afcb6,6,12,1,fl,"
    35                            "afcb.4,.4,7,.4,ty8,my,fl,"
    36                            "afcb.4,.4,7,.4,tx8,mx,fl");
     31        m_body.SendCommand("sc#d91"
     32                           "[afcb3 20 3 .8 afcb20 3 3 .8]"
     33                           "sc#cca"
     34                           "[afcb6 6 12 1]"
     35                           "[afcb.4 .4 7 .4 ty8 my]"
     36                           "[afcb.4 .4 7 .4 tx8 mx]");
    3737
    38         m_tail.SendCommand("sc#cca,"
    39                            "afcb6,6,10,1,tz-1,fl,"
    40                            "afcb.4,.4,8,.4,tz-1,ty8,fl,"
    41                            "afcb.4,.4,8,.4,tz-1,ty12,fl,"
    42                            "afcb.4,.4,8,.4,tz-1,tx8,fl,"
    43                            "afcb.4,.4,8,.4,tz-1,tx12,fl,"
    44                            "sc#d91,"
    45                            "afcb3,15,3,.8,ty8,fl,"
    46                            "afcb15,3,3,.8,tx8,fl");
     38        m_tail.SendCommand("sc#cca"
     39                           "[afcb6 6 10 1 tz-1]"
     40                           "[afcb.4 .4 8 .4 tz-1 ty8]"
     41                           "[afcb.4 .4 8 .4 tz-1 ty12]"
     42                           "[afcb.4 .4 8 .4 tz-1 tx8]"
     43                           "[afcb.4 .4 8 .4 tz-1 tx12]"
     44                           "sc#d91"
     45                           "[afcb3 15 3 .8 ty8]"
     46                           "[afcb15 3 3 .8 tx8]");
    4747
    4848        m_position = vec3(RandF(0.f, 100.f), 20.f, RandF(150.f, 250.f));
  • trunk/orbital/starfield.h

    r1423 r1434  
    1919    {
    2020        if (z == 1.f)
    21             m_mesh.SendCommand("sc1,1,1,1,scb1,1,1,0,ad4,1.8,1");
     21            m_mesh.SendCommand("sc#fff scb#fff0 ad4 1.8 1");
    2222        else
    23             m_mesh.SendCommand("sc1,1,1,1,scb1,1,1,0,ad3,0.8,1");
     23            m_mesh.SendCommand("sc#fff scb#fff0 ad3 0.8 1");
    2424
    2525        for (int i = 0; i < count; i++)
  • trunk/orbital/tank.h

    r1433 r1434  
    1919        m_ready(false)
    2020    {
    21         m_body.SendCommand("sc#110,"
    22                            "ab6,6,15,ty-2,"
    23                            "sc#aca,"
    24                            "afcb4,5,16,0.4,tx4,ty5,mx,fl,"
    25                            "sc#3a0,"
    26                            "afcb8,7,10,0.4,tz-4,ty5,fl");
    27         m_turret.SendCommand("sc#3a0,"
    28                              "afcb3,6,10,0.4,tx-8,afcb3,6,10,0.4,tx4,ty13,fl,"
    29                              "sc#aca,"
    30                              "afcb3,6,10,0.4,rx-30,ty13,fl");
     21        m_body.SendCommand("[sc#110 ab6 6 15 ty-2"
     22                           " sc#aca afcb4 5 16 0.4 tx4 ty5 mx]"
     23                           "[sc#3a0 afcb8 7 10 0.4 tz-4 ty5]");
     24        m_turret.SendCommand("[sc#3a0 afcb3 6 10 0.4 tx-8 afcb3 6 10 0.4 tx4 ty13]"
     25                             "[sc#aca afcb3 6 10 0.4 rx-30 ty13]");
    3126
    3227        m_rotation = quat::rotate(RandF(0.f, 360.f), vec3(0, 1, 0));
Note: See TracChangeset for help on using the changeset viewer.