d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Sync to HEAD@r272825.

Browse Source
This commit is contained in:
Alexander V. Chernikov 2014-10-09 15:35:28 +00:00
commit 779b53d008
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/projects/ipfw/; revision=272826
289 changed files with 22271 additions and 10591 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Makefile.inc1
View File

@ -299,6 +299,10 @@ HMAKE+= PATH=${TMPPATH} METALOG=${METALOG} -DNO_ROOT
WMAKEENV+= MK_CTF=no WMAKEENV+= MK_CTF=no
.endif .endif
.if defined(CROSS_TOOLCHAIN)
LOCALBASE?= /usr/local
.include "${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk"
.endif
.if defined(CROSS_TOOLCHAIN_PREFIX) .if defined(CROSS_TOOLCHAIN_PREFIX)
CROSS_COMPILER_PREFIX?=${CROSS_TOOLCHAIN_PREFIX} CROSS_COMPILER_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
CROSS_BINUTILS_PREFIX?=${CROSS_TOOLCHAIN_PREFIX} CROSS_BINUTILS_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
@ -311,7 +315,7 @@ X${COMPILER}?= ${CROSS_COMPILER_PREFIX}${${COMPILER}}
X${COMPILER}?= ${${COMPILER}} X${COMPILER}?= ${${COMPILER}}
.endif .endif
.endfor .endfor
XBINUTILS= AS AR LD NM OBJDUMP RANLIB STRINGS XBINUTILS= AS AR LD NM OBJCOPY OBJDUMP RANLIB STRINGS
.for BINUTIL in ${XBINUTILS} .for BINUTIL in ${XBINUTILS}
.if defined(CROSS_BINUTILS_PREFIX) .if defined(CROSS_BINUTILS_PREFIX)
X${BINUTIL}?= ${CROSS_BINUTILS_PREFIX}${${BINUTIL}} X${BINUTIL}?= ${CROSS_BINUTILS_PREFIX}${${BINUTIL}}
@ -322,7 +326,8 @@ X${BINUTIL}?= ${${BINUTIL}}
WMAKEENV+= CC="${XCC} ${XFLAGS}" CXX="${XCXX} ${XFLAGS}" \ WMAKEENV+= CC="${XCC} ${XFLAGS}" CXX="${XCXX} ${XFLAGS}" \
CPP="${XCPP} ${XFLAGS}" \ CPP="${XCPP} ${XFLAGS}" \
AS="${XAS}" AR="${XAR}" LD="${XLD}" NM=${XNM} \ AS="${XAS}" AR="${XAR}" LD="${XLD}" NM=${XNM} \
OBJDUMP=${XOBJDUMP} RANLIB=${XRANLIB} STRINGS=${XSTRINGS} OBJDUMP=${XOBJDUMP} OBJCOPY="${XOBJCOPY}" \
RANLIB=${XRANLIB} STRINGS=${XSTRINGS}
.if ${XCC:M/*} .if ${XCC:M/*}
XFLAGS= --sysroot=${WORLDTMP} XFLAGS= --sysroot=${WORLDTMP}
@ -343,10 +348,14 @@ TARGET_ABI= gnueabihf
TARGET_ABI= gnueabi TARGET_ABI= gnueabi
.endif .endif
.endif .endif
.if defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc
XFLAGS+= -isystem ${WORLDTMP}/usr/include -L${WORLDTMP}/usr/lib
.else
TARGET_ABI?= unknown TARGET_ABI?= unknown
TARGET_TRIPLE?= ${TARGET_ARCH:C/amd64/x86_64/}-${TARGET_ABI}-freebsd11.0 TARGET_TRIPLE?= ${TARGET_ARCH:C/amd64/x86_64/}-${TARGET_ABI}-freebsd11.0
XFLAGS+= -target ${TARGET_TRIPLE} XFLAGS+= -target ${TARGET_TRIPLE}
.endif .endif
.endif
WMAKE= ${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 DESTDIR=${WORLDTMP} WMAKE= ${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 DESTDIR=${WORLDTMP}

6
bin/sleep/Makefile
View File

@ -1,6 +1,12 @@
# @(#)Makefile 8.1 (Berkeley) 5/31/93 # @(#)Makefile 8.1 (Berkeley) 5/31/93
# $FreeBSD$ # $FreeBSD$
.include <src.opts.mk>
PROG= sleep PROG= sleep
.if ${MK_TESTS} != "no"
SUBDIR+= tests
.endif
.include <bsd.prog.mk> .include <bsd.prog.mk>

12
bin/sleep/tests/Makefile Normal file
View File

@ -0,0 +1,12 @@
# $FreeBSD$
TESTSRC= ${.CURDIR}/../../../contrib/netbsd-tests/bin/sleep
.PATH: ${TESTSRC}
.include <bsd.own.mk>
TESTSDIR= ${TESTSBASE}/bin/sleep
ATF_TESTS_SH= sleep_test
ATF_TESTS_SH_SRC_sleep_test= t_sleep.sh
.include <bsd.test.mk>

26
cddl/contrib/opensolaris/cmd/zdb/zdb.c
View File

@ -76,8 +76,10 @@
#ifndef lint #ifndef lint
extern boolean_t zfs_recover; extern boolean_t zfs_recover;
extern uint64_t zfs_arc_max, zfs_arc_meta_limit;
#else #else
boolean_t zfs_recover; boolean_t zfs_recover;
uint64_t zfs_arc_max, zfs_arc_meta_limit;
#endif #endif
const char cmdname[] = "zdb"; const char cmdname[] = "zdb";
@ -89,7 +91,7 @@ extern void dump_intent_log(zilog_t *);
uint64_t *zopt_object = NULL; uint64_t *zopt_object = NULL;
int zopt_objects = 0; int zopt_objects = 0;
libzfs_handle_t *g_zfs; libzfs_handle_t *g_zfs;
uint64_t max_inflight = 200; uint64_t max_inflight = 1000;
/* /*
* These libumem hooks provide a reasonable set of defaults for the allocator's * These libumem hooks provide a reasonable set of defaults for the allocator's
@ -2382,7 +2384,7 @@ zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
zcb->zcb_readfails = 0; zcb->zcb_readfails = 0;
if (dump_opt['b'] < 5 && isatty(STDERR_FILENO) && if (dump_opt['b'] < 5 &&
gethrtime() > zcb->zcb_lastprint + NANOSEC) { gethrtime() > zcb->zcb_lastprint + NANOSEC) {
uint64_t now = gethrtime(); uint64_t now = gethrtime();
char buf[10]; char buf[10];
@ -2467,9 +2469,9 @@ zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
if (!dump_opt['L']) { if (!dump_opt['L']) {
vdev_t *rvd = spa->spa_root_vdev; vdev_t *rvd = spa->spa_root_vdev;
for (int c = 0; c < rvd->vdev_children; c++) { for (uint64_t c = 0; c < rvd->vdev_children; c++) {
vdev_t *vd = rvd->vdev_child[c]; vdev_t *vd = rvd->vdev_child[c];
for (int m = 0; m < vd->vdev_ms_count; m++) { for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
metaslab_t *msp = vd->vdev_ms[m]; metaslab_t *msp = vd->vdev_ms[m];
mutex_enter(&msp->ms_lock); mutex_enter(&msp->ms_lock);
metaslab_unload(msp); metaslab_unload(msp);
@ -2482,6 +2484,15 @@ zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
* interfaces. * interfaces.
*/ */
if (msp->ms_sm != NULL) { if (msp->ms_sm != NULL) {
(void) fprintf(stderr,
"\rloading space map for "
"vdev %llu of %llu, "
"metaslab %llu of %llu ...",
(longlong_t)c,
(longlong_t)rvd->vdev_children,
(longlong_t)m,
(longlong_t)vd->vdev_ms_count);
msp->ms_ops = &zdb_metaslab_ops; msp->ms_ops = &zdb_metaslab_ops;
VERIFY0(space_map_load(msp->ms_sm, VERIFY0(space_map_load(msp->ms_sm,
msp->ms_tree, SM_ALLOC)); msp->ms_tree, SM_ALLOC));
@ -2490,6 +2501,7 @@ zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
mutex_exit(&msp->ms_lock); mutex_exit(&msp->ms_lock);
} }
} }
(void) fprintf(stderr, "\n");
} }
spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
@ -3490,6 +3502,12 @@ main(int argc, char **argv)
usage(); usage();
} }
/*
* ZDB does not typically re-read blocks; therefore limit the ARC
* to 256 MB, which can be used entirely for metadata.
*/
zfs_arc_max = zfs_arc_meta_limit = 256 * 1024 * 1024;
kernel_init(FREAD); kernel_init(FREAD);
g_zfs = libzfs_init(); g_zfs = libzfs_init();
ASSERT(g_zfs != NULL); ASSERT(g_zfs != NULL);

23
cddl/contrib/opensolaris/lib/libdtrace/common/dt_grammar.y
View File

@ -207,6 +207,8 @@
%type <l_tok> unary_operator %type <l_tok> unary_operator
%type <l_tok> struct_or_union %type <l_tok> struct_or_union
%type <l_str> dtrace_keyword_ident
%% %%
dtrace_program: d_expression DT_TOK_EOF { return (dt_node_root($1)); } dtrace_program: d_expression DT_TOK_EOF { return (dt_node_root($1)); }
@ -391,12 +393,18 @@ postfix_expression:
| postfix_expression DT_TOK_DOT DT_TOK_TNAME { | postfix_expression DT_TOK_DOT DT_TOK_TNAME {
$$ = OP2(DT_TOK_DOT, $1, dt_node_ident($3)); $$ = OP2(DT_TOK_DOT, $1, dt_node_ident($3));
} }
| postfix_expression DT_TOK_DOT dtrace_keyword_ident {
$$ = OP2(DT_TOK_DOT, $1, dt_node_ident($3));
}
| postfix_expression DT_TOK_PTR DT_TOK_IDENT { | postfix_expression DT_TOK_PTR DT_TOK_IDENT {
$$ = OP2(DT_TOK_PTR, $1, dt_node_ident($3)); $$ = OP2(DT_TOK_PTR, $1, dt_node_ident($3));
} }
| postfix_expression DT_TOK_PTR DT_TOK_TNAME { | postfix_expression DT_TOK_PTR DT_TOK_TNAME {
$$ = OP2(DT_TOK_PTR, $1, dt_node_ident($3)); $$ = OP2(DT_TOK_PTR, $1, dt_node_ident($3));
} }
| postfix_expression DT_TOK_PTR dtrace_keyword_ident {
$$ = OP2(DT_TOK_PTR, $1, dt_node_ident($3));
}
| postfix_expression DT_TOK_ADDADD { | postfix_expression DT_TOK_ADDADD {
$$ = OP1(DT_TOK_POSTINC, $1); $$ = OP1(DT_TOK_POSTINC, $1);
} }
@ -411,6 +419,10 @@ postfix_expression:
DT_TOK_TNAME DT_TOK_RPAR { DT_TOK_TNAME DT_TOK_RPAR {
$$ = dt_node_offsetof($3, $5); $$ = dt_node_offsetof($3, $5);
} }
| DT_TOK_OFFSETOF DT_TOK_LPAR type_name DT_TOK_COMMA
dtrace_keyword_ident DT_TOK_RPAR {
$$ = dt_node_offsetof($3, $5);
}
| DT_TOK_XLATE DT_TOK_LT type_name DT_TOK_GT | DT_TOK_XLATE DT_TOK_LT type_name DT_TOK_GT
DT_TOK_LPAR expression DT_TOK_RPAR { DT_TOK_LPAR expression DT_TOK_RPAR {
$$ = OP2(DT_TOK_XLATE, dt_node_type($3), $6); $$ = OP2(DT_TOK_XLATE, dt_node_type($3), $6);
@ -835,4 +847,15 @@ function_parameters:
| parameter_type_list { $$ = $1; } | parameter_type_list { $$ = $1; }
; ;
dtrace_keyword_ident:
DT_KEY_PROBE { $$ = DUP("probe"); }
| DT_KEY_PROVIDER { $$ = DUP("provider"); }
| DT_KEY_SELF { $$ = DUP("self"); }
| DT_KEY_STRING { $$ = DUP("string"); }
| DT_TOK_STRINGOF { $$ = DUP("stringof"); }
| DT_KEY_USERLAND { $$ = DUP("userland"); }
| DT_TOK_XLATE { $$ = DUP("xlate"); }
| DT_KEY_XLATOR { $$ = DUP("translator"); }
;
%% %%

142
contrib/byacc/CHANGES
View File

@ -1,3 +1,145 @@
2014-10-06 Thomas E. Dickey <tom@invisible-island.net>
* package/debian/source/format:
change to native format to work around regression in Debian packaging.
* VERSION, package/byacc.spec, package/debian/changelog, package/mingw-byacc.spec, package/pkgsrc/Makefile:
bump
* configure: regen
* main.c:
correct parameter for umask - for very old mkstemp's - and use type mode_t
to quiet compiler warning
* configure.in: add configure check for mode_t
* reader.c:
better fix for get_line, by ensuring there is enough space to null-terminate
its result (prompted by discussion with Craig Rodrigues).
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> 2014-07-15 Thomas E. Dickey <tom@invisible-island.net>
* aclocal.m4: resync with my-autoconf (no change to configure script) * aclocal.m4: resync with my-autoconf (no change to configure script)

2
contrib/byacc/MANIFEST
View File

@ -1,4 +1,4 @@
MANIFEST for byacc-20140715, version t20140715 MANIFEST for byacc-20141006, version t20141006
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
MANIFEST this file MANIFEST this file
ACKNOWLEDGEMENTS original version of byacc - 1993 ACKNOWLEDGEMENTS original version of byacc - 1993

2
contrib/byacc/VERSION
View File

@ -1 +1 @@
20140715 20141006

19
contrib/byacc/aclocal.m4 vendored
View File

@ -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 Macros for byacc configure script (Thomas E. Dickey)
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
dnl Copyright 2004-2013,2014 Thomas E. Dickey dnl Copyright 2004-2013,2014 Thomas E. Dickey
@ -54,7 +54,7 @@ define([CF_ACVERSION_COMPARE],
[ifelse([$8], , ,[$8])], [ifelse([$8], , ,[$8])],
[ifelse([$9], , ,[$9])])])dnl [ifelse([$9], , ,[$9])])])dnl
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 -------------
dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
dnl The second parameter if given makes this macro verbose. dnl The second parameter if given makes this macro verbose.
@ -79,7 +79,7 @@ no)
-D*) -D*)
cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-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}" \ && test -z "${cf_tst_cflags}" \
&& cf_fix_cppflags=yes && cf_fix_cppflags=yes
@ -116,7 +116,7 @@ yes)
cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'` 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}" \ && test -z "${cf_tst_cflags}" \
&& cf_fix_cppflags=no && cf_fix_cppflags=no
;; ;;
@ -1085,7 +1085,7 @@ fi
fi fi
])dnl ])dnl
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 ---------------
dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions, 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, 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 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
CF_GNU_SOURCE CF_GNU_SOURCE
;; ;;
minix*) #(vi
cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
;;
mirbsd*) #(vi mirbsd*) #(vi
# setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
cf_XOPEN_SOURCE= cf_XOPEN_SOURCE=
@ -1165,6 +1168,10 @@ solaris2.*) #(vi
cf_xopen_source="-D__EXTENSIONS__" cf_xopen_source="-D__EXTENSIONS__"
cf_cv_xopen_source=broken 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_TRY_XOPEN_SOURCE
CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
@ -1172,7 +1179,7 @@ solaris2.*) #(vi
esac esac
if test -n "$cf_xopen_source" ; then if test -n "$cf_xopen_source" ; then
CF_ADD_CFLAGS($cf_xopen_source) CF_ADD_CFLAGS($cf_xopen_source,true)
fi fi
dnl In anything but the default case, we may have system-specific setting dnl In anything but the default case, we may have system-specific setting

