wnparse.tab.c

一个与传统电子字典不同的字典

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const unsigned char yyr1[] =
{
       0,    25,    26,    26,    27,    27,    27,    27,    27,    27,
      28,    28,    29,    29,    29,    29,    30,    30,    31,    31,
      31,    31,    32,    32,    32,    33,    33,    33,    33,    34,
      34,    34,    34,    34,    34,    34,    34,    34,    34,    35,
      36,    36,    36,    37,    37,    38,    38,    39,    39,    40,
      40,    40,    41,    41,    42,    42,    43,    43,    44,    44,
      45,    45,    45,    46,    46,    47,    47,    48,    48
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
static const unsigned char yyr2[] =
{
       0,     2,     2,     0,     1,     1,     1,     1,     1,     1,
       6,     5,     7,     6,     6,     5,     6,     5,     0,     2,
       3,     2,     5,     6,     5,     1,     2,     1,     2,     1,
       2,     1,     2,     2,     3,     4,     5,     6,     5,     2,
       2,     1,     2,     0,     1,     0,     1,     1,     2,     2,
       3,     2,     3,     2,     1,     3,     2,     2,     0,     2,
       6,     5,     2,     7,     6,     1,     4,     2,     3
};

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
   means the default is an error.  */
static const unsigned char yydefact[] =
{
       3,     0,     1,     0,    18,    18,    18,    18,     0,     9,
       0,     2,     4,     5,     6,     7,     8,    53,     0,     0,
       0,     0,    58,     0,     0,    54,    58,    62,    21,    44,
      25,    27,     0,     0,    19,     0,     0,    41,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,    57,    58,
       0,     0,    18,    65,    52,     0,    56,    26,    28,    33,
      25,    27,     0,     0,    47,    20,    39,    42,    29,    31,
      40,     0,    45,    49,     0,     0,    45,    51,     0,     0,
       0,    45,     0,    45,    59,     0,    67,     0,     0,    55,
      34,     0,    26,    28,     0,    48,    30,    32,    45,    46,
      11,    45,     0,    15,    50,    45,    45,    61,    45,    17,
      68,     0,     0,     0,     0,    35,     0,     0,    10,    14,
      45,    13,    60,    16,    66,     0,    45,    36,    38,    22,
       0,    24,    12,    45,    64,    37,    23,    63
};

/* YYDEFGOTO[NTERM-NUM]. */
static const yysigned_char yydefgoto[] =
{
      -1,     1,    11,    12,    13,    14,    18,    34,    35,    36,
      37,    38,    39,   100,    65,    43,    15,    24,    25,    48,
      49,    26,    52,    53
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -56
static const short int yypact[] =
{
     -56,    91,   -56,   -12,   -56,   -56,   -56,   -56,   102,   -56,
      31,   -56,   -56,   -56,   -56,   -56,   -56,   -56,    53,   104,
      53,    53,    31,    26,    60,   -56,    31,   -56,   -56,   -56,
      -2,   113,    34,   136,   -56,    32,    55,   -56,   125,    52,
      61,   110,    84,     9,   125,    86,   125,    98,   -56,    31,
     117,   118,   -56,   -56,   -56,   102,   -56,   122,   124,    87,
     129,   134,    32,   109,   -56,   -56,   -56,   -56,   135,   137,
     -56,   130,   138,   -56,   132,     9,   138,   -56,   139,   140,
     141,   138,   142,   138,   -56,    32,   -56,   131,    53,   -56,
     133,   144,   -56,   -56,    75,   -56,   -56,   -56,   138,   -56,
     -56,   138,   143,   -56,   -56,   138,   138,   -56,   138,   -56,
     -56,    89,   125,   145,   147,   150,    48,    19,   -56,   -56,
     138,   -56,   -56,   -56,   -56,   146,   138,   153,   -56,   -56,
      22,   -56,   -56,   138,   -56,   -56,   -56,   -56
};

/* YYPGOTO[NTERM-NUM].  */
static const yysigned_char yypgoto[] =
{
     -56,   -56,   -56,   -56,   -56,   -56,    28,   -56,   126,   -56,
     -35,    -5,   -19,   -55,   -45,   -37,   -56,   -56,   103,   -18,
      29,   -56,   -56,   119
};

/* 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 -44
static const short int yytable[] =
{
      42,    45,    47,    70,    75,    86,    70,    17,    56,    70,
      77,    70,    57,   -29,    41,    44,    46,    94,    29,    71,
      77,   103,    74,    77,    79,    80,   107,    82,   109,   -43,
      16,    84,    78,    19,    20,    21,     6,    50,   131,    27,
     110,   136,    78,   118,    59,    78,   119,    51,    63,    67,
     121,   122,    10,   123,    28,    64,   102,   117,    68,    69,
      40,    32,    29,    30,    31,   132,    32,   129,    54,   113,
      66,   134,    72,   -43,    33,    73,    70,    70,   137,   130,
      88,    70,   111,   112,    55,    68,    69,    40,    32,   116,
      67,     2,     3,   125,     4,     5,     6,     7,     8,    68,
      69,    90,    32,    22,    76,    28,    81,    23,   124,    91,
       9,    67,    10,    29,    30,    31,    40,    32,    83,    29,
      68,    69,    40,    32,   -43,    33,    67,    58,   -31,    50,
     -43,    85,    95,    63,    29,    68,    69,   -30,    32,   -32,
      64,    68,    69,    92,    32,   -43,    60,    61,    93,    96,
      98,    97,   101,   104,   115,   114,    99,   127,    89,    62,
     105,   106,   108,   120,   128,   126,   133,   135,     0,     0,
      87
};

static const short int yycheck[] =
{
      19,    20,    21,    38,    41,    50,    41,    19,    26,    44,
       1,    46,    14,    15,    19,    20,    21,    62,     9,    38,
       1,    76,    41,     1,    43,    44,    81,    46,    83,    20,
       1,    49,    23,     5,     6,     7,     5,    11,    19,    10,
      85,    19,    23,    98,    10,    23,   101,    21,    16,     1,
     105,   106,    21,   108,     1,    23,    75,    94,    10,    11,
      12,    13,     9,    10,    11,   120,    13,    19,     8,    88,
      15,   126,    20,    20,    21,    14,   111,   112,   133,   116,
      52,   116,    87,    88,    24,    10,    11,    12,    13,    94,
       1,     0,     1,   112,     3,     4,     5,     6,     7,    10,
      11,    14,    13,     1,    20,     1,    20,     5,    19,    22,
      19,     1,    21,     9,    10,    11,    12,    13,    20,     9,
      10,    11,    12,    13,    20,    21,     1,    14,    15,    11,
      20,    14,    23,    16,     9,    10,    11,    15,    13,    15,
      23,    10,    11,    14,    13,    20,    10,    11,    14,    14,
      20,    14,    20,    14,    10,    22,    18,    10,    55,    33,
      20,    20,    20,    20,    14,    20,    20,    14,    -1,    -1,
      51
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const unsigned char yystos[] =
{
       0,    26,     0,     1,     3,     4,     5,     6,     7,    19,
      21,    27,    28,    29,    30,    41,    45,    19,    31,    31,
      31,    31,     1,     5,    42,    43,    46,    45,     1,     9,
      10,    11,    13,    21,    32,    33,    34,    35,    36,    37,
      12,    36,    37,    40,    36,    37,    36,    37,    44,    45,
      11,    21,    47,    48,     8,    24,    44,    14,    14,    10,
      10,    11,    33,    16,    23,    39,    15,     1,    10,    11,
      35,    37,    20,    14,    37,    40,    20,     1,    23,    37,
      37,    20,    37,    20,    44,    14,    39,    48,    31,    43,
      14,    22,    14,    14,    39,    23,    14,    14,    20,    18,
      38,    20,    37,    38,    14,    20,    20,    38,    20,    38,
      39,    36,    36,    37,    22,    10,    36,    40,    38,    38,
      20,    38,    38,    38,    19,    37,    20,    10,    14,    19,
      40,    19,    38,    20,    38,    14,    19,    38
};

#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 (YY_("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 long int yylno = yyrline[yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
             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
   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.  */
static YYSIZE_T
#   if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
#   else
yystrlen (yystr)
     const char *yystr;
#   endif
{
  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
{
  char *yyd = yydest;
  const char *yys = yysrc;

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

  return yyd - 1;
}
#  endif
# endif

# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      size_t yyn = 0;
      char const *yyp = yystr;

      for (;;)
	switch (*++yyp)
	  {
	  case '\'':
	  case ',':
	    goto do_not_strip_quotes;

	  case '\\':
	    if (*++yyp != '\\')
	      goto do_not_strip_quotes;
	    /* Fall through.  */
	  default:
	    if (yyres)
	      yyres[yyn] = *yyp;
	    yyn++;
	    break;

	  case '"':
	    if (yyres)
	      yyres[yyn] = '\0';
	    return yyn;
	  }
    do_not_strip_quotes: ;
    }

  if (! yyres)
    return yystrlen (yystr);

  return yystpcpy (yyres, yystr) - yyres;
}
# endif

#endif /* YYERROR_VERBOSE */