kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-09-06 12:36:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove extra dependencies

Browse Source 
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@6421 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Kevin P. Fleming
2005-08-26 19:55:11 +00:00
parent 66e69e0143
commit 6319baba24
3 changed files with 102 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@@ -352,10 +352,10 @@ ifneq ($(wildcard .tags-depend),)
include .tags-depend include .tags-depend
endif endif
ast_expr2.c: FORCE ast_expr2.c:
bison -d --name-prefix=ast_yy ast_expr2.y -o ast_expr2.c bison -d --name-prefix=ast_yy ast_expr2.y -o ast_expr2.c
ast_expr2f.c: FORCE ast_expr2f.c:
flex ast_expr2.fl flex ast_expr2.fl
testexpr2: ast_expr2f.c ast_expr2.c ast_expr2.h testexpr2: ast_expr2f.c ast_expr2.c ast_expr2.h

177
ast_expr2.c
View File

@@ -1,7 +1,7 @@
/* A Bison parser, made by GNU Bison 1.875d. */ /* A Bison parser, made by GNU Bison 1.875. */
/* Skeleton parser for Yacc-like parsing with Bison, /* Skeleton parser for Yacc-like parsing with Bison,
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -260,7 +260,7 @@ typedef union YYSTYPE {
struct val *val; struct val *val;
} YYSTYPE; } YYSTYPE;
/* Line 191 of yacc.c. */ /* Line 191 of yacc.c. */
#line 264 "ast_expr2.c" #line 263 "ast_expr2.c"
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_TRIVIAL 1
@@ -287,24 +287,16 @@ extern int ast_yylex __P((YYSTYPE *, YYLTYPE *, yyscan_t));
/* Line 214 of yacc.c. */ /* Line 214 of yacc.c. */
#line 291 "ast_expr2.c" #line 290 "ast_expr2.c"
#if ! defined (yyoverflow) || YYERROR_VERBOSE #if ! defined (yyoverflow) || YYERROR_VERBOSE
# ifndef YYFREE
# define YYFREE free
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
# endif
/* The parser invokes alloca or malloc; define the necessary symbols. */ /* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA
# define YYSTACK_ALLOC alloca # define YYSTACK_ALLOC alloca
# endif
# else # else
# ifndef YYSTACK_USE_ALLOCA
# if defined (alloca) || defined (_ALLOCA_H) # if defined (alloca) || defined (_ALLOCA_H)
# define YYSTACK_ALLOC alloca # define YYSTACK_ALLOC alloca
# else # else
@@ -313,6 +305,7 @@ extern int ast_yylex __P((YYSTYPE *, YYLTYPE *, yyscan_t));
# endif # endif
# endif # endif
# endif # endif
# endif
# ifdef YYSTACK_ALLOC # ifdef YYSTACK_ALLOC
/* Pacify GCC's `empty if-body' warning. */ /* Pacify GCC's `empty if-body' warning. */
@@ -322,21 +315,20 @@ extern int ast_yylex __P((YYSTYPE *, YYLTYPE *, yyscan_t));
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t # define YYSIZE_T size_t
# endif # endif
# define YYSTACK_ALLOC YYMALLOC # define YYSTACK_ALLOC malloc
# define YYSTACK_FREE YYFREE # define YYSTACK_FREE free
# endif # endif
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
#if (! defined (yyoverflow) \ #if (! defined (yyoverflow) \
&& (! defined (__cplusplus) \ && (! defined (__cplusplus) \
|| (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \ || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
&& defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */ /* A type that is properly aligned for any stack member. */
union yyalloc union yyalloc
{ {
short int yyss; short yyss;
YYSTYPE yyvs; YYSTYPE yyvs;
YYLTYPE yyls; YYLTYPE yyls;
}; };
@@ -347,13 +339,13 @@ union yyalloc
/* The size of an array large to enough to hold all stacks, each with /* The size of an array large to enough to hold all stacks, each with
N elements. */ N elements. */
# define YYSTACK_BYTES(N) \ # define YYSTACK_BYTES(N) \
((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ 2 * YYSTACK_GAP_MAXIMUM) + 2 * YYSTACK_GAP_MAXIMUM)
/* Copy COUNT objects from FROM to TO. The source and destination do /* Copy COUNT objects from FROM to TO. The source and destination do
not overlap. */ not overlap. */
# ifndef YYCOPY # ifndef YYCOPY
# if defined (__GNUC__) && 1 < __GNUC__ # if 1 < __GNUC__
# define YYCOPY(To, From, Count) \ # define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From))) __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else # else
@@ -389,7 +381,7 @@ union yyalloc
#if defined (__STDC__) || defined (__cplusplus) #if defined (__STDC__) || defined (__cplusplus)
typedef signed char yysigned_char; typedef signed char yysigned_char;
#else #else
typedef short int yysigned_char; typedef short yysigned_char;
#endif #endif
/* YYFINAL -- State number of the termination state. */ /* YYFINAL -- State number of the termination state. */
@@ -495,7 +487,7 @@ static const char *const yytname[] =
# ifdef YYPRINT # ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */ token YYLEX-NUM. */
static const unsigned short int yytoknum[] = static const unsigned short yytoknum[] =
{ {
0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
@@ -632,8 +624,7 @@ static const unsigned char yystos[] =
#define YYACCEPT goto yyacceptlab #define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab #define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab #define YYERROR goto yyerrlab1
/* Like YYERROR except do call yyerror. This remains here temporarily /* Like YYERROR except do call yyerror. This remains here temporarily
to ease the transition to the new meaning of YYERROR, for GCC. to ease the transition to the new meaning of YYERROR, for GCC.
@@ -668,10 +659,10 @@ while (0)
#ifndef YYLLOC_DEFAULT #ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \ # define YYLLOC_DEFAULT(Current, Rhs, N) \
((Current).first_line = (Rhs)[1].first_line, \ Current.first_line = Rhs[1].first_line; \
(Current).first_column = (Rhs)[1].first_column, \ Current.first_column = Rhs[1].first_column; \
(Current).last_line = (Rhs)[N].last_line, \ Current.last_line = Rhs[N].last_line; \
(Current).last_column = (Rhs)[N].last_column) Current.last_column = Rhs[N].last_column;
#endif #endif
/* YYLEX -- calling `yylex' with the right arguments. */ /* YYLEX -- calling `yylex' with the right arguments. */
@@ -715,17 +706,17 @@ do { \
/*------------------------------------------------------------------. /*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its | | yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). | | TOP (cinluded). |
`------------------------------------------------------------------*/ `------------------------------------------------------------------*/
#if defined (__STDC__) || defined (__cplusplus) #if defined (__STDC__) || defined (__cplusplus)
static void static void
yy_stack_print (short int *bottom, short int *top) yy_stack_print (short *bottom, short *top)
#else #else
static void static void
yy_stack_print (bottom, top) yy_stack_print (bottom, top)
short int *bottom; short *bottom;
short int *top; short *top;
#endif #endif
{ {
YYFPRINTF (stderr, "Stack now"); YYFPRINTF (stderr, "Stack now");
@@ -755,9 +746,9 @@ yy_reduce_print (yyrule)
#endif #endif
{ {
int yyi; int yyi;
unsigned int yylno = yyrline[yyrule]; unsigned int yylineno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
yyrule - 1, yylno); yyrule - 1, yylineno);
/* Print the symbols being reduced, and their result. */ /* Print the symbols being reduced, and their result. */
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
@@ -794,7 +785,7 @@ int yydebug;
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */ evaluated with infinite-precision integer arithmetic. */
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 #if YYMAXDEPTH == 0
# undef YYMAXDEPTH # undef YYMAXDEPTH
#endif #endif
@@ -998,9 +989,9 @@ YYLTYPE yylloc;
to reallocate them elsewhere. */ to reallocate them elsewhere. */
/* The state stack. */ /* The state stack. */
short int yyssa[YYINITDEPTH]; short yyssa[YYINITDEPTH];
short int *yyss = yyssa; short *yyss = yyssa;
register short int *yyssp; register short *yyssp;
/* The semantic value stack. */ /* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE yyvsa[YYINITDEPTH];
@@ -1041,7 +1032,6 @@ YYLTYPE yylloc;
yyssp = yyss; yyssp = yyss;
yyvsp = yyvs; yyvsp = yyvs;
yylsp = yyls; yylsp = yyls;
goto yysetstate; goto yysetstate;
/*------------------------------------------------------------. /*------------------------------------------------------------.
@@ -1067,7 +1057,7 @@ YYLTYPE yylloc;
these so that the &'s don't force the real ones into these so that the &'s don't force the real ones into
memory. */ memory. */
YYSTYPE *yyvs1 = yyvs; YYSTYPE *yyvs1 = yyvs;
short int *yyss1 = yyss; short *yyss1 = yyss;
YYLTYPE *yyls1 = yyls; YYLTYPE *yyls1 = yyls;
/* Each stack pointer address is followed by the size of the /* Each stack pointer address is followed by the size of the
@@ -1095,7 +1085,7 @@ YYLTYPE yylloc;
yystacksize = YYMAXDEPTH; yystacksize = YYMAXDEPTH;
{ {
short int *yyss1 = yyss; short *yyss1 = yyss;
union yyalloc *yyptr = union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr) if (! yyptr)
@@ -1224,7 +1214,7 @@ yyreduce:
yyval = yyvsp[1-yylen]; yyval = yyvsp[1-yylen];
/* Default location. */ /* Default location. */
YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen); YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
YY_REDUCE_PRINT (yyn); YY_REDUCE_PRINT (yyn);
switch (yyn) switch (yyn)
{ {
@@ -1376,8 +1366,8 @@ yyreduce:
} }
/* Line 1010 of yacc.c. */ /* Line 991 of yacc.c. */
#line 1381 "ast_expr2.c" #line 1370 "ast_expr2.c"
yyvsp -= yylen; yyvsp -= yylen;
yyssp -= yylen; yyssp -= yylen;
@@ -1418,33 +1408,18 @@ yyerrlab:
{ {
YYSIZE_T yysize = 0; YYSIZE_T yysize = 0;
int yytype = YYTRANSLATE (yychar); int yytype = YYTRANSLATE (yychar);
const char* yyprefix;
char *yymsg; char *yymsg;
int yyx; int yyx, yycount;
yycount = 0;
/* Start YYX at -YYN if negative to avoid negative indexes in /* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. */ YYCHECK. */
int yyxbegin = yyn < 0 ? -yyn : 0; for (yyx = yyn < 0 ? -yyn : 0;
yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 0;
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
{ yysize += yystrlen (yytname[yyx]) + 15, yycount++;
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); yysize += yystrlen ("syntax error, unexpected ") + 1;
yycount += 1; yysize += yystrlen (yytname[yytype]);
if (yycount == 5)
{
yysize = 0;
break;
}
}
yysize += (sizeof ("syntax error, unexpected ")
+ yystrlen (yytname[yytype]));
yymsg = (char *) YYSTACK_ALLOC (yysize); yymsg = (char *) YYSTACK_ALLOC (yysize);
if (yymsg != 0) if (yymsg != 0)
{ {
@@ -1453,13 +1428,16 @@ yyerrlab:
if (yycount < 5) if (yycount < 5)
{ {
yyprefix = ", expecting "; yycount = 0;
for (yyx = yyxbegin; yyx < yyxend; ++yyx) for (yyx = yyn < 0 ? -yyn : 0;
yyx < (int) (sizeof (yytname) / sizeof (char *));
yyx++)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
{ {
yyp = yystpcpy (yyp, yyprefix); const char *yyq = ! yycount ? ", expecting " : " or ";
yyp = yystpcpy (yyp, yyq);
yyp = yystpcpy (yyp, yytname[yyx]); yyp = yystpcpy (yyp, yytname[yyx]);
yyprefix = " or "; yycount++;
} }
} }
yyerror (yymsg); yyerror (yymsg);
@@ -1480,59 +1458,53 @@ yyerrlab:
/* If just tried and failed to reuse lookahead token after an /* If just tried and failed to reuse lookahead token after an
error, discard it. */ error, discard it. */
if (yychar <= YYEOF) /* Return failure if at end of input. */
{
/* If at end of input, pop the error token,
then the rest of the stack, then return failure. */
if (yychar == YYEOF) if (yychar == YYEOF)
for (;;)
{ {
/* Pop the error token. */
YYPOPSTACK; YYPOPSTACK;
if (yyssp == yyss) /* Pop the rest of the stack. */
YYABORT; while (yyss < yyssp)
{
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[*yyssp], yyvsp, yylsp); yydestruct (yystos[*yyssp], yyvsp, yylsp);
YYPOPSTACK;
} }
YYABORT;
} }
else
{
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
yydestruct (yytoken, &yylval, &yylloc); yydestruct (yytoken, &yylval, &yylloc);
yychar = YYEMPTY; yychar = YYEMPTY;
*++yylerrsp = yylloc; *++yylerrsp = yylloc;
} }
}
/* Else will try to reuse lookahead token after shifting the error /* Else will try to reuse lookahead token after shifting the error
token. */ token. */
goto yyerrlab1; goto yyerrlab2;
/*---------------------------------------------------. /*----------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. | | yyerrlab1 -- error raised explicitly by an action. |
`---------------------------------------------------*/ `----------------------------------------------------*/
yyerrorlab: yyerrlab1:
#ifdef __GNUC__ /* Suppress GCC warning that yyerrlab1 is unused when no action
/* Pacify GCC when the user code never invokes YYERROR and the label invokes YYERROR. */
yyerrorlab therefore never appears in user code. */ #if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__) \
if (0) && !defined __cplusplus
goto yyerrorlab; __attribute__ ((__unused__))
#endif #endif
yyvsp -= yylen;
yyssp -= yylen;
yystate = *yyssp;
yylerrsp = yylsp; yylerrsp = yylsp;
*++yylerrsp = yyloc; *++yylerrsp = yyloc;
yylsp -= yylen; goto yyerrlab2;
goto yyerrlab1;
/*-------------------------------------------------------------. /*---------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. | | yyerrlab2 -- pop states until the error token can be shifted. |
`-------------------------------------------------------------*/ `---------------------------------------------------------------*/
yyerrlab1: yyerrlab2:
yyerrstatus = 3; /* Each real token shifted decrements this. */ yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;) for (;;)
@@ -1555,8 +1527,9 @@ yyerrlab1:
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[yystate], yyvsp, yylsp); yydestruct (yystos[yystate], yyvsp, yylsp);
YYPOPSTACK; yyvsp--;
yystate = *yyssp; yystate = *--yyssp;
yylsp--;
YY_STACK_PRINT (yyss, yyssp); YY_STACK_PRINT (yyss, yyssp);
} }
@@ -1566,7 +1539,7 @@ yyerrlab1:
YYDPRINTF ((stderr, "Shifting error token, ")); YYDPRINTF ((stderr, "Shifting error token, "));
*++yyvsp = yylval; *++yyvsp = yylval;
YYLLOC_DEFAULT (yyloc, yylsp, yylerrsp - yylsp); YYLLOC_DEFAULT (yyloc, yylsp, (yylerrsp - yylsp));
*++yylsp = yyloc; *++yylsp = yyloc;
yystate = yyn; yystate = yyn;

8
ast_expr2.h
View File

@@ -1,7 +1,7 @@
/* A Bison parser, made by GNU Bison 1.875d. */ /* A Bison parser, made by GNU Bison 1.875. */
/* Skeleton parser for Yacc-like parsing with Bison, /* Skeleton parser for Yacc-like parsing with Bison,
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -82,8 +82,8 @@
typedef union YYSTYPE { typedef union YYSTYPE {
struct val *val; struct val *val;
} YYSTYPE; } YYSTYPE;
/* Line 1285 of yacc.c. */ /* Line 1249 of yacc.c. */
#line 87 "ast_expr2.h" #line 86 "ast_expr2.h"
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_TRIVIAL 1