version 1.11, 2012/12/17 07:20:45 |
version 1.12, 2018/03/29 01:32:54 |
Line 242 typedef union YYSTYPE |
|
Line 242 typedef union YYSTYPE |
|
/* Line 214 of yacc.c */ |
/* Line 214 of yacc.c */ |
#line 83 "parse.y" |
#line 83 "parse.y" |
|
|
FNODE f; |
FNODE f; |
SNODE s; |
SNODE s; |
NODE n; |
NODE n; |
NODE2 n2; |
NODE2 n2; |
int i; |
int i; |
pointer p; |
pointer p; |
|
|
|
|
|
|
|
|
# endif |
# endif |
# if (defined __cplusplus && ! defined _STDLIB_H \ |
# if (defined __cplusplus && ! defined _STDLIB_H \ |
&& ! ((defined YYMALLOC || defined malloc) \ |
&& ! ((defined YYMALLOC || defined malloc) \ |
&& (defined YYFREE || defined free))) |
&& (defined YYFREE || defined free))) |
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
# ifndef _STDLIB_H |
# ifndef _STDLIB_H |
# define _STDLIB_H 1 |
# define _STDLIB_H 1 |
Line 422 void free (void *); /* INFRINGES ON USER NAME SPACE */ |
|
Line 422 void free (void *); /* INFRINGES ON USER NAME SPACE */ |
|
|
|
#if (! defined yyoverflow \ |
#if (! defined yyoverflow \ |
&& (! defined __cplusplus \ |
&& (! defined __cplusplus \ |
|| (defined YYSTYPE_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 |
|
|
# 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 |
# define YYCOPY(To, From, Count) \ |
# define YYCOPY(To, From, Count) \ |
do \ |
do \ |
{ \ |
{ \ |
YYSIZE_T yyi; \ |
YYSIZE_T yyi; \ |
for (yyi = 0; yyi < (Count); yyi++) \ |
for (yyi = 0; yyi < (Count); yyi++) \ |
(To)[yyi] = (From)[yyi]; \ |
(To)[yyi] = (From)[yyi]; \ |
} \ |
} \ |
while (YYID (0)) |
while (YYID (0)) |
# endif |
# endif |
# endif |
# endif |
|
|
elements in the stack, and YYPTR gives the new location of the |
elements in the stack, and YYPTR gives the new location of the |
stack. Advance YYPTR to a properly aligned location for the next |
stack. Advance YYPTR to a properly aligned location for the next |
stack. */ |
stack. */ |
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ |
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ |
do \ |
do \ |
{ \ |
{ \ |
YYSIZE_T yynewbytes; \ |
YYSIZE_T yynewbytes; \ |
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ |
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ |
Stack = &yyptr->Stack_alloc; \ |
Stack = &yyptr->Stack_alloc; \ |
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
yyptr += yynewbytes / sizeof (*yyptr); \ |
yyptr += yynewbytes / sizeof (*yyptr); \ |
} \ |
} \ |
while (YYID (0)) |
while (YYID (0)) |
|
|
#endif |
#endif |
|
|
#define YYUNDEFTOK 2 |
#define YYUNDEFTOK 2 |
#define YYMAXUTOK 307 |
#define YYMAXUTOK 307 |
|
|
#define YYTRANSLATE(YYX) \ |
#define YYTRANSLATE(YYX) \ |
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
|
|
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
Line 1085 static const yytype_uint8 yystos[] = |
|
Line 1085 static const yytype_uint8 yystos[] = |
|
65, 95, 66 |
65, 95, 66 |
}; |
}; |
|
|
#define yyerrok (yyerrstatus = 0) |
#define yyerrok (yyerrstatus = 0) |
#define yyclearin (yychar = YYEMPTY) |
#define yyclearin (yychar = YYEMPTY) |
#define YYEMPTY (-2) |
#define YYEMPTY (-2) |
#define YYEOF 0 |
#define YYEOF 0 |
|
|
#define YYACCEPT goto yyacceptlab |
#define YYACCEPT goto yyacceptlab |
#define YYABORT goto yyabortlab |
#define YYABORT goto yyabortlab |
#define YYERROR goto yyerrorlab |
#define YYERROR goto yyerrorlab |
|
|
|
|
/* 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. |
Once GCC version 2 has supplanted version 1, this can go. */ |
Once GCC version 2 has supplanted version 1, this can go. */ |
|
|
#define YYFAIL goto yyerrlab |
#define YYFAIL goto yyerrlab |
|
|
#define YYRECOVERING() (!!yyerrstatus) |
#define YYRECOVERING() (!!yyerrstatus) |
|
|
#define YYBACKUP(Token, Value) \ |
#define YYBACKUP(Token, Value) \ |
do \ |
do \ |
if (yychar == YYEMPTY && yylen == 1) \ |
if (yychar == YYEMPTY && yylen == 1) \ |
{ \ |
{ \ |
yychar = (Token); \ |
yychar = (Token); \ |
yylval = (Value); \ |
yylval = (Value); \ |
yytoken = YYTRANSLATE (yychar); \ |
yytoken = YYTRANSLATE (yychar); \ |
YYPOPSTACK (1); \ |
YYPOPSTACK (1); \ |
goto yybackup; \ |
goto yybackup; \ |
} \ |
} \ |
else \ |
else \ |
{ \ |
{ \ |
yyerror (YY_("syntax error: cannot back up")); \ |
yyerror (YY_("syntax error: cannot back up")); \ |
YYERROR; \ |
YYERROR; \ |
} \ |
} \ |
while (YYID (0)) |
while (YYID (0)) |
|
|
|
|
#define YYTERROR 1 |
#define YYTERROR 1 |
#define YYERRCODE 256 |
#define YYERRCODE 256 |
|
|
|
|
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
Line 1131 while (YYID (0)) |
|
Line 1131 while (YYID (0)) |
|
|
|
#define YYRHSLOC(Rhs, K) ((Rhs)[K]) |
#define YYRHSLOC(Rhs, K) ((Rhs)[K]) |
#ifndef YYLLOC_DEFAULT |
#ifndef YYLLOC_DEFAULT |
# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
do \ |
do \ |
if (YYID (N)) \ |
if (YYID (N)) \ |
{ \ |
{ \ |
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ |
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ |
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \ |
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \ |
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \ |
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \ |
} \ |
} \ |
else \ |
else \ |
{ \ |
{ \ |
(Current).first_line = (Current).last_line = \ |
(Current).first_line = (Current).last_line = \ |
YYRHSLOC (Rhs, 0).last_line; \ |
YYRHSLOC (Rhs, 0).last_line; \ |
(Current).first_column = (Current).last_column = \ |
(Current).first_column = (Current).last_column = \ |
YYRHSLOC (Rhs, 0).last_column; \ |
YYRHSLOC (Rhs, 0).last_column; \ |
} \ |
} \ |
while (YYID (0)) |
while (YYID (0)) |
#endif |
#endif |
|
|
Line 1157 while (YYID (0)) |
|
Line 1157 while (YYID (0)) |
|
|
|
#ifndef YY_LOCATION_PRINT |
#ifndef YY_LOCATION_PRINT |
# if YYLTYPE_IS_TRIVIAL |
# if YYLTYPE_IS_TRIVIAL |
# define YY_LOCATION_PRINT(File, Loc) \ |
# define YY_LOCATION_PRINT(File, Loc) \ |
fprintf (File, "%d.%d-%d.%d", \ |
fprintf (File, "%d.%d-%d.%d", \ |
(Loc).first_line, (Loc).first_column, \ |
(Loc).first_line, (Loc).first_column, \ |
(Loc).last_line, (Loc).last_column) |
(Loc).last_line, (Loc).last_column) |
# else |
# else |
# define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
# define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
# endif |
# endif |
Line 1183 while (YYID (0)) |
|
Line 1183 while (YYID (0)) |
|
# define YYFPRINTF fprintf |
# define YYFPRINTF fprintf |
# endif |
# endif |
|
|
# define YYDPRINTF(Args) \ |
# define YYDPRINTF(Args) \ |
do { \ |
do { \ |
if (yydebug) \ |
if (yydebug) \ |
YYFPRINTF Args; \ |
YYFPRINTF Args; \ |
} while (YYID (0)) |
} while (YYID (0)) |
|
|
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
do { \ |
do { \ |
if (yydebug) \ |
if (yydebug) \ |
{ \ |
{ \ |
YYFPRINTF (stderr, "%s ", Title); \ |
YYFPRINTF (stderr, "%s ", Title); \ |
yy_symbol_print (stderr, \ |
yy_symbol_print (stderr, \ |
Type, Value); \ |
Type, Value); \ |
YYFPRINTF (stderr, "\n"); \ |
YYFPRINTF (stderr, "\n"); \ |
} \ |
} \ |
} while (YYID (0)) |
} while (YYID (0)) |
|
|
|
|
Line 1229 yy_symbol_value_print (yyoutput, yytype, yyvaluep) |
|
Line 1229 yy_symbol_value_print (yyoutput, yytype, yyvaluep) |
|
switch (yytype) |
switch (yytype) |
{ |
{ |
default: |
default: |
break; |
break; |
} |
} |
} |
} |
|
|
Line 1284 yy_stack_print (yybottom, yytop) |
|
Line 1284 yy_stack_print (yybottom, yytop) |
|
YYFPRINTF (stderr, "\n"); |
YYFPRINTF (stderr, "\n"); |
} |
} |
|
|
# define YY_STACK_PRINT(Bottom, Top) \ |
# define YY_STACK_PRINT(Bottom, Top) \ |
do { \ |
do { \ |
if (yydebug) \ |
if (yydebug) \ |
yy_stack_print ((Bottom), (Top)); \ |
yy_stack_print ((Bottom), (Top)); \ |
} while (YYID (0)) |
} while (YYID (0)) |
|
|
|
|
Line 1310 yy_reduce_print (yyvsp, yyrule) |
|
Line 1310 yy_reduce_print (yyvsp, yyrule) |
|
int yyi; |
int yyi; |
unsigned long int yylno = yyrline[yyrule]; |
unsigned long int yylno = yyrline[yyrule]; |
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", |
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", |
yyrule - 1, yylno); |
yyrule - 1, yylno); |
/* The symbols being reduced. */ |
/* The symbols being reduced. */ |
for (yyi = 0; yyi < yynrhs; yyi++) |
for (yyi = 0; yyi < yynrhs; yyi++) |
{ |
{ |
YYFPRINTF (stderr, " $%d = ", yyi + 1); |
YYFPRINTF (stderr, " $%d = ", yyi + 1); |
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
&(yyvsp[(yyi + 1) - (yynrhs)]) |
&(yyvsp[(yyi + 1) - (yynrhs)]) |
); |
); |
YYFPRINTF (stderr, "\n"); |
YYFPRINTF (stderr, "\n"); |
} |
} |
} |
} |
|
|
# define YY_REDUCE_PRINT(Rule) \ |
# define YY_REDUCE_PRINT(Rule) \ |
do { \ |
do { \ |
if (yydebug) \ |
if (yydebug) \ |
yy_reduce_print (yyvsp, Rule); \ |
yy_reduce_print (yyvsp, Rule); \ |
} while (YYID (0)) |
} while (YYID (0)) |
|
|
|
|
|
|
|
|
/* YYINITDEPTH -- initial size of the parser's stacks. */ |
/* YYINITDEPTH -- initial size of the parser's stacks. */ |
#ifndef YYINITDEPTH |
#ifndef YYINITDEPTH |
# define YYINITDEPTH 200 |
# define YYINITDEPTH 200 |
#endif |
#endif |
|
|
Line 1427 yytnamerr (char *yyres, const char *yystr) |
|
Line 1427 yytnamerr (char *yyres, const char *yystr) |
|
char const *yyp = yystr; |
char const *yyp = yystr; |
|
|
for (;;) |
for (;;) |
switch (*++yyp) |
switch (*++yyp) |
{ |
{ |
case '\'': |
case '\'': |
case ',': |
case ',': |
goto do_not_strip_quotes; |
goto do_not_strip_quotes; |
|
|
case '\\': |
case '\\': |
if (*++yyp != '\\') |
if (*++yyp != '\\') |
goto do_not_strip_quotes; |
goto do_not_strip_quotes; |
/* Fall through. */ |
/* Fall through. */ |
default: |
default: |
if (yyres) |
if (yyres) |
yyres[yyn] = *yyp; |
yyres[yyn] = *yyp; |
yyn++; |
yyn++; |
break; |
break; |
|
|
case '"': |
case '"': |
if (yyres) |
if (yyres) |
yyres[yyn] = '\0'; |
yyres[yyn] = '\0'; |
return yyn; |
return yyn; |
} |
} |
do_not_strip_quotes: ; |
do_not_strip_quotes: ; |
} |
} |
|
|
Line 1485 yysyntax_error (char *yyresult, int yystate, int yycha |
|
Line 1485 yysyntax_error (char *yyresult, int yystate, int yycha |
|
|
|
# if 0 |
# if 0 |
/* This is so xgettext sees the translatable formats that are |
/* This is so xgettext sees the translatable formats that are |
constructed on the fly. */ |
constructed on the fly. */ |
YY_("syntax error, unexpected %s"); |
YY_("syntax error, unexpected %s"); |
YY_("syntax error, unexpected %s, expecting %s"); |
YY_("syntax error, unexpected %s, expecting %s"); |
YY_("syntax error, unexpected %s, expecting %s or %s"); |
YY_("syntax error, unexpected %s, expecting %s or %s"); |
Line 1498 yysyntax_error (char *yyresult, int yystate, int yycha |
|
Line 1498 yysyntax_error (char *yyresult, int yystate, int yycha |
|
static char const yyexpecting[] = ", expecting %s"; |
static char const yyexpecting[] = ", expecting %s"; |
static char const yyor[] = " or %s"; |
static char const yyor[] = " or %s"; |
char yyformat[sizeof yyunexpected |
char yyformat[sizeof yyunexpected |
+ sizeof yyexpecting - 1 |
+ sizeof yyexpecting - 1 |
+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) |
+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) |
* (sizeof yyor - 1))]; |
* (sizeof yyor - 1))]; |
char const *yyprefix = yyexpecting; |
char const *yyprefix = yyexpecting; |
|
|
/* 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; |
int yyxbegin = yyn < 0 ? -yyn : 0; |
|
|
/* Stay within bounds of both yycheck and yytname. */ |
/* Stay within bounds of both yycheck and yytname. */ |
Line 1516 yysyntax_error (char *yyresult, int yystate, int yycha |
|
Line 1516 yysyntax_error (char *yyresult, int yystate, int yycha |
|
yyfmt = yystpcpy (yyformat, yyunexpected); |
yyfmt = yystpcpy (yyformat, yyunexpected); |
|
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
{ |
{ |
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
{ |
{ |
yycount = 1; |
yycount = 1; |
yysize = yysize0; |
yysize = yysize0; |
yyformat[sizeof yyunexpected - 1] = '\0'; |
yyformat[sizeof yyunexpected - 1] = '\0'; |
break; |
break; |
} |
} |
yyarg[yycount++] = yytname[yyx]; |
yyarg[yycount++] = yytname[yyx]; |
yysize1 = yysize + yytnamerr (0, yytname[yyx]); |
yysize1 = yysize + yytnamerr (0, yytname[yyx]); |
yysize_overflow |= (yysize1 < yysize); |
yysize_overflow |= (yysize1 < yysize); |
yysize = yysize1; |
yysize = yysize1; |
yyfmt = yystpcpy (yyfmt, yyprefix); |
yyfmt = yystpcpy (yyfmt, yyprefix); |
yyprefix = yyor; |
yyprefix = yyor; |
} |
} |
|
|
yyf = YY_(yyformat); |
yyf = YY_(yyformat); |
yysize1 = yysize + yystrlen (yyf); |
yysize1 = yysize + yystrlen (yyf); |
Line 1539 yysyntax_error (char *yyresult, int yystate, int yycha |
|
Line 1539 yysyntax_error (char *yyresult, int yystate, int yycha |
|
yysize = yysize1; |
yysize = yysize1; |
|
|
if (yysize_overflow) |
if (yysize_overflow) |
return YYSIZE_MAXIMUM; |
return YYSIZE_MAXIMUM; |
|
|
if (yyresult) |
if (yyresult) |
{ |
{ |
/* Avoid sprintf, as that infringes on the user's name space. |
/* Avoid sprintf, as that infringes on the user's name space. |
Don't have undefined behavior even if the translation |
Don't have undefined behavior even if the translation |
produced a string with the wrong number of "%s"s. */ |
produced a string with the wrong number of "%s"s. */ |
char *yyp = yyresult; |
char *yyp = yyresult; |
int yyi = 0; |
int yyi = 0; |
while ((*yyp = *yyf) != '\0') |
while ((*yyp = *yyf) != '\0') |
{ |
{ |
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
{ |
{ |
yyp += yytnamerr (yyp, yyarg[yyi++]); |
yyp += yytnamerr (yyp, yyarg[yyi++]); |
yyf += 2; |
yyf += 2; |
} |
} |
else |
else |
{ |
{ |
yyp++; |
yyp++; |
yyf++; |
yyf++; |
} |
} |
} |
} |
} |
} |
return yysize; |
return yysize; |
} |
} |
} |
} |
Line 1595 yydestruct (yymsg, yytype, yyvaluep) |
|
Line 1595 yydestruct (yymsg, yytype, yyvaluep) |
|
{ |
{ |
|
|
default: |
default: |
break; |
break; |
} |
} |
} |
} |
|
|
|
|
|
|
#ifdef yyoverflow |
#ifdef yyoverflow |
{ |
{ |
/* Give user a chance to reallocate the stack. Use copies of |
/* Give user a chance to reallocate the stack. Use copies of |
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; |
yytype_int16 *yyss1 = yyss; |
yytype_int16 *yyss1 = yyss; |
|
|
/* Each stack pointer address is followed by the size of the |
/* Each stack pointer address is followed by the size of the |
data in use in that stack, in bytes. This used to be a |
data in use in that stack, in bytes. This used to be a |
conditional around just the two extra args, but that might |
conditional around just the two extra args, but that might |
be undefined if yyoverflow is a macro. */ |
be undefined if yyoverflow is a macro. */ |
yyoverflow (YY_("memory exhausted"), |
yyoverflow (YY_("memory exhausted"), |
&yyss1, yysize * sizeof (*yyssp), |
&yyss1, yysize * sizeof (*yyssp), |
&yyvs1, yysize * sizeof (*yyvsp), |
&yyvs1, yysize * sizeof (*yyvsp), |
&yystacksize); |
&yystacksize); |
|
|
yyss = yyss1; |
yyss = yyss1; |
yyvs = yyvs1; |
yyvs = yyvs1; |
} |
} |
#else /* no yyoverflow */ |
#else /* no yyoverflow */ |
# ifndef YYSTACK_RELOCATE |
# ifndef YYSTACK_RELOCATE |
|
|
# else |
# else |
/* Extend the stack our own way. */ |
/* Extend the stack our own way. */ |
if (YYMAXDEPTH <= yystacksize) |
if (YYMAXDEPTH <= yystacksize) |
goto yyexhaustedlab; |
goto yyexhaustedlab; |
yystacksize *= 2; |
yystacksize *= 2; |
if (YYMAXDEPTH < yystacksize) |
if (YYMAXDEPTH < yystacksize) |
yystacksize = YYMAXDEPTH; |
yystacksize = YYMAXDEPTH; |
|
|
{ |
{ |
yytype_int16 *yyss1 = yyss; |
yytype_int16 *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) |
goto yyexhaustedlab; |
goto yyexhaustedlab; |
YYSTACK_RELOCATE (yyss_alloc, yyss); |
YYSTACK_RELOCATE (yyss_alloc, yyss); |
YYSTACK_RELOCATE (yyvs_alloc, yyvs); |
YYSTACK_RELOCATE (yyvs_alloc, yyvs); |
# undef YYSTACK_RELOCATE |
# undef YYSTACK_RELOCATE |
if (yyss1 != yyssa) |
if (yyss1 != yyssa) |
YYSTACK_FREE (yyss1); |
YYSTACK_FREE (yyss1); |
} |
} |
# endif |
# endif |
#endif /* no yyoverflow */ |
#endif /* no yyoverflow */ |
|
|
yyvsp = yyvs + yysize - 1; |
yyvsp = yyvs + yysize - 1; |
|
|
YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
(unsigned long int) yystacksize)); |
(unsigned long int) yystacksize)); |
|
|
if (yyss + yystacksize - 1 <= yyssp) |
if (yyss + yystacksize - 1 <= yyssp) |
YYABORT; |
YYABORT; |
} |
} |
|
|
YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
|
|
if (yyn <= 0) |
if (yyn <= 0) |
{ |
{ |
if (yyn == 0 || yyn == YYTABLE_NINF) |
if (yyn == 0 || yyn == YYTABLE_NINF) |
goto yyerrlab; |
goto yyerrlab; |
yyn = -yyn; |
yyn = -yyn; |
goto yyreduce; |
goto yyreduce; |
} |
} |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 131 "parse.y" |
#line 131 "parse.y" |
{ |
{ |
parse_snode = (yyvsp[(1) - (1)].s); |
parse_snode = (yyvsp[(1) - (1)].s); |
if ( yychar >= 0 ) |
if ( yychar >= 0 ) |
fprintf(stderr, |
fprintf(stderr, |
"Warning: a token was wasted after an 'if' statement without 'else'.\n"); |
"Warning: a token was wasted after an 'if' statement without 'else'.\n"); |
YYACCEPT; |
YYACCEPT; |
} |
} |
break; |
break; |
|
|
case 3: |
case 3: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 178 "parse.y" |
#line 178 "parse.y" |
{ |
{ |
mkuf((yyvsp[(2) - (12)].p),asir_infile->name,(yyvsp[(6) - (12)].n), |
mkuf((yyvsp[(2) - (12)].p),asir_infile->name,(yyvsp[(6) - (12)].n), |
mksnode(1,S_CPLX,(yyvsp[(11) - (12)].n)),(yyvsp[(1) - (12)].i),asir_infile->ln,(yyvsp[(9) - (12)].p),CUR_MODULE); |
mksnode(1,S_CPLX,(yyvsp[(11) - (12)].n)),(yyvsp[(1) - (12)].i),asir_infile->ln,(yyvsp[(9) - (12)].p),CUR_MODULE); |
(yyval.s) = 0; NOPR; |
(yyval.s) = 0; NOPR; |
} |
} |
break; |
break; |
|
|
case 32: |
case 32: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 184 "parse.y" |
#line 184 "parse.y" |
{ |
{ |
CUR_MODULE = mkmodule((yyvsp[(2) - (3)].p)); |
CUR_MODULE = mkmodule((yyvsp[(2) - (3)].p)); |
MPVS = CUR_MODULE->pvs; |
MPVS = CUR_MODULE->pvs; |
(yyval.s) = mksnode(1,S_MODULE,CUR_MODULE); NOPR; |
(yyval.s) = mksnode(1,S_MODULE,CUR_MODULE); NOPR; |
} |
} |
break; |
break; |
|
|
case 33: |
case 33: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 263 "parse.y" |
#line 263 "parse.y" |
{ |
{ |
FUNC f; |
FUNC f; |
|
|
searchf(noargsysf,(yyvsp[(1) - (1)].p),&f); |
searchf(noargsysf,(yyvsp[(1) - (1)].p),&f); |
if ( f ) |
if ( f ) |
(yyval.f) = mkfnode(2,I_FUNC,f,NULLP); |
(yyval.f) = mkfnode(2,I_FUNC,f,NULLP); |
else { |
else { |
searchc((yyvsp[(1) - (1)].p),&f); |
searchc((yyvsp[(1) - (1)].p),&f); |
if ( f ) |
if ( f ) |
(yyval.f) = mkfnode(2,I_FUNC,f,mkfnode(1,I_LIST,NULLP)); |
(yyval.f) = mkfnode(2,I_FUNC,f,mkfnode(1,I_LIST,NULLP)); |
else { |
else { |
gen_searchf_searchonly((yyvsp[(1) - (1)].p),(FUNC *)&f); |
gen_searchf_searchonly((yyvsp[(1) - (1)].p),(FUNC *)&f); |
if ( f ) |
if ( f ) |
makesrvar(f,(P *)&val); |
makesrvar(f,(P *)&val); |
else |
else |
makevar((yyvsp[(1) - (1)].p),(P *)&val); |
makevar((yyvsp[(1) - (1)].p),(P *)&val); |
(yyval.f) = mkfnode(1,I_FORMULA,val); |
(yyval.f) = mkfnode(1,I_FORMULA,val); |
} |
} |
} |
} |
} |
} |
break; |
break; |
|
|
case 64: |
case 64: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 284 "parse.y" |
#line 284 "parse.y" |
{ |
{ |
gen_searchf((yyvsp[(1) - (4)].p),(FUNC *)&val); |
gen_searchf((yyvsp[(1) - (4)].p),(FUNC *)&val); |
print_crossref(val); |
print_crossref(val); |
(yyval.f) = mkfnode(2,I_FUNC,val,mkfnode(1,I_LIST,(yyvsp[(3) - (4)].n))); |
(yyval.f) = mkfnode(2,I_FUNC,val,mkfnode(1,I_LIST,(yyvsp[(3) - (4)].n))); |
} |
} |
break; |
break; |
|
|
case 65: |
case 65: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 291 "parse.y" |
#line 291 "parse.y" |
{ |
{ |
gen_searchf((yyvsp[(1) - (6)].p),(FUNC *)&val); |
gen_searchf((yyvsp[(1) - (6)].p),(FUNC *)&val); |
print_crossref(val); |
print_crossref(val); |
(yyval.f) = mkfnode(3,I_FUNC_OPT,val, |
(yyval.f) = mkfnode(3,I_FUNC_OPT,val, |
mkfnode(1,I_LIST,(yyvsp[(3) - (6)].n)),mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
mkfnode(1,I_LIST,(yyvsp[(3) - (6)].n)),mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
} |
} |
break; |
break; |
|
|
case 66: |
case 66: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 298 "parse.y" |
#line 298 "parse.y" |
{ |
{ |
gen_searchf((yyvsp[(3) - (6)].p),(FUNC *)&val); |
gen_searchf((yyvsp[(3) - (6)].p),(FUNC *)&val); |
print_crossref(val); |
print_crossref(val); |
(yyval.f) = mkfnode(2,I_MAP,val,mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
(yyval.f) = mkfnode(2,I_MAP,val,mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
} |
} |
break; |
break; |
|
|
case 67: |
case 67: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 304 "parse.y" |
#line 304 "parse.y" |
{ |
{ |
gen_searchf((yyvsp[(3) - (6)].p),(FUNC *)&val); |
gen_searchf((yyvsp[(3) - (6)].p),(FUNC *)&val); |
print_crossref(val); |
print_crossref(val); |
(yyval.f) = mkfnode(2,I_RECMAP,val,mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
(yyval.f) = mkfnode(2,I_RECMAP,val,mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
} |
} |
break; |
break; |
|
|
case 68: |
case 68: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 310 "parse.y" |
#line 310 "parse.y" |
{ |
{ |
searchpf((yyvsp[(1) - (7)].p),(FUNC *)&val); |
searchpf((yyvsp[(1) - (7)].p),(FUNC *)&val); |
(yyval.f) = mkfnode(3,I_PFDERIV,val,mkfnode(1,I_LIST,(yyvsp[(6) - (7)].n)),mkfnode(1,I_LIST,(yyvsp[(3) - (7)].n))); |
(yyval.f) = mkfnode(3,I_PFDERIV,val,mkfnode(1,I_LIST,(yyvsp[(6) - (7)].n)),mkfnode(1,I_LIST,(yyvsp[(3) - (7)].n))); |
} |
} |
break; |
break; |
|
|
case 69: |
case 69: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 315 "parse.y" |
#line 315 "parse.y" |
{ |
{ |
(yyval.f) = mkfnode(2,I_GETOPT,(yyvsp[(3) - (4)].p)); |
(yyval.f) = mkfnode(2,I_GETOPT,(yyvsp[(3) - (4)].p)); |
} |
} |
break; |
break; |
|
|
case 70: |
case 70: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 319 "parse.y" |
#line 319 "parse.y" |
{ |
{ |
(yyval.f) = mkfnode(2,I_GETOPT,NULLP); |
(yyval.f) = mkfnode(2,I_GETOPT,NULLP); |
} |
} |
break; |
break; |
|
|
case 71: |
case 71: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 323 "parse.y" |
#line 323 "parse.y" |
{ |
{ |
(yyval.f) = mkfnode(3,I_TIMER,(yyvsp[(3) - (8)].f),(yyvsp[(5) - (8)].f),(yyvsp[(7) - (8)].f)); |
(yyval.f) = mkfnode(3,I_TIMER,(yyvsp[(3) - (8)].f),(yyvsp[(5) - (8)].f),(yyvsp[(7) - (8)].f)); |
} |
} |
break; |
break; |
|
|
case 72: |
case 72: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 327 "parse.y" |
#line 327 "parse.y" |
{ |
{ |
searchf(parif,(yyvsp[(3) - (4)].p),(FUNC *)&val); |
searchf(parif,(yyvsp[(3) - (4)].p),(FUNC *)&val); |
if ( !val ) |
if ( !val ) |
mkparif((yyvsp[(3) - (4)].p),(FUNC *)&val); |
mkparif((yyvsp[(3) - (4)].p),(FUNC *)&val); |
(yyval.f) = mkfnode(2,I_FUNC,val,NULLP); |
(yyval.f) = mkfnode(2,I_FUNC,val,NULLP); |
} |
} |
break; |
break; |
|
|
case 73: |
case 73: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 334 "parse.y" |
#line 334 "parse.y" |
{ |
{ |
searchf(parif,(yyvsp[(3) - (6)].p),(FUNC *)&val); |
searchf(parif,(yyvsp[(3) - (6)].p),(FUNC *)&val); |
if ( !val ) |
if ( !val ) |
mkparif((yyvsp[(3) - (6)].p),(FUNC *)&val); |
mkparif((yyvsp[(3) - (6)].p),(FUNC *)&val); |
(yyval.f) = mkfnode(2,I_FUNC,val,mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
(yyval.f) = mkfnode(2,I_FUNC,val,mkfnode(1,I_LIST,(yyvsp[(5) - (6)].n))); |
} |
} |
break; |
break; |
|
|
case 74: |
case 74: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 341 "parse.y" |
#line 341 "parse.y" |
{ |
{ |
(yyval.f) = mkfnode(2,I_IFUNC,(yyvsp[(3) - (7)].f),mkfnode(1,I_LIST,(yyvsp[(6) - (7)].n)),NULLP); |
(yyval.f) = mkfnode(2,I_IFUNC,(yyvsp[(3) - (7)].f),mkfnode(1,I_LIST,(yyvsp[(6) - (7)].n)),NULLP); |
} |
} |
break; |
break; |
|
|
case 75: |
case 75: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 345 "parse.y" |
#line 345 "parse.y" |
{ |
{ |
(yyval.f) = mkfnode(3,I_IFUNC,(yyvsp[(3) - (9)].f),mkfnode(1,I_LIST,(yyvsp[(6) - (9)].n)), |
(yyval.f) = mkfnode(3,I_IFUNC,(yyvsp[(3) - (9)].f),mkfnode(1,I_LIST,(yyvsp[(6) - (9)].n)), |
mkfnode(1,I_LIST,(yyvsp[(8) - (9)].n))); |
mkfnode(1,I_LIST,(yyvsp[(8) - (9)].n))); |
} |
} |
break; |
break; |
|
|
case 76: |
case 76: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 350 "parse.y" |
#line 350 "parse.y" |
{ |
{ |
if ( main_parser || allow_create_var ) |
if ( main_parser || allow_create_var ) |
t = mkfnode(2,I_PVAR,makepvar((yyvsp[(1) - (4)].p)),NULLP); |
t = mkfnode(2,I_PVAR,makepvar((yyvsp[(1) - (4)].p)),NULLP); |
else { |
else { |
ind = searchpvar((yyvsp[(1) - (4)].p)); |
ind = searchpvar((yyvsp[(1) - (4)].p)); |
if ( ind == -1 ) { |
if ( ind == -1 ) { |
fprintf(stderr,"%s : no such variable.\n",(yyvsp[(1) - (4)].p)); |
fprintf(stderr,"%s : no such variable.\n",(yyvsp[(1) - (4)].p)); |
YYABORT; |
YYABORT; |
} else |
} else |
t = mkfnode(2,I_PVAR,ind,NULLP); |
t = mkfnode(2,I_PVAR,ind,NULLP); |
} |
} |
(yyval.f) = mkfnode(2,I_IFUNC,t,mkfnode(1,I_LIST,(yyvsp[(3) - (4)].n))); |
(yyval.f) = mkfnode(2,I_IFUNC,t,mkfnode(1,I_LIST,(yyvsp[(3) - (4)].n))); |
} |
} |
break; |
break; |
|
|
case 77: |
case 77: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 370 "parse.y" |
#line 370 "parse.y" |
{ |
{ |
if ( main_parser || allow_create_var ) |
if ( main_parser || allow_create_var ) |
(yyval.f) = mkfnode(2,I_PVAR,makepvar((yyvsp[(1) - (1)].p)),NULLP); |
(yyval.f) = mkfnode(2,I_PVAR,makepvar((yyvsp[(1) - (1)].p)),NULLP); |
else { |
else { |
ind = searchpvar((yyvsp[(1) - (1)].p)); |
ind = searchpvar((yyvsp[(1) - (1)].p)); |
if ( ind == -1 ) { |
if ( ind == -1 ) { |
fprintf(stderr,"%s : no such variable.\n",(yyvsp[(1) - (1)].p)); |
fprintf(stderr,"%s : no such variable.\n",(yyvsp[(1) - (1)].p)); |
YYABORT; |
YYABORT; |
} else |
} else |
(yyval.f) = mkfnode(2,I_PVAR,ind,NULLP); |
(yyval.f) = mkfnode(2,I_PVAR,ind,NULLP); |
} |
} |
} |
} |
break; |
break; |
|
|
case 81: |
case 81: |
|
|
/* Line 1455 of yacc.c */ |
/* Line 1455 of yacc.c */ |
#line 383 "parse.y" |
#line 383 "parse.y" |
{ |
{ |
if ( (yyvsp[(1) - (4)].f)->id == I_PVAR || (yyvsp[(1) - (4)].f)->id == I_INDEX ) { |
if ( (yyvsp[(1) - (4)].f)->id == I_PVAR || (yyvsp[(1) - (4)].f)->id == I_INDEX ) { |
appendtonode((NODE)(yyvsp[(1) - (4)].f)->arg[1],(pointer)(yyvsp[(3) - (4)].f),&a); |
appendtonode((NODE)(yyvsp[(1) - (4)].f)->arg[1],(pointer)(yyvsp[(3) - (4)].f),&a); |
(yyvsp[(1) - (4)].f)->arg[1] = (pointer)a; (yyval.f) = (yyvsp[(1) - (4)].f); |
(yyvsp[(1) - (4)].f)->arg[1] = (pointer)a; (yyval.f) = (yyvsp[(1) - (4)].f); |
} else { |
} else { |
MKNODE(a,(yyvsp[(3) - (4)].f),0); |
MKNODE(a,(yyvsp[(3) - (4)].f),0); |
(yyval.f) = mkfnode(2,I_INDEX,(pointer)(yyvsp[(1) - (4)].f),a); |
(yyval.f) = mkfnode(2,I_INDEX,(pointer)(yyvsp[(1) - (4)].f),a); |
} |
} |
} |
} |
break; |
break; |
|
|
case 82: |
case 82: |
|
|
yyerror (YY_("syntax error")); |
yyerror (YY_("syntax error")); |
#else |
#else |
{ |
{ |
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); |
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); |
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) |
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) |
{ |
{ |
YYSIZE_T yyalloc = 2 * yysize; |
YYSIZE_T yyalloc = 2 * yysize; |
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) |
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) |
yyalloc = YYSTACK_ALLOC_MAXIMUM; |
yyalloc = YYSTACK_ALLOC_MAXIMUM; |
if (yymsg != yymsgbuf) |
if (yymsg != yymsgbuf) |
YYSTACK_FREE (yymsg); |
YYSTACK_FREE (yymsg); |
yymsg = (char *) YYSTACK_ALLOC (yyalloc); |
yymsg = (char *) YYSTACK_ALLOC (yyalloc); |
if (yymsg) |
if (yymsg) |
yymsg_alloc = yyalloc; |
yymsg_alloc = yyalloc; |
else |
else |
{ |
{ |
yymsg = yymsgbuf; |
yymsg = yymsgbuf; |
yymsg_alloc = sizeof yymsgbuf; |
yymsg_alloc = sizeof yymsgbuf; |
} |
} |
} |
} |
|
|
if (0 < yysize && yysize <= yymsg_alloc) |
if (0 < yysize && yysize <= yymsg_alloc) |
{ |
{ |
(void) yysyntax_error (yymsg, yystate, yychar); |
(void) yysyntax_error (yymsg, yystate, yychar); |
yyerror (yymsg); |
yyerror (yymsg); |
} |
} |
else |
else |
{ |
{ |
yyerror (YY_("syntax error")); |
yyerror (YY_("syntax error")); |
if (yysize != 0) |
if (yysize != 0) |
goto yyexhaustedlab; |
goto yyexhaustedlab; |
} |
} |
} |
} |
#endif |
#endif |
} |
} |
|
|
if (yyerrstatus == 3) |
if (yyerrstatus == 3) |
{ |
{ |
/* 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) |
if (yychar <= YYEOF) |
{ |
{ |
/* Return failure if at end of input. */ |
/* Return failure if at end of input. */ |
if (yychar == YYEOF) |
if (yychar == YYEOF) |
YYABORT; |
YYABORT; |
} |
} |
else |
else |
{ |
{ |
yydestruct ("Error: discarding", |
yydestruct ("Error: discarding", |
yytoken, &yylval); |
yytoken, &yylval); |
yychar = YYEMPTY; |
yychar = YYEMPTY; |
} |
} |
} |
} |
|
|
/* Else will try to reuse lookahead token after shifting the error |
/* Else will try to reuse lookahead token after shifting the error |
|
|
| yyerrlab1 -- common code for both syntax error and YYERROR. | |
| yyerrlab1 -- common code for both syntax error and YYERROR. | |
`-------------------------------------------------------------*/ |
`-------------------------------------------------------------*/ |
yyerrlab1: |
yyerrlab1: |
yyerrstatus = 3; /* Each real token shifted decrements this. */ |
yyerrstatus = 3; /* Each real token shifted decrements this. */ |
|
|
for (;;) |
for (;;) |
{ |
{ |
yyn = yypact[yystate]; |
yyn = yypact[yystate]; |
if (yyn != YYPACT_NINF) |
if (yyn != YYPACT_NINF) |
{ |
{ |
yyn += YYTERROR; |
yyn += YYTERROR; |
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
{ |
{ |
yyn = yytable[yyn]; |
yyn = yytable[yyn]; |
if (0 < yyn) |
if (0 < yyn) |
break; |
break; |
} |
} |
} |
} |
|
|
/* Pop the current state because it cannot handle the error token. */ |
/* Pop the current state because it cannot handle the error token. */ |
if (yyssp == yyss) |
if (yyssp == yyss) |
YYABORT; |
YYABORT; |
|
|
|
|
yydestruct ("Error: popping", |
yydestruct ("Error: popping", |
yystos[yystate], yyvsp); |
yystos[yystate], yyvsp); |
YYPOPSTACK (1); |
YYPOPSTACK (1); |
yystate = *yyssp; |
yystate = *yyssp; |
YY_STACK_PRINT (yyss, yyssp); |
YY_STACK_PRINT (yyss, yyssp); |
Line 2978 yyexhaustedlab: |
|
Line 2978 yyexhaustedlab: |
|
yyreturn: |
yyreturn: |
if (yychar != YYEMPTY) |
if (yychar != YYEMPTY) |
yydestruct ("Cleanup: discarding lookahead", |
yydestruct ("Cleanup: discarding lookahead", |
yytoken, &yylval); |
yytoken, &yylval); |
/* Do not reclaim the symbols of the rule which action triggered |
/* Do not reclaim the symbols of the rule which action triggered |
this YYABORT or YYACCEPT. */ |
this YYABORT or YYACCEPT. */ |
YYPOPSTACK (yylen); |
YYPOPSTACK (yylen); |
|
|
while (yyssp != yyss) |
while (yyssp != yyss) |
{ |
{ |
yydestruct ("Cleanup: popping", |
yydestruct ("Cleanup: popping", |
yystos[*yyssp], yyvsp); |
yystos[*yyssp], yyvsp); |
YYPOPSTACK (1); |
YYPOPSTACK (1); |
} |
} |
#ifndef yyoverflow |
#ifndef yyoverflow |