106
contrib/byacc/btyaccpar.c
View File

@ -18,7 +18,7 @@ const char *const banner[] =
{ {
"/* original parser id follows */", "/* original parser id follows */",
"/* yysccsid[] = \"@(#)yaccpar 1.9 (Berkeley) 02/21/93\" */", "/* 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 YYBYACC 1",
CONCAT1("#define YYMAJOR ", YYMAJOR), CONCAT1("#define YYMAJOR ", YYMAJOR),
@ -56,7 +56,7 @@ const char *const tables[] =
"#if YYBTYACC", "#if YYBTYACC",
"extern const YYINT yycindex[];", "extern const YYINT yycindex[];",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"extern const YYINT yygindex[];", "extern const YYINT yygindex[];",
"extern const YYINT yytable[];", "extern const YYINT yytable[];",
"extern const YYINT yycheck[];", "extern const YYINT yycheck[];",
@ -64,7 +64,7 @@ const char *const tables[] =
"#if YYBTYACC", "#if YYBTYACC",
"extern const YYINT yyctable[];", "extern const YYINT yyctable[];",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"", "",
"#if YYDEBUG", "#if YYDEBUG",
"extern const char *const yyname[];", "extern const char *const yyname[];",
@ -127,7 +127,7 @@ const char *const hdr_defs[] =
"#define YYLVQUEUEGROWTH 32", "#define YYLVQUEUEGROWTH 32",
"#endif", "#endif",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"", "",
"/* define the initial stack-sizes */", "/* define the initial stack-sizes */",
"#ifdef YYSTACKSIZE", "#ifdef YYSTACKSIZE",
@ -172,7 +172,7 @@ const char *const hdr_defs[] =
"};", "};",
"typedef struct YYParseState_s YYParseState;", "typedef struct YYParseState_s YYParseState;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
0 0
}; };
@ -220,7 +220,7 @@ const char *const hdr_vars[] =
"", "",
"static short *yylexemes = 0;", "static short *yylexemes = 0;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
0 0
}; };
@ -277,7 +277,7 @@ const char *const body_vars[] =
"", "",
" static short *yylexemes = 0;", " static short *yylexemes = 0;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
0 0
}; };
@ -290,14 +290,14 @@ const char *const body_1[] =
"#if YYBTYACC", "#if YYBTYACC",
"#define yytrial (yyps->save)", "#define yytrial (yyps->save)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"", "",
"#if YYDEBUG", "#if YYDEBUG",
"#include <stdio.h> /* needed for printf */", "#include <stdio.h> /* needed for printf */",
"#endif", "#endif",
"", "",
"#include <stdlib.h> /* needed for malloc, etc */", "#include <stdlib.h> /* needed for malloc, etc */",
"#include <string.h> /* needed for memset */", "#include <string.h> /* needed for memset */",
"", "",
"/* allocate initial stack or double stack size, up to YYMAXDEPTH */", "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
"static int yygrowstack(YYSTACKDATA *data)", "static int yygrowstack(YYSTACKDATA *data)",
@ -404,7 +404,7 @@ const char *const body_1[] =
" free(p);", " free(p);",
"}", "}",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"", "",
"#define YYABORT goto yyabort", "#define YYABORT goto yyabort",
"#define YYREJECT goto yyabort", "#define YYREJECT goto yyabort",
@ -416,7 +416,7 @@ const char *const body_1[] =
"#define YYVALID_NESTED do { if (yyps->save && \\", "#define YYVALID_NESTED do { if (yyps->save && \\",
" yyps->save->save == 0) goto yyvalid; } while(0)", " yyps->save->save == 0) goto yyvalid; } while(0)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"", "",
"int", "int",
"YYPARSE_DECL()", "YYPARSE_DECL()",
@ -432,7 +432,7 @@ const char *const body_2[] =
" int yynewerrflag;", " int yynewerrflag;",
" YYParseState *yyerrctx = NULL;", " YYParseState *yyerrctx = NULL;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" YYLTYPE yyerror_loc_range[2]; /* position of error start & end */", " YYLTYPE yyerror_loc_range[2]; /* position of error start & end */",
"#endif", "#endif",
@ -454,7 +454,7 @@ const char *const body_2[] =
" yyps = yyNewState(0); if (yyps == 0) goto yyenomem;", " yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
" yyps->save = 0;", " yyps->save = 0;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" yynerrs = 0;", " yynerrs = 0;",
" yyerrflag = 0;", " yyerrflag = 0;",
" yychar = YYEMPTY;", " yychar = YYEMPTY;",
@ -495,8 +495,8 @@ const char *const body_2[] =
" /* in trial mode; save scanner results for future parse attempts */", " /* in trial mode; save scanner results for future parse attempts */",
" if (yylvp == yylvlim)", " if (yylvp == yylvlim)",
" { /* Enlarge lexical value queue */", " { /* Enlarge lexical value queue */",
" int p = yylvp - yylvals;", " size_t p = (size_t) (yylvp - yylvals);",
" int s = yylvlim - yylvals;", " size_t s = (size_t) (yylvlim - yylvals);",
"", "",
" s += YYLVQUEUEGROWTH;", " s += YYLVQUEUEGROWTH;",
" if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;", " 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 */", " /* normal operation, no conflict encountered */",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" yychar = YYLEX;", " yychar = YYLEX;",
#if defined(YYBTYACC) #if defined(YYBTYACC)
"#if YYBTYACC", "#if YYBTYACC",
" } while (0);", " } while (0);",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" if (yychar < 0) yychar = YYEOF;", " if (yychar < 0) yychar = YYEOF;",
" /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */", " /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
"#if YYDEBUG", "#if YYDEBUG",
@ -544,7 +544,7 @@ const char *const body_2[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (!yytrial)", " if (!yytrial)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));", " fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));",
"#endif", "#endif",
" fputc('\\n', stderr);", " fputc('\\n', stderr);",
@ -598,12 +598,12 @@ const char *const body_2[] =
" save->state = yystate;", " save->state = yystate;",
" save->errflag = yyerrflag;", " save->errflag = yyerrflag;",
" save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);", " 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);", " 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)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);", " 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", "#endif",
" ctry = yytable[yyn];", " ctry = yytable[yyn];",
" if (yyctable[ctry] == -1)", " if (yyctable[ctry] == -1)",
@ -658,7 +658,7 @@ const char *const body_2[] =
" yylexp--;", " yylexp--;",
" yychar = YYEMPTY;", " yychar = YYEMPTY;",
" }", " }",
" save->lexeme = yylvp - yylvals;", " save->lexeme = (int) (yylvp - yylvals);",
" yyps->save = save;", " yyps->save = save;",
" }", " }",
" if (yytable[yyn] == ctry)", " if (yytable[yyn] == ctry)",
@ -695,7 +695,7 @@ const char *const body_2[] =
" }", " }",
" } /* End of code dealing with conflicts */", " } /* End of code dealing with conflicts */",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&", " if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
" yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)", " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
" {", " {",
@ -754,14 +754,14 @@ const char *const body_2[] =
" yyerrctx->state = yystate;", " yyerrctx->state = yystate;",
" yyerrctx->errflag = yyerrflag;", " yyerrctx->errflag = yyerrflag;",
" yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);", " 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);", " 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)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);", " 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", "#endif",
" yyerrctx->lexeme = yylvp - yylvals;", " yyerrctx->lexeme = (int) (yylvp - yylvals);",
" }", " }",
" yylvp = yylvals + save->lexeme;", " yylvp = yylvals + save->lexeme;",
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
@ -770,12 +770,12 @@ const char *const body_2[] =
" yylexp = yylexemes + save->lexeme;", " yylexp = yylexemes + save->lexeme;",
" yychar = YYEMPTY;", " yychar = YYEMPTY;",
" yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);", " 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);", " 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)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);", " 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", "#endif",
" ctry = ++save->ctry;", " ctry = ++save->ctry;",
" yystate = save->state;", " yystate = save->state;",
@ -805,12 +805,12 @@ const char *const body_2[] =
" yylloc = yylpp[-1];", " yylloc = yylpp[-1];",
"#endif", "#endif",
" yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);", " 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);", " 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)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);", " 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", "#endif",
" yystate = yyerrctx->state;", " yystate = yyerrctx->state;",
" yyFreeState(yyerrctx);", " yyFreeState(yyerrctx);",
@ -820,7 +820,7 @@ const char *const body_2[] =
" }", " }",
" if (yynewerrflag == 0) goto yyinrecovery;", " if (yynewerrflag == 0) goto yyinrecovery;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"", "",
" YYERROR_CALL(\"syntax error\");", " YYERROR_CALL(\"syntax error\");",
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
@ -876,7 +876,7 @@ const char *const body_2[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (!yytrial)", " if (!yytrial)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" YYDESTRUCT_CALL(\"error: discarding state\",", " YYDESTRUCT_CALL(\"error: discarding state\",",
" yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);", " yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);",
@ -909,7 +909,7 @@ const char *const body_2[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (!yytrial)", " if (!yytrial)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);", " YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);",
"#else", "#else",
@ -932,7 +932,7 @@ const char *const body_2[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (!yytrial)", " if (!yytrial)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" if (yym > 0)", " if (yym > 0)",
" {", " {",
" int i;", " int i;",
@ -961,7 +961,7 @@ const char *const body_2[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (!yytrial)", " if (!yytrial)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" {", " {",
" YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);", " YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);",
" /* just in case YYERROR is invoked within the action, save", " /* just in case YYERROR is invoked within the action, save",
@ -998,7 +998,7 @@ const char *const trailer[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (!yytrial)", " if (!yytrial)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));", " fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));",
"#endif", "#endif",
" fprintf(stderr, \"shifting from state 0 to final state %d\\n\", YYFINAL);", " 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 */", " /* in trial mode; save scanner results for future parse attempts */",
" if (yylvp == yylvlim)", " if (yylvp == yylvlim)",
" { /* Enlarge lexical value queue */", " { /* Enlarge lexical value queue */",
" int p = yylvp - yylvals;", " size_t p = (size_t) (yylvp - yylvals);",
" int s = yylvlim - yylvals;", " size_t s = (size_t) (yylvlim - yylvals);",
"", "",
" s += YYLVQUEUEGROWTH;", " s += YYLVQUEUEGROWTH;",
" if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)", " if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)",
@ -1062,13 +1062,13 @@ const char *const trailer[] =
" }", " }",
" /* normal operation, no conflict encountered */", " /* normal operation, no conflict encountered */",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" yychar = YYLEX;", " yychar = YYLEX;",
#if defined(YYBTYACC) #if defined(YYBTYACC)
"#if YYBTYACC", "#if YYBTYACC",
" } while (0);", " } while (0);",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" if (yychar < 0) yychar = YYEOF;", " if (yychar < 0) yychar = YYEOF;",
" /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */", " /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
"#if YYDEBUG", "#if YYDEBUG",
@ -1097,7 +1097,7 @@ const char *const trailer[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (!yytrial)", " if (!yytrial)",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));", " fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));",
"#endif", "#endif",
" fprintf(stderr, \"shifting from state %d to state %d\\n\", *yystack.s_mark, yystate);", " 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;", " yylexp = yylexemes + yypath->lexeme;",
" yychar = YYEMPTY;", " yychar = YYEMPTY;",
" yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);", " 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);", " 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)", "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
" yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);", " 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", "#endif",
" yystate = yypath->state;", " yystate = yypath->state;",
" goto yyloop;", " goto yyloop;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
"", "",
"yyoverflow:", "yyoverflow:",
" YYERROR_CALL(\"yacc stack overflow\");", " YYERROR_CALL(\"yacc stack overflow\");",
@ -1161,7 +1161,7 @@ const char *const trailer[] =
" YYERROR_CALL(\"memory exhausted\");", " YYERROR_CALL(\"memory exhausted\");",
"yyabort_nomem:", "yyabort_nomem:",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" yyresult = 2;", " yyresult = 2;",
" goto yyreturn;", " goto yyreturn;",
"", "",
@ -1174,7 +1174,7 @@ const char *const trailer[] =
"#if YYBTYACC", "#if YYBTYACC",
" if (yyps->save) goto yyvalid;", " if (yyps->save) goto yyvalid;",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" yyresult = 0;", " yyresult = 0;",
"", "",
"yyreturn:", "yyreturn:",
@ -1224,7 +1224,7 @@ const char *const trailer[] =
" yyFreeState(save);", " yyFreeState(save);",
" }", " }",
"#endif /* YYBTYACC */", "#endif /* YYBTYACC */",
#endif /* defined(YYBTYACC) */ #endif /* defined(YYBTYACC) */
" yyfreestack(&yystack);", " yyfreestack(&yystack);",
" return (yyresult);", " return (yyresult);",
"}", "}",

8
contrib/byacc/closure.c
View File

@ -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" #include "defs.h"
@ -6,6 +6,7 @@ Value_t *itemset;
Value_t *itemsetend; Value_t *itemsetend;
unsigned *ruleset; unsigned *ruleset;
static unsigned *first_base;
static unsigned *first_derives; static unsigned *first_derives;
static unsigned *EFF; static unsigned *EFF;
@ -68,7 +69,8 @@ set_first_derives(void)
rulesetsize = WORDSIZE(nrules); rulesetsize = WORDSIZE(nrules);
varsetsize = WORDSIZE(nvars); 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(); set_EFF();
@ -176,7 +178,7 @@ finalize_closure(void)
{ {
FREE(itemset); FREE(itemset);
FREE(ruleset); FREE(ruleset);
FREE(first_derives + ntokens * WORDSIZE(nrules)); FREE(first_base);
} }
#ifdef DEBUG #ifdef DEBUG

12
contrib/byacc/config.sub vendored
View File

@ -2,7 +2,7 @@
# Configuration validation subroutine script. # Configuration validation subroutine script.
# Copyright 1992-2014 Free Software Foundation, Inc. # 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 # 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 # under the terms of the GNU General Public License as published by
@ -283,8 +283,10 @@ case $basic_machine in
| mips64vr5900 | mips64vr5900el \ | mips64vr5900 | mips64vr5900el \
| mipsisa32 | mipsisa32el \ | mipsisa32 | mipsisa32el \
| mipsisa32r2 | mipsisa32r2el \ | mipsisa32r2 | mipsisa32r2el \
| mipsisa32r6 | mipsisa32r6el \
| mipsisa64 | mipsisa64el \ | mipsisa64 | mipsisa64el \
| mipsisa64r2 | mipsisa64r2el \ | mipsisa64r2 | mipsisa64r2el \
| mipsisa64r6 | mipsisa64r6el \
| mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sb1 | mipsisa64sb1el \
| mipsisa64sr71k | mipsisa64sr71kel \ | mipsisa64sr71k | mipsisa64sr71kel \
| mipsr5900 | mipsr5900el \ | mipsr5900 | mipsr5900el \
@ -401,8 +403,10 @@ case $basic_machine in
| mips64vr5900-* | mips64vr5900el-* \ | mips64vr5900-* | mips64vr5900el-* \
| mipsisa32-* | mipsisa32el-* \ | mipsisa32-* | mipsisa32el-* \
| mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa32r2-* | mipsisa32r2el-* \
| mipsisa32r6-* | mipsisa32r6el-* \
| mipsisa64-* | mipsisa64el-* \ | mipsisa64-* | mipsisa64el-* \
| mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64r2-* | mipsisa64r2el-* \
| mipsisa64r6-* | mipsisa64r6el-* \
| mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \
| mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \
| mipsr5900-* | mipsr5900el-* \ | mipsr5900-* | mipsr5900el-* \
@ -824,6 +828,10 @@ case $basic_machine in
basic_machine=powerpc-unknown basic_machine=powerpc-unknown
os=-morphos os=-morphos
;; ;;
moxiebox)
basic_machine=moxie-unknown
os=-moxiebox
;;
msdos) msdos)
basic_machine=i386-pc basic_machine=i386-pc
os=-msdos os=-msdos
@ -1369,7 +1377,7 @@ case $os in
| -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
| -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
| -linux-newlib* | -linux-musl* | -linux-uclibc* \ | -linux-newlib* | -linux-musl* | -linux-uclibc* \
| -uxpv* | -beos* | -mpeix* | -udk* \ | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
| -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
| -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
| -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \

1147
contrib/byacc/configure vendored
View File

File diff suppressed because it is too large Load Diff

6
contrib/byacc/configure.in
View File

@ -1,7 +1,7 @@
dnl Process this file with 'autoconf' to produce a 'configure' script dnl Process this file with 'autoconf' to produce a 'configure' script
dnl $Id: configure.in,v 1.19 2014/04/22 22:56:51 tom Exp $ dnl $Id: configure.in,v 1.20 2014/10/06 22:39:39 tom Exp $
AC_PREREQ(2.52.20011201) AC_PREREQ(2.52.20011201)
AC_REVISION($Revision: 1.19 $) AC_REVISION($Revision: 1.20 $)
AC_INIT(main.c) AC_INIT(main.c)
AC_CONFIG_HEADER(config.h:config_h.in) AC_CONFIG_HEADER(config.h:config_h.in)
@ -54,6 +54,8 @@ CF_WITH_WARNINGS(Wwrite-strings)
CF_DISABLE_ECHO CF_DISABLE_ECHO
CF_DISABLE_LEAKS CF_DISABLE_LEAKS
AC_TYPE_MODE_T
### output makefile ### output makefile
AC_OUTPUT(makefile) AC_OUTPUT(makefile)
CF_MAKE_DOCS(yacc,1) CF_MAKE_DOCS(yacc,1)

4
contrib/byacc/defs.h
View File

@ -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 #ifdef HAVE_CONFIG_H
#include <config.h> #include <config.h>
@ -157,6 +157,7 @@
#define CALLOC(k,n) (calloc((size_t)(k),(size_t)(n))) #define CALLOC(k,n) (calloc((size_t)(k),(size_t)(n)))
#define FREE(x) (free((char*)(x))) #define FREE(x) (free((char*)(x)))
#define MALLOC(n) (malloc((size_t)(n))) #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 TMALLOC(t,n) ((t*) malloc((size_t)(n) * sizeof(t)))
#define NEW(t) ((t*)allocate(sizeof(t))) #define NEW(t) ((t*)allocate(sizeof(t)))
#define NEW2(n,t) ((t*)allocate(((size_t)(n)*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 unsigned *LA;
extern Value_t *LAruleno; extern Value_t *LAruleno;
extern Value_t *lookaheads; extern Value_t *lookaheads;
extern Value_t *goto_base;
extern Value_t *goto_map; extern Value_t *goto_map;
extern Value_t *from_state; extern Value_t *from_state;
extern Value_t *to_state; extern Value_t *to_state;

13
contrib/byacc/lalr.c
View File

@ -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" #include "defs.h"
@ -34,6 +34,7 @@ Value_t *accessing_symbol;
core **state_table; core **state_table;
shifts **shift_table; shifts **shift_table;
reductions **reduction_table; reductions **reduction_table;
Value_t *goto_base;
Value_t *goto_map; Value_t *goto_map;
Value_t *from_state; Value_t *from_state;
Value_t *to_state; Value_t *to_state;
@ -179,12 +180,16 @@ set_goto_map(void)
int i; int i;
int symbol; int symbol;
int k; int k;
Value_t *temp_base;
Value_t *temp_map; Value_t *temp_map;
Value_t state2; Value_t state2;
Value_t state1; Value_t state1;
goto_map = NEW2(nvars + 1, Value_t) - ntokens; goto_base = NEW2(nvars + 1, Value_t);
temp_map = NEW2(nvars + 1, Value_t) - ntokens; temp_base = NEW2(nvars + 1, Value_t);
goto_map = goto_base - ntokens;
temp_map = temp_base - ntokens;
ngotos = 0; ngotos = 0;
for (sp = first_shift; sp; sp = sp->next) 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. */ /* Map_goto maps a state/symbol pair into its numeric representation. */

9
contrib/byacc/main.c
View File

@ -1,4 +1,4 @@
/* $Id: main.c,v 1.51 2014/05/28 02:01:55 Tom.Shields Exp $ */ /* $Id: main.c,v 1.54 2014/10/06 22:40:07 tom Exp $ */
#include <signal.h> #include <signal.h>
#ifndef _WIN32 #ifndef _WIN32
@ -491,8 +491,8 @@ close_tmpfiles(void)
{ {
MY_TMPFILES *next = my_tmpfiles->next; MY_TMPFILES *next = my_tmpfiles->next;
chmod(my_tmpfiles->name, 0644); (void)chmod(my_tmpfiles->name, 0644);
unlink(my_tmpfiles->name); (void)unlink(my_tmpfiles->name);
free(my_tmpfiles->name); free(my_tmpfiles->name);
free(my_tmpfiles); free(my_tmpfiles);
@ -574,6 +574,8 @@ open_tmpfile(const char *label)
result = 0; result = 0;
if (name != 0) if (name != 0)
{ {
mode_t save_umask = umask(0177);
if ((mark = strrchr(label, '_')) == 0) if ((mark = strrchr(label, '_')) == 0)
mark = label + strlen(label); mark = label + strlen(label);
@ -601,6 +603,7 @@ open_tmpfile(const char *label)
my_tmpfiles = item; my_tmpfiles = item;
} }
} }
(void)umask(save_umask);
} }
#else #else
result = tmpfile(); result = tmpfile();

170
contrib/byacc/output.c
View File

