config_gram.c

AVR的USB文件

};

/* 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[] =
{
       2,     0,     0,     0,    13,    11,     0,     3,     4,     0,
       0,     0,     0,     0,     0,     0,     1,     5,     6,     7,
       0,     0,     0,    35,    36,    37,    38,    39,    40,    41,
      42,    43,    44,    45,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,    14,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,    12,     0,     9,     8,    10,    64,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,    46,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,    19,     0,    59,    57,    55,    56,
      54,    58,    51,    68,    67,    62,    50,    48,    49,    60,
      52,    53,    63,    61,    15,    66,    47,    17,    26,    24,
      31,    21,    30,    29,    33,    32,    27,    28,    22,    23,
      25,    34,    20,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,    65,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,    69,    16,
      18,    73,    71,    76,    75,    74,    77,    78,    79,    72,
      80,    70
};

/* YYDEFGOTO[NTERM-NUM]. */
static const short yydefgoto[] =
{
      -1,     6,     7,     8,     9,    15,    10,    14,   115,   118,
      61,    62,    45,    46,   109,   105,   112,    47,    95,   106,
     143,   144
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -83
static const yysigned_char yypact[] =
{
      -4,   -45,   -37,   -28,   -83,   -83,    34,    -4,   -83,   -25,
     -22,   -23,   -20,   -17,    54,    72,   -83,   -83,   -83,   -83,
     -14,   -13,   -12,   -83,   -83,   -83,   -83,   -83,   -83,   -83,
     -83,   -83,   -83,   -83,   -11,   -19,   -10,    -7,    -6,    -5,
       9,    14,    16,    19,    20,    21,    54,    22,    24,    25,
      26,    27,    28,    31,    33,    36,    37,    39,    41,    47,
      48,    72,    49,   -83,   -83,   -83,   -83,    32,    51,    46,
      52,    55,    53,   -30,     0,   -27,   -32,    56,    50,   -83,
      59,    61,    60,    56,    63,    67,    68,    69,    70,    71,
     -15,    59,    73,    75,   -83,    -1,   -83,   -83,   -83,   -83,
     -83,   -83,   -83,   -83,   -83,   -83,   -83,   -83,   -83,   -83,
     -83,   -83,   -83,   -83,   -83,    58,   -83,   -83,    78,   -83,
     -83,    58,   -83,   -83,   -83,   -83,   -83,   -83,   -83,   -83,
      78,   -83,   -83,    74,    79,    80,    81,    82,    83,    84,
      85,    86,    87,    -1,    77,    88,    90,    91,   -32,    92,
      93,    94,   -32,    95,    96,    97,    56,    89,   -83,   -83,
     -83,   -83,   -83,   -83,   -83,   -83,   -83,   -83,   -83,   -83,
      58,   -83
};

/* YYPGOTO[NTERM-NUM].  */
static const short yypgoto[] =
{
     -83,   -83,   -83,   142,   -83,   -83,   -83,   -83,   -82,    76,
     -83,   100,   -74,   -83,   -83,   -83,   -83,   104,   -83,   -76,
     -83,    23
};

/* 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, parse error.  */
#define YYTABLE_NINF -1
static const unsigned char yytable[] =
{
     113,   121,    23,    24,    25,    26,    27,    28,    29,    30,
      31,    32,    33,   102,   133,   134,    11,     1,     2,     3,
     107,   142,   110,   128,    12,   111,   103,   104,   103,   104,
     108,   135,   136,    13,    16,   137,     4,    18,     5,   129,
      19,    20,    67,   138,    21,   139,   140,    22,    63,    64,
      65,    68,   141,    66,    69,    70,    71,    23,    24,    25,
      26,    27,    28,    29,    30,    31,    32,    33,    34,   142,
      72,    35,   162,    36,   170,    73,   166,    74,    37,    38,
      75,    76,    77,    39,    79,    80,    81,    82,    83,    84,
      48,    40,    85,    41,    86,    96,    49,    87,    88,    50,
      89,    51,    90,    42,    43,    44,    52,    53,    91,    92,
      98,    94,   116,    54,    97,    99,   101,    55,   145,   100,
     114,    56,   117,   120,    57,   119,   122,    58,    59,    60,
     123,   124,   125,   126,   127,   147,   131,   132,   146,   158,
     148,   149,   150,   151,   152,   153,   154,   155,   156,    17,
      78,   171,   159,   160,   161,   163,   164,   165,   167,   168,
     169,    93,     0,     0,     0,     0,   157,   130
};

static const short yycheck[] =
{
      76,    83,     3,     4,     5,     6,     7,     8,     9,    10,
      11,    12,    13,    43,    15,    16,    61,    21,    22,    23,
      20,    95,    49,    38,    61,    52,    58,    59,    58,    59,
      30,    32,    33,    61,     0,    36,    40,    62,    42,    54,
      62,    64,    61,    44,    64,    46,    47,    64,    62,    62,
      62,    61,    53,    64,    61,    61,    61,     3,     4,     5,
       6,     7,     8,     9,    10,    11,    12,    13,    14,   143,
      61,    17,   148,    19,   156,    61,   152,    61,    24,    25,
      61,    61,    61,    29,    62,    61,    61,    61,    61,    61,
      18,    37,    61,    39,    61,    63,    24,    61,    61,    27,
      61,    29,    61,    49,    50,    51,    34,    35,    61,    61,
      64,    62,    62,    41,    63,    63,    63,    45,    60,    64,
      64,    49,    63,    63,    52,    64,    63,    55,    56,    57,
      63,    63,    63,    63,    63,    61,    63,    62,    60,    62,
      61,    61,    61,    61,    61,    61,    61,    61,    61,     7,
      46,    62,    64,    63,    63,    63,    63,    63,    63,    63,
      63,    61,    -1,    -1,    -1,    -1,   143,    91
};

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

#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);						\
      yychar1 = 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.  */

#define YYLEX	yylex ()

/* 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)
/* 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)
#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 YYOUT.  |
`-----------------------------*/

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

  if (yytype < YYNTOKENS)
    {
      YYFPRINTF (yyout, "token %s (", yytname[yytype]);
# ifdef YYPRINT
      YYPRINT (yyout, yytoknum[yytype], yyvalue);
# endif
    }
  else
    YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);

  switch (yytype)
    {
      default:
        break;
    }
  YYFPRINTF (yyout, ")");
}
#endif /* YYDEBUG. */


