LTP GCOV extension - code coverage report
Current view: directory - usr/share/bison - bison.simple
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 89
Code covered: 92.1 % Executed lines: 82

       1                 : /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
       2                 : #line
       3                 : /* Skeleton output parser for bison,
       4                 : 
       5                 :    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
       6                 :    Foundation, Inc.
       7                 : 
       8                 :    This program is free software; you can redistribute it and/or modify
       9                 :    it under the terms of the GNU General Public License as published by
      10                 :    the Free Software Foundation; either version 2, or (at your option)
      11                 :    any later version.
      12                 : 
      13                 :    This program is distributed in the hope that it will be useful,
      14                 :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :    GNU General Public License for more details.
      17                 : 
      18                 :    You should have received a copy of the GNU General Public License
      19                 :    along with this program; if not, write to the Free Software
      20                 :    Foundation, Inc., 59 Temple Place - Suite 330,
      21                 :    Boston, MA 02111-1307, USA.  */
      22                 : 
      23                 : /* As a special exception, when this file is copied by Bison into a
      24                 :    Bison output file, you may use that output file without restriction.
      25                 :    This special exception was added by the Free Software Foundation
      26                 :    in version 1.24 of Bison.  */
      27                 : 
      28                 : /* This is the parser code that is written into each bison parser when
      29                 :    the %semantic_parser declaration is not specified in the grammar.
      30                 :    It was written by Richard Stallman by simplifying the hairy parser
      31                 :    used when %semantic_parser is specified.  */
      32                 : 
      33                 : /* All symbols defined below should begin with yy or YY, to avoid
      34                 :    infringing on user name space.  This should be done even for local
      35                 :    variables, as they might otherwise be expanded by user macros.
      36                 :    There are some unavoidable exceptions within include files to
      37                 :    define necessary library symbols; they are noted "INFRINGES ON
      38                 :    USER NAME SPACE" below.  */
      39                 : 
      40                 : #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
      41                 : 
      42                 : /* The parser invokes alloca or malloc; define the necessary symbols.  */
      43                 : 
      44                 : # if YYSTACK_USE_ALLOCA
      45                 : #  define YYSTACK_ALLOC alloca
      46                 : # else
      47                 : #  ifndef YYSTACK_USE_ALLOCA
      48                 : #   if defined (alloca) || defined (_ALLOCA_H)
      49                 : #    define YYSTACK_ALLOC alloca
      50                 : #   else
      51                 : #    ifdef __GNUC__
      52                 : #     define YYSTACK_ALLOC __builtin_alloca
      53                 : #    endif
      54                 : #   endif
      55                 : #  endif
      56                 : # endif
      57                 : 
      58                 : # ifdef YYSTACK_ALLOC
      59                 :    /* Pacify GCC's `empty if-body' warning. */
      60                 : #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
      61                 : # else
      62                 : #  if defined (__STDC__) || defined (__cplusplus)
      63                 : #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
      64                 : #   define YYSIZE_T size_t
      65                 : #  endif
      66                 : #  define YYSTACK_ALLOC malloc
      67                 : #  define YYSTACK_FREE free
      68                 : # endif
      69                 : #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
      70                 : 
      71                 : 
      72                 : #if (! defined (yyoverflow) \
      73                 :      && (! defined (__cplusplus) \
      74                 :          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
      75                 : 
      76                 : /* A type that is properly aligned for any stack member.  */
      77                 : union yyalloc
      78                 : {
      79                 :   short yyss;
      80                 :   YYSTYPE yyvs;
      81                 : # if YYLSP_NEEDED
      82                 :   YYLTYPE yyls;
      83                 : # endif
      84                 : };
      85                 : 
      86                 : /* The size of the maximum gap between one aligned stack and the next.  */
      87                 : # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
      88                 : 
      89                 : /* The size of an array large to enough to hold all stacks, each with
      90                 :    N elements.  */
      91                 : # if YYLSP_NEEDED
      92                 : #  define YYSTACK_BYTES(N) \
      93                 :      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
      94                 :       + 2 * YYSTACK_GAP_MAX)
      95                 : # else
      96                 : #  define YYSTACK_BYTES(N) \
      97                 :      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
      98                 :       + YYSTACK_GAP_MAX)
      99                 : # endif
     100                 : 
     101                 : /* Copy COUNT objects from FROM to TO.  The source and destination do
     102                 :    not overlap.  */
     103                 : # ifndef YYCOPY
     104                 : #  if 1 < __GNUC__
     105                 : #   define YYCOPY(To, From, Count) \
     106                 :       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
     107                 : #  else
     108                 : #   define YYCOPY(To, From, Count)              \
     109                 :       do                                        \
     110                 :         {                                       \
     111                 :           register YYSIZE_T yyi;                \
     112                 :           for (yyi = 0; yyi < (Count); yyi++)        \
     113                 :             (To)[yyi] = (From)[yyi];            \
     114                 :         }                                       \
     115                 :       while (0)
     116                 : #  endif
     117                 : # endif
     118                 : 
     119                 : /* Relocate STACK from its old location to the new one.  The
     120                 :    local variables YYSIZE and YYSTACKSIZE give the old and new number of
     121                 :    elements in the stack, and YYPTR gives the new location of the
     122                 :    stack.  Advance YYPTR to a properly aligned location for the next
     123                 :    stack.  */
     124                 : # define YYSTACK_RELOCATE(Stack)                                        \
     125                 :     do                                                                  \
     126                 :       {                                                                 \
     127                 :         YYSIZE_T yynewbytes;                                            \
     128                 :         YYCOPY (&yyptr->Stack, Stack, yysize);                           \
     129                 :         Stack = &yyptr->Stack;                                           \
     130                 :         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
     131                 :         yyptr += yynewbytes / sizeof (*yyptr);                          \
     132                 :       }                                                                 \
     133                 :     while (0)
     134                 : 
     135                 : #endif
     136                 : 
     137                 : 
     138                 : #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
     139                 : # define YYSIZE_T __SIZE_TYPE__
     140                 : #endif
     141                 : #if ! defined (YYSIZE_T) && defined (size_t)
     142                 : # define YYSIZE_T size_t
     143                 : #endif
     144                 : #if ! defined (YYSIZE_T)
     145                 : # if defined (__STDC__) || defined (__cplusplus)
     146                 : #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
     147                 : #  define YYSIZE_T size_t
     148                 : # endif
     149                 : #endif
     150                 : #if ! defined (YYSIZE_T)
     151                 : # define YYSIZE_T unsigned int
     152                 : #endif
     153                 : 
     154                 : #define yyerrok         (yyerrstatus = 0)
     155                 : #define yyclearin       (yychar = YYEMPTY)
     156                 : #define YYEMPTY         -2
     157                 : #define YYEOF           0
     158                 : #define YYACCEPT        goto yyacceptlab
     159                 : #define YYABORT         goto yyabortlab
     160                 : #define YYERROR         goto yyerrlab1
     161                 : /* Like YYERROR except do call yyerror.  This remains here temporarily
     162                 :    to ease the transition to the new meaning of YYERROR, for GCC.
     163                 :    Once GCC version 2 has supplanted version 1, this can go.  */
     164                 : #define YYFAIL          goto yyerrlab
     165                 : #define YYRECOVERING()  (!!yyerrstatus)
     166                 : #define YYBACKUP(Token, Value)                                  \
     167                 : do                                                              \
     168                 :   if (yychar == YYEMPTY && yylen == 1)                          \
     169                 :     {                                                           \
     170                 :       yychar = (Token);                                         \
     171                 :       yylval = (Value);                                         \
     172                 :       yychar1 = YYTRANSLATE (yychar);                           \
     173                 :       YYPOPSTACK;                                               \
     174                 :       goto yybackup;                                            \
     175                 :     }                                                           \
     176                 :   else                                                          \
     177                 :     {                                                           \
     178                 :       yyerror ("syntax error: cannot back up");                       \
     179                 :       YYERROR;                                                  \
     180                 :     }                                                           \
     181                 : while (0)
     182                 : 
     183                 : #define YYTERROR        1
     184                 : #define YYERRCODE       256
     185                 : 
     186                 : 
     187                 : /* YYLLOC_DEFAULT -- Compute the default location (before the actions
     188                 :    are run).
     189                 : 
     190                 :    When YYLLOC_DEFAULT is run, CURRENT is set the location of the
     191                 :    first token.  By default, to implement support for ranges, extend
     192                 :    its range to the last symbol.  */
     193                 : 
     194                 : #ifndef YYLLOC_DEFAULT
     195                 : # define YYLLOC_DEFAULT(Current, Rhs, N)        \
     196                 :    Current.last_line   = Rhs[N].last_line;      \
     197                 :    Current.last_column = Rhs[N].last_column;
     198                 : #endif
     199                 : 
     200                 : 
     201                 : /* YYLEX -- calling `yylex' with the right arguments.  */
     202                 : 
     203                 : #if YYPURE
     204                 : # if YYLSP_NEEDED
     205                 : #  ifdef YYLEX_PARAM
     206                 : #   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
     207                 : #  else
     208                 : #   define YYLEX                yylex (&yylval, &yylloc)
     209                 : #  endif
     210                 : # else /* !YYLSP_NEEDED */
     211                 : #  ifdef YYLEX_PARAM
     212                 : #   define YYLEX                yylex (&yylval, YYLEX_PARAM)
     213                 : #  else
     214                 : #   define YYLEX                yylex (&yylval)
     215                 : #  endif
     216                 : # endif /* !YYLSP_NEEDED */
     217                 : #else /* !YYPURE */
     218                 : # define YYLEX                  yylex ()
     219                 : #endif /* !YYPURE */
     220                 : 
     221                 : 
     222                 : /* Enable debugging if requested.  */
     223                 : #if YYDEBUG
     224                 : 
     225                 : # ifndef YYFPRINTF
     226                 : #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
     227                 : #  define YYFPRINTF fprintf
     228                 : # endif
     229                 : 
     230                 : # define YYDPRINTF(Args)                        \
     231                 : do {                                            \
     232                 :   if (yydebug)                                  \
     233                 :     YYFPRINTF Args;                             \
     234                 : } while (0)
     235                 : /* Nonzero means print parse trace.  It is left uninitialized so that
     236                 :    multiple parsers can coexist.  */
     237                 : int yydebug;
     238                 : #else /* !YYDEBUG */
     239                 : # define YYDPRINTF(Args)
     240                 : #endif /* !YYDEBUG */
     241                 : 
     242                 : /* YYINITDEPTH -- initial size of the parser's stacks.  */
     243                 : #ifndef YYINITDEPTH
     244                 : # define YYINITDEPTH 200
     245                 : #endif
     246                 : 
     247                 : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
     248                 :    if the built-in stack extension method is used).
     249                 : 
     250                 :    Do not make this value too large; the results are undefined if
     251                 :    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
     252                 :    evaluated with infinite-precision integer arithmetic.  */
     253                 : 
     254                 : #if YYMAXDEPTH == 0
     255                 : # undef YYMAXDEPTH
     256                 : #endif
     257                 : 
     258                 : #ifndef YYMAXDEPTH
     259                 : # define YYMAXDEPTH 10000
     260                 : #endif
     261                 : 
     262                 : #ifdef YYERROR_VERBOSE
     263                 : 
     264                 : # ifndef yystrlen
     265                 : #  if defined (__GLIBC__) && defined (_STRING_H)
     266                 : #   define yystrlen strlen
     267                 : #  else
     268                 : /* Return the length of YYSTR.  */
     269                 : static YYSIZE_T
     270                 : #   if defined (__STDC__) || defined (__cplusplus)
     271                 : yystrlen (const char *yystr)
     272                 : #   else
     273                 : yystrlen (yystr)
     274                 :      const char *yystr;
     275                 : #   endif
     276                 : {
     277                 :   register const char *yys = yystr;
     278                 : 
     279                 :   while (*yys++ != '\0')
     280                 :     continue;
     281                 : 
     282                 :   return yys - yystr - 1;
     283                 : }
     284                 : #  endif
     285                 : # endif
     286                 : 
     287                 : # ifndef yystpcpy
     288                 : #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
     289                 : #   define yystpcpy stpcpy
     290                 : #  else
     291                 : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
     292                 :    YYDEST.  */
     293                 : static char *
     294                 : #   if defined (__STDC__) || defined (__cplusplus)
     295                 : yystpcpy (char *yydest, const char *yysrc)
     296                 : #   else
     297                 : yystpcpy (yydest, yysrc)
     298                 :      char *yydest;
     299                 :      const char *yysrc;
     300                 : #   endif
     301                 : {
     302                 :   register char *yyd = yydest;
     303                 :   register const char *yys = yysrc;
     304                 : 
     305                 :   while ((*yyd++ = *yys++) != '\0')
     306                 :     continue;
     307                 : 
     308                 :   return yyd - 1;
     309                 : }
     310                 : #  endif
     311                 : # endif
     312                 : #endif
     313                 : 
     314                 : #line
     315                 : 
     316                 : /* The user can define YYPARSE_PARAM as the name of an argument to be passed
     317                 :    into yyparse.  The argument should have type void *.
     318                 :    It should actually point to an object.
     319                 :    Grammar actions can access the variable by casting it
     320                 :    to the proper pointer type.  */
     321                 : 
     322                 : #ifdef YYPARSE_PARAM
     323                 : # if defined (__STDC__) || defined (__cplusplus)
     324                 : #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
     325                 : #  define YYPARSE_PARAM_DECL
     326                 : # else
     327                 : #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
     328                 : #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
     329                 : # endif
     330                 : #else /* !YYPARSE_PARAM */
     331                 : # define YYPARSE_PARAM_ARG
     332                 : # define YYPARSE_PARAM_DECL
     333                 : #endif /* !YYPARSE_PARAM */
     334                 : 
     335                 : /* Prevent warning if -Wstrict-prototypes.  */
     336                 : #ifdef __GNUC__
     337                 : # ifdef YYPARSE_PARAM
     338                 : int yyparse (void *);
     339                 : # else
     340                 : int yyparse (void);
     341                 : # endif
     342                 : #endif
     343                 : 
     344                 : /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
     345                 :    variables are global, or local to YYPARSE.  */
     346                 : 
     347                 : #define YY_DECL_NON_LSP_VARIABLES                       \
     348                 : /* The lookahead symbol.  */                            \
     349                 : int yychar;                                             \
     350                 :                                                         \
     351                 : /* The semantic value of the lookahead symbol. */       \
     352                 : YYSTYPE yylval;                                         \
     353                 :                                                         \
     354                 : /* Number of parse errors so far.  */                   \
     355                 : int yynerrs;
     356                 : 
     357                 : #if YYLSP_NEEDED
     358                 : # define YY_DECL_VARIABLES                      \
     359                 : YY_DECL_NON_LSP_VARIABLES                       \
     360                 :                                                 \
     361                 : /* Location data for the lookahead symbol.  */  \
     362                 : YYLTYPE yylloc;
     363                 : #else
     364                 : # define YY_DECL_VARIABLES                      \
     365                 : YY_DECL_NON_LSP_VARIABLES
     366                 : #endif
     367                 : 
     368                 : 
     369                 : /* If nonreentrant, generate the variables here. */
     370                 : 
     371                 : #if !YYPURE
     372                 : YY_DECL_VARIABLES
     373                 : #endif  /* !YYPURE */
     374                 : 
     375                 : int
     376                 : yyparse (YYPARSE_PARAM_ARG)
     377              48 :      YYPARSE_PARAM_DECL
     378                 : {
     379                 :   /* If reentrant, generate the variables here. */
     380                 : #if YYPURE
     381                 :   YY_DECL_VARIABLES
     382                 : #endif  /* !YYPURE */
     383                 : 
     384                 :   register int yystate;
     385                 :   register int yyn;
     386                 :   int yyresult;
     387                 :   /* Number of tokens to shift before error messages enabled.  */
     388                 :   int yyerrstatus;
     389                 :   /* Lookahead token as an internal (translated) token number.  */
     390                 :   int yychar1 = 0;
     391                 : 
     392                 :   /* Three stacks and their tools:
     393                 :      `yyss': related to states,
     394                 :      `yyvs': related to semantic values,
     395                 :      `yyls': related to locations.
     396                 : 
     397                 :      Refer to the stacks thru separate pointers, to allow yyoverflow
     398                 :      to reallocate them elsewhere.  */
     399                 : 
     400                 :   /* The state stack. */
     401                 :   short yyssa[YYINITDEPTH];
     402                 :   short *yyss = yyssa;
     403                 :   register short *yyssp;
     404                 : 
     405                 :   /* The semantic value stack.  */
     406                 :   YYSTYPE yyvsa[YYINITDEPTH];
     407                 :   YYSTYPE *yyvs = yyvsa;
     408                 :   register YYSTYPE *yyvsp;
     409                 : 
     410                 : #if YYLSP_NEEDED
     411                 :   /* The location stack.  */
     412                 :   YYLTYPE yylsa[YYINITDEPTH];
     413                 :   YYLTYPE *yyls = yylsa;
     414                 :   YYLTYPE *yylsp;
     415                 : #endif
     416                 : 
     417                 : #if YYLSP_NEEDED
     418                 : # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
     419                 : #else
     420                 : # define YYPOPSTACK   (yyvsp--, yyssp--)
     421                 : #endif
     422                 : 
     423                 :   YYSIZE_T yystacksize = YYINITDEPTH;
     424                 : 
     425                 : 
     426                 :   /* The variables used to return semantic value and location from the
     427                 :      action routines.  */
     428                 :   YYSTYPE yyval;
     429                 : #if YYLSP_NEEDED
     430                 :   YYLTYPE yyloc;
     431                 : #endif
     432                 : 
     433                 :   /* When reducing, the number of symbols on the RHS of the reduced
     434                 :      rule. */
     435                 :   int yylen;
     436                 : 
     437                 :   YYDPRINTF ((stderr, "Starting parse\n"));
     438                 : 
     439                 :   yystate = 0;
     440                 :   yyerrstatus = 0;
     441                 :   yynerrs = 0;
     442              48 :   yychar = YYEMPTY;             /* Cause a token to be read.  */
     443              48 : 
     444                 :   /* Initialize stack pointers.
     445                 :      Waste one element of value and location stack
     446                 :      so that they stay on the same level as the state stack.
     447                 :      The wasted elements are never initialized.  */
     448                 : 
     449                 :   yyssp = yyss;
     450                 :   yyvsp = yyvs;
     451                 : #if YYLSP_NEEDED
     452                 :   yylsp = yyls;
     453                 : #endif
     454                 :   goto yysetstate;
     455                 : 
     456                 : /*------------------------------------------------------------.
     457                 : | yynewstate -- Push a new state, which is found in yystate.  |
     458                 : `------------------------------------------------------------*/
     459                 :  yynewstate:
     460          166536 :   /* In all cases, when you get here, the value and location stacks
     461                 :      have just been pushed. so pushing a state here evens the stacks.
     462                 :      */
     463                 :   yyssp++;
     464          166536 : 
     465                 :  yysetstate:
     466          166536 :   *yyssp = yystate;
     467          166584 : 
     468                 :   if (yyssp >= yyss + yystacksize - 1)
     469          166584 :     {
     470                 :       /* Get the current used size of the three stacks, in elements.  */
     471                 :       YYSIZE_T yysize = yyssp - yyss + 1;
     472                 : 
     473                 : #ifdef yyoverflow
     474                 :       {
     475                 :         /* Give user a chance to reallocate the stack. Use copies of
     476                 :            these so that the &'s don't force the real ones into
     477                 :            memory.  */
     478                 :         YYSTYPE *yyvs1 = yyvs;
     479                 :         short *yyss1 = yyss;
     480                 : 
     481                 :         /* Each stack pointer address is followed by the size of the
     482                 :            data in use in that stack, in bytes.  */
     483                 : # if YYLSP_NEEDED
     484                 :         YYLTYPE *yyls1 = yyls;
     485                 :         /* This used to be a conditional around just the two extra args,
     486                 :            but that might be undefined if yyoverflow is a macro.  */
     487                 :         yyoverflow ("parser stack overflow",
     488                 :                     &yyss1, yysize * sizeof (*yyssp),
     489                 :                     &yyvs1, yysize * sizeof (*yyvsp),
     490                 :                     &yyls1, yysize * sizeof (*yylsp),
     491                 :                     &yystacksize);
     492                 :         yyls = yyls1;
     493                 : # else
     494                 :         yyoverflow ("parser stack overflow",
     495                 :                     &yyss1, yysize * sizeof (*yyssp),
     496                 :                     &yyvs1, yysize * sizeof (*yyvsp),
     497                 :                     &yystacksize);
     498                 : # endif
     499                 :         yyss = yyss1;
     500                 :         yyvs = yyvs1;
     501                 :       }
     502                 : #else /* no yyoverflow */
     503                 : # ifndef YYSTACK_RELOCATE
     504                 :       goto yyoverflowlab;
     505                 : # else
     506                 :       /* Extend the stack our own way.  */
     507                 :       if (yystacksize >= YYMAXDEPTH)
     508                 :         goto yyoverflowlab;
     509                 :       yystacksize *= 2;
     510                 :       if (yystacksize > YYMAXDEPTH)
     511                 :         yystacksize = YYMAXDEPTH;
     512                 : 
     513                 :       {
     514                 :         short *yyss1 = yyss;
     515                 :         union yyalloc *yyptr =
     516                 :           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
     517                 :         if (! yyptr)
     518                 :           goto yyoverflowlab;
     519                 :         YYSTACK_RELOCATE (yyss);
     520                 :         YYSTACK_RELOCATE (yyvs);
     521                 : # if YYLSP_NEEDED
     522                 :         YYSTACK_RELOCATE (yyls);
     523                 : # endif
     524                 : # undef YYSTACK_RELOCATE
     525                 :         if (yyss1 != yyssa)
     526                 :           YYSTACK_FREE (yyss1);
     527                 :       }
     528                 : # endif
     529                 : #endif /* no yyoverflow */
     530                 : 
     531                 :       yyssp = yyss + yysize - 1;
     532                 :       yyvsp = yyvs + yysize - 1;
     533                 : #if YYLSP_NEEDED
     534                 :       yylsp = yyls + yysize - 1;
     535                 : #endif
     536                 : 
     537                 :       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
     538                 :                   (unsigned long int) yystacksize));
     539                 : 
     540                 :       if (yyssp >= yyss + yystacksize - 1)
     541                 :         YYABORT;
     542                 :     }
     543                 : 
     544                 :   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
     545                 : 
     546                 :   goto yybackup;
     547                 : 
     548                 : 
     549                 : /*-----------.
     550                 : | yybackup.  |
     551                 : `-----------*/
     552                 : yybackup:
     553          166584 : 
     554                 : /* Do appropriate processing given the current state.  */
     555                 : /* Read a lookahead token if we need one and don't already have one.  */
     556                 : /* yyresume: */
     557                 : 
     558                 :   /* First try to decide what to do without reference to lookahead token.  */
     559                 : 
     560                 :   yyn = yypact[yystate];
     561          166584 :   if (yyn == YYFLAG)
     562          166584 :     goto yydefault;
     563           87073 : 
     564                 :   /* Not known => get a lookahead token if don't already have one.  */
     565                 : 
     566                 :   /* yychar is either YYEMPTY or YYEOF
     567                 :      or a valid token in external form.  */
     568                 : 
     569                 :   if (yychar == YYEMPTY)
     570           87073 :     {
     571                 :       YYDPRINTF ((stderr, "Reading a token: "));
     572                 :       yychar = YYLEX;
     573           60369 :     }
     574                 : 
     575                 :   /* Convert token to internal form (in yychar1) for indexing tables with */
     576                 : 
     577                 :   if (yychar <= 0)           /* This means end of input. */
     578           87073 :     {
     579                 :       yychar1 = 0;
     580                 :       yychar = YYEOF;           /* Don't call YYLEX any more */
     581             142 : 
     582                 :       YYDPRINTF ((stderr, "Now at end of input.\n"));
     583                 :     }
     584                 :   else
     585                 :     {
     586                 :       yychar1 = YYTRANSLATE (yychar);
     587           86931 : 
     588                 : #if YYDEBUG
     589                 :      /* We have to keep this `#if YYDEBUG', since we use variables
     590                 :         which are defined only if `YYDEBUG' is set.  */
     591                 :       if (yydebug)
     592                 :         {
     593                 :           YYFPRINTF (stderr, "Next token is %d (%s",
     594                 :                      yychar, yytname[yychar1]);
     595                 :           /* Give the individual parser a way to print the precise
     596                 :              meaning of a token, for further debugging info.  */
     597                 : # ifdef YYPRINT
     598                 :           YYPRINT (stderr, yychar, yylval);
     599                 : # endif
     600                 :           YYFPRINTF (stderr, ")\n");
     601                 :         }
     602                 : #endif
     603                 :     }
     604                 : 
     605                 :   yyn += yychar1;
     606           87073 :   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
     607           87073 :     goto yydefault;
     608                 : 
     609                 :   yyn = yytable[yyn];
     610           61656 : 
     611                 :   /* yyn is what to do for this token type in this state.
     612                 :      Negative => reduce, -yyn is rule number.
     613                 :      Positive => shift, yyn is new state.
     614                 :        New state is final state => don't bother to shift,
     615                 :        just return success.
     616                 :      0, or most negative number => error.  */
     617                 : 
     618                 :   if (yyn < 0)
     619           61656 :     {
     620                 :       if (yyn == YYFLAG)
     621            1246 :         goto yyerrlab;
     622            1246 :       yyn = -yyn;
     623            1246 :       goto yyreduce;
     624            1246 :     }
     625                 :   else if (yyn == 0)
     626           60410 :     goto yyerrlab;
     627           60410 : 
     628                 :   if (yyn == YYFINAL)
     629           60410 :     YYACCEPT;
     630           60363 : 
     631                 :   /* Shift the lookahead token.  */
     632                 :   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
     633                 :               yychar, yytname[yychar1]));
     634                 : 
     635                 :   /* Discard the token being shifted unless it is eof.  */
     636                 :   if (yychar != YYEOF)
     637           60363 :     yychar = YYEMPTY;
     638           60316 : 
     639                 :   *++yyvsp = yylval;
     640           60363 : #if YYLSP_NEEDED
     641                 :   *++yylsp = yylloc;
     642                 : #endif
     643                 : 
     644                 :   /* Count tokens shifted since error; after three, turn off error
     645                 :      status.  */
     646                 :   if (yyerrstatus)
     647           60363 :     yyerrstatus--;
     648               3 : 
     649                 :   yystate = yyn;
     650                 :   goto yynewstate;
     651                 : 
     652                 : 
     653                 : /*-----------------------------------------------------------.
     654                 : | yydefault -- do the default action for the current state.  |
     655                 : `-----------------------------------------------------------*/
     656                 : yydefault:
     657          104928 :   yyn = yydefact[yystate];
     658          104928 :   if (yyn == 0)
     659          104928 :     goto yyerrlab;
     660          106167 :   goto yyreduce;
     661                 : 
     662                 : 
     663                 : /*-----------------------------.
     664                 : | yyreduce -- Do a reduction.  |
     665                 : `-----------------------------*/
     666                 : yyreduce:
     667          106167 :   /* yyn is the number of a rule to reduce with.  */
     668                 :   yylen = yyr2[yyn];
     669          106167 : 
     670                 :   /* If YYLEN is nonzero, implement the default value of the action:
     671                 :      `$$ = $1'.
     672                 : 
     673                 :      Otherwise, the following line sets YYVAL to the semantic value of
     674                 :      the lookahead token.  This behavior is undocumented and Bison
     675                 :      users should not rely upon it.  Assigning to YYVAL
     676                 :      unconditionally makes the parser a bit smaller, and it avoids a
     677                 :      GCC warning that YYVAL may be used uninitialized.  */
     678                 :   yyval = yyvsp[1-yylen];
     679          106167 : 
     680                 : #if YYLSP_NEEDED
     681                 :   /* Similarly for the default location.  Let the user run additional
     682                 :      commands if for instance locations are ranges.  */
     683                 :   yyloc = yylsp[1-yylen];
     684                 :   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
     685                 : #endif
     686                 : 
     687                 : #if YYDEBUG
     688                 :   /* We have to keep this `#if YYDEBUG', since we use variables which
     689                 :      are defined only if `YYDEBUG' is set.  */
     690                 :   if (yydebug)
     691                 :     {
     692                 :       int yyi;
     693                 : 
     694                 :       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
     695                 :                  yyn, yyrline[yyn]);
     696                 : 
     697                 :       /* Print the symbols being reduced, and their result.  */
     698                 :       for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
     699                 :         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
     700                 :       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     701                 :     }
     702                 : #endif
     703                 : %% actions /* The action file replaces this line. */
     704                 : #line
     705          106167 : 
     706                 :   yyvsp -= yylen;
     707          106164 :   yyssp -= yylen;
     708          106164 : #if YYLSP_NEEDED
     709                 :   yylsp -= yylen;
     710                 : #endif
     711                 : 
     712                 : #if YYDEBUG
     713                 :   if (yydebug)
     714                 :     {
     715                 :       short *yyssp1 = yyss - 1;
     716                 :       YYFPRINTF (stderr, "state stack now");
     717                 :       while (yyssp1 != yyssp)
     718                 :         YYFPRINTF (stderr, " %d", *++yyssp1);
     719                 :       YYFPRINTF (stderr, "\n");
     720                 :     }
     721                 : #endif
     722                 : 
     723                 :   *++yyvsp = yyval;
     724          106164 : #if YYLSP_NEEDED
     725                 :   *++yylsp = yyloc;
     726                 : #endif
     727                 : 
     728                 :   /* Now `shift' the result of the reduction.  Determine what state
     729                 :      that goes to, based on the state we popped back to and the rule
     730                 :      number reduced by.  */
     731                 : 
     732                 :   yyn = yyr1[yyn];
     733                 : 
     734                 :   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
     735          106164 :   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     736          144889 :     yystate = yytable[yystate];
     737           38725 :   else
     738                 :     yystate = yydefgoto[yyn - YYNTBASE];
     739           67439 : 
     740                 :   goto yynewstate;
     741                 : 
     742                 : 
     743                 : /*------------------------------------.
     744                 : | yyerrlab -- here on detecting error |
     745                 : `------------------------------------*/
     746                 : yyerrlab:
     747               7 :   /* If not already recovering from an error, report this error.  */
     748                 :   if (!yyerrstatus)
     749               7 :     {
     750                 :       ++yynerrs;
     751               1 : 
     752                 : #ifdef YYERROR_VERBOSE
     753                 :       yyn = yypact[yystate];
     754                 : 
     755                 :       if (yyn > YYFLAG && yyn < YYLAST)
     756                 :         {
     757                 :           YYSIZE_T yysize = 0;
     758                 :           char *yymsg;
     759                 :           int yyx, yycount;
     760                 : 
     761                 :           yycount = 0;
     762                 :           /* Start YYX at -YYN if negative to avoid negative indexes in
     763                 :              YYCHECK.  */
     764                 :           for (yyx = yyn < 0 ? -yyn : 0;
     765                 :                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
     766                 :             if (yycheck[yyx + yyn] == yyx)
     767                 :               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
     768                 :           yysize += yystrlen ("parse error, unexpected ") + 1;
     769                 :           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
     770                 :           yymsg = (char *) YYSTACK_ALLOC (yysize);
     771                 :           if (yymsg != 0)
     772                 :             {
     773                 :               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
     774                 :               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
     775                 : 
     776                 :               if (yycount < 5)
     777                 :                 {
     778                 :                   yycount = 0;
     779                 :                   for (yyx = yyn < 0 ? -yyn : 0;
     780                 :                        yyx < (int) (sizeof (yytname) / sizeof (char *));
     781                 :                        yyx++)
     782                 :                     if (yycheck[yyx + yyn] == yyx)
     783                 :                       {
     784                 :                         const char *yyq = ! yycount ? ", expecting " : " or ";
     785                 :                         yyp = yystpcpy (yyp, yyq);
     786                 :                         yyp = yystpcpy (yyp, yytname[yyx]);
     787                 :                         yycount++;
     788                 :                       }
     789                 :                 }
     790                 :               yyerror (yymsg);
     791                 :               YYSTACK_FREE (yymsg);
     792                 :             }
     793                 :           else
     794                 :             yyerror ("parse error; also virtual memory exhausted");
     795                 :         }
     796                 :       else
     797                 : #endif /* defined (YYERROR_VERBOSE) */
     798                 :         yyerror ("parse error");
     799               1 :     }
     800                 :   goto yyerrlab1;
     801                 : 
     802                 : 
     803                 : /*--------------------------------------------------.
     804                 : | yyerrlab1 -- error raised explicitly by an action |
     805                 : `--------------------------------------------------*/
     806                 : yyerrlab1:
     807               9 :   if (yyerrstatus == 3)
     808               9 :     {
     809                 :       /* If just tried and failed to reuse lookahead token after an
     810                 :          error, discard it.  */
     811                 : 
     812                 :       /* return failure if at end of input */
     813                 :       if (yychar == YYEOF)
     814               6 :         YYABORT;
     815               5 :       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
     816                 :                   yychar, yytname[yychar1]));
     817                 :       yychar = YYEMPTY;
     818               5 :     }
     819                 : 
     820                 :   /* Else will try to reuse lookahead token after shifting the error
     821                 :      token.  */
     822                 : 
     823                 :   yyerrstatus = 3;              /* Each real token shifted decrements this */
     824                 : 
     825                 :   goto yyerrhandle;
     826               9 : 
     827                 : 
     828                 : /*-------------------------------------------------------------------.
     829                 : | yyerrdefault -- current state does not do anything special for the |
     830                 : | error token.                                                       |
     831                 : `-------------------------------------------------------------------*/
     832                 : yyerrdefault:
     833              16 : #if 0
     834                 :   /* This is wrong; only states that explicitly want error tokens
     835                 :      should shift them.  */
     836                 : 
     837                 :   /* If its default is to accept any token, ok.  Otherwise pop it.  */
     838                 :   yyn = yydefact[yystate];
     839                 :   if (yyn)
     840                 :     goto yydefault;
     841                 : #endif
     842                 : 
     843                 : 
     844                 : /*---------------------------------------------------------------.
     845                 : | yyerrpop -- pop the current state because it cannot handle the |
     846                 : | error token                                                    |
     847                 : `---------------------------------------------------------------*/
     848                 : yyerrpop:
     849              16 :   if (yyssp == yyss)
     850              16 :     YYABORT;
     851              16 :   yyvsp--;
     852              16 :   yystate = *--yyssp;
     853              16 : #if YYLSP_NEEDED
     854                 :   yylsp--;
     855                 : #endif
     856                 : 
     857                 : #if YYDEBUG
     858                 :   if (yydebug)
     859                 :     {
     860                 :       short *yyssp1 = yyss - 1;
     861                 :       YYFPRINTF (stderr, "Error: state stack now");
     862                 :       while (yyssp1 != yyssp)
     863                 :         YYFPRINTF (stderr, " %d", *++yyssp1);
     864                 :       YYFPRINTF (stderr, "\n");
     865                 :     }
     866                 : #endif
     867                 : 
     868                 : /*--------------.
     869                 : | yyerrhandle.  |
     870                 : `--------------*/
     871                 : yyerrhandle:
     872              25 :   yyn = yypact[yystate];
     873              25 :   if (yyn == YYFLAG)
     874              25 :     goto yyerrdefault;
     875              20 : 
     876                 :   yyn += YYTERROR;
     877              20 :   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
     878              20 :     goto yyerrdefault;
     879                 : 
     880                 :   yyn = yytable[yyn];
     881               9 :   if (yyn < 0)
     882               9 :     {
     883                 :       if (yyn == YYFLAG)
     884               0 :         goto yyerrpop;
     885               0 :       yyn = -yyn;
     886               0 :       goto yyreduce;
     887               0 :     }
     888                 :   else if (yyn == 0)
     889               9 :     goto yyerrpop;
     890               9 : 
     891                 :   if (yyn == YYFINAL)
     892               9 :     YYACCEPT;
     893               9 : 
     894                 :   YYDPRINTF ((stderr, "Shifting error token, "));
     895                 : 
     896                 :   *++yyvsp = yylval;
     897               9 : #if YYLSP_NEEDED
     898                 :   *++yylsp = yylloc;
     899                 : #endif
     900                 : 
     901                 :   yystate = yyn;
     902                 :   goto yynewstate;
     903               9 : 
     904                 : 
     905                 : /*-------------------------------------.
     906                 : | yyacceptlab -- YYACCEPT comes here.  |
     907                 : `-------------------------------------*/
     908                 : yyacceptlab:
     909                 :   yyresult = 0;
     910                 :   goto yyreturn;
     911                 : 
     912                 : /*-----------------------------------.
     913                 : | yyabortlab -- YYABORT comes here.  |
     914                 : `-----------------------------------*/
     915                 : yyabortlab:
     916                 :   yyresult = 1;
     917                 :   goto yyreturn;
     918                 : 
     919                 : /*---------------------------------------------.
     920                 : | yyoverflowab -- parser overflow comes here.  |
     921                 : `---------------------------------------------*/
     922                 : yyoverflowlab:
     923               0 :   yyerror ("parser stack overflow");
     924               0 :   yyresult = 2;
     925                 :   /* Fall through.  */
     926                 : 
     927                 : yyreturn:
     928              47 : #ifndef yyoverflow
     929                 :   if (yyss != yyssa)
     930                 :     YYSTACK_FREE (yyss);
     931                 : #endif
     932                 :   return yyresult;
     933                 : }

Generated by: LTP GCOV extension version 1.4