@ -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" #include "defs.h"
@ -53,6 +53,43 @@ puts_code(FILE * fp, const char *s)
fputs(s, fp); 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 static void
write_code_lineno(FILE * fp) write_code_lineno(FILE * fp)
{ {
@ -1007,30 +1044,33 @@ output_ctable(void)
{ {
int i; int i;
int j; 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) 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); FREE(conflicts);
}
end_table();
output_line("#endif");
} }
#endif #endif
@ -1056,7 +1096,7 @@ output_actions(void)
FREE(accessing_symbol); FREE(accessing_symbol);
goto_actions(); goto_actions();
FREE(goto_map + ntokens); FREE(goto_base);
FREE(from_state); FREE(from_state);
FREE(to_state); FREE(to_state);
@ -1607,15 +1647,7 @@ output_parse_decl(FILE * fp)
putl_code(fp, "#else\n"); putl_code(fp, "#else\n");
puts_code(fp, "# define YYPARSE_DECL() yyparse("); puts_code(fp, "# define YYPARSE_DECL() yyparse(");
if (!parse_param) puts_param_types(fp, parse_param, 0);
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 ? ", " : "");
}
putl_code(fp, ")\n"); putl_code(fp, ")\n");
putl_code(fp, "#endif\n"); putl_code(fp, "#endif\n");
@ -1633,7 +1665,8 @@ output_lex_decl(FILE * fp)
#if defined(YYBTYACC) #if defined(YYBTYACC)
if (locations) 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"); " YYLEX_PARAM_TYPE YYLEX_PARAM)\n");
} }
else else
@ -1646,7 +1679,8 @@ output_lex_decl(FILE * fp)
#if defined(YYBTYACC) #if defined(YYBTYACC)
if (locations) 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"); " void * YYLEX_PARAM)\n");
} }
else else
@ -1672,8 +1706,6 @@ output_lex_decl(FILE * fp)
putl_code(fp, "#else\n"); putl_code(fp, "#else\n");
if (pure_parser && lex_param) if (pure_parser && lex_param)
{ {
param *p;
#if defined(YYBTYACC) #if defined(YYBTYACC)
if (locations) if (locations)
puts_code(fp, puts_code(fp,
@ -1681,9 +1713,7 @@ output_lex_decl(FILE * fp)
else else
#endif #endif
puts_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval, "); puts_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval, ");
for (p = lex_param; p; p = p->next) puts_param_types(fp, lex_param, 0);
fprintf(fp, "%s %s%s%s", p->type, p->name, p->type2,
p->next ? ", " : "");
putl_code(fp, ")\n"); putl_code(fp, ")\n");
#if defined(YYBTYACC) #if defined(YYBTYACC)
@ -1692,8 +1722,7 @@ output_lex_decl(FILE * fp)
else else
#endif #endif
puts_code(fp, "# define YYLEX yylex(&yylval, "); puts_code(fp, "# define YYLEX yylex(&yylval, ");
for (p = lex_param; p; p = p->next) puts_param_names(fp, lex_param, 0);
fprintf(fp, "%s%s", p->name, p->next ? ", " : "");
putl_code(fp, ")\n"); putl_code(fp, ")\n");
} }
else if (pure_parser) else if (pure_parser)
@ -1714,17 +1743,12 @@ output_lex_decl(FILE * fp)
} }
else if (lex_param) else if (lex_param)
{ {
param *p;
puts_code(fp, "# define YYLEX_DECL() yylex("); puts_code(fp, "# define YYLEX_DECL() yylex(");
for (p = lex_param; p; p = p->next) puts_param_types(fp, lex_param, 0);
fprintf(fp, "%s %s%s%s", p->type, p->name, p->type2,
p->next ? ", " : "");
putl_code(fp, ")\n"); putl_code(fp, ")\n");
puts_code(fp, "# define YYLEX yylex("); puts_code(fp, "# define YYLEX yylex(");
for (p = lex_param; p; p = p->next) puts_param_names(fp, lex_param, 0);
fprintf(fp, "%s%s", p->name, p->next ? ", " : "");
putl_code(fp, ")\n"); putl_code(fp, ")\n");
} }
else else
@ -1738,8 +1762,6 @@ output_lex_decl(FILE * fp)
static void static void
output_error_decl(FILE * fp) output_error_decl(FILE * fp)
{ {
param *p;
putc_code(fp, '\n'); putc_code(fp, '\n');
putl_code(fp, "/* Parameters sent to yyerror. */\n"); putl_code(fp, "/* Parameters sent to yyerror. */\n");
putl_code(fp, "#ifndef YYERROR_DECL\n"); putl_code(fp, "#ifndef YYERROR_DECL\n");
@ -1748,22 +1770,20 @@ output_error_decl(FILE * fp)
if (locations) if (locations)
puts_code(fp, "YYLTYPE loc, "); puts_code(fp, "YYLTYPE loc, ");
#endif #endif
for (p = parse_param; p; p = p->next) puts_param_types(fp, parse_param, 1);
fprintf(fp, "%s %s%s, ", p->type, p->name, p->type2);
putl_code(fp, "const char *s)\n"); putl_code(fp, "const char *s)\n");
putl_code(fp, "#endif\n"); putl_code(fp, "#endif\n");
putl_code(fp, "#ifndef YYERROR_CALL\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 defined(YYBTYACC)
if (locations) if (locations)
puts_code(fp, "yylloc, "); puts_code(fp, "yylloc, ");
#endif #endif
for (p = parse_param; p; p = p->next) puts_param_names(fp, parse_param, 1);
fprintf(fp, "%s, ", p->name);
putl_code(fp, "msg)\n"); putl_code(fp, "msg)\n");
putl_code(fp, "#endif\n"); putl_code(fp, "#endif\n");
} }
@ -1773,24 +1793,42 @@ output_yydestruct_decl(FILE * fp)
{ {
putc_code(fp, '\n'); putc_code(fp, '\n');
putl_code(fp, "#ifndef YYDESTRUCT_DECL\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 defined(YYBTYACC)
if (locations) if (locations)
putl_code(fp, puts_code(fp, ", YYLTYPE *loc");
"#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, YYLTYPE *loc)\n");
else
#endif #endif
putl_code(fp, if (parse_param)
"#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val)\n"); {
puts_code(fp, ", ");
puts_param_types(fp, parse_param, 0);
}
putl_code(fp, ")\n");
putl_code(fp, "#endif\n"); putl_code(fp, "#endif\n");
putl_code(fp, "#ifndef YYDESTRUCT_CALL\n"); putl_code(fp, "#ifndef YYDESTRUCT_CALL\n");
puts_code(fp, "#define YYDESTRUCT_CALL(msg, psymb, val");
#if defined(YYBTYACC) #if defined(YYBTYACC)
if (locations) if (locations)
putl_code(fp, puts_code(fp, ", loc");
"#define YYDESTRUCT_CALL(msg, psymb, val, loc) yydestruct(msg, psymb, val, loc)\n");
else
#endif #endif
putl_code(fp, puts_code(fp, ") yydestruct(msg, psymb, val");
"#define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val)\n"); #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"); putl_code(fp, "#endif\n");
} }

4
contrib/byacc/package/byacc.spec
View File

@ -1,8 +1,8 @@
Summary: byacc - public domain Berkeley LALR Yacc parser generator Summary: byacc - public domain Berkeley LALR Yacc parser generator
%define AppProgram byacc %define AppProgram byacc
%define AppVersion 20140715 %define AppVersion 20141006
%define UseProgram yacc %define UseProgram yacc
# $XTermId: byacc.spec,v 1.22 2014/07/15 19:36:54 tom Exp $ # $XTermId: byacc.spec,v 1.25 2014/10/06 22:52:03 tom Exp $
Name: %{AppProgram} Name: %{AppProgram}
Version: %{AppVersion} Version: %{AppVersion}
Release: 1 Release: 1

12
contrib/byacc/package/debian/changelog
View File

@ -1,3 +1,15 @@
byacc (20141006) unstable; urgency=low
* maintenance updates
-- Thomas E. Dickey <dickey@invisible-island.net> Mon, 06 Oct 2014 18:52:03 -0400
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 byacc (20140715) unstable; urgency=low
* maintenance updates * maintenance updates

2
contrib/byacc/package/debian/source/format
View File

@ -1 +1 @@
3.0 (quilt) 3.0 (native)

4
contrib/byacc/package/mingw-byacc.spec
View File

@ -1,8 +1,8 @@
Summary: byacc - public domain Berkeley LALR Yacc parser generator Summary: byacc - public domain Berkeley LALR Yacc parser generator
%define AppProgram byacc %define AppProgram byacc
%define AppVersion 20140715 %define AppVersion 20141006
%define UseProgram yacc %define UseProgram yacc
# $XTermId: mingw-byacc.spec,v 1.4 2014/07/15 19:36:54 tom Exp $ # $XTermId: mingw-byacc.spec,v 1.7 2014/10/06 22:52:03 tom Exp $
Name: %{AppProgram} Name: %{AppProgram}
Version: %{AppVersion} Version: %{AppVersion}
Release: 1 Release: 1

2
contrib/byacc/package/pkgsrc/Makefile
View File

@ -1,7 +1,7 @@
# $NetBSD: Makefile,v 1.9 2008/07/24 17:13:00 tonnerre Exp $ # $NetBSD: Makefile,v 1.9 2008/07/24 17:13:00 tonnerre Exp $
# #
DISTNAME= byacc-20140715 DISTNAME= byacc-20141006
PKGREVISION= 1 PKGREVISION= 1
CATEGORIES= devel CATEGORIES= devel
MASTER_SITES= ftp://invisible-island.net/byacc/ MASTER_SITES= ftp://invisible-island.net/byacc/

416
contrib/byacc/reader.c
View File

@ -1,4 +1,4 @@
/* $Id: reader.c,v 1.47 2014/04/09 21:09:27 tom Exp $ */ /* $Id: reader.c,v 1.58 2014/10/06 22:15:08 tom Exp $ */
#include "defs.h" #include "defs.h"
@ -70,6 +70,7 @@ static bucket *default_destructor[3] =
static bucket * static bucket *
lookup_type_destructor(char *tag) lookup_type_destructor(char *tag)
{ {
const char fmt[] = "%.*s destructor";
char name[1024] = "\0"; char name[1024] = "\0";
bucket *bp, **bpp = &default_destructor[TYPE_SPECIFIED]; bucket *bp, **bpp = &default_destructor[TYPE_SPECIFIED];
@ -80,7 +81,8 @@ lookup_type_destructor(char *tag)
bpp = &bp->link; 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; bp->tag = tag;
return (bp); return (bp);
@ -133,10 +135,10 @@ get_line(void)
++lineno; ++lineno;
for (;;) for (;;)
{ {
line[i] = (char)c; line[i++] = (char)c;
if (c == '\n') if (c == '\n')
break; break;
if (++i >= linesize) if ((i + 3) >= linesize)
{ {
linesize += LINESIZE; linesize += LINESIZE;
line = TREALLOC(char, line, linesize); line = TREALLOC(char, line, linesize);
@ -145,11 +147,12 @@ get_line(void)
c = getc(f); c = getc(f);
if (c == EOF) if (c == EOF)
{ {
line[i] = '\n'; line[i++] = '\n';
saw_eof = 1; saw_eof = 1;
break; break;
} }
} }
line[i] = '\0';
cptr = line; cptr = line;
return; return;
} }
@ -205,7 +208,7 @@ skip_comment(void)
} }
static int static int
nextc(void) next_inline(void)
{ {
char *s; char *s;
@ -221,27 +224,6 @@ nextc(void)
{ {
switch (*s) 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 '/': case '/':
if (s[1] == '*') if (s[1] == '*')
{ {
@ -266,6 +248,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* */ /* *INDENT-OFF* */
static struct keyword static struct keyword
{ {
@ -644,92 +661,109 @@ copy_union(void)
} }
} }
/* static char *
* Keep a linked list of parameters after_blanks(char *s)
*/
static void
copy_param(int k)
{ {
char *buf; while (*s != '\0' && isspace(UCH(*s)))
int c; ++s;
param *head, *p; return s;
int i; }
int name, type2;
c = nextc(); /*
if (c == EOF) * Trim leading/trailing blanks, and collapse multiple embedded blanks to a
unexpected_EOF(); * single space. Return index to last character in the buffer.
if (c != L_CURL) */
goto out; static int
cptr++; trim_blanks(char *buffer)
{
c = nextc(); if (*buffer != '\0')
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++)
{ {
if (c == '\0') char *d = buffer;
missing_brace(); char *s = after_blanks(d);
if (c == EOF)
unexpected_EOF();
buf[i] = (char)c;
}
if (i == 0) while ((*d++ = *s++) != '\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] != '[')
{ {
if (buf[i] == ']') ;
++level; }
else if (buf[i] == '[')
--level; --d;
i--; 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])) || static void
UCH(buf[i]) == '_')) save_param(int k, char *buffer, int name, int type2)
i--; {
param *head, *p;
if (!isspace(UCH(buf[i])) && buf[i] != '*')
goto out;
name = i + 1;
p = TMALLOC(param, 1); p = TMALLOC(param, 1);
NO_SPACE(p); NO_SPACE(p);
p->type2 = strdup(buf + type2); p->type2 = strdup(buffer + type2);
NO_SPACE(p->type2); NO_SPACE(p->type2);
buffer[type2] = '\0';
(void)trim_blanks(p->type2);
buf[type2] = '\0'; p->name = strdup(buffer + name);
p->name = strdup(buf + name);
NO_SPACE(p->name); NO_SPACE(p->name);
buffer[name] = '\0';
(void)trim_blanks(p->name);
buf[name] = '\0'; p->type = strdup(buffer);
p->type = buf; NO_SPACE(p->type);
(void)trim_blanks(p->type);
if (k == LEX_PARAM) if (k == LEX_PARAM)
head = lex_param; head = lex_param;
@ -750,9 +784,169 @@ copy_param(int k)
parse_param = p; parse_param = p;
} }
p->next = NULL; 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; return;
out: oops:
FREE(buf);
syntax_error(lineno, line, cptr); syntax_error(lineno, line, cptr);
} }
@ -1634,10 +1828,11 @@ compile_arg(char **theptr, char *yyvaltag)
{ {
offsets = TMALLOC(Value_t, maxoffset + 1); offsets = TMALLOC(Value_t, maxoffset + 1);
NO_SPACE(offsets); 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; rhs = pitem + nitems - 1;
if (yyvaltag) if (yyvaltag)
@ -1664,7 +1859,7 @@ compile_arg(char **theptr, char *yyvaltag)
dollar_warning(rescan_lineno, val); dollar_warning(rescan_lineno, val);
i = val - maxoffset; i = val - maxoffset;
} }
else else if (maxoffset > 0)
{ {
i = offsets[val]; i = offsets[val];
if (!tag && !(tag = rhs[i]->tag) && havetags) if (!tag && !(tag = rhs[i]->tag) && havetags)
@ -2020,14 +2215,6 @@ add_symbol(void)
pitem[nitems - 1] = bp; pitem[nitems - 1] = bp;
} }
static char *
after_blanks(char *s)
{
while (*s != '\0' && isspace(UCH(*s)))
++s;
return s;
}
static void static void
copy_action(void) copy_action(void)
{ {
@ -2084,12 +2271,13 @@ copy_action(void)
{ {
offsets = TMALLOC(Value_t, maxoffset + 1); offsets = TMALLOC(Value_t, maxoffset + 1);
NO_SPACE(offsets); NO_SPACE(offsets);
}
for (j = 0, i++; i < nitems; i++) for (j = 0, i++; i < nitems; i++)
{
if (pitem[i]->class != ARGUMENT)
{ {
offsets[++j] = (Value_t) (i - nitems + 1); if (pitem[i]->class != ARGUMENT)
{
offsets[++j] = (Value_t) (i - nitems + 1);
}
} }
} }
rhs = pitem + nitems - 1; rhs = pitem + nitems - 1;
@ -2177,7 +2365,7 @@ copy_action(void)
{ {
++cptr; ++cptr;
i = get_number(); i = get_number();
if (havetags) if (havetags && offsets)
{ {
if (i <= 0 || i > maxoffset) if (i <= 0 || i > maxoffset)
unknown_rhs(i); unknown_rhs(i);

75
contrib/byacc/test/btyacc/btyacc_calc1.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -311,7 +311,26 @@ static const YYINT calc1_ctable[] = { 20,
16, -1, 21, 16, -1, 22, 16, -1, 23, 16, 16, -1, 21, 16, -1, 22, 16, -1, 23, 16,
-1, 4, 16, -1, 14, 16, -1, 34, 16, -1, -1, 4, 16, -1, 14, 16, -1, 34, 16, -1,
10, 16, -1, 11, 16, -1, 12, 16, -1, 13, 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 #endif
#define YYFINAL 1 #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)); 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 */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -603,11 +622,11 @@ vdiv(double a, double b, INTERVAL v)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -841,8 +860,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -938,12 +957,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -998,7 +1017,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -1092,14 +1111,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -1108,12 +1127,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -1143,12 +1162,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1494,7 +1513,7 @@ case 28:
yyval.vval = yystack.l_mark[-1].vval; yyval.vval = yystack.l_mark[-1].vval;
} }
break; break;
#line 1498 "btyacc_calc1.tab.c" #line 1517 "btyacc_calc1.tab.c"
default: default:
break; break;
} }
@ -1545,8 +1564,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1649,12 +1668,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

197
contrib/byacc/test/btyacc/btyacc_demo.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -387,7 +387,32 @@ static const YYINT demo_check[] = { 42,
#if YYBTYACC #if YYBTYACC
static const YYINT demo_ctable[] = { -1, static const YYINT demo_ctable[] = { -1,
1, 10, -1, 21, 4, -1, 23, 29, -1, 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 #endif
#define YYFINAL 1 #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_expr_code(Expr *expr);
extern Code * build_if(Expr *cond_expr, Code *then_stmt, Code *else_stmt); extern Code * build_if(Expr *cond_expr, Code *then_stmt, Code *else_stmt);
extern Code * code_append(Code *stmt_list, Code *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. */ /* Release memory associated with symbol. */
#if ! defined YYDESTRUCT_IS_DECLARED #if ! defined YYDESTRUCT_IS_DECLARED
@ -651,7 +676,7 @@ YYDESTRUCT_DECL()
(*loc).last_line, (*loc).last_column); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 655 "btyacc_demo.tab.c" #line 680 "btyacc_demo.tab.c"
case 45: case 45:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 664 "btyacc_demo.tab.c" #line 689 "btyacc_demo.tab.c"
case 42: case 42:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 673 "btyacc_demo.tab.c" #line 698 "btyacc_demo.tab.c"
case 47: case 47:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 682 "btyacc_demo.tab.c" #line 707 "btyacc_demo.tab.c"
case 37: case 37:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 691 "btyacc_demo.tab.c" #line 716 "btyacc_demo.tab.c"
case 257: case 257:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 700 "btyacc_demo.tab.c" #line 725 "btyacc_demo.tab.c"
case 258: case 258:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 709 "btyacc_demo.tab.c" #line 734 "btyacc_demo.tab.c"
case 40: case 40:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 718 "btyacc_demo.tab.c" #line 743 "btyacc_demo.tab.c"
case 91: case 91:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 727 "btyacc_demo.tab.c" #line 752 "btyacc_demo.tab.c"
case 46: case 46:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 736 "btyacc_demo.tab.c" #line 761 "btyacc_demo.tab.c"
case 259: case 259:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).id); } free((*val).id); }
break; break;
#line 745 "btyacc_demo.tab.c" #line 770 "btyacc_demo.tab.c"
case 260: case 260:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).expr); } free((*val).expr); }
break; break;
#line 754 "btyacc_demo.tab.c" #line 779 "btyacc_demo.tab.c"
case 261: case 261:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 763 "btyacc_demo.tab.c" #line 788 "btyacc_demo.tab.c"
case 262: case 262:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 772 "btyacc_demo.tab.c" #line 797 "btyacc_demo.tab.c"
case 263: case 263:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 781 "btyacc_demo.tab.c" #line 806 "btyacc_demo.tab.c"
case 264: case 264:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 790 "btyacc_demo.tab.c" #line 815 "btyacc_demo.tab.c"
case 265: case 265:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 799 "btyacc_demo.tab.c" #line 824 "btyacc_demo.tab.c"
case 266: case 266:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 808 "btyacc_demo.tab.c" #line 833 "btyacc_demo.tab.c"
case 267: case 267:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 817 "btyacc_demo.tab.c" #line 842 "btyacc_demo.tab.c"
case 268: case 268:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 826 "btyacc_demo.tab.c" #line 851 "btyacc_demo.tab.c"
case 269: case 269:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 835 "btyacc_demo.tab.c" #line 860 "btyacc_demo.tab.c"
case 59: case 59:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 844 "btyacc_demo.tab.c" #line 869 "btyacc_demo.tab.c"
case 44: case 44:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 853 "btyacc_demo.tab.c" #line 878 "btyacc_demo.tab.c"
case 41: case 41:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 862 "btyacc_demo.tab.c" #line 887 "btyacc_demo.tab.c"
case 93: case 93:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 871 "btyacc_demo.tab.c" #line 896 "btyacc_demo.tab.c"
case 123: case 123:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 880 "btyacc_demo.tab.c" #line 905 "btyacc_demo.tab.c"
case 125: case 125:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 889 "btyacc_demo.tab.c" #line 914 "btyacc_demo.tab.c"
case 270: case 270:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 898 "btyacc_demo.tab.c" #line 923 "btyacc_demo.tab.c"
case 271: case 271:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 907 "btyacc_demo.tab.c" #line 932 "btyacc_demo.tab.c"
case 272: case 272:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).expr); } free((*val).expr); }
break; break;
#line 916 "btyacc_demo.tab.c" #line 941 "btyacc_demo.tab.c"
case 273: case 273:
#line 67 "btyacc_demo.y" #line 67 "btyacc_demo.y"
{ /* 'msg' is a 'char *' indicating the context of destructor invocation*/ { /* 'msg' is a 'char *' indicating the context of destructor invocation*/
@ -922,7 +947,7 @@ YYDESTRUCT_DECL()
(*loc).last_line, (*loc).last_column); (*loc).last_line, (*loc).last_column);
free((*val).decl->scope); free((*val).decl->type); } free((*val).decl->scope); free((*val).decl->type); }
break; break;
#line 926 "btyacc_demo.tab.c" #line 951 "btyacc_demo.tab.c"
case 274: case 274:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 935 "btyacc_demo.tab.c" #line 960 "btyacc_demo.tab.c"
case 275: case 275:
#line 83 "btyacc_demo.y" #line 83 "btyacc_demo.y"
{ printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
/* in this example, we don't know what to do here */ } /* in this example, we don't know what to do here */ }
break; break;
#line 944 "btyacc_demo.tab.c" #line 969 "btyacc_demo.tab.c"
case 276: case 276:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).code); } free((*val).code); }
break; break;
#line 953 "btyacc_demo.tab.c" #line 978 "btyacc_demo.tab.c"
case 277: case 277:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).code); } free((*val).code); }
break; break;
#line 962 "btyacc_demo.tab.c" #line 987 "btyacc_demo.tab.c"
case 278: case 278:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).code); } free((*val).code); }
break; break;
#line 971 "btyacc_demo.tab.c" #line 996 "btyacc_demo.tab.c"
case 279: case 279:
#line 73 "btyacc_demo.y" #line 73 "btyacc_demo.y"
{ printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).decl); } free((*val).decl); }
break; break;
#line 980 "btyacc_demo.tab.c" #line 1005 "btyacc_demo.tab.c"
case 280: case 280:
#line 73 "btyacc_demo.y" #line 73 "btyacc_demo.y"
{ printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).decl); } free((*val).decl); }
break; break;
#line 989 "btyacc_demo.tab.c" #line 1014 "btyacc_demo.tab.c"
case 281: case 281:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 998 "btyacc_demo.tab.c" #line 1023 "btyacc_demo.tab.c"
case 282: case 282:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 1007 "btyacc_demo.tab.c" #line 1032 "btyacc_demo.tab.c"
case 283: case 283:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 1016 "btyacc_demo.tab.c" #line 1041 "btyacc_demo.tab.c"
case 284: case 284:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 1025 "btyacc_demo.tab.c" #line 1050 "btyacc_demo.tab.c"
case 285: case 285:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 1034 "btyacc_demo.tab.c" #line 1059 "btyacc_demo.tab.c"
case 286: case 286:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1043 "btyacc_demo.tab.c" #line 1068 "btyacc_demo.tab.c"
case 287: case 287:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).dlist); } free((*val).dlist); }
break; break;
#line 1052 "btyacc_demo.tab.c" #line 1077 "btyacc_demo.tab.c"
case 288: case 288:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).dlist); } free((*val).dlist); }
break; break;
#line 1061 "btyacc_demo.tab.c" #line 1086 "btyacc_demo.tab.c"
case 289: case 289:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1070 "btyacc_demo.tab.c" #line 1095 "btyacc_demo.tab.c"
case 290: case 290:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1079 "btyacc_demo.tab.c" #line 1104 "btyacc_demo.tab.c"
case 291: case 291:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 1088 "btyacc_demo.tab.c" #line 1113 "btyacc_demo.tab.c"
case 292: case 292:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1097 "btyacc_demo.tab.c" #line 1122 "btyacc_demo.tab.c"
case 293: case 293:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1106 "btyacc_demo.tab.c" #line 1131 "btyacc_demo.tab.c"
case 294: case 294:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 1115 "btyacc_demo.tab.c" #line 1140 "btyacc_demo.tab.c"
case 295: case 295:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1124 "btyacc_demo.tab.c" #line 1149 "btyacc_demo.tab.c"
case 296: case 296:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).type); } free((*val).type); }
break; break;
#line 1133 "btyacc_demo.tab.c" #line 1158 "btyacc_demo.tab.c"
case 297: case 297:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1142 "btyacc_demo.tab.c" #line 1167 "btyacc_demo.tab.c"
case 298: case 298:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1151 "btyacc_demo.tab.c" #line 1176 "btyacc_demo.tab.c"
case 299: case 299:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1160 "btyacc_demo.tab.c" #line 1185 "btyacc_demo.tab.c"
case 300: case 300:
#line 78 "btyacc_demo.y" #line 78 "btyacc_demo.y"
{ printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n", { 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); (*loc).last_line, (*loc).last_column);
free((*val).scope); } free((*val).scope); }
break; break;
#line 1169 "btyacc_demo.tab.c" #line 1194 "btyacc_demo.tab.c"
} }
} }
#define YYDESTRUCT_IS_DECLARED 1 #define YYDESTRUCT_IS_DECLARED 1
@ -1178,11 +1203,11 @@ YYDESTRUCT_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -1366,8 +1391,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -1463,12 +1488,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -1523,7 +1548,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -1617,14 +1642,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -1633,12 +1658,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -1668,12 +1693,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -2093,7 +2118,7 @@ case 61:
#line 197 "btyacc_demo.y" #line 197 "btyacc_demo.y"
{ yyval.code = yystack.l_mark[-1].code; } { yyval.code = yystack.l_mark[-1].code; }
break; break;
#line 2097 "btyacc_demo.tab.c" #line 2122 "btyacc_demo.tab.c"
default: default:
break; break;
} }
@ -2144,8 +2169,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -2248,12 +2273,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