/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

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

  switch (yytype)
    {
      default:
        break;
    }
}



/* The user can define YYPARSE_PARAM as the name of an argument to be passed
   into yyparse.  The argument should have type void *.
   It should actually point to an object.
   Grammar actions can access the variable by casting it
   to the proper pointer type.  */

#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL
# else
#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
# endif
#else /* !YYPARSE_PARAM */
# define YYPARSE_PARAM_ARG
# define YYPARSE_PARAM_DECL
#endif /* !YYPARSE_PARAM */

/* Prevent warning if -Wstrict-prototypes.  */
#ifdef __GNUC__
# ifdef YYPARSE_PARAM
int yyparse (void *);
# else
int yyparse (void);
# endif
#endif


/* The lookahead symbol.  */
int yychar;

/* The semantic value of the lookahead symbol.  */
YYSTYPE yylval;

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


int
yyparse (YYPARSE_PARAM_ARG)
     YYPARSE_PARAM_DECL
{
  
  register int yystate;
  register int yyn;
  int yyresult;
  /* Number of tokens to shift before error messages enabled.  */
  int yyerrstatus;
  /* Lookahead token as an internal (translated) token number.  */
  int yychar1 = 0;

  /* Three stacks and their tools:
     `yyss': related to states,
     `yyvs': related to semantic values,
     `yyls': related to locations.

     Refer to the stacks thru separate pointers, to allow yyoverflow
     to reallocate them elsewhere.  */

  /* The state stack.  */
  short	yyssa[YYINITDEPTH];
  short *yyss = yyssa;
  register short *yyssp;

  /* The semantic value stack.  */
  YYSTYPE yyvsa[YYINITDEPTH];
  YYSTYPE *yyvs = yyvsa;
  register YYSTYPE *yyvsp;



#define YYPOPSTACK   (yyvsp--, yyssp--)

  YYSIZE_T yystacksize = YYINITDEPTH;

  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;


  /* When reducing, the number of symbols on the RHS of the reduced
     rule.  */
  int yylen;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY;		/* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */

  yyssp = yyss;
  yyvsp = yyvs;

  goto yysetstate;

/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
 yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed. so pushing a state here evens the stacks.
     */
  yyssp++;

 yysetstate:
  *yyssp = yystate;

  if (yyssp >= yyss + yystacksize - 1)
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYSIZE_T yysize = yyssp - yyss + 1;

#ifdef yyoverflow
      {
	/* Give user a chance to reallocate the stack. Use copies of
	   these so that the &'s don't force the real ones into
	   memory.  */
	YYSTYPE *yyvs1 = yyvs;
	short *yyss1 = yyss;


	/* Each stack pointer address is followed by the size of the
	   data in use in that stack, in bytes.  This used to be a
	   conditional around just the two extra args, but that might
	   be undefined if yyoverflow is a macro.  */
	yyoverflow ("parser stack overflow",
		    &yyss1, yysize * sizeof (*yyssp),
		    &yyvs1, yysize * sizeof (*yyvsp),

		    &yystacksize);

	yyss = yyss1;
	yyvs = yyvs1;
      }
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
      goto yyoverflowlab;
# else
      /* Extend the stack our own way.  */
      if (yystacksize >= YYMAXDEPTH)
	goto yyoverflowlab;
      yystacksize *= 2;
      if (yystacksize > YYMAXDEPTH)
	yystacksize = YYMAXDEPTH;

      {
	short *yyss1 = yyss;
	union yyalloc *yyptr =
	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
	if (! yyptr)
	  goto yyoverflowlab;
	YYSTACK_RELOCATE (yyss);