import byacc 20141005
This commit is contained in:
parent
f78755d12f
commit
f78bee35d7
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/vendor/byacc/dist/; revision=272651 svn path=/vendor/byacc/20141005/; revision=272652; tag=vendor/byacc/20141005
122
CHANGES
122
CHANGES
@ -1,3 +1,125 @@
|
||||
2014-10-05 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* main.c:
|
||||
make change to umask before calling mkstemp, as suggested in Coverity #56902
|
||||
|
||||
* reader.c:
|
||||
adjust logic in copy_action to avoid potential null-pointer dereference
|
||||
(Coverity #56901)
|
||||
|
||||
* reader.c:
|
||||
adjust logic to avoid potential null-pointer dereference in compile_args
|
||||
(Coverity #63407)
|
||||
|
||||
* reader.c: eliminate strcpy into fixed-size buffer (Coverity #63408)
|
||||
|
||||
* yacc.1: document changes made with respect to %parse-param
|
||||
|
||||
* output.c:
|
||||
add parameters from %parse-param to destructor. The order of the parameters
|
||||
is intentionally inconsistent with yyparse/yyerror, for "compatibility" with
|
||||
bison.
|
||||
|
||||
* test/btyacc/btyacc_destroy1.tab.c, test/btyacc/btyacc_destroy2.tab.c, test/btyacc/btyacc_destroy3.tab.c:
|
||||
regen
|
||||
|
||||
* output.c:
|
||||
use puts_param_types/puts_param_names to output lex_param data.
|
||||
|
||||
* test/btyacc/ok_syntax1.tab.c, test/btyacc/calc2.tab.c, test/btyacc/calc3.tab.c, test/yacc/ok_syntax1.tab.c, test/yacc/calc2.tab.c, test/yacc/calc3.tab.c, test/btyacc/error.tab.c, test/btyacc/grammar.tab.c, test/btyacc/inherit0.tab.c, test/btyacc/inherit1.tab.c, test/btyacc/inherit2.tab.c, test/btyacc/pure_calc.tab.c, test/btyacc/pure_error.tab.c, test/btyacc/quote_calc-s.tab.c, test/btyacc/quote_calc.tab.c, test/btyacc/quote_calc2-s.tab.c, test/btyacc/quote_calc2.tab.c, test/btyacc/quote_calc3-s.tab.c, test/btyacc/quote_calc3.tab.c, test/btyacc/quote_calc4-s.tab.c, test/btyacc/quote_calc4.tab.c, test/btyacc/varsyntax_calc1.tab.c, test/btyacc/btyacc_calc1.tab.c, test/btyacc/btyacc_demo.tab.c, test/btyacc/calc.tab.c, test/btyacc/calc1.tab.c, test/btyacc/code_calc.code.c, test/btyacc/code_error.code.c, test/btyacc/empty.tab.c, test/btyacc/err_inherit3.tab.c, test/btyacc/err_inherit4.tab.c, test/btyacc/err_syntax10.tab.c, test/btyacc/err_syntax11.tab.c, test/btyacc/err_syntax12.tab.c, test/btyacc/err_syntax18.tab.c, test/btyacc/err_syntax20.tab.c, test/btyacc/rename_debug.c:
|
||||
regen
|
||||
|
||||
* btyaccpar.c: add casts, change types to fix strict compiler warnings
|
||||
|
||||
* test/btyacc/err_syntax17.tab.c, test/btyacc/err_syntax19.tab.c, test/btyacc/err_syntax2.tab.c, test/btyacc/err_syntax21.tab.c, test/btyacc/err_syntax22.tab.c, test/btyacc/err_syntax23.tab.c, test/btyacc/err_syntax24.tab.c, test/btyacc/err_syntax25.tab.c, test/btyacc/err_syntax26.tab.c, test/btyacc/err_syntax27.tab.c, test/btyacc/err_syntax3.tab.c, test/btyacc/err_syntax4.tab.c, test/btyacc/err_syntax5.tab.c, test/btyacc/err_syntax6.tab.c, test/btyacc/err_syntax7.tab.c, test/btyacc/err_syntax7a.tab.c, test/btyacc/err_syntax7b.tab.c, test/btyacc/err_syntax8.tab.c, test/btyacc/err_syntax8a.tab.c, test/btyacc/err_syntax9.tab.c, test/btyacc/err_inherit1.tab.c, test/btyacc/err_inherit2.tab.c, test/btyacc/err_inherit5.tab.c, test/btyacc/err_syntax1.tab.c, test/btyacc/err_syntax13.tab.c, test/btyacc/err_syntax14.tab.c, test/btyacc/err_syntax15.tab.c, test/btyacc/err_syntax16.tab.c:
|
||||
regen
|
||||
|
||||
* output.c: gcc-warning
|
||||
|
||||
* test/btyacc/code_calc.tab.c, test/btyacc/code_error.tab.c: regen
|
||||
|
||||
* output.c: fix limit when merging real/workaround tables
|
||||
|
||||
* output.c:
|
||||
for btyacc, it is possible to have no conflicts - but in that case, the
|
||||
"ctable" was not generated at all, while the skeleton uses the table.
|
||||
The most straightforward (workaround) is generating a dummy table which
|
||||
rejects any state.
|
||||
|
||||
* test/btyacc_destroy3.y, test/btyacc_destroy2.y, test/btyacc_destroy1.y:
|
||||
fix "make check_make"
|
||||
|
||||
* test/yacc/calc3.tab.c, test/yacc/ok_syntax1.tab.c, test/yacc/calc2.tab.c, test/btyacc/btyacc_destroy1.tab.c, test/btyacc/btyacc_destroy2.tab.c:
|
||||
regen
|
||||
|
||||
* reader.c:
|
||||
trim blanks from interim value in copy_param() to handle special case when
|
||||
a space precedes a comma.
|
||||
|
||||
* output.c:
|
||||
use two new functions, puts_param_types and puts_param_names, to improve
|
||||
format of the parse_param list (by trimming space after "*") as well as
|
||||
correcting the output of the comma-separated names (only the last name
|
||||
was output).
|
||||
|
||||
* test/btyacc/ok_syntax1.tab.c, test/btyacc/btyacc_destroy3.tab.c, test/btyacc/calc2.tab.c, test/btyacc/calc3.tab.c:
|
||||
regen
|
||||
|
||||
* reader.c:
|
||||
modify copy_param() to handle resulting comma-separated list. Before, it
|
||||
only expected a single parameter.
|
||||
|
||||
2014-10-04 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* reader.c: split-out save_param() from copy_param()
|
||||
|
||||
* reader.c: trim_blanks() did not always convert spaces - fix.
|
||||
|
||||
* reader.c: fix some minor regressions with error-reporting
|
||||
|
||||
* aclocal.m4: update CF_XOPEN_SOURCE for Unixware change from lynx
|
||||
|
||||
* VERSION, package/byacc.spec, package/debian/changelog, package/mingw-byacc.spec, package/pkgsrc/Makefile:
|
||||
bump
|
||||
|
||||
* reader.c:
|
||||
modify copy_param() to accept multiple parameters, each in curly braces like
|
||||
recent bison, as well as honoring bison's undocumented feature to accept the
|
||||
parameters as a comma-separated list.
|
||||
|
||||
* test/btyacc/btyacc_destroy3.tab.c, test/btyacc/btyacc_destroy1.tab.c, test/btyacc/btyacc_destroy2.tab.c, test/btyacc/btyacc_destroy3.error, test/btyacc/btyacc_destroy3.output, test/btyacc/btyacc_destroy3.tab.h, test/btyacc/btyacc_destroy2.error, test/btyacc/btyacc_destroy2.output, test/btyacc/btyacc_destroy2.tab.h:
|
||||
RCS_BASE
|
||||
|
||||
2014-10-03 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* test/btyacc/btyacc_demo2.error, test/btyacc/btyacc_demo2.output, test/btyacc/btyacc_demo2.tab.c, test/btyacc/btyacc_demo2.tab.h, test/btyacc/btyacc_destroy1.error, test/btyacc/btyacc_destroy1.output, test/btyacc/btyacc_destroy1.tab.h, test/btyacc_destroy3.y, test/btyacc_destroy1.y, test/btyacc_destroy2.y:
|
||||
RCS_BASE
|
||||
|
||||
2014-10-02 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* main.c, reader.c, defs.h:
|
||||
use calloc in get_line() when allocating line to ensure it is fully initialized,
|
||||
fixes a later uninitialized value in copy_param() (FreeBSD #193499).
|
||||
|
||||
2014-09-17 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* closure.c, lalr.c, output.c, defs.h:
|
||||
rephrase odd addressing to fix Coverity #48848, #38950, #38860, not actually
|
||||
a bug.
|
||||
|
||||
2014-09-01 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* config.sub: update to 2014-07-28
|
||||
|
||||
2014-07-27 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* configure: regen
|
||||
|
||||
* aclocal.m4: modified to support port to Minix3.2
|
||||
|
||||
* package/pkgsrc/Makefile, VERSION, package/byacc.spec, package/debian/changelog, package/mingw-byacc.spec:
|
||||
bump
|
||||
|
||||
2014-07-15 Thomas E. Dickey <tom@invisible-island.net>
|
||||
|
||||
* aclocal.m4: resync with my-autoconf (no change to configure script)
|
||||
|
2
MANIFEST
2
MANIFEST
@ -1,4 +1,4 @@
|
||||
MANIFEST for byacc-20140715, version t20140715
|
||||
MANIFEST for byacc-20141005, version t20141005
|
||||
--------------------------------------------------------------------------------
|
||||
MANIFEST this file
|
||||
ACKNOWLEDGEMENTS original version of byacc - 1993
|
||||
|
19
aclocal.m4
vendored
19
aclocal.m4
vendored
@ -1,4 +1,4 @@
|
||||
dnl $Id: aclocal.m4,v 1.35 2014/07/15 19:38:05 tom Exp $
|
||||
dnl $Id: aclocal.m4,v 1.37 2014/10/04 16:40:06 tom Exp $
|
||||
dnl Macros for byacc configure script (Thomas E. Dickey)
|
||||
dnl ---------------------------------------------------------------------------
|
||||
dnl Copyright 2004-2013,2014 Thomas E. Dickey
|
||||
@ -54,7 +54,7 @@ define([CF_ACVERSION_COMPARE],
|
||||
[ifelse([$8], , ,[$8])],
|
||||
[ifelse([$9], , ,[$9])])])dnl
|
||||
dnl ---------------------------------------------------------------------------
|
||||
dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
|
||||
dnl CF_ADD_CFLAGS version: 11 updated: 2014/07/22 05:32:57
|
||||
dnl -------------
|
||||
dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
|
||||
dnl The second parameter if given makes this macro verbose.
|
||||
@ -79,7 +79,7 @@ no)
|
||||
-D*)
|
||||
cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
|
||||
|
||||
test "${cf_add_cflags}" != "${cf_tst_cflags}" \
|
||||
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
|
||||
&& test -z "${cf_tst_cflags}" \
|
||||
&& cf_fix_cppflags=yes
|
||||
|
||||
@ -116,7 +116,7 @@ yes)
|
||||
|
||||
cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
|
||||
|
||||
test "${cf_add_cflags}" != "${cf_tst_cflags}" \
|
||||
test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
|
||||
&& test -z "${cf_tst_cflags}" \
|
||||
&& cf_fix_cppflags=no
|
||||
;;
|
||||
@ -1085,7 +1085,7 @@ fi
|
||||
fi
|
||||
])dnl
|
||||
dnl ---------------------------------------------------------------------------
|
||||
dnl CF_XOPEN_SOURCE version: 46 updated: 2014/02/09 19:30:15
|
||||
dnl CF_XOPEN_SOURCE version: 48 updated: 2014/09/01 12:29:14
|
||||
dnl ---------------
|
||||
dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
|
||||
dnl or adapt to the vendor's definitions to get equivalent functionality,
|
||||
@ -1136,6 +1136,9 @@ irix[[56]].*) #(vi
|
||||
linux*|gnu*|mint*|k*bsd*-gnu) #(vi
|
||||
CF_GNU_SOURCE
|
||||
;;
|
||||
minix*) #(vi
|
||||
cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
|
||||
;;
|
||||
mirbsd*) #(vi
|
||||
# setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
|
||||
cf_XOPEN_SOURCE=
|
||||
@ -1165,6 +1168,10 @@ solaris2.*) #(vi
|
||||
cf_xopen_source="-D__EXTENSIONS__"
|
||||
cf_cv_xopen_source=broken
|
||||
;;
|
||||
sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
|
||||
cf_XOPEN_SOURCE=
|
||||
cf_POSIX_C_SOURCE=
|
||||
;;
|
||||
*)
|
||||
CF_TRY_XOPEN_SOURCE
|
||||
CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
|
||||
@ -1172,7 +1179,7 @@ solaris2.*) #(vi
|
||||
esac
|
||||
|
||||
if test -n "$cf_xopen_source" ; then
|
||||
CF_ADD_CFLAGS($cf_xopen_source)
|
||||
CF_ADD_CFLAGS($cf_xopen_source,true)
|
||||
fi
|
||||
|
||||
dnl In anything but the default case, we may have system-specific setting
|
||||
|
106
btyaccpar.c
106
btyaccpar.c
@ -18,7 +18,7 @@ const char *const banner[] =
|
||||
{
|
||||
"/* original parser id follows */",
|
||||
"/* yysccsid[] = \"@(#)yaccpar 1.9 (Berkeley) 02/21/93\" */",
|
||||
"/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */",
|
||||
"/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */",
|
||||
"",
|
||||
"#define YYBYACC 1",
|
||||
CONCAT1("#define YYMAJOR ", YYMAJOR),
|
||||
@ -56,7 +56,7 @@ const char *const tables[] =
|
||||
"#if YYBTYACC",
|
||||
"extern const YYINT yycindex[];",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"extern const YYINT yygindex[];",
|
||||
"extern const YYINT yytable[];",
|
||||
"extern const YYINT yycheck[];",
|
||||
@ -64,7 +64,7 @@ const char *const tables[] =
|
||||
"#if YYBTYACC",
|
||||
"extern const YYINT yyctable[];",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"",
|
||||
"#if YYDEBUG",
|
||||
"extern const char *const yyname[];",
|
||||
@ -127,7 +127,7 @@ const char *const hdr_defs[] =
|
||||
"#define YYLVQUEUEGROWTH 32",
|
||||
"#endif",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"",
|
||||
"/* define the initial stack-sizes */",
|
||||
"#ifdef YYSTACKSIZE",
|
||||
@ -172,7 +172,7 @@ const char *const hdr_defs[] =
|
||||
"};",
|
||||
"typedef struct YYParseState_s YYParseState;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
0
|
||||
};
|
||||
|
||||
@ -220,7 +220,7 @@ const char *const hdr_vars[] =
|
||||
"",
|
||||
"static short *yylexemes = 0;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
0
|
||||
};
|
||||
|
||||
@ -277,7 +277,7 @@ const char *const body_vars[] =
|
||||
"",
|
||||
" static short *yylexemes = 0;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
0
|
||||
};
|
||||
|
||||
@ -290,14 +290,14 @@ const char *const body_1[] =
|
||||
"#if YYBTYACC",
|
||||
"#define yytrial (yyps->save)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"",
|
||||
"#if YYDEBUG",
|
||||
"#include <stdio.h> /* needed for printf */",
|
||||
"#include <stdio.h> /* needed for printf */",
|
||||
"#endif",
|
||||
"",
|
||||
"#include <stdlib.h> /* needed for malloc, etc */",
|
||||
"#include <string.h> /* needed for memset */",
|
||||
"#include <stdlib.h> /* needed for malloc, etc */",
|
||||
"#include <string.h> /* needed for memset */",
|
||||
"",
|
||||
"/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
|
||||
"static int yygrowstack(YYSTACKDATA *data)",
|
||||
@ -404,7 +404,7 @@ const char *const body_1[] =
|
||||
" free(p);",
|
||||
"}",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"",
|
||||
"#define YYABORT goto yyabort",
|
||||
"#define YYREJECT goto yyabort",
|
||||
@ -416,7 +416,7 @@ const char *const body_1[] =
|
||||
"#define YYVALID_NESTED do { if (yyps->save && \\",
|
||||
" yyps->save->save == 0) goto yyvalid; } while(0)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"",
|
||||
"int",
|
||||
"YYPARSE_DECL()",
|
||||
@ -432,7 +432,7 @@ const char *const body_2[] =
|
||||
" int yynewerrflag;",
|
||||
" YYParseState *yyerrctx = NULL;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" YYLTYPE yyerror_loc_range[2]; /* position of error start & end */",
|
||||
"#endif",
|
||||
@ -454,7 +454,7 @@ const char *const body_2[] =
|
||||
" yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
|
||||
" yyps->save = 0;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" yynerrs = 0;",
|
||||
" yyerrflag = 0;",
|
||||
" yychar = YYEMPTY;",
|
||||
@ -495,8 +495,8 @@ const char *const body_2[] =
|
||||
" /* in trial mode; save scanner results for future parse attempts */",
|
||||
" if (yylvp == yylvlim)",
|
||||
" { /* Enlarge lexical value queue */",
|
||||
" int p = yylvp - yylvals;",
|
||||
" int s = yylvlim - yylvals;",
|
||||
" size_t p = (size_t) (yylvp - yylvals);",
|
||||
" size_t s = (size_t) (yylvlim - yylvals);",
|
||||
"",
|
||||
" s += YYLVQUEUEGROWTH;",
|
||||
" if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;",
|
||||
@ -524,13 +524,13 @@ const char *const body_2[] =
|
||||
" }",
|
||||
" /* normal operation, no conflict encountered */",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" yychar = YYLEX;",
|
||||
#if defined(YYBTYACC)
|
||||
"#if YYBTYACC",
|
||||
" } while (0);",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" if (yychar < 0) yychar = YYEOF;",
|
||||
" /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
|
||||
"#if YYDEBUG",
|
||||
@ -544,7 +544,7 @@ const char *const body_2[] =
|
||||
"#if YYBTYACC",
|
||||
" if (!yytrial)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));",
|
||||
"#endif",
|
||||
" fputc('\\n', stderr);",
|
||||
@ -598,12 +598,12 @@ const char *const body_2[] =
|
||||
" save->state = yystate;",
|
||||
" save->errflag = yyerrflag;",
|
||||
" save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);",
|
||||
" memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);",
|
||||
" memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
" memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);",
|
||||
" memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
" memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
"#endif",
|
||||
" ctry = yytable[yyn];",
|
||||
" if (yyctable[ctry] == -1)",
|
||||
@ -658,7 +658,7 @@ const char *const body_2[] =
|
||||
" yylexp--;",
|
||||
" yychar = YYEMPTY;",
|
||||
" }",
|
||||
" save->lexeme = yylvp - yylvals;",
|
||||
" save->lexeme = (int) (yylvp - yylvals);",
|
||||
" yyps->save = save;",
|
||||
" }",
|
||||
" if (yytable[yyn] == ctry)",
|
||||
@ -695,7 +695,7 @@ const char *const body_2[] =
|
||||
" }",
|
||||
" } /* End of code dealing with conflicts */",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
|
||||
" yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
|
||||
" {",
|
||||
@ -754,14 +754,14 @@ const char *const body_2[] =
|
||||
" yyerrctx->state = yystate;",
|
||||
" yyerrctx->errflag = yyerrflag;",
|
||||
" yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);",
|
||||
" memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);",
|
||||
" memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
" memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);",
|
||||
" memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
" memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
"#endif",
|
||||
" yyerrctx->lexeme = yylvp - yylvals;",
|
||||
" yyerrctx->lexeme = (int) (yylvp - yylvals);",
|
||||
" }",
|
||||
" yylvp = yylvals + save->lexeme;",
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
@ -770,12 +770,12 @@ const char *const body_2[] =
|
||||
" yylexp = yylexemes + save->lexeme;",
|
||||
" yychar = YYEMPTY;",
|
||||
" yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);",
|
||||
" memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);",
|
||||
" memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
" memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);",
|
||||
" memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
" memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
"#endif",
|
||||
" ctry = ++save->ctry;",
|
||||
" yystate = save->state;",
|
||||
@ -805,12 +805,12 @@ const char *const body_2[] =
|
||||
" yylloc = yylpp[-1];",
|
||||
"#endif",
|
||||
" yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);",
|
||||
" memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);",
|
||||
" memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
" memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);",
|
||||
" memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
" memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
"#endif",
|
||||
" yystate = yyerrctx->state;",
|
||||
" yyFreeState(yyerrctx);",
|
||||
@ -820,7 +820,7 @@ const char *const body_2[] =
|
||||
" }",
|
||||
" if (yynewerrflag == 0) goto yyinrecovery;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"",
|
||||
" YYERROR_CALL(\"syntax error\");",
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
@ -876,7 +876,7 @@ const char *const body_2[] =
|
||||
"#if YYBTYACC",
|
||||
" if (!yytrial)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" YYDESTRUCT_CALL(\"error: discarding state\",",
|
||||
" yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);",
|
||||
@ -909,7 +909,7 @@ const char *const body_2[] =
|
||||
"#if YYBTYACC",
|
||||
" if (!yytrial)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);",
|
||||
"#else",
|
||||
@ -932,7 +932,7 @@ const char *const body_2[] =
|
||||
"#if YYBTYACC",
|
||||
" if (!yytrial)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" if (yym > 0)",
|
||||
" {",
|
||||
" int i;",
|
||||
@ -961,7 +961,7 @@ const char *const body_2[] =
|
||||
"#if YYBTYACC",
|
||||
" if (!yytrial)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" {",
|
||||
" YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);",
|
||||
" /* just in case YYERROR is invoked within the action, save",
|
||||
@ -998,7 +998,7 @@ const char *const trailer[] =
|
||||
"#if YYBTYACC",
|
||||
" if (!yytrial)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));",
|
||||
"#endif",
|
||||
" fprintf(stderr, \"shifting from state 0 to final state %d\\n\", YYFINAL);",
|
||||
@ -1030,8 +1030,8 @@ const char *const trailer[] =
|
||||
" /* in trial mode; save scanner results for future parse attempts */",
|
||||
" if (yylvp == yylvlim)",
|
||||
" { /* Enlarge lexical value queue */",
|
||||
" int p = yylvp - yylvals;",
|
||||
" int s = yylvlim - yylvals;",
|
||||
" size_t p = (size_t) (yylvp - yylvals);",
|
||||
" size_t s = (size_t) (yylvlim - yylvals);",
|
||||
"",
|
||||
" s += YYLVQUEUEGROWTH;",
|
||||
" if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)",
|
||||
@ -1062,13 +1062,13 @@ const char *const trailer[] =
|
||||
" }",
|
||||
" /* normal operation, no conflict encountered */",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" yychar = YYLEX;",
|
||||
#if defined(YYBTYACC)
|
||||
"#if YYBTYACC",
|
||||
" } while (0);",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" if (yychar < 0) yychar = YYEOF;",
|
||||
" /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
|
||||
"#if YYDEBUG",
|
||||
@ -1097,7 +1097,7 @@ const char *const trailer[] =
|
||||
"#if YYBTYACC",
|
||||
" if (!yytrial)",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));",
|
||||
"#endif",
|
||||
" fprintf(stderr, \"shifting from state %d to state %d\\n\", *yystack.s_mark, yystate);",
|
||||
@ -1140,17 +1140,17 @@ const char *const trailer[] =
|
||||
" yylexp = yylexemes + yypath->lexeme;",
|
||||
" yychar = YYEMPTY;",
|
||||
" yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);",
|
||||
" memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
|
||||
" yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);",
|
||||
" memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
" memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
|
||||
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
||||
" yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);",
|
||||
" memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
" memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
|
||||
"#endif",
|
||||
" yystate = yypath->state;",
|
||||
" goto yyloop;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
"",
|
||||
"yyoverflow:",
|
||||
" YYERROR_CALL(\"yacc stack overflow\");",
|
||||
@ -1161,7 +1161,7 @@ const char *const trailer[] =
|
||||
" YYERROR_CALL(\"memory exhausted\");",
|
||||
"yyabort_nomem:",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" yyresult = 2;",
|
||||
" goto yyreturn;",
|
||||
"",
|
||||
@ -1174,7 +1174,7 @@ const char *const trailer[] =
|
||||
"#if YYBTYACC",
|
||||
" if (yyps->save) goto yyvalid;",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" yyresult = 0;",
|
||||
"",
|
||||
"yyreturn:",
|
||||
@ -1224,7 +1224,7 @@ const char *const trailer[] =
|
||||
" yyFreeState(save);",
|
||||
" }",
|
||||
"#endif /* YYBTYACC */",
|
||||
#endif /* defined(YYBTYACC) */
|
||||
#endif /* defined(YYBTYACC) */
|
||||
" yyfreestack(&yystack);",
|
||||
" return (yyresult);",
|
||||
"}",
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* $Id: closure.c,v 1.10 2014/02/19 00:45:42 Tom.Shields Exp $ */
|
||||
/* $Id: closure.c,v 1.11 2014/09/18 00:40:07 tom Exp $ */
|
||||
|
||||
#include "defs.h"
|
||||
|
||||
@ -6,6 +6,7 @@ Value_t *itemset;
|
||||
Value_t *itemsetend;
|
||||
unsigned *ruleset;
|
||||
|
||||
static unsigned *first_base;
|
||||
static unsigned *first_derives;
|
||||
static unsigned *EFF;
|
||||
|
||||
@ -68,7 +69,8 @@ set_first_derives(void)
|
||||
|
||||
rulesetsize = WORDSIZE(nrules);
|
||||
varsetsize = WORDSIZE(nvars);
|
||||
first_derives = NEW2(nvars * rulesetsize, unsigned) - ntokens * rulesetsize;
|
||||
first_base = NEW2(nvars * rulesetsize, unsigned);
|
||||
first_derives = first_base - ntokens * rulesetsize;
|
||||
|
||||
set_EFF();
|
||||
|
||||
@ -176,7 +178,7 @@ finalize_closure(void)
|
||||
{
|
||||
FREE(itemset);
|
||||
FREE(ruleset);
|
||||
FREE(first_derives + ntokens * WORDSIZE(nrules));
|
||||
FREE(first_base);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
|
12
config.sub
vendored
12
config.sub
vendored
@ -2,7 +2,7 @@
|
||||
# Configuration validation subroutine script.
|
||||
# Copyright 1992-2014 Free Software Foundation, Inc.
|
||||
|
||||
timestamp='2014-04-03'
|
||||
timestamp='2014-07-28'
|
||||
|
||||
# This file is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the GNU General Public License as published by
|
||||
@ -283,8 +283,10 @@ case $basic_machine in
|
||||
| mips64vr5900 | mips64vr5900el \
|
||||
| mipsisa32 | mipsisa32el \
|
||||
| mipsisa32r2 | mipsisa32r2el \
|
||||
| mipsisa32r6 | mipsisa32r6el \
|
||||
| mipsisa64 | mipsisa64el \
|
||||
| mipsisa64r2 | mipsisa64r2el \
|
||||
| mipsisa64r6 | mipsisa64r6el \
|
||||
| mipsisa64sb1 | mipsisa64sb1el \
|
||||
| mipsisa64sr71k | mipsisa64sr71kel \
|
||||
| mipsr5900 | mipsr5900el \
|
||||
@ -401,8 +403,10 @@ case $basic_machine in
|
||||
| mips64vr5900-* | mips64vr5900el-* \
|
||||
| mipsisa32-* | mipsisa32el-* \
|
||||
| mipsisa32r2-* | mipsisa32r2el-* \
|
||||
| mipsisa32r6-* | mipsisa32r6el-* \
|
||||
| mipsisa64-* | mipsisa64el-* \
|
||||
| mipsisa64r2-* | mipsisa64r2el-* \
|
||||
| mipsisa64r6-* | mipsisa64r6el-* \
|
||||
| mipsisa64sb1-* | mipsisa64sb1el-* \
|
||||
| mipsisa64sr71k-* | mipsisa64sr71kel-* \
|
||||
| mipsr5900-* | mipsr5900el-* \
|
||||
@ -824,6 +828,10 @@ case $basic_machine in
|
||||
basic_machine=powerpc-unknown
|
||||
os=-morphos
|
||||
;;
|
||||
moxiebox)
|
||||
basic_machine=moxie-unknown
|
||||
os=-moxiebox
|
||||
;;
|
||||
msdos)
|
||||
basic_machine=i386-pc
|
||||
os=-msdos
|
||||
@ -1369,7 +1377,7 @@ case $os in
|
||||
| -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
|
||||
| -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
|
||||
| -linux-newlib* | -linux-musl* | -linux-uclibc* \
|
||||
| -uxpv* | -beos* | -mpeix* | -udk* \
|
||||
| -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
|
||||
| -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
|
||||
| -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
|
||||
| -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
|
||||
|
4
defs.h
4
defs.h
@ -1,4 +1,4 @@
|
||||
/* $Id: defs.h,v 1.49 2014/04/22 23:34:34 tom Exp $ */
|
||||
/* $Id: defs.h,v 1.51 2014/10/02 22:38:13 tom Exp $ */
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
@ -157,6 +157,7 @@
|
||||
#define CALLOC(k,n) (calloc((size_t)(k),(size_t)(n)))
|
||||
#define FREE(x) (free((char*)(x)))
|
||||
#define MALLOC(n) (malloc((size_t)(n)))
|
||||
#define TCMALLOC(t,n) ((t*) calloc((size_t)(n), sizeof(t)))
|
||||
#define TMALLOC(t,n) ((t*) malloc((size_t)(n) * sizeof(t)))
|
||||
#define NEW(t) ((t*)allocate(sizeof(t)))
|
||||
#define NEW2(n,t) ((t*)allocate(((size_t)(n)*sizeof(t))))
|
||||
@ -366,6 +367,7 @@ extern reductions **reduction_table;
|
||||
extern unsigned *LA;
|
||||
extern Value_t *LAruleno;
|
||||
extern Value_t *lookaheads;
|
||||
extern Value_t *goto_base;
|
||||
extern Value_t *goto_map;
|
||||
extern Value_t *from_state;
|
||||
extern Value_t *to_state;
|
||||
|
13
lalr.c
13
lalr.c
@ -1,4 +1,4 @@
|
||||
/* $Id: lalr.c,v 1.10 2014/02/19 00:35:17 Tom.Shields Exp $ */
|
||||
/* $Id: lalr.c,v 1.11 2014/09/18 00:26:39 tom Exp $ */
|
||||
|
||||
#include "defs.h"
|
||||
|
||||
@ -34,6 +34,7 @@ Value_t *accessing_symbol;
|
||||
core **state_table;
|
||||
shifts **shift_table;
|
||||
reductions **reduction_table;
|
||||
Value_t *goto_base;
|
||||
Value_t *goto_map;
|
||||
Value_t *from_state;
|
||||
Value_t *to_state;
|
||||
@ -179,12 +180,16 @@ set_goto_map(void)
|
||||
int i;
|
||||
int symbol;
|
||||
int k;
|
||||
Value_t *temp_base;
|
||||
Value_t *temp_map;
|
||||
Value_t state2;
|
||||
Value_t state1;
|
||||
|
||||
goto_map = NEW2(nvars + 1, Value_t) - ntokens;
|
||||
temp_map = NEW2(nvars + 1, Value_t) - ntokens;
|
||||
goto_base = NEW2(nvars + 1, Value_t);
|
||||
temp_base = NEW2(nvars + 1, Value_t);
|
||||
|
||||
goto_map = goto_base - ntokens;
|
||||
temp_map = temp_base - ntokens;
|
||||
|
||||
ngotos = 0;
|
||||
for (sp = first_shift; sp; sp = sp->next)
|
||||
@ -237,7 +242,7 @@ set_goto_map(void)
|
||||
}
|
||||
}
|
||||
|
||||
FREE(temp_map + ntokens);
|
||||
FREE(temp_base);
|
||||
}
|
||||
|
||||
/* Map_goto maps a state/symbol pair into its numeric representation. */
|
||||
|
9
main.c
9
main.c
@ -1,4 +1,4 @@
|
||||
/* $Id: main.c,v 1.51 2014/05/28 02:01:55 Tom.Shields Exp $ */
|
||||
/* $Id: main.c,v 1.53 2014/10/06 00:55:28 tom Exp $ */
|
||||
|
||||
#include <signal.h>
|
||||
#ifndef _WIN32
|
||||
@ -491,8 +491,8 @@ close_tmpfiles(void)
|
||||
{
|
||||
MY_TMPFILES *next = my_tmpfiles->next;
|
||||
|
||||
chmod(my_tmpfiles->name, 0644);
|
||||
unlink(my_tmpfiles->name);
|
||||
(void)chmod(my_tmpfiles->name, 0644);
|
||||
(void)unlink(my_tmpfiles->name);
|
||||
|
||||
free(my_tmpfiles->name);
|
||||
free(my_tmpfiles);
|
||||
@ -574,6 +574,8 @@ open_tmpfile(const char *label)
|
||||
result = 0;
|
||||
if (name != 0)
|
||||
{
|
||||
int save_umask = umask(0600);
|
||||
|
||||
if ((mark = strrchr(label, '_')) == 0)
|
||||
mark = label + strlen(label);
|
||||
|
||||
@ -601,6 +603,7 @@ open_tmpfile(const char *label)
|
||||
my_tmpfiles = item;
|
||||
}
|
||||
}
|
||||
(void)umask(save_umask);
|
||||
}
|
||||
#else
|
||||
result = tmpfile();
|
||||
|
170
output.c
170
output.c
@ -1,4 +1,4 @@
|
||||
/* $Id: output.c,v 1.67 2014/04/22 23:16:57 tom Exp $ */
|
||||
/* $Id: output.c,v 1.74 2014/10/05 23:21:09 tom Exp $ */
|
||||
|
||||
#include "defs.h"
|
||||
|
||||
@ -53,6 +53,43 @@ puts_code(FILE * fp, const char *s)
|
||||
fputs(s, fp);
|
||||
}
|
||||
|
||||
static void
|
||||
puts_param_types(FILE * fp, param * list, int more)
|
||||
{
|
||||
param *p;
|
||||
|
||||
if (list != 0)
|
||||
{
|
||||
for (p = list; p; p = p->next)
|
||||
{
|
||||
size_t len_type = strlen(p->type);
|
||||
fprintf(fp, "%s%s%s%s%s", p->type,
|
||||
(((len_type != 0) && (p->type[len_type - 1] == '*'))
|
||||
? ""
|
||||
: " "),
|
||||
p->name, p->type2,
|
||||
((more || p->next) ? ", " : ""));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!more)
|
||||
fprintf(fp, "void");
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
puts_param_names(FILE * fp, param * list, int more)
|
||||
{
|
||||
param *p;
|
||||
|
||||
for (p = list; p; p = p->next)
|
||||
{
|
||||
fprintf(fp, "%s%s", p->name,
|
||||
((more || p->next) ? ", " : ""));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
write_code_lineno(FILE * fp)
|
||||
{
|
||||
@ -1007,30 +1044,33 @@ output_ctable(void)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int limit = (conflicts != 0) ? nconflicts : 0;
|
||||
|
||||
if (limit < high)
|
||||
limit = (int)high;
|
||||
|
||||
output_line("#if YYBTYACC");
|
||||
start_int_table("ctable", conflicts ? conflicts[0] : -1);
|
||||
|
||||
j = 10;
|
||||
for (i = 1; i < limit; i++)
|
||||
{
|
||||
if (j >= 10)
|
||||
{
|
||||
output_newline();
|
||||
j = 1;
|
||||
}
|
||||
else
|
||||
++j;
|
||||
|
||||
output_int((conflicts != 0 && i < nconflicts) ? conflicts[i] : -1);
|
||||
}
|
||||
|
||||
if (conflicts)
|
||||
{
|
||||
output_line("#if YYBTYACC");
|
||||
start_int_table("ctable", conflicts[0]);
|
||||
|
||||
j = 10;
|
||||
for (i = 1; i < nconflicts; i++)
|
||||
{
|
||||
if (j >= 10)
|
||||
{
|
||||
output_newline();
|
||||
j = 1;
|
||||
}
|
||||
else
|
||||
++j;
|
||||
|
||||
output_int(conflicts[i]);
|
||||
}
|
||||
|
||||
end_table();
|
||||
output_line("#endif");
|
||||
FREE(conflicts);
|
||||
}
|
||||
|
||||
end_table();
|
||||
output_line("#endif");
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1056,7 +1096,7 @@ output_actions(void)
|
||||
FREE(accessing_symbol);
|
||||
|
||||
goto_actions();
|
||||
FREE(goto_map + ntokens);
|
||||
FREE(goto_base);
|
||||
FREE(from_state);
|
||||
FREE(to_state);
|
||||
|
||||
@ -1607,15 +1647,7 @@ output_parse_decl(FILE * fp)
|
||||
putl_code(fp, "#else\n");
|
||||
|
||||
puts_code(fp, "# define YYPARSE_DECL() yyparse(");
|
||||
if (!parse_param)
|
||||
puts_code(fp, "void");
|
||||
else
|
||||
{
|
||||
param *p;
|
||||
for (p = parse_param; p; p = p->next)
|
||||
fprintf(fp, "%s %s%s%s", p->type, p->name, p->type2,
|
||||
p->next ? ", " : "");
|
||||
}
|
||||
puts_param_types(fp, parse_param, 0);
|
||||
putl_code(fp, ")\n");
|
||||
|
||||
putl_code(fp, "#endif\n");
|
||||
@ -1633,7 +1665,8 @@ output_lex_decl(FILE * fp)
|
||||
#if defined(YYBTYACC)
|
||||
if (locations)
|
||||
{
|
||||
putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLTYPE *yylloc,"
|
||||
putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval,"
|
||||
" YYLTYPE *yylloc,"
|
||||
" YYLEX_PARAM_TYPE YYLEX_PARAM)\n");
|
||||
}
|
||||
else
|
||||
@ -1646,7 +1679,8 @@ output_lex_decl(FILE * fp)
|
||||
#if defined(YYBTYACC)
|
||||
if (locations)
|
||||
{
|
||||
putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLTYPE *yylloc,"
|
||||
putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval,"
|
||||
" YYLTYPE *yylloc,"
|
||||
" void * YYLEX_PARAM)\n");
|
||||
}
|
||||
else
|
||||
@ -1672,8 +1706,6 @@ output_lex_decl(FILE * fp)
|
||||
putl_code(fp, "#else\n");
|
||||
if (pure_parser && lex_param)
|
||||
{
|
||||
param *p;
|
||||
|
||||
#if defined(YYBTYACC)
|
||||
if (locations)
|
||||
puts_code(fp,
|
||||
@ -1681,9 +1713,7 @@ output_lex_decl(FILE * fp)
|
||||
else
|
||||
#endif
|
||||
puts_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval, ");
|
||||
for (p = lex_param; p; p = p->next)
|
||||
fprintf(fp, "%s %s%s%s", p->type, p->name, p->type2,
|
||||
p->next ? ", " : "");
|
||||
puts_param_types(fp, lex_param, 0);
|
||||
putl_code(fp, ")\n");
|
||||
|
||||
#if defined(YYBTYACC)
|
||||
@ -1692,8 +1722,7 @@ output_lex_decl(FILE * fp)
|
||||
else
|
||||
#endif
|
||||
puts_code(fp, "# define YYLEX yylex(&yylval, ");
|
||||
for (p = lex_param; p; p = p->next)
|
||||
fprintf(fp, "%s%s", p->name, p->next ? ", " : "");
|
||||
puts_param_names(fp, lex_param, 0);
|
||||
putl_code(fp, ")\n");
|
||||
}
|
||||
else if (pure_parser)
|
||||
@ -1714,17 +1743,12 @@ output_lex_decl(FILE * fp)
|
||||
}
|
||||
else if (lex_param)
|
||||
{
|
||||
param *p;
|
||||
|
||||
puts_code(fp, "# define YYLEX_DECL() yylex(");
|
||||
for (p = lex_param; p; p = p->next)
|
||||
fprintf(fp, "%s %s%s%s", p->type, p->name, p->type2,
|
||||
p->next ? ", " : "");
|
||||
puts_param_types(fp, lex_param, 0);
|
||||
putl_code(fp, ")\n");
|
||||
|
||||
puts_code(fp, "# define YYLEX yylex(");
|
||||
for (p = lex_param; p; p = p->next)
|
||||
fprintf(fp, "%s%s", p->name, p->next ? ", " : "");
|
||||
puts_param_names(fp, lex_param, 0);
|
||||
putl_code(fp, ")\n");
|
||||
}
|
||||
else
|
||||
@ -1738,8 +1762,6 @@ output_lex_decl(FILE * fp)
|
||||
static void
|
||||
output_error_decl(FILE * fp)
|
||||
{
|
||||
param *p;
|
||||
|
||||
putc_code(fp, '\n');
|
||||
putl_code(fp, "/* Parameters sent to yyerror. */\n");
|
||||
putl_code(fp, "#ifndef YYERROR_DECL\n");
|
||||
@ -1748,22 +1770,20 @@ output_error_decl(FILE * fp)
|
||||
if (locations)
|
||||
puts_code(fp, "YYLTYPE loc, ");
|
||||
#endif
|
||||
for (p = parse_param; p; p = p->next)
|
||||
fprintf(fp, "%s %s%s, ", p->type, p->name, p->type2);
|
||||
puts_param_types(fp, parse_param, 1);
|
||||
putl_code(fp, "const char *s)\n");
|
||||
putl_code(fp, "#endif\n");
|
||||
|
||||
putl_code(fp, "#ifndef YYERROR_CALL\n");
|
||||
puts_code(fp, "#define YYERROR_CALL(msg) yyerror(");
|
||||
|
||||
puts_code(fp, "#define YYERROR_CALL(msg) yyerror(");
|
||||
#if defined(YYBTYACC)
|
||||
if (locations)
|
||||
puts_code(fp, "yylloc, ");
|
||||
#endif
|
||||
for (p = parse_param; p; p = p->next)
|
||||
fprintf(fp, "%s, ", p->name);
|
||||
|
||||
puts_param_names(fp, parse_param, 1);
|
||||
putl_code(fp, "msg)\n");
|
||||
|
||||
putl_code(fp, "#endif\n");
|
||||
}
|
||||
|
||||
@ -1773,24 +1793,42 @@ output_yydestruct_decl(FILE * fp)
|
||||
{
|
||||
putc_code(fp, '\n');
|
||||
putl_code(fp, "#ifndef YYDESTRUCT_DECL\n");
|
||||
|
||||
puts_code(fp,
|
||||
"#define YYDESTRUCT_DECL() "
|
||||
"yydestruct(const char *msg, int psymb, YYSTYPE *val");
|
||||
#if defined(YYBTYACC)
|
||||
if (locations)
|
||||
putl_code(fp,
|
||||
"#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, YYLTYPE *loc)\n");
|
||||
else
|
||||
puts_code(fp, ", YYLTYPE *loc");
|
||||
#endif
|
||||
putl_code(fp,
|
||||
"#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val)\n");
|
||||
if (parse_param)
|
||||
{
|
||||
puts_code(fp, ", ");
|
||||
puts_param_types(fp, parse_param, 0);
|
||||
}
|
||||
putl_code(fp, ")\n");
|
||||
|
||||
putl_code(fp, "#endif\n");
|
||||
|
||||
putl_code(fp, "#ifndef YYDESTRUCT_CALL\n");
|
||||
|
||||
puts_code(fp, "#define YYDESTRUCT_CALL(msg, psymb, val");
|
||||
#if defined(YYBTYACC)
|
||||
if (locations)
|
||||
putl_code(fp,
|
||||
"#define YYDESTRUCT_CALL(msg, psymb, val, loc) yydestruct(msg, psymb, val, loc)\n");
|
||||
else
|
||||
puts_code(fp, ", loc");
|
||||
#endif
|
||||
putl_code(fp,
|
||||
"#define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val)\n");
|
||||
puts_code(fp, ") yydestruct(msg, psymb, val");
|
||||
#if defined(YYBTYACC)
|
||||
if (locations)
|
||||
puts_code(fp, ", loc");
|
||||
#endif
|
||||
if (parse_param)
|
||||
{
|
||||
puts_code(fp, ", ");
|
||||
puts_param_names(fp, parse_param, 0);
|
||||
}
|
||||
putl_code(fp, ")\n");
|
||||
|
||||
putl_code(fp, "#endif\n");
|
||||
}
|
||||
|
||||
|
@ -1,8 +1,8 @@
|
||||
Summary: byacc - public domain Berkeley LALR Yacc parser generator
|
||||
%define AppProgram byacc
|
||||
%define AppVersion 20140715
|
||||
%define AppVersion 20141005
|
||||
%define UseProgram yacc
|
||||
# $XTermId: byacc.spec,v 1.22 2014/07/15 19:36:54 tom Exp $
|
||||
# $XTermId: byacc.spec,v 1.24 2014/10/04 16:37:39 tom Exp $
|
||||
Name: %{AppProgram}
|
||||
Version: %{AppVersion}
|
||||
Release: 1
|
||||
|
@ -1,3 +1,9 @@
|
||||
byacc (20141005) unstable; urgency=low
|
||||
|
||||
* maintenance updates
|
||||
|
||||
-- Thomas E. Dickey <dickey@invisible-island.net> Sun, 27 Jul 2014 10:45:06 -0400
|
||||
|
||||
byacc (20140715) unstable; urgency=low
|
||||
|
||||
* maintenance updates
|
||||
|
@ -1,8 +1,8 @@
|
||||
Summary: byacc - public domain Berkeley LALR Yacc parser generator
|
||||
%define AppProgram byacc
|
||||
%define AppVersion 20140715
|
||||
%define AppVersion 20141005
|
||||
%define UseProgram yacc
|
||||
# $XTermId: mingw-byacc.spec,v 1.4 2014/07/15 19:36:54 tom Exp $
|
||||
# $XTermId: mingw-byacc.spec,v 1.6 2014/10/04 16:37:39 tom Exp $
|
||||
Name: %{AppProgram}
|
||||
Version: %{AppVersion}
|
||||
Release: 1
|
||||
|
@ -1,7 +1,7 @@
|
||||
# $NetBSD: Makefile,v 1.9 2008/07/24 17:13:00 tonnerre Exp $
|
||||
#
|
||||
|
||||
DISTNAME= byacc-20140715
|
||||
DISTNAME= byacc-20141005
|
||||
PKGREVISION= 1
|
||||
CATEGORIES= devel
|
||||
MASTER_SITES= ftp://invisible-island.net/byacc/
|
||||
|
411
reader.c
411
reader.c
@ -1,4 +1,4 @@
|
||||
/* $Id: reader.c,v 1.47 2014/04/09 21:09:27 tom Exp $ */
|
||||
/* $Id: reader.c,v 1.57 2014/10/06 00:52:44 tom Exp $ */
|
||||
|
||||
#include "defs.h"
|
||||
|
||||
@ -70,6 +70,7 @@ static bucket *default_destructor[3] =
|
||||
static bucket *
|
||||
lookup_type_destructor(char *tag)
|
||||
{
|
||||
const char fmt[] = "%.*s destructor";
|
||||
char name[1024] = "\0";
|
||||
bucket *bp, **bpp = &default_destructor[TYPE_SPECIFIED];
|
||||
|
||||
@ -80,7 +81,8 @@ lookup_type_destructor(char *tag)
|
||||
bpp = &bp->link;
|
||||
}
|
||||
|
||||
*bpp = bp = make_bucket(strcat(strcpy(name, tag), " destructor"));
|
||||
sprintf(name, fmt, (int)(sizeof(name) - sizeof(fmt)), tag);
|
||||
*bpp = bp = make_bucket(name);
|
||||
bp->tag = tag;
|
||||
|
||||
return (bp);
|
||||
@ -125,7 +127,7 @@ get_line(void)
|
||||
if (line)
|
||||
FREE(line);
|
||||
linesize = LINESIZE + 1;
|
||||
line = TMALLOC(char, linesize);
|
||||
line = TCMALLOC(char, linesize);
|
||||
NO_SPACE(line);
|
||||
}
|
||||
|
||||
@ -205,7 +207,7 @@ skip_comment(void)
|
||||
}
|
||||
|
||||
static int
|
||||
nextc(void)
|
||||
next_inline(void)
|
||||
{
|
||||
char *s;
|
||||
|
||||
@ -221,27 +223,6 @@ nextc(void)
|
||||
{
|
||||
switch (*s)
|
||||
{
|
||||
case '\n':
|
||||
get_line();
|
||||
if (line == 0)
|
||||
return (EOF);
|
||||
s = cptr;
|
||||
break;
|
||||
|
||||
case ' ':
|
||||
case '\t':
|
||||
case '\f':
|
||||
case '\r':
|
||||
case '\v':
|
||||
case ',':
|
||||
case ';':
|
||||
++s;
|
||||
break;
|
||||
|
||||
case '\\':
|
||||
cptr = s;
|
||||
return ('%');
|
||||
|
||||
case '/':
|
||||
if (s[1] == '*')
|
||||
{
|
||||
@ -266,6 +247,41 @@ nextc(void)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
nextc(void)
|
||||
{
|
||||
int ch;
|
||||
int finish = 0;
|
||||
|
||||
do
|
||||
{
|
||||
switch (ch = next_inline())
|
||||
{
|
||||
case '\n':
|
||||
get_line();
|
||||
break;
|
||||
case ' ':
|
||||
case '\t':
|
||||
case '\f':
|
||||
case '\r':
|
||||
case '\v':
|
||||
case ',':
|
||||
case ';':
|
||||
++cptr;
|
||||
break;
|
||||
case '\\':
|
||||
ch = '%';
|
||||
/* FALLTHRU */
|
||||
default:
|
||||
finish = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (!finish);
|
||||
|
||||
return ch;
|
||||
}
|
||||
/* *INDENT-OFF* */
|
||||
static struct keyword
|
||||
{
|
||||
@ -643,92 +659,109 @@ copy_union(void)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Keep a linked list of parameters
|
||||
*/
|
||||
static void
|
||||
copy_param(int k)
|
||||
static char *
|
||||
after_blanks(char *s)
|
||||
{
|
||||
char *buf;
|
||||
int c;
|
||||
param *head, *p;
|
||||
int i;
|
||||
int name, type2;
|
||||
while (*s != '\0' && isspace(UCH(*s)))
|
||||
++s;
|
||||
return s;
|
||||
}
|
||||
|
||||
c = nextc();
|
||||
if (c == EOF)
|
||||
unexpected_EOF();
|
||||
if (c != L_CURL)
|
||||
goto out;
|
||||
cptr++;
|
||||
|
||||
c = nextc();
|
||||
if (c == EOF)
|
||||
unexpected_EOF();
|
||||
if (c == R_CURL)
|
||||
goto out;
|
||||
|
||||
buf = TMALLOC(char, linesize);
|
||||
NO_SPACE(buf);
|
||||
|
||||
for (i = 0; (c = *cptr++) != R_CURL; i++)
|
||||
/*
|
||||
* Trim leading/trailing blanks, and collapse multiple embedded blanks to a
|
||||
* single space. Return index to last character in the buffer.
|
||||
*/
|
||||
static int
|
||||
trim_blanks(char *buffer)
|
||||
{
|
||||
if (*buffer != '\0')
|
||||
{
|
||||
if (c == '\0')
|
||||
missing_brace();
|
||||
if (c == EOF)
|
||||
unexpected_EOF();
|
||||
buf[i] = (char)c;
|
||||
}
|
||||
char *d = buffer;
|
||||
char *s = after_blanks(d);
|
||||
|
||||
if (i == 0)
|
||||
goto out;
|
||||
|
||||
buf[i--] = '\0';
|
||||
while (i > 0 && isspace(UCH(buf[i])))
|
||||
buf[i--] = '\0';
|
||||
|
||||
if (buf[i] == ']')
|
||||
{
|
||||
int level = 1;
|
||||
while (i >= 0 && level > 0 && buf[i] != '[')
|
||||
while ((*d++ = *s++) != '\0')
|
||||
{
|
||||
if (buf[i] == ']')
|
||||
++level;
|
||||
else if (buf[i] == '[')
|
||||
--level;
|
||||
i--;
|
||||
;
|
||||
}
|
||||
|
||||
--d;
|
||||
while ((--d != buffer) && isspace(UCH(*d)))
|
||||
*d = '\0';
|
||||
|
||||
for (s = d = buffer; (*d++ = *s++) != '\0';)
|
||||
{
|
||||
if (isspace(UCH(*s)))
|
||||
{
|
||||
*s = ' ';
|
||||
while (isspace(UCH(*s)))
|
||||
{
|
||||
*s++ = ' ';
|
||||
}
|
||||
--s;
|
||||
}
|
||||
}
|
||||
if (i <= 0)
|
||||
unexpected_EOF();
|
||||
type2 = i--;
|
||||
}
|
||||
else
|
||||
|
||||
return (int)strlen(buffer) - 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Scan forward in the current line-buffer looking for a right-curly bracket.
|
||||
*
|
||||
* Parameters begin with a left-curly bracket, and continue until there are no
|
||||
* more interesting characters after the last right-curly bracket on the
|
||||
* current line. Bison documents parameters as separated like this:
|
||||
* {type param1} {type2 param2}
|
||||
* but also accepts commas (although some versions of bison mishandle this)
|
||||
* {type param1, type2 param2}
|
||||
*/
|
||||
static int
|
||||
more_curly(void)
|
||||
{
|
||||
char *save = cptr;
|
||||
int result = 0;
|
||||
int finish = 0;
|
||||
do
|
||||
{
|
||||
type2 = i + 1;
|
||||
switch (next_inline())
|
||||
{
|
||||
case 0:
|
||||
case '\n':
|
||||
finish = 1;
|
||||
break;
|
||||
case R_CURL:
|
||||
finish = 1;
|
||||
result = 1;
|
||||
break;
|
||||
}
|
||||
++cptr;
|
||||
}
|
||||
while (!finish);
|
||||
cptr = save;
|
||||
return result;
|
||||
}
|
||||
|
||||
while (i > 0 && (isalnum(UCH(buf[i])) ||
|
||||
UCH(buf[i]) == '_'))
|
||||
i--;
|
||||
|
||||
if (!isspace(UCH(buf[i])) && buf[i] != '*')
|
||||
goto out;
|
||||
|
||||
name = i + 1;
|
||||
static void
|
||||
save_param(int k, char *buffer, int name, int type2)
|
||||
{
|
||||
param *head, *p;
|
||||
|
||||
p = TMALLOC(param, 1);
|
||||
NO_SPACE(p);
|
||||
|
||||
p->type2 = strdup(buf + type2);
|
||||
p->type2 = strdup(buffer + type2);
|
||||
NO_SPACE(p->type2);
|
||||
buffer[type2] = '\0';
|
||||
(void)trim_blanks(p->type2);
|
||||
|
||||
buf[type2] = '\0';
|
||||
|
||||
p->name = strdup(buf + name);
|
||||
p->name = strdup(buffer + name);
|
||||
NO_SPACE(p->name);
|
||||
buffer[name] = '\0';
|
||||
(void)trim_blanks(p->name);
|
||||
|
||||
buf[name] = '\0';
|
||||
p->type = buf;
|
||||
p->type = strdup(buffer);
|
||||
NO_SPACE(p->type);
|
||||
(void)trim_blanks(p->type);
|
||||
|
||||
if (k == LEX_PARAM)
|
||||
head = lex_param;
|
||||
@ -749,9 +782,169 @@ copy_param(int k)
|
||||
parse_param = p;
|
||||
}
|
||||
p->next = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Keep a linked list of parameters. This may be multi-line, if the trailing
|
||||
* right-curly bracket is absent.
|
||||
*/
|
||||
static void
|
||||
copy_param(int k)
|
||||
{
|
||||
int c;
|
||||
int name, type2;
|
||||
int curly = 0;
|
||||
char *buf = 0;
|
||||
int i = -1;
|
||||
size_t buf_size = 0;
|
||||
int st_lineno = lineno;
|
||||
char *comma;
|
||||
|
||||
do
|
||||
{
|
||||
int state = curly;
|
||||
c = next_inline();
|
||||
switch (c)
|
||||
{
|
||||
case EOF:
|
||||
unexpected_EOF();
|
||||
break;
|
||||
case L_CURL:
|
||||
if (curly == 1)
|
||||
{
|
||||
goto oops;
|
||||
}
|
||||
curly = 1;
|
||||
st_lineno = lineno;
|
||||
break;
|
||||
case R_CURL:
|
||||
if (curly != 1)
|
||||
{
|
||||
goto oops;
|
||||
}
|
||||
curly = 2;
|
||||
break;
|
||||
case '\n':
|
||||
if (curly == 0)
|
||||
{
|
||||
goto oops;
|
||||
}
|
||||
break;
|
||||
case '%':
|
||||
if ((curly == 1) && (cptr == line))
|
||||
{
|
||||
lineno = st_lineno;
|
||||
missing_brace();
|
||||
}
|
||||
/* FALLTHRU */
|
||||
case '"':
|
||||
case '\'':
|
||||
goto oops;
|
||||
default:
|
||||
if (curly == 0 && !isspace(UCH(c)))
|
||||
{
|
||||
goto oops;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (buf == 0)
|
||||
{
|
||||
buf_size = (size_t) linesize;
|
||||
buf = TMALLOC(char, buf_size);
|
||||
}
|
||||
else if (c == '\n')
|
||||
{
|
||||
get_line();
|
||||
if (line == 0)
|
||||
unexpected_EOF();
|
||||
--cptr;
|
||||
buf_size += (size_t) linesize;
|
||||
buf = TREALLOC(char, buf, buf_size);
|
||||
}
|
||||
NO_SPACE(buf);
|
||||
if (curly)
|
||||
{
|
||||
if ((state == 2) && (c == L_CURL))
|
||||
{
|
||||
buf[++i] = ',';
|
||||
}
|
||||
else if ((state == 2) && isspace(UCH(c)))
|
||||
{
|
||||
;
|
||||
}
|
||||
else if ((c != L_CURL) && (c != R_CURL))
|
||||
{
|
||||
buf[++i] = (char)c;
|
||||
}
|
||||
}
|
||||
cptr++;
|
||||
}
|
||||
while (curly < 2 || more_curly());
|
||||
|
||||
if (i == 0)
|
||||
{
|
||||
if (curly == 1)
|
||||
{
|
||||
lineno = st_lineno;
|
||||
missing_brace();
|
||||
}
|
||||
goto oops;
|
||||
}
|
||||
|
||||
buf[i--] = '\0';
|
||||
i = trim_blanks(buf);
|
||||
|
||||
comma = buf - 1;
|
||||
do
|
||||
{
|
||||
char *parms = (comma + 1);
|
||||
comma = strchr(parms, ',');
|
||||
if (comma != 0)
|
||||
*comma = '\0';
|
||||
|
||||
(void)trim_blanks(parms);
|
||||
i = (int)strlen(parms) - 1;
|
||||
if (i < 0)
|
||||
{
|
||||
goto oops;
|
||||
}
|
||||
|
||||
if (parms[i] == ']')
|
||||
{
|
||||
int level = 1;
|
||||
while (i >= 0 && level > 0 && parms[i] != '[')
|
||||
{
|
||||
if (parms[i] == ']')
|
||||
++level;
|
||||
else if (parms[i] == '[')
|
||||
--level;
|
||||
i--;
|
||||
}
|
||||
if (i <= 0)
|
||||
unexpected_EOF();
|
||||
type2 = i--;
|
||||
}
|
||||
else
|
||||
{
|
||||
type2 = i + 1;
|
||||
}
|
||||
|
||||
while (i > 0 && (isalnum(UCH(parms[i])) || UCH(parms[i]) == '_'))
|
||||
i--;
|
||||
|
||||
if (!isspace(UCH(parms[i])) && parms[i] != '*')
|
||||
goto oops;
|
||||
|
||||
name = i + 1;
|
||||
|
||||
save_param(k, parms, name, type2);
|
||||
}
|
||||
while (comma != 0);
|
||||
FREE(buf);
|
||||
return;
|
||||
|
||||
out:
|
||||
oops:
|
||||
FREE(buf);
|
||||
syntax_error(lineno, line, cptr);
|
||||
}
|
||||
|
||||
@ -1633,10 +1826,11 @@ compile_arg(char **theptr, char *yyvaltag)
|
||||
{
|
||||
offsets = TMALLOC(Value_t, maxoffset + 1);
|
||||
NO_SPACE(offsets);
|
||||
|
||||
for (j = 0, i++; i < nitems; i++)
|
||||
if (pitem[i]->class != ARGUMENT)
|
||||
offsets[++j] = (Value_t) (i - nitems + 1);
|
||||
}
|
||||
for (j = 0, i++; i < nitems; i++)
|
||||
if (pitem[i]->class != ARGUMENT)
|
||||
offsets[++j] = (Value_t) (i - nitems + 1);
|
||||
rhs = pitem + nitems - 1;
|
||||
|
||||
if (yyvaltag)
|
||||
@ -1663,7 +1857,7 @@ compile_arg(char **theptr, char *yyvaltag)
|
||||
dollar_warning(rescan_lineno, val);
|
||||
i = val - maxoffset;
|
||||
}
|
||||
else
|
||||
else if (maxoffset > 0)
|
||||
{
|
||||
i = offsets[val];
|
||||
if (!tag && !(tag = rhs[i]->tag) && havetags)
|
||||
@ -2019,14 +2213,6 @@ add_symbol(void)
|
||||
pitem[nitems - 1] = bp;
|
||||
}
|
||||
|
||||
static char *
|
||||
after_blanks(char *s)
|
||||
{
|
||||
while (*s != '\0' && isspace(UCH(*s)))
|
||||
++s;
|
||||
return s;
|
||||
}
|
||||
|
||||
static void
|
||||
copy_action(void)
|
||||
{
|
||||
@ -2083,12 +2269,13 @@ copy_action(void)
|
||||
{
|
||||
offsets = TMALLOC(Value_t, maxoffset + 1);
|
||||
NO_SPACE(offsets);
|
||||
}
|
||||
for (j = 0, i++; i < nitems; i++)
|
||||
{
|
||||
if (pitem[i]->class != ARGUMENT)
|
||||
|
||||
for (j = 0, i++; i < nitems; i++)
|
||||
{
|
||||
offsets[++j] = (Value_t) (i - nitems + 1);
|
||||
if (pitem[i]->class != ARGUMENT)
|
||||
{
|
||||
offsets[++j] = (Value_t) (i - nitems + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
rhs = pitem + nitems - 1;
|
||||
@ -2176,7 +2363,7 @@ copy_action(void)
|
||||
{
|
||||
++cptr;
|
||||
i = get_number();
|
||||
if (havetags)
|
||||
if (havetags && offsets)
|
||||
{
|
||||
if (i <= 0 || i > maxoffset)
|
||||
unknown_rhs(i);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -311,7 +311,26 @@ static const YYINT calc1_ctable[] = { 20,
|
||||
16, -1, 21, 16, -1, 22, 16, -1, 23, 16,
|
||||
-1, 4, 16, -1, 14, 16, -1, 34, 16, -1,
|
||||
10, 16, -1, 11, 16, -1, 12, 16, -1, 13,
|
||||
16, -1,
|
||||
16, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
@ -594,7 +613,7 @@ vdiv(double a, double b, INTERVAL v)
|
||||
{
|
||||
return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
|
||||
}
|
||||
#line 598 "btyacc_calc1.tab.c"
|
||||
#line 617 "btyacc_calc1.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -603,11 +622,11 @@ vdiv(double a, double b, INTERVAL v)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -841,8 +860,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -938,12 +957,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -998,7 +1017,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -1092,14 +1111,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -1108,12 +1127,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -1143,12 +1162,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1494,7 +1513,7 @@ case 28:
|
||||
yyval.vval = yystack.l_mark[-1].vval;
|
||||
}
|
||||
break;
|
||||
#line 1498 "btyacc_calc1.tab.c"
|
||||
#line 1517 "btyacc_calc1.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1545,8 +1564,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1649,12 +1668,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -387,7 +387,32 @@ static const YYINT demo_check[] = { 42,
|
||||
#if YYBTYACC
|
||||
static const YYINT demo_ctable[] = { -1,
|
||||
1, 10, -1, 21, 4, -1, 23, 29, -1, 1,
|
||||
51, -1, 101, 56, -1,
|
||||
51, -1, 101, 56, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
@ -634,7 +659,7 @@ extern Expr * var_expr(Scope *scope, char *id);
|
||||
extern Code * build_expr_code(Expr *expr);
|
||||
extern Code * build_if(Expr *cond_expr, Code *then_stmt, Code *else_stmt);
|
||||
extern Code * code_append(Code *stmt_list, Code *stmt);
|
||||
#line 638 "btyacc_demo.tab.c"
|
||||
#line 663 "btyacc_demo.tab.c"
|
||||
|
||||
/* Release memory associated with symbol. */
|
||||
#if ! defined YYDESTRUCT_IS_DECLARED
|
||||
@ -651,7 +676,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 655 "btyacc_demo.tab.c"
|
||||
#line 680 "btyacc_demo.tab.c"
|
||||
case 45:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -660,7 +685,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 664 "btyacc_demo.tab.c"
|
||||
#line 689 "btyacc_demo.tab.c"
|
||||
case 42:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -669,7 +694,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 673 "btyacc_demo.tab.c"
|
||||
#line 698 "btyacc_demo.tab.c"
|
||||
case 47:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -678,7 +703,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 682 "btyacc_demo.tab.c"
|
||||
#line 707 "btyacc_demo.tab.c"
|
||||
case 37:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -687,7 +712,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 691 "btyacc_demo.tab.c"
|
||||
#line 716 "btyacc_demo.tab.c"
|
||||
case 257:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -696,7 +721,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 700 "btyacc_demo.tab.c"
|
||||
#line 725 "btyacc_demo.tab.c"
|
||||
case 258:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -705,7 +730,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 709 "btyacc_demo.tab.c"
|
||||
#line 734 "btyacc_demo.tab.c"
|
||||
case 40:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -714,7 +739,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 718 "btyacc_demo.tab.c"
|
||||
#line 743 "btyacc_demo.tab.c"
|
||||
case 91:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -723,7 +748,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 727 "btyacc_demo.tab.c"
|
||||
#line 752 "btyacc_demo.tab.c"
|
||||
case 46:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -732,7 +757,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 736 "btyacc_demo.tab.c"
|
||||
#line 761 "btyacc_demo.tab.c"
|
||||
case 259:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -741,7 +766,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).id); }
|
||||
break;
|
||||
#line 745 "btyacc_demo.tab.c"
|
||||
#line 770 "btyacc_demo.tab.c"
|
||||
case 260:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -750,7 +775,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).expr); }
|
||||
break;
|
||||
#line 754 "btyacc_demo.tab.c"
|
||||
#line 779 "btyacc_demo.tab.c"
|
||||
case 261:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -759,7 +784,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 763 "btyacc_demo.tab.c"
|
||||
#line 788 "btyacc_demo.tab.c"
|
||||
case 262:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -768,7 +793,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 772 "btyacc_demo.tab.c"
|
||||
#line 797 "btyacc_demo.tab.c"
|
||||
case 263:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -777,7 +802,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 781 "btyacc_demo.tab.c"
|
||||
#line 806 "btyacc_demo.tab.c"
|
||||
case 264:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -786,7 +811,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 790 "btyacc_demo.tab.c"
|
||||
#line 815 "btyacc_demo.tab.c"
|
||||
case 265:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -795,7 +820,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 799 "btyacc_demo.tab.c"
|
||||
#line 824 "btyacc_demo.tab.c"
|
||||
case 266:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -804,7 +829,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 808 "btyacc_demo.tab.c"
|
||||
#line 833 "btyacc_demo.tab.c"
|
||||
case 267:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -813,7 +838,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 817 "btyacc_demo.tab.c"
|
||||
#line 842 "btyacc_demo.tab.c"
|
||||
case 268:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -822,7 +847,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 826 "btyacc_demo.tab.c"
|
||||
#line 851 "btyacc_demo.tab.c"
|
||||
case 269:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -831,7 +856,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 835 "btyacc_demo.tab.c"
|
||||
#line 860 "btyacc_demo.tab.c"
|
||||
case 59:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -840,7 +865,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 844 "btyacc_demo.tab.c"
|
||||
#line 869 "btyacc_demo.tab.c"
|
||||
case 44:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -849,7 +874,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 853 "btyacc_demo.tab.c"
|
||||
#line 878 "btyacc_demo.tab.c"
|
||||
case 41:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -858,7 +883,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 862 "btyacc_demo.tab.c"
|
||||
#line 887 "btyacc_demo.tab.c"
|
||||
case 93:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -867,7 +892,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 871 "btyacc_demo.tab.c"
|
||||
#line 896 "btyacc_demo.tab.c"
|
||||
case 123:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -876,7 +901,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 880 "btyacc_demo.tab.c"
|
||||
#line 905 "btyacc_demo.tab.c"
|
||||
case 125:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -885,7 +910,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 889 "btyacc_demo.tab.c"
|
||||
#line 914 "btyacc_demo.tab.c"
|
||||
case 270:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -894,7 +919,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 898 "btyacc_demo.tab.c"
|
||||
#line 923 "btyacc_demo.tab.c"
|
||||
case 271:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -903,7 +928,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 907 "btyacc_demo.tab.c"
|
||||
#line 932 "btyacc_demo.tab.c"
|
||||
case 272:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -912,7 +937,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).expr); }
|
||||
break;
|
||||
#line 916 "btyacc_demo.tab.c"
|
||||
#line 941 "btyacc_demo.tab.c"
|
||||
case 273:
|
||||
#line 67 "btyacc_demo.y"
|
||||
{ /* 'msg' is a 'char *' indicating the context of destructor invocation*/
|
||||
@ -922,7 +947,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).decl->scope); free((*val).decl->type); }
|
||||
break;
|
||||
#line 926 "btyacc_demo.tab.c"
|
||||
#line 951 "btyacc_demo.tab.c"
|
||||
case 274:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -931,7 +956,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 935 "btyacc_demo.tab.c"
|
||||
#line 960 "btyacc_demo.tab.c"
|
||||
case 275:
|
||||
#line 83 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
|
||||
@ -940,7 +965,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
/* in this example, we don't know what to do here */ }
|
||||
break;
|
||||
#line 944 "btyacc_demo.tab.c"
|
||||
#line 969 "btyacc_demo.tab.c"
|
||||
case 276:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -949,7 +974,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).code); }
|
||||
break;
|
||||
#line 953 "btyacc_demo.tab.c"
|
||||
#line 978 "btyacc_demo.tab.c"
|
||||
case 277:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -958,7 +983,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).code); }
|
||||
break;
|
||||
#line 962 "btyacc_demo.tab.c"
|
||||
#line 987 "btyacc_demo.tab.c"
|
||||
case 278:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -967,7 +992,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).code); }
|
||||
break;
|
||||
#line 971 "btyacc_demo.tab.c"
|
||||
#line 996 "btyacc_demo.tab.c"
|
||||
case 279:
|
||||
#line 73 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n",
|
||||
@ -976,7 +1001,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).decl); }
|
||||
break;
|
||||
#line 980 "btyacc_demo.tab.c"
|
||||
#line 1005 "btyacc_demo.tab.c"
|
||||
case 280:
|
||||
#line 73 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n",
|
||||
@ -985,7 +1010,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).decl); }
|
||||
break;
|
||||
#line 989 "btyacc_demo.tab.c"
|
||||
#line 1014 "btyacc_demo.tab.c"
|
||||
case 281:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -994,7 +1019,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 998 "btyacc_demo.tab.c"
|
||||
#line 1023 "btyacc_demo.tab.c"
|
||||
case 282:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1003,7 +1028,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 1007 "btyacc_demo.tab.c"
|
||||
#line 1032 "btyacc_demo.tab.c"
|
||||
case 283:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1012,7 +1037,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 1016 "btyacc_demo.tab.c"
|
||||
#line 1041 "btyacc_demo.tab.c"
|
||||
case 284:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1021,7 +1046,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 1025 "btyacc_demo.tab.c"
|
||||
#line 1050 "btyacc_demo.tab.c"
|
||||
case 285:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1030,7 +1055,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 1034 "btyacc_demo.tab.c"
|
||||
#line 1059 "btyacc_demo.tab.c"
|
||||
case 286:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1039,7 +1064,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1043 "btyacc_demo.tab.c"
|
||||
#line 1068 "btyacc_demo.tab.c"
|
||||
case 287:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1048,7 +1073,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).dlist); }
|
||||
break;
|
||||
#line 1052 "btyacc_demo.tab.c"
|
||||
#line 1077 "btyacc_demo.tab.c"
|
||||
case 288:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1057,7 +1082,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).dlist); }
|
||||
break;
|
||||
#line 1061 "btyacc_demo.tab.c"
|
||||
#line 1086 "btyacc_demo.tab.c"
|
||||
case 289:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1066,7 +1091,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1070 "btyacc_demo.tab.c"
|
||||
#line 1095 "btyacc_demo.tab.c"
|
||||
case 290:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1075,7 +1100,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1079 "btyacc_demo.tab.c"
|
||||
#line 1104 "btyacc_demo.tab.c"
|
||||
case 291:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1084,7 +1109,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 1088 "btyacc_demo.tab.c"
|
||||
#line 1113 "btyacc_demo.tab.c"
|
||||
case 292:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1093,7 +1118,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1097 "btyacc_demo.tab.c"
|
||||
#line 1122 "btyacc_demo.tab.c"
|
||||
case 293:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1102,7 +1127,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1106 "btyacc_demo.tab.c"
|
||||
#line 1131 "btyacc_demo.tab.c"
|
||||
case 294:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1111,7 +1136,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 1115 "btyacc_demo.tab.c"
|
||||
#line 1140 "btyacc_demo.tab.c"
|
||||
case 295:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1120,7 +1145,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1124 "btyacc_demo.tab.c"
|
||||
#line 1149 "btyacc_demo.tab.c"
|
||||
case 296:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1129,7 +1154,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).type); }
|
||||
break;
|
||||
#line 1133 "btyacc_demo.tab.c"
|
||||
#line 1158 "btyacc_demo.tab.c"
|
||||
case 297:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1138,7 +1163,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1142 "btyacc_demo.tab.c"
|
||||
#line 1167 "btyacc_demo.tab.c"
|
||||
case 298:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1147,7 +1172,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1151 "btyacc_demo.tab.c"
|
||||
#line 1176 "btyacc_demo.tab.c"
|
||||
case 299:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1156,7 +1181,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1160 "btyacc_demo.tab.c"
|
||||
#line 1185 "btyacc_demo.tab.c"
|
||||
case 300:
|
||||
#line 78 "btyacc_demo.y"
|
||||
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
|
||||
@ -1165,7 +1190,7 @@ YYDESTRUCT_DECL()
|
||||
(*loc).last_line, (*loc).last_column);
|
||||
free((*val).scope); }
|
||||
break;
|
||||
#line 1169 "btyacc_demo.tab.c"
|
||||
#line 1194 "btyacc_demo.tab.c"
|
||||
}
|
||||
}
|
||||
#define YYDESTRUCT_IS_DECLARED 1
|
||||
@ -1178,11 +1203,11 @@ YYDESTRUCT_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -1366,8 +1391,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -1463,12 +1488,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -1523,7 +1548,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -1617,14 +1642,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -1633,12 +1658,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -1668,12 +1693,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -2093,7 +2118,7 @@ case 61:
|
||||
#line 197 "btyacc_demo.y"
|
||||
{ yyval.code = yystack.l_mark[-1].code; }
|
||||
break;
|
||||
#line 2097 "btyacc_demo.tab.c"
|
||||
#line 2122 "btyacc_demo.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -2144,8 +2169,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -2248,12 +2273,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
1
test/btyacc/btyacc_demo2.error
Normal file
1
test/btyacc/btyacc_demo2.error
Normal file
@ -0,0 +1 @@
|
||||
YACC: e - line 82 of "./btyacc_demo2.y", $$ is untyped
|
0
test/btyacc/btyacc_demo2.output
Normal file
0
test/btyacc/btyacc_demo2.output
Normal file
15
test/btyacc/btyacc_demo2.tab.c
Normal file
15
test/btyacc/btyacc_demo2.tab.c
Normal file
@ -0,0 +1,15 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
#define YYMINOR 9
|
||||
#define YYCHECK "yyyymmdd"
|
||||
|
||||
#define YYEMPTY (-1)
|
||||
#define yyclearin (yychar = YYEMPTY)
|
||||
#define yyerrok (yyerrflag = 0)
|
||||
#define YYRECOVERING() (yyerrflag != 0)
|
||||
#define YYENOMEM (-2)
|
||||
#define YYEOF 0
|
0
test/btyacc/btyacc_demo2.tab.h
Normal file
0
test/btyacc/btyacc_demo2.tab.h
Normal file
0
test/btyacc/btyacc_destroy1.error
Normal file
0
test/btyacc/btyacc_destroy1.error
Normal file
247
test/btyacc/btyacc_destroy1.output
Normal file
247
test/btyacc/btyacc_destroy1.output
Normal file
@ -0,0 +1,247 @@
|
||||
0 $accept : declaration $end
|
||||
|
||||
1 declaration : class type namelist '(' class ',' type ')'
|
||||
2 | type locnamelist '(' class ')'
|
||||
|
||||
3 class : GLOBAL
|
||||
4 | LOCAL
|
||||
|
||||
5 type : REAL
|
||||
6 | INTEGER
|
||||
|
||||
7 namelist : namelist NAME
|
||||
8 | NAME
|
||||
|
||||
9 locnamelist : namelist '(' LOCAL ',' type ')'
|
||||
|
||||
state 0
|
||||
$accept : . declaration $end (0)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
declaration goto 5
|
||||
class goto 6
|
||||
type goto 7
|
||||
|
||||
|
||||
state 1
|
||||
class : GLOBAL . (3)
|
||||
|
||||
. reduce 3
|
||||
|
||||
|
||||
state 2
|
||||
class : LOCAL . (4)
|
||||
|
||||
. reduce 4
|
||||
|
||||
|
||||
state 3
|
||||
type : REAL . (5)
|
||||
|
||||
. reduce 5
|
||||
|
||||
|
||||
state 4
|
||||
type : INTEGER . (6)
|
||||
|
||||
. reduce 6
|
||||
|
||||
|
||||
state 5
|
||||
$accept : declaration . $end (0)
|
||||
|
||||
$end accept
|
||||
|
||||
|
||||
state 6
|
||||
declaration : class . type namelist '(' class ',' type ')' (1)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 8
|
||||
|
||||
|
||||
state 7
|
||||
declaration : type . locnamelist '(' class ')' (2)
|
||||
|
||||
NAME shift 9
|
||||
. error
|
||||
|
||||
locnamelist goto 10
|
||||
namelist goto 11
|
||||
|
||||
|
||||
state 8
|
||||
declaration : class type . namelist '(' class ',' type ')' (1)
|
||||
|
||||
NAME shift 9
|
||||
. error
|
||||
|
||||
namelist goto 12
|
||||
|
||||
|
||||
state 9
|
||||
namelist : NAME . (8)
|
||||
|
||||
. reduce 8
|
||||
|
||||
|
||||
state 10
|
||||
declaration : type locnamelist . '(' class ')' (2)
|
||||
|
||||
'(' shift 13
|
||||
. error
|
||||
|
||||
|
||||
state 11
|
||||
namelist : namelist . NAME (7)
|
||||
locnamelist : namelist . '(' LOCAL ',' type ')' (9)
|
||||
|
||||
NAME shift 14
|
||||
'(' shift 15
|
||||
. error
|
||||
|
||||
|
||||
state 12
|
||||
declaration : class type namelist . '(' class ',' type ')' (1)
|
||||
namelist : namelist . NAME (7)
|
||||
|
||||
NAME shift 14
|
||||
'(' shift 16
|
||||
. error
|
||||
|
||||
|
||||
state 13
|
||||
declaration : type locnamelist '(' . class ')' (2)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
. error
|
||||
|
||||
class goto 17
|
||||
|
||||
|
||||
state 14
|
||||
namelist : namelist NAME . (7)
|
||||
|
||||
. reduce 7
|
||||
|
||||
|
||||
state 15
|
||||
locnamelist : namelist '(' . LOCAL ',' type ')' (9)
|
||||
|
||||
LOCAL shift 18
|
||||
. error
|
||||
|
||||
|
||||
state 16
|
||||
declaration : class type namelist '(' . class ',' type ')' (1)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
. error
|
||||
|
||||
class goto 19
|
||||
|
||||
|
||||
state 17
|
||||
declaration : type locnamelist '(' class . ')' (2)
|
||||
|
||||
')' shift 20
|
||||
. error
|
||||
|
||||
|
||||
state 18
|
||||
locnamelist : namelist '(' LOCAL . ',' type ')' (9)
|
||||
|
||||
',' shift 21
|
||||
. error
|
||||
|
||||
|
||||
state 19
|
||||
declaration : class type namelist '(' class . ',' type ')' (1)
|
||||
|
||||
',' shift 22
|
||||
. error
|
||||
|
||||
|
||||
state 20
|
||||
declaration : type locnamelist '(' class ')' . (2)
|
||||
|
||||
. reduce 2
|
||||
|
||||
|
||||
state 21
|
||||
locnamelist : namelist '(' LOCAL ',' . type ')' (9)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 23
|
||||
|
||||
|
||||
state 22
|
||||
declaration : class type namelist '(' class ',' . type ')' (1)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 24
|
||||
|
||||
|
||||
state 23
|
||||
locnamelist : namelist '(' LOCAL ',' type . ')' (9)
|
||||
|
||||
')' shift 25
|
||||
. error
|
||||
|
||||
|
||||
state 24
|
||||
declaration : class type namelist '(' class ',' type . ')' (1)
|
||||
|
||||
')' shift 26
|
||||
. error
|
||||
|
||||
|
||||
state 25
|
||||
locnamelist : namelist '(' LOCAL ',' type ')' . (9)
|
||||
|
||||
. reduce 9
|
||||
|
||||
|
||||
state 26
|
||||
declaration : class type namelist '(' class ',' type ')' . (1)
|
||||
|
||||
. reduce 1
|
||||
|
||||
|
||||
10 terminals, 6 nonterminals
|
||||
10 grammar rules, 27 states
|
||||
|
||||
grammar parser grammar
|
||||
symbol# value# symbol
|
||||
0 0 $end
|
||||
1 256 error
|
||||
2 257 GLOBAL
|
||||
3 258 LOCAL
|
||||
4 259 REAL
|
||||
5 260 INTEGER
|
||||
6 261 NAME
|
||||
7 40 '('
|
||||
8 44 ','
|
||||
9 41 ')'
|
||||
10 262 $accept
|
||||
11 263 declaration
|
||||
12 264 locnamelist
|
||||
13 265 class
|
||||
14 266 type
|
||||
15 267 namelist
|
1451
test/btyacc/btyacc_destroy1.tab.c
Normal file
1451
test/btyacc/btyacc_destroy1.tab.c
Normal file
File diff suppressed because it is too large
Load Diff
25
test/btyacc/btyacc_destroy1.tab.h
Normal file
25
test/btyacc/btyacc_destroy1.tab.h
Normal file
@ -0,0 +1,25 @@
|
||||
#ifndef _destroy1__defines_h_
|
||||
#define _destroy1__defines_h_
|
||||
|
||||
#define GLOBAL 257
|
||||
#define LOCAL 258
|
||||
#define REAL 259
|
||||
#define INTEGER 260
|
||||
#define NAME 261
|
||||
#ifdef YYSTYPE
|
||||
#undef YYSTYPE_IS_DECLARED
|
||||
#define YYSTYPE_IS_DECLARED 1
|
||||
#endif
|
||||
#ifndef YYSTYPE_IS_DECLARED
|
||||
#define YYSTYPE_IS_DECLARED 1
|
||||
typedef union
|
||||
{
|
||||
class cval;
|
||||
type tval;
|
||||
namelist * nlist;
|
||||
name id;
|
||||
} YYSTYPE;
|
||||
#endif /* !YYSTYPE_IS_DECLARED */
|
||||
extern YYSTYPE destroy1_lval;
|
||||
|
||||
#endif /* _destroy1__defines_h_ */
|
0
test/btyacc/btyacc_destroy2.error
Normal file
0
test/btyacc/btyacc_destroy2.error
Normal file
247
test/btyacc/btyacc_destroy2.output
Normal file
247
test/btyacc/btyacc_destroy2.output
Normal file
@ -0,0 +1,247 @@
|
||||
0 $accept : declaration $end
|
||||
|
||||
1 declaration : class type namelist '(' class ',' type ')'
|
||||
2 | type locnamelist '(' class ')'
|
||||
|
||||
3 class : GLOBAL
|
||||
4 | LOCAL
|
||||
|
||||
5 type : REAL
|
||||
6 | INTEGER
|
||||
|
||||
7 namelist : namelist NAME
|
||||
8 | NAME
|
||||
|
||||
9 locnamelist : namelist '(' LOCAL ',' type ')'
|
||||
|
||||
state 0
|
||||
$accept : . declaration $end (0)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
declaration goto 5
|
||||
class goto 6
|
||||
type goto 7
|
||||
|
||||
|
||||
state 1
|
||||
class : GLOBAL . (3)
|
||||
|
||||
. reduce 3
|
||||
|
||||
|
||||
state 2
|
||||
class : LOCAL . (4)
|
||||
|
||||
. reduce 4
|
||||
|
||||
|
||||
state 3
|
||||
type : REAL . (5)
|
||||
|
||||
. reduce 5
|
||||
|
||||
|
||||
state 4
|
||||
type : INTEGER . (6)
|
||||
|
||||
. reduce 6
|
||||
|
||||
|
||||
state 5
|
||||
$accept : declaration . $end (0)
|
||||
|
||||
$end accept
|
||||
|
||||
|
||||
state 6
|
||||
declaration : class . type namelist '(' class ',' type ')' (1)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 8
|
||||
|
||||
|
||||
state 7
|
||||
declaration : type . locnamelist '(' class ')' (2)
|
||||
|
||||
NAME shift 9
|
||||
. error
|
||||
|
||||
locnamelist goto 10
|
||||
namelist goto 11
|
||||
|
||||
|
||||
state 8
|
||||
declaration : class type . namelist '(' class ',' type ')' (1)
|
||||
|
||||
NAME shift 9
|
||||
. error
|
||||
|
||||
namelist goto 12
|
||||
|
||||
|
||||
state 9
|
||||
namelist : NAME . (8)
|
||||
|
||||
. reduce 8
|
||||
|
||||
|
||||
state 10
|
||||
declaration : type locnamelist . '(' class ')' (2)
|
||||
|
||||
'(' shift 13
|
||||
. error
|
||||
|
||||
|
||||
state 11
|
||||
namelist : namelist . NAME (7)
|
||||
locnamelist : namelist . '(' LOCAL ',' type ')' (9)
|
||||
|
||||
NAME shift 14
|
||||
'(' shift 15
|
||||
. error
|
||||
|
||||
|
||||
state 12
|
||||
declaration : class type namelist . '(' class ',' type ')' (1)
|
||||
namelist : namelist . NAME (7)
|
||||
|
||||
NAME shift 14
|
||||
'(' shift 16
|
||||
. error
|
||||
|
||||
|
||||
state 13
|
||||
declaration : type locnamelist '(' . class ')' (2)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
. error
|
||||
|
||||
class goto 17
|
||||
|
||||
|
||||
state 14
|
||||
namelist : namelist NAME . (7)
|
||||
|
||||
. reduce 7
|
||||
|
||||
|
||||
state 15
|
||||
locnamelist : namelist '(' . LOCAL ',' type ')' (9)
|
||||
|
||||
LOCAL shift 18
|
||||
. error
|
||||
|
||||
|
||||
state 16
|
||||
declaration : class type namelist '(' . class ',' type ')' (1)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
. error
|
||||
|
||||
class goto 19
|
||||
|
||||
|
||||
state 17
|
||||
declaration : type locnamelist '(' class . ')' (2)
|
||||
|
||||
')' shift 20
|
||||
. error
|
||||
|
||||
|
||||
state 18
|
||||
locnamelist : namelist '(' LOCAL . ',' type ')' (9)
|
||||
|
||||
',' shift 21
|
||||
. error
|
||||
|
||||
|
||||
state 19
|
||||
declaration : class type namelist '(' class . ',' type ')' (1)
|
||||
|
||||
',' shift 22
|
||||
. error
|
||||
|
||||
|
||||
state 20
|
||||
declaration : type locnamelist '(' class ')' . (2)
|
||||
|
||||
. reduce 2
|
||||
|
||||
|
||||
state 21
|
||||
locnamelist : namelist '(' LOCAL ',' . type ')' (9)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 23
|
||||
|
||||
|
||||
state 22
|
||||
declaration : class type namelist '(' class ',' . type ')' (1)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 24
|
||||
|
||||
|
||||
state 23
|
||||
locnamelist : namelist '(' LOCAL ',' type . ')' (9)
|
||||
|
||||
')' shift 25
|
||||
. error
|
||||
|
||||
|
||||
state 24
|
||||
declaration : class type namelist '(' class ',' type . ')' (1)
|
||||
|
||||
')' shift 26
|
||||
. error
|
||||
|
||||
|
||||
state 25
|
||||
locnamelist : namelist '(' LOCAL ',' type ')' . (9)
|
||||
|
||||
. reduce 9
|
||||
|
||||
|
||||
state 26
|
||||
declaration : class type namelist '(' class ',' type ')' . (1)
|
||||
|
||||
. reduce 1
|
||||
|
||||
|
||||
10 terminals, 6 nonterminals
|
||||
10 grammar rules, 27 states
|
||||
|
||||
grammar parser grammar
|
||||
symbol# value# symbol
|
||||
0 0 $end
|
||||
1 256 error
|
||||
2 257 GLOBAL
|
||||
3 258 LOCAL
|
||||
4 259 REAL
|
||||
5 260 INTEGER
|
||||
6 261 NAME
|
||||
7 40 '('
|
||||
8 44 ','
|
||||
9 41 ')'
|
||||
10 262 $accept
|
||||
11 263 declaration
|
||||
12 264 locnamelist
|
||||
13 265 class
|
||||
14 266 type
|
||||
15 267 namelist
|
1451
test/btyacc/btyacc_destroy2.tab.c
Normal file
1451
test/btyacc/btyacc_destroy2.tab.c
Normal file
File diff suppressed because it is too large
Load Diff
25
test/btyacc/btyacc_destroy2.tab.h
Normal file
25
test/btyacc/btyacc_destroy2.tab.h
Normal file
@ -0,0 +1,25 @@
|
||||
#ifndef _destroy2__defines_h_
|
||||
#define _destroy2__defines_h_
|
||||
|
||||
#define GLOBAL 257
|
||||
#define LOCAL 258
|
||||
#define REAL 259
|
||||
#define INTEGER 260
|
||||
#define NAME 261
|
||||
#ifdef YYSTYPE
|
||||
#undef YYSTYPE_IS_DECLARED
|
||||
#define YYSTYPE_IS_DECLARED 1
|
||||
#endif
|
||||
#ifndef YYSTYPE_IS_DECLARED
|
||||
#define YYSTYPE_IS_DECLARED 1
|
||||
typedef union
|
||||
{
|
||||
class cval;
|
||||
type tval;
|
||||
namelist * nlist;
|
||||
name id;
|
||||
} YYSTYPE;
|
||||
#endif /* !YYSTYPE_IS_DECLARED */
|
||||
extern YYSTYPE destroy2_lval;
|
||||
|
||||
#endif /* _destroy2__defines_h_ */
|
0
test/btyacc/btyacc_destroy3.error
Normal file
0
test/btyacc/btyacc_destroy3.error
Normal file
247
test/btyacc/btyacc_destroy3.output
Normal file
247
test/btyacc/btyacc_destroy3.output
Normal file
@ -0,0 +1,247 @@
|
||||
0 $accept : declaration $end
|
||||
|
||||
1 declaration : class type namelist '(' class ',' type ')'
|
||||
2 | type locnamelist '(' class ')'
|
||||
|
||||
3 class : GLOBAL
|
||||
4 | LOCAL
|
||||
|
||||
5 type : REAL
|
||||
6 | INTEGER
|
||||
|
||||
7 namelist : namelist NAME
|
||||
8 | NAME
|
||||
|
||||
9 locnamelist : namelist '(' LOCAL ',' type ')'
|
||||
|
||||
state 0
|
||||
$accept : . declaration $end (0)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
declaration goto 5
|
||||
class goto 6
|
||||
type goto 7
|
||||
|
||||
|
||||
state 1
|
||||
class : GLOBAL . (3)
|
||||
|
||||
. reduce 3
|
||||
|
||||
|
||||
state 2
|
||||
class : LOCAL . (4)
|
||||
|
||||
. reduce 4
|
||||
|
||||
|
||||
state 3
|
||||
type : REAL . (5)
|
||||
|
||||
. reduce 5
|
||||
|
||||
|
||||
state 4
|
||||
type : INTEGER . (6)
|
||||
|
||||
. reduce 6
|
||||
|
||||
|
||||
state 5
|
||||
$accept : declaration . $end (0)
|
||||
|
||||
$end accept
|
||||
|
||||
|
||||
state 6
|
||||
declaration : class . type namelist '(' class ',' type ')' (1)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 8
|
||||
|
||||
|
||||
state 7
|
||||
declaration : type . locnamelist '(' class ')' (2)
|
||||
|
||||
NAME shift 9
|
||||
. error
|
||||
|
||||
locnamelist goto 10
|
||||
namelist goto 11
|
||||
|
||||
|
||||
state 8
|
||||
declaration : class type . namelist '(' class ',' type ')' (1)
|
||||
|
||||
NAME shift 9
|
||||
. error
|
||||
|
||||
namelist goto 12
|
||||
|
||||
|
||||
state 9
|
||||
namelist : NAME . (8)
|
||||
|
||||
. reduce 8
|
||||
|
||||
|
||||
state 10
|
||||
declaration : type locnamelist . '(' class ')' (2)
|
||||
|
||||
'(' shift 13
|
||||
. error
|
||||
|
||||
|
||||
state 11
|
||||
namelist : namelist . NAME (7)
|
||||
locnamelist : namelist . '(' LOCAL ',' type ')' (9)
|
||||
|
||||
NAME shift 14
|
||||
'(' shift 15
|
||||
. error
|
||||
|
||||
|
||||
state 12
|
||||
declaration : class type namelist . '(' class ',' type ')' (1)
|
||||
namelist : namelist . NAME (7)
|
||||
|
||||
NAME shift 14
|
||||
'(' shift 16
|
||||
. error
|
||||
|
||||
|
||||
state 13
|
||||
declaration : type locnamelist '(' . class ')' (2)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
. error
|
||||
|
||||
class goto 17
|
||||
|
||||
|
||||
state 14
|
||||
namelist : namelist NAME . (7)
|
||||
|
||||
. reduce 7
|
||||
|
||||
|
||||
state 15
|
||||
locnamelist : namelist '(' . LOCAL ',' type ')' (9)
|
||||
|
||||
LOCAL shift 18
|
||||
. error
|
||||
|
||||
|
||||
state 16
|
||||
declaration : class type namelist '(' . class ',' type ')' (1)
|
||||
|
||||
GLOBAL shift 1
|
||||
LOCAL shift 2
|
||||
. error
|
||||
|
||||
class goto 19
|
||||
|
||||
|
||||
state 17
|
||||
declaration : type locnamelist '(' class . ')' (2)
|
||||
|
||||
')' shift 20
|
||||
. error
|
||||
|
||||
|
||||
state 18
|
||||
locnamelist : namelist '(' LOCAL . ',' type ')' (9)
|
||||
|
||||
',' shift 21
|
||||
. error
|
||||
|
||||
|
||||
state 19
|
||||
declaration : class type namelist '(' class . ',' type ')' (1)
|
||||
|
||||
',' shift 22
|
||||
. error
|
||||
|
||||
|
||||
state 20
|
||||
declaration : type locnamelist '(' class ')' . (2)
|
||||
|
||||
. reduce 2
|
||||
|
||||
|
||||
state 21
|
||||
locnamelist : namelist '(' LOCAL ',' . type ')' (9)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 23
|
||||
|
||||
|
||||
state 22
|
||||
declaration : class type namelist '(' class ',' . type ')' (1)
|
||||
|
||||
REAL shift 3
|
||||
INTEGER shift 4
|
||||
. error
|
||||
|
||||
type goto 24
|
||||
|
||||
|
||||
state 23
|
||||
locnamelist : namelist '(' LOCAL ',' type . ')' (9)
|
||||
|
||||
')' shift 25
|
||||
. error
|
||||
|
||||
|
||||
state 24
|
||||
declaration : class type namelist '(' class ',' type . ')' (1)
|
||||
|
||||
')' shift 26
|
||||
. error
|
||||
|
||||
|
||||
state 25
|
||||
locnamelist : namelist '(' LOCAL ',' type ')' . (9)
|
||||
|
||||
. reduce 9
|
||||
|
||||
|
||||
state 26
|
||||
declaration : class type namelist '(' class ',' type ')' . (1)
|
||||
|
||||
. reduce 1
|
||||
|
||||
|
||||
10 terminals, 6 nonterminals
|
||||
10 grammar rules, 27 states
|
||||
|
||||
grammar parser grammar
|
||||
symbol# value# symbol
|
||||
0 0 $end
|
||||
1 256 error
|
||||
2 257 GLOBAL
|
||||
3 258 LOCAL
|
||||
4 259 REAL
|
||||
5 260 INTEGER
|
||||
6 261 NAME
|
||||
7 40 '('
|
||||
8 44 ','
|
||||
9 41 ')'
|
||||
10 262 $accept
|
||||
11 263 declaration
|
||||
12 264 locnamelist
|
||||
13 265 class
|
||||
14 266 type
|
||||
15 267 namelist
|
1451
test/btyacc/btyacc_destroy3.tab.c
Normal file
1451
test/btyacc/btyacc_destroy3.tab.c
Normal file
File diff suppressed because it is too large
Load Diff
25
test/btyacc/btyacc_destroy3.tab.h
Normal file
25
test/btyacc/btyacc_destroy3.tab.h
Normal file
@ -0,0 +1,25 @@
|
||||
#ifndef _destroy3__defines_h_
|
||||
#define _destroy3__defines_h_
|
||||
|
||||
#define GLOBAL 257
|
||||
#define LOCAL 258
|
||||
#define REAL 259
|
||||
#define INTEGER 260
|
||||
#define NAME 261
|
||||
#ifdef YYSTYPE
|
||||
#undef YYSTYPE_IS_DECLARED
|
||||
#define YYSTYPE_IS_DECLARED 1
|
||||
#endif
|
||||
#ifndef YYSTYPE_IS_DECLARED
|
||||
#define YYSTYPE_IS_DECLARED 1
|
||||
typedef union
|
||||
{
|
||||
class cval;
|
||||
type tval;
|
||||
namelist * nlist;
|
||||
name id;
|
||||
} YYSTYPE;
|
||||
#endif /* !YYSTYPE_IS_DECLARED */
|
||||
extern YYSTYPE destroy3_lval;
|
||||
|
||||
#endif /* _destroy3__defines_h_ */
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -266,6 +266,32 @@ static const YYINT calc_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT calc_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -476,7 +502,7 @@ yylex(void)
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 480 "calc.tab.c"
|
||||
#line 506 "calc.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -485,11 +511,11 @@ yylex(void)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -673,8 +699,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -770,12 +796,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -830,7 +856,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -924,14 +950,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -940,12 +966,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -975,12 +1001,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1193,7 +1219,7 @@ case 18:
|
||||
#line 63 "calc.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1197 "calc.tab.c"
|
||||
#line 1223 "calc.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1244,8 +1270,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1348,12 +1374,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -310,6 +310,33 @@ static const YYINT calc1_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 259, 257,
|
||||
258, 259, 257, -1, 259,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT calc1_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 7
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -619,7 +646,7 @@ vdiv(double a, double b, INTERVAL v)
|
||||
{
|
||||
return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
|
||||
}
|
||||
#line 623 "calc1.tab.c"
|
||||
#line 650 "calc1.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -628,11 +655,11 @@ vdiv(double a, double b, INTERVAL v)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -816,8 +843,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -913,12 +940,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -973,7 +1000,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -1067,14 +1094,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -1083,12 +1110,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -1118,12 +1145,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1439,7 +1466,7 @@ case 28:
|
||||
yyval.vval = yystack.l_mark[-1].vval;
|
||||
}
|
||||
break;
|
||||
#line 1443 "calc1.tab.c"
|
||||
#line 1470 "calc1.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1490,8 +1517,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1594,12 +1621,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -146,7 +146,7 @@ typedef int YYSTYPE;
|
||||
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
|
||||
# endif
|
||||
#else
|
||||
# define YYPARSE_DECL() yyparse(int regs[26], int * base)
|
||||
# define YYPARSE_DECL() yyparse(int regs[26], int *base)
|
||||
#endif
|
||||
|
||||
/* Parameters sent to lex. */
|
||||
@ -154,13 +154,13 @@ typedef int YYSTYPE;
|
||||
# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
|
||||
# define YYLEX yylex(YYLEX_PARAM)
|
||||
#else
|
||||
# define YYLEX_DECL() yylex(int * base)
|
||||
# define YYLEX_DECL() yylex(int *base)
|
||||
# define YYLEX yylex(base)
|
||||
#endif
|
||||
|
||||
/* Parameters sent to yyerror. */
|
||||
#ifndef YYERROR_DECL
|
||||
#define YYERROR_DECL() yyerror(int regs[26], int * base, const char *s)
|
||||
#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
|
||||
#endif
|
||||
#ifndef YYERROR_CALL
|
||||
#define YYERROR_CALL(msg) yyerror(regs, base, msg)
|
||||
@ -268,6 +268,32 @@ static const YYINT calc2_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT calc2_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -489,7 +515,7 @@ YYLEX_DECL()
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 493 "calc2.tab.c"
|
||||
#line 519 "calc2.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -498,11 +524,11 @@ YYLEX_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -686,8 +712,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -783,12 +809,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -843,7 +869,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -937,14 +963,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -953,12 +979,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -988,12 +1014,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1206,7 +1232,7 @@ case 18:
|
||||
#line 70 "calc2.y"
|
||||
{ yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1210 "calc2.tab.c"
|
||||
#line 1236 "calc2.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1257,8 +1283,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1361,12 +1387,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -147,7 +147,7 @@ typedef int YYSTYPE;
|
||||
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
|
||||
# endif
|
||||
#else
|
||||
# define YYPARSE_DECL() yyparse(int regs[26], int * base)
|
||||
# define YYPARSE_DECL() yyparse(int regs[26], int *base)
|
||||
#endif
|
||||
|
||||
/* Parameters sent to lex. */
|
||||
@ -159,13 +159,13 @@ typedef int YYSTYPE;
|
||||
# endif
|
||||
# define YYLEX yylex(&yylval, YYLEX_PARAM)
|
||||
#else
|
||||
# define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
|
||||
# define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
|
||||
# define YYLEX yylex(&yylval, base)
|
||||
#endif
|
||||
|
||||
/* Parameters sent to yyerror. */
|
||||
#ifndef YYERROR_DECL
|
||||
#define YYERROR_DECL() yyerror(int regs[26], int * base, const char *s)
|
||||
#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
|
||||
#endif
|
||||
#ifndef YYERROR_CALL
|
||||
#define YYERROR_CALL(msg) yyerror(regs, base, msg)
|
||||
@ -273,6 +273,32 @@ static const YYINT calc3_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT calc3_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -444,7 +470,7 @@ YYLEX_DECL()
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 448 "calc3.tab.c"
|
||||
#line 474 "calc3.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -453,11 +479,11 @@ YYLEX_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -691,8 +717,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -788,12 +814,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -848,7 +874,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -942,14 +968,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -958,12 +984,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -993,12 +1019,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1211,7 +1237,7 @@ case 18:
|
||||
#line 73 "calc3.y"
|
||||
{ yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1215 "calc3.tab.c"
|
||||
#line 1241 "calc3.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1262,8 +1288,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1366,12 +1392,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -382,11 +382,11 @@ yylex(void)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -570,8 +570,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -667,12 +667,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -727,7 +727,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -821,14 +821,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -837,12 +837,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -872,12 +872,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1141,8 +1141,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1245,12 +1245,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -96,6 +96,32 @@ const YYINT calc_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
|
||||
};
|
||||
#if YYBTYACC
|
||||
const YYINT calc_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
#endif
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -354,11 +354,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -542,8 +542,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -639,12 +639,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -699,7 +699,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -793,14 +793,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -809,12 +809,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -844,12 +844,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1052,8 +1052,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1156,12 +1156,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -33,6 +33,10 @@ const YYINT error_table[] = { 1,
|
||||
};
|
||||
const YYINT error_check[] = { 256,
|
||||
};
|
||||
#if YYBTYACC
|
||||
const YYINT error_ctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
#endif
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -197,6 +197,10 @@ static const YYINT empty_table[] = { 0,
|
||||
};
|
||||
static const YYINT empty_check[] = { -1,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT empty_ctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -360,7 +364,7 @@ static void
|
||||
YYERROR_DECL() {
|
||||
printf("%s\n",s);
|
||||
}
|
||||
#line 364 "empty.tab.c"
|
||||
#line 368 "empty.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -369,11 +373,11 @@ YYERROR_DECL() {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -557,8 +561,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -654,12 +658,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -714,7 +718,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -808,14 +812,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -824,12 +828,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -859,12 +863,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1067,8 +1071,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1171,12 +1175,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -243,6 +243,11 @@ static const YYINT err_inherit3_check[] = { 257,
|
||||
258, 259, 260, 14, 259, 260, 17, 261, 261, 6,
|
||||
12,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT err_inherit3_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 5
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -411,7 +416,7 @@ static short *yylexemes = 0;
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
||||
#line 415 "err_inherit3.tab.c"
|
||||
#line 420 "err_inherit3.tab.c"
|
||||
|
||||
/* Release memory associated with symbol. */
|
||||
#if ! defined YYDESTRUCT_IS_DECLARED
|
||||
@ -431,7 +436,7 @@ YYDESTRUCT_DECL()
|
||||
}
|
||||
}
|
||||
break;
|
||||
#line 435 "err_inherit3.tab.c"
|
||||
#line 440 "err_inherit3.tab.c"
|
||||
case 264:
|
||||
#line 30 "err_inherit3.y"
|
||||
{
|
||||
@ -443,7 +448,7 @@ YYDESTRUCT_DECL()
|
||||
}
|
||||
}
|
||||
break;
|
||||
#line 447 "err_inherit3.tab.c"
|
||||
#line 452 "err_inherit3.tab.c"
|
||||
case 265:
|
||||
#line 30 "err_inherit3.y"
|
||||
{
|
||||
@ -455,7 +460,7 @@ YYDESTRUCT_DECL()
|
||||
}
|
||||
}
|
||||
break;
|
||||
#line 459 "err_inherit3.tab.c"
|
||||
#line 464 "err_inherit3.tab.c"
|
||||
}
|
||||
}
|
||||
#define YYDESTRUCT_IS_DECLARED 1
|
||||
@ -468,11 +473,11 @@ YYDESTRUCT_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -656,8 +661,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -753,12 +758,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -813,7 +818,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -907,14 +912,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -923,12 +928,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -958,12 +963,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1176,7 +1181,7 @@ case 14:
|
||||
#line 75 "err_inherit3.y"
|
||||
{ yyval.nlist = yystack.l_mark[0].nlist; }
|
||||
break;
|
||||
#line 1180 "err_inherit3.tab.c"
|
||||
#line 1185 "err_inherit3.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1227,8 +1232,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1331,12 +1336,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -263,6 +263,11 @@ static const YYINT err_inherit4_check[] = { 257,
|
||||
258, 259, 260, 259, 260, 0, 261, 261, 0, 14,
|
||||
6,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT err_inherit4_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 5
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -429,7 +434,7 @@ static short *yylexemes = 0;
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
||||
#line 433 "err_inherit4.tab.c"
|
||||
#line 438 "err_inherit4.tab.c"
|
||||
|
||||
/* Release memory associated with symbol. */
|
||||
#if ! defined YYDESTRUCT_IS_DECLARED
|
||||
@ -442,17 +447,17 @@ YYDESTRUCT_DECL()
|
||||
#line 28 "err_inherit4.y"
|
||||
{ }
|
||||
break;
|
||||
#line 446 "err_inherit4.tab.c"
|
||||
#line 451 "err_inherit4.tab.c"
|
||||
case 264:
|
||||
#line 28 "err_inherit4.y"
|
||||
{ }
|
||||
break;
|
||||
#line 451 "err_inherit4.tab.c"
|
||||
#line 456 "err_inherit4.tab.c"
|
||||
case 265:
|
||||
#line 28 "err_inherit4.y"
|
||||
{ }
|
||||
break;
|
||||
#line 456 "err_inherit4.tab.c"
|
||||
#line 461 "err_inherit4.tab.c"
|
||||
}
|
||||
}
|
||||
#define YYDESTRUCT_IS_DECLARED 1
|
||||
@ -465,11 +470,11 @@ YYDESTRUCT_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -653,8 +658,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -750,12 +755,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -810,7 +815,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -904,14 +909,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -920,12 +925,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -955,12 +960,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1165,7 +1170,7 @@ case 12:
|
||||
#line 77 "err_inherit4.y"
|
||||
{ yyval.nlist = yystack.l_mark[0].nlist; yyloc = yystack.p_mark[1]; }
|
||||
break;
|
||||
#line 1169 "err_inherit4.tab.c"
|
||||
#line 1174 "err_inherit4.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1216,8 +1221,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1320,12 +1325,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -187,6 +187,10 @@ static const YYINT err_syntax10_table[] = { 1,
|
||||
};
|
||||
static const YYINT err_syntax10_check[] = { 256,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT err_syntax10_ctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -359,7 +363,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 363 "err_syntax10.tab.c"
|
||||
#line 367 "err_syntax10.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -368,11 +372,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -556,8 +560,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -653,12 +657,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -713,7 +717,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -807,14 +811,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -823,12 +827,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -858,12 +862,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1066,8 +1070,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1170,12 +1174,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -193,6 +193,10 @@ static const YYINT err_syntax11_table[] = { 1,
|
||||
};
|
||||
static const YYINT err_syntax11_check[] = { 256,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT err_syntax11_ctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -365,7 +369,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 369 "err_syntax11.tab.c"
|
||||
#line 373 "err_syntax11.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -374,11 +378,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -562,8 +566,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -659,12 +663,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -719,7 +723,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -813,14 +817,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -829,12 +833,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -864,12 +868,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1072,8 +1076,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1176,12 +1180,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -194,6 +194,10 @@ static const YYINT err_syntax12_table[] = { 1,
|
||||
};
|
||||
static const YYINT err_syntax12_check[] = { 256,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT err_syntax12_ctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -371,7 +375,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 375 "err_syntax12.tab.c"
|
||||
#line 379 "err_syntax12.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -380,11 +384,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -568,8 +572,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -665,12 +669,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -725,7 +729,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -819,14 +823,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -835,12 +839,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -870,12 +874,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1078,8 +1082,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1182,12 +1186,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -195,6 +195,11 @@ static const YYINT err_syntax18_table[] = { 1,
|
||||
static const YYINT err_syntax18_check[] = { 40,
|
||||
-1, 41, 1,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT err_syntax18_ctable[] = { -1,
|
||||
-1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -367,7 +372,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 371 "err_syntax18.tab.c"
|
||||
#line 376 "err_syntax18.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -376,11 +381,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -564,8 +569,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -661,12 +666,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -721,7 +726,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -815,14 +820,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -831,12 +836,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -866,12 +871,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1028,7 +1033,7 @@ case 1:
|
||||
#line 9 "err_syntax18.y"
|
||||
{ yyval = yystack.l_mark[1]; }
|
||||
break;
|
||||
#line 1032 "err_syntax18.tab.c"
|
||||
#line 1037 "err_syntax18.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1079,8 +1084,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1183,12 +1188,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -190,6 +190,11 @@ static const YYINT err_syntax20_table[] = { 1,
|
||||
static const YYINT err_syntax20_check[] = { 40,
|
||||
257, 41,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT err_syntax20_ctable[] = { -1,
|
||||
-1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -362,7 +367,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 366 "err_syntax20.tab.c"
|
||||
#line 371 "err_syntax20.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -371,11 +376,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -559,8 +564,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -656,12 +661,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -716,7 +721,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -810,14 +815,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -826,12 +831,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -861,12 +866,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1023,7 +1028,7 @@ case 1:
|
||||
#line 12 "err_syntax20.y"
|
||||
{ yystack.l_mark[-1].rechk = 3; }
|
||||
break;
|
||||
#line 1027 "err_syntax20.tab.c"
|
||||
#line 1032 "err_syntax20.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1074,8 +1079,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1178,12 +1183,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -193,6 +193,10 @@ static const YYINT error_table[] = { 1,
|
||||
};
|
||||
static const YYINT error_check[] = { 256,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT error_ctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -364,7 +368,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 368 "error.tab.c"
|
||||
#line 372 "error.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -373,11 +377,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -561,8 +565,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -658,12 +662,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -718,7 +722,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -812,14 +816,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -828,12 +832,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -863,12 +867,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1071,8 +1075,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1175,12 +1179,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -794,6 +794,103 @@ static const YYINT grammar_check[] = { 38,
|
||||
269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
|
||||
279, 280, 281, 282,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT grammar_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 33
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -1244,7 +1341,7 @@ free_parser(void)
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#line 1248 "grammar.tab.c"
|
||||
#line 1345 "grammar.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -1253,11 +1350,11 @@ free_parser(void)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -1441,8 +1538,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -1538,12 +1635,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -1598,7 +1695,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -1692,14 +1789,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -1708,12 +1805,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -1743,12 +1840,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -2575,7 +2672,7 @@ case 114:
|
||||
yyval.declarator->func_def = FUNC_ANSI;
|
||||
}
|
||||
break;
|
||||
#line 2579 "grammar.tab.c"
|
||||
#line 2676 "grammar.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -2626,8 +2723,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -2730,12 +2827,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -217,6 +217,11 @@ static const YYINT inherit0_check[] = { 257,
|
||||
258, 259, 260, 259, 260, 0, 261, 261, 0, 6,
|
||||
13,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT inherit0_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 5
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -382,7 +387,7 @@ static short *yylexemes = 0;
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
||||
#line 386 "inherit0.tab.c"
|
||||
#line 391 "inherit0.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -391,11 +396,11 @@ extern void YYERROR_DECL();
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -579,8 +584,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -676,12 +681,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -736,7 +741,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -830,14 +835,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -846,12 +851,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -881,12 +886,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1083,7 +1088,7 @@ case 11:
|
||||
#line 43 "inherit0.y"
|
||||
{ yyval = yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1087 "inherit0.tab.c"
|
||||
#line 1092 "inherit0.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1134,8 +1139,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1238,12 +1243,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -238,6 +238,11 @@ static const YYINT inherit1_check[] = { 257,
|
||||
258, 259, 260, 259, 260, 0, 261, 261, 0, 13,
|
||||
6,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT inherit1_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 5
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -403,7 +408,7 @@ static short *yylexemes = 0;
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
||||
#line 407 "inherit1.tab.c"
|
||||
#line 412 "inherit1.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -412,11 +417,11 @@ extern void YYERROR_DECL();
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -600,8 +605,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -697,12 +702,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -757,7 +762,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -851,14 +856,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -867,12 +872,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -902,12 +907,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1108,7 +1113,7 @@ case 11:
|
||||
#line 71 "inherit1.y"
|
||||
{ yyval.nlist = yystack.l_mark[0].nlist; }
|
||||
break;
|
||||
#line 1112 "inherit1.tab.c"
|
||||
#line 1117 "inherit1.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1159,8 +1164,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1263,12 +1268,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -243,6 +243,12 @@ static const YYINT inherit2_check[] = { 257,
|
||||
258, 259, 260, 259, 260, 0, 261, 261, 0, 14,
|
||||
6, -1, 12,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT inherit2_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 5
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -410,7 +416,7 @@ static short *yylexemes = 0;
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
||||
#line 414 "inherit2.tab.c"
|
||||
#line 420 "inherit2.tab.c"
|
||||
|
||||
/* Release memory associated with symbol. */
|
||||
#if ! defined YYDESTRUCT_IS_DECLARED
|
||||
@ -430,7 +436,7 @@ YYDESTRUCT_DECL()
|
||||
}
|
||||
}
|
||||
break;
|
||||
#line 434 "inherit2.tab.c"
|
||||
#line 440 "inherit2.tab.c"
|
||||
case 264:
|
||||
#line 30 "inherit2.y"
|
||||
{
|
||||
@ -442,7 +448,7 @@ YYDESTRUCT_DECL()
|
||||
}
|
||||
}
|
||||
break;
|
||||
#line 446 "inherit2.tab.c"
|
||||
#line 452 "inherit2.tab.c"
|
||||
case 265:
|
||||
#line 30 "inherit2.y"
|
||||
{
|
||||
@ -454,7 +460,7 @@ YYDESTRUCT_DECL()
|
||||
}
|
||||
}
|
||||
break;
|
||||
#line 458 "inherit2.tab.c"
|
||||
#line 464 "inherit2.tab.c"
|
||||
}
|
||||
}
|
||||
#define YYDESTRUCT_IS_DECLARED 1
|
||||
@ -467,11 +473,11 @@ YYDESTRUCT_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -655,8 +661,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -752,12 +758,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -812,7 +818,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -906,14 +912,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -922,12 +928,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -957,12 +963,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1171,7 +1177,7 @@ case 13:
|
||||
#line 75 "inherit2.y"
|
||||
{ yyval.nlist = yystack.l_mark[0].nlist; }
|
||||
break;
|
||||
#line 1175 "inherit2.tab.c"
|
||||
#line 1181 "inherit2.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1222,8 +1228,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1326,12 +1332,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -155,7 +155,7 @@ typedef union
|
||||
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
|
||||
# endif
|
||||
#else
|
||||
# define YYPARSE_DECL() yyparse(int regs[26], int * base)
|
||||
# define YYPARSE_DECL() yyparse(int regs[26], int *base)
|
||||
#endif
|
||||
|
||||
/* Parameters sent to lex. */
|
||||
@ -167,13 +167,13 @@ typedef union
|
||||
# endif
|
||||
# define YYLEX yylex(&yylval, YYLEX_PARAM)
|
||||
#else
|
||||
# define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
|
||||
# define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
|
||||
# define YYLEX yylex(&yylval, base)
|
||||
#endif
|
||||
|
||||
/* Parameters sent to yyerror. */
|
||||
#ifndef YYERROR_DECL
|
||||
#define YYERROR_DECL() yyerror(int regs[26], int * base, const char *s)
|
||||
#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
|
||||
#endif
|
||||
#ifndef YYERROR_CALL
|
||||
#define YYERROR_CALL(msg) yyerror(regs, base, msg)
|
||||
@ -294,6 +294,32 @@ static const YYINT ok_syntax1_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT ok_syntax1_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -467,7 +493,7 @@ YYLEX_DECL()
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 471 "ok_syntax1.tab.c"
|
||||
#line 497 "ok_syntax1.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -476,11 +502,11 @@ YYLEX_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -714,8 +740,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -811,12 +837,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -871,7 +897,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -965,14 +991,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -981,12 +1007,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -1016,12 +1042,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1234,7 +1260,7 @@ case 18:
|
||||
#line 101 "ok_syntax1.y"
|
||||
{ yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
|
||||
break;
|
||||
#line 1238 "ok_syntax1.tab.c"
|
||||
#line 1264 "ok_syntax1.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1285,8 +1311,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1389,12 +1415,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -276,6 +276,32 @@ static const YYINT calc_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT calc_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -440,7 +466,7 @@ YYLEX_DECL()
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 444 "pure_calc.tab.c"
|
||||
#line 470 "pure_calc.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -449,11 +475,11 @@ YYLEX_DECL()
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -687,8 +713,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -784,12 +810,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -844,7 +870,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -938,14 +964,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -954,12 +980,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -989,12 +1015,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1207,7 +1233,7 @@ case 18:
|
||||
#line 69 "pure_calc.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1211 "pure_calc.tab.c"
|
||||
#line 1237 "pure_calc.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1258,8 +1284,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1362,12 +1388,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -205,6 +205,10 @@ static const YYINT error_table[] = { 1,
|
||||
};
|
||||
static const YYINT error_check[] = { 256,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT error_ctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -330,7 +334,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 334 "pure_error.tab.c"
|
||||
#line 338 "pure_error.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -339,11 +343,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -577,8 +581,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -674,12 +678,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -734,7 +738,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -828,14 +832,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -844,12 +848,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -879,12 +883,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1087,8 +1091,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1191,12 +1195,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -280,6 +280,36 @@ static const YYINT quote_calc_check[] = { 10,
|
||||
263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
|
||||
261, 261, 263, 263, 265, 265, 267, 267,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -490,7 +520,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 494 "quote_calc-s.tab.c"
|
||||
#line 524 "quote_calc-s.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -499,11 +529,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -687,8 +717,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -784,12 +814,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -844,7 +874,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -938,14 +968,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -954,12 +984,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -989,12 +1019,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1207,7 +1237,7 @@ case 18:
|
||||
#line 70 "quote_calc.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1211 "quote_calc-s.tab.c"
|
||||
#line 1241 "quote_calc-s.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1258,8 +1288,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1362,12 +1392,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -286,6 +286,36 @@ static const YYINT quote_calc_check[] = { 10,
|
||||
263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
|
||||
261, 261, 263, 263, 265, 265, 267, 267,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -496,7 +526,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 500 "quote_calc.tab.c"
|
||||
#line 530 "quote_calc.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -505,11 +535,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -693,8 +723,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -790,12 +820,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -850,7 +880,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -944,14 +974,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -960,12 +990,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -995,12 +1025,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1213,7 +1243,7 @@ case 18:
|
||||
#line 70 "quote_calc.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1217 "quote_calc.tab.c"
|
||||
#line 1247 "quote_calc.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1264,8 +1294,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1368,12 +1398,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -280,6 +280,36 @@ static const YYINT quote_calc2_check[] = { 10,
|
||||
264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
|
||||
260, 262, 262, 264, 264, 266, 266, 268, 268,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc2_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -490,7 +520,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 494 "quote_calc2-s.tab.c"
|
||||
#line 524 "quote_calc2-s.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -499,11 +529,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -687,8 +717,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -784,12 +814,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -844,7 +874,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -938,14 +968,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -954,12 +984,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -989,12 +1019,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1207,7 +1237,7 @@ case 18:
|
||||
#line 70 "quote_calc2.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1211 "quote_calc2-s.tab.c"
|
||||
#line 1241 "quote_calc2-s.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1258,8 +1288,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1362,12 +1392,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -286,6 +286,36 @@ static const YYINT quote_calc2_check[] = { 10,
|
||||
264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
|
||||
260, 262, 262, 264, 264, 266, 266, 268, 268,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc2_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -496,7 +526,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 500 "quote_calc2.tab.c"
|
||||
#line 530 "quote_calc2.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -505,11 +535,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -693,8 +723,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -790,12 +820,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -850,7 +880,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -944,14 +974,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -960,12 +990,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -995,12 +1025,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1213,7 +1243,7 @@ case 18:
|
||||
#line 70 "quote_calc2.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1217 "quote_calc2.tab.c"
|
||||
#line 1247 "quote_calc2.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1264,8 +1294,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1368,12 +1398,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -280,6 +280,36 @@ static const YYINT quote_calc3_check[] = { 10,
|
||||
263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
|
||||
261, 261, 263, 263, 265, 265, 267, 267,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc3_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -491,7 +521,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 495 "quote_calc3-s.tab.c"
|
||||
#line 525 "quote_calc3-s.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -500,11 +530,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -688,8 +718,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -785,12 +815,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -845,7 +875,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -939,14 +969,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -955,12 +985,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -990,12 +1020,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1208,7 +1238,7 @@ case 18:
|
||||
#line 70 "quote_calc3.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1212 "quote_calc3-s.tab.c"
|
||||
#line 1242 "quote_calc3-s.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1259,8 +1289,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1363,12 +1393,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -280,6 +280,36 @@ static const YYINT quote_calc3_check[] = { 10,
|
||||
263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
|
||||
261, 261, 263, 263, 265, 265, 267, 267,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc3_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -491,7 +521,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 495 "quote_calc3.tab.c"
|
||||
#line 525 "quote_calc3.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -500,11 +530,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -688,8 +718,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -785,12 +815,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -845,7 +875,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -939,14 +969,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -955,12 +985,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -990,12 +1020,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1208,7 +1238,7 @@ case 18:
|
||||
#line 70 "quote_calc3.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1212 "quote_calc3.tab.c"
|
||||
#line 1242 "quote_calc3.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1259,8 +1289,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1363,12 +1393,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -280,6 +280,36 @@ static const YYINT quote_calc4_check[] = { 10,
|
||||
264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
|
||||
260, 262, 262, 264, 264, 266, 266, 268, 268,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc4_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -491,7 +521,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 495 "quote_calc4-s.tab.c"
|
||||
#line 525 "quote_calc4-s.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -500,11 +530,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -688,8 +718,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -785,12 +815,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -845,7 +875,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -939,14 +969,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -955,12 +985,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -990,12 +1020,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1208,7 +1238,7 @@ case 18:
|
||||
#line 70 "quote_calc4.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1212 "quote_calc4-s.tab.c"
|
||||
#line 1242 "quote_calc4-s.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1259,8 +1289,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1363,12 +1393,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -280,6 +280,36 @@ static const YYINT quote_calc4_check[] = { 10,
|
||||
264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
|
||||
260, 262, 262, 264, 264, 266, 266, 268, 268,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT quote_calc4_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 1
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -491,7 +521,7 @@ yylex(void) {
|
||||
}
|
||||
return( c );
|
||||
}
|
||||
#line 495 "quote_calc4.tab.c"
|
||||
#line 525 "quote_calc4.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -500,11 +530,11 @@ yylex(void) {
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -688,8 +718,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -785,12 +815,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -845,7 +875,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -939,14 +969,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -955,12 +985,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -990,12 +1020,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1208,7 +1238,7 @@ case 18:
|
||||
#line 70 "quote_calc4.y"
|
||||
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
|
||||
break;
|
||||
#line 1212 "quote_calc4.tab.c"
|
||||
#line 1242 "quote_calc4.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1259,8 +1289,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1363,12 +1393,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -52,6 +52,10 @@ static const YYINT yytable[] = { 1,
|
||||
};
|
||||
static const YYINT yycheck[] = { 256,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT yyctable[] = { -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 2
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 1
|
||||
@ -227,7 +231,7 @@ yyerror(const char* s)
|
||||
{
|
||||
printf("%s\n", s);
|
||||
}
|
||||
#line 232 "rename_debug.c"
|
||||
#line 236 "rename_debug.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -236,11 +240,11 @@ yyerror(const char* s)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -424,8 +428,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -521,12 +525,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -581,7 +585,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -675,14 +679,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -691,12 +695,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -726,12 +730,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -934,8 +938,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1038,12 +1042,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/* original parser id follows */
|
||||
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
|
||||
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
|
||||
|
||||
#define YYBYACC 1
|
||||
#define YYMAJOR 1
|
||||
@ -311,6 +311,33 @@ static const YYINT varsyntax_calc1_check[] = { 40,
|
||||
-1, -1, -1, -1, -1, 256, 257, 258, 259, 257,
|
||||
258, 259, 257, -1, 259,
|
||||
};
|
||||
#if YYBTYACC
|
||||
static const YYINT varsyntax_calc1_ctable[] = { -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1,
|
||||
};
|
||||
#endif
|
||||
#define YYFINAL 7
|
||||
#ifndef YYDEBUG
|
||||
#define YYDEBUG 0
|
||||
@ -620,7 +647,7 @@ vdiv(double a, double b, INTERVAL v)
|
||||
{
|
||||
return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
|
||||
}
|
||||
#line 624 "varsyntax_calc1.tab.c"
|
||||
#line 651 "varsyntax_calc1.tab.c"
|
||||
|
||||
/* For use in generated program */
|
||||
#define yydepth (int)(yystack.s_mark - yystack.s_base)
|
||||
@ -629,11 +656,11 @@ vdiv(double a, double b, INTERVAL v)
|
||||
#endif /* YYBTYACC */
|
||||
|
||||
#if YYDEBUG
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#include <stdio.h> /* needed for printf */
|
||||
#endif
|
||||
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
#include <stdlib.h> /* needed for malloc, etc */
|
||||
#include <string.h> /* needed for memset */
|
||||
|
||||
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
|
||||
static int yygrowstack(YYSTACKDATA *data)
|
||||
@ -817,8 +844,8 @@ YYPARSE_DECL()
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
|
||||
@ -914,12 +941,12 @@ YYPARSE_DECL()
|
||||
save->state = yystate;
|
||||
save->errflag = yyerrflag;
|
||||
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = yytable[yyn];
|
||||
if (yyctable[ctry] == -1)
|
||||
@ -974,7 +1001,7 @@ YYPARSE_DECL()
|
||||
yylexp--;
|
||||
yychar = YYEMPTY;
|
||||
}
|
||||
save->lexeme = yylvp - yylvals;
|
||||
save->lexeme = (int) (yylvp - yylvals);
|
||||
yyps->save = save;
|
||||
}
|
||||
if (yytable[yyn] == ctry)
|
||||
@ -1068,14 +1095,14 @@ YYPARSE_DECL()
|
||||
yyerrctx->state = yystate;
|
||||
yyerrctx->errflag = yyerrflag;
|
||||
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yyerrctx->lexeme = yylvp - yylvals;
|
||||
yyerrctx->lexeme = (int) (yylvp - yylvals);
|
||||
}
|
||||
yylvp = yylvals + save->lexeme;
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
@ -1084,12 +1111,12 @@ YYPARSE_DECL()
|
||||
yylexp = yylexemes + save->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
ctry = ++save->ctry;
|
||||
yystate = save->state;
|
||||
@ -1119,12 +1146,12 @@ YYPARSE_DECL()
|
||||
yylloc = yylpp[-1];
|
||||
#endif
|
||||
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yyerrctx->state;
|
||||
yyFreeState(yyerrctx);
|
||||
@ -1440,7 +1467,7 @@ case 28:
|
||||
yyval.vval = yystack.l_mark[-1].vval;
|
||||
}
|
||||
break;
|
||||
#line 1444 "varsyntax_calc1.tab.c"
|
||||
#line 1471 "varsyntax_calc1.tab.c"
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1491,8 +1518,8 @@ break;
|
||||
/* in trial mode; save scanner results for future parse attempts */
|
||||
if (yylvp == yylvlim)
|
||||
{ /* Enlarge lexical value queue */
|
||||
int p = yylvp - yylvals;
|
||||
int s = yylvlim - yylvals;
|
||||
size_t p = (size_t) (yylvp - yylvals);
|
||||
size_t s = (size_t) (yylvlim - yylvals);
|
||||
|
||||
s += YYLVQUEUEGROWTH;
|
||||
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
|
||||
@ -1595,12 +1622,12 @@ break;
|
||||
yylexp = yylexemes + yypath->lexeme;
|
||||
yychar = YYEMPTY;
|
||||
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
|
||||
yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
|
||||
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
|
||||
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
|
||||
#endif
|
||||
yystate = yypath->state;
|
||||
goto yyloop;
|
||||
|
91
test/btyacc_destroy1.y
Normal file
91
test/btyacc_destroy1.y
Normal file
@ -0,0 +1,91 @@
|
||||
%parse-param { struct parser_param *param , int flag }
|
||||
|
||||
%{
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef enum {cGLOBAL, cLOCAL} class;
|
||||
typedef enum {tREAL, tINTEGER} type;
|
||||
typedef char * name;
|
||||
|
||||
struct symbol { class c; type t; name id; };
|
||||
typedef struct symbol symbol;
|
||||
|
||||
struct namelist { symbol *s; struct namelist *next; };
|
||||
typedef struct namelist namelist;
|
||||
|
||||
struct parser_param {
|
||||
int *rtrn;
|
||||
symbol ss;
|
||||
};
|
||||
|
||||
extern symbol *mksymbol(type t, class c, name id);
|
||||
|
||||
#ifdef YYBISON
|
||||
#define YYLEX_DECL() yylex(void)
|
||||
#define YYERROR_DECL() yyerror(const char *s)
|
||||
#endif
|
||||
%}
|
||||
|
||||
%token <cval> GLOBAL LOCAL
|
||||
%token <tval> REAL INTEGER
|
||||
%token <id> NAME
|
||||
|
||||
%type <nlist> declaration
|
||||
%type <nlist> locnamelist
|
||||
%type <cval> class
|
||||
%type <tval> type
|
||||
%type <nlist> namelist
|
||||
|
||||
%destructor { if (!param->rtrn) close($$); } <file>
|
||||
|
||||
%destructor {
|
||||
namelist *p = $$;
|
||||
while (p != NULL)
|
||||
{ namelist *pp = p;
|
||||
p = p->next;
|
||||
free(pp->s); free(pp);
|
||||
}
|
||||
} declaration
|
||||
|
||||
%union
|
||||
{
|
||||
class cval;
|
||||
type tval;
|
||||
namelist * nlist;
|
||||
name id;
|
||||
}
|
||||
|
||||
%start declaration
|
||||
|
||||
%%
|
||||
declaration: class type namelist'(' class ',' type ')'
|
||||
{ $$ = $3; }
|
||||
| type locnamelist '(' class ')'
|
||||
{ $$ = $2; }
|
||||
;
|
||||
|
||||
class : GLOBAL { $$ = cGLOBAL; }
|
||||
| LOCAL { $$ = cLOCAL; }
|
||||
;
|
||||
|
||||
type : REAL { $$ = tREAL; }
|
||||
| INTEGER { $$ = tINTEGER; }
|
||||
;
|
||||
|
||||
namelist: namelist NAME
|
||||
{ $$->s = mksymbol($<tval>0, $<cval>0, $2);
|
||||
$$->next = $1;
|
||||
}
|
||||
| NAME
|
||||
{ $$->s = mksymbol(0, 0, $1);
|
||||
$$->next = NULL;
|
||||
}
|
||||
;
|
||||
|
||||
locnamelist: namelist '(' LOCAL ',' type ')'
|
||||
{ $$ = $1; }
|
||||
;
|
||||
%%
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
91
test/btyacc_destroy2.y
Normal file
91
test/btyacc_destroy2.y
Normal file
@ -0,0 +1,91 @@
|
||||
%parse-param { struct parser_param *param } { int flag }
|
||||
|
||||
%{
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef enum {cGLOBAL, cLOCAL} class;
|
||||
typedef enum {tREAL, tINTEGER} type;
|
||||
typedef char * name;
|
||||
|
||||
struct symbol { class c; type t; name id; };
|
||||
typedef struct symbol symbol;
|
||||
|
||||
struct namelist { symbol *s; struct namelist *next; };
|
||||
typedef struct namelist namelist;
|
||||
|
||||
struct parser_param {
|
||||
int *rtrn;
|
||||
symbol ss;
|
||||
};
|
||||
|
||||
extern symbol *mksymbol(type t, class c, name id);
|
||||
|
||||
#ifdef YYBISON
|
||||
#define YYLEX_DECL() yylex(void)
|
||||
#define YYERROR_DECL() yyerror(const char *s)
|
||||
#endif
|
||||
%}
|
||||
|
||||
%token <cval> GLOBAL LOCAL
|
||||
%token <tval> REAL INTEGER
|
||||
%token <id> NAME
|
||||
|
||||
%type <nlist> declaration
|
||||
%type <nlist> locnamelist
|
||||
%type <cval> class
|
||||
%type <tval> type
|
||||
%type <nlist> namelist
|
||||
|
||||
%destructor { if (!param->rtrn) close($$); } <file>
|
||||
|
||||
%destructor {
|
||||
namelist *p = $$;
|
||||
while (p != NULL)
|
||||
{ namelist *pp = p;
|
||||
p = p->next;
|
||||
free(pp->s); free(pp);
|
||||
}
|
||||
} declaration
|
||||
|
||||
%union
|
||||
{
|
||||
class cval;
|
||||
type tval;
|
||||
namelist * nlist;
|
||||
name id;
|
||||
}
|
||||
|
||||
%start declaration
|
||||
|
||||
%%
|
||||
declaration: class type namelist'(' class ',' type ')'
|
||||
{ $$ = $3; }
|
||||
| type locnamelist '(' class ')'
|
||||
{ $$ = $2; }
|
||||
;
|
||||
|
||||
class : GLOBAL { $$ = cGLOBAL; }
|
||||
| LOCAL { $$ = cLOCAL; }
|
||||
;
|
||||
|
||||
type : REAL { $$ = tREAL; }
|
||||
| INTEGER { $$ = tINTEGER; }
|
||||
;
|
||||
|
||||
namelist: namelist NAME
|
||||
{ $$->s = mksymbol($<tval>0, $<cval>0, $2);
|
||||
$$->next = $1;
|
||||
}
|
||||
| NAME
|
||||
{ $$->s = mksymbol(0, 0, $1);
|
||||
$$->next = NULL;
|
||||
}
|
||||
;
|
||||
|
||||
locnamelist: namelist '(' LOCAL ',' type ')'
|
||||
{ $$ = $1; }
|
||||
;
|
||||
%%
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
94
test/btyacc_destroy3.y
Normal file
94
test/btyacc_destroy3.y
Normal file
@ -0,0 +1,94 @@
|
||||
%parse-param {
|
||||
struct parser_param *param,
|
||||
int flag
|
||||
}
|
||||
|
||||
%{
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef enum {cGLOBAL, cLOCAL} class;
|
||||
typedef enum {tREAL, tINTEGER} type;
|
||||
typedef char * name;
|
||||
|
||||
struct symbol { class c; type t; name id; };
|
||||
typedef struct symbol symbol;
|
||||
|
||||
struct namelist { symbol *s; struct namelist *next; };
|
||||
typedef struct namelist namelist;
|
||||
|
||||
struct parser_param {
|
||||
int *rtrn;
|
||||
symbol ss;
|
||||
};
|
||||
|
||||
extern symbol *mksymbol(type t, class c, name id);
|
||||
|
||||
#ifdef YYBISON
|
||||
#define YYLEX_DECL() yylex(void)
|
||||
#define YYERROR_DECL() yyerror(const char *s)
|
||||
#endif
|
||||
%}
|
||||
|
||||
%token <cval> GLOBAL LOCAL
|
||||
%token <tval> REAL INTEGER
|
||||
%token <id> NAME
|
||||
|
||||
%type <nlist> declaration
|
||||
%type <nlist> locnamelist
|
||||
%type <cval> class
|
||||
%type <tval> type
|
||||
%type <nlist> namelist
|
||||
|
||||
%destructor { if (!param->rtrn) close($$); } <file>
|
||||
|
||||
%destructor {
|
||||
namelist *p = $$;
|
||||
while (p != NULL)
|
||||
{ namelist *pp = p;
|
||||
p = p->next;
|
||||
free(pp->s); free(pp);
|
||||
}
|
||||
} declaration
|
||||
|
||||
%union
|
||||
{
|
||||
class cval;
|
||||
type tval;
|
||||
namelist * nlist;
|
||||
name id;
|
||||
}
|
||||
|
||||
%start declaration
|
||||
|
||||
%%
|
||||
declaration: class type namelist'(' class ',' type ')'
|
||||
{ $$ = $3; }
|
||||
| type locnamelist '(' class ')'
|
||||
{ $$ = $2; }
|
||||
;
|
||||
|
||||
class : GLOBAL { $$ = cGLOBAL; }
|
||||
| LOCAL { $$ = cLOCAL; }
|
||||
;
|
||||
|
||||
type : REAL { $$ = tREAL; }
|
||||
| INTEGER { $$ = tINTEGER; }
|
||||
;
|
||||
|
||||
namelist: namelist NAME
|
||||
{ $$->s = mksymbol($<tval>0, $<cval>0, $2);
|
||||
$$->next = $1;
|
||||
}
|
||||
| NAME
|
||||
{ $$->s = mksymbol(0, 0, $1);
|
||||
$$->next = NULL;
|
||||
}
|
||||
;
|
||||
|
||||
locnamelist: namelist '(' LOCAL ',' type ')'
|
||||
{ $$ = $1; }
|
||||
;
|
||||
%%
|
||||
|
||||
extern int YYLEX_DECL();
|
||||
extern void YYERROR_DECL();
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user