1
contrib/byacc/test/btyacc/btyacc_demo2.error Normal file
View File

@ -0,0 +1 @@
YACC: e - line 82 of "./btyacc_demo2.y", $$ is untyped

0
contrib/byacc/test/btyacc/btyacc_demo2.output Normal file
View File

15
contrib/byacc/test/btyacc/btyacc_demo2.tab.c Normal file
View 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
contrib/byacc/test/btyacc/btyacc_demo2.tab.h Normal file
View File

0
contrib/byacc/test/btyacc/btyacc_destroy1.error Normal file
View File

247
contrib/byacc/test/btyacc/btyacc_destroy1.output Normal file
View 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
contrib/byacc/test/btyacc/btyacc_destroy1.tab.c Normal file
View File

File diff suppressed because it is too large Load Diff

25
contrib/byacc/test/btyacc/btyacc_destroy1.tab.h Normal file
View 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
contrib/byacc/test/btyacc/btyacc_destroy2.error Normal file
View File

247
contrib/byacc/test/btyacc/btyacc_destroy2.output Normal file
View 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
contrib/byacc/test/btyacc/btyacc_destroy2.tab.c Normal file
View File

File diff suppressed because it is too large Load Diff

25
contrib/byacc/test/btyacc/btyacc_destroy2.tab.h Normal file
View 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
contrib/byacc/test/btyacc/btyacc_destroy3.error Normal file
View File

