parse.c

samba最新软件

      40,    36,    41,    69,    70,    71,    99,    72,   125,   126,
      73,   127,    74,    75,    76,    77,   104,    78,    79,    80,
      81,    82,    83,    84,    85,    86,   114,   161,   162,   163,
     164,    87,    88,   111,   117,    42,    89,    90,   121,   122,
     123,   167,   168,     4,   135,     9,    10,   136,   137,   138,
     139,   140,   141,   142,   143,   144,   145,   146
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -113
static const yytype_int16 yypact[] =
{
     -74,   -67,    38,   -69,    23,  -113,  -113,   -44,  -113,   -41,
     -69,     4,   -26,  -113,  -113,    -3,     1,    10,    52,   -10,
    -113,  -113,  -113,    45,    13,  -113,  -113,    77,   -35,    15,
      64,    19,    17,    20,    15,  -113,    85,  -113,    25,  -113,
      19,  -113,  -113,    15,  -113,  -113,    27,    47,  -113,  -113,
      26,    29,  -113,  -113,  -113,   -30,  -113,    89,    61,  -113,
     -57,   -47,  -113,  -113,  -113,  -113,    82,  -113,    -4,   -68,
    -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,
    -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,   -17,  -113,
    -113,  -113,  -113,   -67,    35,    33,    46,    51,    46,  -113,
    -113,    69,    44,   -73,    88,    82,   -72,    56,  -113,  -113,
    -113,    49,    93,     7,  -113,  -113,  -113,    82,  -113,    58,
      82,   -76,   -13,  -113,    57,    59,  -113,    60,  -113,    68,
    -113,  -113,  -113,  -113,  -113,  -113,   -75,  -113,  -113,  -113,
    -113,  -113,  -113,  -113,  -113,  -113,  -113,   -63,  -113,  -113,
    -113,   -62,    82,    56,  -113,   -46,    65,  -113,   141,    82,
     142,    63,  -113,  -113,  -113,    56,    66,   -38,  -113,    56,
     -16,  -113,    93,  -113,    76,    -7,  -113,    93,    81,  -113,
    -113,  -113,    56,  -113,  -113,    72,   -19,    93,  -113,    83,
      58,  -113,  -113,  -113,  -113,    78,  -113,  -113,    80,    84,
      87,    62,   162,  -113,    90,  -113,  -113,  -113,  -113,  -113,
    -113,    93,  -113,  -113
};

/* YYPGOTO[NTERM-NUM].  */
static const yytype_int16 yypgoto[] =
{
    -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,   150,   136,
    -113,   143,  -113,   -65,  -113,  -113,    86,  -113,    91,    16,
    -113,  -113,  -113,  -113,  -113,  -113,    92,  -113,  -113,  -113,
    -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,
    -113,  -113,  -113,  -113,  -113,  -113,  -113,  -113,   -60,  -113,
      22,  -113,    -5,    97,     2,   184,  -113,  -112,  -113,  -113,
    -113,  -113,  -113,  -113,  -113,    21,  -113,  -113
};

