zconf.tab.c_shipped

busybox最新版的源码:学习和应用的好东东,多的不说了,大家看后再说吧

{
     -78,     2,   159,   -78,   -21,     0,     0,   -12,     0,     1,
       4,     0,    27,    38,    60,    58,   -78,   -78,   -78,   -78,
     -78,   -78,   -78,   100,   -78,   104,   -78,   -78,   -78,   -78,
     -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,
     -78,   -78,   -78,   -78,   -78,   -78,    86,   113,   -78,   114,
     -78,   -78,   125,   127,   128,   -78,   -78,    60,    60,   210,
      65,   -78,   141,   142,    39,   103,   182,   200,     6,    66,
       6,   131,   -78,   146,   -78,   -78,   -78,   -78,   -78,   196,
     -78,    60,    60,   146,    40,    40,   -78,   -78,   155,   156,
      -2,    60,     0,     0,    60,   105,    40,   194,   -78,   -78,
     -78,   206,   -78,   -78,   183,     0,     0,   195,   -78,   -78,
     -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,
     -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,   -78,
     -78,   197,   -78,   -78,   -78,   -78,   -78,    60,   213,   216,
     212,   203,   212,   190,   212,    40,   208,   -78,   -78,   212,
     222,   212,   219,   -78,   -78,    60,   223,   -78,   -78,   224,
     225,   212,   -78,   226,   -78,   227,   -78,    47,   -78,   -78,
     -78,   228,   -78,   -78,   -78
};

/* YYPGOTO[NTERM-NUM].  */
static const short int yypgoto[] =
{
     -78,   -78,   -78,   -78,   164,   -36,   -78,   -78,   -78,   -78,
     230,   -78,   -78,   -78,   -78,    29,   -78,   -78,   -78,   -78,
     -78,   -78,   -78,   -78,   -78,   -78,    59,   -78,   -78,   -78,
     -78,   -78,   198,   220,    24,   157,    -5,   169,   202,    74,
     -53,   -77
};

/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
   positive, shift that token.  If negative, reduce the rule which
   number is the opposite.  If zero, do what YYDEFACT says.
   If YYTABLE_NINF, syntax error.  */
#define YYTABLE_NINF -76
static const short int yytable[] =
{
      46,    47,     3,    49,    79,    80,    52,   133,   134,    43,
       6,     7,     8,     9,    10,    11,    12,    13,    48,   145,
      14,    15,   137,    55,    56,    44,    45,    57,   131,   132,
     109,    50,    58,   122,    51,   122,    24,   138,   139,   -28,
      88,   143,   -28,   -28,   -28,   -28,   -28,   -28,   -28,   -28,
     -28,    89,    53,   -28,   -28,    90,    91,   -28,    92,    93,
      94,    95,    96,    54,    97,    55,    56,    88,   161,    98,
     -66,   -66,   -66,   -66,   -66,   -66,   -66,   -66,    81,    82,
     -66,   -66,    90,    91,   152,    55,    56,   140,    61,    57,
     112,    97,    84,   123,    58,   123,   121,   117,    85,   125,
     149,    62,   167,   -30,    88,    63,   -30,   -30,   -30,   -30,
     -30,   -30,   -30,   -30,   -30,    89,    72,   -30,   -30,    90,
      91,   -30,    92,    93,    94,    95,    96,   119,    97,   127,
     144,   -75,    88,    98,   -75,   -75,   -75,   -75,   -75,   -75,
     -75,   -75,   -75,    74,    75,   -75,   -75,    90,    91,   -75,
     -75,   -75,   -75,   -75,   -75,    76,    97,    77,    78,    -2,
       4,   121,     5,     6,     7,     8,     9,    10,    11,    12,
      13,    86,    87,    14,    15,    16,   129,    17,    18,    19,
      20,    21,    22,    88,    23,   135,   136,   -43,   -43,    24,
     -43,   -43,   -43,   -43,    89,   146,   -43,   -43,    90,    91,
     104,   105,   106,   107,   155,     7,     8,    97,    10,    11,
      12,    13,   108,   148,    14,    15,   158,   159,   160,   147,
     151,    81,    82,   163,   130,   165,   155,    81,    82,    82,
      24,   113,   116,   157,   124,   171,   115,   120,   162,   128,
      72,    81,    82,   153,    81,    82,   154,    81,    82,   166,
      81,    82,   164,   168,   169,   170,   172,   173,   174,    65,
      71,    83,     0,   150,   111
};