247
contrib/byacc/test/btyacc/btyacc_destroy3.output Normal file
View 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
contrib/byacc/test/btyacc/btyacc_destroy3.tab.c Normal file
View File

File diff suppressed because it is too large Load Diff

25
contrib/byacc/test/btyacc/btyacc_destroy3.tab.h Normal file
View 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_ */

80
contrib/byacc/test/btyacc/calc.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258, -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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -476,7 +502,7 @@ yylex(void)
} }
return( c ); return( c );
} }
#line 480 "calc.tab.c" #line 506 "calc.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -485,11 +511,11 @@ yylex(void)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -673,8 +699,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -770,12 +796,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -830,7 +856,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -924,14 +950,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -940,12 +966,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -975,12 +1001,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1193,7 +1219,7 @@ case 18:
#line 63 "calc.y" #line 63 "calc.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1197 "calc.tab.c" #line 1223 "calc.tab.c"
default: default:
break; break;
} }
@ -1244,8 +1270,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1348,12 +1374,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

81
contrib/byacc/test/btyacc/calc1.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -310,6 +310,33 @@ static const YYINT calc1_check[] = { 40,
-1, -1, -1, -1, -1, 256, 257, 258, 259, 257, -1, -1, -1, -1, -1, 256, 257, 258, 259, 257,
258, 259, 257, -1, 259, 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 #define YYFINAL 7
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #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)); 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 */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -628,11 +655,11 @@ vdiv(double a, double b, INTERVAL v)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -816,8 +843,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -913,12 +940,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -973,7 +1000,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -1067,14 +1094,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -1083,12 +1110,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -1118,12 +1145,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1439,7 +1466,7 @@ case 28:
yyval.vval = yystack.l_mark[-1].vval; yyval.vval = yystack.l_mark[-1].vval;
} }
break; break;
#line 1443 "calc1.tab.c" #line 1470 "calc1.tab.c"
default: default:
break; break;
} }
@ -1490,8 +1517,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1594,12 +1621,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

86
contrib/byacc/test/btyacc/calc2.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -146,7 +146,7 @@ typedef int YYSTYPE;
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif # endif
#else #else
# define YYPARSE_DECL() yyparse(int regs[26], int * base) # define YYPARSE_DECL() yyparse(int regs[26], int *base)
#endif #endif
/* Parameters sent to lex. */ /* Parameters sent to lex. */
@ -154,13 +154,13 @@ typedef int YYSTYPE;
# define YYLEX_DECL() yylex(void *YYLEX_PARAM) # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
# define YYLEX yylex(YYLEX_PARAM) # define YYLEX yylex(YYLEX_PARAM)
#else #else
# define YYLEX_DECL() yylex(int * base) # define YYLEX_DECL() yylex(int *base)
# define YYLEX yylex(base) # define YYLEX yylex(base)
#endif #endif
/* Parameters sent to yyerror. */ /* Parameters sent to yyerror. */
#ifndef YYERROR_DECL #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 #endif
#ifndef YYERROR_CALL #ifndef YYERROR_CALL
#define YYERROR_CALL(msg) yyerror(regs, base, msg) #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, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258, -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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -489,7 +515,7 @@ YYLEX_DECL()
} }
return( c ); return( c );
} }
#line 493 "calc2.tab.c" #line 519 "calc2.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -498,11 +524,11 @@ YYLEX_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -686,8 +712,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -783,12 +809,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -843,7 +869,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -937,14 +963,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -953,12 +979,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -988,12 +1014,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1206,7 +1232,7 @@ case 18:
#line 70 "calc2.y" #line 70 "calc2.y"
{ yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1210 "calc2.tab.c" #line 1236 "calc2.tab.c"
default: default:
break; break;
} }
@ -1257,8 +1283,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1361,12 +1387,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

86
contrib/byacc/test/btyacc/calc3.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -147,7 +147,7 @@ typedef int YYSTYPE;
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif # endif
#else #else
# define YYPARSE_DECL() yyparse(int regs[26], int * base) # define YYPARSE_DECL() yyparse(int regs[26], int *base)
#endif #endif
/* Parameters sent to lex. */ /* Parameters sent to lex. */
@ -159,13 +159,13 @@ typedef int YYSTYPE;
# endif # endif
# define YYLEX yylex(&yylval, YYLEX_PARAM) # define YYLEX yylex(&yylval, YYLEX_PARAM)
#else #else
# define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base) # define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
# define YYLEX yylex(&yylval, base) # define YYLEX yylex(&yylval, base)
#endif #endif
/* Parameters sent to yyerror. */ /* Parameters sent to yyerror. */
#ifndef YYERROR_DECL #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 #endif
#ifndef YYERROR_CALL #ifndef YYERROR_CALL
#define YYERROR_CALL(msg) yyerror(regs, base, msg) #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, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258, -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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -444,7 +470,7 @@ YYLEX_DECL()
} }
return( c ); return( c );
} }
#line 448 "calc3.tab.c" #line 474 "calc3.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -453,11 +479,11 @@ YYLEX_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -691,8 +717,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -788,12 +814,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -848,7 +874,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -942,14 +968,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -958,12 +984,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -993,12 +1019,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1211,7 +1237,7 @@ case 18:
#line 73 "calc3.y" #line 73 "calc3.y"
{ yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1215 "calc3.tab.c" #line 1241 "calc3.tab.c"
default: default:
break; break;
} }
@ -1262,8 +1288,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1366,12 +1392,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

50
contrib/byacc/test/btyacc/code_calc.code.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -382,11 +382,11 @@ yylex(void)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -570,8 +570,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -667,12 +667,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -727,7 +727,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -821,14 +821,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -837,12 +837,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -872,12 +872,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1141,8 +1141,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1245,12 +1245,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

26
contrib/byacc/test/btyacc/code_calc.tab.c
View File

@ -96,6 +96,32 @@ const YYINT calc_check[] = { 40,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258, -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 #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
#endif #endif

50
contrib/byacc/test/btyacc/code_error.code.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -354,11 +354,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -542,8 +542,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -639,12 +639,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -699,7 +699,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -793,14 +793,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -809,12 +809,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -844,12 +844,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1052,8 +1052,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1156,12 +1156,12 @@ YYPARSE_DECL()
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

4
contrib/byacc/test/btyacc/code_error.tab.c
View File

@ -33,6 +33,10 @@ const YYINT error_table[] = { 1,
}; };
const YYINT error_check[] = { 256, const YYINT error_check[] = { 256,
}; };
#if YYBTYACC
const YYINT error_ctable[] = { -1,
};
#endif
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
#endif #endif

56
contrib/byacc/test/btyacc/empty.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -197,6 +197,10 @@ static const YYINT empty_table[] = { 0,
}; };
static const YYINT empty_check[] = { -1, static const YYINT empty_check[] = { -1,
}; };
#if YYBTYACC
static const YYINT empty_ctable[] = { -1,
};
#endif
#define YYFINAL 1 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -360,7 +364,7 @@ static void
YYERROR_DECL() { YYERROR_DECL() {
printf("%s\n",s); printf("%s\n",s);
} }
#line 364 "empty.tab.c" #line 368 "empty.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -369,11 +373,11 @@ YYERROR_DECL() {
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -557,8 +561,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -654,12 +658,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -714,7 +718,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -808,14 +812,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -824,12 +828,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -859,12 +863,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1067,8 +1071,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1171,12 +1175,12 @@ YYPARSE_DECL()
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

2
contrib/byacc/test/btyacc/err_inherit1.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_inherit2.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

65
contrib/byacc/test/btyacc/err_inherit3.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 258, 259, 260, 14, 259, 260, 17, 261, 261, 6,
12, 12,
}; };
#if YYBTYACC
static const YYINT err_inherit3_ctable[] = { -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
#endif
#define YYFINAL 5 #define YYFINAL 5
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -411,7 +416,7 @@ static short *yylexemes = 0;
extern int YYLEX_DECL(); extern int YYLEX_DECL();
extern void YYERROR_DECL(); extern void YYERROR_DECL();
#line 415 "err_inherit3.tab.c" #line 420 "err_inherit3.tab.c"
/* Release memory associated with symbol. */ /* Release memory associated with symbol. */
#if ! defined YYDESTRUCT_IS_DECLARED #if ! defined YYDESTRUCT_IS_DECLARED
@ -431,7 +436,7 @@ YYDESTRUCT_DECL()
} }
} }
break; break;
#line 435 "err_inherit3.tab.c" #line 440 "err_inherit3.tab.c"
case 264: case 264:
#line 30 "err_inherit3.y" #line 30 "err_inherit3.y"
{ {
@ -443,7 +448,7 @@ YYDESTRUCT_DECL()
} }
} }
break; break;
#line 447 "err_inherit3.tab.c" #line 452 "err_inherit3.tab.c"
case 265: case 265:
#line 30 "err_inherit3.y" #line 30 "err_inherit3.y"
{ {
@ -455,7 +460,7 @@ YYDESTRUCT_DECL()
} }
} }
break; break;
#line 459 "err_inherit3.tab.c" #line 464 "err_inherit3.tab.c"
} }
} }
#define YYDESTRUCT_IS_DECLARED 1 #define YYDESTRUCT_IS_DECLARED 1
@ -468,11 +473,11 @@ YYDESTRUCT_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -656,8 +661,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -753,12 +758,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -813,7 +818,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -907,14 +912,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -923,12 +928,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -958,12 +963,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1176,7 +1181,7 @@ case 14:
#line 75 "err_inherit3.y" #line 75 "err_inherit3.y"
{ yyval.nlist = yystack.l_mark[0].nlist; } { yyval.nlist = yystack.l_mark[0].nlist; }
break; break;
#line 1180 "err_inherit3.tab.c" #line 1185 "err_inherit3.tab.c"
default: default:
break; break;
} }
@ -1227,8 +1232,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1331,12 +1336,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