/* 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 -13
static const yytype_int16 yytable[] =
{
     157,   107,   108,     5,   202,    29,   105,   172,   178,   102,
     115,    15,     1,   120,   120,   170,   112,     7,   179,   171,
       8,   116,   150,   154,   113,   158,   159,     3,   175,   170,
     160,    16,   180,   181,    47,    48,    49,   103,     6,    50,
     153,   173,    17,   151,    11,   170,   155,   106,    12,   183,
      51,   -12,   165,   190,    13,   169,   109,   191,    52,    53,
     194,    54,    97,    19,    98,   198,   200,    20,    55,   192,
     120,    21,   110,   113,    56,   203,    57,    58,   196,   124,
      22,    23,   128,    25,    26,    28,    59,   182,    37,    60,
      61,    47,    48,    49,   186,     5,    50,    27,   129,   213,
     130,    32,    62,    63,    64,    38,    65,    51,    43,    66,
      44,    67,   128,    93,    94,    52,    53,    46,    54,   120,
      95,    68,   131,    96,   128,    55,   100,   199,   101,   119,
     130,    56,   124,    57,    58,   102,    97,   132,   156,   133,
     134,   152,   130,    59,   166,     3,    60,    61,   113,   174,
     175,   177,   131,   185,   187,   176,   188,   210,   189,    62,
      63,    64,   184,    65,   131,   134,   201,   132,    67,   133,
     134,   206,   204,   207,   211,     3,    91,   208,    68,   132,
     209,   133,   134,   212,    45,   205,    92,     3,   149,   147,
     118,   197,   193,   148,    14,   195
};

static const yytype_uint8 yycheck[] =
{
     112,    66,     6,     1,    23,    40,    53,    20,    83,    66,
      27,     7,    86,    86,    86,    91,    84,    86,    93,    95,
      89,    38,    95,    95,    92,    18,    19,    94,    91,    91,
      23,    27,    95,    95,     9,    10,    11,    94,     0,    14,
     105,    54,    38,   103,    21,    91,   106,    94,    92,    95,
      25,    86,   117,    91,    95,   120,    60,    95,    33,    34,
     172,    36,    92,    89,    94,   177,   178,    70,    43,    85,
      86,    70,    76,    92,    49,   187,    51,    52,    85,    86,
      70,    29,    31,    93,    39,     8,    61,   152,    24,    64,
      65,     9,    10,    11,   159,    93,    14,    84,    47,   211,
      49,    86,    77,    78,    79,    86,    81,    25,    91,    84,
      90,    86,    31,    86,    67,    33,    34,    32,    36,    86,
      94,    96,    71,    94,    31,    43,    37,    46,    67,    94,
      49,    49,    86,    51,    52,    66,    92,    86,    89,    88,
      89,    53,    49,    61,    86,    94,    64,    65,    92,    92,
      91,    83,    71,    12,    12,    95,    93,    95,    92,    77,
      78,    79,    97,    81,    71,    89,    94,    86,    86,    88,
      89,    93,    89,    93,    12,    94,    40,    93,    96,    86,
      93,    88,    89,    93,    34,   190,    43,    94,   102,    98,
      93,   175,   170,   101,    10,   174
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const yytype_uint8 yystos[] =
{
       0,    86,    99,    94,   151,   152,     0,    86,    89,   153,
     154,    21,    92,    95,   153,     7,    27,    38,   100,    89,
      70,    70,    70,    29,   101,    93,    39,    84,     8,    40,
     102,   103,    86,   104,   105,   106,   109,    24,    86,   107,
     108,   110,   143,    91,    90,   106,    32,     9,    10,    11,
      14,    25,    33,    34,    36,    43,    49,    51,    52,    61,
      64,    65,    77,    78,    79,    81,    84,    86,    96,   111,
     112,   113,   115,   118,   120,   121,   122,   123,   125,   126,
     127,   128,   129,   130,   131,   132,   133,   139,   140,   144,
     145,   107,   109,    86,    67,    94,    94,    92,    94,   114,
      37,    67,    66,    94,   124,    53,    94,   111,     6,    60,
      76,   141,    84,    92,   134,    27,    38,   142,   151,    94,
      86,   146,   147,   148,    86,   116,   117,   119,    31,    47,
      49,    71,    86,    88,    89,   152,   155,   156,   157,   158,
     159,   160,   161,   162,   163,   164,   165,   116,   124,   114,
      95,   146,    53,   111,    95,   146,    89,   155,    18,    19,
      23,   135,   136,   137,   138,   111,    86,   149,   150,   111,
      91,    95,    20,    54,    92,    91,    95,    83,    83,    93,
      95,    95,   111,    95,    97,    12,   111,    12,    93,    92,
      91,    95,    85,   148,   155,   163,    85,   117,   155,    46,
     155,    94,    23,   155,    89,   150,    93,    93,    93,    93,
      95,    12,    93,   155
};

#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 (1);						\
      goto yybackup;						\
    }								\
  else								\
    {								\
      yyerror (YY_("syntax error: cannot back up")); \
      YYERROR;							\
    }								\
while (YYID (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 (YYID (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 (YYID (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 (YYID (0))

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


/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/

/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep)
    FILE *yyoutput;
    int yytype;
    YYSTYPE const * const yyvaluep;
#endif
{
  if (!yyvaluep)
    return;
# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# else
  YYUSE (yyoutput);
# endif
  switch (yytype)
    {
      default:
	break;
    }
}


/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep)
    FILE *yyoutput;
    int yytype;
    YYSTYPE const * const yyvaluep;
#endif
{
  if (yytype < YYNTOKENS)
    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
  else
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
  YYFPRINTF (yyoutput, ")");
}

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

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
#else
static void
yy_stack_print (bottom, top)
    yytype_int16 *bottom;
    yytype_int16 *top;
#endif
{
  YYFPRINTF (stderr, "Stack now");
  for (; 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 (YYID (0))


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

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyvsp, yyrule)
    YYSTYPE *yyvsp;
    int yyrule;
#endif
{
  int yynrhs = yyr2[yyrule];
  int yyi;
  unsigned long int yylno = yyrline[yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
	     yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      fprintf (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
		       &(yyvsp[(yyi + 1) - (yynrhs)])
		       		       );
      fprintf (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)		\
do {					\
  if (yydebug)				\
    yy_reduce_print (yyvsp, Rule); \
} while (YYID (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
   YYSTACK_ALLOC_MAXIMUM < 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.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
yystrlen (const char *yystr)
#else