ael.tab.c

来自「Asterisk-1.4.4最新内核源代码」· C语言 代码 · 共 2,072 行 · 第 1/5 页

      71,    72,  -115,    73,   198,   143,    74,    75,    76,    77,
      78,    64,    44,    79,    80,    65,    36,    19,   241,  -113,
    -113,  -113,    82,   134,   135,    37,   211,    -2,    15,    25,
     -14,  -115,  -115,  -115,    27,     1,   250,   251,    38,    39,
      53,    64,     2,     3,     1,   -27,    40,    41,    42,    43,
       4,     2,     3,   171,   168,   244,   245,   246,   247,     4,
      31,   145,   145,   153,   237,   146,   147,   154,   145,   153,
      54,    55,  -123,   234,   167,   168,   164,   169,   181,   165,
     238,   182,    58,   182,   249,   193,   194,   195,   168,   168,
     229,   231,   232,   228,   168,   230,   168,    52,    59,    60,
      61,   148,   159,    94,    92,    91,    93,   109,   261,   112,
      95,    97,   120,   107,   121,   115,   122,   123,   136,   188,
     138,   125,   144,   149,   156,   157,   178,   160,   166,   170,
     173,   176,   180,   185,   189,   190,   199,   200,   208,   218,
     186,   222,   201,   131,   192,   221,   233,   235,   205,   216,
     207,   209,   239,   240,   223,   243,    16,   212,   242,   168,
     214,   215,   255,   256,   236,   260,   217,     0,   139,     0,
     219,   137,    30,     0,   220,     0,   224,     0,   225,     0,
       0,     0,     0,     0,   198,   152,     0,   254,   259,     0,
       0,     0,     0,     0,     0,     0,     0,     0,    66
};

static const yytype_int16 yycheck[] =
{
      52,    17,    75,   106,    60,   199,     1,   201,     1,    31,
       5,    63,     1,     1,    41,    36,     9,     5,     7,    41,
      41,    10,     7,    36,     5,     7,     4,    12,    41,     4,
       1,    24,    84,     8,     5,     1,     1,    12,    90,     5,
       5,    36,    94,    18,    19,    20,    41,    22,   242,   243,
      25,    26,    27,    28,    29,    36,    41,    32,    33,    41,
      41,   255,    37,    34,    35,    36,    41,     0,    34,    35,
      36,     7,   124,   176,    11,    71,    12,    73,     6,    13,
       8,     9,     3,    11,    80,     4,     1,    21,   144,     8,
       5,   164,   165,    12,   167,     6,   169,    31,     1,    18,
      19,    20,     5,    22,    41,    41,    25,    26,    27,    28,
      29,     1,    46,    32,    33,     5,     8,    41,   221,    34,
      35,    36,    41,     8,     9,    17,   178,     0,     1,    41,
       3,    34,    35,    36,     9,     8,   239,   240,    30,    31,
      41,     1,    15,    16,     8,     5,    38,    39,    40,    41,
      23,    15,    16,    10,    11,   228,   229,   230,   231,    23,
       4,     1,     1,     1,   216,     5,     5,     5,     1,     1,
      41,    24,     5,     5,    10,    11,    10,    13,     7,    13,
       7,    10,     6,    10,   236,    34,    35,    36,    11,    11,
      13,    13,   208,    10,    11,    10,    11,     4,     4,     4,
       4,    13,     4,    24,    41,     8,     6,     6,   260,     6,
      41,    41,     8,    41,     8,    41,     8,     6,     5,   148,
       8,    41,     8,     8,     6,     8,    21,    41,    41,     8,
       8,     4,    41,    41,     8,     7,    13,     7,    14,     7,
      41,     5,    11,    41,   158,    11,     8,     8,    41,    24,
      41,    41,    11,    11,   197,    11,     6,    41,    13,    11,
      41,    41,    13,     8,    24,     7,   191,    -1,    93,    -1,
      41,    90,    21,    -1,    41,    -1,    41,    -1,    41,    -1,
      -1,    -1,    -1,    -1,    41,   103,    -1,    41,    41,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    46
};

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

#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 (&yylloc, parseio, 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 (&yylval, &yylloc, YYLEX_PARAM)
#else
# define YYLEX yylex (&yylval, &yylloc)
#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, Location, parseio); \
      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, YYLTYPE const * const yylocationp, struct parse_io *parseio)
#else
static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseio)
    FILE *yyoutput;
    int yytype;
    YYSTYPE const * const yyvaluep;
    YYLTYPE const * const yylocationp;
    struct parse_io *parseio;
#endif
{
  if (!yyvaluep)
    return;
  YYUSE (yylocationp);
  YYUSE (parseio);
# 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, YYLTYPE const * const yylocationp, struct parse_io *parseio)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, parseio)
    FILE *yyoutput;
    int yytype;
    YYSTYPE const * const yyvaluep;
    YYLTYPE const * const yylocationp;
    struct parse_io *parseio;
#endif
{
  if (yytype < YYNTOKENS)
    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
  else
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

  YY_LOCATION_PRINT (yyoutput, *yylocationp);
  YYFPRINTF (yyoutput, ": ");
  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseio);
  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, YYLTYPE *yylsp, int yyrule, struct parse_io *parseio)
#else
static void
yy_reduce_print (yyvsp, yylsp, yyrule, parseio)
    YYSTYPE *yyvsp;
    YYLTYPE *yylsp;
    int yyrule;
    struct parse_io *parseio;
#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)])
		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , parseio);
      fprintf (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)		\
do {					\
  if (yydebug)				\
    yy_reduce_print (yyvsp, yylsp, Rule, parseio); \
} 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
static YYSIZE_T
yystrlen (yystr)
    const char *yystr;
#endif
{
  YYSIZE_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}
#  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.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static char *
yystpcpy (char *yydest, const char *yysrc)
#else
static char *
yystpcpy (yydest, yysrc)
    char *yydest;
    const char *yysrc;
#endif
{
  char *yyd = yydest;
  const char *yys = yysrc;

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