ael.tab.c

asterisk 是一个很有知名度开源软件

     269,   276,   273,   187,   187,  -219,   187,   243,   187,  -219,
     244,   274,  -219,   247,  -219,   115,  -219,   213,  -219,  -219,
    -219,   251,   252,   257,   264,  -219,  -219,  -219,   283,  -219,
    -219,   284,  -219,  -219,   242,   286,   260,   262,   285,   292,
     124,   265,   267,  -219,   267,   172,    15,   176,  -219,   165,
    -219,    -6,   290,   294,  -219,  -219,  -219,   293,   277,   213,
      12,  -219,   129,  -219,   295,   296,    56,  -219,  -219,  -219,
     268,   291,   298,   187,   187,   187,   187,  -219,  -219,  -219,
    -219,   213,  -219,  -219,  -219,    56,    56,  -219,   267,   267,
     301,   301,   301,   301,   271,  -219,  -219,  -219,   300,  -219,
     307,   267,  -219,  -219,   275,   309,   213,  -219
};

/* YYPGOTO[NTERM-NUM].  */
static const yytype_int16 yypgoto[] =
{
    -219,  -219,  -219,   310,   -19,  -219,  -219,  -219,  -219,   125,
       5,  -219,   -15,  -219,  -219,   -31,  -219,  -219,  -219,  -114,
    -219,   154,    25,  -219,  -219,   143,   217,  -218,   -82,  -219,
     -59,  -219,  -219,  -219,  -219,  -219,  -219,  -219,  -219,  -219,
    -219,  -219,  -219,  -219,  -219,   108,   103,  -219,   227,  -219,
    -219,  -219,   -65,   209,  -219,   -51
};

/* 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 -133
static const yytype_int16 yytable[] =
{
      96,    28,   133,   111,   251,   172,   252,   174,   101,    62,
     -66,   167,    22,   108,   118,   168,   -20,  -132,    13,    25,
      51,    64,    75,   145,   112,    51,   187,    25,   254,   156,
      25,    26,    65,   157,   158,   144,   183,    27,    51,   184,
      50,    96,   221,   160,    14,    50,   155,    26,    15,   101,
     278,   279,    16,    27,    23,   109,    26,   119,    50,   146,
      76,   -49,    27,   283,    77,   159,   200,   203,    78,   201,
      17,   157,   158,   129,    79,    80,    81,    20,    82,   130,
     194,   233,    83,    84,    85,    86,    87,    71,    36,    88,
      89,   -49,   -49,   -49,    37,    32,   207,    38,    48,    91,
      72,   225,   226,   159,   227,   126,   229,   128,    29,   161,
       1,    73,   212,    21,   139,   162,   119,     2,     3,    76,
     -49,   149,   150,    77,    40,     4,     5,    78,   -31,   190,
     187,    41,   267,    79,    80,    81,   264,    82,   234,   201,
      42,    83,    84,    85,    86,    87,    32,    31,    88,    89,
      34,   276,   277,    33,    43,    44,    35,    48,    91,   216,
     217,   218,    45,    46,    47,    48,    49,   186,   187,    60,
     188,   270,   271,   272,   273,   263,   187,    59,   256,    61,
     262,    76,   253,   187,    63,    77,   255,   187,   141,    78,
     142,    32,    66,   143,    67,    79,    80,    81,    68,    82,
      69,    70,   275,    83,    84,    85,    86,    87,    74,   102,
      88,    89,   257,   103,   104,    90,   105,    76,    47,    48,
      91,    77,   106,   116,   117,    78,   122,   287,   124,   127,
     130,    79,    80,    81,   135,    82,   136,   137,   138,    83,
      84,    85,    86,    87,   151,   140,    88,    89,   153,    -2,
      18,   163,   -14,   164,   165,    48,    91,     1,   166,   171,
     173,   176,   175,   178,     2,     3,   189,   179,   185,   192,
     195,   210,     4,     5,   199,   197,   204,   213,   205,   206,
     208,   211,   222,   223,   224,   146,   228,   230,   231,   239,
     232,   240,   241,   243,   235,   237,   246,   247,   258,   259,
     238,   260,   261,   244,   268,   245,   265,   266,   249,   269,
     250,   221,   187,   281,   280,   282,   286,    19,   285,   209,
     215,   154,   242,   248,   169,     0,     0,   152
};

static const yytype_int16 yycheck[] =
{
      59,    20,    84,    68,   222,   119,   224,   121,    59,    40,
      11,     1,     1,     1,    73,     5,     5,     5,    43,    14,
      35,    32,    53,     7,     5,    40,    11,    22,    13,     7,
      25,    37,    43,    11,    12,    94,    10,    43,    53,    13,
      35,   100,    43,   108,     4,    40,   105,    37,    24,   100,
     268,   269,    23,    43,    43,    43,    37,     1,    53,    43,
       4,     5,    43,   281,     8,    43,     7,     7,    12,    10,
       0,    11,    12,    37,    18,    19,    20,     3,    22,    43,
     139,   195,    26,    27,    28,    29,    30,     1,     1,    33,
      34,    35,    36,    37,     7,     9,   161,    10,    42,    43,
      14,   183,   184,    43,   186,    80,   188,    82,    43,     8,
       8,    25,   171,     6,    89,    14,     1,    15,    16,     4,
       5,     8,     9,     8,     1,    23,    24,    12,     5,    10,
      11,     8,   246,    18,    19,    20,     7,    22,   197,    10,
      17,    26,    27,    28,    29,    30,     9,    22,    33,    34,
      25,   265,   266,     5,    31,    32,     4,    42,    43,    35,
      36,    37,    39,    40,    41,    42,    43,    10,    11,    43,
      13,   253,   254,   255,   256,   240,    11,     4,    13,    43,
     239,     4,    10,    11,    25,     8,    10,    11,     6,    12,
       8,     9,     6,    11,     4,    18,    19,    20,     4,    22,
       4,    43,   261,    26,    27,    28,    29,    30,     5,     8,
      33,    34,   231,    43,     6,    38,    25,     4,    41,    42,
      43,     8,    43,     9,    43,    12,    43,   286,     6,     6,
      43,    18,    19,    20,     8,    22,     8,     8,     6,    26,
      27,    28,    29,    30,     5,    43,    33,    34,     8,     0,
       1,     5,     3,     5,    13,    42,    43,     8,     8,    25,
       5,     8,     6,     4,    15,    16,     8,    43,    43,     8,
       4,     8,    23,    24,    43,    21,    43,     7,    43,    43,
      43,    43,    13,     7,    11,    43,    43,    43,    14,    25,
      43,     8,     8,     7,    43,    43,    11,     5,     8,     5,
      43,     8,    25,    43,    13,    43,    11,    11,    43,    11,
      43,    43,    11,    13,    43,     8,     7,     7,    43,   165,
     177,   104,   214,   220,   115,    -1,    -1,   100
};

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

#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).