yacc.tab.cpp

c语言的简化编译器

       0,    36,    27,     0,    10,    23,    25,    35,    70,     0,
       0,    40,     0,    37,    38,    41,    28,     0,     0,     0,
       0,    29,    31,     0,    39,     0,    67,    30,     0,     0,
      32
};

/* YYDEFGOTO[NTERM-NUM]. */
static const yysigned_char yydefgoto[] =
{
      -1,     5,     6,     7,     8,    90,    20,    91,    11,    22,
      23,    24,    92,    93,    94,   112,   113,   114,    95,    33,
      34,    65,    66,    35
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -74
static const short yypact[] =
{
      22,   -74,   -11,   -74,   -74,     4,   -74,   -74,    22,   -28,
      32,   -74,    20,   -74,   -74,   -74,   -23,    16,    51,    16,
     -74,    37,    34,   -74,    24,    29,   -74,   -74,   -74,    51,
     187,    51,   337,   -74,   -74,    45,    52,   -74,    41,    16,
      51,   -74,   -74,    55,   294,   -74,    51,    51,    51,    51,
      51,    51,    51,    51,    51,    51,    51,    51,    51,    51,
      41,    91,   -74,   -74,   220,    62,   -74,    51,   -74,   362,
     362,   -15,   -15,   -15,   -15,   -15,   -15,    36,    36,    56,
      56,   -74,   337,   -74,    53,    57,    58,    27,   -74,   -74,
     -74,    70,   -74,   128,   -74,   230,    51,   -74,   -74,    51,
      51,   187,   -74,   258,    69,   -74,   -74,   -74,   -74,   303,
     330,   -74,    64,   -74,    63,   337,   -74,   165,   165,    51,
     187,    86,   -74,   266,   -74,   165,    51,   -74,    80,   165,
     -74
};

/* YYPGOTO[NTERM-NUM].  */
static const yysigned_char yypgoto[] =
{
     -74,   -74,   -74,   102,   -74,     0,   -74,    46,   -74,    92,
      77,   -74,   -36,   -74,   -73,   -74,    -3,   -74,   -17,   -24,
     -74,    -8,    23,   -20
};

/* 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 -1
static const unsigned char yytable[] =
{
       9,    32,    62,    18,    13,    41,    15,    45,     9,    42,
      12,    42,    19,    44,    54,    55,    56,    57,    58,     1,
     106,     3,     4,    64,    83,     1,     2,     3,     4,    69,
      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
      80,    81,    82,    98,   121,   122,    10,    42,    25,    26,
      27,    28,   127,    16,    10,    17,   130,    29,    37,    38,
      39,   102,    30,    21,    40,    21,    31,    56,    57,    58,
     103,    59,    25,    26,    27,    28,    43,    60,    61,    64,
      67,    29,   109,   110,   115,    21,    30,    97,    99,    58,
      31,   104,   100,   101,     1,    18,     3,     4,   119,   120,
     125,   111,   123,   115,    84,   129,    85,    86,    87,    64,
      14,    36,    25,    26,    27,    28,    63,   124,   128,   108,
     111,    29,     0,     0,     0,    88,    30,     0,    61,    89,
      31,     1,     0,     3,     4,     0,     0,     0,     0,     0,
       0,    84,     0,    85,    86,    87,     0,     0,     0,    25,
      26,    27,    28,     0,     0,     0,     0,     0,    29,     0,
       0,     0,    88,    30,     0,    61,   105,    31,     1,     0,
       3,     4,     0,     0,     0,     0,     0,     0,    84,     0,
      85,    86,    87,     0,     0,     0,    25,    26,    27,    28,
       1,     0,     3,     4,     0,    29,     0,     0,     0,    88,
      30,     0,    61,     0,    31,     0,     0,     0,    25,    26,
      27,    28,     0,     0,     0,     0,     0,    29,     0,     0,
       0,     0,    30,     0,     0,     0,    31,    46,    47,    48,
      49,    50,    51,     0,     0,     0,     0,    46,    47,    48,
      49,    50,    51,     0,     0,     0,     0,    52,    53,    54,
      55,    56,    57,    58,     0,     0,    96,    52,    53,    54,
      55,    56,    57,    58,   107,    46,    47,    48,    49,    50,
      51,     0,     0,    46,    47,    48,    49,    50,    51,     0,
       0,     0,     0,     0,     0,    52,    53,    54,    55,    56,
      57,    58,   116,    52,    53,    54,    55,    56,    57,    58,
     126,    46,    47,    48,    49,    50,    51,     0,     0,     0,
      46,    47,    48,    49,    50,    51,     0,     0,     0,    68,
       0,    52,    53,    54,    55,    56,    57,    58,   117,     0,
      52,    53,    54,    55,    56,    57,    58,    46,    47,    48,
      49,    50,    51,     0,    46,    47,    48,    49,    50,    51,
       0,     0,     0,     0,     0,   118,     0,    52,    53,    54,
      55,    56,    57,    58,    52,    53,    54,    55,    56,    57,
      58,    48,    49,    50,    51,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,    52,
      53,    54,    55,    56,    57,    58
};

static const short yycheck[] =
{
       0,    18,    38,    26,     0,    29,    34,    31,     8,    29,
      21,    31,    35,    30,    29,    30,    31,    32,    33,     3,
      93,     5,     6,    40,    60,     3,     4,     5,     6,    46,
      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
      57,    58,    59,    67,   117,   118,     0,    67,    21,    22,
      23,    24,   125,    21,     8,    35,   129,    30,    21,    25,
      36,    34,    35,    17,    35,    19,    39,    31,    32,    33,
      87,    26,    21,    22,    23,    24,    30,    25,    37,    96,
      25,    30,    99,   100,   101,    39,    35,    25,    35,    33,
      39,    21,    35,    35,     3,    26,     5,     6,    34,    36,
      14,   101,   119,   120,    13,    25,    15,    16,    17,   126,
       8,    19,    21,    22,    23,    24,    39,   120,   126,    96,
     120,    30,    -1,    -1,    -1,    34,    35,    -1,    37,    38,
      39,     3,    -1,     5,     6,    -1,    -1,    -1,    -1,    -1,
      -1,    13,    -1,    15,    16,    17,    -1,    -1,    -1,    21,
      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    -1,
      -1,    -1,    34,    35,    -1,    37,    38,    39,     3,    -1,
       5,     6,    -1,    -1,    -1,    -1,    -1,    -1,    13,    -1,
      15,    16,    17,    -1,    -1,    -1,    21,    22,    23,    24,
       3,    -1,     5,     6,    -1,    30,    -1,    -1,    -1,    34,
      35,    -1,    37,    -1,    39,    -1,    -1,    -1,    21,    22,
      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    -1,    -1,
      -1,    -1,    35,    -1,    -1,    -1,    39,     7,     8,     9,
      10,    11,    12,    -1,    -1,    -1,    -1,     7,     8,     9,
      10,    11,    12,    -1,    -1,    -1,    -1,    27,    28,    29,
      30,    31,    32,    33,    -1,    -1,    36,    27,    28,    29,
      30,    31,    32,    33,    34,     7,     8,     9,    10,    11,
      12,    -1,    -1,     7,     8,     9,    10,    11,    12,    -1,
      -1,    -1,    -1,    -1,    -1,    27,    28,    29,    30,    31,
      32,    33,    34,    27,    28,    29,    30,    31,    32,    33,
      34,     7,     8,     9,    10,    11,    12,    -1,    -1,    -1,
       7,     8,     9,    10,    11,    12,    -1,    -1,    -1,    25,
      -1,    27,    28,    29,    30,    31,    32,    33,    25,    -1,
      27,    28,    29,    30,    31,    32,    33,     7,     8,     9,
      10,    11,    12,    -1,     7,     8,     9,    10,    11,    12,
      -1,    -1,    -1,    -1,    -1,    25,    -1,    27,    28,    29,
      30,    31,    32,    33,    27,    28,    29,    30,    31,    32,
      33,     9,    10,    11,    12,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    27,
      28,    29,    30,    31,    32,    33
};

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

#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 yyerrlab1

/* 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 -- Compute the default location (before the actions
   are run).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)         \
  Current.first_line   = Rhs[1].first_line;      \
  Current.first_column = Rhs[1].first_column;    \
  Current.last_line    = Rhs[N].last_line;       \
  Current.last_column  = Rhs[N].last_column;
#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 YYDSYMPRINT(Args)			\
do {						\
  if (yydebug)					\
    yysymprint Args;				\
} while (0)

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

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

#if defined (__STDC__) || defined (__cplusplus)
static void
yy_stack_print (short *bottom, short *top)
#else
static void
yy_stack_print (bottom, top)
    short *bottom;
    short *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 yylineno = yyrline[yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
             yyrule - 1, yylineno);
  /* 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 YYDSYMPRINT(Args)
# define YYDSYMPRINTF(Title, Token, 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.  */

#if YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif

#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]);
# ifdef YYPRINT
      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# endif
    }
  else
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

  switch (yytype)
    {
      default:
        break;
    }
  YYFPRINTF (yyoutput, ")");
}

#endif /* ! YYDEBUG */