static const short int yycheck[] =
{
       5,     6,     0,     8,    57,    58,    11,    84,    85,    30,
       4,     5,     6,     7,     8,     9,    10,    11,    30,    96,
      14,    15,    24,    25,    26,    25,    26,    29,    81,    82,
      66,    30,    34,    69,    30,    71,    30,    90,    91,     0,
       1,    94,     3,     4,     5,     6,     7,     8,     9,    10,
      11,    12,    25,    14,    15,    16,    17,    18,    19,    20,
      21,    22,    23,    25,    25,    25,    26,     1,   145,    30,
       4,     5,     6,     7,     8,     9,    10,    11,    31,    32,
      14,    15,    16,    17,   137,    25,    26,    92,    30,    29,
      66,    25,    27,    69,    34,    71,    30,    68,    33,    70,
     105,     1,   155,     0,     1,     1,     3,     4,     5,     6,
       7,     8,     9,    10,    11,    12,    30,    14,    15,    16,
      17,    18,    19,    20,    21,    22,    23,    68,    25,    70,
      25,     0,     1,    30,     3,     4,     5,     6,     7,     8,
       9,    10,    11,    30,    30,    14,    15,    16,    17,    18,
      19,    20,    21,    22,    23,    30,    25,    30,    30,     0,
       1,    30,     3,     4,     5,     6,     7,     8,     9,    10,
      11,    30,    30,    14,    15,    16,    30,    18,    19,    20,
      21,    22,    23,     1,    25,    30,    30,     5,     6,    30,
       8,     9,    10,    11,    12,     1,    14,    15,    16,    17,
      18,    19,    20,    21,    14,     5,     6,    25,     8,     9,
      10,    11,    30,    30,    14,    15,   142,   143,   144,    13,
      25,    31,    32,   149,    28,   151,    14,    31,    32,    32,
      30,    67,    68,    30,    70,   161,    67,    68,    30,    70,
      30,    31,    32,    30,    31,    32,    30,    31,    32,    30,
      31,    32,    30,    30,    30,    30,    30,    30,    30,    29,
      40,    59,    -1,   106,    66
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const unsigned char yystos[] =
{
       0,    36,    37,     0,     1,     3,     4,     5,     6,     7,
       8,     9,    10,    11,    14,    15,    16,    18,    19,    20,
      21,    22,    23,    25,    30,    38,    39,    41,    42,    43,
      44,    47,    48,    50,    54,    56,    58,    59,    61,    63,
      64,    65,    72,    30,    25,    26,    71,    71,    30,    71,
      30,    30,    71,    25,    25,    25,    26,    29,    34,    75,
      76,    30,     1,     1,    45,    45,    51,    53,    57,    68,
      62,    68,    30,    73,    30,    30,    30,    30,    30,    75,
      75,    31,    32,    73,    27,    33,    30,    30,     1,    12,
      16,    17,    19,    20,    21,    22,    23,    25,    30,    40,
      46,    66,    67,    69,    18,    19,    20,    21,    30,    40,
      52,    67,    69,    39,    49,    72,    39,    50,    55,    61,
      72,    30,    40,    69,    39,    50,    60,    61,    72,    30,
      28,    75,    75,    76,    76,    30,    30,    24,    75,    75,
      71,    70,    71,    75,    25,    76,     1,    13,    30,    71,
      70,    25,    75,    30,    30,    14,    74,    30,    74,    74,
      74,    76,    30,    74,    30,    74,    30,    75,    30,    30,
      30,    74,    30,    30,    30
};

#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif

#define yyerrok		(yyerrstatus = 0)
#define yyclearin	(yychar = YYEMPTY)
#define YYEMPTY		(-2)
#define YYEOF		0

#define YYACCEPT	goto yyacceptlab
#define YYABORT		goto yyabortlab
#define YYERROR		goto yyerrorlab


/* Like YYERROR except do call yyerror.  This remains here temporarily
   to ease the transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */

#define YYFAIL		goto yyerrlab

#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)					\
do								\
  if (yychar == YYEMPTY && yylen == 1)				\
    {								\
      yychar = (Token);						\
      yylval = (Value);						\
      yytoken = YYTRANSLATE (yychar);				\
      YYPOPSTACK;						\
      goto yybackup;						\
    }								\
  else								\
    { 								\
      yyerror ("syntax error: cannot back up");\
      YYERROR;							\
    }								\
while (0)


#define YYTERROR	1
#define YYERRCODE	256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#define YYRHSLOC(Rhs, K) ((Rhs)[K])
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)				\
    do									\
      if (N)								\
	{								\
	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
	}								\
      else								\
	{								\
	  (Current).first_line   = (Current).last_line   =		\
	    YYRHSLOC (Rhs, 0).last_line;				\
	  (Current).first_column = (Current).last_column =		\
	    YYRHSLOC (Rhs, 0).last_column;				\
	}								\
    while (0)
#endif


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if YYLTYPE_IS_TRIVIAL
#  define YY_LOCATION_PRINT(File, Loc)			\
     fprintf (File, "%d.%d-%d.%d",			\
              (Loc).first_line, (Loc).first_column,	\
              (Loc).last_line,  (Loc).last_column)
# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


/* YYLEX -- calling `yylex' with the right arguments.  */

#ifdef YYLEX_PARAM
# define YYLEX yylex (YYLEX_PARAM)
#else
# define YYLEX yylex ()
#endif

/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)			\
do {						\
  if (yydebug)					\
    YYFPRINTF Args;				\
} while (0)

# define YY_SYMBOL_PRINT(Title, Type, Value, Location)		\
do {								\
  if (yydebug)							\
    {								\
      YYFPRINTF (stderr, "%s ", Title);				\
      yysymprint (stderr, 					\
                  Type, Value);	\
      YYFPRINTF (stderr, "\n");					\
    }								\
} while (0)

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
yy_stack_print (short int *bottom, short int *top)
#else
static void
yy_stack_print (bottom, top)
    short int *bottom;
    short int *top;
#endif
{
  YYFPRINTF (stderr, "Stack now");
  for (/* Nothing. */; bottom <= top; ++bottom)
    YYFPRINTF (stderr, " %d", *bottom);
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)				\
do {								\
  if (yydebug)							\
    yy_stack_print ((Bottom), (Top));				\
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
yy_reduce_print (int yyrule)
#else
static void
yy_reduce_print (yyrule)
    int yyrule;
#endif
{
  int yyi;
  unsigned int yylno = yyrline[yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
             yyrule - 1, yylno);
  /* Print the symbols being reduced, and their result.  */
  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
}

# define YY_REDUCE_PRINT(Rule)		\
do {					\
  if (yydebug)				\
    yy_reduce_print (Rule);		\
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef	YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif



#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined (__GLIBC__) && defined (_STRING_H)
#   define yystrlen strlen
#  else
/* Return the length of YYSTR.  */
static YYSIZE_T
#   if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
#   else
yystrlen (yystr)
     const char *yystr;
#   endif
{
  register const char *yys = yystr;

  while (*yys++ != '\0')
    continue;

  return yys - yystr - 1;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
#   if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
#   else
yystpcpy (yydest, yysrc)
     char *yydest;
     const char *yysrc;
#   endif
{
  register char *yyd = yydest;
  register const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif

#endif /* !YYERROR_VERBOSE */



#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
#else
static void
yysymprint (yyoutput, yytype, yyvaluep)
    FILE *yyoutput;
    int yytype;
    YYSTYPE *yyvaluep;
#endif
{
  /* Pacify ``unused variable'' warnings.  */
  (void) yyvaluep;

  if (yytype < YYNTOKENS)
    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
  else
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);


# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# endif
  switch (yytype)
    {
      default:
        break;
    }
  YYFPRINTF (yyoutput, ")");
}

#endif /* ! YYDEBUG */
/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yymsg, yytype, yyvaluep)
    const char *yymsg;
    int yytype;
    YYSTYPE *yyvaluep;
#endif
{
  /* Pacify ``unused variable'' warnings.  */
  (void) yyvaluep;

  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  switch (yytype)
    {
      case 48: /* choice_entry */

        {
	fprintf(stderr, "%s:%d: missing end statement for this entry\n",
		(yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
	if (current_menu == (yyvaluep->menu))
		menu_end_menu();
};

        break;
      case 54: /* if_entry */

        {
	fprintf(stderr, "%s:%d: missing end statement for this entry\n",
		(yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
	if (current_menu == (yyvaluep->menu))
		menu_end_menu();
};

        break;
      case 59: /* menu_entry */

        {
	fprintf(stderr, "%s:%d: missing end statement for this entry\n",
		(yyvaluep->menu)->file->name, (yyvaluep->menu)->lineno);
	if (current_menu == (yyvaluep->menu))
		menu_end_menu();
};

        break;

      default:
        break;
    }
}


/* Prevent warnings from -Wmissing-prototypes.  */

#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
int yyparse (void *YYPARSE_PARAM);
# else
int yyparse ();
# endif
#else /* ! YYPARSE_PARAM */
#if defined (__STDC__) || defined (__cplusplus)
int yyparse (void);
#else
int yyparse ();
#endif
#endif /* ! YYPARSE_PARAM */



/* The look-ahead symbol.  */
int yychar;

/* The semantic value of the look-ahead symbol.  */
YYSTYPE yylval;

/* Number of syntax errors so far.  */
int yynerrs;



/*----------.
| yyparse.  |
`----------*/

#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
int yyparse (void *YYPARSE_PARAM)
# else
int yyparse (YYPARSE_PARAM)
  void *YYPARSE_PARAM;
# endif
#else /* ! YYPARSE_PARAM */
#if defined (__STDC__) || defined (__cplusplus)
int
yyparse (void)
#else
int
yyparse ()

#endif
#endif
{