Changeset ca1eb1 in git


Ignore:
Timestamp:
May 11, 2011, 2:26:22 PM (13 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'd25190065115c859833252500a64cfb7b11e3a50')
Children:
568cf0845ad03f316fc5a94760ced50ad71135aa
Parents:
121fd948ff7e5bb73a626cab71e2ca71e4f01dd5
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2011-05-11 14:26:22+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:36:03+01:00
Message:
readcf.cc generated again
File:
1 edited

Legend:

Unmodified
Added
Removed
  • factory/readcf.cc

    r121fd9 rca1eb1  
    7979
    8080/* Copy the first part of user declarations.  */
    81 #line 4 "readcf.y"
     81#line 4 "readcf.yy"
    8282
    8383
     
    294294#  if (defined __cplusplus && ! defined _STDLIB_H \
    295295       && ! ((defined YYMALLOC || defined malloc) \
    296              && (defined YYFREE || defined free)))
     296             && (defined YYFREE || defined free)))
    297297#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
    298298#   ifndef _STDLIB_H
     
    320320#if (! defined yyoverflow \
    321321     && (! defined __cplusplus \
    322         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
     322        || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
    323323
    324324/* A type that is properly aligned for any stack member.  */
     
    345345      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
    346346#  else
    347 #   define YYCOPY(To, From, Count)                \
    348       do                                        \
    349         {                                        \
    350           YYSIZE_T yyi;                                \
    351           for (yyi = 0; yyi < (Count); yyi++)        \
    352             (To)[yyi] = (From)[yyi];                \
    353         }                                        \
     347#   define YYCOPY(To, From, Count)              \
     348      do                                        \
     349        {                                       \
     350          YYSIZE_T yyi;                         \
     351          for (yyi = 0; yyi < (Count); yyi++)   \
     352            (To)[yyi] = (From)[yyi];            \
     353        }                                       \
    354354      while (YYID (0))
    355355#  endif
     
    361361   stack.  Advance YYPTR to a properly aligned location for the next
    362362   stack.  */
    363 # define YYSTACK_RELOCATE(Stack)                                        \
    364     do                                                                        \
    365       {                                                                        \
    366         YYSIZE_T yynewbytes;                                                \
    367         YYCOPY (&yyptr->Stack, Stack, yysize);                                \
    368         Stack = &yyptr->Stack;                                                \
    369         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
    370         yyptr += yynewbytes / sizeof (*yyptr);                                \
    371       }                                                                        \
     363# define YYSTACK_RELOCATE(Stack)                                        \
     364    do                                                                  \
     365      {                                                                 \
     366        YYSIZE_T yynewbytes;                                            \
     367        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
     368        Stack = &yyptr->Stack;                                          \
     369        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
     370        yyptr += yynewbytes / sizeof (*yyptr);                          \
     371      }                                                                 \
    372372    while (YYID (0))
    373373
     
    392392#define YYMAXUTOK   259
    393393
    394 #define YYTRANSLATE(YYX)                                                \
     394#define YYTRANSLATE(YYX)                                                \
    395395  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
    396396
     
    551551};
    552552
    553 #define yyerrok                (yyerrstatus = 0)
    554 #define yyclearin        (yychar = YYEMPTY)
    555 #define YYEMPTY                (-2)
    556 #define YYEOF                0
    557 
    558 #define YYACCEPT        goto yyacceptlab
    559 #define YYABORT                goto yyabortlab
    560 #define YYERROR                goto yyerrorlab
     553#define yyerrok         (yyerrstatus = 0)
     554#define yyclearin       (yychar = YYEMPTY)
     555#define YYEMPTY         (-2)
     556#define YYEOF           0
     557
     558#define YYACCEPT        goto yyacceptlab
     559#define YYABORT         goto yyabortlab
     560#define YYERROR         goto yyerrorlab
    561561
    562562
     
    565565   Once GCC version 2 has supplanted version 1, this can go.  */
    566566
    567 #define YYFAIL                goto yyerrlab
     567#define YYFAIL          goto yyerrlab
    568568
    569569#define YYRECOVERING()  (!!yyerrstatus)
    570570
    571 #define YYBACKUP(Token, Value)                                        \
    572 do                                                                \
    573   if (yychar == YYEMPTY && yylen == 1)                                \
    574     {                                                                \
    575       yychar = (Token);                                                \
    576       yylval = (Value);                                                \
    577       yytoken = YYTRANSLATE (yychar);                                \
    578       YYPOPSTACK (1);                                                \
    579       goto yybackup;                                                \
    580     }                                                                \
    581   else                                                                \
    582     {                                                                \
     571#define YYBACKUP(Token, Value)                                  \
     572do                                                              \
     573  if (yychar == YYEMPTY && yylen == 1)                          \
     574    {                                                           \
     575      yychar = (Token);                                         \
     576      yylval = (Value);                                         \
     577      yytoken = YYTRANSLATE (yychar);                           \
     578      YYPOPSTACK (1);                                           \
     579      goto yybackup;                                            \
     580    }                                                           \
     581  else                                                          \
     582    {                                                           \
    583583      yyerror (YY_("syntax error: cannot back up")); \
    584       YYERROR;                                                        \
    585     }                                                                \
     584      YYERROR;                                                  \
     585    }                                                           \
    586586while (YYID (0))
    587587
    588588
    589 #define YYTERROR        1
    590 #define YYERRCODE        256
     589#define YYTERROR        1
     590#define YYERRCODE       256
    591591
    592592
     
    597597#define YYRHSLOC(Rhs, K) ((Rhs)[K])
    598598#ifndef YYLLOC_DEFAULT
    599 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
    600     do                                                                        \
     599# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
     600    do                                                                  \
    601601      if (YYID (N))                                                    \
    602         {                                                                \
    603           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
    604           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;        \
    605           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;                \
    606           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;        \
    607         }                                                                \
    608       else                                                                \
    609         {                                                                \
    610           (Current).first_line   = (Current).last_line   =                \
    611             YYRHSLOC (Rhs, 0).last_line;                                \
    612           (Current).first_column = (Current).last_column =                \
    613             YYRHSLOC (Rhs, 0).last_column;                                \
    614         }                                                                \
     602        {                                                               \
     603          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
     604          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
     605          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
     606          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
     607        }                                                               \
     608      else                                                              \
     609        {                                                               \
     610          (Current).first_line   = (Current).last_line   =              \
     611            YYRHSLOC (Rhs, 0).last_line;                                \
     612          (Current).first_column = (Current).last_column =              \
     613            YYRHSLOC (Rhs, 0).last_column;                              \
     614        }                                                               \
    615615    while (YYID (0))
    616616#endif
     
    623623#ifndef YY_LOCATION_PRINT
    624624# if YYLTYPE_IS_TRIVIAL
    625 #  define YY_LOCATION_PRINT(File, Loc)                        \
    626      fprintf (File, "%d.%d-%d.%d",                        \
    627               (Loc).first_line, (Loc).first_column,        \
    628               (Loc).last_line,  (Loc).last_column)
     625#  define YY_LOCATION_PRINT(File, Loc)                  \
     626     fprintf (File, "%d.%d-%d.%d",                      \
     627              (Loc).first_line, (Loc).first_column,     \
     628              (Loc).last_line,  (Loc).last_column)
    629629# else
    630630#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
     
    649649# endif
    650650
    651 # define YYDPRINTF(Args)                        \
    652 do {                                                \
    653   if (yydebug)                                        \
    654     YYFPRINTF Args;                                \
     651# define YYDPRINTF(Args)                        \
     652do {                                            \
     653  if (yydebug)                                  \
     654    YYFPRINTF Args;                             \
    655655} while (YYID (0))
    656656
    657 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                          \
    658 do {                                                                          \
    659   if (yydebug)                                                                  \
    660     {                                                                          \
    661       YYFPRINTF (stderr, "%s ", Title);                                          \
    662       yy_symbol_print (stderr,                                                  \
    663                   Type, Value); \
    664       YYFPRINTF (stderr, "\n");                                                  \
    665     }                                                                          \
     657# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
     658do {                                                                      \
     659  if (yydebug)                                                            \
     660    {                                                                     \
     661      YYFPRINTF (stderr, "%s ", Title);                                   \
     662      yy_symbol_print (stderr,                                            \
     663                  Type, Value); \
     664      YYFPRINTF (stderr, "\n");                                           \
     665    }                                                                     \
    666666} while (YYID (0))
    667667
     
    695695    {
    696696      default:
    697         break;
     697        break;
    698698    }
    699699}
     
    747747}
    748748
    749 # define YY_STACK_PRINT(Bottom, Top)                                \
    750 do {                                                                \
    751   if (yydebug)                                                        \
    752     yy_stack_print ((Bottom), (Top));                                \
     749# define YY_STACK_PRINT(Bottom, Top)                            \
     750do {                                                            \
     751  if (yydebug)                                                  \
     752    yy_stack_print ((Bottom), (Top));                           \
    753753} while (YYID (0))
    754754
     
    773773  unsigned long int yylno = yyrline[yyrule];
    774774  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
    775              yyrule - 1, yylno);
     775             yyrule - 1, yylno);
    776776  /* The symbols being reduced.  */
    777777  for (yyi = 0; yyi < yynrhs; yyi++)
     
    779779      fprintf (stderr, "   $%d = ", yyi + 1);
    780780      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
    781                        &(yyvsp[(yyi + 1) - (yynrhs)])
    782                                               );
     781                       &(yyvsp[(yyi + 1) - (yynrhs)])
     782                                       );
    783783      fprintf (stderr, "\n");
    784784    }
    785785}
    786786
    787 # define YY_REDUCE_PRINT(Rule)                \
    788 do {                                        \
    789   if (yydebug)                                \
     787# define YY_REDUCE_PRINT(Rule)          \
     788do {                                    \
     789  if (yydebug)                          \
    790790    yy_reduce_print (yyvsp, Rule); \
    791791} while (YYID (0))
     
    803803
    804804/* YYINITDEPTH -- initial size of the parser's stacks.  */
    805 #ifndef        YYINITDEPTH
     805#ifndef YYINITDEPTH
    806806# define YYINITDEPTH 200
    807807#endif
     
    891891
    892892      for (;;)
    893         switch (*++yyp)
    894           {
    895           case '\'':
    896           case ',':
    897             goto do_not_strip_quotes;
    898 
    899           case '\\':
    900             if (*++yyp != '\\')
    901               goto do_not_strip_quotes;
    902             /* Fall through.  */
    903           default:
    904             if (yyres)
    905               yyres[yyn] = *yyp;
    906             yyn++;
    907             break;
    908 
    909           case '"':
    910             if (yyres)
    911               yyres[yyn] = '\0';
    912             return yyn;
    913           }
     893        switch (*++yyp)
     894          {
     895          case '\'':
     896          case ',':
     897            goto do_not_strip_quotes;
     898
     899          case '\\':
     900            if (*++yyp != '\\')
     901              goto do_not_strip_quotes;
     902            /* Fall through.  */
     903          default:
     904            if (yyres)
     905              yyres[yyn] = *yyp;
     906            yyn++;
     907            break;
     908
     909          case '"':
     910            if (yyres)
     911              yyres[yyn] = '\0';
     912            return yyn;
     913          }
    914914    do_not_strip_quotes: ;
    915915    }
     
    949949# if 0
    950950      /* This is so xgettext sees the translatable formats that are
    951         constructed on the fly.  */
     951        constructed on the fly.  */
    952952      YY_("syntax error, unexpected %s");
    953953      YY_("syntax error, unexpected %s, expecting %s");
     
    962962      static char const yyor[] = " or %s";
    963963      char yyformat[sizeof yyunexpected
    964                     + sizeof yyexpecting - 1
    965                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
    966                        * (sizeof yyor - 1))];
     964                    + sizeof yyexpecting - 1
     965                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
     966                       * (sizeof yyor - 1))];
    967967      char const *yyprefix = yyexpecting;
    968968
    969969      /* Start YYX at -YYN if negative to avoid negative indexes in
    970         YYCHECK.  */
     970        YYCHECK.  */
    971971      int yyxbegin = yyn < 0 ? -yyn : 0;
    972972
     
    980980
    981981      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
    982         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
    983           {
    984             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
    985               {
    986                 yycount = 1;
    987                 yysize = yysize0;
    988                 yyformat[sizeof yyunexpected - 1] = '\0';
    989                 break;
    990               }
    991             yyarg[yycount++] = yytname[yyx];
    992             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
    993             yysize_overflow |= (yysize1 < yysize);
    994             yysize = yysize1;
    995             yyfmt = yystpcpy (yyfmt, yyprefix);
    996             yyprefix = yyor;
    997           }
     982        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
     983          {
     984            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
     985              {
     986                yycount = 1;
     987                yysize = yysize0;
     988                yyformat[sizeof yyunexpected - 1] = '\0';
     989                break;
     990              }
     991            yyarg[yycount++] = yytname[yyx];
     992            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
     993            yysize_overflow |= (yysize1 < yysize);
     994            yysize = yysize1;
     995            yyfmt = yystpcpy (yyfmt, yyprefix);
     996            yyprefix = yyor;
     997          }
    998998
    999999      yyf = YY_(yyformat);
     
    10031003
    10041004      if (yysize_overflow)
    1005         return YYSIZE_MAXIMUM;
     1005        return YYSIZE_MAXIMUM;
    10061006
    10071007      if (yyresult)
    1008         {
    1009           /* Avoid sprintf, as that infringes on the user's name space.
    1010              Don't have undefined behavior even if the translation
    1011              produced a string with the wrong number of "%s"s.  */
    1012           char *yyp = yyresult;
    1013           int yyi = 0;
    1014           while ((*yyp = *yyf) != '\0')
    1015             {
    1016               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
    1017                 {
    1018                   yyp += yytnamerr (yyp, yyarg[yyi++]);
    1019                   yyf += 2;
    1020                 }
    1021               else
    1022                 {
    1023                   yyp++;
    1024                   yyf++;
    1025                 }
    1026             }
    1027         }
     1008        {
     1009          /* Avoid sprintf, as that infringes on the user's name space.
     1010             Don't have undefined behavior even if the translation
     1011             produced a string with the wrong number of "%s"s.  */
     1012          char *yyp = yyresult;
     1013          int yyi = 0;
     1014          while ((*yyp = *yyf) != '\0')
     1015            {
     1016              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
     1017                {
     1018                  yyp += yytnamerr (yyp, yyarg[yyi++]);
     1019                  yyf += 2;
     1020                }
     1021              else
     1022                {
     1023                  yyp++;
     1024                  yyf++;
     1025                }
     1026            }
     1027        }
    10281028      return yysize;
    10291029    }
     
    10601060
    10611061      default:
    1062         break;
     1062        break;
    10631063    }
    10641064}
     
    11211121#endif
    11221122{
    1123 
     1123 
    11241124  int yystate;
    11251125  int yyn;
     
    11741174  yyerrstatus = 0;
    11751175  yynerrs = 0;
    1176   yychar = YYEMPTY;/* Cause a token to be read.  */
     1176  yychar = YYEMPTY;             /* Cause a token to be read.  */
    11771177
    11781178  /* Initialize stack pointers.
     
    12041204#ifdef yyoverflow
    12051205      {
    1206         /* Give user a chance to reallocate the stack.  Use copies of
    1207            these so that the &'s don't force the real ones into
    1208            memory.  */
    1209         YYSTYPE *yyvs1 = yyvs;
    1210         yytype_int16 *yyss1 = yyss;
    1211 
    1212 
    1213         /* Each stack pointer address is followed by the size of the
    1214            data in use in that stack, in bytes.  This used to be a
    1215            conditional around just the two extra args, but that might
    1216            be undefined if yyoverflow is a macro.  */
    1217         yyoverflow (YY_("memory exhausted"),
    1218                     &yyss1, yysize * sizeof (*yyssp),
    1219                     &yyvs1, yysize * sizeof (*yyvsp),
    1220 
    1221                     &yystacksize);
    1222 
    1223         yyss = yyss1;
    1224         yyvs = yyvs1;
     1206        /* Give user a chance to reallocate the stack.  Use copies of
     1207           these so that the &'s don't force the real ones into
     1208           memory.  */
     1209        YYSTYPE *yyvs1 = yyvs;
     1210        yytype_int16 *yyss1 = yyss;
     1211
     1212
     1213        /* Each stack pointer address is followed by the size of the
     1214           data in use in that stack, in bytes.  This used to be a
     1215           conditional around just the two extra args, but that might
     1216           be undefined if yyoverflow is a macro.  */
     1217        yyoverflow (YY_("memory exhausted"),
     1218                    &yyss1, yysize * sizeof (*yyssp),
     1219                    &yyvs1, yysize * sizeof (*yyvsp),
     1220
     1221                    &yystacksize);
     1222
     1223        yyss = yyss1;
     1224        yyvs = yyvs1;
    12251225      }
    12261226#else /* no yyoverflow */
     
    12301230      /* Extend the stack our own way.  */
    12311231      if (YYMAXDEPTH <= yystacksize)
    1232         goto yyexhaustedlab;
     1232        goto yyexhaustedlab;
    12331233      yystacksize *= 2;
    12341234      if (YYMAXDEPTH < yystacksize)
    1235         yystacksize = YYMAXDEPTH;
     1235        yystacksize = YYMAXDEPTH;
    12361236
    12371237      {
    1238         yytype_int16 *yyss1 = yyss;
    1239         union yyalloc *yyptr =
    1240           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
    1241         if (! yyptr)
    1242           goto yyexhaustedlab;
    1243         YYSTACK_RELOCATE (yyss);
    1244         YYSTACK_RELOCATE (yyvs);
     1238        yytype_int16 *yyss1 = yyss;
     1239        union yyalloc *yyptr =
     1240          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
     1241        if (! yyptr)
     1242          goto yyexhaustedlab;
     1243        YYSTACK_RELOCATE (yyss);
     1244        YYSTACK_RELOCATE (yyvs);
    12451245
    12461246#  undef YYSTACK_RELOCATE
    1247         if (yyss1 != yyssa)
    1248           YYSTACK_FREE (yyss1);
     1247        if (yyss1 != yyssa)
     1248          YYSTACK_FREE (yyss1);
    12491249      }
    12501250# endif
     
    12561256
    12571257      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
    1258                   (unsigned long int) yystacksize));
     1258                  (unsigned long int) yystacksize));
    12591259
    12601260      if (yyss + yystacksize - 1 <= yyssp)
    1261         YYABORT;
     1261        YYABORT;
    12621262    }
    12631263
     
    13081308    {
    13091309      if (yyn == 0 || yyn == YYTABLE_NINF)
    1310         goto yyerrlab;
     1310        goto yyerrlab;
    13111311      yyn = -yyn;
    13121312      goto yyreduce;
     
    13661366    {
    13671367        case 5:
    1368 #line 71 "readcf.y"
    1369     { *retvalue = (yyvsp[(1) - (2)]).getval(); return 0; ;}
     1368#line 71 "readcf.yy"
     1369    { *retvalue = (yyvsp[(1) - (2)]).getval(); return 0; }
    13701370    break;
    13711371
    13721372  case 6:
    1373 #line 74 "readcf.y"
    1374     { (yyval) = (yyvsp[(1) - (1)]); ;}
     1373#line 74 "readcf.yy"
     1374    { (yyval) = (yyvsp[(1) - (1)]); }
    13751375    break;
    13761376
    13771377  case 7:
    1378 #line 75 "readcf.y"
    1379     { (yyval) = (yyvsp[(1) - (3)]).getval() + (yyvsp[(3) - (3)]).getval(); ;}
     1378#line 75 "readcf.yy"
     1379    { (yyval) = (yyvsp[(1) - (3)]).getval() + (yyvsp[(3) - (3)]).getval(); }
    13801380    break;
    13811381
    13821382  case 8:
    1383 #line 76 "readcf.y"
    1384     { (yyval) = (yyvsp[(1) - (3)]).getval() - (yyvsp[(3) - (3)]).getval(); ;}
     1383#line 76 "readcf.yy"
     1384    { (yyval) = (yyvsp[(1) - (3)]).getval() - (yyvsp[(3) - (3)]).getval(); }
    13851385    break;
    13861386
    13871387  case 9:
    1388 #line 77 "readcf.y"
    1389     { (yyval) = (yyvsp[(1) - (3)]).getval() * (yyvsp[(3) - (3)]).getval(); ;}
     1388#line 77 "readcf.yy"
     1389    { (yyval) = (yyvsp[(1) - (3)]).getval() * (yyvsp[(3) - (3)]).getval(); }
    13901390    break;
    13911391
    13921392  case 10:
    1393 #line 78 "readcf.y"
    1394     { (yyval) = (yyvsp[(1) - (3)]).getval() / (yyvsp[(3) - (3)]).getval(); ;}
     1393#line 78 "readcf.yy"
     1394    { (yyval) = (yyvsp[(1) - (3)]).getval() / (yyvsp[(3) - (3)]).getval(); }
    13951395    break;
    13961396
    13971397  case 11:
    1398 #line 79 "readcf.y"
    1399     { (yyval) = -(yyvsp[(2) - (2)]).getval(); ;}
     1398#line 79 "readcf.yy"
     1399    { (yyval) = -(yyvsp[(2) - (2)]).getval(); }
    14001400    break;
    14011401
    14021402  case 12:
    1403 #line 80 "readcf.y"
    1404     { (yyval) = (yyvsp[(2) - (2)]).getval(); ;}
     1403#line 80 "readcf.yy"
     1404    { (yyval) = (yyvsp[(2) - (2)]).getval(); }
    14051405    break;
    14061406
    14071407  case 13:
    1408 #line 81 "readcf.y"
    1409     { (yyval) = power( (yyvsp[(1) - (3)]).getval(), (yyvsp[(3) - (3)]).getintval() ); ;}
     1408#line 81 "readcf.yy"
     1409    { (yyval) = power( (yyvsp[(1) - (3)]).getval(), (yyvsp[(3) - (3)]).getintval() ); }
    14101410    break;
    14111411
    14121412  case 14:
    1413 #line 82 "readcf.y"
    1414     { (yyval) = (yyvsp[(2) - (3)]).getval(); ;}
     1413#line 82 "readcf.yy"
     1414    { (yyval) = (yyvsp[(2) - (3)]).getval(); }
    14151415    break;
    14161416
     
    14561456#else
    14571457      {
    1458         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
    1459         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
    1460           {
    1461             YYSIZE_T yyalloc = 2 * yysize;
    1462             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
    1463               yyalloc = YYSTACK_ALLOC_MAXIMUM;
    1464             if (yymsg != yymsgbuf)
    1465               YYSTACK_FREE (yymsg);
    1466             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
    1467             if (yymsg)
    1468               yymsg_alloc = yyalloc;
    1469             else
    1470               {
    1471                 yymsg = yymsgbuf;
    1472                 yymsg_alloc = sizeof yymsgbuf;
    1473               }
    1474           }
    1475 
    1476         if (0 < yysize && yysize <= yymsg_alloc)
    1477           {
    1478             (void) yysyntax_error (yymsg, yystate, yychar);
    1479             yyerror (yymsg);
    1480           }
    1481         else
    1482           {
    1483             yyerror (YY_("syntax error"));
    1484             if (yysize != 0)
    1485               goto yyexhaustedlab;
    1486           }
     1458        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
     1459        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
     1460          {
     1461            YYSIZE_T yyalloc = 2 * yysize;
     1462            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
     1463              yyalloc = YYSTACK_ALLOC_MAXIMUM;
     1464            if (yymsg != yymsgbuf)
     1465              YYSTACK_FREE (yymsg);
     1466            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
     1467            if (yymsg)
     1468              yymsg_alloc = yyalloc;
     1469            else
     1470              {
     1471                yymsg = yymsgbuf;
     1472                yymsg_alloc = sizeof yymsgbuf;
     1473              }
     1474          }
     1475
     1476        if (0 < yysize && yysize <= yymsg_alloc)
     1477          {
     1478            (void) yysyntax_error (yymsg, yystate, yychar);
     1479            yyerror (yymsg);
     1480          }
     1481        else
     1482          {
     1483            yyerror (YY_("syntax error"));
     1484            if (yysize != 0)
     1485              goto yyexhaustedlab;
     1486          }
    14871487      }
    14881488#endif
     
    14941494    {
    14951495      /* If just tried and failed to reuse look-ahead token after an
    1496         error, discard it.  */
     1496        error, discard it.  */
    14971497
    14981498      if (yychar <= YYEOF)
    1499         {
    1500           /* Return failure if at end of input.  */
    1501           if (yychar == YYEOF)
    1502             YYABORT;
    1503         }
     1499        {
     1500          /* Return failure if at end of input.  */
     1501          if (yychar == YYEOF)
     1502            YYABORT;
     1503        }
    15041504      else
    1505         {
    1506           yydestruct ("Error: discarding",
    1507                       yytoken, &yylval);
    1508           yychar = YYEMPTY;
    1509         }
     1505        {
     1506          yydestruct ("Error: discarding",
     1507                      yytoken, &yylval);
     1508          yychar = YYEMPTY;
     1509        }
    15101510    }
    15111511
     
    15391539`-------------------------------------------------------------*/
    15401540yyerrlab1:
    1541   yyerrstatus = 3;        /* Each real token shifted decrements this.  */
     1541  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
    15421542
    15431543  for (;;)
     
    15451545      yyn = yypact[yystate];
    15461546      if (yyn != YYPACT_NINF)
    1547         {
    1548           yyn += YYTERROR;
    1549           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
    1550             {
    1551               yyn = yytable[yyn];
    1552               if (0 < yyn)
    1553                 break;
    1554             }
    1555         }
     1547        {
     1548          yyn += YYTERROR;
     1549          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
     1550            {
     1551              yyn = yytable[yyn];
     1552              if (0 < yyn)
     1553                break;
     1554            }
     1555        }
    15561556
    15571557      /* Pop the current state because it cannot handle the error token.  */
    15581558      if (yyssp == yyss)
    1559         YYABORT;
     1559        YYABORT;
    15601560
    15611561
    15621562      yydestruct ("Error: popping",
    1563                   yystos[yystate], yyvsp);
     1563                  yystos[yystate], yyvsp);
    15641564      YYPOPSTACK (1);
    15651565      yystate = *yyssp;
     
    16071607  if (yychar != YYEOF && yychar != YYEMPTY)
    16081608     yydestruct ("Cleanup: discarding lookahead",
    1609                 yytoken, &yylval);
     1609                yytoken, &yylval);
    16101610  /* Do not reclaim the symbols of the rule which action triggered
    16111611     this YYABORT or YYACCEPT.  */
     
    16151615    {
    16161616      yydestruct ("Cleanup: popping",
    1617                   yystos[*yyssp], yyvsp);
     1617                  yystos[*yyssp], yyvsp);
    16181618      YYPOPSTACK (1);
    16191619    }
     
    16311631
    16321632
    1633 #line 85 "readcf.y"
     1633#line 85 "readcf.yy"
    16341634
    16351635
Note: See TracChangeset for help on using the changeset viewer.