65
contrib/byacc/test/btyacc/err_inherit4.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 258, 259, 260, 259, 260, 0, 261, 261, 0, 14,
6, 6,
}; };
#if YYBTYACC
static const YYINT err_inherit4_ctable[] = { -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
#endif
#define YYFINAL 5 #define YYFINAL 5
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -429,7 +434,7 @@ static short *yylexemes = 0;
extern int YYLEX_DECL(); extern int YYLEX_DECL();
extern void YYERROR_DECL(); extern void YYERROR_DECL();
#line 433 "err_inherit4.tab.c" #line 438 "err_inherit4.tab.c"
/* Release memory associated with symbol. */ /* Release memory associated with symbol. */
#if ! defined YYDESTRUCT_IS_DECLARED #if ! defined YYDESTRUCT_IS_DECLARED
@ -442,17 +447,17 @@ YYDESTRUCT_DECL()
#line 28 "err_inherit4.y" #line 28 "err_inherit4.y"
{ } { }
break; break;
#line 446 "err_inherit4.tab.c" #line 451 "err_inherit4.tab.c"
case 264: case 264:
#line 28 "err_inherit4.y" #line 28 "err_inherit4.y"
{ } { }
break; break;
#line 451 "err_inherit4.tab.c" #line 456 "err_inherit4.tab.c"
case 265: case 265:
#line 28 "err_inherit4.y" #line 28 "err_inherit4.y"
{ } { }
break; break;
#line 456 "err_inherit4.tab.c" #line 461 "err_inherit4.tab.c"
} }
} }
#define YYDESTRUCT_IS_DECLARED 1 #define YYDESTRUCT_IS_DECLARED 1
@ -465,11 +470,11 @@ YYDESTRUCT_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -653,8 +658,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -750,12 +755,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -810,7 +815,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -904,14 +909,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -920,12 +925,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -955,12 +960,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1165,7 +1170,7 @@ case 12:
#line 77 "err_inherit4.y" #line 77 "err_inherit4.y"
{ yyval.nlist = yystack.l_mark[0].nlist; yyloc = yystack.p_mark[1]; } { yyval.nlist = yystack.l_mark[0].nlist; yyloc = yystack.p_mark[1]; }
break; break;
#line 1169 "err_inherit4.tab.c" #line 1174 "err_inherit4.tab.c"
default: default:
break; break;
} }
@ -1216,8 +1221,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1320,12 +1325,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

2
contrib/byacc/test/btyacc/err_inherit5.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax1.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

56
contrib/byacc/test/btyacc/err_syntax10.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -187,6 +187,10 @@ static const YYINT err_syntax10_table[] = { 1,
}; };
static const YYINT err_syntax10_check[] = { 256, static const YYINT err_syntax10_check[] = { 256,
}; };
#if YYBTYACC
static const YYINT err_syntax10_ctable[] = { -1,
};
#endif
#define YYFINAL 2 #define YYFINAL 2
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -359,7 +363,7 @@ yyerror(const char* s)
{ {
printf("%s\n", s); printf("%s\n", s);
} }
#line 363 "err_syntax10.tab.c" #line 367 "err_syntax10.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -368,11 +372,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -556,8 +560,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -653,12 +657,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -713,7 +717,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -807,14 +811,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -823,12 +827,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -858,12 +862,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1066,8 +1070,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1170,12 +1174,12 @@ YYPARSE_DECL()
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

56
contrib/byacc/test/btyacc/err_syntax11.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -193,6 +193,10 @@ static const YYINT err_syntax11_table[] = { 1,
}; };
static const YYINT err_syntax11_check[] = { 256, static const YYINT err_syntax11_check[] = { 256,
}; };
#if YYBTYACC
static const YYINT err_syntax11_ctable[] = { -1,
};
#endif
#define YYFINAL 2 #define YYFINAL 2
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -365,7 +369,7 @@ yyerror(const char* s)
{ {
printf("%s\n", s); printf("%s\n", s);
} }
#line 369 "err_syntax11.tab.c" #line 373 "err_syntax11.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -374,11 +378,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -562,8 +566,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -659,12 +663,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -719,7 +723,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -813,14 +817,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -829,12 +833,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -864,12 +868,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1072,8 +1076,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1176,12 +1180,12 @@ YYPARSE_DECL()
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

56
contrib/byacc/test/btyacc/err_syntax12.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -194,6 +194,10 @@ static const YYINT err_syntax12_table[] = { 1,
}; };
static const YYINT err_syntax12_check[] = { 256, static const YYINT err_syntax12_check[] = { 256,
}; };
#if YYBTYACC
static const YYINT err_syntax12_ctable[] = { -1,
};
#endif
#define YYFINAL 2 #define YYFINAL 2
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -371,7 +375,7 @@ yyerror(const char* s)
{ {
printf("%s\n", s); printf("%s\n", s);
} }
#line 375 "err_syntax12.tab.c" #line 379 "err_syntax12.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -380,11 +384,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -568,8 +572,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -665,12 +669,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -725,7 +729,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -819,14 +823,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -835,12 +839,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -870,12 +874,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1078,8 +1082,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1182,12 +1186,12 @@ YYPARSE_DECL()
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

2
contrib/byacc/test/btyacc/err_syntax13.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax14.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax15.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax16.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax17.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

59
contrib/byacc/test/btyacc/err_syntax18.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -195,6 +195,11 @@ static const YYINT err_syntax18_table[] = { 1,
static const YYINT err_syntax18_check[] = { 40, static const YYINT err_syntax18_check[] = { 40,
-1, 41, 1, -1, 41, 1,
}; };
#if YYBTYACC
static const YYINT err_syntax18_ctable[] = { -1,
-1, -1,
};
#endif
#define YYFINAL 2 #define YYFINAL 2
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -367,7 +372,7 @@ yyerror(const char* s)
{ {
printf("%s\n", s); printf("%s\n", s);
} }
#line 371 "err_syntax18.tab.c" #line 376 "err_syntax18.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -376,11 +381,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -564,8 +569,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -661,12 +666,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -721,7 +726,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -815,14 +820,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -831,12 +836,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -866,12 +871,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1028,7 +1033,7 @@ case 1:
#line 9 "err_syntax18.y" #line 9 "err_syntax18.y"
{ yyval = yystack.l_mark[1]; } { yyval = yystack.l_mark[1]; }
break; break;
#line 1032 "err_syntax18.tab.c" #line 1037 "err_syntax18.tab.c"
default: default:
break; break;
} }
@ -1079,8 +1084,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1183,12 +1188,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

2
contrib/byacc/test/btyacc/err_syntax19.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax2.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

59
contrib/byacc/test/btyacc/err_syntax20.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -190,6 +190,11 @@ static const YYINT err_syntax20_table[] = { 1,
static const YYINT err_syntax20_check[] = { 40, static const YYINT err_syntax20_check[] = { 40,
257, 41, 257, 41,
}; };
#if YYBTYACC
static const YYINT err_syntax20_ctable[] = { -1,
-1,
};
#endif
#define YYFINAL 2 #define YYFINAL 2
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -362,7 +367,7 @@ yyerror(const char* s)
{ {
printf("%s\n", s); printf("%s\n", s);
} }
#line 366 "err_syntax20.tab.c" #line 371 "err_syntax20.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -371,11 +376,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -559,8 +564,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -656,12 +661,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -716,7 +721,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -810,14 +815,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -826,12 +831,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -861,12 +866,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1023,7 +1028,7 @@ case 1:
#line 12 "err_syntax20.y" #line 12 "err_syntax20.y"
{ yystack.l_mark[-1].rechk = 3; } { yystack.l_mark[-1].rechk = 3; }
break; break;
#line 1027 "err_syntax20.tab.c" #line 1032 "err_syntax20.tab.c"
default: default:
break; break;
} }
@ -1074,8 +1079,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1178,12 +1183,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

2
contrib/byacc/test/btyacc/err_syntax21.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax22.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax23.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax24.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax25.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax26.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax27.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax3.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax4.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax5.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax6.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax7.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax7a.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax7b.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax8.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax8a.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

2
contrib/byacc/test/btyacc/err_syntax9.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1

56
contrib/byacc/test/btyacc/error.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -193,6 +193,10 @@ static const YYINT error_table[] = { 1,
}; };
static const YYINT error_check[] = { 256, static const YYINT error_check[] = { 256,
}; };
#if YYBTYACC
static const YYINT error_ctable[] = { -1,
};
#endif
#define YYFINAL 2 #define YYFINAL 2
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -364,7 +368,7 @@ yyerror(const char* s)
{ {
printf("%s\n", s); printf("%s\n", s);
} }
#line 368 "error.tab.c" #line 372 "error.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -373,11 +377,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -561,8 +565,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -658,12 +662,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -718,7 +722,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -812,14 +816,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -828,12 +832,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -863,12 +867,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1071,8 +1075,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1175,12 +1179,12 @@ YYPARSE_DECL()
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

151
contrib/byacc/test/btyacc/grammar.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -794,6 +794,103 @@ static const YYINT grammar_check[] = { 38,
269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
279, 280, 281, 282, 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 #define YYFINAL 33
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -1244,7 +1341,7 @@ free_parser(void)
#endif #endif
} }
#endif #endif
#line 1248 "grammar.tab.c" #line 1345 "grammar.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -1253,11 +1350,11 @@ free_parser(void)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -1441,8 +1538,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -1538,12 +1635,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -1598,7 +1695,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -1692,14 +1789,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -1708,12 +1805,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -1743,12 +1840,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -2575,7 +2672,7 @@ case 114:
yyval.declarator->func_def = FUNC_ANSI; yyval.declarator->func_def = FUNC_ANSI;
} }
break; break;
#line 2579 "grammar.tab.c" #line 2676 "grammar.tab.c"
default: default:
break; break;
} }
@ -2626,8 +2723,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -2730,12 +2827,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

59
contrib/byacc/test/btyacc/inherit0.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -217,6 +217,11 @@ static const YYINT inherit0_check[] = { 257,
258, 259, 260, 259, 260, 0, 261, 261, 0, 6, 258, 259, 260, 259, 260, 0, 261, 261, 0, 6,
13, 13,
}; };
#if YYBTYACC
static const YYINT inherit0_ctable[] = { -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
#endif
#define YYFINAL 5 #define YYFINAL 5
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -382,7 +387,7 @@ static short *yylexemes = 0;
extern int YYLEX_DECL(); extern int YYLEX_DECL();
extern void YYERROR_DECL(); extern void YYERROR_DECL();
#line 386 "inherit0.tab.c" #line 391 "inherit0.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -391,11 +396,11 @@ extern void YYERROR_DECL();
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -579,8 +584,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -676,12 +681,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -736,7 +741,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -830,14 +835,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -846,12 +851,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -881,12 +886,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1083,7 +1088,7 @@ case 11:
#line 43 "inherit0.y" #line 43 "inherit0.y"
{ yyval = yystack.l_mark[0]; } { yyval = yystack.l_mark[0]; }
break; break;
#line 1087 "inherit0.tab.c" #line 1092 "inherit0.tab.c"
default: default:
break; break;
} }
@ -1134,8 +1139,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1238,12 +1243,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

59
contrib/byacc/test/btyacc/inherit1.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -238,6 +238,11 @@ static const YYINT inherit1_check[] = { 257,
258, 259, 260, 259, 260, 0, 261, 261, 0, 13, 258, 259, 260, 259, 260, 0, 261, 261, 0, 13,
6, 6,
}; };
#if YYBTYACC
static const YYINT inherit1_ctable[] = { -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
#endif
#define YYFINAL 5 #define YYFINAL 5
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -403,7 +408,7 @@ static short *yylexemes = 0;
extern int YYLEX_DECL(); extern int YYLEX_DECL();
extern void YYERROR_DECL(); extern void YYERROR_DECL();
#line 407 "inherit1.tab.c" #line 412 "inherit1.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -412,11 +417,11 @@ extern void YYERROR_DECL();
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -600,8 +605,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -697,12 +702,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -757,7 +762,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -851,14 +856,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -867,12 +872,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -902,12 +907,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1108,7 +1113,7 @@ case 11:
#line 71 "inherit1.y" #line 71 "inherit1.y"
{ yyval.nlist = yystack.l_mark[0].nlist; } { yyval.nlist = yystack.l_mark[0].nlist; }
break; break;
#line 1112 "inherit1.tab.c" #line 1117 "inherit1.tab.c"
default: default:
break; break;
} }
@ -1159,8 +1164,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1263,12 +1268,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

