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

orbital: enhance the language with [] contexts.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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
Note: See TracChangeset for help on using the changeset viewer.