66
contrib/byacc/test/btyacc/inherit2.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -243,6 +243,12 @@ static const YYINT inherit2_check[] = { 257,
258, 259, 260, 259, 260, 0, 261, 261, 0, 14, 258, 259, 260, 259, 260, 0, 261, 261, 0, 14,
6, -1, 12, 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 #define YYFINAL 5
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -410,7 +416,7 @@ static short *yylexemes = 0;
extern int YYLEX_DECL(); extern int YYLEX_DECL();
extern void YYERROR_DECL(); extern void YYERROR_DECL();
#line 414 "inherit2.tab.c" #line 420 "inherit2.tab.c"
/* Release memory associated with symbol. */ /* Release memory associated with symbol. */
#if ! defined YYDESTRUCT_IS_DECLARED #if ! defined YYDESTRUCT_IS_DECLARED
@ -430,7 +436,7 @@ YYDESTRUCT_DECL()
} }
} }
break; break;
#line 434 "inherit2.tab.c" #line 440 "inherit2.tab.c"
case 264: case 264:
#line 30 "inherit2.y" #line 30 "inherit2.y"
{ {
@ -442,7 +448,7 @@ YYDESTRUCT_DECL()
} }
} }
break; break;
#line 446 "inherit2.tab.c" #line 452 "inherit2.tab.c"
case 265: case 265:
#line 30 "inherit2.y" #line 30 "inherit2.y"
{ {
@ -454,7 +460,7 @@ YYDESTRUCT_DECL()
} }
} }
break; break;
#line 458 "inherit2.tab.c" #line 464 "inherit2.tab.c"
} }
} }
#define YYDESTRUCT_IS_DECLARED 1 #define YYDESTRUCT_IS_DECLARED 1
@ -467,11 +473,11 @@ YYDESTRUCT_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -655,8 +661,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -752,12 +758,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -812,7 +818,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -906,14 +912,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -922,12 +928,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -957,12 +963,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1171,7 +1177,7 @@ case 13:
#line 75 "inherit2.y" #line 75 "inherit2.y"
{ yyval.nlist = yystack.l_mark[0].nlist; } { yyval.nlist = yystack.l_mark[0].nlist; }
break; break;
#line 1175 "inherit2.tab.c" #line 1181 "inherit2.tab.c"
default: default:
break; break;
} }
@ -1222,8 +1228,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1326,12 +1332,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

86
contrib/byacc/test/btyacc/ok_syntax1.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -155,7 +155,7 @@ typedef union
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif # endif
#else #else
# define YYPARSE_DECL() yyparse(int regs[26], int * base) # define YYPARSE_DECL() yyparse(int regs[26], int *base)
#endif #endif
/* Parameters sent to lex. */ /* Parameters sent to lex. */
@ -167,13 +167,13 @@ typedef union
# endif # endif
# define YYLEX yylex(&yylval, YYLEX_PARAM) # define YYLEX yylex(&yylval, YYLEX_PARAM)
#else #else
# define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base) # define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
# define YYLEX yylex(&yylval, base) # define YYLEX yylex(&yylval, base)
#endif #endif
/* Parameters sent to yyerror. */ /* Parameters sent to yyerror. */
#ifndef YYERROR_DECL #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 #endif
#ifndef YYERROR_CALL #ifndef YYERROR_CALL
#define YYERROR_CALL(msg) yyerror(regs, base, msg) #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, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258, -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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -467,7 +493,7 @@ YYLEX_DECL()
} }
return( c ); return( c );
} }
#line 471 "ok_syntax1.tab.c" #line 497 "ok_syntax1.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -476,11 +502,11 @@ YYLEX_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -714,8 +740,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -811,12 +837,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -871,7 +897,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -965,14 +991,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -981,12 +1007,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -1016,12 +1042,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1234,7 +1260,7 @@ case 18:
#line 101 "ok_syntax1.y" #line 101 "ok_syntax1.y"
{ yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; } { yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
break; break;
#line 1238 "ok_syntax1.tab.c" #line 1264 "ok_syntax1.tab.c"
default: default:
break; break;
} }
@ -1285,8 +1311,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1389,12 +1415,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

80
contrib/byacc/test/btyacc/pure_calc.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 256, 257, 258, 257, 258, -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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -440,7 +466,7 @@ YYLEX_DECL()
} }
return( c ); return( c );
} }
#line 444 "pure_calc.tab.c" #line 470 "pure_calc.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -449,11 +475,11 @@ YYLEX_DECL()
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -687,8 +713,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -784,12 +810,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -844,7 +870,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -938,14 +964,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -954,12 +980,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -989,12 +1015,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1207,7 +1233,7 @@ case 18:
#line 69 "pure_calc.y" #line 69 "pure_calc.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1211 "pure_calc.tab.c" #line 1237 "pure_calc.tab.c"
default: default:
break; break;
} }
@ -1258,8 +1284,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1362,12 +1388,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

56
contrib/byacc/test/btyacc/pure_error.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 1 #define YYMAJOR 1
@ -205,6 +205,10 @@ static const YYINT error_table[] = { 1,
}; };
static const YYINT error_check[] = { 256, static const YYINT error_check[] = { 256,
}; };
#if YYBTYACC
static const YYINT error_ctable[] = { -1,
};
#endif
#define YYFINAL 2 #define YYFINAL 2
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -330,7 +334,7 @@ yyerror(const char* s)
{ {
printf("%s\n", s); printf("%s\n", s);
} }
#line 334 "pure_error.tab.c" #line 338 "pure_error.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -339,11 +343,11 @@ yyerror(const char* s)
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -577,8 +581,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -674,12 +678,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -734,7 +738,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -828,14 +832,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -844,12 +848,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -879,12 +883,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1087,8 +1091,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1191,12 +1195,12 @@ YYPARSE_DECL()
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

84
contrib/byacc/test/btyacc/quote_calc-s.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
261, 261, 263, 263, 265, 265, 267, 267, 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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -490,7 +520,7 @@ yylex(void) {
} }
return( c ); return( c );
} }
#line 494 "quote_calc-s.tab.c" #line 524 "quote_calc-s.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -499,11 +529,11 @@ yylex(void) {
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -687,8 +717,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -784,12 +814,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -844,7 +874,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -938,14 +968,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -954,12 +984,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -989,12 +1019,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1207,7 +1237,7 @@ case 18:
#line 70 "quote_calc.y" #line 70 "quote_calc.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1211 "quote_calc-s.tab.c" #line 1241 "quote_calc-s.tab.c"
default: default:
break; break;
} }
@ -1258,8 +1288,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1362,12 +1392,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

84
contrib/byacc/test/btyacc/quote_calc.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
261, 261, 263, 263, 265, 265, 267, 267, 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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -496,7 +526,7 @@ yylex(void) {
} }
return( c ); return( c );
} }
#line 500 "quote_calc.tab.c" #line 530 "quote_calc.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -505,11 +535,11 @@ yylex(void) {
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -693,8 +723,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -790,12 +820,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -850,7 +880,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -944,14 +974,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -960,12 +990,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -995,12 +1025,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1213,7 +1243,7 @@ case 18:
#line 70 "quote_calc.y" #line 70 "quote_calc.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1217 "quote_calc.tab.c" #line 1247 "quote_calc.tab.c"
default: default:
break; break;
} }
@ -1264,8 +1294,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1368,12 +1398,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

84
contrib/byacc/test/btyacc/quote_calc2-s.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
260, 262, 262, 264, 264, 266, 266, 268, 268, 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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -490,7 +520,7 @@ yylex(void) {
} }
return( c ); return( c );
} }
#line 494 "quote_calc2-s.tab.c" #line 524 "quote_calc2-s.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -499,11 +529,11 @@ yylex(void) {
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -687,8 +717,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -784,12 +814,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -844,7 +874,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -938,14 +968,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -954,12 +984,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -989,12 +1019,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1207,7 +1237,7 @@ case 18:
#line 70 "quote_calc2.y" #line 70 "quote_calc2.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1211 "quote_calc2-s.tab.c" #line 1241 "quote_calc2-s.tab.c"
default: default:
break; break;
} }
@ -1258,8 +1288,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1362,12 +1392,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

84
contrib/byacc/test/btyacc/quote_calc2.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
260, 262, 262, 264, 264, 266, 266, 268, 268, 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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -496,7 +526,7 @@ yylex(void) {
} }
return( c ); return( c );
} }
#line 500 "quote_calc2.tab.c" #line 530 "quote_calc2.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -505,11 +535,11 @@ yylex(void) {
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -693,8 +723,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -790,12 +820,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -850,7 +880,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -944,14 +974,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -960,12 +990,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -995,12 +1025,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1213,7 +1243,7 @@ case 18:
#line 70 "quote_calc2.y" #line 70 "quote_calc2.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1217 "quote_calc2.tab.c" #line 1247 "quote_calc2.tab.c"
default: default:
break; break;
} }
@ -1264,8 +1294,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1368,12 +1398,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

84
contrib/byacc/test/btyacc/quote_calc3-s.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
261, 261, 263, 263, 265, 265, 267, 267, 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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -491,7 +521,7 @@ yylex(void) {
} }
return( c ); return( c );
} }
#line 495 "quote_calc3-s.tab.c" #line 525 "quote_calc3-s.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -500,11 +530,11 @@ yylex(void) {
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -688,8 +718,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -785,12 +815,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -845,7 +875,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -939,14 +969,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -955,12 +985,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -990,12 +1020,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1208,7 +1238,7 @@ case 18:
#line 70 "quote_calc3.y" #line 70 "quote_calc3.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1212 "quote_calc3-s.tab.c" #line 1242 "quote_calc3-s.tab.c"
default: default:
break; break;
} }
@ -1259,8 +1289,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1363,12 +1393,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

84
contrib/byacc/test/btyacc/quote_calc3.tab.c
View File

@ -1,6 +1,6 @@
/* original parser id follows */ /* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ /* 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 YYBYACC 1
#define YYMAJOR 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, 263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
261, 261, 263, 263, 265, 265, 267, 267, 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 #define YYFINAL 1
#ifndef YYDEBUG #ifndef YYDEBUG
#define YYDEBUG 0 #define YYDEBUG 0
@ -491,7 +521,7 @@ yylex(void) {
} }
return( c ); return( c );
} }
#line 495 "quote_calc3.tab.c" #line 525 "quote_calc3.tab.c"
/* For use in generated program */ /* For use in generated program */
#define yydepth (int)(yystack.s_mark - yystack.s_base) #define yydepth (int)(yystack.s_mark - yystack.s_base)
@ -500,11 +530,11 @@ yylex(void) {
#endif /* YYBTYACC */ #endif /* YYBTYACC */
#if YYDEBUG #if YYDEBUG
#include <stdio.h> /* needed for printf */ #include <stdio.h> /* needed for printf */
#endif #endif
#include <stdlib.h> /* needed for malloc, etc */ #include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */ #include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data) static int yygrowstack(YYSTACKDATA *data)
@ -688,8 +718,8 @@ YYPARSE_DECL()
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
@ -785,12 +815,12 @@ YYPARSE_DECL()
save->state = yystate; save->state = yystate;
save->errflag = yyerrflag; save->errflag = yyerrflag;
save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
ctry = yytable[yyn]; ctry = yytable[yyn];
if (yyctable[ctry] == -1) if (yyctable[ctry] == -1)
@ -845,7 +875,7 @@ YYPARSE_DECL()
yylexp--; yylexp--;
yychar = YYEMPTY; yychar = YYEMPTY;
} }
save->lexeme = yylvp - yylvals; save->lexeme = (int) (yylvp - yylvals);
yyps->save = save; yyps->save = save;
} }
if (yytable[yyn] == ctry) if (yytable[yyn] == ctry)
@ -939,14 +969,14 @@ YYPARSE_DECL()
yyerrctx->state = yystate; yyerrctx->state = yystate;
yyerrctx->errflag = yyerrflag; yyerrctx->errflag = yyerrflag;
yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 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 #endif
yyerrctx->lexeme = yylvp - yylvals; yyerrctx->lexeme = (int) (yylvp - yylvals);
} }
yylvp = yylvals + save->lexeme; yylvp = yylvals + save->lexeme;
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
@ -955,12 +985,12 @@ YYPARSE_DECL()
yylexp = yylexemes + save->lexeme; yylexp = yylexemes + save->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 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 #endif
ctry = ++save->ctry; ctry = ++save->ctry;
yystate = save->state; yystate = save->state;
@ -990,12 +1020,12 @@ YYPARSE_DECL()
yylloc = yylpp[-1]; yylloc = yylpp[-1];
#endif #endif
yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 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 #endif
yystate = yyerrctx->state; yystate = yyerrctx->state;
yyFreeState(yyerrctx); yyFreeState(yyerrctx);
@ -1208,7 +1238,7 @@ case 18:
#line 70 "quote_calc3.y" #line 70 "quote_calc3.y"
{ yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
break; break;
#line 1212 "quote_calc3.tab.c" #line 1242 "quote_calc3.tab.c"
default: default:
break; break;
} }
@ -1259,8 +1289,8 @@ break;
/* in trial mode; save scanner results for future parse attempts */ /* in trial mode; save scanner results for future parse attempts */
if (yylvp == yylvlim) if (yylvp == yylvlim)
{ /* Enlarge lexical value queue */ { /* Enlarge lexical value queue */
int p = yylvp - yylvals; size_t p = (size_t) (yylvp - yylvals);
int s = yylvlim - yylvals; size_t s = (size_t) (yylvlim - yylvals);
s += YYLVQUEUEGROWTH; s += YYLVQUEUEGROWTH;
if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
@ -1363,12 +1393,12 @@ break;
yylexp = yylexemes + yypath->lexeme; yylexp = yylexemes + yypath->lexeme;
yychar = YYEMPTY; yychar = YYEMPTY;
yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 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); 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) #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 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 #endif
yystate = yypath->state; yystate = yypath->state;
goto yyloop; goto yyloop;

Some files were not shown because too many files have changed in this diff Show More