295 Commits
Author SHA1 Message Date
Will Estes ab49343b08 gettext: pulled latest translations; recompiled against current sources 2017-05-06 16:34:36 -04:00
Will Estes 0cfad78b32 version 2.6.4
* NEWS: Record release date.
2017-05-06 16:34:35 -04:00
Will Estes 31cdc1f095 note previous version 2017-05-06 16:34:35 -04:00
Will Estes 3d843a0f8d doc: update NEWS for upcoming release 2017-05-06 16:34:35 -04:00
viktor.shepel 7889866f58 doc: Correct typo in C code sample in manual 2017-05-06 10:56:29 -04:00
Explorer09 e5c7ad3aec scanner: Mention %# comments are removed when building skel.c 2017-05-06 10:51:48 -04:00
Demi Obenour a1634aa8d3 Honor user definitions of yy_* macros
The user may have defined the yy_* macros themselves.  In that case,
don't clobber them.
2017-05-03 16:16:37 -04:00
Demi Obenour d564d45477 Don't leak macro definitions into header files
This allowed unnamespaced definitions to leak into header files,
breaking client code.

Fixes #142
2017-05-03 16:16:37 -04:00
Demi Obenour ba530cd52f scanner: Check for 0 bracecount when EOL ends quoted literal.
This can happen in the case of // comments (which Flex doesn't handle
specially).
2017-05-03 16:13:39 -04:00
Demi Obenour b1c2957b3f scanner: when bracelevel is negative, treat as zero.
This really should never happen, but this at least fixes the
breakage on Verilator.
2017-05-03 16:13:02 -04:00
Jeff Smith 8b746fa025 test: enable more silent building of tests.
When running 'make V=0 check', some compile and link steps are made
less verbose and some are not.  This cleans up most steps that are
not.

These have no effect if V=0 is not specified.
2017-05-03 14:27:42 -04:00
Demi Obenour 2f21edac99 build: Delete comments from skeleton file.
Since the comments in flex.skl are, by hypothesis, not needed in
skel.c, we remove them. THis reduces the size of the resulting
executable somewhat.
2017-05-03 13:24:09 -04:00
Explorer09 2592576239 build: do not generate lib/Makefile.in.
Files in lib/ are picked up and built using makefile directives in
src/Makefile.am. Remove the need to generate lib/Makefile.in and the
stub lib/Makefile.am.
2017-05-03 13:14:16 -04:00
Will Estes 9131b8426a gettext: revert listing generated .c files 2017-05-02 20:39:15 -04:00
Jeff Smith 88b8e2a9d5 FLEX_EXIT() is the preferred way to exit flex 2017-05-02 15:31:05 -04:00
Explorer09 47d6a45345 Fix myesc() 'sptr' conditionals
* Don't call isascii() here. It's deprecated in POSIX and not needed
  for myesc's case.
* The check of the character class and range here should match what's
  defined as {ESCSEQ} in scan.l, so for [[:xdigit:]] we use isxdigit();
  for [0-7] we check '0' <= c <= '7' (not isdigit(c) because isdigit is
  locale-dependant in standard's sense)
* Add missing length limit for "\x<hex>" (<hex> is at most 2 digits)
2017-05-02 15:14:25 -04:00
Explorer09 d4ab90f185 Obsolete htoui() and otoui(); use strtoul().
No sense to keep these two function when libc's strtoul() can do the
same job, but better.
2017-05-02 15:14:25 -04:00
Todd C. Miller 09697fb269 scanner: update yy_buf_size after yyrealloc() 2017-05-02 15:08:10 -04:00
Simon Sobisch c2ceb3e129 build: use lowest versions for gettext, automake. 2017-05-02 14:56:59 -04:00
Simon Sobisch 5b30b23fe9 gettext: more recent makevars; new script to update po files.
Previously, "make dist" and similar commands would cause the po files
to be updated, which is incorrect. The more recent version now used
should not do this.

Replaced Rules-getpo by extra script to manually update and rebuild all po files.
2017-05-02 14:56:59 -04:00
Simon Sobisch 3211921c23 gettext: list generated files instead of flex, bison sources in POTFILES.in.
Listing the flex and bison sources -- as the gettext manual suggests
-- causes warnings. Listing the generated C files for the lexer and
parser removes the warnings. Since both files contain line directives,
any translator who needs to refer back to those files should be able
to find the context in which strings are needed.
2017-05-02 14:56:38 -04:00
Simon Sobisch 4efcf28ee6 build: only touch ChangeLog if it does not exist 2017-05-02 14:43:49 -04:00
Simon Sobisch 634ef8a945 build: list earliest useable versions for automake 2017-05-02 14:43:49 -04:00
Simon Sobisch 0a9687d138 build: check for how to call libtoolize.
Previously, we would call libtoolize and if that failed, we would call
glibtoolize since some platforms have the libtoolize program under
that name.

Instead, we check to see if the environment variable LIBTOOLIZE is set
and use that if so. Otherwise, we try to find a program "libtoolize"
on the path and failing that glibtoolize. We alert the user if no
suitable program can be found.
2017-05-02 14:43:49 -04:00
Alastair Hughes 89f10ee36f build: support cross compiling.
Check for cross compiling. If cross compiling, build stage1flex using a
custom link command.
We also override LDADD since that adds the replacement implementations
that are cross compiled, and instead always use the replacement library
implementations.

We don't use BUILD_OBJEXT and BUILD_EXEEXT since it seems that automake
does not support these.

Fixes #78.
2017-02-23 14:07:56 -05:00
Explorer09 d1b195b671 build: Include <strings.h>; add strcasecmp() check to configure.
strings.h (not string.h) is the standard-defined include header for
strcasecmp(). Include <strings.h> for portability (even though glibc
exposes strcasecmp() declaration also in <string.h> by default).
2017-02-17 16:56:21 -05:00
Explorer09 dbb4e94dc7 build: Let configure error if missing required functions, headers..
`configure` will now error if a required header or function is not
found on the system.

Also add comments on optional functions checks.

Add sys/stats.h and sys/wait.h to list of required headers in
configure.

This fixes issue #180.
2017-02-17 16:55:33 -05:00
Explorer09 c7a545ae09 scanner: compute powers of two faster.
Replace the naive "for" loop in determining power of two with a clever
bitwise solution. This code is around the Internet already and is in
Public Domain.
2017-02-16 13:26:21 -05:00
Explorer09 122e58965a test: skip pthread test when needed files missing.
"Unlisting" the pthread test when libpthread is not available is never
a good idea. Should let it compile into a stub program that returns
the "skip" status.

configure.ac and tests/Makefile.am are edited so that pthread test can
be built anyway, but only works (not as the stub) when both pthread.h
and libpthread are detected on the system.

Also fix a small typo in tests/pthread.l comments.
2017-02-16 09:33:35 -05:00
Will Estes 2e820b6015 build: mv scan.c when building dist.
Revert change to copy scan.c when building the distribution
archive. Move it instead. This satisfies automake's notions of what
should be clean and ensures that the distribution archive contains a
just-built copy of scan.c.

Fixes #186
2017-02-16 09:27:22 -05:00
Will Estes 44f10b366f build: don't assume distdir/scan.c is writeable 2017-02-06 12:04:03 -05:00
Explorer09 a7adbf20a9 build: Add dist-hook to force remake scan.c.
This will ensure the flex scanner included in release tarball being
generated by exactly the flex version to be released.

Here's one catch after this change: You may not run "make dist" or
"make distdir" if you configure the flex source to be cross-compiled.
2017-02-06 11:48:05 -05:00
Explorer09 dae5c22f87 build: respect '--localedir' from configure.
Makefile shouldn't overwrite the 'localedir' variable, because that's
what '--localedir' option in 'configure' is for.
2017-02-06 11:45:09 -05:00
Explorer09 dec3a380e5 build: Remove "-I$(top_srcdir)/intl" from CPPFLAGS.
Revert commit e02c3d27ee

("include the intl/ subdirectory when searching for include files")

Flex doesn't come with libintl source code, so inclusion of
$(top_srcdir)/intl subdirectory during compiling is unnecessary.

This flag seems to be left after "remove intl from dist"
(commit 8f45da06ad) without someone
cleaning this up.

Users who need to build with gettext functionality from libintl would
use the '--with-libintl-prefix' configure option.
2017-02-06 11:44:13 -05:00
Explorer09 e2d569053a scanner: fix regcomp's error reporting, double malloc.
Fix unneeded double malloc - let regerror(). Write its message after
our "regcomp for (regex) failed: " string.

Also, errbuf cannot be free()'d because of flexfatal containing a
longjmp.
2017-02-06 11:37:18 -05:00
Explorer09 3c0ccc4520 test: Skip bison tests if bison is not available 2017-01-25 10:33:06 -05:00
Explorer09 546851ba35 build: remove repeated bison detection from configure.
AC_PROG_YACC already detects the bison program. We can just use it,
and make notice if [ $YACC != 'bison -y' ]

Remove unused AC_SUBST([BISON], ...).

Add AM_CONDITIONAL([HAVE_BISON], ...) so that we can skip bison tests
in testsuite when bison is absent.

We don't make any attempt to detect other yacc implementations since
flex is developed with bison. While it would be possible, the need
isn't there right now. It would be possible to add a --with-parser
option that defaulted to bison if such a need cropped up.
2017-01-25 10:29:26 -05:00
Explorer09 a2fccbe579 build: fix Makefile parse.h dependency clauses.
The current clauses stating "main.c: parse.h" and "yylex.c: parse.h" do
not work as expected. Make did not try to build parse.h upon building
flex-main.o as it would think main.c exist already and ignore the
clause. Fix this by explicitly stating that the .o files depend on
parse.h instead.

This dependency bug only happens if user builds flex from a
checked-out repository.
2017-01-24 12:07:06 -05:00
Explorer09 e8cb34ed48 test: Remake *_scanner.c if *_scanner.h is missing.
If a ${foo}_scanner.c exists but the respective ${foo}_scanner.h is
missing, then 'make' can halt. Fix this by deleting the
${foo}_scanner.c file and then remake it. This rule is the same as the
automake-generated rule for .c files that require LEX or YACC (except
automake will use ylwrap).
2017-01-24 11:56:09 -05:00
Explorer09 afc687f586 test: remove BUILT_SOURCES; add missing dependencies.
Without BUILT_SOURCES in Makefile, no test sources in tests/ will be
built when using the default "make all" target. This is desireable for
people who are just building flex but who do not want to run, and
therefore, build any part of the test suite.

Also fix missing sources dependencies:

    bison_nr_scanner.$(OBJEXT): bison_nr_parser.h
    bison_yylloc_scanner.$(OBJEXT): bison_yylloc_parser.h
    bison_yylval_scanner.$(OBJEXT): bison_yylval_parser.h
2017-01-24 11:53:46 -05:00
Explorer09 9c54eb6e30 build: detect overflow for [re]allocate_array.
Use reallocarray() when we have it (i.e. in OpenBSD system). When we
don't, use equivalent overflow detection for our allocate_array and
reallocate_array functions.

Remove lib/reallocarray.c from our LIBOBJS as we no longer need it.

Provide a fallback SIZE_MAX macro definition in flexint.h (not
preprocessor friendly, but enough for our reallocate_array use case).
2017-01-24 07:36:50 -05:00
Will Estes 7e4d538724 doc: v2.6.4 2017-01-23 14:25:11 -05:00
Thomas Klausner 0a89eef5dc build: more BSD make and vpath build fixes.
BSD make doesn't like $< with more than one source
specified. Additionally, make sure to specify srcdir when referring to
source files since vpath builds depend on this.
2017-01-23 13:48:15 -05:00
Thomas Klausner b61b0fe906 build: Fix skel.c generation with BSD make 2017-01-23 13:45:34 -05:00
Christos Zoulas 078b46c69d Add more defines in the non-reentrant part.
Fix the reentrant part; don't "#define yyfoo yyfoo" because it breaks
code that does #ifndef yywrap ..
2017-01-23 13:39:49 -05:00
Christos Zoulas 726c8dab23 scanner: Add yyparse prototype 2017-01-23 13:38:58 -05:00
Thomas Klausner 6bf98d9aea scanner: move comment for consistency 2017-01-23 13:35:26 -05:00
Christos Zoulas 1a9468797d scanner: Use array instead of pointer 2017-01-23 13:32:40 -05:00
Christos Zoulas 43a5bebd7d scanner: manage path to m4 better.
Avoid alloca() for SSP; it is better anyway; since we don't need to
strdup the path.
2017-01-23 12:31:21 -05:00
Christos Zoulas fb175a49c3 scanner: Avoid creating unused label 2017-01-23 12:06:53 -05:00
Christos Zoulas f01ab4fe02 Cast argument to avoid arithmetic on void *. 2017-01-23 11:42:14 -05:00
Christos Zoulas 7ca76038df scanner: Use strncpy 2017-01-23 11:38:36 -05:00
Christos Zoulas f5d87f1a26 scanner: Use prefix when defining yywrap to avoid redefinition.
Fixes regression introduced in v2.6.3.
2017-01-23 11:35:19 -05:00
Christos Zoulas 6f47a5232c scanner: Include stdarg.h for va_list 2017-01-23 11:27:51 -05:00
Christos Zoulas d0d0573900 scanner: Rename warn to lwarn.
This avoids a naming conflict in NetBSD's  libc.
2017-01-23 11:01:54 -05:00
Explorer09 da071cfb7a test: document automake convention for skipped exit status. 2017-01-20 11:06:06 -05:00
Explorer09 dd7c6d4a0f test: let testwrapper scripts be run by ${SHELL}.
This allows user to use a different shell if /bin/sh has problems.
The use of $SHELL (variable) to run scripts is already an Automake
convention. All shell scripts in build-aux are run by $SHELL.
2017-01-17 21:10:42 -05:00
Explorer09 bcf7a07369 test: Remove test scripts bashisms.
They now all work under a POSIX compliant sh. Specifically, 'dash' can
now be used for running "make check" tests.

Note that none of these scripts has ever been using a pipe, so
`set -o pipefail` is unnecessary and removed.
2017-01-17 21:10:16 -05:00
Explorer09 8c8691c3fd test: exit on '-1' test non-zero status.
If a '-1' test program returns a non-zero status, don't go further and
compare it's (numeric) output values. This allows a '-1' test to
indicate a "skip" status or an otherwise error. (Currently no such '-1'
test would skip like this, though.)

Shell syntax note: `set -e` will not exit with the syntax like this
`test $(false) = $(false);`. The exit statuses of `false` in the
example will be ignored instead. But putting the output in a variable,
such as `VAR=$(false)`, DOES exit.
2017-01-17 21:08:42 -05:00
Explorer09 bb92951c02 build: Fix 'make indent' target
This 'make indent' target has not been working since the directories
reorganization in flex 2.6.0. Now make it work again.

Note that the current indent profile breaks many styles of existing
code. The indent target should not be used until the .indent.pro
options are reviewed for desireability.
2017-01-12 18:02:24 -05:00
Explorer09 8db5267af4 build: Simplify indent program detection 2017-01-12 18:01:57 -05:00
Tobias Klauser de0c5e91df filter: Don't emit #line if %option noline set
One place emitting a #line directive to the generated header was
missed in commit 647a92b9f4 when resolving #55. Fix it to respect
gen_line_dirs as well.
2017-01-12 17:44:00 -05:00
Will Estes 84a9a4b9fc translation: refresh po files from translation project 2017-01-12 13:22:02 -05:00
Harald van Dijk e666829949 c++: Fix yyrestart(NULL) SEGV.
Binding a reference to a dereferenced null pointer is invalid and
compilers optimise away the &file == 0 check. We need a real stream.

yyin is available already, and yyrestart(NULL) is only supported when
yyin will not be used, so there is no harm in just passing in that.
Since we now always have a valid stream, we can skip the null check
too.

Fixes #98.
2017-01-11 21:04:28 -05:00
luistung 7f263e3520 scanner: join symbol list.
Removed a newline that caused a problem building the scanner in some
circumstances. Specifically:

'bad character' error  when executing

/bin/sh ../build-aux/ylwrap scan.l lex.yy.c scan.c -- flex
2017-01-11 09:09:15 -05:00
Will Estes a58086a269 scanner: remove void cast before fprintf 2017-01-11 09:05:18 -05:00
Will Estes 581ef6d17f doc: update NEWS for 2.6.3 release 2016-12-30 12:48:24 -05:00
Explorer09 adddfba7ab build: New configure option '--disable-bootstrap'.
If configure is run with '--disable-bootstrap', then stage1flex won't
be built and stage1scan.c will be generated by sed'ing scan.c.

This option is intended to workaround bootstrap bugs rather than to
fix the bootstrapping issues which are proving subtler and harder to
fix than anyone would like.
2016-12-29 17:26:07 -05:00
Explorer09 6964073c59 build: "make clean" deletes stage1scan.c, stage1flex 2016-12-29 17:25:19 -05:00
Explorer09 935478c3fe build: allow building libfl even with --disable-libfl.
For various reasons, we may wish to build libfl explicitly even when
configure has been run with the --disable-libfl option. This is
possible, now, via 'make -C src libfl.la'.
2016-12-29 17:19:53 -05:00
Alexis La Goutte a33e6fd5b4 scanner: remove trailing whitespace in skeleton 2016-12-29 15:11:11 -05:00
Demi Obenour 8d4aa5ccaf scanner: Disallow, overquote '[' and ']' in prefix 2016-12-29 14:18:15 -05:00
Samuel Thibault 7975c43384 scanner: allocate correct buffer size for m4 path.
Flex did not check the length of the m4 path which could lead to a
buffer overflow in some cases. Additionally, not all platforms believe
in PATH_MAX, so stop relying on it.

Fixes #138
2016-12-29 08:47:10 -05:00
Will Estes 6bea32e937 doc: note no more libcompat in NEWS 2016-11-24 18:50:21 -05:00
Will Estes 223f297825 build: explain empty lib/Makefile.am 2016-11-24 18:50:21 -05:00
Explorer09 44fa758931 build: warn about cross compiling with *alloc 2016-11-24 18:48:28 -05:00
Explorer09 713f5a0cb4 build: Link $(LIBOBJS) from src/ dir, remove libcompat.la.
The libcompat.la library was small and less friendly to bootstrapping
and cross compilation. Now, we will simply link individual object
files as needed, which is simpler.
2016-11-24 18:45:07 -05:00
Explorer09 11c445cde9 build: Let stage1flex respect LFLAGS 2016-11-15 19:26:08 -05:00
Will Estes 99612781d9 doc: describe --disable-libfl in NEWS 2016-11-14 14:26:48 -05:00
Explorer09 5d71e9ffb9 build: Add --disable-libfl configure option.
Disabling libfl is useful when building flex for a cross-toolchain.

Fixes: GH-99
2016-11-14 14:23:27 -05:00
Demi Obenour 347652c32b fix backwards incompatible changes in 2.6.2.
This patch addscompatibility `#defines` for all macros affected by
`%prefix`.

Fixes #113.
2016-11-12 12:00:12 -05:00
Will Estes d374b87e68 git: ignore quote_in_comment artifacts 2016-11-08 12:53:21 -05:00
Demi Obenour c8ad3d682f Fixes a major bug in Flex's own lexing of literals.
My changes caused Flex to mishandle string and character literals in
line comments.  This commit fixes them.

Fixes #113.
2016-11-08 12:49:44 -05:00
Thomas Klausner 0af671a275 Fix unportable test(1) operator.
"==" is only supported by bash, "=" is the standard comparison
operator.
2016-11-06 22:32:43 +01:00
Demi Obenour 14846e5e1a Add more escaping tests 2016-11-02 13:22:02 -04:00
Demi Obenour e1038db19a Fix another escaping bug
in non-indented verbatim section 2 code.

I also did some reformatting.
2016-11-01 20:20:46 -04:00
Alastair Hughes 75f4305eed build: fix false negatives for help2man and texi2dvi
HELP2MAN and TEXI2DVI (or the corresponding ac_prog variables) will
never be zero length as they fall back to the missing script; check for
the fall back and warn on that instead of always warning.
2016-10-29 09:11:20 -04:00
Explorer09 c503eaf061 doc: Don't delete flex.1 during "make distclean".
flex.1 is pre-generated in release tarball. If we delete it, the next
"configure and make" on the source directory will then require help2man
unnecessarily.
2016-10-28 19:48:11 -04:00
Alastair Hughes 92311a56b3 Only regenerate the man page when required.
Make the flex binary an order-only prerequisite, and add back the
prerequisites from before 7cfb440. This prevents rebuilding the man page
whenever the flex binary is rebuilt, which causes problems if help2man
is not installed and will never work when cross compiling.

Fixes #108.
2016-10-27 17:55:46 -04:00
Will Estes 2bf2ad6d68 build: no longer build PIC version of libfl.
The PIC version of libfl was not being built correctly. From the lack
of bug reports around this problem, we conclude that the PIC version
of libfl is not used and so we drop it from the build build targets
for flex.
2016-10-26 14:09:36 -04:00
Explorer09 023cd4f754 doc: README.md formatting fixes
* Wrap everything in the raw document in 72 char per line limit.
* Proper casing for terms "Git" and "GitHub" (don't try to look lazy).
* Add unordered list marks when needed.
* Say `configure && make && make install` and quoted for fixed-width
  font.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
2016-10-25 10:20:35 -04:00
Will Estes 31cc18ebd0 build: version 2.6.3 begins 2016-10-25 09:53:50 -04:00
Will Estes 35d2fdfad1 doc: mark 2.6.2 release date 2016-10-24 18:29:36 -04:00
Will Estes 2ecf674239 build: switch xz to lzip 2016-10-24 18:26:22 -04:00
Demi Obenour b02489f588 Fix M4 quotation in section 2 prologue and refactor duplicated code 2016-10-23 14:04:42 -04:00
Alex Kennedy 802cd0a6ed Update flex.texi: Removed repedative wording
"Flex used to" was written twice at the beginning of Chapter 9, paragraph 2.
2016-10-21 20:42:36 -07:00
Demi Obenour 4bffa41e4e Improved M4 quotation
This fixes M4 quotation of certain strings beginning with `yy` (in
section 3 of the input file only) and character literals.  The new
quotation method is also less brittle and faster.

Tests that relied on the old behavior were fixed.

Also, `yyconst` is no longer defined; use `const` (which it
unconditionally was defined to) instead.
2016-10-19 20:39:06 -04:00
Will Estes 7dcb10c048 build: for automake, flex is foreign 2016-10-19 17:00:50 -04:00
Will Estes 9a4ae5d619 doc: mv README to README.md 2016-10-19 10:27:23 -04:00
Will Estes 2ad733a56e doc: touch up README 2016-10-19 10:26:44 -04:00
Will Estes 507f96a5ff doc: README no longer mentions sourceforge 2016-10-19 05:25:36 -04:00
Will Estes 17bf278ad7 doc: update NEWS with more post-2.6.1 additions 2016-10-06 16:39:04 -04:00
Demi Obenour 9d3ddf572e Fix M4 quoting of section 3.
This fixes M4 quoting of section 3 of the input file, including escape
sequences and character constants.

Tests were added to verify the behavior in section 3 with respect to
quoting. Both escaping of quotes and quoting of potential macro-start
characters are tested. Existing tests were also fixed to account for the new -- and now correct -- behavior. Many tests relied on the old behavior of expanding M4 macros
in section 3.  They needed to be updated for the new behavior.
2016-10-05 19:25:56 -04:00
Mightyjo 735ffb6a65 Fix yyrestart(NULL) SEGV. 2016-10-05 17:19:03 -04:00
Demi Obenour ee87e5df00 scanner: M4 quoting fixes 2016-09-25 19:40:10 -04:00
Demi Obenour 749a8c80f7 Support make indent for out of source builds 2016-09-25 19:40:10 -04:00
Demi Obenour fb91984b3b Simplify some shell code 2016-09-25 18:53:29 -04:00
Demi Obenour e50d903620 no longer generate K&R C scanners 2016-09-25 16:12:14 -04:00
Demi Obenour 7528bc0aee Fix escaping of [[ and ]] in strings
Previously, `[[` and `]]` were not escaped in strings, which led
to bad interactions with m4.

Also, don't break strings on newline, as GCC et al support whitespace
between a backslash and the subsequent newline.
2016-09-04 18:29:30 -04:00
Translation Project b22b8fdb97 new sv translation 2016-06-20 09:17:57 -04:00
Demetri Obenour 925549475e Delete action_m4_define from misc.c
This function was not used and always triggered a fatal error when run.
2016-05-23 17:36:33 -04:00
Will Estes 7878f90988 test: run direct tests from srcdir 2016-05-20 17:31:27 -04:00
Egor Pugin 1b7a7165f3 Exited with error code on some conditions in include tests 2016-05-20 17:31:27 -04:00
Will Estes 98fd512f9a test: drop .exe when making input file names 2016-05-20 17:31:27 -04:00
Will Estes 0cc66ab7fd test: removed dependencies for include tests 2016-05-20 14:09:29 -04:00
Tobias Klauser 0afeed389c Avoid realloc on every call of sf_push()
Currently, every call to sf_push() realloc()'s _sf_stack, even if the
maximum size _sf_max wasn't changed. As the indentation beneath the
"if" clause already indicates, the realloc() should only be executed
if _sf_max was increased.

Found by compiling flex with the -Wmisleading-indentation flags of gcc,
which leads to the following warning:

scanflags.c: In function ‘sf_push’:
scanflags.c:42:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
     if (_sf_top_ix + 1 >= _sf_max)
     ^~
scanflags.c:44:9: note: ...this statement, but the latter is misleadingly indented as if it is guarded by the ‘if’
         _sf_stk = realloc(_sf_stk, sizeof(scanflags_t) * _sf_max);
         ^~~~~~~
2016-04-28 10:18:21 +02:00
Will Estes 2061043d3d build: prettified command to build man page 2016-03-31 18:47:00 -04:00
Will Estes 84ca965d1f build: added man page to DISTCLEANFILES 2016-03-31 18:46:23 -04:00
Will Estes 9f2343bf65 remove unused TODO, BUGS files 2016-03-31 16:09:28 -04:00
Will Estes ad46bcf9cd removed to.do/ directory 2016-03-31 15:58:16 -04:00
Will Estes e15146bbaa gettext: removed flex.skl from POTFILES.in file list 2016-03-31 13:36:09 -04:00
rlar 4db9c203f6 fix skel.c dependency (missing tables_shared.c) and
polish build rule

Also remove references to srcdir since skel.c is no longer mentioned in po/POTFILES.in.
2016-03-31 11:19:20 -04:00
rlar 7cfb440c7c fix flex.1 dependency
git clean -fdx && ./autogen.sh && \
  mkdir -p ../build && cd ../build && ../flex/configure && make -j10 && \
  make dist

failed with:

>  help2man: can't get `--help' info from ../../flex/src/flex

Note:
  There is no dependency except for the flex binary.
2016-03-31 10:51:19 -04:00
rlar 39cff7e239 fix stage1scan.c and stage1scan.l dependency
git clean -fdx && ./autogen.sh && \
  mkdir -p ../build && cd ../build && ../flex/configure && make -j10

failed with:

> ../src/stage1flex -o stage1scan.c stage1scan.l
> stage1flex: can't open stage1scan.l

Note:
  stage1scan.c is not necessairy in the "make dist" generated tar.gz file.
  stage1flex will be build from scan.c (which is distributed),
    and this will then generate stage1scan.c from scan.l
2016-03-31 10:47:00 -04:00
Will Estes 07a1d30ba3 gettext: list src/flex.skl in po/POTFILES.in 2016-03-31 10:21:56 -04:00
rlar 8d09d89c33 warning in generated code, with -Ca
warning: conversion to 'yy_state_type' from 'flex_uint32_t' may change the sign of the result [-Wsign-conversion]
2016-03-31 07:17:32 -04:00
rlar f57cb42c7d suppress WARNINGFLAGS' for the almost obsolete noansi' test cases 2016-03-31 07:15:43 -04:00
rlar f1ce47684c configure option --enable-warnings' and WARNINGFLAGS'
`WARNINGFLAGS' can be passed when invoking `configure'
 and when invoking `make'

if configure switch `--enable-warnings' was given
  then default to something useful if we have `GCC'

`WARNINGFLAGS' is not used when compiling `stage1flex'
  to avoid unnecessary clutter
2016-03-31 07:11:51 -04:00
Tobias Klauser babe9a1e8e Fix potential buffer overflow in strncat()
When using clang/llvm 3.8 to compile flex, the following warning is
emitted:

main.c:378:27: warning: the value of the size argument in 'strncat' is too large, might lead to a buffer overflow [-Wstrncat-size]
                                        strncat(m4_path, m4, sizeof(m4_path));
                                                             ^~~~~~~~~~~~~~~
main.c:378:27: note: change the argument to be the free space in the destination buffer minus the terminating null byte
                                        strncat(m4_path, m4, sizeof(m4_path));
                                                             ^~~~~~~~~~~~~~~
                                                             sizeof(m4_path) - strlen(m4_path) - 1

Fix it up by using the solution proposed by the warning message.
2016-03-31 10:09:57 +02:00
Robert.Larice Robert Larice c5d903dcda build: simplified dependency tracking so parallel make runs succeed 2016-03-29 15:19:00 -04:00
rlar fab3f206e4 avoid warning in generated code, with -Cf
warning: conversion to 'unsigned int' from 'int' may change the sign of the result [-Wsign-conversion]
2016-03-28 16:41:15 -04:00
Will Estes 42325b8b39 mention v2.6.2; summarize changes since 2.6.1 2016-03-18 15:25:10 -04:00
Will Estes e873499f32 doc: corrected example in manual, gh#67 2016-03-18 15:09:44 -04:00
rlar 0292299ec5 warning: conversion to 'size_t' from 'int' may change the sign of the result [-Wsign-conversion] 2016-03-18 14:52:04 -04:00
rlar ed59d3e066 warning: conversion to 'long unsigned int' from 'int' may change the sign of the result [-Wsign-conversion] 2016-03-18 14:49:23 -04:00
rlar c2429b5a4a warning: conversion to 'flex_uint32_t' from 'long unsigned int' may alter its value [-Wconversion]
struct yytbl_reader, member bread is of type flex_uint32_t
2016-03-18 14:46:43 -04:00
rlar 70b804fb02 warning: redundant redeclaration of '...' [-Wredundant-decls] 2016-03-18 14:39:21 -04:00
rlar 676a62ec1e warning: no previous prototype for '...' [-Wmissing-prototypes] 2016-03-18 14:35:39 -04:00
rlar d112fbaf53 warning: unused variable 'fp' [-Wunused-variable] 2016-03-18 14:31:37 -04:00
rlar 2da698f147 main(), warning: redundant redeclaration of 'main' [-Wredundant-decls] 2016-03-18 14:27:58 -04:00
rlar 08fd44f453 main(), warning: old-style function definition [-Wold-style-definition] 2016-03-18 14:06:11 -04:00
rlar f4be44b2b2 main(), warning: old-style function definition [-Wold-style-definition] 2016-03-18 13:56:25 -04:00
rlar 8756116ccb Fix two more casts 2016-03-16 08:27:58 -04:00
Bastian Köcher 1da19feba7 Fixes yyl compare with unsigned warning 2016-03-16 08:23:01 -04:00
Robert Larice 197b523555 Suppress portability warnings in Makefile generation 2016-03-16 08:23:01 -04:00
rlar dc55016677 generated code, in yyensure_buffer_stack(), change type of local `num_to_alloc'
which is exclusively used in yy_size_t context
2016-03-12 14:29:47 -05:00
rlar 8c098febc9 generated code, in yy_get_next_buffer(), change type of local `number_to_move'
suits better, because `yy_n_chars' and `yy_buf_size' are of type `int'
2016-03-12 14:28:55 -05:00
rlar cf4121fa97 generated code, _yybytes_len' is of type int', fix code accordingly 2016-03-12 14:27:38 -05:00
rlar 3946924ed5 generated code, max_size' seems to be of type int', fix casts accordingly 2016-03-12 14:25:34 -05:00
rlar 986bb5e294 generated code, here new_size' is of type int', fix casts accordingly 2016-03-12 14:23:30 -05:00
rlar 33dd868353 generated code, yy_buf_size' is of type int', fix casts accordingly 2016-03-12 14:22:43 -05:00
rlar 3614d4c834 generated code, offset' is of type int' 2016-03-12 14:21:33 -05:00
rlar 04c31bf09f generated code, yy_more_len' is of type int' 2016-03-12 14:20:30 -05:00
rlar 48152721a0 scan.l, rewrite two loops to avoid unneccesairy casting 2016-03-12 14:16:46 -05:00
rlar bdc999cbc1 improve readability 2016-03-12 14:12:49 -05:00
rlar fb60d5a04e another cast in tblcmp.c to avoid warning 2016-03-12 14:10:48 -05:00
rlar 3d640d049d casts in buf_append() to get rid of warnings 2016-03-08 15:35:53 -05:00
rlar de3fb712c2 cast to suite type of flex_uint32_t td_lolen 2016-03-08 15:35:45 -05:00
rlar 9160ceb67f cast to get rid of warnings 2016-03-08 15:30:35 -05:00
rlar 00bc43fa04 cast and fix usage of log10(), ceil to prevent buffer overflow 2016-03-08 15:20:45 -05:00
rlar c7b3db7957 tables.c, sprinkle casts to get rid of warnings 2016-03-08 15:20:45 -05:00
rlar 598ba7fd4c yytbl_data_compress(), change type of local newsz to get rid of warnings 2016-03-08 15:20:45 -05:00
rlar e8e83d2dbe change type of struct yytbl_writer.total_written to get rid of warnings 2016-03-08 15:13:05 -05:00
rlar c2940d142b change argument type of yytbl_writen() to get rid of warnings 2016-03-08 13:29:08 -05:00
rlar fe89a09e29 yytbl_write8/16/32(), change type of local variables to get rid of warnings 2016-03-08 13:22:54 -05:00
rlar 1d5b34b52a change return type and rename int htoi()/otoi() --> unsigned int htoui()/otoui() 2016-03-08 13:19:20 -05:00
Will Estes 609af5775f Mention 2.6.1 release date 2016-03-01 19:24:24 -05:00
rlar 455205b2e0 avoid warning, add (int) cast to the read() return value
For similiarity with the fread() case.
2016-03-01 06:08:30 -05:00
rlar 265e8e5c90 avoid warning, POSIX says yyless() has an `int' argument 2016-03-01 06:07:36 -05:00
rlar f951c3f8cc use type size_t in filter_tee_header() to avoid warnings 2016-03-01 06:06:42 -05:00
rlar 22d123c1fe add (size_t) casts to malloc invocations to prevent warnings 2016-03-01 06:05:21 -05:00
rlar d2c0374297 add (int) casts to some strlen() invocations to prevent warnings 2016-02-29 20:16:03 -05:00
rlar 0f276adbb2 ndlookup(), char *, to get rid of casts and warnings 2016-02-29 20:11:13 -05:00
rlar 967819769e ndinstal(), char *, to get rid of casts and warnings 2016-02-29 20:07:58 -05:00
rlar b7b9789469 cclinstal() and ccllookup(), char *, to get rid of casts and warnings 2016-02-29 20:07:47 -05:00
rlar 2532a957a6 warning: redundant redeclaration of ‘gen_next_state’ [-Wredundant-decls] 2016-02-29 19:53:12 -05:00
rlar 0f4684dd2a warning: no previous prototype for ‘mkecstbl’ [-Wmissing-prototypes] 2016-02-29 19:41:03 -05:00
rlar cc7d14899c warning: suggest parentheses around assignment used as truth value [-Wparentheses] 2016-02-29 19:06:56 -05:00
rlar 860d7cfe15 warning: redundant redeclaration of ‘yywrap’ [-Wredundant-decls] 2016-02-28 19:43:38 -05:00
rlar ad994f507e warning: redundant redeclaration of ‘yylval’ [-Wredundant-decls] 2016-02-28 19:42:51 -05:00
rlar 4d6fb2187b warning: redundant redeclaration of ‘yyin’ [-Wredundant-decls] 2016-02-28 19:40:05 -05:00
rlar 519783bb98 warning: redundant redeclaration of ‘yyparse’ [-Wredundant-decls] 2016-02-28 19:07:18 -05:00
rlar 318396d05a unification, rename some more
rename these too for improved similiarity:
  OPTION_OP OPT_HEADER OPT_EXTRA_TYPE OPT_TABLES
2016-02-28 18:56:25 -05:00
rlar 804efe8c42 fix name clash, OPT_OUTFILE from parse.y and from options.h
these collide:
  OPT_OUTFILE OPT_PREFIX OPT_YYCLASS
rename them TOK_... in the parser
2016-02-28 18:50:12 -05:00
Will Estes 80484ea267 Prototyped reallocarray implementation 2016-02-28 16:23:19 -05:00
Will Estes aade6607e2 Removed custom strcasecmp() function 2016-02-28 15:51:57 -05:00
rlar fd722d7030 fwrite wants a size_t, yyleng is int per posix 2016-02-28 15:21:12 -05:00
rlar bffbf1fa28 Remove some unneeded casts 2016-02-28 15:17:57 -05:00
rlar 48fa65020f warning: negative integer implicitly converted to unsigned type [-Wsign-conversion] 2016-02-28 15:15:32 -05:00
rlar e66a12bbff dfa.c:157:24: warning: conversion to 'size_t' from 'int' may change the sign of the result [-Wsign-conversion]
most certainly safe cast
2016-02-27 17:40:14 -05:00
rlar 3a132d28d9 ccl.c:86:19: warning: conversion to 'unsigned char' from 'int' may alter its value [-Wconversion]
ch seems to have been checked for proper range some lines above
2016-02-27 17:38:25 -05:00
rlar 71530afc7e warning: deprecated directive, use '%pure-parser' [-Wdeprecated] 2016-02-27 17:35:53 -05:00
rlar 9132612c2c warning: no previous prototype for 'do_nothing' [-Wmissing-prototypes] 2016-02-27 17:35:07 -05:00
rlar f691a6345d included stdlib.h header 2016-02-27 17:31:19 -05:00
Will Estes 458180116d Described more post v2.6.0 changes 2016-02-27 16:23:11 -05:00
Will Estes aa4eac68e7 build: Removed bzip2 distribiution archive 2016-02-27 15:45:34 -05:00
Will Estes 782ee061ec removed obsolete program check 2016-02-27 15:41:59 -05:00
Will Estes 0e2b8c0f95 Made some program checks more robust 2016-02-27 15:35:33 -05:00
rlar 09fd5851bc Remove unneeded cast to int 2016-02-27 14:00:55 -05:00
Will Estes a5cbe929ac Fixed incorrect integer type 2016-02-27 11:56:05 -05:00
Will Estes 7a7c3dfe1b Fix more integer types, resolves sf 184, 187 2016-02-27 09:43:00 -05:00
Robert Larice de03dfb8fa Removed some type conversion warnings 2016-02-26 20:23:05 -05:00
Will Estes a51bd6c301 Changed another buffer size to int; resolves gh#61 2016-02-26 14:23:33 -05:00
Will Estes 4a8eccf830 Changed type of yy_n_chars to int; gh#53, sf#160.
The variable yy_n_chars had been of type yy_size_t which is incorrect
given its use in read(). While it might be adviseable to look at
defining a yy_ssize_t, there might be some issues doing this and so, for
now, at least, we'll punt back to int.
2016-02-24 20:11:24 -05:00
Will Estes d2a67ba6b7 Fixed size of bufferallocation, resolved gh#54.
The value of n_alloc was a count, not a size. Multiplying the value by the element size was incorrect. That multiplication was already being done and having it done twice was incorrect.
2016-02-24 17:50:00 -05:00
Tobias Klauser dcf0226b06 Allow '%option noline' in flex input file, resolves gh#56.
Allow specifying '%option noline' in the input file, leading to the same
effect as calling flex with the command line option --noline.

Signed-off-by: Tobias Klauser <tklauser@distanz.ch>
2016-02-24 16:21:08 -05:00
Tobias Klauser 647a92b9f4 Emit no #line directives if gen_line_dirs is false, resolves igh#55.
There are two instances in the code which will print a #line directive
to the resulting lexer, regardless of the value of gen_line_dirs. Fix
them, so they also respect gen_line_dirs.

Signed-off-by: Tobias Klauser <tklauser@distanz.ch>
2016-02-24 16:19:49 -05:00
Tobias Klauser 64f2774378 Converted K&R style function definitions to ANSI C style
Consistently make use of the ANSI C function definition style instead of
the K&R style.
2016-02-16 14:52:16 +01:00
Tobias Klauser 1cc6c871f9 Used NULL constant instead of plain integer for NULL pointer.
The sparse static checker warns about using plain integer 0 as NULL
pointers in the generated lexer code. Fix this by using NULL
consistently for pointers.
2016-01-29 21:19:48 -05:00
Tobias Klauser a7ff1b23a9 Marked declaration and definition of yy_fatal_error as noreturn.
Only the declaration of yy_fatal_error is marked with
__attribute__((__noreturn__)) in case GCC >= 3 is used, but not the
definition. This leads to the sparse static checker to complain about
function declaration mismatch.

Fix it by defining a macro yynoreturn and using it for both the
declaration and the definition of yy_fatal_error.
2016-01-29 21:19:30 -05:00
Tobias Klauser 4936786fc5 Fixed declaration mismatch in yy_fatal_error.
The prototype declares yy_fatal_error parameter as "const char msg[]"
while the definition uses "const char* msg" (introduced by commit
e9d5fc713f) which causes the sparse static checkers to produce an
error.

Fix this by adjusting the definition to use "const char* msg" as well.
Also change the C++ version accordingly so it matches the declaration in
FlexLexer.hpp.
2016-01-27 17:01:14 -05:00
Will Estes 24a1589f86 flex is for flex #NCoC 2016-01-23 11:43:07 -05:00
Will Estes c351f39a2f Referred to github for issue tracking, no longer sf 2016-01-18 16:00:04 -05:00
Egor Pugin 3d1175b232 Opened files in binary mode explicitly 2016-01-10 15:43:47 -05:00
OBATA Akio 11ea8d73fc Linked flex binary against libintl, not libfl.
Signed-off-by: Thomas Klausner <wiz@NetBSD.org>
2016-01-08 15:23:18 -05:00
Michael van Elst 958ccda44e Improved pipe-stdin hack behavior; resolves sf#198.
Signed-off-by: Thomas <Klausner wiz@NetBSD.org>
2016-01-08 15:07:57 -05:00
Will Estes 3efb40df0e Removed no longer needed header checks 2015-12-27 14:05:51 -05:00
Will Estes 5b856d1fa3 Checked for reallocarray() with AC_REPLACE_FUNCS 2015-12-27 13:57:13 -05:00
Will Estes 5d22149d43 include libgen.h from flexdef.h, not main.c 2015-12-27 13:46:37 -05:00
Michael Reed 145968f5e2 Replace basename2() with basename(3).
Given the following program:

	\#include <libgen.h>
	\#include <stdio.h>

	/* extracts basename from path, optionally stripping the extension "\.*"
	 * (same concept as /bin/sh `basename`, but different handling of extension). */
	static char *basename2 (char *path)
	{
		char   *b;

		for (b = path; *path; path++)
			if (*path == '/')
				b = path + 1;
		return b;
	}

	static void basename_compare(char *path)
	{
		printf("basename: %s\n", basename(path));
		printf("basename2: %s\n\n", basename2(path));
	}

	int main (int argc, char *argv[])
	{
		// From http://pubs.opengroup.org/onlinepubs/9699919799/
		// ``Sample Input and Output Strings''
		basename_compare("/usr/lib");
		basename_compare("/usr/");
		basename_compare("/");
		basename_compare("///");
		basename_compare("//usr//lib//");
		return 0;
	}

... and the program's output:

	basename: lib
	basename2: lib

	basename: usr
	basename2:

	basename: /
	basename2:

	basename: /
	basename2:

	basename: lib
	basename2:

... we can see that basename2() behaves the same as basename(3) in the
average use case, but messes up pretty severely in others.  Besides
that, basename(3) is mandated by POSIX so should be present on modern
Unix-like systems, so we shouldn't define it ourselves.

Some notes:
- it doesn't appear to be mentioned in POSIX, but OpenBSD's basename(3)
  returns NULL if the returned path componenet is > PATH_MAX, so add a
  check for that
- basename(3) shouldn't return an empty string, so remove the
  program_name[0] != '\0' check
2015-12-27 13:39:45 -05:00
Michael Reed 0e00f445a9 Simplify basename2().
It's only call site does not activate the `strip_ext` code path, so the
function can be simplified a lot.  While here, remove a double
assignment.
2015-12-27 13:39:09 -05:00
Michael Reed 6fa7ed0446 Cleaned up __STDC__ #ifdefs.
Assuming a compiler conforming to the ISO C standard is used, i.e.,
__STDC__ is defined to 1, YY_USE_CONST is always defined and can be
eliminated.
2015-12-27 08:32:33 -05:00
Michael Reed 64874cd464 Remove remaining use of PROTO 2015-12-25 14:01:24 -05:00
Serguey Parkhomovsky 5f6b7645e6 buf.c: use snprintf 2015-12-21 14:40:24 -08:00
Will Estes ed855892c7 build: reformatted AC_CHECK_FUNCS for readability 2015-12-19 16:17:31 -05:00
Will Estes aebf37aa12 correct function prototype 2015-12-17 16:45:14 -05:00
Michael Reed c1c3b82b79 Remove more instances of PROTO 2015-12-15 16:11:01 -05:00
Michael Reed c918627e08 Removed prototype for main().
It's not called anywhere else so the prototype is not needed.
See the C99 standard [1], section 5.1.2.2.1 for more info.

[1]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf
2015-12-15 16:05:49 -05:00
Michael McConville 559d79d0f5 Removed more instances of PROTO, ansifying. 2015-12-14 07:20:53 -05:00
Will Estes 56f558ffef Noted github for issue tracking and pull requests 2015-12-13 19:44:19 -05:00
Michael McConville 43f8adbe60 Reformatted README; removed sf bug tracking link. 2015-12-13 19:42:39 -05:00
Michael McConville bfdef978fc Removed macros for indentation level.
Just increment or decrement the indentation counter. That's less to
remember and makes the code more readable.

w# Please enter the commit message for your changes. Lines starting
2015-12-13 19:25:23 -05:00
Mike Frysinger 4082a04921 tests: fixed paths to input files.
The current test wrapper works only when the inputs are specified using
relative paths.  If they're specified with absolute paths, the driver
fails to detect the inputs because it always prepends the input dir name
which itself is a relative path:
$ cd tests
$ ./testwrapper.sh -d . -i $PWD/reject.txt -t ./reject_ver.table
<fails to open inputs>

This normally doesn't show up because people run `./configure` or, for
out of tree builds, `../configure`.  But if you happen to run configure
with an absolute path, then automake tends to generate absolute paths
as well leading to test failures.

Fix all of this by dropping the implicit input directory prepending.

- INPUT_NAME is often a list of files, not just a single one
- the input directory is used to find the testname tables which are
  usually generated, so it's impossible to use files from both source
  and build directories
- most of the time, the full/correct path is already specified
2015-12-13 19:02:51 -05:00
Mike Frysinger ff622ae961 configure: fixed realloc test.
The [] characters are used for quoting in m4, so the attempt to use
them in place of `test` fails yielding the warning at build time:

.../flex/configure: line 20222: no: command not found
2015-12-13 19:01:29 -05:00
Michael McConville 9acbb870c1 Started removal of PROTO macro.
The PROTO macro is no longer needed. Additionally, its usage is inconsistent,
so we began removing it.
2015-12-12 18:01:13 -05:00
Michael Reed e05e093047 Removed SHORT_FILE_NAMES preprocessor symbol.
As a relic of MS-DOS, we don't need this.

It's never defined; see 13b5b214f5.

Removed additional MSDOS ifdef.
2015-12-12 15:40:58 -05:00
Michael McConville 77e54b25ee Added new function reallocarray.
This is taken from OpenSSH Portable, which in turn takes it from
OpenBSD.

reallocarray wraps the stdlib's realloc function. It takes two size
arguments and checks for overflow, like calloc, but doesn't zero the
memory. Therefore, it allows us to do overflow-safe array reallocations
and overflow-safe unzeroed array allocations, which the stdlib
allocation functions don't.

We have a bunch of specific array allocation macros, none of
which check for overflow. reallocarray should be able to replace them.
2015-12-12 15:25:40 -05:00
Michael McConville 13b5b214f5 Removed MS-DOS, VMS macros.
Given the age of the MS-DOS and VMS platforms, it's likely that no one is building flex on them any more. Additionally, the preferred approach is to test for particular platform features rather than to test for particular platforms.
2015-12-12 14:19:37 -05:00
Will Estes c34590c4bf Made search for m4 more explicit. 2015-12-12 11:03:05 -05:00
Will Estes f863c9490e Returned 0 from yywrap() instead of EOF 2015-12-12 07:35:23 -05:00
Will Estes 3a4af3424c Changed end of main() in libmain to exit(0) 2015-12-11 20:25:50 -05:00
Will Estes 965c9fa979 Mentioned v2.6.1; documented some changes since v2.6.0 2015-12-11 10:57:46 -05:00
Will Estes 6f9cbd4af1 Updated build documentation; finished sf#155.
Removed version numbers for build tools. Noted that version requirements for build tools will be noted in configure.ac. Expanded documentation of building texinfo based docs.
2015-12-11 10:41:08 -05:00
Will Estes e5e5fb59c9 Removed flex.pdf from distribution; partially fixed sf#155 2015-12-11 10:40:34 -05:00
Will Estes 07d89829cc Commented in C style in skeleton; fixed sf#195 2015-12-11 09:45:14 -05:00
Will Estes 1e13e9656b Ignored autoscan files 2015-12-10 10:05:59 -05:00
Will Estes d4e8f383e8 Checked for ranlib and strdup() at configure time 2015-12-09 19:39:20 -05:00
Michael McConville 8205442c7c Replace zero_out() with stdlib's memset. 2015-12-09 17:44:33 -05:00
Michael McConville 3d08a01292 Removed memory allocation casts. 2015-12-09 17:33:58 -05:00
Michael McConville 0dfcb6228f Removed alloca() configuration.
Since alloca() is dangerous, depricated, we remove it.
2015-12-09 15:54:02 -05:00
Michael McConville d41be27501 Removed implementation of isascii().
POSIX defines isascii(), so it's likely present on anything weactually build flex on these days.
2015-12-09 15:36:18 -05:00
Michael McConville 7969134687 Removed NULL-checks before free() 2015-12-09 13:15:08 -05:00
Michael McConville d95947343e Removed flex_free()i, corrected buf_destroy logic.
As with flex_alloc(), replace with direct calls to free().

The function buf_destroy is now null safe and the logic was corrected to free()
correctly.
2015-12-09 09:53:57 -05:00
Michael McConville 1cc5d87032 Removed flex_realloc().
As with flex_alloc(), replace calls to flex_realloc(), which was just a
wrapper around realloc().
2015-12-09 09:51:17 -05:00
Michael McConville c53d722b0b Removed flex_alloc; cleaned up style.
The function flex_alloc() was just a wrapper around malloc(). Since this only added unclarity, and the flex_alloc() function is likely a legacy of olden times, remove it in favor of calls to malloc() directly.

Style elements cleaned up:

 * superfluous spacing around parentheses
 * non-constant initialization in variable declarations
 * needless casts
 * almost all uses of assignments as subexpressions
2015-12-09 09:48:39 -05:00
Michael McConville c03bef5411 Remove allocation casts 2015-12-07 21:28:21 -05:00
Will Estes 53e3088d75 Built flex with itself.
Changes in scan.l need to be built into flex with the same version of
flex in some cases. Since this build requirement is minimal, we simply
bootstrap flex unconditionally.

We intentionally exclude from version control the bootstrap artifacts as
the extra copy of the lexer, the intermediate scanner and the bootstrap
executable are not of interest.
2015-12-07 15:37:01 -05:00
Michael McConville e0877888da Use NULL rather than (type *) 0. 2015-12-05 18:50:53 -05:00
Michael McConville 3a1d84cfc0 Replace copy_unsigned_string() with xstrdup().
Like copy_string(), copy_unsigned_string() is just a clone of the
stlib's strdup(). We only use it twice. I'm pretty confident that char
signedness is irrelevant in this case.
2015-12-05 17:42:40 -05:00
Akim Demaille a562291415 Cleaned up white space. 2015-12-05 06:01:48 -05:00
Akim Demaille 35a307f959 Removed struct keyword before yy_buffer_state 2015-12-05 05:49:51 -05:00
Akim Demaille 004399be12 Replaced FLEX_STD macro with std::.
The std:: construct exists as of C++98, so we can simply assume it is
supported.
2015-12-05 05:46:19 -05:00
Akim Demaille 4cea6bfe54 Generated skel.c explicitly in srcdir.
Rewrote the target for skel.c to explicitly mention the srcdir. This
should help when building flex from a directory outside the flex
tree. Spread the rule out over several lines to enhance readability.
2015-12-04 15:07:11 -05:00
Akim Demaille 7ddfe81aa8 Called glibtoolize if libtoolize run fails.
On Mac OS X, libtoolize is known as glibtoolize. In cases where libtoolize is not present, then calling glibtoolize when bootstrapping the build system gives more folks a shot at getting flex built from the ground up.
2015-12-04 14:59:54 -05:00
Mightyjo 9e24fe5ea9 Checked for (g)texi2dvi. Better bison, help2man checks.
Added test for presence of (g)texi2dvi program. Gave notice if texi2dvi
is unavailable and set TEXI2DVI=: to avoid giving users headaches.

Enhanced tests for bison and help2man with notices when the programs
aren't found.  Set their program variables to use the missing script
in build-aux since it's compatible with them.
2015-12-03 07:21:48 -05:00
Michael McConville 399e94f904 Made string copying more standard.
copy_string() was a clone of the stdlib's strdup(). For safety,
simplicity, and speed, we should use that instead. We introduce xstrdup() which wraps strdup() in a failure upon memory allocation errors.
2015-12-02 14:39:09 -05:00
Serguey Parkhomovsky 9ba6e5283e Error on unbalanced parentheses in rules section. 2015-11-30 19:33:32 -05:00
Will Estes f1d53eb001 Cleaned up BUILT_SOURCES list.
Removed reference to skel.c as a built source since other make rules cover this case.
2015-11-29 19:43:05 -05:00
Will Estes 9e1ec519f4 Sorted file names in flex_SOURCES 2015-11-29 19:30:19 -05:00
Mightyjo a97cf48486 Replaced CHAR macro with unsigned char type.
Thanks to Michael McConville for pointing out that the old Char macro
causes problems with static analysis.  The macro has been removed and
replaced with 'unsigned char' throughout the flex sources. The macro is
not needed at best and was confusing at worst. It was not used in any of
the example files nor was it mentioned in the manual at all.
2015-11-29 17:20:22 -05:00
Will Estes 45db9033fe updated syntax of AC_INIT call as per autoupdate 2015-11-21 13:15:53 -05:00
Will Estes 3bc38e963e removed extra call to a _CPPFLAGS variable 2015-11-21 13:12:58 -05:00
Stefan Reinauer 0f7b9136ed Switch function definitions from mixed K&R to consistent ANSI C.
flex was using K&R function definitions for some functions and
ANSI C style in others, sometimes even in the same file. Change
the code to consistently use ANSI C.

Signed-off-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
2015-11-19 19:26:07 -05:00
Mightyjo 09eae589d3 Used in-tree header file for c++ tests. 2015-11-18 15:03:03 -05:00
Will Estes 83d5d1695a Declared version 2.6.0 2015-11-17 11:16:43 -05:00
Will Estes d34b6160af Dated, described flex release 2.6.0 2015-11-17 11:14:05 -05:00
Will Estes 5263986825 Declared version 2.6.0rc1 2015-11-13 14:56:25 -05:00
lukeallardyce 54201ab377 Supplied versioning information in flex libraries.
Resolves sourceforge bug #182. On OSX, and possibly other platforms, building the libfl libraries without versioning information caused a build failures.
2015-11-13 14:48:19 -05:00
Will Estes 0be145eea8 Cleaned up more precisely after make check.
BUILT_SOURCES is now just the list of headers built as per the
automake manual. We provide the list of files to clean to make
rebuilding the test suite programs easier. We then use the CLEANFILES
list in a dist-hook to clean up the distribution that automake gathers
since not distributing flex generated files is foreign to automake's
mindset, but we need exactly that.

Additionally, we locate inputs to the tables-related tests more
precisely. Some files are in srcdir and some are in builddir, which
the arguments to the log compiler are now made aware of.
2015-11-12 21:44:07 -05:00
Will Estes 4864c4f23a Pulled out scripts in tests/Makefile.am 2015-11-11 19:08:26 -05:00
Will Estes 83006c65f8 Added srcdir to tableopts.am include 2015-11-11 18:22:17 -05:00
Will Estes b54685ff22 Changed man page dependencies.
The man page is just the --help output as reformatted by help2man. The
--help option is most likely to change when the flex skeleton changes
or one of the option parsing files changes or the configure.ac script
itself changes. The dependencies reflect this now.

It is still necessary, under some circumstances, to rebuild flex
explicitly before building the man page. In theory, it's possible to
have automake arrange to do this all the time, but doing so works out
to be fragile, given the rest of the build system.
2015-11-11 15:20:56 -05:00
Will Estes 589bb43094 Called libtoolize directly because autoreconf fails to pick up LT_INIT properly 2015-11-10 17:26:39 -05:00
Will Estes b382a56bf3 Added tableopts.sh to EXTRA_DIST 2015-11-10 17:24:28 -05:00
Mightyjo 461f987f09 Made tests depend on the built flex binary. 2015-11-10 14:28:17 -05:00
Mightyjo a6ceb756d9 Merge branch 'master' into streamrefs 2015-11-08 15:43:09 -08:00
Mightyjo cf6cb4dce7 Cleaned more generated sources.
Added skel.c explicitly to MAINTAINERCLEANFILES in src/Makefile.am.

Added a bunch of files to built_SOURCES in tests/Makefile.am so that the
suite is easier to clean up.
2015-11-08 14:59:29 -05:00
Mightyjo 1f4c0e67fe Updated documentation to reflect the revisions to FlexLexer.h 2015-11-07 23:28:09 -08:00
Mightyjo 336a1deaa5 Changed several pointers to istream (and ostream) to references in c++-only sections of the skeleton.
Patched up a variety of expected errors caused by changing istream* to istream&.

Added a stray 'make' at line 545.  Oops.

Changed the buffer_state struct to store std::streambuf* instead of std::istream* for C++ mode.  Changed interfaces in FlexLexer.h to take std::istream& instead of *.  Backward compatibility temporarily broken.

Patched up backward compatibility with reasonable behavior in the presence of null pointers.

Re-added backward-compatible versions of the yyFlexLexer methods that take iostream pointers.  All tests passing.
2015-11-07 23:25:24 -08:00
Translation Project 5acd407ed4 new zh_CN translation from the translation project 2015-09-29 15:53:33 -04:00
Jaska Uimonen b4b8b7ed81 fix possible resource leak with yynultrans_tbl 2015-08-06 09:28:21 -04:00
Jaska Uimonen 5f23fc0033 fix possible uninitialized array values 2015-08-06 09:27:30 -04:00
Will Estes 4f2ae90b28 add %{...%} block to example in manual 2015-08-05 15:27:37 -04:00
Will Estes b6fa146a0f initialize libtool earlier in build system generation 2015-07-15 15:20:11 -04:00
Translation Project 341bfbd389 new da translation from the Translation Project 2015-05-08 15:15:56 -04:00
162 changed files with 9254 additions and 27044 deletions
+3 -1
View File
@@ -2,7 +2,7 @@
*.rej
*.tar.bz2
*.tar.gz
*.tar.xz
*.tar.lz
*~
.deps
.libs
@@ -13,9 +13,11 @@ Makefile
Makefile.in
aclocal.m4
autom4te.cache
autoscan.log
config.log
config.status
configure
configure.scan
flex-*/
libtool
stamp-*
+1
View File
@@ -0,0 +1 @@
2.6.3
-107
View File
@@ -1,107 +0,0 @@
This is a list of bugs still in the queue at lex.sf.net at the time we closed
out the project and moved it to flex.sf.net.
-------------------------------------------------------------
Some strict compilers warn about a few internal flex variables signedness. They
are bogus warnings and can be ignored, but people send in reports nonethless.
-------------------------------------------------------------
The initializer of the yy_transition array in the
generated scanner
contains fewer entries than the declared size of the array.
Examples include yy_transition[6504] with 6250 entries,
yy_transition[13215] with 12961 entries. This looks
like it
is always 254 fewer entries than the declared size.
This bug is present in flex 2.5.4a as well. It appears to be harmless.
-------------------------------------------------------------
The examples in the chapter "Generating C++ Scanners"
contain suspicious code. Attached is a patch that
corrects this, and after these
modifications this example compiles and works.
-------------------------------------------------------------
C++ scanners derived from the yyFlexLexer base class
will not compile with flex-2.5.31 because the
&lt;FlexLexer.h&gt; automatically gets included into the
scanner twice. Because yyFlexLexer is now defined by
default even if no prefix is specified, including
FlexLexer.h twice causes the class yyFlexLexer to be
declared twice. In flex-2.5.4 because yyFlexLexer was
not defined by flex in the scanner code, including
FlexLexer.h more than once only declared yyFlexLexer
once. I appreciate that this is because of the M4
additions to flex, but I can not find a way to stop
flex defining yyFlexLexer if it is not needed.
Here is an example of a class that will not compile:
derived_lexer.h:
#ifndef __derived_lexer__
#define __derived_lexer__
#include &lt;FlexLexer.h&gt;
class derived_lexer : public yyFlexLexer
{
public:
derived_lexer(std::istream* arg_yyin = 0) :
yyFlexLexer(arg_yyin){}
int yylex();
int x;
};
#endif
derived_lexer.l:
%{
#include &quot;derived_lexer.h&quot;
%}
%option yyclass=&quot;derived_lexer&quot;
%%
[0-9]+ {
x = atoi(yytext);
}
%%
main.cpp:
#include &quot;derived_lexer.h&quot;
#include &lt;fstream&gt;
int main()
{
std::ifstream input;
input.open(&quot;input&quot;);
derived_lexer lexer(&amp;input);
lexer.yylex();
}
-------------------------------------------------------------
Hi, the anomally is that if I generate a c++ parser it will not make
yy_scan_buffer and friends.
this is happenning on flex version 2.5.4.
Is this the intent, if so how do I make a c++ parser read from my buffer?
P.S. in c++ it will only generate:
#ifndef YY_NO_SCAN_BUFFER
#endif
#ifndef YY_NO_SCAN_STRING
#endif
#ifndef YY_NO_SCAN_BYTES
#endif
-------------------------------------------------------------
+5
View File
@@ -0,0 +1,5 @@
# Contributor Code of Conduct
This project adheres to No Code of Conduct. We are all adults. We accept anyone's contributions. Nothing else matters.
For more information please visit the [No Code of Conduct](https://github.com/domgetter/NCoC) homepage.
+5 -9
View File
@@ -27,28 +27,21 @@
# and 7-bit scanners when using uncompressed tables (-f or -F options).
# For flex to always generate 8-bit scanners, add "-DDEFAULT_CSIZE=256"
# to DEFS.
#
# For Vax/VMS, add "-DVMS" to DEFS.
#
# For MS-DOS, add "-DMS_DOS" to DEFS. See the directory MISC/MSDOS for
# additional info.
ACLOCAL_AMFLAGS = -I m4
indent = @INDENT@
dist_doc_DATA = \
AUTHORS \
COPYING \
NEWS \
ONEWS \
README
README.md
EXTRA_DIST = \
.indent.pro \
autogen.sh
SUBDIRS = \
lib \
src \
doc \
examples \
@@ -63,8 +56,11 @@ ChangeLog: $(srcdir)/tools/git2cl
$(srcdir)/tools/git2cl > $@ \
; fi
indent:
cd src && $(MAKE) $(AM_MAKEFLAGS) indent
install-exec-hook:
cd $(DESTDIR)$(bindir) && \
$(LN_S) -f flex$(EXEEXT) flex++$(EXEEXT)
.PHONY: ChangeLog tags indent
.PHONY: ChangeLog indent
+216 -4
View File
@@ -1,9 +1,219 @@
This is the file NEWS for the flex package. It records user -visible
changes between releases of flex.
flex NEWS
See the file COPYING for copying conditions.
* Noteworthy changes in release 2.6.4 (2017-05-06) [stable]
* version 2.6.0-pre
** build
*** The indent target now knows about flex's new (as of 2.6.0)
layout. The indent rules it would apply are not correct and do
need to be fixed.
*** The files included in the flex distribution are now built by the
version of flex that is included in the distribution.
*** The configure script has a better idea of which headers are
required to build flex. It will also error when missing functions
are detected.
*** We have lowered the versions of automake and gettext that
configure.ac lists as required for building flex. In autogen.sh,
we now check for how to call libtoolize and use what we find in
the rest of the script.
*** Since files in lib/ are picked up as needed by src/, we no longer
generate a Makefile for that directory.
*** Flex can be cross compiled.
** documentation
*** Some typos were removed from the manual.
** scanner
*** Some minor performance enhancements.
*** We honor user defined yy_* macros again. We are also more careful
to not leak macro definitions into header files.
*** A number of portability fixes were introduced so building flex is
more reliable on more platforms. Additionally, outdated function
calls were removed.
*** When building the flex executable itself, %# comments from
flex.skl are removed when generating the C source code array. This
reduces the size of flex.
** test suite
*** All scripts in the test suite are now run by $(SHELL) and the
needed portability fixes have been included.
*** Test suite dependencies are handled much better. This only matters
if you are actively developing flex or its test suite.
*** Tests that depend on platform dependent features now properly skip
when those platforms are not present.
*** When running "make check", you can now pas V=0 to silence more of
the build. This is useful when you're less connncerned about the
details of building and linking the test programs themselves.
* Noteworthy changes in release 2.6.3 (2016-12-30) [stable]
** scanner
*** several bug fixes resolved problems introduced in recent flex
versions regarding processing of comments, literals and various
quoting scenarios.
*** If the path to m4 was sufficiently long, a buffer overflow could
occur. This has been resolved. The fix also removes dependence on
the constant PATH_MAX.
** build
*** A new configure option --disable-bootstrap changes the behavior of
the build system when building flex. The default
"--enable-bootstrap" behavior is to build flex, then to use that
flex to build flex again. With --disable-bootstrap, the scanner is
simply built by sedding the scanner source. This is friendlier to
cross compilation.
*** The compatibility functions in lib/ are no longer built as a
library. Instead, they are built as $(LIBOBJ) objects. This is
simpler and friendlier to cross compilation.
*** It is now possible to build flex without building the accompanying
libfl. This is friendlier to cross compilation. See the
--disable-libfl option to configure. Resolves #99.
*** the PIC version of libfl was not correctly built. It is no longer
included in the build/installation targets of flex since it was
unused.
*** the distributed man page is only rebuilt when the relevant source
files change or when the binary doesn't exist. In particular, this
is friendlier to cross compilation. Resolves #108
** test
*** the shell scripts in the test suite are more portable across different shell implementations.
* version 2.6.2 released 2016-10-24
** flex internals
*** a segfalt involving yyrestart(NULL) has been fixed
*** flex should now handle quoting when mixed with m4 processing correctly
*** flex handles `[[' and `]]' correctly
*** flex no longer generates non-ANSI code
*** more compilation warnings were squashed in generated scanners
*** prevented a buffer overflow that could occur when input buffers were the exact wrong size
** test suite
*** input filenames on MSWindows are now calculated correctly
*** general code cleanups in a number of tests now make the test suite compile much more cleanly
** build system
*** the xz archive has been replaced with an lzip archive
*** a new option to configure --enable-warnings to encapsulate passing
of warning-related flags which is useful in testing flex
*** make indent now works for out of source builds
*** Portability warnings when generating Makefile.in files are now suppressed; they were just noise and the use of GNU extensions in Makefile.{am,in,} was intentional and well known.
** bugs
*** resolved gh#67
** new sv translation from the translation project
* version 2.6.1 released 2016-03-01
** flex resources
*** The flex project is now hosted at github. Consider this a "period of transition". In particular, you should start at https://github.com/westes/flex for the flex codebase, issue tracking and pull requests.
*** New releases of flex are to be found at https://github.com/westes/flex/releases.
** flex internals
*** Flex now uses more modern and more standard names for variable types. There's more work to be done on that front yet, though.
*** A number of compiler warnings have been remedied.
*** Line directives should now work as expected and be absent when that is expected.
** test suite
*** When running the test suite, c++ files are compiled with the c++ header inside the flex distribution, rather than relying on the build system's flex header , which might not be installed yet or which might be out of date with respect to what flex tests expect.
*** Some portability fixes in the test suite such as opening files for reading in binary mode
** Building flex
*** The file src/scan.c asdistributed with flex source is now built with the current version of flex. Occasionally this had to be done manually to pick up new flex features. It's now just a part of flex's build system.
*** The pdf version of the manual is no longer distributed with flex, although if you have the texinfo package installed, you can still build it.
*** lots of general build system cleanup
*** the build system tries a bit harder to find libtoolize and texi2dvi.
*** When help2man and texi2dvi are missing, the error messages are now much more helpful.
** bug fixes
*** resolved github issues #53, #54, #55, #61.
*** Resolved sf bugs #128, #129, #155, #160, #184, #187, #195.
* version 2.6.0 released 2015-11-17
** User Visible Changes
*** C++ scanners now use references instead of pointers. See the manual for details.
*** A number of compiler warnings were addressed, so flex generated scanners should be quieter under compiler warning scenarios.
*** Allow error reporting routines to accept varying number of arguments
*** Removed deprecated 'register' storage class specifier
*** Changeed output formats from octal to hexadecimal
*** check limits before using array index cclp; resolves sf-166
*** Suppress clang warning about empty @param paragraph; resolves sf#158
*** Fixed malloc/realloc replacement, resolves sf bug#151.
*** Adjusted buffer sizes on ia64.
*** various documentation and code clean up fixes: resolves sf bugs #167, #168, among other patches.
** Flex Internals
*** flex is now organized into subdirectories. This keeps the tree neater at the top level and puts like things near each other and unlike things away from each other.
*** The test suite has been reorganized and is now run with the parallel test suite harness from automake.
*** Cleaned up the automake parts of the build system to better reflect what automake does on its own. Also added a call to libtoolize in autogen.sh because autoreconf gets confused without a prior run of libtoolize.
*** po/Makefile now includes a rule to fetch the latest translations from the translation project. "make -f po/Makefile getpo" from the top level of the flex tree will fetch the files.
*** New da translation from the translation project
* flex version 2.5.39 released 2014-03-26
@@ -528,6 +738,8 @@ But the inverse is still true
See the file ONEWS for changes in earlier releases.
See the file COPYING for copying conditions.
Local Variables:
mode: text
mode: outline-minor
-113
View File
@@ -1,113 +0,0 @@
This is flex, the fast lexical analyzer generator.
flex is a tool for generating scanners: programs which recognize
lexical patterns in text.
More information about flex as well as the latest official release of
flex can be found at:
http://flex.sourceforge.net/
Bug reports should be submitted using the SourceForge Bug Tracker for
flex at:
http://sourceforge.net/tracker/?group_id=97492&atid=618177
The flex codebase is kept in git at:
https://github.com/westes/flex
There are several mailing lists available as well:
flex-announce@lists.sourceforge.net - where posts will be made
announcing new releases of flex.
flex-help@lists.sourceforge.net - where you can post questions about
using flex
flex-devel@lists.sourceforge.net - where you can discuss development of
flex itself
Find information on subscribing to the mailing lists at:
http://sourceforge.net/mail/?group_id=97492
The flex distribution contains the following files which may be of interest:
README - This file.
NEWS - current version number and list of user-visible changes.
INSTALL - basic installation information.
ABOUT-NLS - description of internationalization support in flex.
COPYING - flex's copyright and license.
doc/ - user documentation.
examples/ - containing examples of some possible flex scanners and a
few other things. See the file examples/README for more details.
TODO - outstanding bug reports, desired features, etc.
tests/ - regression tests. See TESTS/README for details.
po/ - internationalization support files.
You need the following tools to build flex from the maintainer's
repository:
compiler suite - flex is built with gcc
bash, or a good Bourne-style shell
m4 - m4 -p needs to work; GNU m4 and a few others are suitable
GNU bison; to generate parse.c from parse.y
autoconf 2.69; for handling the build system
automake 1.12.2; for Makefile generation
gettext 0.18; fori18n support
help2man 1.36; to generate the flex man page
tar, gzip, etc.; for packaging of the source distribution
GNU texinfo 498; to build and test the flex manual
GNU indent 2.8; for indenting the flex source the way we want it done
Once you have all the necessary tools installed, life becomes
simple. To prepare the flex tree for building, run the script:
$ ./autogen.sh
in the top level of the flex source tree.
This script calls the various tools needed to get flex ready for the
GNU-style configure script to be able to work.
From this point on, building flex follows the usual configure, make,
make install routine.
This file is part of flex.
This code is derived from software contributed to Berkeley by
Vern Paxson.
The United States Government has rights in this work pursuant
to contract no. DE-AC03-76SF00098 between the United States
Department of Energy and the University of California.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
Neither the name of the University nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.
+109
View File
@@ -0,0 +1,109 @@
This is flex, the fast lexical analyzer generator.
flex is a tool for generating scanners: programs which recognize
lexical patterns in text.
The flex codebase is kept in
[Git on GitHub.](https://github.com/westes/flex)
Use GitHub's [issues](https://github.com/westes/flex/issues) and
[pull request](https://github.com/westes/flex) features to file bugs
and submit patches.
There are several mailing lists available as well:
* flex-announce@lists.sourceforge.net - where posts will be made
announcing new releases of flex.
* flex-help@lists.sourceforge.net - where you can post questions about
using flex
* flex-devel@lists.sourceforge.net - where you can discuss development
of flex itself
Find information on subscribing to the mailing lists at:
http://sourceforge.net/mail/?group_id=97492
The flex distribution contains the following files which may be of
interest:
* README - This file.
* NEWS - current version number and list of user-visible changes.
* INSTALL - basic installation information.
* ABOUT-NLS - description of internationalization support in flex.
* COPYING - flex's copyright and license.
* doc/ - user documentation.
* examples/ - containing examples of some possible flex scanners and a
few other things. See the file examples/README for more
details.
* tests/ - regression tests. See TESTS/README for details.
* po/ - internationalization support files.
You need the following tools to build flex from the maintainer's
repository:
* compiler suite - flex is built with gcc
* bash, or a good Bourne-style shell
* m4 - m4 -p needs to work; GNU m4 and a few others are suitable
* GNU bison; to generate parse.c from parse.y
* autoconf; for handling the build system
* automake; for Makefile generation
* gettext; for i18n support
* help2man; to generate the flex man page
* tar, gzip, lzip, etc.; for packaging of the source distribution
* GNU texinfo; to build and test the flex manual. Note that if you want
to build the dvi/ps/pdf versions of the documentation you will need
texi2dvi and related programs, along with a sufficiently powerful
implementation of TeX to process them. See your operating system
documentation for how to achieve this. The printable versions of the
manual are not built unless specifically requested, but the targets
are included by automake.
* GNU indent; for indenting the flex source the way we want it done
In cases where the versions of the above tools matter, the file
configure.ac will specify the minimum required versions.
Once you have all the necessary tools installed, life becomes
simple. To prepare the flex tree for building, run the script:
```bash
./autogen.sh
```
in the top level of the flex source tree.
This script calls the various tools needed to get flex ready for the
GNU-style configure script to be able to work.
From this point on, building flex follows the usual routine:
```bash
configure && make && make install
```
This file is part of flex.
This code is derived from software contributed to Berkeley by
Vern Paxson.
The United States Government has rights in this work pursuant
to contract no. DE-AC03-76SF00098 between the United States
Department of Energy and the University of California.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
Neither the name of the University nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.
-66
View File
@@ -1,66 +0,0 @@
* the manual:
** do an end-to-end proofread of the manual (this is under way, but is
going slowly)
** pretty up the dvi output; overflows, etc.
** faq
*** clean up the faqs section. The information is good; the texinfo
could use some touching up.
*** index the faq entries
*** mention that it's possible to use a variable to scan matching
brackets, nested comments etc.
*** include something about lexing/parsing fortran
** create a section on flex design, features, etc.
* getext
** make sure all flex modules use gettext translation facilities
*subdirectories
** in examples/manual, integrate the Makefile.examples into the
Makefile.am
* test suite
** integrate the test suite into automake's framework (note that the
test suite can be run from the top level directory with "make
check". Still, we want to get it completely under automake's control.)
** make test suite more complete
* generic coding
** move as much skeleton code as possible out of gen.c and into
flex.skl
** figure out whether we want to add the capability to have
auto-generated backout rules
** token-type and token buffer support
** check if we still need to #undef macros at the end of a header
** merge yylineno into support for location tracking
** bug where yylineno is not decremented on REJECT
** bug where yylineno is counted in trailing context
* C++
** have a separate skeleton for c++
** revisit the C++ API. We get requests to make it more complete.
Local Variables:
Mode: text
mode: outline-minor
End:
+21 -2
View File
@@ -24,9 +24,28 @@
# If you see no configure script, then run ./autogen.sh to create it
# and procede with the "normal" build procedures.
# use LIBTOOLIZE, if set
LIBTOOLIZE_ORIG="$LIBTOOLIZE";
if test "x$LIBTOOLIZE" = "x"; then LIBTOOLIZE=libtoolize; fi
# test libtoolize
$LIBTOOLIZE --version 2>/dev/null
if test "$?" -ne 0; then
LIBTOOLIZE=glibtoolize
$LIBTOOLIZE --version 2>/dev/null
if test "$?" -ne 0; then
echo "error: libtoolize not working, re-run with LIBTOOLIZE=/path/to/libtoolize"
echo " LIBTOOLIZE is currently \"$LIBTOOLIZE_ORIG\""
exit 1
fi
fi
#if we pretend to have a ChangeLog, then automake is less
#worried. (Don't worry, we *do* have a ChangeLog, we just need the
#Makefile first.)
touch ChangeLog
autoreconf --install --verbose --force
if ! test -f ChangeLog; then
touch ChangeLog
fi
"$LIBTOOLIZE" --install --force
autoreconf --install --force
+86 -30
View File
@@ -24,33 +24,74 @@
# autoconf requirements and initialization
AC_INIT([the fast lexical analyser generator], [2.6.0-pre],
[flex-help@lists.sourceforge.net], [flex])
AC_INIT([the fast lexical analyser generator],[2.6.4],[flex-help@lists.sourceforge.net],[flex])
AC_CONFIG_SRCDIR([src/scan.l])
AC_CONFIG_AUX_DIR([build-aux])
AM_INIT_AUTOMAKE([gnu check-news std-options dist-bzip2 dist-xz parallel-tests 1.14.1])
LT_INIT
AM_INIT_AUTOMAKE([1.11.3 -Wno-portability foreign check-news std-options dist-lzip parallel-tests subdir-objects])
AC_CONFIG_HEADER([src/config.h])
AC_CONFIG_LIBOBJ_DIR([lib])
AC_CONFIG_MACRO_DIR([m4])
LT_INIT
SHARED_VERSION_INFO="2:0:0"
AC_SUBST(SHARED_VERSION_INFO)
# checks for programs
AM_GNU_GETTEXT([external])
AM_GNU_GETTEXT_VERSION([0.19])
AM_GNU_GETTEXT_VERSION([0.18])
AC_PROG_YACC
AS_IF([test "$YACC" != 'bison -y'], [
YACC="\${top_srcdir}/build-aux/missing bison -y"
AC_MSG_NOTICE(no bison program found: only required for maintainers)
])
AM_CONDITIONAL([HAVE_BISON], [test "$YACC" = 'bison -y'])
AM_PROG_LEX
AC_PROG_CC
AX_PROG_CC_FOR_BUILD
AC_PROG_CXX
AM_PROG_CC_C_O
AC_PROG_LN_S
AC_PROG_AWK
AC_PROG_INSTALL
AC_PATH_PROG(BISON, bison,bison)
AC_PATH_PROG(HELP2MAN, help2man, help2man)
# allow passing a variable `WARNINGFLAGS',
# either when invoking `configure', or when invoking `make'
# default to something useful if GCC was detected
AC_ARG_ENABLE([warnings],
[AS_HELP_STRING([--enable-warnings],
[enable a bunch of compiler warning flags (defaults to GCC warning flags).])],
[AS_IF([test "x$GCC" = xyes],
[ : ${WARNINGFLAGS="-Wall -Wextra -Wmissing-prototypes -Wstrict-prototypes -Wnested-externs -Wold-style-definition -Wredundant-decls -Wconversion -Wno-unused-but-set-variable"} ])])
AC_SUBST([WARNINGFLAGS])
AC_ARG_ENABLE([libfl],
[AS_HELP_STRING([--disable-libfl],
[do not build -lfl runtime support library])],
[], [enable_libfl=yes])
AM_CONDITIONAL([ENABLE_LIBFL], [test "x$enable_libfl" = xyes])
# --disable-bootstrap is intended only to workaround problems with bootstrap
# (e.g. when cross-compiling flex or when bootstrapping has bugs).
# Ideally we should be able to bootstrap even when cross-compiling.
AC_ARG_ENABLE([bootstrap],
[AS_HELP_STRING([--disable-bootstrap],
[don't perform a bootstrap when building flex])],
[], [enable_bootstrap=yes])
AM_CONDITIONAL([ENABLE_BOOTSTRAP], [test "x$enable_bootstrap" = xyes])
AM_CONDITIONAL([CROSS], [test "x$cross_compiling" = xyes])
AC_PATH_PROG([HELP2MAN], help2man, [\${top_srcdir}/build-aux/missing help2man])
AS_IF([test "$HELP2MAN" = "\${top_srcdir}/build-aux/missing help2man"],
AC_MSG_WARN(help2man: program not found: building man page will not work)
)
AC_PATH_PROGS([TEXI2DVI], [gtexi2dvi texi2dvi], [\${top_srcdir}/build-aux/missing texi2dvi])
AS_IF([test "$TEXI2DVI" = "\${top_srcdir}/build-aux/missing texi2dvi"],
AC_MSG_WARN(texi2dvi: program not found: building pdf version of manual will not work)
)
# Check for a m4 that supports -P
@@ -63,25 +104,20 @@ AC_CACHE_CHECK([for m4 that supports -P], [ac_cv_path_M4],
AC_SUBST([M4], [$ac_cv_path_M4])
AC_DEFINE_UNQUOTED([M4], ["$M4"], [Define to the m4 executable name.])
AC_PATH_PROG(INDENT, indent, indent)
# if INDENT is set to 'indent' then we didn't find indent
if test "$INDENT" != indent ; then
AC_MSG_CHECKING(if $INDENT is GNU indent)
if $INDENT --version 2>/dev/null | head -n 1|grep "GNU indent" > /dev/null ; then
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
AC_MSG_WARN($INDENT does not appear to be GNU indent.)
fi
else
AC_MSG_WARN(no indent program found: make indent target will not function)
fi
AC_PATH_PROG([INDENT], indent, [\${top_srcdir}/build-aux/missing indent])
AC_MSG_CHECKING(if $INDENT is GNU indent)
AS_IF([$INDENT --version 2>/dev/null | head -n 1 | grep "GNU indent" >/dev/null],
[AC_MSG_RESULT(yes)],
[AC_MSG_RESULT(no)
AC_MSG_WARN($INDENT does not appear to be GNU indent; 'make indent' may not function properly)
])
# checks for headers
AC_HEADER_STDC
AC_HEADER_SYS_WAIT
AC_CHECK_HEADERS([inttypes.h libintl.h limits.h locale.h malloc.h netinet/in.h regex.h stddef.h stdlib.h string.h strings.h unistd.h])
AC_CHECK_HEADERS([regex.h strings.h sys/stat.h sys/wait.h unistd.h], [],
[AC_MSG_ERROR(required header not found on your system)])
AC_CHECK_HEADERS([inttypes.h libintl.h limits.h locale.h malloc.h netinet/in.h])
# checks for libraries
@@ -89,12 +125,12 @@ AC_CHECK_HEADERS([inttypes.h libintl.h limits.h locale.h malloc.h netinet/in.h r
# all we need is the preprocessor symbol defined since we don't need
# LIBS to include libpthread for building flex.
LIBPTHREAD=''
AC_CHECK_LIB(pthread, pthread_mutex_lock,
AC_DEFINE([HAVE_LIBPTHREAD], 1, [pthread library] ),
AC_DEFINE([HAVE_LIBPTHREAD], 0, [pthread library] )
)
AC_CHECK_HEADERS([pthread.h])
AM_CONDITIONAL([want_pthread], [test x$ac_cv_lib_pthread_pthread_mutex_lock = xyes])
[AC_CHECK_HEADERS([pthread.h], [LIBPTHREAD=-lpthread],
[AC_MSG_WARN([pthread tests will be skipped])])],
[AC_MSG_WARN([pthread tests will be skipped])])
AC_SUBST([LIBPTHREAD])
AC_CHECK_LIB(m, log10)
@@ -108,9 +144,30 @@ AC_TYPE_SIZE_T
AC_FUNC_ALLOCA
AC_FUNC_FORK
dnl Autoconf bug: AC_FUNC_MALLOC and AC_FUNC_REALLOC might not warn of cross
dnl compilation. Workaround this.
AC_FUNC_MALLOC
AS_IF([test "$cross_compiling" = yes],
AC_MSG_WARN([result $ac_cv_func_malloc_0_nonnull guessed because of cross compilation]))
AC_FUNC_REALLOC
AC_CHECK_FUNCS([dup2 isascii memset pow regcomp setlocale strchr strtol])
AS_IF([test "$cross_compiling" = yes],
AC_MSG_WARN([result $ac_cv_func_realloc_0_nonnull guessed because of cross compilation]))
AC_CHECK_FUNCS([dup2 dnl
memset dnl
regcomp dnl
strcasecmp dnl
strchr dnl
strdup dnl
strtol dnl
], [], [AC_MSG_ERROR(required library function not found on your system)])
# Optional library functions
AC_CHECK_FUNCS([dnl
pow dnl Used only by "examples/manual/expr"
setlocale dnl Needed only if NLS is enabled
reallocarray dnl OpenBSD function. We have replacement if not available.
])
AC_CONFIG_FILES(
Makefile
@@ -118,7 +175,6 @@ doc/Makefile
examples/Makefile
examples/fastwc/Makefile
examples/manual/Makefile
lib/Makefile
po/Makefile.in
src/Makefile
tools/Makefile
+9 -26
View File
@@ -1,31 +1,14 @@
help2man = @HELP2MAN@
FLEX = $(top_builddir)/src/flex$(EXEEXT)
info_TEXINFOS = flex.texi
dist_man_MANS = flex.1
dist_doc_DATA= flex.pdf
MAINTAINERCLEANFILES = flex.1
CLEANFILES = \
flex.aux \
flex.cp \
flex.cps \
flex.fn \
flex.fns \
flex.hk \
flex.hks \
flex.ky \
flex.log \
flex.op \
flex.ops \
flex.pg \
flex.toc \
flex.tp \
flex.tps \
flex.vr \
flex.vrs
CLEANFILES = *.aux *.cp *.cps *.fn *.fns *.hk *.hks *.ky *.log \
*.op *.ops *.pg *.toc *.tp *.tps *.vr *.vrs
$(dist_man_MANS): $(top_srcdir)/src/main.c
for i in $(dist_man_MANS) ; do \
$(help2man) --name='$(PACKAGE_NAME)' \
--section=`echo $$i | sed -e 's/.*\.\([^.]*\)$$/\1/'` \
$(top_srcdir)/src/flex$(EXEEXT) > $$i || rm -f $$i ; \
done
flex.1: $(top_srcdir)/configure.ac $(top_srcdir)/src/flex.skl $(top_srcdir)/src/options.c $(top_srcdir)/src/options.h | $(FLEX)
$(HELP2MAN) --name='$(PACKAGE_NAME)' --section=1 \
--source='The Flex Project' --manual='Programming' \
--output=$@ $(FLEX) \
|| rm -f $@
+27 -26
View File
@@ -296,8 +296,7 @@ Indices
@cindex reporting bugs
If you find a bug in @code{flex}, please report it using
the SourceForge Bug Tracking facilities which can be found on
@url{http://sourceforge.net/projects/flex,flex's SourceForge Page}.
GitHub's issue tracking facility at @url{https://github.com/westes/flex/issues/}
@node Introduction, Simple Examples, Reporting Bugs, Top
@chapter Introduction
@@ -409,7 +408,7 @@ A somewhat more complicated example:
"+"|"-"|"*"|"/" printf( "An operator: %s\n", yytext );
"{"[\^{}}\n]*"}" /* eat up one-line comments */
"{"[^{}\n]*"}" /* eat up one-line comments */
[ \t\n]+ /* eat up whitespace */
@@ -1492,15 +1491,14 @@ the scanning routine using a K&R-style/non-prototyped function
declaration, you must terminate the definition with a semi-colon (;).
@code{flex} generates @samp{C99} function definitions by
default. However flex does have the ability to generate obsolete, er,
@samp{traditional}, function definitions. This is to support
default. Flex used to have the ability to generate obsolete, er,
@samp{traditional}, function definitions. This was to support
bootstrapping gcc on old systems. Unfortunately, traditional
definitions prevent us from using any standard data types smaller than
int (such as short, char, or bool) as function arguments. For this
reason, future versions of @code{flex} may generate standard C99 code
only, leaving K&R-style functions to the historians. Currently, if you
do @strong{not} want @samp{C99} definitions, then you must use
@code{%option noansi-definitions}.
int (such as short, char, or bool) as function arguments. Furthermore,
traditional definitions support added extra complexity in the skeleton file.
For this reason, current versions of @code{flex} generate standard C99 code
only, leaving K&R-style functions to the historians.
@cindex stdin, default for yyin
@cindex yyin
@@ -2184,7 +2182,7 @@ manages its own input buffer stack manually (instead of letting flex do it).
}
<<EOF>> {
if ( --include_stack_ptr 0 )
if ( --include_stack_ptr == 0 )
{
yyterminate();
}
@@ -2861,19 +2859,13 @@ calls @code{yylex()} again).
@opindex ---option-ansi-definitions
@opindex ansi-definitions
@item --ansi-definitions, @code{%option ansi-definitions}
instruct flex to generate ANSI C99 definitions for functions.
This option is enabled by default.
If @code{%option noansi-definitions} is specified, then the obsolete style
is generated.
Deprecated, ignored
@anchor{option-ansi-prototypes}
@opindex ---option-ansi-prototypes
@opindex ansi-prototypes
@item --ansi-prototypes, @code{%option ansi-prototypes}
instructs flex to generate ANSI C99 prototypes for functions.
This option is enabled by default.
If @code{noansi-prototypes} is specified, then
prototypes will have empty parameter lists.
Deprecated, ignored
@anchor{option-bison-bridge}
@opindex ---bison-bridge
@@ -3764,8 +3756,7 @@ defaults to generating the scanner to the file @file{lex.yy.cc} instead
of @file{lex.yy.c}. The generated scanner includes the header file
@file{FlexLexer.h}, which defines the interface to two C++ classes.
The first class,
@code{FlexLexer},
The first class in @file{FlexLexer.h}, @code{FlexLexer},
provides an abstract base class defining the general scanner class
interface. It provides the following member functions:
@@ -3799,10 +3790,10 @@ returns the current setting of the debugging flag.
Also provided are member functions equivalent to
@code{yy_switch_to_buffer()}, @code{yy_create_buffer()} (though the
first argument is an @code{istream*} object pointer and not a
first argument is an @code{istream&} object reference and not a
@code{FILE*)}, @code{yy_flush_buffer()}, @code{yy_delete_buffer()}, and
@code{yyrestart()} (again, the first argument is a @code{istream*}
object pointer).
@code{yyrestart()} (again, the first argument is a @code{istream&}
object reference).
@tindex yyFlexLexer (C++ only)
@tindex FlexLexer (C++ only)
@@ -3813,9 +3804,12 @@ additional member functions:
@table @code
@findex yyFlexLexer constructor (C++ only)
@item yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 )
@item yyFlexLexer( istream& arg_yyin, ostream& arg_yyout )
constructs a @code{yyFlexLexer} object using the given streams for input
and output. If not specified, the streams default to @code{cin} and
@code{cout}, respectively.
@code{cout}, respectively. @code{yyFlexLexer} does not take ownership of
its stream arguments. It's up to the user to ensure the streams pointed
to remain alive at least as long as the @code{yyFlexLexer} instance.
@findex yylex (C++ version)
@item virtual int yylex()
@@ -3832,11 +3826,13 @@ instead of @code{yyFlexLexer}. In this case, rather than generating
@findex switch_streams (C++ only)
@item virtual void switch_streams(istream* new_in = 0, ostream* new_out = 0)
@item virtual void switch_streams(istream& new_in, ostream& new_out)
reassigns @code{yyin} to @code{new_in} (if non-null) and @code{yyout} to
@code{new_out} (if non-null), deleting the previous input buffer if
@code{yyin} is reassigned.
@item int yylex( istream* new_in, ostream* new_out = 0 )
@item int yylex( istream& new_in, ostream& new_out )
first switches the input streams via @code{switch_streams( new_in,
new_out )} and then returns the value of @code{yylex()}.
@end table
@@ -3893,7 +3889,7 @@ Here is an example of a simple C++ scanner:
int mylineno = 0;
%}
%option noyywrap
%option noyywrap c++
string \"[^\n"]+\"
@@ -3938,6 +3934,9 @@ Here is an example of a simple C++ scanner:
%%
// This include is required if main() is an another source file.
//#include <FlexLexer.h>
int main( int /* argc */, char** /* argv */ )
{
FlexLexer* lexer = new yyFlexLexer;
@@ -4910,8 +4909,10 @@ custom allocator through @code{yyextra}.
%option reentrant
/* Initialize the allocator. */
%{
#define YY_EXTRA_TYPE struct allocator*
#define YY_USER_INIT yyextra = allocator_create();
%}
%%
.|\n ;
+3 -3
View File
@@ -39,13 +39,13 @@ number {num1}|{num2}
}
}
{number} FLEX_STD cout << "number " << YYText() << '\n';
{number} std::cout << "number " << YYText() << '\n';
\n mylineno++;
{name} FLEX_STD cout << "name " << YYText() << '\n';
{name} std::cout << "name " << YYText() << '\n';
{string} FLEX_STD cout << "string " << YYText() << '\n';
{string} std::cout << "string " << YYText() << '\n';
%%
-4
View File
@@ -1,4 +0,0 @@
noinst_LTLIBRARIES = libcompat.la
libcompat_la_SOURCES = lib.c
libcompat_la_LIBADD = $(LTLIBOBJS)
-7
View File
@@ -1,7 +0,0 @@
/* Since building an empty library could cause problems, we provide a
* function to go into the library. We could make this non-trivial by
* moving something that flex treats as a library function into this
* directory. */
void do_nothing(){ return;}
+125
View File
@@ -0,0 +1,125 @@
# ===========================================================================
# http://www.gnu.org/software/autoconf-archive/ax_prog_cc_for_build.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_PROG_CC_FOR_BUILD
#
# DESCRIPTION
#
# This macro searches for a C compiler that generates native executables,
# that is a C compiler that surely is not a cross-compiler. This can be
# useful if you have to generate source code at compile-time like for
# example GCC does.
#
# The macro sets the CC_FOR_BUILD and CPP_FOR_BUILD macros to anything
# needed to compile or link (CC_FOR_BUILD) and preprocess (CPP_FOR_BUILD).
# The value of these variables can be overridden by the user by specifying
# a compiler with an environment variable (like you do for standard CC).
#
# It also sets BUILD_EXEEXT and BUILD_OBJEXT to the executable and object
# file extensions for the build platform, and GCC_FOR_BUILD to `yes' if
# the compiler we found is GCC. All these variables but GCC_FOR_BUILD are
# substituted in the Makefile.
#
# LICENSE
#
# Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org>
#
# Copying and distribution of this file, with or without modification, are
# permitted in any medium without royalty provided the copyright notice
# and this notice are preserved. This file is offered as-is, without any
# warranty.
#serial 8
AU_ALIAS([AC_PROG_CC_FOR_BUILD], [AX_PROG_CC_FOR_BUILD])
AC_DEFUN([AX_PROG_CC_FOR_BUILD], [dnl
AC_REQUIRE([AC_PROG_CC])dnl
AC_REQUIRE([AC_PROG_CPP])dnl
AC_REQUIRE([AC_EXEEXT])dnl
AC_REQUIRE([AC_CANONICAL_HOST])dnl
dnl Use the standard macros, but make them use other variable names
dnl
pushdef([ac_cv_prog_CPP], ac_cv_build_prog_CPP)dnl
pushdef([ac_cv_prog_gcc], ac_cv_build_prog_gcc)dnl
pushdef([ac_cv_prog_cc_works], ac_cv_build_prog_cc_works)dnl
pushdef([ac_cv_prog_cc_cross], ac_cv_build_prog_cc_cross)dnl
pushdef([ac_cv_prog_cc_g], ac_cv_build_prog_cc_g)dnl
pushdef([ac_cv_exeext], ac_cv_build_exeext)dnl
pushdef([ac_cv_objext], ac_cv_build_objext)dnl
pushdef([ac_exeext], ac_build_exeext)dnl
pushdef([ac_objext], ac_build_objext)dnl
pushdef([CC], CC_FOR_BUILD)dnl
pushdef([CPP], CPP_FOR_BUILD)dnl
pushdef([CFLAGS], CFLAGS_FOR_BUILD)dnl
pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD)dnl
pushdef([LDFLAGS], LDFLAGS_FOR_BUILD)dnl
pushdef([host], build)dnl
pushdef([host_alias], build_alias)dnl
pushdef([host_cpu], build_cpu)dnl
pushdef([host_vendor], build_vendor)dnl
pushdef([host_os], build_os)dnl
pushdef([ac_cv_host], ac_cv_build)dnl
pushdef([ac_cv_host_alias], ac_cv_build_alias)dnl
pushdef([ac_cv_host_cpu], ac_cv_build_cpu)dnl
pushdef([ac_cv_host_vendor], ac_cv_build_vendor)dnl
pushdef([ac_cv_host_os], ac_cv_build_os)dnl
pushdef([ac_cpp], ac_build_cpp)dnl
pushdef([ac_compile], ac_build_compile)dnl
pushdef([ac_link], ac_build_link)dnl
save_cross_compiling=$cross_compiling
save_ac_tool_prefix=$ac_tool_prefix
cross_compiling=no
ac_tool_prefix=
AC_PROG_CC
AC_PROG_CPP
AC_EXEEXT
ac_tool_prefix=$save_ac_tool_prefix
cross_compiling=$save_cross_compiling
dnl Restore the old definitions
dnl
popdef([ac_link])dnl
popdef([ac_compile])dnl
popdef([ac_cpp])dnl
popdef([ac_cv_host_os])dnl
popdef([ac_cv_host_vendor])dnl
popdef([ac_cv_host_cpu])dnl
popdef([ac_cv_host_alias])dnl
popdef([ac_cv_host])dnl
popdef([host_os])dnl
popdef([host_vendor])dnl
popdef([host_cpu])dnl
popdef([host_alias])dnl
popdef([host])dnl
popdef([LDFLAGS])dnl
popdef([CPPFLAGS])dnl
popdef([CFLAGS])dnl
popdef([CPP])dnl
popdef([CC])dnl
popdef([ac_objext])dnl
popdef([ac_exeext])dnl
popdef([ac_cv_objext])dnl
popdef([ac_cv_exeext])dnl
popdef([ac_cv_prog_cc_g])dnl
popdef([ac_cv_prog_cc_cross])dnl
popdef([ac_cv_prog_cc_works])dnl
popdef([ac_cv_prog_gcc])dnl
popdef([ac_cv_prog_CPP])dnl
dnl Finally, set Makefile variables
dnl
BUILD_EXEEXT=$ac_build_exeext
BUILD_OBJEXT=$ac_build_objext
AC_SUBST(BUILD_EXEEXT)dnl
AC_SUBST(BUILD_OBJEXT)dnl
AC_SUBST([CFLAGS_FOR_BUILD])dnl
AC_SUBST([CPPFLAGS_FOR_BUILD])dnl
AC_SUBST([LDFLAGS_FOR_BUILD])dnl
])
+38 -1
View File
@@ -8,7 +8,7 @@ subdir = po
top_builddir = ..
# These options get passed to xgettext.
XGETTEXT_OPTIONS = --keyword=_ --keyword=N_
XGETTEXT_OPTIONS = --language=C --keyword=_ --keyword=N_
# This is the copyright holder that gets inserted into the header of the
# $(DOMAIN).pot file. Set this to the copyright holder of the surrounding
@@ -20,6 +20,13 @@ XGETTEXT_OPTIONS = --keyword=_ --keyword=N_
# their copyright.
COPYRIGHT_HOLDER =
# This tells whether or not to prepend "GNU " prefix to the package
# name that gets inserted into the header of the $(DOMAIN).pot file.
# Possible values are "yes", "no", or empty. If it is empty, try to
# detect it automatically by scanning the files in $(top_srcdir) for
# "GNU packagename" string.
PACKAGE_GNU = "no"
# This is the email address or URL to which the translators shall report
# bugs in the untranslated strings:
# - Strings which are not entire sentences, see the maintainer guidelines
@@ -39,3 +46,33 @@ MSGID_BUGS_ADDRESS = flex-devel@lists.sourceforge.net
# This is the list of locale categories, beyond LC_MESSAGES, for which the
# message catalogs shall be used. It is usually empty.
EXTRA_LOCALE_CATEGORIES =
# This tells whether the $(DOMAIN).pot file contains messages with an 'msgctxt'
# context. Possible values are "yes" and "no". Set this to yes if the
# package uses functions taking also a message context, like pgettext(), or
# if in $(XGETTEXT_OPTIONS) you define keywords with a context argument.
USE_MSGCTXT = no
# These options get passed to msgmerge.
# Useful options are in particular:
# --previous to keep previous msgids of translated messages,
# --quiet to reduce the verbosity.
MSGMERGE_OPTIONS =
# These options get passed to msginit.
# If you want to disable line wrapping when writing PO files, add
# --no-wrap to MSGMERGE_OPTIONS, XGETTEXT_OPTIONS, and
# MSGINIT_OPTIONS.
MSGINIT_OPTIONS =
# This tells whether or not to regenerate a PO file when $(DOMAIN).pot
# has changed. Possible values are "yes" and "no". Set this to no if
# the POT file is checked in the repository and the version control
# program ignores timestamps.
PO_DEPENDS_ON_POT = yes
# This tells whether or not to forcibly update $(DOMAIN).pot and
# regenerate PO files on "make dist". Possible values are "yes" and
# "no". Set this to no if the POT file and PO files are maintained
# externally.
DIST_DEPENDS_ON_UPDATE_PO = no
-1
View File
@@ -12,7 +12,6 @@ src/options.c
src/parse.y
src/scan.l
src/scanopt.c
src/skel.c
src/sym.c
src/tblcmp.c
src/yylex.c
-9
View File
@@ -1,9 +0,0 @@
# Rules to fetch the translation project's po files for a domain
# Just rsync the *.po files for a particular textual domain into the
# po/ subdirectory of the project's source tree
getpo:
rsync -Ltvz translationproject.org::tp/latest/flex/*.po $(top_srcdir)/po
.PHONY: getpo
+260 -202
View File
File diff suppressed because it is too large Load Diff
+240 -174
View File
File diff suppressed because it is too large Load Diff
+230 -189
View File
File diff suppressed because it is too large Load Diff
+212 -182
View File
File diff suppressed because it is too large Load Diff
+398 -191
View File
File diff suppressed because it is too large Load Diff
+238 -194
View File
File diff suppressed because it is too large Load Diff
+249 -199
View File
File diff suppressed because it is too large Load Diff
+284 -212
View File
File diff suppressed because it is too large Load Diff
+192 -174
View File
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: flex 2.5.37\n"
"Report-Msgid-Bugs-To: flex-devel@lists.sourceforge.net\n"
"POT-Creation-Date: 2012-07-22 20:48-0400\n"
"POT-Creation-Date: 2017-05-06 10:49-0400\n"
"PO-Revision-Date: 2012-10-05 16:48+0200\n"
"Last-Translator: Tomislav Krznar <tomislav.krznar@gmail.com>\n"
"Language-Team: Croatian <lokalizacija@linux.hr>\n"
@@ -15,56 +15,58 @@ msgstr ""
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Generator: Lokalize 1.4\n"
#: buf.c:78
#: src/buf.c:79
msgid "Allocation of buffer to print string failed"
msgstr ""
#: buf.c:100
#: src/buf.c:107
msgid "Allocation of buffer for line directive failed"
msgstr ""
#: buf.c:177
#: src/buf.c:177
msgid "Allocation of buffer for m4 def failed"
msgstr ""
#: buf.c:197
#: src/buf.c:198
msgid "Allocation of buffer for m4 undef failed"
msgstr ""
#: dfa.c:61
#: src/dfa.c:59
#, c-format
msgid "State #%d is non-accepting -\n"
msgstr ""
#: dfa.c:124
#: src/dfa.c:119
msgid "dangerous trailing context"
msgstr ""
#: dfa.c:166
#: src/dfa.c:159
#, c-format
msgid " associated rule line numbers:"
msgstr ""
#: dfa.c:202
#: src/dfa.c:193
#, c-format
msgid " out-transitions: "
msgstr ""
#: dfa.c:210
#: src/dfa.c:201
#, c-format
msgid ""
"\n"
" jam-transitions: EOF "
msgstr ""
#: dfa.c:341
#: src/dfa.c:331
msgid "consistency check failed in epsclosure()"
msgstr ""
#: dfa.c:429
#: src/dfa.c:419
msgid ""
"\n"
"\n"
@@ -72,24 +74,24 @@ msgid ""
"\n"
msgstr ""
#: dfa.c:604
#: src/dfa.c:587
msgid "could not create unique end-of-buffer state"
msgstr ""
#: dfa.c:625
#: src/dfa.c:608
#, c-format
msgid "state # %d:\n"
msgstr ""
#: dfa.c:785
#: src/dfa.c:768
msgid "Could not write yynxt_tbl[][]"
msgstr ""
#: dfa.c:1049
#: src/dfa.c:1028
msgid "bad transition character detected in sympartition()"
msgstr ""
#: gen.c:478
#: src/gen.c:480
msgid ""
"\n"
"\n"
@@ -97,420 +99,426 @@ msgid ""
"\n"
msgstr ""
#: gen.c:662 gen.c:691 gen.c:1215
#: src/gen.c:669 src/gen.c:698 src/gen.c:1218
#, c-format
msgid "state # %d accepts: [%d]\n"
msgstr ""
#: gen.c:1110
#: src/gen.c:1115
#, c-format
msgid "state # %d accepts: "
msgstr ""
#: gen.c:1157
#: src/gen.c:1162
msgid "Could not write yyacclist_tbl"
msgstr ""
#: gen.c:1233
#: src/gen.c:1236
msgid "Could not write yyacc_tbl"
msgstr ""
#: gen.c:1248 gen.c:1633 gen.c:1656
#: src/gen.c:1251 src/gen.c:1623 src/gen.c:1646
msgid "Could not write ecstbl"
msgstr ""
#: gen.c:1271
#: src/gen.c:1271
msgid ""
"\n"
"\n"
"Meta-Equivalence Classes:\n"
msgstr ""
#: gen.c:1293
#: src/gen.c:1293
msgid "Could not write yymeta_tbl"
msgstr ""
#: gen.c:1354
#: src/gen.c:1352
msgid "Could not write yybase_tbl"
msgstr ""
#: gen.c:1388
#: src/gen.c:1384
msgid "Could not write yydef_tbl"
msgstr ""
#: gen.c:1428
#: src/gen.c:1422
msgid "Could not write yynxt_tbl"
msgstr ""
#: gen.c:1464
#: src/gen.c:1456
msgid "Could not write yychk_tbl"
msgstr ""
#: gen.c:1618 gen.c:1647
#: src/gen.c:1608 src/gen.c:1637
msgid "Could not write ftbl"
msgstr ""
#: gen.c:1624
#: src/gen.c:1614
msgid "Could not write ssltbl"
msgstr ""
#: gen.c:1675
#: src/gen.c:1665
msgid "Could not write eoltbl"
msgstr ""
#: gen.c:1735
#: src/gen.c:1722
msgid "Could not write yynultrans_tbl"
msgstr ""
#: main.c:189
#: src/main.c:178
msgid "rule cannot be matched"
msgstr ""
#: main.c:194
#: src/main.c:183
msgid "-s option given but default rule can be matched"
msgstr ""
#: main.c:234
#: src/main.c:221
msgid "Can't use -+ with -l option"
msgstr ""
#: main.c:237
#: src/main.c:224
msgid "Can't use -f or -F with -l option"
msgstr ""
#: main.c:241
#: src/main.c:228
msgid "Can't use --reentrant or --bison-bridge with -l option"
msgstr ""
#: main.c:278
#: src/main.c:260
msgid "-Cf/-CF and -Cm don't make sense together"
msgstr ""
#: main.c:281
#: src/main.c:263
msgid "-Cf/-CF and -I are incompatible"
msgstr ""
#: main.c:285
#: src/main.c:267
msgid "-Cf/-CF are incompatible with lex-compatibility mode"
msgstr ""
#: main.c:290
#: src/main.c:272
msgid "-Cf and -CF are mutually exclusive"
msgstr ""
#: main.c:294
#: src/main.c:276
msgid "Can't use -+ with -CF option"
msgstr ""
#: main.c:297
#: src/main.c:279
#, c-format
msgid "%array incompatible with -+ option"
msgstr ""
#: main.c:302
#: src/main.c:284
msgid "Options -+ and --reentrant are mutually exclusive."
msgstr ""
#: main.c:305
#: src/main.c:287
msgid "bison bridge not supported for the C++ scanner."
msgstr ""
#: main.c:360 main.c:406
#: src/main.c:336 src/main.c:419
#, c-format
msgid "could not create %s"
msgstr ""
#: main.c:419
#: src/main.c:431
msgid "could not write tables header"
msgstr ""
#: main.c:423
#: src/main.c:435
#, c-format
msgid "can't open skeleton file %s"
msgstr ""
#: main.c:459
#: src/main.c:450
msgid "Prefix cannot include '[' or ']'"
msgstr ""
#: src/main.c:474
msgid "allocation of macro definition failed"
msgstr ""
#: main.c:507
#: src/main.c:521
#, c-format
msgid "input error reading skeleton file %s"
msgstr ""
#: main.c:511
#: src/main.c:525
#, c-format
msgid "error closing skeleton file %s"
msgstr "greška pri zatvaranju datoteke predloška %s"
#: main.c:696
#: src/main.c:709
#, c-format
msgid "error creating header file %s"
msgstr "greška pri stvaranju datoteke zaglavlja %s"
#: main.c:704
#: src/main.c:717
#, c-format
msgid "error writing output file %s"
msgstr "greška pri pisanju izlazne datoteke %s"
#: main.c:708
#: src/main.c:721
#, c-format
msgid "error closing output file %s"
msgstr "greška pri zatvaranju izlazne datoteke %s"
#: main.c:712
#: src/main.c:725
#, c-format
msgid "error deleting output file %s"
msgstr "greška pri uklanjanju izlazne datoteke %s"
#: main.c:719
#: src/main.c:732
#, c-format
msgid "No backing up.\n"
msgstr ""
#: main.c:723
#: src/main.c:736
#, c-format
msgid "%d backing up (non-accepting) states.\n"
msgstr ""
#: main.c:727
#: src/main.c:740
#, c-format
msgid "Compressed tables always back up.\n"
msgstr ""
#: main.c:730
#: src/main.c:743
#, c-format
msgid "error writing backup file %s"
msgstr ""
#: main.c:734
#: src/main.c:747
#, c-format
msgid "error closing backup file %s"
msgstr ""
#: main.c:739
#: src/main.c:752
#, c-format
msgid "%s version %s usage statistics:\n"
msgstr ""
#: main.c:742
#: src/main.c:755
#, c-format
msgid " scanner options: -"
msgstr ""
#: main.c:821
#: src/main.c:834
#, c-format
msgid " %d/%d NFA states\n"
msgstr ""
#: main.c:823
#: src/main.c:836
#, c-format
msgid " %d/%d DFA states (%d words)\n"
msgstr ""
#: main.c:825
#: src/main.c:838
#, c-format
msgid " %d rules\n"
msgstr ""
#: main.c:830
#: src/main.c:843
#, c-format
msgid " No backing up\n"
msgstr ""
#: main.c:834
#: src/main.c:847
#, c-format
msgid " %d backing-up (non-accepting) states\n"
msgstr ""
#: main.c:839
#: src/main.c:852
#, c-format
msgid " Compressed tables always back-up\n"
msgstr ""
#: main.c:843
#: src/main.c:856
#, c-format
msgid " Beginning-of-line patterns used\n"
msgstr ""
#: main.c:845
#: src/main.c:858
#, c-format
msgid " %d/%d start conditions\n"
msgstr ""
#: main.c:849
#: src/main.c:862
#, c-format
msgid " %d epsilon states, %d double epsilon states\n"
msgstr ""
#: main.c:853
#: src/main.c:866
#, c-format
msgid " no character classes\n"
msgstr ""
#: main.c:857
#: src/main.c:870
#, c-format
msgid " %d/%d character classes needed %d/%d words of storage, %d reused\n"
msgstr ""
#: main.c:862
#: src/main.c:875
#, c-format
msgid " %d state/nextstate pairs created\n"
msgstr ""
#: main.c:865
#: src/main.c:878
#, c-format
msgid " %d/%d unique/duplicate transitions\n"
msgstr ""
#: main.c:870
#: src/main.c:883
#, c-format
msgid " %d table entries\n"
msgstr ""
#: main.c:878
#: src/main.c:891
#, c-format
msgid " %d/%d base-def entries created\n"
msgstr ""
#: main.c:882
#: src/main.c:895
#, c-format
msgid " %d/%d (peak %d) nxt-chk entries created\n"
msgstr ""
#: main.c:886
#: src/main.c:899
#, c-format
msgid " %d/%d (peak %d) template nxt-chk entries created\n"
msgstr ""
#: main.c:890
#: src/main.c:903
#, c-format
msgid " %d empty table entries\n"
msgstr ""
#: main.c:892
#: src/main.c:905
#, c-format
msgid " %d protos created\n"
msgstr ""
#: main.c:895
#: src/main.c:908
#, c-format
msgid " %d templates created, %d uses\n"
msgstr ""
#: main.c:903
#: src/main.c:916
#, c-format
msgid " %d/%d equivalence classes created\n"
msgstr ""
#: main.c:911
#: src/main.c:924
#, c-format
msgid " %d/%d meta-equivalence classes created\n"
msgstr ""
#: main.c:917
#: src/main.c:930
#, c-format
msgid " %d (%d saved) hash collisions, %d DFAs equal\n"
msgstr ""
#: main.c:919
#: src/main.c:932
#, c-format
msgid " %d sets of reallocations needed\n"
msgstr ""
#: main.c:921
#: src/main.c:934
#, c-format
msgid " %d total table entries needed\n"
msgstr ""
#: main.c:998
#: src/main.c:1008
#, c-format
msgid "Internal error. flexopts are malformed.\n"
msgstr ""
#: main.c:1008
#: src/main.c:1018
#, c-format
msgid "Try `%s --help' for more information.\n"
msgstr "Pokušajte „%s --help” za više informacija.\n"
#: main.c:1065
#: src/main.c:1075
#, c-format
msgid "unknown -C option '%c'"
msgstr "nepoznata -C opcija „%c”"
#: main.c:1194
#: src/main.c:1204
#, c-format
msgid "%s %s\n"
msgstr "%s %s\n"
#: main.c:1469
#: src/main.c:1476
msgid "fatal parse error"
msgstr "fatalna greška analize"
#: main.c:1501
#: src/main.c:1508
#, c-format
msgid "could not create backing-up info file %s"
msgstr ""
#: main.c:1522
#: src/main.c:1529
#, c-format
msgid "-l AT&T lex compatibility option entails a large performance penalty\n"
msgstr ""
#: main.c:1525
#: src/main.c:1532
#, c-format
msgid " and may be the actual source of other reported performance penalties\n"
msgstr ""
#: main.c:1531
#: src/main.c:1538
#, c-format
msgid "%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"
msgid ""
"%%option yylineno entails a performance penalty ONLY on rules that can match "
"newline characters\n"
msgstr ""
#: main.c:1538
#: src/main.c:1545
#, c-format
msgid "-I (interactive) entails a minor performance penalty\n"
msgstr ""
#: main.c:1543
#: src/main.c:1550
#, c-format
msgid "yymore() entails a minor performance penalty\n"
msgstr ""
#: main.c:1549
#: src/main.c:1556
#, c-format
msgid "REJECT entails a large performance penalty\n"
msgstr ""
#: main.c:1554
#: src/main.c:1561
#, c-format
msgid "Variable trailing context rules entail a large performance penalty\n"
msgstr ""
#: main.c:1566
#: src/main.c:1573
msgid "REJECT cannot be used with -f or -F"
msgstr ""
#: main.c:1569
#: src/main.c:1576
#, c-format
msgid "%option yylineno cannot be used with REJECT"
msgstr ""
#: main.c:1572
#: src/main.c:1579
msgid "variable trailing context rules cannot be used with -f or -F"
msgstr ""
#: main.c:1695
#: src/main.c:1704
#, c-format
msgid "%option yyclass only meaningful for C++ scanners"
msgstr ""
#: main.c:1802
#: src/main.c:1791
#, c-format
msgid "Usage: %s [OPTIONS] [FILE]...\n"
msgstr "Uporaba: %s [OPCIJE] [DATOTEKA]...\n"
#: main.c:1805
#: src/main.c:1794
#, c-format
msgid ""
"Generates programs that perform pattern-matching on text.\n"
@@ -534,13 +542,16 @@ msgid ""
" -T, --trace %s should run in trace mode\n"
" -w, --nowarn do not generate warnings\n"
" -v, --verbose write summary of scanner statistics to stdout\n"
" --hex use hexadecimal numbers instead of octal in debug "
"outputs\n"
"\n"
"Files:\n"
" -o, --outfile=FILE specify output filename\n"
" -S, --skel=FILE specify skeleton file\n"
" -t, --stdout write scanner on stdout instead of %s\n"
" --yyclass=NAME name of C++ class\n"
" --header-file=FILE create a C header file in addition to the scanner\n"
" --header-file=FILE create a C header file in addition to the "
"scanner\n"
" --tables-file[=FILE] write tables to FILE\n"
"\n"
"Scanner behavior:\n"
@@ -562,8 +573,6 @@ msgid ""
" --bison-bridge scanner for bison pure parser.\n"
" --bison-locations include yylloc support.\n"
" --stdinit initialize yyin/yyout to stdin/stdout\n"
" --noansi-definitions old-style function definitions\n"
" --noansi-prototypes empty parameter list in prototypes\n"
" --nounistd do not include <unistd.h>\n"
" --noFUNCTION do not generate a particular FUNCTION\n"
"\n"
@@ -575,51 +584,52 @@ msgid ""
" -V, --version report %s version\n"
msgstr ""
#: misc.c:65
#: src/misc.c:64
msgid "allocation of sko_stack failed"
msgstr ""
#: misc.c:102 misc.c:128
#: src/misc.c:100
#, c-format
msgid "name \"%s\" ridiculously long"
msgstr ""
#: misc.c:177
#: src/misc.c:155
msgid "memory allocation failed in allocate_array()"
msgstr ""
#: misc.c:230
#: src/misc.c:205
#, c-format
msgid "bad character '%s' detected in check_char()"
msgstr ""
#: misc.c:235
#: src/misc.c:210
#, c-format
msgid "scanner requires -8 flag to use the character %s"
msgstr ""
#: misc.c:268
msgid "dynamic memory failure in copy_string()"
msgstr ""
#: src/misc.c:229
#, fuzzy
msgid "memory allocation failure in xstrdup()"
msgstr "alokacija memorije za tablicu simbola nije uspjela"
#: misc.c:367
#: src/misc.c:303
#, c-format
msgid "%s: fatal internal error, %s\n"
msgstr ""
#: misc.c:803
#: src/misc.c:671
msgid "attempt to increase array size failed"
msgstr ""
#: misc.c:930
#: src/misc.c:795
msgid "bad line in skeleton file"
msgstr "neispravan redak u datoteci predloška"
#: misc.c:979
#: src/misc.c:845
msgid "memory allocation failed in yy_flex_xmalloc()"
msgstr ""
#: nfa.c:104
#: src/nfa.c:100
#, c-format
msgid ""
"\n"
@@ -627,226 +637,234 @@ msgid ""
"********** beginning dump of nfa with start state %d\n"
msgstr ""
#: nfa.c:115
#: src/nfa.c:111
#, c-format
msgid "state # %4d\t"
msgstr ""
#: nfa.c:130
#: src/nfa.c:126
#, c-format
msgid "********** end of dump\n"
msgstr ""
#: nfa.c:174
#: src/nfa.c:169
msgid "empty machine in dupmachine()"
msgstr ""
#: nfa.c:240
#: src/nfa.c:234
#, c-format
msgid "Variable trailing context rule at line %d\n"
msgstr ""
#: nfa.c:353
#: src/nfa.c:357
msgid "bad state type in mark_beginning_as_normal()"
msgstr ""
#: nfa.c:598
#: src/nfa.c:595
#, c-format
msgid "input rules are too complicated (>= %d NFA states)"
msgstr ""
#: nfa.c:677
#: src/nfa.c:673
msgid "found too many transitions in mkxtion()"
msgstr ""
#: nfa.c:703
#: src/nfa.c:699
#, c-format
msgid "too many rules (> %d)!"
msgstr "previše pravila (> %d)!"
#: parse.y:159
#: src/parse.y:159
msgid "unknown error processing section 1"
msgstr ""
#: parse.y:184 parse.y:351
#: src/parse.y:184 src/parse.y:353
msgid "bad start condition list"
msgstr ""
#: parse.y:315
#: src/parse.y:204
msgid "Prefix must not contain [ or ]"
msgstr ""
#: src/parse.y:317
msgid "unrecognized rule"
msgstr "neprepoznato pravilo"
#: parse.y:434 parse.y:447 parse.y:516
#: src/parse.y:436 src/parse.y:449 src/parse.y:518
msgid "trailing context used twice"
msgstr ""
#: parse.y:552 parse.y:562 parse.y:635 parse.y:645
#: src/parse.y:554 src/parse.y:564 src/parse.y:637 src/parse.y:647
msgid "bad iteration values"
msgstr "neispravne vrijednosti iteracije"
#: parse.y:580 parse.y:598 parse.y:663 parse.y:681
#: src/parse.y:582 src/parse.y:600 src/parse.y:665 src/parse.y:683
msgid "iteration value must be positive"
msgstr "vrijednost iteracije mora biti pozitivna"
#: parse.y:804 parse.y:814
#: src/parse.y:806 src/parse.y:816
#, c-format
msgid "the character range [%c-%c] is ambiguous in a case-insensitive scanner"
msgstr ""
#: parse.y:819
#: src/parse.y:821
msgid "negative range in character class"
msgstr ""
#: parse.y:916
#: src/parse.y:918
msgid "[:^lower:] is ambiguous in case insensitive scanner"
msgstr ""
#: parse.y:922
#: src/parse.y:924
msgid "[:^upper:] ambiguous in case insensitive scanner"
msgstr ""
#: scan.l:75 scan.l:618 scan.l:676
#: src/scan.l:82 src/scan.l:644 src/scan.l:702
msgid "Input line too long\n"
msgstr "Ulazni redak je predugačak\n"
#: scan.l:161
#: src/scan.l:183
#, c-format
msgid "malformed '%top' directive"
msgstr ""
#: scan.l:183
#: src/scan.l:205
#, no-c-format
msgid "unrecognized '%' directive"
msgstr ""
#: scan.l:192
#: src/scan.l:214
msgid "Definition name too long\n"
msgstr "Ime definicije je predugačko\n"
#: scan.l:284
#: src/scan.l:309
msgid "Unmatched '{'"
msgstr "Neuparena „{”"
#: scan.l:300
#: src/scan.l:325
#, c-format
msgid "Definition value for {%s} too long\n"
msgstr ""
#: scan.l:317
#: src/scan.l:342
msgid "incomplete name definition"
msgstr "nepotpuna definicija imena"
#: scan.l:443
#: src/scan.l:467
msgid "Option line too long\n"
msgstr "Redak opcija je predugačak\n"
#: scan.l:451
#: src/scan.l:475
#, c-format
msgid "unrecognized %%option: %s"
msgstr ""
#: scan.l:633 scan.l:800
#: src/scan.l:659 src/scan.l:832
msgid "bad character class"
msgstr "neispravan razred znakova"
#: scan.l:683
#: src/scan.l:709
#, c-format
msgid "undefined definition {%s}"
msgstr "nedefinirana definicija {%s}"
#: scan.l:755
#: src/scan.l:772
msgid "unbalanced parenthesis"
msgstr ""
#: src/scan.l:787
#, c-format
msgid "bad <start condition>: %s"
msgstr ""
#: scan.l:768
#: src/scan.l:800
msgid "missing quote"
msgstr "nedostaje navodnik"
#: scan.l:834
#: src/scan.l:866
#, c-format
msgid "bad character class expression: %s"
msgstr ""
#: scan.l:856
#: src/scan.l:888
msgid "bad character inside {}'s"
msgstr "neispravan znak unutar {}"
#: scan.l:862
#: src/scan.l:894
msgid "missing }"
msgstr "nedostaje }"
#: scan.l:940
#: src/scan.l:972
msgid "EOF encountered inside an action"
msgstr ""
#: scan.l:945
#: src/scan.l:977
msgid "EOF encountered inside pattern"
msgstr ""
#: scan.l:967
#: src/scan.l:1010
#, c-format
msgid "bad character: %s"
msgstr "neispravan znak: %s"
#: scan.l:996
#: src/scan.l:1038
#, c-format
msgid "can't open %s"
msgstr "ne mogu otvoriti %s"
#: scanopt.c:291
#: src/scanopt.c:259
#, c-format
msgid "Usage: %s [OPTIONS]...\n"
msgstr "Uporaba: %s [OPCIJE]...\n"
#: scanopt.c:564
#: src/scanopt.c:524
#, c-format
msgid "option `%s' doesn't allow an argument\n"
msgstr "opcija „%s” ne dozvoljava argument\n"
#: scanopt.c:569
#: src/scanopt.c:529
#, c-format
msgid "option `%s' requires an argument\n"
msgstr "opcija „%s” zahtijeva argument\n"
#: scanopt.c:573
#: src/scanopt.c:533
#, c-format
msgid "option `%s' is ambiguous\n"
msgstr "opcija „%s” je višeznačna\n"
#: scanopt.c:577
#: src/scanopt.c:537
#, c-format
msgid "Unrecognized option `%s'\n"
msgstr "Neprepoznata opcija „%s”\n"
#: scanopt.c:581
#: src/scanopt.c:541
#, c-format
msgid "Unknown error=(%d)\n"
msgstr "Nepoznata greška=(%d)\n"
#: sym.c:100
#: src/sym.c:92
msgid "symbol table memory allocation failed"
msgstr "alokacija memorije za tablicu simbola nije uspjela"
#: sym.c:202
#: src/sym.c:183
msgid "name defined twice"
msgstr "ime je dvaput definirano"
#: sym.c:253
#: src/sym.c:231
#, c-format
msgid "start condition %s declared twice"
msgstr ""
#: yylex.c:56
#: src/yylex.c:57
msgid "premature EOF"
msgstr "preuranjen EOF"
#: yylex.c:198
#: src/yylex.c:200
#, c-format
msgid "End Marker\n"
msgstr "Oznaka kraja\n"
#: yylex.c:204
#: src/yylex.c:206
#, c-format
msgid "*Something Weird* - tok: %d val: %d\n"
msgstr "*Nešto je čudno* - simbol: %d vrijednost: %d\n"
+908 -524
View File
File diff suppressed because it is too large Load Diff
+228 -188
View File
File diff suppressed because it is too large Load Diff
+224 -187
View File
File diff suppressed because it is too large Load Diff
+222 -186
View File
File diff suppressed because it is too large Load Diff
+292 -178
View File
File diff suppressed because it is too large Load Diff
+222 -184
View File
File diff suppressed because it is too large Load Diff
+226 -189
View File
File diff suppressed because it is too large Load Diff
+410 -456
View File
File diff suppressed because it is too large Load Diff
+276 -172
View File
File diff suppressed because it is too large Load Diff
+26
View File
@@ -0,0 +1,26 @@
#!/bin/sh
# shell for updating the translations before a release
# Let this be executed in the po/ subdir.
cd "$(dirname "$0")" || exit
echo "Updating translations via TP"
rsync -Lrtvz translationproject.org::tp/latest/flex/ . # || exit
# Are there now PO files that are not in svn yet?
NEWSTUFF=$(git status --porcelain *.po | grep "^??")
if [ -n "${NEWSTUFF}" ]; then
echo "New languages found; updating LINGUAS"
echo "# List of available languages." >LINGUAS
echo $(printf '%s\n' *.po | LC_ALL=C sort | sed 's/\.po//g') >>LINGUAS
fi
echo "Regenerating POT file and remerging and recompiling PO files..."
make update-po
# Ensure that the PO files are newer than the POT.
touch *.po
# Compile PO files
make
+239 -194
View File
File diff suppressed because it is too large Load Diff
+535 -306
View File
File diff suppressed because it is too large Load Diff
+194 -174
View File
@@ -8,7 +8,7 @@ msgid ""
msgstr ""
"Project-Id-Version: flex 2.5.37\n"
"Report-Msgid-Bugs-To: flex-devel@lists.sourceforge.net\n"
"POT-Creation-Date: 2012-07-22 20:48-0400\n"
"POT-Creation-Date: 2017-05-06 10:49-0400\n"
"PO-Revision-Date: 2013-02-12 23:23+0800\n"
"Last-Translator: Wei-Lun Chao <bluebat@member.fsf.org>\n"
"Language-Team: Chinese (traditional) <zh-l10n@linux.org.tw>\n"
@@ -16,44 +16,45 @@ msgstr ""
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
"Plural-Forms: nplurals=1; plural=0;\n"
#: buf.c:78
#: src/buf.c:79
msgid "Allocation of buffer to print string failed"
msgstr "給予緩衝區配額以列印字串時失敗"
#: buf.c:100
#: src/buf.c:107
msgid "Allocation of buffer for line directive failed"
msgstr "給予緩衝區配額用於列指令時失敗"
#: buf.c:177
#: src/buf.c:177
msgid "Allocation of buffer for m4 def failed"
msgstr "給予緩衝區配額用於 m4 def 時失敗"
#: buf.c:197
#: src/buf.c:198
msgid "Allocation of buffer for m4 undef failed"
msgstr "給予緩衝區配額用於 m4 undef 時失敗"
#: dfa.c:61
#: src/dfa.c:59
#, c-format
msgid "State #%d is non-accepting -\n"
msgstr "#%d 正處於非存取狀態 -\n"
#: dfa.c:124
#: src/dfa.c:119
msgid "dangerous trailing context"
msgstr "不安全的末端內文"
#: dfa.c:166
#: src/dfa.c:159
#, c-format
msgid " associated rule line numbers:"
msgstr " 關聯的規則列號:"
#: dfa.c:202
#: src/dfa.c:193
#, c-format
msgid " out-transitions: "
msgstr " 外轉換:"
#: dfa.c:210
#: src/dfa.c:201
#, c-format
msgid ""
"\n"
@@ -62,11 +63,11 @@ msgstr ""
"\n"
" 合併轉換:檔案結尾 "
#: dfa.c:341
#: src/dfa.c:331
msgid "consistency check failed in epsclosure()"
msgstr "epsclosure() 中的一致性檢查失敗"
#: dfa.c:429
#: src/dfa.c:419
msgid ""
"\n"
"\n"
@@ -78,24 +79,24 @@ msgstr ""
" DFA 傾印:\n"
"\n"
#: dfa.c:604
#: src/dfa.c:587
msgid "could not create unique end-of-buffer state"
msgstr "無法建立獨一的緩衝區結尾狀態"
#: dfa.c:625
#: src/dfa.c:608
#, c-format
msgid "state # %d:\n"
msgstr "狀態 # %d:\n"
#: dfa.c:785
#: src/dfa.c:768
msgid "Could not write yynxt_tbl[][]"
msgstr "無法寫入 yynxt_tbl[][]"
#: dfa.c:1049
#: src/dfa.c:1028
msgid "bad transition character detected in sympartition()"
msgstr "在 sympartition() 偵測到不當的轉換字元"
#: gen.c:478
#: src/gen.c:480
msgid ""
"\n"
"\n"
@@ -107,29 +108,29 @@ msgstr ""
"等價類別:\n"
"\n"
#: gen.c:662 gen.c:691 gen.c:1215
#: src/gen.c:669 src/gen.c:698 src/gen.c:1218
#, c-format
msgid "state # %d accepts: [%d]\n"
msgstr "狀態 # %d 接受:[%d]\n"
#: gen.c:1110
#: src/gen.c:1115
#, c-format
msgid "state # %d accepts: "
msgstr "狀態 # %d 接受:"
#: gen.c:1157
#: src/gen.c:1162
msgid "Could not write yyacclist_tbl"
msgstr "無法寫入 yyacclist_tbl"
#: gen.c:1233
#: src/gen.c:1236
msgid "Could not write yyacc_tbl"
msgstr "無法寫入 yyacc_tbl"
#: gen.c:1248 gen.c:1633 gen.c:1656
#: src/gen.c:1251 src/gen.c:1623 src/gen.c:1646
msgid "Could not write ecstbl"
msgstr "無法寫入 ecstbl"
#: gen.c:1271
#: src/gen.c:1271
msgid ""
"\n"
"\n"
@@ -139,392 +140,398 @@ msgstr ""
"\n"
" 後設等價類別:\n"
#: gen.c:1293
#: src/gen.c:1293
msgid "Could not write yymeta_tbl"
msgstr "無法寫入 yymeta_tbl"
#: gen.c:1354
#: src/gen.c:1352
msgid "Could not write yybase_tbl"
msgstr "無法寫入 yybase_tbl"
#: gen.c:1388
#: src/gen.c:1384
msgid "Could not write yydef_tbl"
msgstr "無法寫入 yydef_tbl"
#: gen.c:1428
#: src/gen.c:1422
msgid "Could not write yynxt_tbl"
msgstr "無法寫入 yynxt_tbl"
#: gen.c:1464
#: src/gen.c:1456
msgid "Could not write yychk_tbl"
msgstr "無法寫入 yychk_tbl"
#: gen.c:1618 gen.c:1647
#: src/gen.c:1608 src/gen.c:1637
msgid "Could not write ftbl"
msgstr "無法寫入 ftbl"
#: gen.c:1624
#: src/gen.c:1614
msgid "Could not write ssltbl"
msgstr "無法寫入 ssltbl"
#: gen.c:1675
#: src/gen.c:1665
msgid "Could not write eoltbl"
msgstr "無法寫入 eoltbl"
#: gen.c:1735
#: src/gen.c:1722
msgid "Could not write yynultrans_tbl"
msgstr "無法寫入 yynultrans_tbl"
#: main.c:189
#: src/main.c:178
msgid "rule cannot be matched"
msgstr "規則無法吻合"
#: main.c:194
#: src/main.c:183
msgid "-s option given but default rule can be matched"
msgstr "-s 選項已給定但是可以吻合預設規則"
#: main.c:234
#: src/main.c:221
msgid "Can't use -+ with -l option"
msgstr "無法將 -+ 與 -l 選項共同使用"
#: main.c:237
#: src/main.c:224
msgid "Can't use -f or -F with -l option"
msgstr "無法將 -f 或 -F 與 -l 選項共同使用"
#: main.c:241
#: src/main.c:228
msgid "Can't use --reentrant or --bison-bridge with -l option"
msgstr "無法將 --reentrant 或 --bison-bridge 與 -l 選項共同使用"
#: main.c:278
#: src/main.c:260
msgid "-Cf/-CF and -Cm don't make sense together"
msgstr "-Cf/-CF 和 -Cm 共用時不具任何意義"
#: main.c:281
#: src/main.c:263
msgid "-Cf/-CF and -I are incompatible"
msgstr "-Cf/-CF 和 -I 是不相容的"
#: main.c:285
#: src/main.c:267
msgid "-Cf/-CF are incompatible with lex-compatibility mode"
msgstr "-Cf/-CF 與 lex 相容模式是不相容的"
#: main.c:290
#: src/main.c:272
msgid "-Cf and -CF are mutually exclusive"
msgstr "-Cf 和 -CF 是互斥的"
#: main.c:294
#: src/main.c:276
msgid "Can't use -+ with -CF option"
msgstr "無法將 -+ 與 -CF 選項共同使用"
#: main.c:297
#: src/main.c:279
#, c-format
msgid "%array incompatible with -+ option"
msgstr "%array 與 -+ 選項不相容"
#: main.c:302
#: src/main.c:284
msgid "Options -+ and --reentrant are mutually exclusive."
msgstr "選項 -+ 和 --reentrant 是互斥的。"
#: main.c:305
#: src/main.c:287
msgid "bison bridge not supported for the C++ scanner."
msgstr "bison 橋接器不受 C++ 掃描程式支援。"
#: main.c:360 main.c:406
#: src/main.c:336 src/main.c:419
#, c-format
msgid "could not create %s"
msgstr "無法建立 %s"
#: main.c:419
#: src/main.c:431
msgid "could not write tables header"
msgstr "無法寫入表頭"
#: main.c:423
#: src/main.c:435
#, c-format
msgid "can't open skeleton file %s"
msgstr "無法開啟架構檔案 %s"
#: main.c:459
#: src/main.c:450
msgid "Prefix cannot include '[' or ']'"
msgstr ""
#: src/main.c:474
msgid "allocation of macro definition failed"
msgstr "給予巨集定義配額時失敗"
#: main.c:507
#: src/main.c:521
#, c-format
msgid "input error reading skeleton file %s"
msgstr "讀取架構檔案 %s 時輸入錯誤"
#: main.c:511
#: src/main.c:525
#, c-format
msgid "error closing skeleton file %s"
msgstr "關閉架構檔案 %s 時發生錯誤"
#: main.c:696
#: src/main.c:709
#, c-format
msgid "error creating header file %s"
msgstr "建立標頭檔案 %s 時發生錯誤"
#: main.c:704
#: src/main.c:717
#, c-format
msgid "error writing output file %s"
msgstr "寫入輸出檔案 %s 時發生錯誤"
#: main.c:708
#: src/main.c:721
#, c-format
msgid "error closing output file %s"
msgstr "關閉輸出檔案 %s 時發生錯誤"
#: main.c:712
#: src/main.c:725
#, c-format
msgid "error deleting output file %s"
msgstr "刪除輸出檔案 %s 時發生錯誤"
#: main.c:719
#: src/main.c:732
#, c-format
msgid "No backing up.\n"
msgstr "沒有備份。\n"
#: main.c:723
#: src/main.c:736
#, c-format
msgid "%d backing up (non-accepting) states.\n"
msgstr "%d 備份 (非接受) 狀態。\n"
#: main.c:727
#: src/main.c:740
#, c-format
msgid "Compressed tables always back up.\n"
msgstr "壓縮過的表格自動備份。\n"
#: main.c:730
#: src/main.c:743
#, c-format
msgid "error writing backup file %s"
msgstr "寫入備份檔案 %s 時發生錯誤"
#: main.c:734
#: src/main.c:747
#, c-format
msgid "error closing backup file %s"
msgstr "關閉備份檔案 %s 時發生錯誤"
#: main.c:739
#: src/main.c:752
#, c-format
msgid "%s version %s usage statistics:\n"
msgstr "%s 版本 %s 用法統計:\n"
#: main.c:742
#: src/main.c:755
#, c-format
msgid " scanner options: -"
msgstr " 掃描程式選項:-"
#: main.c:821
#: src/main.c:834
#, c-format
msgid " %d/%d NFA states\n"
msgstr " %d/%d NFA 狀態\n"
#: main.c:823
#: src/main.c:836
#, c-format
msgid " %d/%d DFA states (%d words)\n"
msgstr " %d/%d DFA 狀態 (%d 個字詞)\n"
#: main.c:825
#: src/main.c:838
#, c-format
msgid " %d rules\n"
msgstr " %d 條規則\n"
#: main.c:830
#: src/main.c:843
#, c-format
msgid " No backing up\n"
msgstr " 沒有備份\n"
#: main.c:834
#: src/main.c:847
#, c-format
msgid " %d backing-up (non-accepting) states\n"
msgstr " %d 備份 (非接受) 狀態\n"
#: main.c:839
#: src/main.c:852
#, c-format
msgid " Compressed tables always back-up\n"
msgstr " 壓縮過的表格自動備份\n"
#: main.c:843
#: src/main.c:856
#, c-format
msgid " Beginning-of-line patterns used\n"
msgstr " 列首式樣已使用\n"
#: main.c:845
#: src/main.c:858
#, c-format
msgid " %d/%d start conditions\n"
msgstr " %d/%d 起始條件\n"
#: main.c:849
#: src/main.c:862
#, c-format
msgid " %d epsilon states, %d double epsilon states\n"
msgstr " %d ε狀態,%d 雙倍ε狀態\n"
#: main.c:853
#: src/main.c:866
#, c-format
msgid " no character classes\n"
msgstr " 無字元類別\n"
#: main.c:857
#: src/main.c:870
#, c-format
msgid " %d/%d character classes needed %d/%d words of storage, %d reused\n"
msgstr " %d/%d 字元類別所需 %d/%d 字詞的儲存體,%d 重新使用\n"
#: main.c:862
#: src/main.c:875
#, c-format
msgid " %d state/nextstate pairs created\n"
msgstr " %d 狀態/下一狀態對已建立\n"
#: main.c:865
#: src/main.c:878
#, c-format
msgid " %d/%d unique/duplicate transitions\n"
msgstr " %d/%d 獨一/重複轉換\n"
#: main.c:870
#: src/main.c:883
#, c-format
msgid " %d table entries\n"
msgstr " %d 表格項目\n"
#: main.c:878
#: src/main.c:891
#, c-format
msgid " %d/%d base-def entries created\n"
msgstr " %d/%d base-def 項目已建立\n"
#: main.c:882
#: src/main.c:895
#, c-format
msgid " %d/%d (peak %d) nxt-chk entries created\n"
msgstr " %d/%d (尖峰 %d) nxt-chk 項目已建立\n"
#: main.c:886
#: src/main.c:899
#, c-format
msgid " %d/%d (peak %d) template nxt-chk entries created\n"
msgstr " %d/%d (尖峰 %d) 模板 nxt-chk 項目已建立\n"
#: main.c:890
#: src/main.c:903
#, c-format
msgid " %d empty table entries\n"
msgstr " %d 清空表格項目\n"
#: main.c:892
#: src/main.c:905
#, c-format
msgid " %d protos created\n"
msgstr " %d 原型已建立\n"
#: main.c:895
#: src/main.c:908
#, c-format
msgid " %d templates created, %d uses\n"
msgstr " %d 範本已建立,%d 使用\n"
#: main.c:903
#: src/main.c:916
#, c-format
msgid " %d/%d equivalence classes created\n"
msgstr " %d/%d 等價類別已建立\n"
#: main.c:911
#: src/main.c:924
#, c-format
msgid " %d/%d meta-equivalence classes created\n"
msgstr " %d/%d 後設等價類別已建立\n"
#: main.c:917
#: src/main.c:930
#, c-format
msgid " %d (%d saved) hash collisions, %d DFAs equal\n"
msgstr " %d (%d 已儲存) 雜湊碰撞,%d DFAs 相等\n"
#: main.c:919
#: src/main.c:932
#, c-format
msgid " %d sets of reallocations needed\n"
msgstr " 需要 %d 組重新配置\n"
#: main.c:921
#: src/main.c:934
#, c-format
msgid " %d total table entries needed\n"
msgstr " 總計需要 %d 表格項目\n"
#: main.c:998
#: src/main.c:1008
#, c-format
msgid "Internal error. flexopts are malformed.\n"
msgstr "內部錯誤。flexopts 功能異常。\n"
#: main.c:1008
#: src/main.c:1018
#, c-format
msgid "Try `%s --help' for more information.\n"
msgstr "嘗試「%s --help」以獲得更多資訊。\n"
#: main.c:1065
#: src/main.c:1075
#, c-format
msgid "unknown -C option '%c'"
msgstr "不明 -C 選項「%c」"
#: main.c:1194
#: src/main.c:1204
#, c-format
msgid "%s %s\n"
msgstr "%s %s\n"
#: main.c:1469
#: src/main.c:1476
msgid "fatal parse error"
msgstr "嚴重的解析錯誤"
#: main.c:1501
#: src/main.c:1508
#, c-format
msgid "could not create backing-up info file %s"
msgstr "無法建立備份資訊檔案 %s"
#: main.c:1522
#: src/main.c:1529
#, c-format
msgid "-l AT&T lex compatibility option entails a large performance penalty\n"
msgstr "-l AT&T lex 相容性選項會導致大幅效能減退\n"
#: main.c:1525
#: src/main.c:1532
#, c-format
msgid " and may be the actual source of other reported performance penalties\n"
msgstr " 同時也許是其他回報效能減退的實際來源\n"
#: main.c:1531
#: src/main.c:1538
#, c-format
msgid "%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"
msgid ""
"%%option yylineno entails a performance penalty ONLY on rules that can match "
"newline characters\n"
msgstr "%%option yylineno 導致效能減退,只有當該規則該吻合新列字元時才會\n"
#: main.c:1538
#: src/main.c:1545
#, c-format
msgid "-I (interactive) entails a minor performance penalty\n"
msgstr "-I (互動式) 導致小幅效能減退\n"
#: main.c:1543
#: src/main.c:1550
#, c-format
msgid "yymore() entails a minor performance penalty\n"
msgstr "yymore() 導致小幅效能減退\n"
#: main.c:1549
#: src/main.c:1556
#, c-format
msgid "REJECT entails a large performance penalty\n"
msgstr "REJECT 導致大幅效能減退\n"
#: main.c:1554
#: src/main.c:1561
#, c-format
msgid "Variable trailing context rules entail a large performance penalty\n"
msgstr "變數末尾內文規則導致大幅效能減退\n"
#: main.c:1566
#: src/main.c:1573
msgid "REJECT cannot be used with -f or -F"
msgstr "REJECT 無法與 -f 或 -F 共同使用"
#: main.c:1569
#: src/main.c:1576
#, c-format
msgid "%option yylineno cannot be used with REJECT"
msgstr "%option yylineno 無法與 REJECT 共同使用"
#: main.c:1572
#: src/main.c:1579
msgid "variable trailing context rules cannot be used with -f or -F"
msgstr "變數末尾內文規則無法與 -f 或 -F 共同使用"
#: main.c:1695
#: src/main.c:1704
#, c-format
msgid "%option yyclass only meaningful for C++ scanners"
msgstr "%option yyclass 只對於 C++ 掃描程式有意義"
#: main.c:1802
#: src/main.c:1791
#, c-format
msgid "Usage: %s [OPTIONS] [FILE]...\n"
msgstr "用法:%s [選項] [檔案]…\n"
#: main.c:1805
#, c-format
#: src/main.c:1794
#, fuzzy, c-format
msgid ""
"Generates programs that perform pattern-matching on text.\n"
"\n"
@@ -547,13 +554,16 @@ msgid ""
" -T, --trace %s should run in trace mode\n"
" -w, --nowarn do not generate warnings\n"
" -v, --verbose write summary of scanner statistics to stdout\n"
" --hex use hexadecimal numbers instead of octal in debug "
"outputs\n"
"\n"
"Files:\n"
" -o, --outfile=FILE specify output filename\n"
" -S, --skel=FILE specify skeleton file\n"
" -t, --stdout write scanner on stdout instead of %s\n"
" --yyclass=NAME name of C++ class\n"
" --header-file=FILE create a C header file in addition to the scanner\n"
" --header-file=FILE create a C header file in addition to the "
"scanner\n"
" --tables-file[=FILE] write tables to FILE\n"
"\n"
"Scanner behavior:\n"
@@ -575,8 +585,6 @@ msgid ""
" --bison-bridge scanner for bison pure parser.\n"
" --bison-locations include yylloc support.\n"
" --stdinit initialize yyin/yyout to stdin/stdout\n"
" --noansi-definitions old-style function definitions\n"
" --noansi-prototypes empty parameter list in prototypes\n"
" --nounistd do not include <unistd.h>\n"
" --noFUNCTION do not generate a particular FUNCTION\n"
"\n"
@@ -648,51 +656,52 @@ msgstr ""
" -h, --help 產生這個說明訊息\n"
" -V, --version 報告 %s 版本\n"
#: misc.c:65
#: src/misc.c:64
msgid "allocation of sko_stack failed"
msgstr "給予 sko_stack 配額時失敗"
#: misc.c:102 misc.c:128
#: src/misc.c:100
#, c-format
msgid "name \"%s\" ridiculously long"
msgstr "名稱「%s」有荒謬的長度"
#: misc.c:177
#: src/misc.c:155
msgid "memory allocation failed in allocate_array()"
msgstr "在 allocatearray() 中記憶體配置失敗"
#: misc.c:230
#: src/misc.c:205
#, c-format
msgid "bad character '%s' detected in check_char()"
msgstr "在 checkchar() 中偵測到不當的字元「%s」"
#: misc.c:235
#: src/misc.c:210
#, c-format
msgid "scanner requires -8 flag to use the character %s"
msgstr "掃描程式需要 -8 旗標以使用字元 %s"
#: misc.c:268
msgid "dynamic memory failure in copy_string()"
msgstr "在 copystring() 中動態記憶體失敗"
#: src/misc.c:229
#, fuzzy
msgid "memory allocation failure in xstrdup()"
msgstr "在 allocatearray() 中記憶體配置失敗"
#: misc.c:367
#: src/misc.c:303
#, c-format
msgid "%s: fatal internal error, %s\n"
msgstr "%s:嚴重內部錯誤,%s\n"
#: misc.c:803
#: src/misc.c:671
msgid "attempt to increase array size failed"
msgstr "試圖增加陣列大小時失敗"
#: misc.c:930
#: src/misc.c:795
msgid "bad line in skeleton file"
msgstr "架構檔案中不當的列"
#: misc.c:979
#: src/misc.c:845
msgid "memory allocation failed in yy_flex_xmalloc()"
msgstr "在 yy_flex_xmalloc() 中的記憶體配置失敗"
#: nfa.c:104
#: src/nfa.c:100
#, c-format
msgid ""
"\n"
@@ -703,226 +712,237 @@ msgstr ""
"\n"
"********** 開始輸出起始狀態為 %d 的 NFA\n"
#: nfa.c:115
#: src/nfa.c:111
#, c-format
msgid "state # %4d\t"
msgstr "狀態 # %4d\t"
#: nfa.c:130
#: src/nfa.c:126
#, c-format
msgid "********** end of dump\n"
msgstr "********** 傾印結束\n"
#: nfa.c:174
#: src/nfa.c:169
msgid "empty machine in dupmachine()"
msgstr "在 dupmachine() 中清空機器"
#: nfa.c:240
#: src/nfa.c:234
#, c-format
msgid "Variable trailing context rule at line %d\n"
msgstr "變數末尾內文規則於列 %d\n"
#: nfa.c:353
#: src/nfa.c:357
msgid "bad state type in mark_beginning_as_normal()"
msgstr "在 mark_beginning_as_normal() 中有不當的狀態輸入"
#: nfa.c:598
#: src/nfa.c:595
#, c-format
msgid "input rules are too complicated (>= %d NFA states)"
msgstr "輸入規則太複雜 (>= %d NFA 狀態)"
#: nfa.c:677
#: src/nfa.c:673
msgid "found too many transitions in mkxtion()"
msgstr "在 mkxtion() 中找到太多轉換"
#: nfa.c:703
#: src/nfa.c:699
#, c-format
msgid "too many rules (> %d)!"
msgstr "太多規則 (> %d)!"
#: parse.y:159
#: src/parse.y:159
msgid "unknown error processing section 1"
msgstr "不明的錯誤處理區段 1"
#: parse.y:184 parse.y:351
#: src/parse.y:184 src/parse.y:353
msgid "bad start condition list"
msgstr "不當的起始條件清單"
#: parse.y:315
#: src/parse.y:204
msgid "Prefix must not contain [ or ]"
msgstr ""
#: src/parse.y:317
msgid "unrecognized rule"
msgstr "無法辨識的規則"
#: parse.y:434 parse.y:447 parse.y:516
#: src/parse.y:436 src/parse.y:449 src/parse.y:518
msgid "trailing context used twice"
msgstr "末尾內文已使用兩次"
#: parse.y:552 parse.y:562 parse.y:635 parse.y:645
#: src/parse.y:554 src/parse.y:564 src/parse.y:637 src/parse.y:647
msgid "bad iteration values"
msgstr "不當的迭代值"
#: parse.y:580 parse.y:598 parse.y:663 parse.y:681
#: src/parse.y:582 src/parse.y:600 src/parse.y:665 src/parse.y:683
msgid "iteration value must be positive"
msgstr "迭代值必須是正值"
#: parse.y:804 parse.y:814
#: src/parse.y:806 src/parse.y:816
#, c-format
msgid "the character range [%c-%c] is ambiguous in a case-insensitive scanner"
msgstr "在大小寫不須相符的掃描程式中,字元範圍 [%c-%c] 是模稜兩可的"
#: parse.y:819
#: src/parse.y:821
msgid "negative range in character class"
msgstr "在字元類別中有負值範圍"
#: parse.y:916
#: src/parse.y:918
msgid "[:^lower:] is ambiguous in case insensitive scanner"
msgstr "在大小寫不須相符的掃描程式中,[:^lower:] 是模稜兩可的"
#: parse.y:922
#: src/parse.y:924
msgid "[:^upper:] ambiguous in case insensitive scanner"
msgstr "在大小寫不須相符的掃描程式中,[:^upper:] 是模稜兩可的"
#: scan.l:75 scan.l:618 scan.l:676
#: src/scan.l:82 src/scan.l:644 src/scan.l:702
msgid "Input line too long\n"
msgstr "輸入列太長\n"
#: scan.l:161
#: src/scan.l:183
#, c-format
msgid "malformed '%top' directive"
msgstr "異常的「%top」指令"
#: scan.l:183
#: src/scan.l:205
#, no-c-format
msgid "unrecognized '%' directive"
msgstr "無法辨識的「%」指令"
#: scan.l:192
#: src/scan.l:214
msgid "Definition name too long\n"
msgstr "定義名稱太長\n"
#: scan.l:284
#: src/scan.l:309
msgid "Unmatched '{'"
msgstr "不成對的「{」"
#: scan.l:300
#: src/scan.l:325
#, c-format
msgid "Definition value for {%s} too long\n"
msgstr "{%s} 的定義值太長\n"
#: scan.l:317
#: src/scan.l:342
msgid "incomplete name definition"
msgstr "不完整的名稱定義"
#: scan.l:443
#: src/scan.l:467
msgid "Option line too long\n"
msgstr "選項列太長\n"
#: scan.l:451
#: src/scan.l:475
#, c-format
msgid "unrecognized %%option: %s"
msgstr "無法辨識的 %%option:%s"
#: scan.l:633 scan.l:800
#: src/scan.l:659 src/scan.l:832
msgid "bad character class"
msgstr "不當的字元類別"
#: scan.l:683
#: src/scan.l:709
#, c-format
msgid "undefined definition {%s}"
msgstr "未定義的定義 {%s}"
#: scan.l:755
#: src/scan.l:772
msgid "unbalanced parenthesis"
msgstr ""
#: src/scan.l:787
#, c-format
msgid "bad <start condition>: %s"
msgstr "不當的 <起始條件>:%s"
#: scan.l:768
#: src/scan.l:800
msgid "missing quote"
msgstr "缺少引號"
#: scan.l:834
#: src/scan.l:866
#, c-format
msgid "bad character class expression: %s"
msgstr "不當的字元類別運算式:%s"
#: scan.l:856
#: src/scan.l:888
msgid "bad character inside {}'s"
msgstr "不當字元於 {} 內部"
#: scan.l:862
#: src/scan.l:894
msgid "missing }"
msgstr "缺少 }"
#: scan.l:940
#: src/scan.l:972
msgid "EOF encountered inside an action"
msgstr "在動作之內遇到檔案結束"
#: scan.l:945
#: src/scan.l:977
msgid "EOF encountered inside pattern"
msgstr "在式樣之內遇到檔案結束"
#: scan.l:967
#: src/scan.l:1010
#, c-format
msgid "bad character: %s"
msgstr "不當的字元:%s"
#: scan.l:996
#: src/scan.l:1038
#, c-format
msgid "can't open %s"
msgstr "無法開啟 %s"
#: scanopt.c:291
#: src/scanopt.c:259
#, c-format
msgid "Usage: %s [OPTIONS]...\n"
msgstr "用法:%s [選項]…\n"
#: scanopt.c:564
#: src/scanopt.c:524
#, c-format
msgid "option `%s' doesn't allow an argument\n"
msgstr "選項「%s」不允許任何引數\n"
#: scanopt.c:569
#: src/scanopt.c:529
#, c-format
msgid "option `%s' requires an argument\n"
msgstr "選項「%s」需要一個引數\n"
#: scanopt.c:573
#: src/scanopt.c:533
#, c-format
msgid "option `%s' is ambiguous\n"
msgstr "選項「%s」是模稜兩可的\n"
#: scanopt.c:577
#: src/scanopt.c:537
#, c-format
msgid "Unrecognized option `%s'\n"
msgstr "無法辨識的選項 %s\n"
#: scanopt.c:581
#: src/scanopt.c:541
#, c-format
msgid "Unknown error=(%d)\n"
msgstr "不明錯誤=(%d)\n"
#: sym.c:100
#: src/sym.c:92
msgid "symbol table memory allocation failed"
msgstr "符號表記憶體配置失敗"
#: sym.c:202
#: src/sym.c:183
msgid "name defined twice"
msgstr "名稱定義了兩次"
#: sym.c:253
#: src/sym.c:231
#, c-format
msgid "start condition %s declared twice"
msgstr "起始條件 %s 宣告了兩次"
#: yylex.c:56
#: src/yylex.c:57
msgid "premature EOF"
msgstr "過早出現檔案結尾"
#: yylex.c:198
#: src/yylex.c:200
#, c-format
msgid "End Marker\n"
msgstr "結束標誌\n"
#: yylex.c:204
#: src/yylex.c:206
#, c-format
msgid "*Something Weird* - tok: %d val: %d\n"
msgstr "*情況很怪異* - tok:%d val:%d\n"
#~ msgid "dynamic memory failure in copy_string()"
#~ msgstr "在 copystring() 中動態記憶體失敗"
+2
View File
@@ -8,3 +8,5 @@ parse.c
parse.h
scan.c
skel.c
stage1scan.[cl]
stage1flex
+115 -123
View File
@@ -35,80 +35,74 @@
// to rename each yyFlexLexer to some other xxFlexLexer. You then
// include <FlexLexer.h> in your other sources once per lexer class:
//
// #undef yyFlexLexer
// #define yyFlexLexer xxFlexLexer
// #include <FlexLexer.h>
// #undef yyFlexLexer
// #define yyFlexLexer xxFlexLexer
// #include <FlexLexer.h>
//
// #undef yyFlexLexer
// #define yyFlexLexer zzFlexLexer
// #include <FlexLexer.h>
// ...
// #undef yyFlexLexer
// #define yyFlexLexer zzFlexLexer
// #include <FlexLexer.h>
// ...
#ifndef __FLEX_LEXER_H
// Never included before - need to define base class.
#define __FLEX_LEXER_H
#include <iostream>
# ifndef FLEX_STD
# define FLEX_STD std::
# endif
#ifndef YY_CHAR_DEFINED
#define YY_CHAR_DEFINED
typedef unsigned char YY_CHAR;
#endif
extern "C++" {
struct yy_buffer_state;
typedef int yy_state_type;
class FlexLexer {
class FlexLexer
{
public:
virtual ~FlexLexer() { }
virtual ~FlexLexer() { }
const YY_CHAR* YYText() const { return yytext; }
int YYLeng() const { return yyleng; }
const char* YYText() const { return yytext; }
int YYLeng() const { return yyleng; }
virtual void
yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
virtual struct yy_buffer_state*
yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
virtual void yyrestart( FLEX_STD istream* s ) = 0;
virtual void
yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0;
virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0;
virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0;
virtual void yy_delete_buffer( yy_buffer_state* b ) = 0;
virtual void yyrestart( std::istream* s ) = 0;
virtual void yyrestart( std::istream& s ) = 0;
virtual int yylex() = 0;
virtual int yylex() = 0;
// Call yylex with new input/output sources.
int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 )
{
switch_streams( new_in, new_out );
return yylex();
}
// Call yylex with new input/output sources.
int yylex( std::istream& new_in, std::ostream& new_out )
{
switch_streams( new_in, new_out );
return yylex();
}
// Switch to new input/output streams. A nil stream pointer
// indicates "keep the current one".
virtual void switch_streams( FLEX_STD istream* new_in = 0,
FLEX_STD ostream* new_out = 0 ) = 0;
int yylex( std::istream* new_in, std::ostream* new_out = 0)
{
switch_streams( new_in, new_out );
return yylex();
}
int lineno() const { return yylineno; }
// Switch to new input/output streams. A nil stream pointer
// indicates "keep the current one".
virtual void switch_streams( std::istream* new_in,
std::ostream* new_out ) = 0;
virtual void switch_streams( std::istream& new_in,
std::ostream& new_out ) = 0;
int debug() const { return yy_flex_debug; }
void set_debug( int flag ) { yy_flex_debug = flag; }
int lineno() const { return yylineno; }
#ifdef YY_CHARSET
void set_charset(char *charset);
char* get_charset();
#endif
int debug() const { return yy_flex_debug; }
void set_debug( int flag ) { yy_flex_debug = flag; }
protected:
YY_CHAR* yytext;
#ifdef YY_CHARSET
char *yycharset;
#endif
int yyleng;
int yylineno; // only maintained if you use %option yylineno
int yy_flex_debug; // only has effect with -d or "%option debug"
char* yytext;
int yyleng;
int yylineno; // only maintained if you use %option yylineno
int yy_flex_debug; // only has effect with -d or "%option debug"
};
}
@@ -118,111 +112,109 @@ protected:
// Either this is the first time through (yyFlexLexerOnce not defined),
// or this is a repeated include to define a different flavor of
// yyFlexLexer, as discussed in the flex manual.
#define yyFlexLexerOnce
# define yyFlexLexerOnce
extern "C++" {
class yyFlexLexer : public FlexLexer {
public:
// arg_yyin and arg_yyout default to the cin and cout, but we
// only make that assignment when initializing in yylex().
yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );
// arg_yyin and arg_yyout default to the cin and cout, but we
// only make that assignment when initializing in yylex().
yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout );
yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
private:
void ctor_common();
virtual ~yyFlexLexer();
public:
void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );
void yy_delete_buffer( struct yy_buffer_state* b );
void yyrestart( FLEX_STD istream* s );
virtual ~yyFlexLexer();
void yypush_buffer_state( struct yy_buffer_state* new_buffer );
void yypop_buffer_state();
void yy_switch_to_buffer( yy_buffer_state* new_buffer );
yy_buffer_state* yy_create_buffer( std::istream* s, int size );
yy_buffer_state* yy_create_buffer( std::istream& s, int size );
void yy_delete_buffer( yy_buffer_state* b );
void yyrestart( std::istream* s );
void yyrestart( std::istream& s );
virtual int yylex();
virtual void switch_streams( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 );
virtual int yywrap();
void yypush_buffer_state( yy_buffer_state* new_buffer );
void yypop_buffer_state();
virtual int yylex();
virtual void switch_streams( std::istream& new_in, std::ostream& new_out );
virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 );
virtual int yywrap();
protected:
virtual int LexerInput( char* buf, int max_size );
virtual void LexerOutput( const char* buf, int size );
virtual void LexerError( const char* msg );
virtual int LexerInput( char* buf, int max_size );
virtual void LexerOutput( const char* buf, int size );
virtual void LexerError( const char* msg );
void yyunput( int c, YY_CHAR* buf_ptr );
int yyinput();
void yyunput( int c, char* buf_ptr );
int yyinput();
void yy_load_buffer_state();
void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream* s );
void yy_flush_buffer( struct yy_buffer_state* b );
void yy_load_buffer_state();
void yy_init_buffer( yy_buffer_state* b, std::istream& s );
void yy_flush_buffer( yy_buffer_state* b );
int yy_start_stack_ptr;
int yy_start_stack_depth;
int* yy_start_stack;
int yy_start_stack_ptr;
int yy_start_stack_depth;
int* yy_start_stack;
void yy_push_state( int new_state );
void yy_pop_state();
int yy_top_state();
void yy_push_state( int new_state );
void yy_pop_state();
int yy_top_state();
yy_state_type yy_get_previous_state();
yy_state_type yy_try_NUL_trans( yy_state_type current_state );
int yy_get_next_buffer();
yy_state_type yy_get_previous_state();
yy_state_type yy_try_NUL_trans( yy_state_type current_state );
int yy_get_next_buffer();
#ifdef YY_CHARSET
size_t yycharset_convert(char* source, size_t source_bytes, YY_CHAR* target,
size_t target_length, size_t* converted_bytes);
virtual size_t yycharset_handler(char *charset,
char *source, size_t source_bytes,
YY_CHAR *target, size_t target_length,
size_t *converted_bytes);
#endif
std::istream yyin; // input source for default LexerInput
std::ostream yyout; // output sink for default LexerOutput
FLEX_STD istream* yyin; // input source for default LexerInput
FLEX_STD ostream* yyout; // output sink for default LexerOutput
// yy_hold_char holds the character lost when yytext is formed.
char yy_hold_char;
// yy_hold_char holds the character lost when yytext is formed.
YY_CHAR yy_hold_char;
// Number of characters read into yy_ch_buf.
int yy_n_chars;
// Number of characters read into yy_ch_buf.
int yy_n_chars;
// Points to current character in buffer.
char* yy_c_buf_p;
// Points to current character in buffer.
YY_CHAR* yy_c_buf_p;
int yy_init; // whether we need to initialize
int yy_start; // start state number
int yy_init; // whether we need to initialize
int yy_start; // start state number
// Flag which is used to allow yywrap()'s to do buffer switches
// instead of setting up a fresh yyin. A bit of a hack ...
int yy_did_buffer_switch_on_eof;
// Flag which is used to allow yywrap()'s to do buffer switches
// instead of setting up a fresh yyin. A bit of a hack ...
int yy_did_buffer_switch_on_eof;
size_t yy_buffer_stack_top; /**< index of top of stack. */
size_t yy_buffer_stack_max; /**< capacity of stack. */
struct yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
void yyensure_buffer_stack(void);
size_t yy_buffer_stack_top; /**< index of top of stack. */
size_t yy_buffer_stack_max; /**< capacity of stack. */
yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
void yyensure_buffer_stack(void);
// The following are not always needed, but may be depending
// on use of certain flex features (like REJECT or yymore()).
// The following are not always needed, but may be depending
// on use of certain flex features (like REJECT or yymore()).
yy_state_type yy_last_accepting_state;
YY_CHAR* yy_last_accepting_cpos;
yy_state_type yy_last_accepting_state;
char* yy_last_accepting_cpos;
yy_state_type* yy_state_buf;
yy_state_type* yy_state_ptr;
yy_state_type* yy_state_buf;
yy_state_type* yy_state_ptr;
YY_CHAR* yy_full_match;
int* yy_full_state;
int yy_full_lp;
char* yy_full_match;
int* yy_full_state;
int yy_full_lp;
int yy_lp;
int yy_looking_for_trail_begin;
int yy_lp;
int yy_looking_for_trail_begin;
int yy_more_flag;
int yy_more_len;
int yy_more_offset;
int yy_prev_more_offset;
int yy_more_flag;
int yy_more_len;
int yy_more_offset;
int yy_prev_more_offset;
};
}
#endif // yyFlexLexer || ! yyFlexLexerOnce
+102 -76
View File
@@ -1,60 +1,83 @@
AM_YFLAGS = -d
localedir = $(datadir)/locale
AM_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\" -I$(top_srcdir)/intl
LIBS = @LIBINTL@ @LIBS@
AM_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\"
LIBS = @LIBS@
m4 = @M4@
bin_PROGRAMS = flex
lib_LTLIBRARIES = \
libfl.la \
libfl_pic.la
if ENABLE_BOOTSTRAP
noinst_PROGRAMS = stage1flex
endif
if ENABLE_LIBFL
lib_LTLIBRARIES = libfl.la
endif
libfl_la_SOURCES = \
libmain.c \
libyywrap.c
libfl_la_LDFLAGS = -version-info @SHARED_VERSION_INFO@
stage1flex_SOURCES = \
scan.l \
$(COMMON_SOURCES)
if CROSS
stage1flex_LDADD =
stage1flex_SOURCES += \
../lib/malloc.c \
../lib/realloc.c
stage1flex_LINK = $(LIBTOOL) --tag=CC --mode=link $(CC_FOR_BUILD) \
$(CFLAGS_FOR_BUILD) $(LDFLAGS_FOR_BUILD) -o $@
$(stage1flex_OBJECTS): CC=$(CC_FOR_BUILD)
$(stage1flex_OBJECTS): CFLAGS=$(CFLAGS_FOR_BUILD)
$(stage1flex_OBJECTS): CPP=$(CPP_FOR_BUILD)
$(stage1flex_OBJECTS): CPPFLAGS=$(CPPFLAGS_FOR_BUILD)
$(stage1flex_OBJECTS): LDFLAGS=$(LDFLAGS_FOR_BUILD)
else
stage1flex_LDADD = $(LDADD)
stage1flex_LINK = $(LINK)
stage1flex_CFLAGS = $(AM_CFLAGS)
endif
flex_SOURCES = \
$(COMMON_SOURCES)
nodist_flex_SOURCES = \
stage1scan.c
flex_CFLAGS = $(AM_CFLAGS) $(WARNINGFLAGS)
COMMON_SOURCES = \
buf.c \
ccl.c \
dfa.c \
ecs.c \
scanflags.c \
filter.c \
flexdef.h \
flexint.h \
gen.c \
main.c \
misc.c \
nfa.c \
options.c \
options.h \
parse.y \
scan.l \
regex.c \
scanflags.c \
scanopt.c \
scanopt.h \
skel.c \
sym.c \
tblcmp.c \
yylex.c \
options.c \
scanopt.c \
buf.c \
tables.c \
tables_shared.c \
filter.c \
regex.c
LDADD = ../lib/libcompat.la
libfl_la_SOURCES = \
libmain.c \
libyywrap.c
libfl_la_LDFLAGS = -no-undefined -version-info @SHARED_VERSION_INFO@
libfl_pic_la_SOURCES = \
libmain.c \
libyywrap.c
libfl_pic_la_LDFLAGS = -no-undefined -version-info @SHARED_VERSION_INFO@
noinst_HEADERS = \
flexdef.h \
flexint.h \
version.h \
options.h \
scanopt.h \
tables.h \
tables_shared.h
tables_shared.c \
tables_shared.h \
tblcmp.c \
version.h \
yylex.c
LDADD = $(LIBOBJS) @LIBINTL@
include_HEADERS = \
FlexLexer.h
@@ -64,38 +87,38 @@ EXTRA_DIST = \
mkskel.sh \
gettext.h
BUILT_SOURCES = \
skel.c
CLEANFILES = stage1scan.c stage1flex$(EXEEXT)
skel.c: flex.skl mkskel.sh flexint.h tables_shared.h
sed 's/m4_/m4postproc_/g; s/m4preproc_/m4_/g' $(srcdir)/flex.skl | $(m4) -P -DFLEX_MAJOR_VERSION=`echo $(VERSION)|cut -f 1 -d .` -DFLEX_MINOR_VERSION=`echo $(VERSION)|cut -f 2 -d .` -DFLEX_SUBMINOR_VERSION=`echo $(VERSION)|cut -f 3 -d .` | sed 's/m4postproc_/m4_/g' | $(SHELL) $(srcdir)/mkskel.sh >skel.c
MAINTAINERCLEANFILES = skel.c
# Explicitly describe dependencies.
# You can recreate this with `gcc -I. -MM *.c'
buf.o: buf.c flexdef.h flexint.h
ccl.o: ccl.c flexdef.h flexint.h
dfa.o: dfa.c flexdef.h flexint.h tables.h tables_shared.h
ecs.o: ecs.c flexdef.h flexint.h
scanflags.o: scanflags.c flexdef.h flexint.h
gen.o: gen.c flexdef.h flexint.h tables.h tables_shared.h
libmain.o: libmain.c
libyywrap.o: libyywrap.c
main.o: main.c flexdef.h flexint.h version.h options.h scanopt.h \
tables.h tables_shared.h
misc.o: misc.c flexdef.h flexint.h tables.h tables_shared.h
nfa.o: nfa.c flexdef.h flexint.h
options.o: options.c options.h scanopt.h flexdef.h flexint.h
parse.o: parse.c flexdef.h flexint.h tables.h tables_shared.h
scan.o: scan.c flexdef.h flexint.h parse.h
scanopt.o: scanopt.c flexdef.h flexint.h scanopt.h
skel.o: skel.c flexdef.h flexint.h
sym.o: sym.c flexdef.h flexint.h
tables.o: tables.c flexdef.h flexint.h tables.h tables_shared.h
tables_shared.o: tables_shared.c flexdef.h flexint.h tables.h \
tables_shared.h
tblcmp.o: tblcmp.c flexdef.h flexint.h
yylex.o: yylex.c flexdef.h flexint.h parse.h
filter.o: filter.c flexdef.h flexint.h
skel.c: flex.skl mkskel.sh flexint.h tables_shared.h tables_shared.c
$(SHELL) $(srcdir)/mkskel.sh $(srcdir) $(m4) $(VERSION) > $@.tmp
mv $@.tmp $@
if ENABLE_BOOTSTRAP
stage1scan.c: scan.l stage1flex$(EXEEXT)
./stage1flex$(EXEEXT) $(AM_LFLAGS) $(LFLAGS) -o $@ $(srcdir)/scan.l
else
stage1scan.c: scan.c
sed 's|^\(#line .*\)"'`printf %s $< | sed 's|[][\\\\.*]|\\\\&|g'`'"|\1"$@"|g' $< > $@
endif
dist-hook: scan.l flex$(EXEEXT)
chmod u+w $(distdir)/scan.c && \
./flex$(EXEEXT) -o scan.c $< && \
mv scan.c $(distdir)
# make needs to be told to make parse.h so that parallelized runs will
# not fail.
stage1flex-main.$(OBJEXT): parse.h
flex-main.$(OBJEXT): parse.h
stage1flex-yylex.$(OBJEXT): parse.h
flex-yylex.$(OBJEXT): parse.h
stage1flex-scan.$(OBJEXT): parse.h
flex-stage1scan.$(OBJEXT): parse.h
# Run GNU indent on sources. Don't run this unless all the sources compile cleanly.
#
@@ -132,11 +155,14 @@ indentfiles = \
tables_shared.h \
tblcmp.c
indent:
if [ -f .indent.pro ] ; then \
for f in $(indentfiles);\
do\
echo indenting $$f ;\
$(indent) < $$f >/dev/null && indent $$f || echo $$f FAILED to indent ;\
done \
fi
indent: $(top_srcdir)/.indent.pro
cd $(top_srcdir) && \
for f in $(indentfiles); do \
f=src/$$f; \
echo indenting $$f; \
INDENT_PROFILE=.indent.pro $(INDENT) <$$f >/dev/null && \
INDENT_PROFILE=.indent.pro $(INDENT) $$f || \
echo $$f FAILED to indent; \
done;
.PHONY: indent
+42 -47
View File
@@ -73,12 +73,13 @@ struct Buf *buf_prints (struct Buf *buf, const char *fmt, const char *s)
char *t;
size_t tsz;
t = flex_alloc (tsz = strlen (fmt) + strlen (s) + 1);
tsz = strlen(fmt) + strlen(s) + 1;
t = malloc(tsz);
if (!t)
flexfatal (_("Allocation of buffer to print string failed"));
snprintf (t, tsz, fmt, s);
buf = buf_strappend (buf, t);
flex_free (t);
free(t);
return buf;
}
@@ -92,21 +93,26 @@ struct Buf *buf_linedir (struct Buf *buf, const char* filename, int lineno)
{
char *dst, *t;
const char *src;
size_t tsz;
t = flex_alloc (strlen ("#line \"\"\n") + /* constant parts */
2 * strlen (filename) + /* filename with possibly all backslashes escaped */
(int) (1 + log10 (abs (lineno))) + /* line number */
1); /* NUL */
if (gen_line_dirs)
return buf;
tsz = strlen("#line \"\"\n") + /* constant parts */
2 * strlen (filename) + /* filename with possibly all backslashes escaped */
(size_t) (1 + ceil (log10 (abs (lineno)))) + /* line number */
1; /* NUL */
t = malloc(tsz);
if (!t)
flexfatal (_("Allocation of buffer for line directive failed"));
for (dst = t + sprintf (t, "#line %d \"", lineno), src = filename; *src; *dst++ = *src++)
for (dst = t + snprintf (t, tsz, "#line %d \"", lineno), src = filename; *src; *dst++ = *src++)
if (*src == '\\') /* escape backslashes */
*dst++ = '\\';
*dst++ = '"';
*dst++ = '\n';
*dst = '\0';
buf = buf_strappend (buf, t);
flex_free (t);
free(t);
return buf;
}
@@ -124,10 +130,7 @@ struct Buf *buf_concat(struct Buf* dest, const struct Buf* src)
/* Appends n characters in str to buf. */
struct Buf *buf_strnappend (buf, str, n)
struct Buf *buf;
const char *str;
int n;
struct Buf *buf_strnappend (struct Buf *buf, const char *str, int n)
{
buf_append (buf, str, n + 1);
@@ -138,18 +141,13 @@ struct Buf *buf_strnappend (buf, str, n)
}
/* Appends characters in str to buf. */
struct Buf *buf_strappend (buf, str)
struct Buf *buf;
const char *str;
struct Buf *buf_strappend (struct Buf *buf, const char *str)
{
return buf_strnappend (buf, str, strlen (str));
return buf_strnappend (buf, str, (int) strlen (str));
}
/* appends "#define str def\n" */
struct Buf *buf_strdefine (buf, str, def)
struct Buf *buf;
const char *str;
const char *def;
struct Buf *buf_strdefine (struct Buf *buf, const char *str, const char *def)
{
buf_strappend (buf, "#define ");
buf_strappend (buf, " ");
@@ -168,12 +166,13 @@ struct Buf *buf_strdefine (buf, str, def)
*/
struct Buf *buf_m4_define (struct Buf *buf, const char* def, const char* val)
{
const char * fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n";
const char * fmt = "m4_define( [[%s]], [[[[%s]]]])m4_dnl\n";
char * str;
size_t strsz;
val = val?val:"";
str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + strlen(val) + 2);
strsz = strlen(fmt) + strlen(def) + strlen(val) + 2;
str = malloc(strsz);
if (!str)
flexfatal (_("Allocation of buffer for m4 def failed"));
@@ -193,7 +192,8 @@ struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
char * str;
size_t strsz;
str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + 2);
strsz = strlen(fmt) + strlen(def) + 2;
str = malloc(strsz);
if (!str)
flexfatal (_("Allocation of buffer for m4 undef failed"));
@@ -203,23 +203,21 @@ struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
}
/* create buf with 0 elements, each of size elem_size. */
void buf_init (buf, elem_size)
struct Buf *buf;
size_t elem_size;
void buf_init (struct Buf *buf, size_t elem_size)
{
buf->elts = (void *) 0;
buf->elts = NULL;
buf->nelts = 0;
buf->elt_size = elem_size;
buf->nmax = 0;
}
/* frees memory */
void buf_destroy (buf)
struct Buf *buf;
void buf_destroy (struct Buf *buf)
{
if (buf && buf->elts)
flex_free (buf->elts);
buf->elts = (void *) 0;
if (buf) {
free(buf->elts);
buf->elts = NULL;
}
}
@@ -229,10 +227,7 @@ void buf_destroy (buf)
* We grow by mod(512) boundaries.
*/
struct Buf *buf_append (buf, ptr, n_elem)
struct Buf *buf;
const void *ptr;
int n_elem;
struct Buf *buf_append (struct Buf *buf, const void *ptr, int n_elem)
{
int n_alloc = 0;
@@ -242,30 +237,30 @@ struct Buf *buf_append (buf, ptr, n_elem)
/* May need to alloc more. */
if (n_elem + buf->nelts > buf->nmax) {
/* exact amount needed... */
n_alloc = (n_elem + buf->nelts) * buf->elt_size;
/* exact count needed... */
n_alloc = n_elem + buf->nelts;
/* ...plus some extra */
if (((n_alloc * buf->elt_size) % 512) != 0
if ((((size_t) n_alloc * buf->elt_size) % 512) != 0
&& buf->elt_size < 512)
n_alloc +=
(512 -
((n_alloc * buf->elt_size) % 512)) /
buf->elt_size;
n_alloc += (int)
((512 -
(((size_t) n_alloc * buf->elt_size) % 512)) /
buf->elt_size);
if (!buf->elts)
buf->elts =
allocate_array (n_alloc, buf->elt_size);
allocate_array ((int) n_alloc, buf->elt_size);
else
buf->elts =
reallocate_array (buf->elts, n_alloc,
reallocate_array (buf->elts, (int) n_alloc,
buf->elt_size);
buf->nmax = n_alloc;
}
memcpy ((char *) buf->elts + buf->nelts * buf->elt_size, ptr,
n_elem * buf->elt_size);
memcpy ((char *) buf->elts + (size_t) buf->nelts * buf->elt_size, ptr,
(size_t) n_elem * buf->elt_size);
buf->nelts += n_elem;
return buf;
+5 -10
View File
@@ -52,9 +52,7 @@ ccl_contains (const int cclp, const int ch)
/* ccladd - add a single character to a ccl */
void ccladd (cclp, ch)
int cclp;
int ch;
void ccladd (int cclp, int ch)
{
int ind, len, newpos, i;
@@ -85,7 +83,7 @@ void ccladd (cclp, ch)
}
ccllen[cclp] = len + 1;
ccltbl[newpos] = ch;
ccltbl[newpos] = (unsigned char) ch;
}
/* dump_cclp - same thing as list_character_set, but for cclps. */
@@ -185,7 +183,7 @@ ccl_set_union (int a, int b)
/* cclinit - return an empty ccl */
int cclinit ()
int cclinit (void)
{
if (++lastccl >= current_maxccls) {
current_maxccls += MAX_CCLS_INCREMENT;
@@ -225,8 +223,7 @@ int cclinit ()
/* cclnegate - negate the given ccl */
void cclnegate (cclp)
int cclp;
void cclnegate (int cclp)
{
cclng[cclp] = 1;
ccl_has_nl[cclp] = !ccl_has_nl[cclp];
@@ -240,9 +237,7 @@ void cclnegate (cclp)
* has a non-zero value in the cset array.
*/
void list_character_set (file, cset)
FILE *file;
int cset[];
void list_character_set (FILE *file, int cset[])
{
int i;
+32 -53
View File
@@ -34,10 +34,10 @@
/* declare functions that have forward references */
void dump_associated_rules PROTO ((FILE *, int));
void dump_transitions PROTO ((FILE *, int[]));
void sympartition PROTO ((int[], int, int[], int[]));
int symfollowset PROTO ((int[], int, int, int[]));
void dump_associated_rules(FILE *, int);
void dump_transitions(FILE *, int[]);
void sympartition(int[], int, int[], int[]);
int symfollowset(int[], int, int, int[]);
/* check_for_backing_up - check a DFA state for backing up
@@ -49,9 +49,7 @@ int symfollowset PROTO ((int[], int, int, int[]));
* indexed by equivalence class.
*/
void check_for_backing_up (ds, state)
int ds;
int state[];
void check_for_backing_up (int ds, int state[])
{
if ((reject && !dfaacc[ds].dfaacc_set) || (!reject && !dfaacc[ds].dfaacc_state)) { /* state is non-accepting */
++num_backing_up;
@@ -96,10 +94,7 @@ void check_for_backing_up (ds, state)
* accset[1 .. nacc] is the list of accepting numbers for the DFA state.
*/
void check_trailing_context (nfa_states, num_states, accset, nacc)
int *nfa_states, num_states;
int *accset;
int nacc;
void check_trailing_context (int *nfa_states, int num_states, int *accset, int nacc)
{
int i, j;
@@ -137,9 +132,7 @@ void check_trailing_context (nfa_states, num_states, accset, nacc)
* and writes a report to the given file.
*/
void dump_associated_rules (file, ds)
FILE *file;
int ds;
void dump_associated_rules (FILE *file, int ds)
{
int i, j;
int num_associated_rules = 0;
@@ -161,7 +154,7 @@ void dump_associated_rules (file, ds)
}
}
qsort (&rule_set [1], num_associated_rules, sizeof (rule_set [1]), intcmp);
qsort (&rule_set [1], (size_t) num_associated_rules, sizeof (rule_set [1]), intcmp);
fprintf (file, _(" associated rule line numbers:"));
@@ -187,9 +180,7 @@ void dump_associated_rules (file, ds)
* is done to the given file.
*/
void dump_transitions (file, state)
FILE *file;
int state[];
void dump_transitions (FILE *file, int state[])
{
int i, ec;
int out_char_set[CSIZE];
@@ -235,8 +226,7 @@ void dump_transitions (file, state)
* hashval is the hash value for the dfa corresponding to the state set.
*/
int *epsclosure (t, ns_addr, accset, nacc_addr, hv_addr)
int *t, *ns_addr, accset[], *nacc_addr, *hv_addr;
int *epsclosure (int *t, int *ns_addr, int accset[], int *nacc_addr, int *hv_addr)
{
int stkpos, ns, tsp;
int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
@@ -351,7 +341,7 @@ ADD_STATE(state); \
/* increase_max_dfas - increase the maximum number of DFAs */
void increase_max_dfas ()
void increase_max_dfas (void)
{
current_max_dfas += MAX_DFAS_INCREMENT;
@@ -378,7 +368,7 @@ void increase_max_dfas ()
* dfa starts out in state #1.
*/
void ntod ()
void ntod (void)
{
int *accset, ds, nacc, newds;
int sym, hashval, numstates, dsize;
@@ -400,7 +390,7 @@ void ntod ()
* from 1 to CSIZE, so their size must be CSIZE + 1.
*/
int duplist[CSIZE + 1], state[CSIZE + 1];
int targfreq[CSIZE + 1], targstate[CSIZE + 1];
int targfreq[CSIZE + 1] = {0}, targstate[CSIZE + 1];
/* accset needs to be large enough to hold all of the rules present
* in the input, *plus* their YY_TRAILING_HEAD_MASK variants.
@@ -473,14 +463,9 @@ void ntod ()
/* We still may want to use the table if numecs
* is a power of 2.
*/
int power_of_two;
for (power_of_two = 1; power_of_two <= csize;
power_of_two *= 2)
if (numecs == power_of_two) {
use_NUL_table = true;
break;
}
if (numecs <= csize && is_power_of_2(numecs)) {
use_NUL_table = true;
}
}
if (use_NUL_table)
@@ -521,15 +506,13 @@ void ntod ()
* So we'll have to realloc() on the way...
* we'll wait until we can calculate yynxt_tbl->td_hilen.
*/
yynxt_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct
yytbl_data));
yynxt_tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (yynxt_tbl, YYTD_ID_NXT);
yynxt_tbl->td_hilen = 1;
yynxt_tbl->td_lolen = num_full_table_rows;
yynxt_tbl->td_lolen = (flex_uint32_t) num_full_table_rows;
yynxt_tbl->td_data = yynxt_data =
(flex_int32_t *) calloc (yynxt_tbl->td_lolen *
calloc(yynxt_tbl->td_lolen *
yynxt_tbl->td_hilen,
sizeof (flex_int32_t));
yynxt_curr = 0;
@@ -543,12 +526,12 @@ void ntod ()
*/
if (gentables)
out_str_dec
("static yyconst %s yy_nxt[][%d] =\n {\n",
("static const %s yy_nxt[][%d] =\n {\n",
long_align ? "flex_int32_t" : "flex_int16_t",
num_full_table_rows);
else {
out_dec ("#undef YY_NXT_LOLEN\n#define YY_NXT_LOLEN (%d)\n", num_full_table_rows);
out_str ("static yyconst %s *yy_nxt =0;\n",
out_str ("static const %s *yy_nxt =0;\n",
long_align ? "flex_int32_t" : "flex_int16_t");
}
@@ -713,7 +696,7 @@ void ntod ()
/* Each time we hit here, it's another td_hilen, so we realloc. */
yynxt_tbl->td_hilen++;
yynxt_tbl->td_data = yynxt_data =
(flex_int32_t *) realloc (yynxt_data,
realloc (yynxt_data,
yynxt_tbl->td_hilen *
yynxt_tbl->td_lolen *
sizeof (flex_int32_t));
@@ -805,8 +788,8 @@ void ntod ()
mkdeftbl ();
}
flex_free ((void *) accset);
flex_free ((void *) nset);
free(accset);
free(nset);
}
@@ -820,8 +803,7 @@ void ntod ()
* On return, the dfa state number is in newds.
*/
int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
int sns[], numstates, accset[], nacc, hashval, *newds_addr;
int snstods (int sns[], int numstates, int accset[], int nacc, int hashval, int *newds_addr)
{
int didsort = 0;
int i, j;
@@ -836,7 +818,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
/* We sort the states in sns so we
* can compare it to oldsns quickly.
*/
qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
didsort = 1;
}
@@ -871,7 +853,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
*/
if (!didsort)
qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
for (i = 1; i <= numstates; ++i)
dss[newds][i] = sns[i];
@@ -881,7 +863,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
if (nacc == 0) {
if (reject)
dfaacc[newds].dfaacc_set = (int *) 0;
dfaacc[newds].dfaacc_set = NULL;
else
dfaacc[newds].dfaacc_state = 0;
@@ -894,7 +876,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
* match in the event of ties will work.
*/
qsort (&accset [1], nacc, sizeof (accset [1]), intcmp);
qsort (&accset [1], (size_t) nacc, sizeof (accset [1]), intcmp);
dfaacc[newds].dfaacc_set =
allocate_integer_array (nacc + 1);
@@ -942,8 +924,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
* int transsym, int nset[current_max_dfa_size] );
*/
int symfollowset (ds, dsize, transsym, nset)
int ds[], dsize, transsym, nset[];
int symfollowset (int ds[], int dsize, int transsym, int nset[])
{
int ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
@@ -1020,9 +1001,7 @@ int symfollowset (ds, dsize, transsym, nset)
* int symlist[numecs], int duplist[numecs] );
*/
void sympartition (ds, numstates, symlist, duplist)
int ds[], numstates;
int symlist[], duplist[];
void sympartition (int ds[], int numstates, int symlist[], int duplist[])
{
int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
+8 -11
View File
@@ -36,7 +36,7 @@
/* ccl2ecl - convert character classes to set of equivalence classes */
void ccl2ecl ()
void ccl2ecl (void)
{
int i, ich, newlen, cclp, ccls, cclmec;
@@ -56,7 +56,8 @@ void ccl2ecl ()
cclmec = ecgroup[ich];
if (cclmec > 0) {
ccltbl[cclp + newlen] = cclmec;
/* Note: range 1..256 is mapped to 1..255,0 */
ccltbl[cclp + newlen] = (unsigned char) cclmec;
++newlen;
}
}
@@ -74,8 +75,7 @@ void ccl2ecl ()
* Returned is the number of classes.
*/
int cre8ecs (fwd, bck, num)
int fwd[], bck[], num;
int cre8ecs (int fwd[], int bck[], int num)
{
int i, j, numcl;
@@ -100,9 +100,9 @@ int cre8ecs (fwd, bck, num)
/* mkeccl - update equivalence classes based on character class xtions
*
* synopsis
* Char ccls[];
* unsigned char ccls[];
* int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
* void mkeccl( Char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
* void mkeccl( unsigned char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
* int llsiz, int NUL_mapping );
*
* ccls contains the elements of the character class, lenccl is the
@@ -112,9 +112,7 @@ int cre8ecs (fwd, bck, num)
* NUL_mapping is the value which NUL (0) should be mapped to.
*/
void mkeccl (ccls, lenccl, fwd, bck, llsiz, NUL_mapping)
Char ccls[];
int lenccl, fwd[], bck[], llsiz, NUL_mapping;
void mkeccl (unsigned char ccls[], int lenccl, int fwd[], int bck[], int llsiz, int NUL_mapping)
{
int cclp, oldec, newec;
int cclm, i, j;
@@ -201,8 +199,7 @@ void mkeccl (ccls, lenccl, fwd, bck, llsiz, NUL_mapping)
/* mkechar - create equivalence class for single character */
void mkechar (tch, fwd, bck)
int tch, fwd[], bck[];
void mkechar (int tch, int fwd[], int bck[])
{
/* If until now the character has been a proper subset of
* an equivalence class, break it away to create a new ec
+21 -25
View File
@@ -47,9 +47,9 @@ struct filter *filter_create_ext (struct filter *chain, const char *cmd,
va_list ap;
/* allocate and initialize new filter */
f = (struct filter *) flex_alloc (sizeof (struct filter));
f = malloc(sizeof(struct filter));
if (!f)
flexerror (_("flex_alloc failed (f) in filter_create_ext"));
flexerror(_("malloc failed (f) in filter_create_ext"));
memset (f, 0, sizeof (*f));
f->filter_func = NULL;
f->extra = NULL;
@@ -66,23 +66,16 @@ struct filter *filter_create_ext (struct filter *chain, const char *cmd,
/* allocate argv, and populate it with the argument list. */
max_args = 8;
f->argv =
(const char **) flex_alloc (sizeof (char *) *
(max_args + 1));
f->argv = malloc(sizeof(char *) * (size_t) (max_args + 1));
if (!f->argv)
flexerror (_("flex_alloc failed (f->argv) in filter_create_ext"));
flexerror(_("malloc failed (f->argv) in filter_create_ext"));
f->argv[f->argc++] = cmd;
va_start (ap, cmd);
while ((s = va_arg (ap, const char *)) != NULL) {
if (f->argc >= max_args) {
max_args += 8;
f->argv =
(const char **) flex_realloc (f->argv,
sizeof (char
*) *
(max_args +
1));
f->argv = realloc(f->argv, sizeof(char*) * (size_t) (max_args + 1));
}
f->argv[f->argc++] = s;
}
@@ -107,9 +100,9 @@ struct filter *filter_create_int (struct filter *chain,
struct filter *f;
/* allocate and initialize new filter */
f = (struct filter *) flex_alloc (sizeof (struct filter));
f = malloc(sizeof(struct filter));
if (!f)
flexerror (_("flex_alloc failed in filter_create_int"));
flexerror(_("malloc failed in filter_create_int"));
memset (f, 0, sizeof (*f));
f->next = NULL;
f->argc = 0;
@@ -174,6 +167,8 @@ clearerr(stdin);
flexfatal (_("dup2(pipes[0],0)"));
close (pipes[0]);
fseek (stdin, 0, SEEK_CUR);
ungetc(' ', stdin); /* still an evil hack, but one that works better */
(void)fgetc(stdin); /* on NetBSD than the fseek attempt does */
/* run as a filter, either internally or by exec */
if (chain->filter_func) {
@@ -181,7 +176,7 @@ clearerr(stdin);
if ((r = chain->filter_func (chain)) == -1)
flexfatal (_("filter_func failed"));
exit (0);
FLEX_EXIT (0);
}
else {
execvp (chain->argv[0],
@@ -190,7 +185,7 @@ clearerr(stdin);
chain->argv[0]);
}
exit (1);
FLEX_EXIT (1);
}
/* Parent */
@@ -288,9 +283,9 @@ int filter_tee_header (struct filter *chain)
fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
outfilename ? outfilename : "<stdout>");
buf = (char *) flex_alloc (readsz);
buf = malloc((size_t) readsz);
if (!buf)
flexerror (_("flex_alloc failed in filter_tee_header"));
flexerror(_("malloc failed in filter_tee_header"));
while (fgets (buf, readsz, stdin)) {
fputs (buf, to_c);
if (write_header)
@@ -301,7 +296,8 @@ int filter_tee_header (struct filter *chain)
fprintf (to_h, "\n");
/* write a fake line number. It will get fixed by the linedir filter. */
fprintf (to_h, "#line 4000 \"M4_YY_OUTFILE_NAME\"\n");
if (gen_line_dirs)
fprintf (to_h, "#line 4000 \"M4_YY_OUTFILE_NAME\"\n");
fprintf (to_h, "#undef %sIN_HEADER\n", prefix);
fprintf (to_h, "#endif /* %sHEADER_H */\n", prefix);
@@ -328,7 +324,7 @@ int filter_tee_header (struct filter *chain)
while (wait (0) > 0) ;
exit (0);
FLEX_EXIT (0);
return 0;
}
@@ -341,7 +337,7 @@ int filter_tee_header (struct filter *chain)
int filter_fix_linedirs (struct filter *chain)
{
char *buf;
const int readsz = 512;
const size_t readsz = 512;
int lineno = 1;
bool in_gen = true; /* in generated code */
bool last_was_blank = false;
@@ -349,11 +345,11 @@ int filter_fix_linedirs (struct filter *chain)
if (!chain)
return 0;
buf = (char *) flex_alloc (readsz);
buf = malloc(readsz);
if (!buf)
flexerror (_("flex_alloc failed in filter_fix_linedirs"));
flexerror(_("malloc failed in filter_fix_linedirs"));
while (fgets (buf, readsz, stdin)) {
while (fgets (buf, (int) readsz, stdin)) {
regmatch_t m[10];
@@ -395,7 +391,7 @@ int filter_fix_linedirs (struct filter *chain)
/* Adjust the line directives. */
in_gen = true;
snprintf (buf, readsz, "#line %d \"%s\"\n",
lineno + 1, filename);
lineno, filename);
}
else {
/* it's a #line directive for code we didn't write */
+339 -661
View File
File diff suppressed because it is too large Load Diff
+171 -248
View File
@@ -39,30 +39,15 @@
#include <config.h>
#endif
/* AIX requires this to be the first thing in the file. */
#if !defined(__GNUC__) && !defined(__lint__)
# if HAVE_ALLOCA_H
# include <alloca.h>
# else
# ifdef _AIX
#pragma alloca
# else
# ifndef alloca /* predefined by HP cc +Olibcalls */
char *alloca ();
# endif
# endif
# endif
#endif
#ifdef STDC_HEADERS
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <setjmp.h>
#include <ctype.h>
#include <libgen.h> /* for XPG version of basename(3) */
#include <string.h>
#include <math.h>
#endif
#ifdef HAVE_ASSERT_H
#include <assert.h>
#else
@@ -72,28 +57,24 @@ char *alloca ();
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_UNISTD_H
/* Required: dup() and dup2() in <unistd.h> */
#include <unistd.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_SYS_PARAMS_H
#include <sys/params.h>
#endif
#ifdef HAVE_SYS_WAIT_H
/* Required: stat() in <sys/stat.h> */
#include <sys/stat.h>
/* Required: wait() in <sys/wait.h> */
#include <sys/wait.h>
#endif
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#else
#define bool int
#define true 1
#define false 0
#endif
#ifdef HAVE_REGEX_H
#include <stdarg.h>
/* Required: regcomp(), regexec() and regerror() in <regex.h> */
#include <regex.h>
#endif
/* Required: strcasecmp() in <strings.h> */
#include <strings.h>
#include "flexint.h"
/* We use gettext. So, when we write strings which should be translated, we mark them with _() */
@@ -109,33 +90,12 @@ char *alloca ();
/* Always be prepared to generate an 8-bit scanner. */
#define CSIZE 256
#define Char unsigned char
/* Size of input alphabet - should be size of ASCII set. */
#ifndef DEFAULT_CSIZE
#define DEFAULT_CSIZE 128
#endif
#ifndef PROTO
#if defined(__STDC__)
#define PROTO(proto) proto
#else
#define PROTO(proto) ()
#endif
#endif
#ifdef VMS
#ifndef __VMS_POSIX
#define unlink remove
#define SHORT_FILE_NAMES
#endif
#endif
#ifdef MS_DOS
#define SHORT_FILE_NAMES
#endif
/* Maximum line length we'll have to deal with. */
#define MAXLINE 2048
@@ -149,11 +109,8 @@ char *alloca ();
#define ABS(x) ((x) < 0 ? -(x) : (x))
#endif
/* ANSI C does not guarantee that isascii() is defined */
#ifndef isascii
#define isascii(c) ((c) <= 0177)
#endif
/* Whether an integer is a power of two */
#define is_power_of_2(n) ((n) > 0 && ((n) & ((n) - 1)) == 0)
#define unspecified -1
@@ -396,7 +353,6 @@ char *alloca ();
* of what we think based on references to it in the user's actions.
* reject_really_used - same for REJECT
* trace_hex - use hexadecimal numbers in trace/debug outputs instead of octals
* charset_enabled - true if charset interface has been enabled
*/
extern int printstats, syntaxerror, eofseen, ddebug, trace, nowarn,
@@ -405,14 +361,12 @@ extern int interactive, lex_compat, posix_compat, do_yylineno;
extern int useecs, fulltbl, usemecs, fullspd;
extern int gen_line_dirs, performance_report, backing_up_report;
extern int reentrant, bison_bridge_lval, bison_bridge_lloc;
extern bool ansi_func_defs, ansi_func_protos;
extern int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap;
extern int csize;
extern int yymore_used, reject, real_reject, continued_action, in_rule;
extern int yymore_really_used, reject_really_used;
extern int trace_hex;
extern bool charset_enabled;
/* Variables used in the flex input routines:
* datapos - characters on current output line
@@ -427,7 +381,6 @@ extern bool charset_enabled;
* infilename - name of input file
* outfilename - name of output file
* headerfilename - name of the .h file to generate
* headercharfilename - name of the .h file to fill with character type defintion
* did_outfilename - whether outfilename was explicitly set
* prefix - the prefix used for externally visible names ("yy" by default)
* yyclass - yyFlexLexer subclass to use for YY_DECL
@@ -437,8 +390,6 @@ extern bool charset_enabled;
* num_input_files - size of input_files array
* program_name - name with which program was invoked
*
* charset_source - character set that has been declared as used in source file
*
* action_array - array to hold the rule actions
* action_size - size of action_array
* defs1_offset - index where the user's section 1 definitions start
@@ -450,10 +401,10 @@ extern bool charset_enabled;
*/
extern int datapos, dataline, linenum;
extern FILE *skelfile, *yyin, *backing_up_file;
extern FILE *skelfile, *backing_up_file;
extern const char *skel[];
extern int skel_ind;
extern char *infilename, *outfilename, *headerfilename, *headercharfilename;
extern char *infilename, *outfilename, *headerfilename;
extern int did_outfilename;
extern char *prefix, *yyclass, *extra_type;
extern int do_stdinit, use_stdout;
@@ -461,8 +412,6 @@ extern char **input_files;
extern int num_input_files;
extern char *program_name;
extern char *charset_source;
extern char *action_array;
extern int action_size;
extern int defs1_offset, prolog_offset, action_offset, action_index;
@@ -654,7 +603,7 @@ extern int end_of_buffer_state;
extern int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
extern int current_maxccls, current_max_ccl_tbl_size;
extern Char *ccltbl;
extern unsigned char *ccltbl;
/* Variables for miscellaneous information:
@@ -682,62 +631,54 @@ extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
extern int num_backing_up, bol_needed;
void *allocate_array PROTO ((int, size_t));
void *reallocate_array PROTO ((void *, int, size_t));
#ifndef HAVE_REALLOCARRAY
void *reallocarray(void *, size_t, size_t);
#endif
void *flex_alloc PROTO ((size_t));
void *flex_realloc PROTO ((void *, size_t));
void flex_free PROTO ((void *));
void *allocate_array(int, size_t);
void *reallocate_array(void *, int, size_t);
#define allocate_integer_array(size) \
(int *) allocate_array( size, sizeof( int ) )
allocate_array(size, sizeof(int))
#define reallocate_integer_array(array,size) \
(int *) reallocate_array( (void *) array, size, sizeof( int ) )
reallocate_array((void *) array, size, sizeof(int))
#define allocate_bool_array(size) \
(bool *) allocate_array( size, sizeof( bool ) )
allocate_array(size, sizeof(bool))
#define reallocate_bool_array(array,size) \
(bool *) reallocate_array( (void *) array, size, sizeof( bool ) )
reallocate_array((void *) array, size, sizeof(bool))
#define allocate_int_ptr_array(size) \
(int **) allocate_array( size, sizeof( int * ) )
allocate_array(size, sizeof(int *))
#define allocate_char_ptr_array(size) \
(char **) allocate_array( size, sizeof( char * ) )
allocate_array(size, sizeof(char *))
#define allocate_dfaacc_union(size) \
(union dfaacc_union *) \
allocate_array( size, sizeof( union dfaacc_union ) )
allocate_array(size, sizeof(union dfaacc_union))
#define reallocate_int_ptr_array(array,size) \
(int **) reallocate_array( (void *) array, size, sizeof( int * ) )
reallocate_array((void *) array, size, sizeof(int *))
#define reallocate_char_ptr_array(array,size) \
(char **) reallocate_array( (void *) array, size, sizeof( char * ) )
reallocate_array((void *) array, size, sizeof(char *))
#define reallocate_dfaacc_union(array, size) \
(union dfaacc_union *) \
reallocate_array( (void *) array, size, sizeof( union dfaacc_union ) )
reallocate_array((void *) array, size, sizeof(union dfaacc_union))
#define allocate_character_array(size) \
(char *) allocate_array( size, sizeof( char ) )
allocate_array( size, sizeof(char))
#define reallocate_character_array(array,size) \
(char *) reallocate_array( (void *) array, size, sizeof( char ) )
reallocate_array((void *) array, size, sizeof(char))
#define allocate_Character_array(size) \
(Char *) allocate_array( size, sizeof( Char ) )
allocate_array(size, sizeof(unsigned char))
#define reallocate_Character_array(array,size) \
(Char *) reallocate_array( (void *) array, size, sizeof( Char ) )
/* Used to communicate between scanner and parser. The type should really
* be YYSTYPE, but we can't easily get our hands on it.
*/
extern int yylval;
reallocate_array((void *) array, size, sizeof(unsigned char))
/* External functions that are cross-referenced among the flex source files. */
@@ -745,146 +686,143 @@ extern int yylval;
/* from file ccl.c */
extern void ccladd PROTO ((int, int)); /* add a single character to a ccl */
extern int cclinit PROTO ((void)); /* make an empty ccl */
extern void cclnegate PROTO ((int)); /* negate a ccl */
extern void ccladd(int, int); /* add a single character to a ccl */
extern int cclinit(void); /* make an empty ccl */
extern void cclnegate(int); /* negate a ccl */
extern int ccl_set_diff (int a, int b); /* set difference of two ccls. */
extern int ccl_set_union (int a, int b); /* set union of two ccls. */
/* List the members of a set of characters in CCL form. */
extern void list_character_set PROTO ((FILE *, int[]));
extern void list_character_set(FILE *, int[]);
/* from file dfa.c */
/* Check a DFA state for backing up. */
extern void check_for_backing_up PROTO ((int, int[]));
extern void check_for_backing_up(int, int[]);
/* Check to see if NFA state set constitutes "dangerous" trailing context. */
extern void check_trailing_context PROTO ((int *, int, int *, int));
extern void check_trailing_context(int *, int, int *, int);
/* Construct the epsilon closure of a set of ndfa states. */
extern int *epsclosure PROTO ((int *, int *, int[], int *, int *));
extern int *epsclosure(int *, int *, int[], int *, int *);
/* Increase the maximum number of dfas. */
extern void increase_max_dfas PROTO ((void));
extern void increase_max_dfas(void);
extern void ntod PROTO ((void)); /* convert a ndfa to a dfa */
extern void ntod(void); /* convert a ndfa to a dfa */
/* Converts a set of ndfa states into a dfa state. */
extern int snstods PROTO ((int[], int, int[], int, int, int *));
extern int snstods(int[], int, int[], int, int, int *);
/* from file ecs.c */
/* Convert character classes to set of equivalence classes. */
extern void ccl2ecl PROTO ((void));
extern void ccl2ecl(void);
/* Associate equivalence class numbers with class members. */
extern int cre8ecs PROTO ((int[], int[], int));
extern int cre8ecs(int[], int[], int);
/* Update equivalence classes based on character class transitions. */
extern void mkeccl PROTO ((Char[], int, int[], int[], int, int));
extern void mkeccl(unsigned char[], int, int[], int[], int, int);
/* Create equivalence class for single character. */
extern void mkechar PROTO ((int, int[], int[]));
extern void mkechar(int, int[], int[]);
/* from file gen.c */
extern void do_indent PROTO ((void)); /* indent to the current level */
extern void do_indent(void); /* indent to the current level */
/* Generate the code to keep backing-up information. */
extern void gen_backing_up PROTO ((void));
extern void gen_backing_up(void);
/* Generate the code to perform the backing up. */
extern void gen_bu_action PROTO ((void));
extern void gen_bu_action(void);
/* Generate full speed compressed transition table. */
extern void genctbl PROTO ((void));
extern void genctbl(void);
/* Generate the code to find the action number. */
extern void gen_find_action PROTO ((void));
extern void gen_find_action(void);
extern void genftbl PROTO ((void)); /* generate full transition table */
extern void genftbl(void); /* generate full transition table */
/* Generate the code to find the next compressed-table state. */
extern void gen_next_compressed_state PROTO ((char *));
extern void gen_next_compressed_state(char *);
/* Generate the code to find the next match. */
extern void gen_next_match PROTO ((void));
extern void gen_next_match(void);
/* Generate the code to find the next state. */
extern void gen_next_state PROTO ((int));
extern void gen_next_state(int);
/* Generate the code to make a NUL transition. */
extern void gen_NUL_trans PROTO ((void));
extern void gen_NUL_trans(void);
/* Generate the code to find the start state. */
extern void gen_start_state PROTO ((void));
extern void gen_start_state(void);
/* Generate data statements for the transition tables. */
extern void gentabs PROTO ((void));
extern void gentabs(void);
/* Write out a formatted string at the current indentation level. */
extern void indent_put2s PROTO ((const char *, const char *));
extern void indent_put2s(const char *, const char *);
/* Write out a string + newline at the current indentation level. */
extern void indent_puts PROTO ((const char *));
extern void indent_puts(const char *);
extern void make_tables PROTO ((void)); /* generate transition tables */
extern void make_tables(void); /* generate transition tables */
/* from file main.c */
extern void check_options PROTO ((void));
extern void flexend PROTO ((int));
extern void usage PROTO ((void));
extern void check_options(void);
extern void flexend(int);
extern void usage(void);
/* from file misc.c */
/* Add a #define to the action file. */
extern void action_define PROTO ((const char *defname, int value));
extern void action_define(const char *defname, int value);
/* Add the given text to the stored actions. */
extern void add_action PROTO ((const char *new_text));
extern void add_action(const char *new_text);
/* True if a string is all lower case. */
extern int all_lower PROTO ((char *));
extern int all_lower(char *);
/* True if a string is all upper case. */
extern int all_upper PROTO ((char *));
extern int all_upper(char *);
/* Compare two integers for use by qsort. */
extern int intcmp PROTO ((const void *, const void *));
extern int intcmp(const void *, const void *);
/* Check a character to make sure it's in the expected range. */
extern void check_char PROTO ((int c));
extern void check_char(int c);
/* Replace upper-case letter to lower-case. */
extern Char clower PROTO ((int));
extern unsigned char clower(int);
/* Returns a dynamically allocated copy of a string. */
extern char *copy_string PROTO ((const char *));
/* Returns a dynamically allocated copy of a (potentially) unsigned string. */
extern Char *copy_unsigned_string PROTO ((Char *));
/* strdup() that fails fatally on allocation failures. */
extern char *xstrdup(const char *);
/* Compare two characters for use by qsort with '\0' sorting last. */
extern int cclcmp PROTO ((const void *, const void *));
extern int cclcmp(const void *, const void *);
/* Finish up a block of data declarations. */
extern void dataend PROTO ((void));
extern void dataend(void);
/* Flush generated data statements. */
extern void dataflush PROTO ((void));
extern void dataflush(void);
/* Report an error message and terminate. */
extern void flexerror PROTO ((const char *));
extern void flexerror(const char *);
/* Report a fatal error message and terminate. */
extern void flexfatal PROTO ((const char *));
extern void flexfatal(const char *);
/* Report a fatal error with a pinpoint, and terminate */
#if HAVE_DECL___FUNC__
@@ -907,208 +845,195 @@ extern void flexfatal PROTO ((const char *));
}while(0)
#endif /* ! HAVE_DECL___func__ */
/* Convert a hexadecimal digit string to an integer value. */
extern int htoi PROTO ((Char[]));
/* Report an error message formatted */
extern void lerr PROTO ((const char *, ...))
extern void lerr(const char *, ...)
#if defined(__GNUC__) && __GNUC__ >= 3
__attribute__((__format__(__printf__, 1, 2)))
#endif
;
/* Like lerr, but also exit after displaying message. */
extern void lerr_fatal PROTO ((const char *, ...))
extern void lerr_fatal(const char *, ...)
#if defined(__GNUC__) && __GNUC__ >= 3
__attribute__((__format__(__printf__, 1, 2)))
#endif
;
/* Spit out a "#line" statement. */
extern void line_directive_out PROTO ((FILE *, int));
extern void line_directive_out(FILE *, int);
/* Mark the current position in the action array as the end of the section 1
* user defs.
*/
extern void mark_defs1 PROTO ((void));
extern void mark_defs1(void);
/* Mark the current position in the action array as the end of the prolog. */
extern void mark_prolog PROTO ((void));
extern void mark_prolog(void);
/* Generate a data statment for a two-dimensional array. */
extern void mk2data PROTO ((int));
extern void mk2data(int);
extern void mkdata PROTO ((int)); /* generate a data statement */
extern void mkdata(int); /* generate a data statement */
/* Return the integer represented by a string of digits. */
extern int myctoi PROTO ((const char *));
extern int myctoi(const char *);
/* Return character corresponding to escape sequence. */
extern Char myesc PROTO ((Char[]));
/* Convert an octal digit string to an integer value. */
extern int otoi PROTO ((Char[]));
extern unsigned char myesc(unsigned char[]);
/* Output a (possibly-formatted) string to the generated scanner. */
extern void out PROTO ((const char *));
extern void out_dec PROTO ((const char *, int));
extern void out_dec2 PROTO ((const char *, int, int));
extern void out_hex PROTO ((const char *, unsigned int));
extern void out_str PROTO ((const char *, const char *));
extern void out_str3
PROTO ((const char *, const char *, const char *, const char *));
extern void out_str_dec PROTO ((const char *, const char *, int));
extern void outc PROTO ((int));
extern void outn PROTO ((const char *));
extern void out_m4_define (const char* def, const char* val);
extern void out(const char *);
extern void out_dec(const char *, int);
extern void out_dec2(const char *, int, int);
extern void out_hex(const char *, unsigned int);
extern void out_str(const char *, const char *);
extern void out_str3(const char *, const char *, const char *, const char *);
extern void out_str_dec(const char *, const char *, int);
extern void outc(int);
extern void outn(const char *);
extern void out_m4_define(const char* def, const char* val);
/* Return a printable version of the given character, which might be
* 8-bit.
*/
extern char *readable_form PROTO ((int));
extern char *readable_form(int);
/* Write out one section of the skeleton file. */
extern void skelout PROTO ((void));
extern void skelout(void);
/* Output a yy_trans_info structure. */
extern void transition_struct_out PROTO ((int, int));
extern void transition_struct_out(int, int);
/* Only needed when using certain broken versions of bison to build parse.c. */
extern void *yy_flex_xmalloc PROTO ((int));
/* Set a region of memory to 0. */
extern void zero_out PROTO ((char *, size_t));
extern void *yy_flex_xmalloc(int);
/* from file nfa.c */
/* Add an accepting state to a machine. */
extern void add_accept PROTO ((int, int));
extern void add_accept(int, int);
/* Make a given number of copies of a singleton machine. */
extern int copysingl PROTO ((int, int));
extern int copysingl(int, int);
/* Debugging routine to write out an nfa. */
extern void dumpnfa PROTO ((int));
extern void dumpnfa(int);
/* Finish up the processing for a rule. */
extern void finish_rule PROTO ((int, int, int, int, int));
extern void finish_rule(int, int, int, int, int);
/* Connect two machines together. */
extern int link_machines PROTO ((int, int));
extern int link_machines(int, int);
/* Mark each "beginning" state in a machine as being a "normal" (i.e.,
* not trailing context associated) state.
*/
extern void mark_beginning_as_normal PROTO ((int));
extern void mark_beginning_as_normal(int);
/* Make a machine that branches to two machines. */
extern int mkbranch PROTO ((int, int));
extern int mkbranch(int, int);
extern int mkclos PROTO ((int)); /* convert a machine into a closure */
extern int mkopt PROTO ((int)); /* make a machine optional */
extern int mkclos(int); /* convert a machine into a closure */
extern int mkopt(int); /* make a machine optional */
/* Make a machine that matches either one of two machines. */
extern int mkor PROTO ((int, int));
extern int mkor(int, int);
/* Convert a machine into a positive closure. */
extern int mkposcl PROTO ((int));
extern int mkposcl(int);
extern int mkrep PROTO ((int, int, int)); /* make a replicated machine */
extern int mkrep(int, int, int); /* make a replicated machine */
/* Create a state with a transition on a given symbol. */
extern int mkstate PROTO ((int));
extern int mkstate(int);
extern void new_rule PROTO ((void)); /* initialize for a new rule */
extern void new_rule(void); /* initialize for a new rule */
/* from file parse.y */
/* Build the "<<EOF>>" action for the active start conditions. */
extern void build_eof_action PROTO ((void));
extern void build_eof_action(void);
/* Write out a message formatted with one string, pinpointing its location. */
extern void format_pinpoint_message PROTO ((const char *, const char *));
extern void format_pinpoint_message(const char *, const char *);
/* Write out a message, pinpointing its location. */
extern void pinpoint_message PROTO ((const char *));
extern void pinpoint_message(const char *);
/* Write out a warning, pinpointing it at the given line. */
extern void line_warning PROTO ((const char *, int));
extern void line_warning(const char *, int);
/* Write out a message, pinpointing it at the given line. */
extern void line_pinpoint PROTO ((const char *, int));
extern void line_pinpoint(const char *, int);
/* Report a formatted syntax error. */
extern void format_synerr PROTO ((const char *, const char *));
extern void synerr PROTO ((const char *)); /* report a syntax error */
extern void format_warn PROTO ((const char *, const char *));
extern void warn PROTO ((const char *)); /* report a warning */
extern void yyerror PROTO ((const char *)); /* report a parse error */
extern int yyparse PROTO ((void)); /* the YACC parser */
extern void format_synerr(const char *, const char *);
extern void synerr(const char *); /* report a syntax error */
extern void format_warn(const char *, const char *);
extern void lwarn(const char *); /* report a warning */
extern void yyerror(const char *); /* report a parse error */
extern int yyparse(void); /* the YACC parser */
/* from file scan.l */
/* The Flex-generated scanner for flex. */
extern int flexscan PROTO ((void));
extern int flexscan(void);
/* Open the given file (if NULL, stdin) for scanning. */
extern void set_input_file PROTO ((char *));
/* Wrapup a file in the lexical analyzer. */
extern int yywrap PROTO ((void));
extern void set_input_file(char *);
/* from file sym.c */
/* Save the text of a character class. */
extern void cclinstal PROTO ((Char[], int));
extern void cclinstal(char[], int);
/* Lookup the number associated with character class. */
extern int ccllookup PROTO ((Char[]));
extern int ccllookup(char[]);
extern void ndinstal PROTO ((const char *, Char[])); /* install a name definition */
extern Char *ndlookup PROTO ((const char *)); /* lookup a name definition */
extern void ndinstal(const char *, char[]); /* install a name definition */
extern char *ndlookup(const char *); /* lookup a name definition */
/* Increase maximum number of SC's. */
extern void scextend PROTO ((void));
extern void scinstal PROTO ((const char *, int)); /* make a start condition */
extern void scextend(void);
extern void scinstal(const char *, int); /* make a start condition */
/* Lookup the number associated with a start condition. */
extern int sclookup PROTO ((const char *));
extern int sclookup(const char *);
/* from file tblcmp.c */
/* Build table entries for dfa state. */
extern void bldtbl PROTO ((int[], int, int, int, int));
extern void bldtbl(int[], int, int, int, int);
extern void cmptmps PROTO ((void)); /* compress template table entries */
extern void expand_nxt_chk PROTO ((void)); /* increase nxt/chk arrays */
extern void cmptmps(void); /* compress template table entries */
extern void expand_nxt_chk(void); /* increase nxt/chk arrays */
/* Finds a space in the table for a state to be placed. */
extern int find_table_space PROTO ((int *, int));
extern void inittbl PROTO ((void)); /* initialize transition tables */
extern int find_table_space(int *, int);
extern void inittbl(void); /* initialize transition tables */
/* Make the default, "jam" table entries. */
extern void mkdeftbl PROTO ((void));
extern void mkdeftbl(void);
/* Create table entries for a state (or state fragment) which has
* only one out-transition.
*/
extern void mk1tbl PROTO ((int, int, int, int));
extern void mk1tbl(int, int, int, int);
/* Place a state into full speed transition table. */
extern void place_state PROTO ((int *, int, int));
extern void place_state(int *, int, int);
/* Save states with only one out-transition to be processed later. */
extern void stack1 PROTO ((int, int, int, int));
extern void stack1(int, int, int, int);
/* from file yylex.c */
extern int yylex PROTO ((void));
extern int yylex(void);
/* A growable array. See buf.c. */
struct Buf {
@@ -1118,30 +1043,28 @@ struct Buf {
int nmax; /* max capacity of elements. */
};
extern void buf_init PROTO ((struct Buf * buf, size_t elem_size));
extern void buf_destroy PROTO ((struct Buf * buf));
extern struct Buf *buf_append
PROTO ((struct Buf * buf, const void *ptr, int n_elem));
extern struct Buf *buf_concat PROTO((struct Buf* dest, const struct Buf* src));
extern struct Buf *buf_strappend PROTO ((struct Buf *, const char *str));
extern struct Buf *buf_strnappend
PROTO ((struct Buf *, const char *str, int nchars));
extern struct Buf *buf_strdefine
PROTO ((struct Buf * buf, const char *str, const char *def));
extern struct Buf *buf_prints PROTO((struct Buf *buf, const char *fmt, const char* s));
extern struct Buf *buf_m4_define PROTO((struct Buf *buf, const char* def, const char* val));
extern struct Buf *buf_m4_undefine PROTO((struct Buf *buf, const char* def));
extern struct Buf *buf_print_strings PROTO((struct Buf * buf, FILE* out));
extern struct Buf *buf_linedir PROTO((struct Buf *buf, const char* filename, int lineno));
extern void buf_init(struct Buf * buf, size_t elem_size);
extern void buf_destroy(struct Buf * buf);
extern struct Buf *buf_append(struct Buf * buf, const void *ptr, int n_elem);
extern struct Buf *buf_concat(struct Buf* dest, const struct Buf* src);
extern struct Buf *buf_strappend(struct Buf *, const char *str);
extern struct Buf *buf_strnappend(struct Buf *, const char *str, int nchars);
extern struct Buf *buf_strdefine(struct Buf * buf, const char *str, const char *def);
extern struct Buf *buf_prints(struct Buf *buf, const char *fmt, const char* s);
extern struct Buf *buf_m4_define(struct Buf *buf, const char* def, const char* val);
extern struct Buf *buf_m4_undefine(struct Buf *buf, const char* def);
extern struct Buf *buf_print_strings(struct Buf * buf, FILE* out);
extern struct Buf *buf_linedir(struct Buf *buf, const char* filename, int lineno);
extern struct Buf userdef_buf; /* a string buffer for #define's generated by user-options on cmd line. */
extern struct Buf defs_buf; /* a char* buffer to save #define'd some symbols generated by flex. */
extern struct Buf yydmap_buf; /* a string buffer to hold yydmap elements */
extern struct Buf m4defs_buf; /* Holds m4 definitions. */
extern struct Buf top_buf; /* contains %top code. String buffer. */
extern bool no_section3_escape; /* True if the undocumented option --unsafe-no-m4-sect3-escape was passed */
/* For blocking out code from the header file. */
#define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[")
#define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl")
#define OUT_END_CODE() outn("]])")
/* For setjmp/longjmp (instead of calling exit(2)). Linkage in main.c */
@@ -1194,14 +1117,14 @@ struct filter {
/* output filter chain */
extern struct filter * output_chain;
extern struct filter *filter_create_ext PROTO((struct filter * chain, const char *cmd, ...));
struct filter *filter_create_int PROTO((struct filter *chain,
extern struct filter *filter_create_ext (struct filter * chain, const char *cmd, ...);
struct filter *filter_create_int(struct filter *chain,
int (*filter_func) (struct filter *),
void *extra));
extern bool filter_apply_chain PROTO((struct filter * chain));
extern int filter_truncate (struct filter * chain, int max_len);
extern int filter_tee_header PROTO((struct filter *chain));
extern int filter_fix_linedirs PROTO((struct filter *chain));
void *extra);
extern bool filter_apply_chain(struct filter * chain);
extern int filter_truncate(struct filter * chain, int max_len);
extern int filter_tee_header(struct filter *chain);
extern int filter_fix_linedirs(struct filter *chain);
/*
@@ -1221,9 +1144,9 @@ bool regmatch_empty (regmatch_t * m);
typedef unsigned int scanflags_t;
extern scanflags_t* _sf_stk;
extern size_t _sf_top_ix, _sf_max; /**< stack of scanner flags. */
#define _SF_CASE_INS 0x0001
#define _SF_DOT_ALL 0x0002
#define _SF_SKIP_WS 0x0004
#define _SF_CASE_INS ((scanflags_t) 0x0001)
#define _SF_DOT_ALL ((scanflags_t) 0x0002)
#define _SF_SKIP_WS ((scanflags_t) 0x0004)
#define sf_top() (_sf_stk[_sf_top_ix])
#define sf_case_ins() (sf_top() & _SF_CASE_INS)
#define sf_dot_all() (sf_top() & _SF_DOT_ALL)
+4
View File
@@ -58,6 +58,10 @@ typedef unsigned int flex_uint32_t;
#define UINT32_MAX (4294967295U)
#endif
#ifndef SIZE_MAX
#define SIZE_MAX (~(size_t)0)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
+169 -196
View File
@@ -37,16 +37,11 @@
/* declare functions that have forward references */
void gen_next_state PROTO ((int));
void genecs PROTO ((void));
void indent_put2s PROTO ((const char *, const char *));
void indent_puts PROTO ((const char *));
void genecs(void);
static int indent_level = 0; /* each level is 8 spaces */
#define indent_up() (++indent_level)
#define indent_down() (--indent_level)
#define set_indent(indent_val) indent_level = indent_val
/* Almost everything is done in terms of arrays starting at 1, so provide
@@ -58,44 +53,30 @@ static int indent_level = 0; /* each level is 8 spaces */
static const char *get_int16_decl (void)
{
return (gentables)
? "static yyconst flex_int16_t %s[%d] =\n { 0,\n"
: "static yyconst flex_int16_t * %s = 0;\n";
? "static const flex_int16_t %s[%d] =\n { 0,\n"
: "static const flex_int16_t * %s = 0;\n";
}
static const char *get_int32_decl (void)
{
return (gentables)
? "static yyconst flex_int32_t %s[%d] =\n { 0,\n"
: "static yyconst flex_int32_t * %s = 0;\n";
? "static const flex_int32_t %s[%d] =\n { 0,\n"
: "static const flex_int32_t * %s = 0;\n";
}
static const char *get_state_decl (void)
{
return (gentables)
? "static yyconst yy_state_type %s[%d] =\n { 0,\n"
: "static yyconst yy_state_type * %s = 0;\n";
}
static const char *get_uint16_decl (void)
{
return (gentables)
? "static yyconst flex_uint16_t %s[%d] =\n { 0,\n"
: "static yyconst flex_uint16_t * %s = 0;\n";
}
static const char *get_uint32_decl (void)
{
return (gentables)
? "static yyconst flex_uint32_t %s[%d] =\n { 0,\n"
: "static yyconst flex_uint32_t * %s = 0;\n";
? "static const yy_state_type %s[%d] =\n { 0,\n"
: "static const yy_state_type * %s = 0;\n";
}
static const char *get_yy_char_decl (void)
{
return (gentables)
? "static yyconst YY_CHAR %s[%d] =\n { 0,\n"
: "static yyconst YY_CHAR * %s = 0;\n";
? "static const YY_CHAR %s[%d] =\n { 0,\n"
: "static const YY_CHAR * %s = 0;\n";
}
/* Indent to the current level. */
@@ -125,12 +106,12 @@ static struct yytbl_data *mkeoltbl (void)
flex_int8_t *tdata = 0;
struct yytbl_data *tbl;
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (tbl, YYTD_ID_RULE_CAN_MATCH_EOL);
tbl->td_flags = YYTD_DATA8;
tbl->td_lolen = num_rules + 1;
tbl->td_lolen = (flex_uint32_t) (num_rules + 1);
tbl->td_data = tdata =
(flex_int8_t *) calloc (tbl->td_lolen, sizeof (flex_int8_t));
calloc(tbl->td_lolen, sizeof (flex_int8_t));
for (i = 1; i <= num_rules; i++)
tdata[i] = rule_has_nl[i] ? 1 : 0;
@@ -176,12 +157,12 @@ void gen_backing_up (void)
else
indent_puts ("if ( yy_accept[yy_current_state] )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("YY_G(yy_last_accepting_state) = yy_current_state;");
indent_puts ("YY_G(yy_last_accepting_cpos) = yy_cp;");
indent_puts ("}");
indent_down ();
--indent_level;
}
@@ -232,14 +213,14 @@ static struct yytbl_data *mkctbl (void)
((tblend + numecs + 1) >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (tbl, YYTD_ID_TRANSITION);
tbl->td_flags = YYTD_DATA32 | YYTD_STRUCT;
tbl->td_hilen = 0;
tbl->td_lolen = tblend + numecs + 1; /* number of structs */
tbl->td_lolen = (flex_uint32_t) (tblend + numecs + 1); /* number of structs */
tbl->td_data = tdata =
(flex_int32_t *) calloc (tbl->td_lolen * 2, sizeof (flex_int32_t));
calloc(tbl->td_lolen * 2, sizeof (flex_int32_t));
/* We want the transition to be represented as the offset to the
* next state, not the actual state number, which is what it currently
@@ -328,14 +309,14 @@ static struct yytbl_data *mkssltbl (void)
flex_int32_t *tdata = 0;
flex_int32_t i;
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (tbl, YYTD_ID_START_STATE_LIST);
tbl->td_flags = YYTD_DATA32 | YYTD_PTRANS;
tbl->td_hilen = 0;
tbl->td_lolen = lastsc * 2 + 1;
tbl->td_lolen = (flex_uint32_t) (lastsc * 2 + 1);
tbl->td_data = tdata =
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
calloc(tbl->td_lolen, sizeof (flex_int32_t));
for (i = 0; i <= lastsc * 2; ++i)
tdata[i] = base[i];
@@ -358,9 +339,9 @@ void genctbl (void)
/* Table of verify for transition and offset to next state. */
if (gentables)
out_dec ("static yyconst struct yy_trans_info yy_transition[%d] =\n {\n", tblend + numecs + 1);
out_dec ("static const struct yy_trans_info yy_transition[%d] =\n {\n", tblend + numecs + 1);
else
outn ("static yyconst struct yy_trans_info *yy_transition = 0;");
outn ("static const struct yy_trans_info *yy_transition = 0;");
/* We want the transition to be represented as the offset to the
* next state, not the actual state number, which is what it currently
@@ -432,9 +413,9 @@ void genctbl (void)
/* Table of pointers to start states. */
if (gentables)
out_dec ("static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n", lastsc * 2 + 1);
out_dec ("static const struct yy_trans_info *yy_start_state_list[%d] =\n", lastsc * 2 + 1);
else
outn ("static yyconst struct yy_trans_info **yy_start_state_list =0;");
outn ("static const struct yy_trans_info **yy_start_state_list =0;");
if (gentables) {
outn (" {");
@@ -452,20 +433,20 @@ void genctbl (void)
/* mkecstbl - Make equivalence-class tables. */
struct yytbl_data *mkecstbl (void)
static struct yytbl_data *mkecstbl (void)
{
int i;
struct yytbl_data *tbl = 0;
flex_int32_t *tdata = 0;
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (tbl, YYTD_ID_EC);
tbl->td_flags |= YYTD_DATA32;
tbl->td_hilen = 0;
tbl->td_lolen = csize;
tbl->td_lolen = (flex_uint32_t) csize;
tbl->td_data = tdata =
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
calloc(tbl->td_lolen, sizeof (flex_int32_t));
for (i = 1; i < csize; ++i) {
ecgroup[i] = ABS (ecgroup[i]);
@@ -528,19 +509,23 @@ void gen_find_action (void)
indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);");
indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];");
if (!variable_trailing_context_rules)
outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[[");
if(reject_really_used)
outn ("find_rule: /* we branch to this label when backing up */");
if (!variable_trailing_context_rules)
outn ("]])\n");
indent_puts
("for ( ; ; ) /* until we find what rule we matched */");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts
("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];");
@@ -548,25 +533,25 @@ void gen_find_action (void)
indent_puts
("if ( yy_act & YY_TRAILING_HEAD_MASK ||");
indent_puts (" YY_G(yy_looking_for_trail_begin) )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts
("if ( yy_act == YY_G(yy_looking_for_trail_begin) )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("YY_G(yy_looking_for_trail_begin) = 0;");
indent_puts ("yy_act &= ~YY_TRAILING_HEAD_MASK;");
indent_puts ("break;");
indent_puts ("}");
indent_down ();
--indent_level;
indent_puts ("}");
indent_down ();
--indent_level;
indent_puts
("else if ( yy_act & YY_TRAILING_MASK )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts
("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;");
@@ -585,10 +570,10 @@ void gen_find_action (void)
}
indent_puts ("}");
indent_down ();
--indent_level;
indent_puts ("else");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("YY_G(yy_full_match) = yy_cp;");
indent_puts
@@ -596,7 +581,7 @@ void gen_find_action (void)
indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");
indent_puts ("break;");
indent_puts ("}");
indent_down ();
--indent_level;
indent_puts ("++YY_G(yy_lp);");
indent_puts ("goto find_rule;");
@@ -606,16 +591,16 @@ void gen_find_action (void)
/* Remember matched text in case we back up due to
* trailing context plus REJECT.
*/
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("YY_G(yy_full_match) = yy_cp;");
indent_puts ("break;");
indent_puts ("}");
indent_down ();
--indent_level;
}
indent_puts ("}");
indent_down ();
--indent_level;
indent_puts ("--yy_cp;");
@@ -628,7 +613,7 @@ void gen_find_action (void)
indent_puts ("}");
indent_down ();
--indent_level;
}
else { /* compressed */
@@ -639,7 +624,7 @@ void gen_find_action (void)
* the match.
*/
indent_puts ("if ( yy_act == 0 )");
indent_up ();
++indent_level;
indent_puts ("{ /* have to back up */");
indent_puts
("yy_cp = YY_G(yy_last_accepting_cpos);");
@@ -648,7 +633,7 @@ void gen_find_action (void)
indent_puts
("yy_act = yy_accept[yy_current_state];");
indent_puts ("}");
indent_down ();
--indent_level;
}
}
}
@@ -664,14 +649,14 @@ struct yytbl_data *mkftbl (void)
struct yytbl_data *tbl;
flex_int32_t *tdata = 0;
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (tbl, YYTD_ID_ACCEPT);
tbl->td_flags |= YYTD_DATA32;
tbl->td_hilen = 0; /* it's a one-dimensional array */
tbl->td_lolen = lastdfa + 1;
tbl->td_lolen = (flex_uint32_t) (lastdfa + 1);
tbl->td_data = tdata =
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
calloc(tbl->td_lolen, sizeof (flex_int32_t));
dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
@@ -727,8 +712,7 @@ void genftbl (void)
/* Generate the code to find the next compressed-table state. */
void gen_next_compressed_state (char_map)
char *char_map;
void gen_next_compressed_state (char *char_map)
{
indent_put2s ("YY_CHAR yy_c = %s;", char_map);
@@ -740,7 +724,7 @@ void gen_next_compressed_state (char_map)
indent_puts
("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("yy_current_state = (int) yy_def[yy_current_state];");
@@ -757,16 +741,16 @@ void gen_next_compressed_state (char_map)
/* lastdfa + 2 is the beginning of the templates */
out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2);
indent_up ();
indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];");
indent_down ();
++indent_level;
indent_puts ("yy_c = yy_meta[yy_c];");
--indent_level;
}
indent_puts ("}");
indent_down ();
--indent_level;
indent_puts
("yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];");
("yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];");
}
@@ -793,7 +777,7 @@ void gen_next_match (void)
("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s ]) > 0 )",
char_map);
indent_up ();
++indent_level;
if (num_backing_up > 0) {
indent_puts ("{");
@@ -807,7 +791,7 @@ void gen_next_match (void)
indent_puts ("}");
indent_down ();
--indent_level;
outc ('\n');
indent_puts ("yy_current_state = -yy_current_state;");
@@ -816,15 +800,15 @@ void gen_next_match (void)
else if (fullspd) {
indent_puts ("{");
indent_puts
("yyconst struct yy_trans_info *yy_trans_info;\n");
("const struct yy_trans_info *yy_trans_info;\n");
indent_puts ("YY_CHAR yy_c;\n");
indent_put2s ("for ( yy_c = %s;", char_map);
indent_puts
(" (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->");
(" (yy_trans_info = &yy_current_state[yy_c])->");
indent_puts ("yy_verify == yy_c;");
indent_put2s (" yy_c = %s )", char_map_2);
indent_up ();
++indent_level;
if (num_backing_up > 0)
indent_puts ("{");
@@ -837,14 +821,14 @@ void gen_next_match (void)
indent_puts ("}");
}
indent_down ();
--indent_level;
indent_puts ("}");
}
else { /* compressed */
indent_puts ("do");
indent_up ();
++indent_level;
indent_puts ("{");
gen_next_state (false);
@@ -853,7 +837,7 @@ void gen_next_match (void)
indent_puts ("}");
indent_down ();
--indent_level;
do_indent ();
@@ -878,8 +862,7 @@ void gen_next_match (void)
/* Generate the code to find the next state. */
void gen_next_state (worry_about_NULs)
int worry_about_NULs;
void gen_next_state (int worry_about_NULs)
{ /* NOTE - changes in here should be reflected in gen_next_match() */
char char_map[256];
@@ -905,7 +888,7 @@ void gen_next_state (worry_about_NULs)
gen_backing_up ();
indent_puts ("if ( *yy_cp )");
indent_up ();
++indent_level;
indent_puts ("{");
}
@@ -931,12 +914,12 @@ void gen_next_state (worry_about_NULs)
if (worry_about_NULs && nultrans) {
indent_puts ("}");
indent_down ();
--indent_level;
indent_puts ("else");
indent_up ();
++indent_level;
indent_puts
("yy_current_state = yy_NUL_trans[yy_current_state];");
indent_down ();
--indent_level;
}
if (fullspd || fulltbl)
@@ -960,7 +943,7 @@ void gen_NUL_trans (void)
/* We're going to need yy_cp lying around for the call
* below to gen_backing_up().
*/
indent_puts ("YY_CHAR *yy_cp = YY_G(yy_c_buf_p);");
indent_puts ("char *yy_cp = YY_G(yy_c_buf_p);");
outc ('\n');
@@ -984,7 +967,7 @@ void gen_NUL_trans (void)
out_dec ("int yy_c = %d;\n", NUL_ec);
indent_puts
("yyconst struct yy_trans_info *yy_trans_info;\n");
("const struct yy_trans_info *yy_trans_info;\n");
indent_puts
("yy_trans_info = &yy_current_state[(unsigned int) yy_c];");
indent_puts ("yy_current_state += yy_trans_info->yy_nxt;");
@@ -1009,10 +992,10 @@ void gen_NUL_trans (void)
* the state stack and yy_c_buf_p get out of sync.
*/
indent_puts ("if ( ! yy_is_jam )");
indent_up ();
++indent_level;
indent_puts
("*YY_G(yy_state_ptr)++ = yy_current_state;");
indent_down ();
--indent_level;
}
}
@@ -1023,11 +1006,11 @@ void gen_NUL_trans (void)
if (need_backing_up && (fullspd || fulltbl)) {
outc ('\n');
indent_puts ("if ( ! yy_is_jam )");
indent_up ();
++indent_level;
indent_puts ("{");
gen_backing_up ();
indent_puts ("}");
indent_down ();
--indent_level;
}
}
@@ -1111,11 +1094,11 @@ void gentabs (void)
"\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n",
long_align ? "flex_int32_t" : "flex_int16_t");
yyacclist_tbl = (struct yytbl_data*)calloc(1,sizeof(struct yytbl_data));
yyacclist_tbl = calloc(1,sizeof(struct yytbl_data));
yytbl_data_init (yyacclist_tbl, YYTD_ID_ACCLIST);
yyacclist_tbl->td_lolen = MAX(numas,1) + 1;
yyacclist_tbl->td_lolen = (flex_uint32_t) (MAX(numas,1) + 1);
yyacclist_tbl->td_data = yyacclist_data =
(flex_int32_t *) calloc (yyacclist_tbl->td_lolen, sizeof (flex_int32_t));
calloc(yyacclist_tbl->td_lolen, sizeof (flex_int32_t));
yyacclist_curr = 1;
j = 1; /* index into "yy_acclist" array */
@@ -1220,13 +1203,11 @@ void gentabs (void)
"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
long_align ? "flex_int32_t" : "flex_int16_t");
yyacc_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct yytbl_data));
yyacc_tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (yyacc_tbl, YYTD_ID_ACCEPT);
yyacc_tbl->td_lolen = k;
yyacc_tbl->td_lolen = (flex_uint32_t) k;
yyacc_tbl->td_data = yyacc_data =
(flex_int32_t *) calloc (yyacc_tbl->td_lolen, sizeof (flex_int32_t));
calloc(yyacc_tbl->td_lolen, sizeof (flex_int32_t));
yyacc_curr=1;
for (i = 1; i <= lastdfa; ++i) {
@@ -1279,14 +1260,11 @@ void gentabs (void)
* templates with).
*/
flex_int32_t *yymecs_data = 0;
yymeta_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct
yytbl_data));
yymeta_tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (yymeta_tbl, YYTD_ID_META);
yymeta_tbl->td_lolen = numecs + 1;
yymeta_tbl->td_lolen = (flex_uint32_t) (numecs + 1);
yymeta_tbl->td_data = yymecs_data =
(flex_int32_t *) calloc (yymeta_tbl->td_lolen,
calloc(yymeta_tbl->td_lolen,
sizeof (flex_int32_t));
if (trace)
@@ -1323,20 +1301,18 @@ void gentabs (void)
/* Begin generating yy_base */
out_str_dec ((tblend >= INT16_MAX || long_align) ?
get_uint32_decl () : get_uint16_decl (),
get_int32_decl () : get_int16_decl (),
"yy_base", total_states + 1);
buf_prints (&yydmap_buf,
"\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n",
(tblend >= INT16_MAX
|| long_align) ? "flex_uint32_t" : "flex_uint16_t");
yybase_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct yytbl_data));
|| long_align) ? "flex_int32_t" : "flex_int16_t");
yybase_tbl = calloc (1, sizeof (struct yytbl_data));
yytbl_data_init (yybase_tbl, YYTD_ID_BASE);
yybase_tbl->td_lolen = total_states + 1;
yybase_tbl->td_lolen = (flex_uint32_t) (total_states + 1);
yybase_tbl->td_data = yybase_data =
(flex_int32_t *) calloc (yybase_tbl->td_lolen,
calloc(yybase_tbl->td_lolen,
sizeof (flex_int32_t));
yybase_curr = 1;
@@ -1390,13 +1366,11 @@ void gentabs (void)
(total_states >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
yydef_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct yytbl_data));
yydef_tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (yydef_tbl, YYTD_ID_DEF);
yydef_tbl->td_lolen = total_states + 1;
yydef_tbl->td_lolen = (flex_uint32_t) (total_states + 1);
yydef_tbl->td_data = yydef_data =
(flex_int32_t *) calloc (yydef_tbl->td_lolen, sizeof (flex_int32_t));
calloc(yydef_tbl->td_lolen, sizeof (flex_int32_t));
for (i = 1; i <= total_states; ++i) {
mkdata (def[i]);
@@ -1416,21 +1390,19 @@ void gentabs (void)
/* Begin generating yy_nxt */
out_str_dec ((total_states >= INT16_MAX || long_align) ?
get_uint32_decl () : get_uint16_decl (), "yy_nxt",
get_int32_decl () : get_int16_decl (), "yy_nxt",
tblend + 1);
buf_prints (&yydmap_buf,
"\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
(total_states >= INT16_MAX
|| long_align) ? "flex_uint32_t" : "flex_uint16_t");
|| long_align) ? "flex_int32_t" : "flex_int16_t");
yynxt_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct yytbl_data));
yynxt_tbl = calloc (1, sizeof (struct yytbl_data));
yytbl_data_init (yynxt_tbl, YYTD_ID_NXT);
yynxt_tbl->td_lolen = tblend + 1;
yynxt_tbl->td_lolen = (flex_uint32_t) (tblend + 1);
yynxt_tbl->td_data = yynxt_data =
(flex_int32_t *) calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t));
calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t));
for (i = 1; i <= tblend; ++i) {
/* Note, the order of the following test is important.
@@ -1463,13 +1435,11 @@ void gentabs (void)
(total_states >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
yychk_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct yytbl_data));
yychk_tbl = calloc (1, sizeof (struct yytbl_data));
yytbl_data_init (yychk_tbl, YYTD_ID_CHK);
yychk_tbl->td_lolen = tblend + 1;
yychk_tbl->td_lolen = (flex_uint32_t) (tblend + 1);
yychk_tbl->td_data = yychk_data =
(flex_int32_t *) calloc (yychk_tbl->td_lolen, sizeof (flex_int32_t));
calloc(yychk_tbl->td_lolen, sizeof (flex_int32_t));
for (i = 1; i <= tblend; ++i) {
if (chk[i] == 0)
@@ -1489,7 +1459,7 @@ void gentabs (void)
}
/* End generating yy_chk */
flex_free ((void *) acc_array);
free(acc_array);
}
@@ -1497,8 +1467,7 @@ void gentabs (void)
* current indentation level, adding a final newline.
*/
void indent_put2s (fmt, arg)
const char *fmt, *arg;
void indent_put2s (const char *fmt, const char *arg)
{
do_indent ();
out_str (fmt, arg);
@@ -1510,8 +1479,7 @@ void indent_put2s (fmt, arg)
* newline.
*/
void indent_puts (str)
const char *str;
void indent_puts (const char *str)
{
do_indent ();
outn (str);
@@ -1525,7 +1493,7 @@ void make_tables (void)
{
int i;
int did_eof_rule = false;
struct yytbl_data *yynultrans_tbl;
struct yytbl_data *yynultrans_tbl = NULL;
skelout (); /* %% [2.0] - break point in skel */
@@ -1538,11 +1506,11 @@ void make_tables (void)
if (yymore_used && !yytext_is_array) {
indent_puts ("YY_G(yytext_ptr) -= YY_G(yy_more_len); \\");
indent_puts
("yyleng = (size_t) (yy_cp - YY_G(yytext_ptr)); \\");
("yyleng = (int) (yy_cp - YY_G(yytext_ptr)); \\");
}
else
indent_puts ("yyleng = (size_t) (yy_cp - yy_bp); \\");
indent_puts ("yyleng = (int) (yy_cp - yy_bp); \\");
/* Now also deal with copying yytext_ptr to yytext if needed. */
skelout (); /* %% [3.0] - break point in skel */
@@ -1553,10 +1521,10 @@ void make_tables (void)
else
indent_puts ("if ( yyleng >= YYLMAX ) \\");
indent_up ();
++indent_level;
indent_puts
("YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\");
indent_down ();
--indent_level;
if (yymore_used) {
indent_puts
@@ -1593,7 +1561,7 @@ void make_tables (void)
set_indent (0);
indent_puts ("struct yy_trans_info");
indent_up ();
++indent_level;
indent_puts ("{");
/* We require that yy_verify and yy_nxt must be of the same size int. */
@@ -1609,7 +1577,7 @@ void make_tables (void)
indent_put2s ("%s yy_nxt;", trans_offset_type);
indent_puts ("};");
indent_down ();
--indent_level;
}
else {
/* We generate a bogus 'struct yy_trans_info' data type
@@ -1621,12 +1589,12 @@ void make_tables (void)
("/* This struct is not used in this scanner,");
indent_puts (" but its presence is necessary. */");
indent_puts ("struct yy_trans_info");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("flex_int32_t yy_verify;");
indent_puts ("flex_int32_t yy_nxt;");
indent_puts ("};");
indent_down ();
--indent_level;
}
if (fullspd) {
@@ -1709,7 +1677,7 @@ void make_tables (void)
indent_puts
("static yy_state_type yy_last_accepting_state;");
indent_puts
("static YY_CHAR *yy_last_accepting_cpos;\n");
("static char *yy_last_accepting_cpos;\n");
}
}
@@ -1724,16 +1692,13 @@ void make_tables (void)
(fullspd) ? "struct yy_trans_info*" :
"flex_int32_t");
yynultrans_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct
yytbl_data));
yynultrans_tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (yynultrans_tbl, YYTD_ID_NUL_TRANS);
if (fullspd)
yynultrans_tbl->td_flags |= YYTD_PTRANS;
yynultrans_tbl->td_lolen = lastdfa + 1;
yynultrans_tbl->td_lolen = (flex_uint32_t) (lastdfa + 1);
yynultrans_tbl->td_data = yynultrans_data =
(flex_int32_t *) calloc (yynultrans_tbl->td_lolen,
calloc(yynultrans_tbl->td_lolen,
sizeof (flex_int32_t));
for (i = 1; i <= lastdfa; ++i) {
@@ -1755,9 +1720,13 @@ void make_tables (void)
0)
flexerror (_
("Could not write yynultrans_tbl"));
}
if (yynultrans_tbl != NULL) {
yytbl_data_destroy (yynultrans_tbl);
yynultrans_tbl = NULL;
}
}
/* End generating yy_NUL_trans */
}
@@ -1781,7 +1750,7 @@ void make_tables (void)
/* Declare state buffer variables. */
if (!C_plus_plus && !reentrant) {
outn ("static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;");
outn ("static YY_CHAR *yy_full_match;");
outn ("static char *yy_full_match;");
outn ("static int yy_lp;");
}
@@ -1846,13 +1815,13 @@ void make_tables (void)
indent_puts ("#define YY_MORE_ADJ 0");
indent_puts
("#define YY_RESTORE_YY_MORE_OFFSET \\");
indent_up ();
++indent_level;
indent_puts ("{ \\");
indent_puts
("YY_G(yy_more_offset) = YY_G(yy_prev_more_offset); \\");
indent_puts ("yyleng -= YY_G(yy_more_offset); \\");
indent_puts ("}");
indent_down ();
--indent_level;
}
else {
indent_puts
@@ -1876,14 +1845,14 @@ void make_tables (void)
outn ("#define YYLMAX 8192");
outn ("#endif\n");
if (!reentrant){
outn ("YY_CHAR yytext[YYLMAX];");
outn ("YY_CHAR *yytext_ptr;");
outn ("char yytext[YYLMAX];");
outn ("char *yytext_ptr;");
}
}
else {
if(! reentrant)
outn ("YY_CHAR *yytext;");
outn ("char *yytext;");
}
}
@@ -1896,7 +1865,7 @@ void make_tables (void)
if (!C_plus_plus) {
if (use_read) {
outn ("\terrno=0; \\");
outn ("\twhile ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\");
outn ("\twhile ( (result = (int) read( fileno(yyin), buf, (yy_size_t) max_size )) < 0 ) \\");
outn ("\t{ \\");
outn ("\t\tif( errno != EINTR) \\");
outn ("\t\t{ \\");
@@ -1912,7 +1881,7 @@ void make_tables (void)
outn ("\tif ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \\");
outn ("\t\t{ \\");
outn ("\t\tint c = '*'; \\");
outn ("\t\tsize_t n; \\");
outn ("\t\tint n; \\");
outn ("\t\tfor ( n = 0; n < max_size && \\");
outn ("\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\");
outn ("\t\t\tbuf[n] = (char) c; \\");
@@ -1925,7 +1894,7 @@ void make_tables (void)
outn ("\telse \\");
outn ("\t\t{ \\");
outn ("\t\terrno=0; \\");
outn ("\t\twhile ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\");
outn ("\t\twhile ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \\");
outn ("\t\t\t{ \\");
outn ("\t\t\tif( errno != EINTR) \\");
outn ("\t\t\t\t{ \\");
@@ -1942,16 +1911,16 @@ void make_tables (void)
skelout (); /* %% [6.0] - break point in skel */
indent_puts ("#define YY_RULE_SETUP \\");
indent_up ();
++indent_level;
if (bol_needed) {
indent_puts ("if ( yyleng > 0 ) \\");
indent_up ();
++indent_level;
indent_puts ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \\");
indent_puts ("\t\t(yytext[yyleng - 1] == '\\n'); \\");
indent_down ();
--indent_level;
}
indent_puts ("YY_USER_ACTION");
indent_down ();
--indent_level;
skelout (); /* %% [7.0] - break point in skel */
@@ -1967,13 +1936,13 @@ void make_tables (void)
if (yymore_used && !yytext_is_array) {
indent_puts ("YY_G(yy_more_len) = 0;");
indent_puts ("if ( YY_G(yy_more_flag) )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts
("YY_G(yy_more_len) = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);");
("YY_G(yy_more_len) = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr));");
indent_puts ("YY_G(yy_more_flag) = 0;");
indent_puts ("}");
indent_down ();
--indent_level;
}
skelout (); /* %% [9.0] - break point in skel */
@@ -1992,39 +1961,39 @@ void make_tables (void)
outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[[");
indent_puts
("if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("yy_size_t yyl;");
indent_puts ("int yyl;");
do_indent ();
out_str ("for ( yyl = %s; yyl < yyleng; ++yyl )\n",
yymore_used ? (yytext_is_array ? "YY_G(yy_prev_more_offset)" :
"YY_G(yy_more_len)") : "0");
indent_up ();
++indent_level;
indent_puts ("if ( yytext[yyl] == '\\n' )");
indent_up ();
++indent_level;
indent_puts ("M4_YY_INCR_LINENO();");
indent_down ();
indent_down ();
--indent_level;
--indent_level;
indent_puts ("}");
indent_down ();
--indent_level;
outn ("]])");
skelout (); /* %% [12.0] - break point in skel */
if (ddebug) {
indent_puts ("if ( yy_flex_debug )");
indent_up ();
++indent_level;
indent_puts ("{");
indent_puts ("if ( yy_act == 0 )");
indent_up ();
++indent_level;
indent_puts (C_plus_plus ?
"std::cerr << \"--scanner backing up\\n\";" :
"fprintf( stderr, \"--scanner backing up\\n\" );");
indent_down ();
--indent_level;
do_indent ();
out_dec ("else if ( yy_act < %d )\n", num_rules);
indent_up ();
++indent_level;
if (C_plus_plus) {
indent_puts
@@ -2040,11 +2009,11 @@ void make_tables (void)
(" (long)yy_rule_linenum[yy_act], yytext );");
}
indent_down ();
--indent_level;
do_indent ();
out_dec ("else if ( yy_act == %d )\n", num_rules);
indent_up ();
++indent_level;
if (C_plus_plus) {
indent_puts
@@ -2056,21 +2025,21 @@ void make_tables (void)
indent_puts (" yytext );");
}
indent_down ();
--indent_level;
do_indent ();
out_dec ("else if ( yy_act == %d )\n", num_rules + 1);
indent_up ();
++indent_level;
indent_puts (C_plus_plus ?
"std::cerr << \"--(end of buffer or a NUL)\\n\";" :
"fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );");
indent_down ();
--indent_level;
do_indent ();
outn ("else");
indent_up ();
++indent_level;
if (C_plus_plus) {
indent_puts
@@ -2081,15 +2050,15 @@ void make_tables (void)
("fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );");
}
indent_down ();
--indent_level;
indent_puts ("}");
indent_down ();
--indent_level;
}
/* Copy actions to output file. */
skelout (); /* %% [13.0] - break point in skel */
indent_up ();
++indent_level;
gen_bu_action ();
out (&action_array[action_offset]);
@@ -2104,9 +2073,9 @@ void make_tables (void)
}
if (did_eof_rule) {
indent_up ();
++indent_level;
indent_puts ("yyterminate();");
indent_down ();
--indent_level;
}
@@ -2164,17 +2133,17 @@ void make_tables (void)
if (do_yylineno) {
indent_puts
("if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )");
indent_up ();
++indent_level;
indent_puts ("M4_YY_INCR_LINENO();");
indent_down ();
--indent_level;
}
}
else if (do_yylineno) {
indent_puts ("if ( c == '\\n' )");
indent_up ();
++indent_level;
indent_puts ("M4_YY_INCR_LINENO();");
indent_down ();
--indent_level;
}
skelout ();
@@ -2185,7 +2154,11 @@ void make_tables (void)
if (sectnum == 3) {
OUT_BEGIN_CODE ();
if (!no_section3_escape)
fputs("[[", stdout);
(void) flexscan (); /* copy remainder of input to output */
if (!no_section3_escape)
fputs("]]", stdout);
OUT_END_CODE ();
}
}
+3 -1
View File
@@ -21,6 +21,8 @@
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/* PURPOSE. */
#include <stdlib.h>
extern int yylex (void);
int main (int argc, char *argv[])
@@ -30,5 +32,5 @@ int main (int argc, char *argv[])
while (yylex () != 0) ;
return 0;
exit(0);
}
+91 -198
View File
@@ -36,15 +36,15 @@
#include "version.h"
#include "options.h"
#include "tables.h"
#include "parse.h"
static char flex_version[] = FLEX_VERSION;
/* declare functions that have forward references */
void flexinit PROTO ((int, char **));
void readin PROTO ((void));
void set_up_initial_allocations PROTO ((void));
static char *basename2 PROTO ((char *path, int should_strip_ext));
void flexinit(int, char **);
void readin(void);
void set_up_initial_allocations(void);
/* these globals are all defined and commented in flexdef.h */
@@ -64,7 +64,7 @@ int skel_ind = 0;
char *action_array;
int action_size, defs1_offset, prolog_offset, action_offset,
action_index;
char *infilename = NULL, *outfilename = NULL, *headerfilename = NULL, *headercharfilename = NULL;
char *infilename = NULL, *outfilename = NULL, *headerfilename = NULL;
int did_outfilename;
char *prefix, *yyclass, *extra_type = NULL;
int do_stdinit, use_stdout;
@@ -94,21 +94,18 @@ int *accsiz, *dhash, numas;
int numsnpairs, jambase, jamstate;
int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
int current_maxccls, current_max_ccl_tbl_size;
Char *ccltbl;
unsigned char *ccltbl;
char nmstr[MAXLINE];
int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
int num_backing_up, bol_needed;
FILE *backing_up_file;
FILE *char_header_file = NULL;
int end_of_buffer_state;
char **input_files;
int num_input_files;
jmp_buf flex_main_jmp_buf;
bool *rule_has_nl, *ccl_has_nl;
int nlch = '\n';
bool ansi_func_defs, ansi_func_protos, charset_enabled = false;
char *charset_source = NULL;
bool tablesext, tablesverify, gentables;
char *tablesfilename=0,*tablesname=0;
@@ -119,19 +116,9 @@ struct yytbl_writer tableswr;
*/
char *program_name = "flex";
#ifndef SHORT_FILE_NAMES
static const char outfile_template[] = "lex.%s.%s";
static const char backing_name[] = "lex.backup";
static const char tablesfile_template[] = "lex.%s.tables";
#else
static const char outfile_template[] = "lex%s.%s";
static const char backing_name[] = "lex.bck";
static const char tablesfile_template[] = "lex%s.tbl";
#endif
#ifdef MS_DOS
extern unsigned _stklen = 16384;
#endif
/* From scan.l */
extern FILE* yyout;
@@ -140,18 +127,15 @@ static char outfile_path[MAXLINE];
static int outfile_created = 0;
static char *skelname = NULL;
static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */
const char *escaped_qstart = "[[]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[]]";
const char *escaped_qend = "[[]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[]]";
const char *escaped_qstart = "]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[";
const char *escaped_qend = "]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[";
/* For debugging. The max number of filters to apply to skeleton. */
static int preproc_level = 1000;
int flex_main PROTO ((int argc, char *argv[]));
int main PROTO ((int argc, char *argv[]));
int flex_main (int argc, char *argv[]);
int flex_main (argc, argv)
int argc;
char *argv[];
int flex_main (int argc, char *argv[])
{
int i, exit_status, child_status;
@@ -211,9 +195,7 @@ int flex_main (argc, argv)
}
/* Wrapper around flex_main, so flex_main can be built as a library. */
int main (argc, argv)
int argc;
char *argv[];
int main (int argc, char *argv[])
{
#if ENABLE_NLS
#if HAVE_LOCALE_H
@@ -229,7 +211,7 @@ int main (argc, argv)
/* check_options - check user-specified options */
void check_options ()
void check_options (void)
{
int i;
const char * m4 = NULL;
@@ -294,7 +276,7 @@ void check_options ()
flexerror (_("Can't use -+ with -CF option"));
if (C_plus_plus && yytext_is_array) {
warn (_("%array incompatible with -+ option"));
lwarn (_("%array incompatible with -+ option"));
yytext_is_array = false;
}
@@ -304,8 +286,6 @@ void check_options ()
if (C_plus_plus && bison_bridge_lval)
flexerror (_("bison bridge not supported for the C++ scanner."));
if(C_plus_plus)
buf_m4_define( &m4defs_buf, "M4_YY_CXX", NULL);
if (useecs) { /* Set up doubly-linked equivalence classes. */
@@ -330,14 +310,8 @@ void check_options ()
}
}
if (!ansi_func_defs)
buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_DEFS", NULL);
if (!ansi_func_protos)
buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_PROTOS", NULL);
if (extra_type)
buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type);
if (extra_type)
buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type);
if (!use_stdout) {
FILE *prev_stdout;
@@ -367,47 +341,48 @@ void check_options ()
/* Setup the filter chain. */
output_chain = filter_create_int(NULL, filter_tee_header, headerfilename);
if ( !(m4 = getenv("M4")))
m4 = M4;
if ( !(m4 = getenv("M4"))) {
char *slash;
m4 = M4;
if ((slash = strrchr(M4, '/')) != NULL) {
m4 = slash+1;
/* break up $PATH */
const char *path = getenv("PATH");
if (!path) {
m4 = M4;
} else {
int m4_length = strlen(m4);
do {
size_t length = strlen(path);
struct stat sbuf;
const char *endOfDir = strchr(path, ':');
if (!endOfDir)
endOfDir = path+length;
{
char *m4_path = calloc(endOfDir-path + 1 + m4_length + 1, 1);
memcpy(m4_path, path, endOfDir-path);
m4_path[endOfDir-path] = '/';
memcpy(m4_path + (endOfDir-path) + 1, m4, m4_length + 1);
if (stat(m4_path, &sbuf) == 0 &&
(S_ISREG(sbuf.st_mode)) && sbuf.st_mode & S_IXUSR) {
m4 = m4_path;
break;
}
free(m4_path);
}
path = endOfDir+1;
} while (path[0]);
if (!path[0])
m4 = M4;
}
}
}
filter_create_ext(output_chain, m4, "-P", 0);
filter_create_int(output_chain, filter_fix_linedirs, NULL);
if(headerfilename && !headercharfilename) {
char *suffix = ".h";
char *basesuffix = "_char";
size_t suffix_len = strlen(suffix);
size_t basesuffix_len = strlen(basesuffix);
size_t headerfilename_len = strlen(headerfilename);
char *p = strstr(headerfilename, suffix);
if(p && headerfilename+headerfilename_len-suffix_len == p)
headerfilename_len -= suffix_len; /* cut out suffix */
headercharfilename = malloc(headerfilename_len+basesuffix_len+suffix_len+1);
p = headercharfilename;
strncpy(p, headerfilename, headerfilename_len);
p += headerfilename_len;
strncpy(p, basesuffix, basesuffix_len);
p += basesuffix_len;
strncpy(p, suffix, suffix_len);
}
/* Setup char header file */
if(headercharfilename) {
char_header_file = fopen(headercharfilename, "w");
fprintf(char_header_file, "#pragma once\n");
fprintf(char_header_file, "\n");
fflush(char_header_file);
buf_strappend(&userdef_buf, "#include \"");
buf_strappend(&userdef_buf, headercharfilename);
buf_strappend(&userdef_buf, "\"\n");
}
/* For debugging, only run the requested number of filters. */
if (preproc_level > 0) {
filter_truncate(output_chain, preproc_level);
@@ -430,26 +405,25 @@ void check_options ()
FILE *tablesout;
struct yytbl_hdr hdr;
char *pname = 0;
int nbytes = 0;
size_t nbytes = 0;
buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL);
if (!tablesfilename) {
nbytes = strlen (prefix) + strlen (tablesfile_template) + 2;
tablesfilename = pname = (char *) calloc (nbytes, 1);
tablesfilename = pname = calloc(nbytes, 1);
snprintf (pname, nbytes, tablesfile_template, prefix);
}
if ((tablesout = fopen (tablesfilename, "w")) == NULL)
lerr (_("could not create %s"), tablesfilename);
if (pname)
free (pname);
free(pname);
tablesfilename = 0;
yytbl_writer_init (&tableswr, tablesout);
nbytes = strlen (prefix) + strlen ("tables") + 2;
tablesname = (char *) calloc (nbytes, 1);
tablesname = calloc(nbytes, 1);
snprintf (tablesname, nbytes, "%stables", prefix);
yytbl_hdr_init (&hdr, flex_version, tablesname);
@@ -472,6 +446,8 @@ void check_options ()
if ( bison_bridge_lloc)
buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL);
if (strchr(prefix, '[') || strchr(prefix, ']'))
flexerror(_("Prefix cannot include '[' or ']'"));
buf_m4_define(&m4defs_buf, "M4_YY_PREFIX", prefix);
if (did_outfilename)
@@ -480,12 +456,6 @@ void check_options ()
if (do_yylineno)
buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL);
if(charset_enabled)
buf_m4_define(&m4defs_buf, "M4_YY_CHARSET", NULL);
if(charset_source)
buf_m4_define(&m4defs_buf, "M4_YY_CHARSET_SOURCE", charset_source);
/* Create the alignment type. */
buf_strdefine (&userdef_buf, "YY_INT_ALIGNED",
long_align ? "long int" : "short int");
@@ -498,7 +468,8 @@ void check_options ()
char *str, *fmt = "#define %s %d\n";
size_t strsz;
str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(scname[i]) + (int)(1 + log10(i)) + 2);
strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2;
str = malloc(strsz);
if (!str)
flexfatal(_("allocation of macro definition failed"));
snprintf(str, strsz, fmt, scname[i], i - 1);
@@ -520,7 +491,8 @@ void check_options ()
m4defs_buf.nelts = 0; /* memory leak here. */
/* Place a bogus line directive, it will be fixed in the filter. */
outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
if (gen_line_dirs)
outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
/* Dump the user defined preproc directives. */
if (userdef_buf.elts)
@@ -536,9 +508,7 @@ void check_options ()
* This routine does not return.
*/
void flexend (exit_status)
int exit_status;
void flexend (int exit_status)
{
static int called_before = -1; /* prevent infinite recursion. */
int tblsiz;
@@ -546,10 +516,6 @@ void flexend (exit_status)
if (++called_before)
FLEX_EXIT (exit_status);
if(char_header_file && fclose (char_header_file))
lerrsf (_("error closing char header file %s"),
headercharfilename);
if (skelfile != NULL) {
if (ferror (skelfile))
lerr (_("input error reading skeleton file %s"),
@@ -589,7 +555,6 @@ void flexend (exit_status)
"EOB_ACT_END_OF_FILE",
"EOB_ACT_LAST_MATCH",
"FLEX_SCANNER",
"FLEX_STD",
"REJECT",
"YYFARGS0",
"YYFARGS1",
@@ -676,7 +641,7 @@ void flexend (exit_status)
"yypop_buffer_state",
"yyensure_buffer_stack",
"yyalloc",
"yyconst",
"const",
"yyextra",
"yyfree",
"yyget_debug",
@@ -976,9 +941,7 @@ void flexend (exit_status)
/* flexinit - initialize flex */
void flexinit (argc, argv)
int argc;
char **argv;
void flexinit (int argc, char **argv)
{
int i, sawcmpflag, rv, optind;
char *arg;
@@ -1003,7 +966,6 @@ void flexinit (argc, argv)
tablesext = tablesverify = false;
gentables = true;
tablesfilename = tablesname = NULL;
ansi_func_defs = ansi_func_protos = true;
sawcmpflag = false;
@@ -1032,9 +994,9 @@ void flexinit (argc, argv)
flex_init_regex();
/* Enable C++ if program name ends with '+'. */
program_name = basename2 (argv[0], 0);
program_name = basename (argv[0]);
if (program_name[0] != '\0' &&
if (program_name != NULL &&
program_name[strlen (program_name) - 1] == '+')
C_plus_plus = true;
@@ -1155,7 +1117,7 @@ void flexinit (argc, argv)
break;
case OPT_PREPROC_LEVEL:
preproc_level = strtol(arg,NULL,0);
preproc_level = (int) strtol(arg,NULL,0);
break;
case OPT_MAIN:
@@ -1318,7 +1280,7 @@ void flexinit (argc, argv)
}
else {
buf_strnappend (&userdef_buf, arg,
def - arg);
(int) (def - arg));
buf_strappend (&userdef_buf, " ");
buf_strappend (&userdef_buf,
def + 1);
@@ -1380,14 +1342,6 @@ void flexinit (argc, argv)
reject_really_used = false;
break;
case OPT_NO_ANSI_FUNC_DEFS:
ansi_func_defs = false;
break;
case OPT_NO_ANSI_FUNC_PROTOS:
ansi_func_protos = false;
break;
case OPT_NO_YY_PUSH_STATE:
//buf_strdefine (&userdef_buf, "YY_NO_PUSH_STATE", "1");
buf_m4_define( &m4defs_buf, "M4_YY_NO_PUSH_STATE",0);
@@ -1474,6 +1428,10 @@ void flexinit (argc, argv)
break;
case OPT_HEX:
trace_hex = 1;
break;
case OPT_NO_SECT3_ESCAPE:
no_section3_escape = true;
break;
} /* switch */
} /* while scanopt() */
@@ -1506,20 +1464,13 @@ void flexinit (argc, argv)
/* readin - read in the rules section of the input file(s) */
void readin ()
void readin (void)
{
static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
static char yy_nostdinit[] =
"FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
static char character_type_uchar[] = "typedef unsigned char YY_CHAR;";
static char character_type_char[] = "typedef char YY_CHAR;";
static char character_defined[] = "#define YY_CHAR_DEFINED";
"FILE *yyin = NULL, *yyout = NULL;";
static char charset_handler_t[] = "typedef size_t(*yycharset_handler_t)(char*,char*,size_t,YY_CHAR*,size_t,size_t*);\n";
static char charset_handler_t_reentrant[] = "typedef size_t(*yycharset_handler_t)(char*,char*,size_t,YY_CHAR*,size_t,size_t*,yyscan_t);\n";
line_directive_out ((FILE *) 0, 1);
line_directive_out(NULL, 1);
if (yyparse ()) {
pinpoint_message (_("fatal parse error"));
@@ -1636,9 +1587,9 @@ void readin ()
if (!do_yywrap) {
if (!C_plus_plus) {
if (reentrant)
outn ("\n#define yywrap(yyscanner) (/*CONSTCOND*/1)");
out_str ("\n#define %swrap(yyscanner) (/*CONSTCOND*/1)\n", prefix);
else
outn ("\n#define yywrap() (/*CONSTCOND*/1)");
out_str ("\n#define %swrap() (/*CONSTCOND*/1)\n", prefix);
}
outn ("#define YY_SKIP_YYWRAP");
}
@@ -1647,27 +1598,9 @@ void readin ()
outn ("\n#define FLEX_DEBUG");
OUT_BEGIN_CODE ();
outn("#ifndef YY_CHAR_DEFINED");
if (csize == 256) {
outn (character_type_uchar);
if(char_header_file)
fprintf(char_header_file, "%s\n", character_type_uchar);
} else {
outn (character_type_char);
if(char_header_file)
fprintf(char_header_file, "%s\n", character_type_char);
}
outn(character_defined);
outn("#endif");
if(char_header_file) {
fprintf(char_header_file, "%s\n", character_defined);
fflush(char_header_file);
}
outn ("typedef flex_uint8_t YY_CHAR;");
OUT_END_CODE ();
if(charset_enabled)
outn ("#define YY_CHARSET");
if (C_plus_plus) {
outn ("#define yytext_ptr yytext");
@@ -1709,7 +1642,7 @@ void readin ()
OUT_BEGIN_CODE ();
if (fullspd)
outn ("typedef yyconst struct yy_trans_info *yy_state_type;");
outn ("typedef const struct yy_trans_info *yy_state_type;");
else if (!C_plus_plus)
outn ("typedef int yy_state_type;");
OUT_END_CODE ();
@@ -1750,20 +1683,18 @@ void readin ()
*/
if (yytext_is_array) {
if (!reentrant)
outn ("extern YY_CHAR yytext[];\n");
outn ("extern char yytext[];\n");
}
else {
/* This prevents warning of "already defined macro" in multiple
* non-reentrant scanners */
outn("#ifdef yytext_ptr");
outn("#undef yytext_ptr");
outn("#endif");
if (reentrant) {
outn ("#define yytext_ptr yytext_r");
}
else {
outn ("extern YY_CHAR *yytext;");
outn ("extern char *yytext;");
outn("#ifdef yytext_ptr");
outn("#undef yytext_ptr");
outn("#endif");
outn ("#define yytext_ptr yytext");
}
}
@@ -1773,22 +1704,6 @@ void readin ()
("%option yyclass only meaningful for C++ scanners"));
}
outn("");
if(charset_enabled) {
if(!reentrant)
outn(charset_handler_t);
else
outn(charset_handler_t_reentrant);
OUT_BEGIN_CODE ();
if(!C_plus_plus && !reentrant) {
outn("char *yycharset = NULL;");
outn("yycharset_handler_t yycharset_handler = NULL;");
}
OUT_END_CODE ();
}
if (useecs)
numecs = cre8ecs (nextecm, ecgroup, csize);
else
@@ -1805,7 +1720,7 @@ void readin ()
/* set_up_initial_allocations - allocate memory for internal tables */
void set_up_initial_allocations ()
void set_up_initial_allocations (void)
{
maximum_mns = (long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS);
current_mns = INITIAL_MNS;
@@ -1859,31 +1774,11 @@ void set_up_initial_allocations ()
dss = allocate_int_ptr_array (current_max_dfas);
dfaacc = allocate_dfaacc_union (current_max_dfas);
nultrans = (int *) 0;
nultrans = NULL;
}
/* extracts basename from path, optionally stripping the extension "\.*"
* (same concept as /bin/sh `basename`, but different handling of extension). */
static char *basename2 (path, strip_ext)
char *path;
int strip_ext; /* boolean */
{
char *b, *e = 0;
b = path;
for (b = path; *path; path++)
if (*path == '/')
b = path + 1;
else if (*path == '.')
e = path;
if (strip_ext && e && e > b)
*e = '\0';
return b;
}
void usage ()
void usage (void)
{
FILE *f = stdout;
@@ -1941,8 +1836,6 @@ void usage ()
" --bison-bridge scanner for bison pure parser.\n"
" --bison-locations include yylloc support.\n"
" --stdinit initialize yyin/yyout to stdin/stdout\n"
" --noansi-definitions old-style function definitions\n"
" --noansi-prototypes empty parameter list in prototypes\n"
" --nounistd do not include <unistd.h>\n"
" --noFUNCTION do not generate a particular FUNCTION\n"
"\n" "Miscellaneous:\n"
+84 -229
View File
@@ -30,7 +30,6 @@
/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/* PURPOSE. */
#include "flexdef.h"
#include "tables.h"
@@ -60,14 +59,15 @@ static void sko_push(bool dc)
{
if(!sko_stack){
sko_sz = 1;
sko_stack = (struct sko_state*)flex_alloc(sizeof(struct sko_state)*sko_sz);
sko_stack = malloc(sizeof(struct sko_state) * (size_t) sko_sz);
if (!sko_stack)
flexfatal(_("allocation of sko_stack failed"));
sko_len = 0;
}
if(sko_len >= sko_sz){
sko_sz *= 2;
sko_stack = (struct sko_state*)flex_realloc(sko_stack,sizeof(struct sko_state)*sko_sz);
sko_stack = realloc(sko_stack,
sizeof(struct sko_state) * (size_t) sko_sz);
}
/* initialize to zero and push */
@@ -90,9 +90,7 @@ static void sko_pop(bool* dc)
}
/* Append "#define defname value\n" to the running buffer. */
void action_define (defname, value)
const char *defname;
int value;
void action_define (const char *defname, int value)
{
char buf[MAXLINE];
char *cpy;
@@ -108,39 +106,14 @@ void action_define (defname, value)
add_action (buf);
/* track #defines so we can undef them when we're done. */
cpy = copy_string (defname);
cpy = xstrdup(defname);
buf_append (&defs_buf, &cpy, 1);
}
#ifdef notdef
/** Append "m4_define([[defname]],[[value]])m4_dnl\n" to the running buffer.
* @param defname The macro name.
* @param value The macro value, can be NULL, which is the same as the empty string.
*/
static void action_m4_define (const char *defname, const char * value)
{
char buf[MAXLINE];
flexfatal ("DO NOT USE THIS FUNCTION!");
if ((int) strlen (defname) > MAXLINE / 2) {
format_pinpoint_message (_
("name \"%s\" ridiculously long"),
defname);
return;
}
snprintf (buf, sizeof(buf), "m4_define([[%s]],[[%s]])m4_dnl\n", defname, value?value:"");
add_action (buf);
}
#endif
/* Append "new_text" to the running buffer. */
void add_action (new_text)
const char *new_text;
void add_action (const char *new_text)
{
int len = strlen (new_text);
int len = (int) strlen (new_text);
while (len + action_index >= action_size - 10 /* slop */ ) {
int new_size = action_size * 2;
@@ -166,14 +139,17 @@ void add_action (new_text)
/* allocate_array - allocate memory for an integer array of the given size */
void *allocate_array (size, element_size)
int size;
size_t element_size;
void *allocate_array (int size, size_t element_size)
{
void *mem;
size_t num_bytes = element_size * size;
mem = flex_alloc (num_bytes);
#if HAVE_REALLOCARRAY
/* reallocarray has built-in overflow detection */
mem = reallocarray(NULL, (size_t) size, element_size);
#else
size_t num_bytes = (size_t) size * element_size;
mem = (size && SIZE_MAX / (size_t) size < element_size) ? NULL :
malloc(num_bytes);
#endif
if (!mem)
flexfatal (_
("memory allocation failed in allocate_array()"));
@@ -184,11 +160,10 @@ void *allocate_array (size, element_size)
/* all_lower - true if a string is all lower-case */
int all_lower (str)
char *str;
int all_lower (char *str)
{
while (*str) {
if (!isascii ((Char) * str) || !islower ((Char) * str))
if (!isascii ((unsigned char) * str) || !islower ((unsigned char) * str))
return 0;
++str;
}
@@ -199,11 +174,10 @@ int all_lower (str)
/* all_upper - true if a string is all upper-case */
int all_upper (str)
char *str;
int all_upper (char *str)
{
while (*str) {
if (!isascii ((Char) * str) || !isupper ((Char) * str))
if (!isascii ((unsigned char) * str) || !isupper ((unsigned char) * str))
return 0;
++str;
}
@@ -225,8 +199,7 @@ int intcmp (const void *a, const void *b)
* and exits.
*/
void check_char (c)
int c;
void check_char (int c)
{
if (c >= CSIZE)
lerr (_("bad character '%s' detected in check_char()"),
@@ -242,57 +215,20 @@ void check_char (c)
/* clower - replace upper-case letter to lower-case */
Char clower (c)
int c;
unsigned char clower (int c)
{
return (Char) ((isascii (c) && isupper (c)) ? tolower (c) : c);
return (unsigned char) ((isascii (c) && isupper (c)) ? tolower (c) : c);
}
/* copy_string - returns a dynamically allocated copy of a string */
char *copy_string (str)
const char *str;
char *xstrdup(const char *s)
{
const char *c1;
char *c2;
char *copy;
unsigned int size;
char *s2;
/* find length */
for (c1 = str; *c1; ++c1) ;
if ((s2 = strdup(s)) == NULL)
flexfatal (_("memory allocation failure in xstrdup()"));
size = (c1 - str + 1) * sizeof (char);
copy = (char *) flex_alloc (size);
if (copy == NULL)
flexfatal (_("dynamic memory failure in copy_string()"));
for (c2 = copy; (*c2++ = *str++) != 0;) ;
return copy;
}
/* copy_unsigned_string -
* returns a dynamically allocated copy of a (potentially) unsigned string
*/
Char *copy_unsigned_string (str)
Char *str;
{
Char *c;
Char *copy;
/* find length */
for (c = str; *c; ++c) ;
copy = allocate_Character_array (c - str + 1);
for (c = copy; (*c++ = *str++) != 0;) ;
return copy;
return s2;
}
@@ -300,19 +236,19 @@ Char *copy_unsigned_string (str)
int cclcmp (const void *a, const void *b)
{
if (!*(const Char *) a)
if (!*(const unsigned char *) a)
return 1;
else
if (!*(const Char *) b)
if (!*(const unsigned char *) b)
return - 1;
else
return *(const Char *) a - *(const Char *) b;
return *(const unsigned char *) a - *(const unsigned char *) b;
}
/* dataend - finish up a block of data declarations */
void dataend ()
void dataend (void)
{
/* short circuit any output */
if (gentables) {
@@ -330,7 +266,7 @@ void dataend ()
/* dataflush - flush generated data statements */
void dataflush ()
void dataflush (void)
{
/* short circuit any output */
if (!gentables)
@@ -353,8 +289,7 @@ void dataflush ()
/* flexerror - report an error message and terminate */
void flexerror (msg)
const char *msg;
void flexerror (const char *msg)
{
fprintf (stderr, "%s: %s\n", program_name, msg);
flexend (1);
@@ -363,8 +298,7 @@ void flexerror (msg)
/* flexfatal - report a fatal error message and terminate */
void flexfatal (msg)
const char *msg;
void flexfatal (const char *msg)
{
fprintf (stderr, _("%s: fatal internal error, %s\n"),
program_name, msg);
@@ -372,22 +306,10 @@ void flexfatal (msg)
}
/* htoi - convert a hexadecimal digit string to an integer value */
int htoi (str)
Char str[];
{
unsigned int result;
(void) sscanf ((char *) str, "%x", &result);
return result;
}
/* lerr - report an error message */
void lerr (const char *msg, ...) {
void lerr (const char *msg, ...)
{
char errmsg[MAXLINE];
va_list args;
@@ -414,13 +336,11 @@ void lerr_fatal (const char *msg, ...)
/* line_directive_out - spit out a "#line" statement */
void line_directive_out (output_file, do_infile)
FILE *output_file;
int do_infile;
void line_directive_out (FILE *output_file, int do_infile)
{
char directive[MAXLINE], filename[MAXLINE];
char *s1, *s2, *s3;
static const char *line_fmt = "#line %d \"%s\"\n";
static const char line_fmt[] = "#line %d \"%s\"\n";
if (!gen_line_dirs)
return;
@@ -434,8 +354,8 @@ void line_directive_out (output_file, do_infile)
s3 = &filename[sizeof (filename) - 2];
while (s2 < s3 && *s1) {
if (*s1 == '\\')
/* Escape the '\' */
if (*s1 == '\\' || *s1 == '"')
/* Escape the '\' or '"' */
*s2++ = '\\';
*s2++ = *s1++;
@@ -464,7 +384,7 @@ void line_directive_out (output_file, do_infile)
* representing where the user's section 1 definitions end
* and the prolog begins
*/
void mark_defs1 ()
void mark_defs1 (void)
{
defs1_offset = 0;
action_array[action_index++] = '\0';
@@ -476,7 +396,7 @@ void mark_defs1 ()
/* mark_prolog - mark the current position in the action array as
* representing the end of the action prolog
*/
void mark_prolog ()
void mark_prolog (void)
{
action_array[action_index++] = '\0';
action_offset = action_index;
@@ -488,8 +408,7 @@ void mark_prolog ()
*
* Generates a data statement initializing the current 2-D array to "value".
*/
void mk2data (value)
int value;
void mk2data (int value)
{
/* short circuit any output */
if (!gentables)
@@ -518,8 +437,7 @@ void mk2data (value)
* Generates a data statement initializing the current array element to
* "value".
*/
void mkdata (value)
int value;
void mkdata (int value)
{
/* short circuit any output */
if (!gentables)
@@ -544,8 +462,7 @@ void mkdata (value)
/* myctoi - return the integer represented by a string of digits */
int myctoi (array)
const char *array;
int myctoi (const char *array)
{
int val = 0;
@@ -557,10 +474,9 @@ int myctoi (array)
/* myesc - return character corresponding to escape sequence */
Char myesc (array)
Char array[];
unsigned char myesc (unsigned char array[])
{
Char c, esc_char;
unsigned char c, esc_char;
switch (array[1]) {
case 'b':
@@ -573,19 +489,10 @@ Char myesc (array)
return '\r';
case 't':
return '\t';
#if defined (__STDC__)
case 'a':
return '\a';
case 'v':
return '\v';
#else
case 'a':
return '\007';
case 'v':
return '\013';
#endif
case '0':
case '1':
case '2':
@@ -597,18 +504,15 @@ Char myesc (array)
{ /* \<octal> */
int sptr = 1;
while (isascii (array[sptr]) &&
isdigit (array[sptr]))
/* Don't increment inside loop control
* because if isdigit() is a macro it might
* expand into multiple increments ...
*/
while (sptr <= 3 &&
array[sptr] >= '0' && array[sptr] <= '7') {
++sptr;
}
c = array[sptr];
array[sptr] = '\0';
esc_char = otoi (array + 1);
esc_char = (unsigned char) strtoul (array + 1, NULL, 8);
array[sptr] = c;
@@ -619,18 +523,18 @@ Char myesc (array)
{ /* \x<hex> */
int sptr = 2;
while (isascii (array[sptr]) &&
isxdigit (array[sptr]))
while (sptr <= 3 && isxdigit (array[sptr])) {
/* Don't increment inside loop control
* because if isdigit() is a macro it might
* because if isxdigit() is a macro it might
* expand into multiple increments ...
*/
++sptr;
}
c = array[sptr];
array[sptr] = '\0';
esc_char = htoi (array + 2);
esc_char = (unsigned char) strtoul (array + 2, NULL, 16);
array[sptr] = c;
@@ -643,76 +547,51 @@ Char myesc (array)
}
/* otoi - convert an octal digit string to an integer value */
int otoi (str)
Char str[];
{
unsigned int result;
(void) sscanf ((char *) str, "%o", &result);
return result;
}
/* out - various flavors of outputing a (possibly formatted) string for the
* generated scanner, keeping track of the line count.
*/
void out (str)
const char *str;
void out (const char *str)
{
fputs (str, stdout);
}
void out_dec (fmt, n)
const char *fmt;
int n;
void out_dec (const char *fmt, int n)
{
fprintf (stdout, fmt, n);
}
void out_dec2 (fmt, n1, n2)
const char *fmt;
int n1, n2;
void out_dec2 (const char *fmt, int n1, int n2)
{
fprintf (stdout, fmt, n1, n2);
}
void out_hex (fmt, x)
const char *fmt;
unsigned int x;
void out_hex (const char *fmt, unsigned int x)
{
fprintf (stdout, fmt, x);
}
void out_str (fmt, str)
const char *fmt, str[];
void out_str (const char *fmt, const char str[])
{
fprintf (stdout,fmt, str);
}
void out_str3 (fmt, s1, s2, s3)
const char *fmt, s1[], s2[], s3[];
void out_str3 (const char *fmt, const char s1[], const char s2[], const char s3[])
{
fprintf (stdout,fmt, s1, s2, s3);
}
void out_str_dec (fmt, str, n)
const char *fmt, str[];
int n;
void out_str_dec (const char *fmt, const char str[], int n)
{
fprintf (stdout,fmt, str, n);
}
void outc (c)
int c;
void outc (int c)
{
fputc (c, stdout);
}
void outn (str)
const char *str;
void outn (const char *str)
{
fputs (str,stdout);
fputc('\n',stdout);
@@ -734,8 +613,7 @@ void out_m4_define (const char* def, const char* val)
* The returned string is in static storage.
*/
char *readable_form (c)
int c;
char *readable_form (int c)
{
static char rform[20];
@@ -751,14 +629,10 @@ char *readable_form (c)
return "\\r";
case '\t':
return "\\t";
#if defined (__STDC__)
case '\a':
return "\\a";
case '\v':
return "\\v";
#endif
default:
if(trace_hex)
snprintf (rform, sizeof(rform), "\\x%.2x", (unsigned int) c);
@@ -772,7 +646,7 @@ char *readable_form (c)
return "' '";
else {
rform[0] = c;
rform[0] = (char) c;
rform[1] = '\0';
return rform;
@@ -782,15 +656,17 @@ char *readable_form (c)
/* reallocate_array - increase the size of a dynamic array */
void *reallocate_array (array, size, element_size)
void *array;
int size;
size_t element_size;
void *reallocate_array (void *array, int size, size_t element_size)
{
void *new_array;
size_t num_bytes = element_size * size;
new_array = flex_realloc (array, num_bytes);
#if HAVE_REALLOCARRAY
/* reallocarray has built-in overflow detection */
new_array = reallocarray(array, (size_t) size, element_size);
#else
size_t num_bytes = (size_t) size * element_size;
new_array = (size && SIZE_MAX / (size_t) size < element_size) ? NULL :
realloc(array, num_bytes);
#endif
if (!new_array)
flexfatal (_("attempt to increase array size failed"));
@@ -804,7 +680,7 @@ void *reallocate_array (array, size, element_size)
* Copies skelfile or skel array to stdout until a line beginning with
* "%%" or EOF is found.
*/
void skelout ()
void skelout (void)
{
char buf_storage[MAXLINE];
char *buf = buf_storage;
@@ -915,9 +791,6 @@ void skelout ()
/* %e end linkage-only code. */
OUT_END_CODE ();
}
else if (buf[1] == '#') {
/* %# a comment in the skel. ignore. */
}
else {
flexfatal (_("bad line in skeleton file"));
}
@@ -935,8 +808,7 @@ void skelout ()
* element_n. Formats the output with spaces and carriage returns.
*/
void transition_struct_out (element_v, element_n)
int element_v, element_n;
void transition_struct_out (int element_v, int element_n)
{
/* short circuit any output */
@@ -960,12 +832,14 @@ void transition_struct_out (element_v, element_n)
/* The following is only needed when building flex's parser using certain
* broken versions of bison.
*
* XXX: this is should go soon
*/
void *yy_flex_xmalloc (size)
int size;
void *yy_flex_xmalloc (int size)
{
void *result = flex_alloc ((size_t) size);
void *result;
result = malloc((size_t) size);
if (!result)
flexfatal (_
("memory allocation failed in yy_flex_xmalloc()"));
@@ -974,29 +848,10 @@ void *yy_flex_xmalloc (size)
}
/* zero_out - set a region of memory to 0
*
* Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
*/
void zero_out (region_ptr, size_in_bytes)
char *region_ptr;
size_t size_in_bytes;
{
char *rp, *rp_end;
rp = region_ptr;
rp_end = region_ptr + size_in_bytes;
while (rp < rp_end)
*rp++ = 0;
}
/* Remove all '\n' and '\r' characters, if any, from the end of str.
* str can be any null-terminated string, or NULL.
* returns str. */
char *chomp (str)
char *str;
char *chomp (char *str)
{
char *p = str;
+27 -10
View File
@@ -21,17 +21,34 @@
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE.
cat <<!
/* File created from flex.skl via mkskel.sh */
if test ! $# = 3; then
echo 'Usage: mkskel.sh srcdir m4 version' >&2
exit 1
fi
echo '/* File created from flex.skl via mkskel.sh */
#include "flexdef.h"
const char *skel[] = {
!
const char *skel[] = {'
srcdir=$1
m4=$2
VERSION=$3
case $VERSION in
*[!0-9.]*) echo 'Invalid version number' >&2; exit 1;;
esac
IFS=.
set $VERSION
sed 's/4_/a4_/g
s/m4preproc_/m4_/g
' "$srcdir/flex.skl" |
"$m4" -P -I "$srcdir" "-DFLEX_MAJOR_VERSION=$1" \
"-DFLEX_MINOR_VERSION=$2" \
"-DFLEX_SUBMINOR_VERSION=$3" |
sed '/^%#/d
s/m4_/m4preproc_/g
s/a4_/4_/g
s/[\\"]/\\&/g
s/.*/ "&",/'
sed 's/\\/&&/g' | sed 's/"/\\"/g' | sed 's/.*/ "&",/'
cat <<!
0
};
!
echo ' 0
};'
+21 -36
View File
@@ -36,8 +36,8 @@
/* declare functions that have forward references */
int dupmachine PROTO ((int));
void mkxtion PROTO ((int, int));
int dupmachine(int);
void mkxtion(int, int);
/* add_accept - add an accepting state to a machine
@@ -45,8 +45,7 @@ void mkxtion PROTO ((int, int));
* accepting_number becomes mach's accepting number.
*/
void add_accept (mach, accepting_number)
int mach, accepting_number;
void add_accept (int mach, int accepting_number)
{
/* Hang the accepting number off an epsilon state. if it is associated
* with a state that has a non-epsilon out-transition, then the state
@@ -77,8 +76,7 @@ void add_accept (mach, accepting_number)
* num - the number of copies of singl to be present in newsng
*/
int copysingl (singl, num)
int singl, num;
int copysingl (int singl, int num)
{
int copy, i;
@@ -93,9 +91,7 @@ int copysingl (singl, num)
/* dumpnfa - debugging routine to write out an nfa */
void dumpnfa (state1)
int state1;
void dumpnfa (int state1)
{
int sym, tsp1, tsp2, anum, ns;
@@ -148,8 +144,7 @@ void dumpnfa (state1)
* states accessible by the arrays firstst and lastst
*/
int dupmachine (mach)
int mach;
int dupmachine (int mach)
{
int i, init, state_offset;
int state = 0;
@@ -196,9 +191,8 @@ int dupmachine (mach)
* context has variable length.
*/
void finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
pcont_act)
int mach, variable_trail_rule, headcnt, trailcnt, pcont_act;
void finish_rule (int mach, int variable_trail_rule, int headcnt, int trailcnt,
int pcont_act)
{
char action_text[MAXLINE];
@@ -292,7 +286,8 @@ void finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
if (!continued_action)
add_action ("YY_RULE_SETUP\n");
line_directive_out ((FILE *) 0, 1);
line_directive_out(NULL, 1);
add_action("[[");
}
@@ -312,8 +307,7 @@ void finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
* FIRST is set to new by the operation. last is unmolested.
*/
int link_machines (first, last)
int first, last;
int link_machines (int first, int last)
{
if (first == NIL)
return last;
@@ -339,8 +333,7 @@ int link_machines (first, last)
* The "beginning" states are the epsilon closure of the first state
*/
void mark_beginning_as_normal (mach)
int mach;
void mark_beginning_as_normal (int mach)
{
switch (state_type[mach]) {
case STATE_NORMAL:
@@ -381,8 +374,7 @@ void mark_beginning_as_normal (mach)
* more mkbranch's. Compare with mkor()
*/
int mkbranch (first, second)
int first, second;
int mkbranch (int first, int second)
{
int eps;
@@ -409,8 +401,7 @@ int mkbranch (first, second)
* new - a new state which matches the closure of "state"
*/
int mkclos (state)
int state;
int mkclos (int state)
{
return mkopt (mkposcl (state));
}
@@ -430,8 +421,7 @@ int mkclos (state)
* 2. mach is destroyed by the call
*/
int mkopt (mach)
int mach;
int mkopt (int mach)
{
int eps;
@@ -467,8 +457,7 @@ int mkopt (mach)
* the number of epsilon states needed
*/
int mkor (first, second)
int first, second;
int mkor (int first, int second)
{
int eps, orend;
@@ -523,8 +512,7 @@ int mkor (first, second)
* new - a machine matching the positive closure of "state"
*/
int mkposcl (state)
int state;
int mkposcl (int state)
{
int eps;
@@ -553,8 +541,7 @@ int mkposcl (state)
* if "ub" is INFINITE_REPEAT then "new" matches "lb" or more occurrences of "mach"
*/
int mkrep (mach, lb, ub)
int mach, lb, ub;
int mkrep (int mach, int lb, int ub)
{
int base_mach, tail, copy, i;
@@ -600,8 +587,7 @@ int mkrep (mach, lb, ub)
* that it admittedly is)
*/
int mkstate (sym)
int sym;
int mkstate (int sym)
{
if (++lastnfa >= current_mns) {
if ((current_mns += MNS_INCREMENT) >= maximum_mns)
@@ -677,8 +663,7 @@ current_mns);
* stateto - the state to which the transition is to be made
*/
void mkxtion (statefrom, stateto)
int statefrom, stateto;
void mkxtion (int statefrom, int stateto)
{
if (trans1[statefrom] == NO_TRANSITION)
trans1[statefrom] = stateto;
@@ -695,7 +680,7 @@ void mkxtion (statefrom, stateto)
/* new_rule - initialize for a new rule */
void new_rule ()
void new_rule (void)
{
if (++num_rules >= current_max_rules) {
++num_reallocs;
+2 -5
View File
@@ -213,10 +213,6 @@ optspec_t flexopts[] = {
,
{"--nowarn", OPT_NO_WARN, 0}
, /* Suppress warning messages. */
{"--noansi-definitions", OPT_NO_ANSI_FUNC_DEFS, 0}
,
{"--noansi-prototypes", OPT_NO_ANSI_FUNC_PROTOS, 0}
,
{"--yyclass=NAME", OPT_YYCLASS, 0}
,
{"--yylineno", OPT_YYLINENO, 0}
@@ -275,7 +271,8 @@ optspec_t flexopts[] = {
,
{"--noyyset_lloc", OPT_NO_YYSET_LLOC, 0}
,
{"--unsafe-no-m4-sect3-escape", OPT_NO_SECT3_ESCAPE, 0}
,
{0, 0, 0} /* required final NULL entry. */
};
+2 -3
View File
@@ -68,8 +68,6 @@ enum flexopt_flag_t {
OPT_META_ECS,
OPT_NEVER_INTERACTIVE,
OPT_NO_ALIGN,
OPT_NO_ANSI_FUNC_DEFS,
OPT_NO_ANSI_FUNC_PROTOS,
OPT_NO_DEBUG,
OPT_NO_DEFAULT,
OPT_NO_ECS,
@@ -127,7 +125,8 @@ enum flexopt_flag_t {
OPT_YYCLASS,
OPT_YYLINENO,
OPT_YYMORE,
OPT_YYWRAP
OPT_YYWRAP,
OPT_NO_SECT3_ESCAPE,
};
#endif
+39 -51
View File
@@ -1,8 +1,8 @@
/* parse.y - parser for flex input */
%token CHAR NUMBER SECTEND SCDECL XSCDECL NAME PREVCCL EOF_OP
%token OPTION_OP OPT_OUTFILE OPT_PREFIX OPT_YYCLASS OPT_HEADER OPT_HEADER_CHAR
%token OPT_EXTRA_TYPE OPT_TABLES OPT_CHARSET_SOURCE
%token TOK_OPTION TOK_OUTFILE TOK_PREFIX TOK_YYCLASS TOK_HEADER_FILE TOK_EXTRA_TYPE
%token TOK_TABLES_FILE
%token CCE_ALNUM CCE_ALPHA CCE_BLANK CCE_CNTRL CCE_DIGIT CCE_GRAPH
%token CCE_LOWER CCE_PRINT CCE_PUNCT CCE_SPACE CCE_UPPER CCE_XDIGIT
@@ -80,7 +80,7 @@ int previous_continued_action; /* whether the previous rule's action was '|' */
do{ \
char fw3_msg[MAXLINE];\
snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
warn( fw3_msg );\
lwarn( fw3_msg );\
}while(0)
/* Expand a POSIX character class expression. */
@@ -140,7 +140,7 @@ goal : initlex sect1 sect1end sect2 initforrule
else
add_action( "ECHO" );
add_action( ";\n\tYY_BREAK\n" );
add_action( ";\n\tYY_BREAK]]\n" );
}
;
@@ -184,32 +184,30 @@ namelist1 : namelist1 NAME
{ synerr( _("bad start condition list") ); }
;
options : OPTION_OP optionlist
options : TOK_OPTION optionlist
;
optionlist : optionlist option
|
;
option : OPT_OUTFILE '=' NAME
option : TOK_OUTFILE '=' NAME
{
outfilename = copy_string( nmstr );
outfilename = xstrdup(nmstr);
did_outfilename = 1;
}
| OPT_EXTRA_TYPE '=' NAME
{ extra_type = copy_string( nmstr ); }
| OPT_PREFIX '=' NAME
{ prefix = copy_string( nmstr ); }
| OPT_YYCLASS '=' NAME
{ yyclass = copy_string( nmstr ); }
| OPT_HEADER '=' NAME
{ headerfilename = copy_string( nmstr ); }
| OPT_HEADER_CHAR '=' NAME
{ headercharfilename = copy_string( nmstr ); }
| OPT_TABLES '=' NAME
{ tablesext = true; tablesfilename = copy_string( nmstr ); }
| OPT_CHARSET_SOURCE '=' NAME
{ charset_source = copy_string(nmstr); }
| TOK_EXTRA_TYPE '=' NAME
{ extra_type = xstrdup(nmstr); }
| TOK_PREFIX '=' NAME
{ prefix = xstrdup(nmstr);
if (strchr(prefix, '[') || strchr(prefix, ']'))
flexerror(_("Prefix must not contain [ or ]")); }
| TOK_YYCLASS '=' NAME
{ yyclass = xstrdup(nmstr); }
| TOK_HEADER_FILE '=' NAME
{ headerfilename = xstrdup(nmstr); }
| TOK_TABLES_FILE '=' NAME
{ tablesext = true; tablesfilename = xstrdup(nmstr); }
;
sect2 : sect2 scon initforrule flexrule '\n'
@@ -307,7 +305,7 @@ flexrule : '^' rule
scon_stk[++scon_stk_ptr] = i;
if ( scon_stk_ptr == 0 )
warn(
lwarn(
"all start conditions already have <<EOF>> rules" );
else
@@ -402,7 +400,7 @@ rule : re2 re
* erroneously.
*/
if ( ! varlength || headcnt != 0 )
warn(
lwarn(
"trailing context made variable due to preceding '|' action" );
/* Mark as variable. */
@@ -457,7 +455,7 @@ rule : re2 re
/* See the comment in the rule for "re2 re"
* above.
*/
warn(
lwarn(
"trailing context made variable due to preceding '|' action" );
varlength = true;
@@ -729,7 +727,7 @@ singleton : singleton '*'
{
/* Sort characters for fast searching.
*/
qsort( ccltbl + cclmap[$1], ccllen[$1], sizeof (*ccltbl), cclcmp );
qsort( ccltbl + cclmap[$1], (size_t) ccllen[$1], sizeof (*ccltbl), cclcmp );
if ( useecs )
mkeccl( ccltbl + cclmap[$1], ccllen[$1],
@@ -917,13 +915,13 @@ ccl_expr:
| CCE_NEG_XDIGIT { CCL_NEG_EXPR(isxdigit); }
| CCE_NEG_LOWER {
if ( sf_case_ins() )
warn(_("[:^lower:] is ambiguous in case insensitive scanner"));
lwarn(_("[:^lower:] is ambiguous in case insensitive scanner"));
else
CCL_NEG_EXPR(islower);
}
| CCE_NEG_UPPER {
if ( sf_case_ins() )
warn(_("[:^upper:] ambiguous in case insensitive scanner"));
lwarn(_("[:^upper:] ambiguous in case insensitive scanner"));
else
CCL_NEG_EXPR(isupper);
}
@@ -955,7 +953,7 @@ string : string CHAR
* conditions
*/
void build_eof_action()
void build_eof_action(void)
{
int i;
char action_text[MAXLINE];
@@ -980,7 +978,8 @@ void build_eof_action()
}
}
line_directive_out( (FILE *) 0, 1 );
line_directive_out(NULL, 1);
add_action("[[");
/* This isn't a normal rule after all - don't count it as
* such, so we don't have any holes in the rule numbering
@@ -994,8 +993,7 @@ void build_eof_action()
/* format_synerr - write out formatted syntax error */
void format_synerr( msg, arg )
const char *msg, arg[];
void format_synerr( const char *msg, const char arg[] )
{
char errmsg[MAXLINE];
@@ -1006,8 +1004,7 @@ const char *msg, arg[];
/* synerr - report a syntax error */
void synerr( str )
const char *str;
void synerr( const char *str )
{
syntaxerror = true;
pinpoint_message( str );
@@ -1016,20 +1013,18 @@ const char *str;
/* format_warn - write out formatted warning */
void format_warn( msg, arg )
const char *msg, arg[];
void format_warn( const char *msg, const char arg[] )
{
char warn_msg[MAXLINE];
snprintf( warn_msg, sizeof(warn_msg), msg, arg );
warn( warn_msg );
lwarn( warn_msg );
}
/* warn - report a warning, unless -w was given */
/* lwarn - report a warning, unless -w was given */
void warn( str )
const char *str;
void lwarn( const char *str )
{
line_warning( str, linenum );
}
@@ -1038,8 +1033,7 @@ const char *str;
* pinpointing its location
*/
void format_pinpoint_message( msg, arg )
const char *msg, arg[];
void format_pinpoint_message( const char *msg, const char arg[] )
{
char errmsg[MAXLINE];
@@ -1050,8 +1044,7 @@ const char *msg, arg[];
/* pinpoint_message - write out a message, pinpointing its location */
void pinpoint_message( str )
const char *str;
void pinpoint_message( const char *str )
{
line_pinpoint( str, linenum );
}
@@ -1059,9 +1052,7 @@ const char *str;
/* line_warning - report a warning at a given line, unless -w was given */
void line_warning( str, line )
const char *str;
int line;
void line_warning( const char *str, int line )
{
char warning[MAXLINE];
@@ -1075,9 +1066,7 @@ int line;
/* line_pinpoint - write out a message, pinpointing it at the given line */
void line_pinpoint( str, line )
const char *str;
int line;
void line_pinpoint( const char *str, int line )
{
fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
}
@@ -1087,8 +1076,7 @@ int line;
* currently, messages are ignore
*/
void yyerror( msg )
const char *msg;
void yyerror( const char *msg )
{
(void)msg;
}
+13 -17
View File
@@ -54,21 +54,17 @@ void flex_regcomp(regex_t *preg, const char *regex, int cflags)
memset (preg, 0, sizeof (regex_t));
if ((err = regcomp (preg, regex, cflags)) != 0) {
const int errbuf_sz = 200;
char *errbuf, *rxerr;
const size_t errbuf_sz = 200;
char *errbuf;
int n;
errbuf = (char*)flex_alloc(errbuf_sz *sizeof(char));
errbuf = malloc(errbuf_sz * sizeof(char));
if (!errbuf)
flexfatal(_("Unable to allocate buffer to report regcomp"));
rxerr = (char*)flex_alloc(errbuf_sz *sizeof(char));
if (!rxerr)
flexfatal(_("Unable to allocate buffer for regerror"));
regerror (err, preg, rxerr, errbuf_sz);
snprintf (errbuf, errbuf_sz, "regcomp for \"%s\" failed: %s", regex, rxerr);
n = snprintf(errbuf, errbuf_sz, "regcomp for \"%s\" failed: ", regex);
regerror(err, preg, errbuf+n, errbuf_sz-(size_t)n);
flexfatal (errbuf);
free(errbuf);
free(rxerr);
flexfatal (errbuf); /* never returns - no need to free(errbuf) */
}
}
@@ -80,12 +76,12 @@ void flex_regcomp(regex_t *preg, const char *regex, int cflags)
char *regmatch_dup (regmatch_t * m, const char *src)
{
char *str;
int len;
size_t len;
if (m == NULL || m->rm_so < 0)
if (m == NULL || m->rm_so < 0 || m->rm_eo < m->rm_so)
return NULL;
len = m->rm_eo - m->rm_so;
str = (char *) flex_alloc ((len + 1) * sizeof (char));
len = (size_t) (m->rm_eo - m->rm_so);
str = malloc((len + 1) * sizeof(char));
if (!str)
flexfatal(_("Unable to allocate a copy of the match"));
strncpy (str, src + m->rm_so, len);
@@ -107,7 +103,7 @@ char *regmatch_cpy (regmatch_t * m, char *dest, const char *src)
return dest;
}
snprintf (dest, regmatch_len(m), "%s", src + m->rm_so);
snprintf (dest, (size_t) regmatch_len(m), "%s", src + m->rm_so);
return dest;
}
@@ -150,7 +146,7 @@ int regmatch_strtol (regmatch_t * m, const char *src, char **endptr,
else
s = regmatch_dup (m, src);
n = strtol (s, endptr, base);
n = (int) strtol (s, endptr, base);
if (s != buf)
free (s);
+190 -174
View File
@@ -38,6 +38,12 @@ extern bool tablesverify, tablesext;
extern int trlcontxt; /* Set in parse.y for each rule. */
extern const char *escaped_qstart, *escaped_qend;
#define M4QSTART "[""["
#define M4QEND "]""]"
#define ESCAPED_QSTART "[" M4QEND M4QSTART "[" M4QEND M4QSTART
#define ESCAPED_QEND M4QEND "]" M4QSTART M4QEND "]" M4QSTART
#define ACTION_ECHO add_action( yytext )
#define ACTION_IFDEF(def, should_define) \
{ \
@@ -45,8 +51,8 @@ extern const char *escaped_qstart, *escaped_qend;
action_define( def, 1 ); \
}
#define ACTION_ECHO_QSTART add_action (escaped_qstart)
#define ACTION_ECHO_QEND add_action (escaped_qend)
#define ACTION_ECHO_QSTART add_action (ESCAPED_QSTART)
#define ACTION_ECHO_QEND add_action (ESCAPED_QEND)
#define ACTION_M4_IFDEF(def, should_define) \
do{ \
@@ -59,7 +65,7 @@ extern const char *escaped_qstart, *escaped_qend;
#define MARK_END_OF_PROLOG mark_prolog();
#define YY_DECL \
int flexscan()
int flexscan(void)
#define RETURNCHAR \
yylval = (unsigned char) yytext[0]; \
@@ -68,18 +74,20 @@ extern const char *escaped_qstart, *escaped_qend;
#define RETURNNAME \
if(yyleng < MAXLINE) \
{ \
strcpy( nmstr, yytext ); \
strncpy( nmstr, yytext, sizeof(nmstr) ); \
return NAME; \
} \
else \
{ \
do { \
synerr(_("Input line too long\n")); \
FLEX_EXIT(EXIT_FAILURE); \
} \
return NAME;
} while (0)
#define PUT_BACK_STRING(str, start) \
for ( i = strlen( str ) - 1; i >= start; --i ) \
unput((str)[i])
{ size_t i = strlen( str ); \
while ( i > start ) \
unput((str)[--i]); \
}
#define CHECK_REJECT(str) \
if ( all_upper( str ) ) \
@@ -93,6 +101,23 @@ extern const char *escaped_qstart, *escaped_qend;
if ( getenv("POSIXLY_CORRECT") ) \
posix_compat = true;
#define START_CODEBLOCK(x) do { \
/* Emit the needed line directive... */\
if (indented_code == false) { \
linenum++; \
line_directive_out(NULL, 1); \
} \
add_action(M4QSTART); \
yy_push_state(CODEBLOCK); \
if ((indented_code = x)) ACTION_ECHO; \
} while(0)
#define END_CODEBLOCK do { \
yy_pop_state();\
add_action(M4QEND); \
if (!indented_code) line_directive_out(NULL, 0);\
} while (0)
%}
%option caseless nodefault noreject stack noyy_top_state
@@ -104,7 +129,9 @@ extern const char *escaped_qstart, *escaped_qend;
%x GROUP_WITH_PARAMS
%x GROUP_MINUS_PARAMS
%x EXTENDED_COMMENT
%x COMMENT_DISCARD
%x COMMENT_DISCARD CODE_COMMENT
%x SECT3_NOESCAPE
%x CHARACTER_CONSTANT
WS [[:blank:]]+
OPTWS [[:blank:]]*
@@ -125,8 +152,8 @@ CCL_EXPR ("[:"^?[[:alpha:]]+":]")
LEXOPT [aceknopr]
M4QSTART "[["
M4QEND "]]"
M4QSTART "[""["
M4QEND "]""]"
%%
static int bracelevel, didadef, indented_code;
@@ -134,22 +161,17 @@ M4QEND "]]"
static int option_sense;
int doing_codeblock = false;
int i, brace_depth=0, brace_start_line=0;
Char nmdef[MAXLINE];
int brace_depth=0, brace_start_line=0;
char nmdef[MAXLINE];
<INITIAL>{
^{WS} indented_code = true; BEGIN(CODEBLOCK);
^"/*" ACTION_ECHO; yy_push_state( COMMENT );
^{WS} START_CODEBLOCK(true);
^"/*" add_action("/*[""["); yy_push_state( COMMENT );
^#{OPTWS}line{WS} yy_push_state( LINEDIR );
^"%s"{NAME}? return SCDECL;
^"%x"{NAME}? return XSCDECL;
^"%{".*{NL} {
++linenum;
line_directive_out( (FILE *) 0, 1 );
indented_code = false;
BEGIN(CODEBLOCK);
}
^"%{".*{NL} START_CODEBLOCK(false);
^"%top"[[:blank:]]*"{"[[:blank:]]*{NL} {
brace_start_line = linenum;
++linenum;
@@ -166,7 +188,7 @@ M4QEND "]]"
sectnum = 2;
bracelevel = 0;
mark_defs1();
line_directive_out( (FILE *) 0, 1 );
line_directive_out(NULL, 1);
BEGIN(SECT2PROLOG);
return SECTEND;
}
@@ -174,7 +196,7 @@ M4QEND "]]"
^"%pointer".*{NL} yytext_is_array = false; ++linenum;
^"%array".*{NL} yytext_is_array = true; ++linenum;
^"%option" BEGIN(OPTION); return OPTION_OP;
^"%option" BEGIN(OPTION); return TOK_OPTION;
^"%"{LEXOPT}{OPTWS}[[:digit:]]*{OPTWS}{NL} ++linenum; /* ignore */
^"%"{LEXOPT}{WS}.*{NL} ++linenum; /* ignore */
@@ -185,7 +207,7 @@ M4QEND "]]"
^{NAME} {
if(yyleng < MAXLINE)
{
strcpy( nmstr, yytext );
strncpy( nmstr, yytext, sizeof(nmstr) );
}
else
{
@@ -203,14 +225,18 @@ M4QEND "]]"
}
<COMMENT>{
"*/" ACTION_ECHO; yy_pop_state();
"*" ACTION_ECHO;
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
[^*\n] ACTION_ECHO;
<COMMENT,CODE_COMMENT>{ /* */
[^\[\]\*\n]* ACTION_ECHO;
. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO;
}
<COMMENT>{
"*/" add_action("*/]""]"); yy_pop_state();
}
<CODE_COMMENT>{
"*/" ACTION_ECHO; yy_pop_state();
}
<COMMENT_DISCARD>{
/* This is the same as COMMENT, but is discarded rather than output. */
@@ -223,7 +249,7 @@ M4QEND "]]"
<EXTENDED_COMMENT>{
")" yy_pop_state();
[^\n\)]+ ;
{NL} ++linenum;
{NL} ++linenum;
}
<LINEDIR>{
@@ -231,25 +257,25 @@ M4QEND "]]"
[[:digit:]]+ linenum = myctoi( yytext );
\"[^"\n]*\" {
flex_free( (void *) infilename );
infilename = copy_string( yytext + 1 );
free(infilename);
infilename = xstrdup(yytext + 1);
infilename[strlen( infilename ) - 1] = '\0';
}
. /* ignore spurious characters */
}
<ACTION,CODEBLOCK,ACTION_STRING,PERCENT_BRACE_ACTION,CHARACTER_CONSTANT,COMMENT,CODE_COMMENT>{
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
}
<CODEBLOCK>{
^"%}".*{NL} ++linenum; BEGIN(INITIAL);
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
. ACTION_ECHO;
^"%}".*{NL} ++linenum; END_CODEBLOCK;
[^\n%\[\]]* ACTION_ECHO;
. ACTION_ECHO;
{NL} {
++linenum;
ACTION_ECHO;
if ( indented_code )
BEGIN(INITIAL);
if ( indented_code ) END_CODEBLOCK;
}
}
@@ -272,12 +298,11 @@ M4QEND "]]"
buf_strnappend(&top_buf, yytext, yyleng);
}
{M4QSTART} buf_strnappend(&top_buf, escaped_qstart, strlen(escaped_qstart));
{M4QEND} buf_strnappend(&top_buf, escaped_qend, strlen(escaped_qend));
[^{}\r\n] {
buf_strnappend(&top_buf, yytext, yyleng);
}
{M4QSTART} buf_strnappend(&top_buf, escaped_qstart, (int) strlen(escaped_qstart));
{M4QEND} buf_strnappend(&top_buf, escaped_qend, (int) strlen(escaped_qend));
([^{}\r\n\[\]]+)|[^{}\r\n] {
buf_strnappend(&top_buf, yytext, yyleng);
}
<<EOF>> {
linenum = brace_start_line;
@@ -293,7 +318,7 @@ M4QEND "]]"
{NOT_WS}[^\r\n]* {
if(yyleng < MAXLINE)
{
strcpy( (char *) nmdef, yytext );
strncpy( nmdef, yytext, sizeof(nmdef) );
}
else
{
@@ -301,12 +326,12 @@ M4QEND "]]"
FLEX_EXIT(EXIT_FAILURE);
}
/* Skip trailing whitespace. */
for ( i = strlen( (char *) nmdef ) - 1;
i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
--i )
;
nmdef[i + 1] = '\0';
{
size_t i = strlen( nmdef );
while (i > 0 && (nmdef[i-1] == ' ' || nmdef[i-1] == '\t'))
--i;
nmdef[i] = '\0';
}
ndinstal( nmstr, nmdef );
didadef = true;
@@ -338,8 +363,6 @@ M4QEND "]]"
interactive = option_sense;
}
array yytext_is_array = option_sense;
ansi-definitions ansi_func_defs = option_sense;
ansi-prototypes ansi_func_protos = option_sense;
backup backing_up_report = option_sense;
batch interactive = ! option_sense;
bison-bridge bison_bridge_lval = option_sense;
@@ -349,7 +372,6 @@ M4QEND "]]"
"c++" C_plus_plus = option_sense;
caseful|case-sensitive sf_set_case_ins(!option_sense);
caseless|case-insensitive sf_set_case_ins(option_sense);
charset charset_enabled = true;
debug ddebug = option_sense;
default spprdflt = ! option_sense;
ecs useecs = option_sense;
@@ -365,6 +387,7 @@ M4QEND "]]"
interactive interactive = option_sense;
lex-compat lex_compat = option_sense;
posix-compat posix_compat = option_sense;
line gen_line_dirs = option_sense;
main {
ACTION_M4_IFDEF( "M4""_YY_MAIN", option_sense);
/* Override yywrap */
@@ -421,14 +444,12 @@ M4QEND "]]"
yyget_lloc ACTION_M4_IFDEF("M4""_YY_NO_GET_LLOC", ! option_sense);
yyset_lloc ACTION_M4_IFDEF("M4""_YY_NO_SET_LLOC", ! option_sense);
extra-type return OPT_EXTRA_TYPE;
outfile return OPT_OUTFILE;
prefix return OPT_PREFIX;
yyclass return OPT_YYCLASS;
header(-file)? return OPT_HEADER;
header-char(-file)? return OPT_HEADER_CHAR;
tables-file return OPT_TABLES;
charset-source return OPT_CHARSET_SOURCE;
extra-type return TOK_EXTRA_TYPE;
outfile return TOK_OUTFILE;
prefix return TOK_PREFIX;
yyclass return TOK_YYCLASS;
header(-file)? return TOK_HEADER_FILE;
tables-file return TOK_TABLES_FILE;
tables-verify {
tablesverify = option_sense;
if(!tablesext && option_sense)
@@ -439,7 +460,7 @@ M4QEND "]]"
\"[^"\n]*\" {
if(yyleng-1 < MAXLINE)
{
strcpy( nmstr, yytext + 1 );
strncpy( nmstr, yytext + 1, sizeof(nmstr) );
}
else
{
@@ -464,19 +485,20 @@ M4QEND "]]"
^"%{".* ++bracelevel; yyless( 2 ); /* eat only %{ */
^"%}".* --bracelevel; yyless( 2 ); /* eat only %} */
^{WS}.* ACTION_ECHO; /* indented code in prolog */
^{WS} START_CODEBLOCK(true); /* indented code in prolog */
^{NOT_WS}.* { /* non-indented code */
if ( bracelevel <= 0 )
{ /* not in %{ ... %} */
yyless( 0 ); /* put it all back */
yy_set_bol( 1 );
mark_prolog();
BEGIN(SECT2);
}
else
ACTION_ECHO;
}
^{NOT_WS}.* {
/* non-indented code */
if ( bracelevel <= 0 ) {
/* not in %{ ... %} */
yyless( 0 ); /* put it all back */
yy_set_bol( 1 );
mark_prolog();
BEGIN(SECT2);
} else {
START_CODEBLOCK(true);
}
}
. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO;
@@ -530,11 +552,11 @@ M4QEND "]]"
if (sf_skip_ws()){
/* We're in the middle of a (?x: ) pattern. */
/* Push back everything starting at the "|" */
size_t amt;
amt = strchr (yytext, '|') - yytext;
int amt = (int) (strchr (yytext, '|') - yytext);
yyless(amt);
}
else {
add_action("]""]");
continued_action = true;
++linenum;
return '\n';
@@ -604,9 +626,10 @@ M4QEND "]]"
^"%%".* {
sectnum = 3;
BEGIN(SECT3);
BEGIN(no_section3_escape ? SECT3_NOESCAPE : SECT3);
outn("/* Begin user sect3 */");
yyterminate(); /* to stop the parser */
}
"["({FIRST_CCL_CHAR}|{CCL_EXPR})({CCL_CHAR}|{CCL_EXPR})* {
@@ -614,7 +637,7 @@ M4QEND "]]"
if(yyleng < MAXLINE)
{
strcpy( nmstr, yytext );
strncpy( nmstr, yytext, sizeof(nmstr) );
}
else
{
@@ -630,7 +653,7 @@ M4QEND "]]"
* The reason it was disabled is so yacc/bison can parse
* ccl operations, such as ccl difference and union.
*/
&& (cclval = ccllookup( (Char *) nmstr )) != 0 )
&& (cclval = ccllookup( nmstr )) != 0 )
{
if ( input() != ']' )
synerr( _( "bad character class" ) );
@@ -644,7 +667,7 @@ M4QEND "]]"
/* We fudge a bit. We know that this ccl will
* soon be numbered as lastccl + 1 by cclinit.
*/
cclinstal( (Char *) nmstr, lastccl + 1 );
cclinstal( nmstr, lastccl + 1 );
/* Push back everything but the leading bracket
* so the ccl can be rescanned.
@@ -664,7 +687,7 @@ M4QEND "]]"
* context.
*/
"{"{NAME}"}"[[:space:]]? {
Char *nmdefptr;
char *nmdefptr;
int end_is_ws, end_ch;
end_ch = yytext[yyleng-1];
@@ -672,7 +695,7 @@ M4QEND "]]"
if(yyleng-1 < MAXLINE)
{
strcpy( nmstr, yytext + 1 );
strncpy( nmstr, yytext + 1, sizeof(nmstr) );
}
else
{
@@ -688,7 +711,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
else
{ /* push back name surrounded by ()'s */
int len = strlen( (char *) nmdefptr );
size_t len = strlen( nmdefptr );
if (end_is_ws)
unput(end_ch);
@@ -696,7 +719,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
(len > 0 && nmdefptr[len - 1] == '$')
|| (end_is_ws && trlcontxt && !sf_skip_ws()))
{ /* don't use ()'s after all */
PUT_BACK_STRING((char *) nmdefptr, 0);
PUT_BACK_STRING(nmdefptr, 0);
if ( nmdefptr[0] == '^' )
BEGIN(CARETISBOL);
@@ -705,7 +728,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
else
{
unput(')');
PUT_BACK_STRING((char *) nmdefptr, 0);
PUT_BACK_STRING(nmdefptr, 0);
unput('(');
}
}
@@ -741,7 +764,13 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
return '(';
}
"(" sf_push(); return '(';
")" sf_pop(); return ')';
")" {
if (_sf_top_ix > 0) {
sf_pop();
return ')';
} else
synerr(_("unbalanced parenthesis"));
}
[/|*+?.(){}] return (unsigned char) yytext[0];
. RETURNCHAR;
@@ -873,35 +902,31 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
<PERCENT_BRACE_ACTION>{
{OPTWS}"%}".* bracelevel = 0;
<ACTION>"/*" ACTION_ECHO; yy_push_state( COMMENT );
<ACTION>"/*" ACTION_ECHO; yy_push_state( CODE_COMMENT );
<CODEBLOCK,ACTION>{
"reject" {
ACTION_ECHO;
CHECK_REJECT(yytext);
}
"yymore" {
ACTION_ECHO;
CHECK_YYMORE(yytext);
}
"reject" {
ACTION_ECHO;
CHECK_REJECT(yytext);
}
"yymore" {
ACTION_ECHO;
CHECK_YYMORE(yytext);
}
}
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
. ACTION_ECHO;
{NL} {
++linenum;
ACTION_ECHO;
if ( bracelevel == 0 ||
(doing_codeblock && indented_code) )
{
if ( doing_rule_action )
add_action( "\tYY_BREAK\n" );
. ACTION_ECHO;
{NL} {
++linenum;
ACTION_ECHO;
if (bracelevel <= 0 || (doing_codeblock && indented_code)) {
if ( doing_rule_action )
add_action( "\tYY_BREAK]""]\n" );
doing_rule_action = doing_codeblock = false;
BEGIN(SECT2);
}
}
doing_rule_action = doing_codeblock = false;
BEGIN(SECT2);
}
}
}
@@ -909,37 +934,41 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
<ACTION>{
"{" ACTION_ECHO; ++bracelevel;
"}" ACTION_ECHO; --bracelevel;
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
[^[:alpha:]_{}"'/\n\[\]]+ ACTION_ECHO;
[\[\]] ACTION_ECHO;
{NAME} ACTION_ECHO;
"'"([^'\\\n]|\\.)*"'" ACTION_ECHO; /* character constant */
[^[:alpha:]_{}\"'/\n\[\]]+ ACTION_ECHO;
{NAME} ACTION_ECHO;
"'"([^\'\\\n]|\\.)"'" ACTION_ECHO; /* character constant */
"'" ACTION_ECHO; BEGIN(CHARACTER_CONSTANT);
\" ACTION_ECHO; BEGIN(ACTION_STRING);
{NL} {
++linenum;
ACTION_ECHO;
if ( bracelevel == 0 )
{
if ( doing_rule_action )
add_action( "\tYY_BREAK\n" );
{NL} {
++linenum;
ACTION_ECHO;
if (bracelevel <= 0) {
if ( doing_rule_action )
add_action( "\tYY_BREAK]""]\n" );
doing_rule_action = false;
BEGIN(SECT2);
}
}
. ACTION_ECHO;
doing_rule_action = false;
BEGIN(SECT2);
}
}
. ACTION_ECHO;
}
<ACTION_STRING>{
[^"\\\n]+ ACTION_ECHO;
\\. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO; BEGIN(ACTION);
[^\[\]\"\\\n]+ ACTION_ECHO;
\" ACTION_ECHO; BEGIN(ACTION);
. ACTION_ECHO;
}
<CHARACTER_CONSTANT>{
[^\[\]\'\\\n]+ ACTION_ECHO;
\' ACTION_ECHO; BEGIN(ACTION);
}
<ACTION_STRING,CHARACTER_CONSTANT>{
(\\\n)* ACTION_ECHO;
\\(\\\n)*. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); }
. ACTION_ECHO;
}
<COMMENT,COMMENT_DISCARD,ACTION,ACTION_STRING><<EOF>> {
<COMMENT,CODE_COMMENT,COMMENT_DISCARD,ACTION,ACTION_STRING,CHARACTER_CONSTANT><<EOF>> {
synerr( _( "EOF encountered inside an action" ) );
yyterminate();
}
@@ -950,7 +979,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
}
<SECT2,QUOTE,FIRSTCCL,CCL>{ESCSEQ} {
yylval = myesc( (Char *) yytext );
yylval = myesc( (unsigned char *) yytext );
if ( YY_START == FIRSTCCL )
BEGIN(CCL);
@@ -958,21 +987,32 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
return CHAR;
}
<SECT3>{
{M4QSTART} fwrite (escaped_qstart, 1, strlen(escaped_qstart), yyout);
{M4QEND} fwrite (escaped_qend, 1, strlen(escaped_qend), yyout);
[^\[\]\n]*(\n?) ECHO;
(.|\n) ECHO;
<<EOF>> sectnum = 0; yyterminate();
{M4QSTART} fputs(escaped_qstart, yyout);
{M4QEND} fputs(escaped_qend, yyout);
[^\[\]]* ECHO;
[][] ECHO;
<<EOF>> {
sectnum = 0;
yyterminate();
}
}
<SECT3_NOESCAPE>{
{M4QSTART} fprintf(yyout, "[""[%s]""]", escaped_qstart);
{M4QEND} fprintf(yyout, "[""[%s]""]", escaped_qend);
[^][]* ECHO;
[][] ECHO;
<<EOF>> {
sectnum = 0;
yyterminate();
}
}
<*>.|\n format_synerr( _( "bad character: %s" ), yytext );
%%
int yywrap()
int yywrap(void)
{
if ( --num_input_files > 0 )
{
@@ -987,12 +1027,11 @@ int yywrap()
/* set_input_file - open the given file (if NULL, stdin) for scanning */
void set_input_file( file )
char *file;
void set_input_file( char *file )
{
if ( file && strcmp( file, "-" ) )
{
infilename = copy_string( file );
infilename = xstrdup(file);
yyin = fopen( infilename, "r" );
if ( yyin == NULL )
@@ -1002,31 +1041,8 @@ char *file;
else
{
yyin = stdin;
infilename = copy_string( "<stdin>" );
infilename = xstrdup("<stdin>");
}
linenum = 1;
}
/* Wrapper routines for accessing the scanner's malloc routines. */
void *flex_alloc( size )
size_t size;
{
return (void *) malloc( size );
}
void *flex_realloc( ptr, size )
void *ptr;
size_t size;
{
return (void *) realloc( ptr, size );
}
void flex_free( ptr )
void *ptr;
{
if ( ptr )
free( ptr );
}
+6 -3
View File
@@ -39,8 +39,10 @@ size_t _sf_top_ix=0, _sf_max=0;
void
sf_push (void)
{
if (_sf_top_ix + 1 >= _sf_max)
_sf_stk = (scanflags_t*) flex_realloc ( (void*) _sf_stk, sizeof(scanflags_t) * (_sf_max += 32));
if (_sf_top_ix + 1 >= _sf_max) {
_sf_max += 32;
_sf_stk = realloc(_sf_stk, sizeof(scanflags_t) * _sf_max);
}
// copy the top element
_sf_stk[_sf_top_ix + 1] = _sf_stk[_sf_top_ix];
@@ -59,7 +61,8 @@ void
sf_init (void)
{
assert(_sf_stk == NULL);
_sf_stk = (scanflags_t*) flex_alloc ( sizeof(scanflags_t) * (_sf_max = 32));
_sf_max = 32;
_sf_stk = malloc(sizeof(scanflags_t) * _sf_max);
if (!_sf_stk)
lerr_fatal(_("Unable to allocate %zu of stack"), sizeof(scanflags_t));
_sf_stk[_sf_top_ix] = 0;
+46 -98
View File
@@ -37,20 +37,6 @@
/* Internal structures */
#ifdef HAVE_STRCASECMP
#define STRCASECMP(a,b) strcasecmp(a,b)
#else
static int STRCASECMP PROTO ((const char *, const char *));
static int STRCASECMP (a, b)
const char *a;
const char *b;
{
while (tolower ((unsigned char)*a++) == tolower ((unsigned char)*b++)) ;
return b - a;
}
#endif
#define ARG_NONE 0x01
#define ARG_REQ 0x02
#define ARG_OPT 0x04
@@ -77,56 +63,45 @@ struct _scanopt_t {
};
/* Accessor functions. These WOULD be one-liners, but portability calls. */
static const char *NAME PROTO ((struct _scanopt_t *, int));
static int PRINTLEN PROTO ((struct _scanopt_t *, int));
static int RVAL PROTO ((struct _scanopt_t *, int));
static int FLAGS PROTO ((struct _scanopt_t *, int));
static const char *DESC PROTO ((struct _scanopt_t *, int));
static int scanopt_err PROTO ((struct _scanopt_t *, int, int));
static int matchlongopt PROTO ((char *, char **, int *, char **, int *));
static int find_opt
PROTO ((struct _scanopt_t *, int, char *, int, int *, int *opt_offset));
static const char *NAME(struct _scanopt_t *, int);
static int PRINTLEN(struct _scanopt_t *, int);
static int RVAL(struct _scanopt_t *, int);
static int FLAGS(struct _scanopt_t *, int);
static const char *DESC(struct _scanopt_t *, int);
static int scanopt_err(struct _scanopt_t *, int, int);
static int matchlongopt(char *, char **, int *, char **, int *);
static int find_opt(struct _scanopt_t *, int, char *, int, int *, int *opt_offset);
static const char *NAME (s, i)
struct _scanopt_t *s;
int i;
static const char *NAME (struct _scanopt_t *s, int i)
{
return s->options[i].opt_fmt +
((s->aux[i].flags & IS_LONG) ? 2 : 1);
}
static int PRINTLEN (s, i)
struct _scanopt_t *s;
int i;
static int PRINTLEN (struct _scanopt_t *s, int i)
{
return s->aux[i].printlen;
}
static int RVAL (s, i)
struct _scanopt_t *s;
int i;
static int RVAL (struct _scanopt_t *s, int i)
{
return s->options[i].r_val;
}
static int FLAGS (s, i)
struct _scanopt_t *s;
int i;
static int FLAGS (struct _scanopt_t *s, int i)
{
return s->aux[i].flags;
}
static const char *DESC (s, i)
struct _scanopt_t *s;
int i;
static const char *DESC (struct _scanopt_t *s, int i)
{
return s->options[i].desc ? s->options[i].desc : "";
}
#ifndef NO_SCANOPT_USAGE
static int get_cols PROTO ((void));
static int get_cols (void);
static int get_cols ()
static int get_cols (void)
{
char *env;
int cols = 80; /* default */
@@ -159,15 +134,11 @@ static int get_cols ()
(s)->subscript= 0; \
}while(0)
scanopt_t *scanopt_init (options, argc, argv, flags)
const optspec_t *options;
int argc;
char **argv;
int flags;
scanopt_t *scanopt_init (const optspec_t *options, int argc, char **argv, int flags)
{
int i;
struct _scanopt_t *s;
s = (struct _scanopt_t *) malloc (sizeof (struct _scanopt_t));
s = malloc(sizeof (struct _scanopt_t));
s->options = options;
s->optc = 0;
@@ -186,10 +157,10 @@ scanopt_t *scanopt_init (options, argc, argv, flags)
s->optc++;
/* Build auxiliary data */
s->aux = (struct _aux *) malloc (s->optc * sizeof (struct _aux));
s->aux = malloc((size_t) s->optc * sizeof (struct _aux));
for (i = 0; i < s->optc; i++) {
const Char *p, *pname;
const unsigned char *p, *pname;
const struct optspec_t *opt;
struct _aux *aux;
@@ -200,14 +171,14 @@ scanopt_t *scanopt_init (options, argc, argv, flags)
if (opt->opt_fmt[0] == '-' && opt->opt_fmt[1] == '-') {
aux->flags |= IS_LONG;
pname = (const Char *)(opt->opt_fmt + 2);
pname = (const unsigned char *)(opt->opt_fmt + 2);
s->has_long = 1;
}
else {
pname = (const Char *)(opt->opt_fmt + 1);
pname = (const unsigned char *)(opt->opt_fmt + 1);
s->has_short = 1;
}
aux->printlen = strlen (opt->opt_fmt);
aux->printlen = (int) strlen (opt->opt_fmt);
aux->namelen = 0;
for (p = pname + 1; *p; p++) {
@@ -215,21 +186,21 @@ scanopt_t *scanopt_init (options, argc, argv, flags)
if (*p == '=' || isspace ((unsigned char)*p)
|| !(aux->flags & IS_LONG)) {
if (aux->namelen == 0)
aux->namelen = p - pname;
aux->namelen = (int) (p - pname);
aux->flags |= ARG_REQ;
aux->flags &= ~ARG_NONE;
}
/* detect optional arg. This overrides required arg. */
if (*p == '[') {
if (aux->namelen == 0)
aux->namelen = p - pname;
aux->namelen = (int) (p - pname);
aux->flags &= ~(ARG_REQ | ARG_NONE);
aux->flags |= ARG_OPT;
break;
}
}
if (aux->namelen == 0)
aux->namelen = p - pname;
aux->namelen = (int) (p - pname);
}
return (scanopt_t *) s;
}
@@ -255,10 +226,7 @@ typedef struct usg_elem usg_elem;
[indent][option, alias1, alias2...][indent][description line1
description line2...]
*/
int scanopt_usage (scanner, fp, usage)
scanopt_t *scanner;
FILE *fp;
const char *usage;
int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
{
struct _scanopt_t *s;
int i, columns, indent = 2;
@@ -293,7 +261,7 @@ int scanopt_usage (scanner, fp, usage)
fprintf (fp, "\n");
/* Sort by r_val and string. Yes, this is O(n*n), but n is small. */
store = (usg_elem *) malloc (s->optc * sizeof (usg_elem));
store = malloc((size_t) s->optc * sizeof (usg_elem));
for (i = 0; i < s->optc; i++) {
/* grab the next preallocate node. */
@@ -319,7 +287,7 @@ int scanopt_usage (scanner, fp, usage)
}
if (!ptr_if_no_alias
&&
STRCASECMP (NAME (s, (*ue_curr)->idx),
strcasecmp (NAME (s, (*ue_curr)->idx),
NAME (s, ue->idx)) > 0) {
ptr_if_no_alias = ue_curr;
}
@@ -391,7 +359,7 @@ int scanopt_usage (scanner, fp, usage)
maxlen[0] = len;
/* It's much easier to calculate length for description column! */
len = strlen (DESC (s, ue->idx));
len = (int) strlen (DESC (s, ue->idx));
if (len > maxlen[1])
maxlen[1] = len;
}
@@ -529,10 +497,7 @@ int scanopt_usage (scanner, fp, usage)
#endif /* no scanopt_usage */
static int scanopt_err (s, is_short, err)
struct _scanopt_t *s;
int is_short;
int err;
static int scanopt_err (struct _scanopt_t *s, int is_short, int err)
{
const char *optname = "";
char optchar[2];
@@ -587,16 +552,11 @@ static int scanopt_err (s, is_short, err)
* optname will point to str + 2
*
*/
static int matchlongopt (str, optname, optlen, arg, arglen)
char *str;
char **optname;
int *optlen;
char **arg;
int *arglen;
static int matchlongopt (char *str, char **optname, int *optlen, char **arg, int *arglen)
{
char *p;
*optname = *arg = (char *) 0;
*optname = *arg = NULL;
*optlen = *arglen = 0;
/* Match regex /--./ */
@@ -605,13 +565,13 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
return 0;
p += 2;
*optname = (char *) p;
*optname = p;
/* find the end of optname */
while (*p && *p != '=')
++p;
*optlen = p - *optname;
*optlen = (int) (p - *optname);
if (!*p)
/* an option with no '=...' part. */
@@ -623,7 +583,7 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
*arg = p;
while (*p)
++p;
*arglen = p - *arg;
*arglen = (int) (p - *arg);
return 1;
}
@@ -634,13 +594,8 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
* Short options must be exact.
* Return boolean true if found and no error.
* Error stored in err_code or zero if no error. */
static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
struct _scanopt_t *s;
int lookup_long;
char *optstart;
int len;
int *err_code;
int *opt_offset;
static int find_opt (struct _scanopt_t *s, int lookup_long, char *optstart, int
len, int *err_code, int *opt_offset)
{
int nmatch = 0, lastr_val = 0, i;
@@ -651,17 +606,15 @@ static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
return 0;
for (i = 0; i < s->optc; i++) {
char *optname;
const char *optname;
optname =
(char *) (s->options[i].opt_fmt +
(lookup_long ? 2 : 1));
optname = s->options[i].opt_fmt + (lookup_long ? 2 : 1);
if (lookup_long && (s->aux[i].flags & IS_LONG)) {
if (len > s->aux[i].namelen)
continue;
if (strncmp (optname, optstart, len) == 0) {
if (strncmp (optname, optstart, (size_t) len) == 0) {
nmatch++;
*opt_offset = i;
@@ -699,10 +652,7 @@ static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
}
int scanopt (svoid, arg, optindex)
scanopt_t *svoid;
char **arg;
int *optindex;
int scanopt (scanopt_t *svoid, char **arg, int *optindex)
{
char *optname = NULL, *optarg = NULL, *pstart;
int namelen = 0, arglen = 0;
@@ -788,7 +738,7 @@ int scanopt (svoid, arg, optindex)
arglen = 0;
}
else
arglen = strlen (optarg);
arglen = (int) strlen (optarg);
}
/* At this point, we have a long or short option matched at opt_offset into
@@ -848,16 +798,14 @@ int scanopt (svoid, arg, optindex)
}
int scanopt_destroy (svoid)
scanopt_t *svoid;
int scanopt_destroy (scanopt_t *svoid)
{
struct _scanopt_t *s;
s = (struct _scanopt_t *) svoid;
if (s) {
if (s->aux)
free (s->aux);
free (s);
if (s != NULL) {
free(s->aux);
free(s);
}
return 0;
}
+5 -14
View File
@@ -47,9 +47,6 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef PROTO
#define PROTO(args) args
#endif
/* Error codes. */ enum scanopt_err_t {
SCANOPT_ERR_OPT_UNRECOGNIZED = -1, /* Unrecognized option. */
SCANOPT_ERR_OPT_AMBIGUOUS = -2, /* It matched more than one option name. */
@@ -85,12 +82,12 @@ extern "C" {
* flags - Control behavior.
* Return: A malloc'd pointer .
*/
scanopt_t *scanopt_init PROTO ((const optspec_t * options,
int argc, char **argv, int flags));
scanopt_t *scanopt_init (const optspec_t * options, int argc,
char **argv, int flags);
/* Frees memory used by scanner.
* Always returns 0. */
int scanopt_destroy PROTO ((scanopt_t * scanner));
int scanopt_destroy (scanopt_t * scanner);
#ifndef NO_SCANOPT_USAGE
/* Prints a usage message based on contents of optlist.
@@ -100,10 +97,7 @@ extern "C" {
* usage - Text to be prepended to option list. May be NULL.
* Return: Always returns 0 (zero).
*/
int scanopt_usage
PROTO (
(scanopt_t * scanner, FILE * fp,
const char *usage));
int scanopt_usage (scanopt_t * scanner, FILE * fp, const char *usage);
#endif
/* Scans command-line options in argv[].
@@ -120,10 +114,7 @@ extern "C" {
* < 0 on error (return value is an error code).
*
*/
int scanopt
PROTO (
(scanopt_t * scanner, char **optarg,
int *optindex));
int scanopt (scanopt_t * scanner, char **optarg, int *optindex);
#ifdef __cplusplus
}
+23 -46
View File
@@ -59,12 +59,10 @@ static struct hash_entry *ccltab[CCL_HASH_SIZE];
/* declare functions that have forward references */
static int addsym PROTO ((char[], char *, int, hash_table, int));
static struct hash_entry *findsym PROTO ((const char *sym,
hash_table table,
int table_size));
static int hashfunct PROTO ((const char *, int));
static int addsym(char[], char *, int, hash_table, int);
static struct hash_entry *findsym (const char *sym, hash_table table,
int table_size);
static int hashfunct(const char *, int);
/* addsym - add symbol and definitions to symbol table
@@ -72,12 +70,7 @@ static int hashfunct PROTO ((const char *, int));
* -1 is returned if the symbol already exists, and the change not made.
*/
static int addsym (sym, str_def, int_def, table, table_size)
char sym[];
char *str_def;
int int_def;
hash_table table;
int table_size;
static int addsym (char sym[], char *str_def, int int_def, hash_table table, int table_size)
{
int hash_val = hashfunct (sym, table_size);
struct hash_entry *sym_entry = table[hash_val];
@@ -93,8 +86,7 @@ static int addsym (sym, str_def, int_def, table, table_size)
}
/* create new entry */
new_entry = (struct hash_entry *)
flex_alloc (sizeof (struct hash_entry));
new_entry = malloc(sizeof(struct hash_entry));
if (new_entry == NULL)
flexfatal (_("symbol table memory allocation failed"));
@@ -119,15 +111,13 @@ static int addsym (sym, str_def, int_def, table, table_size)
/* cclinstal - save the text of a character class */
void cclinstal (ccltxt, cclnum)
Char ccltxt[];
int cclnum;
void cclinstal (char ccltxt[], int cclnum)
{
/* We don't bother checking the return status because we are not
* called unless the symbol is new.
*/
(void) addsym ((char *) copy_unsigned_string (ccltxt),
(void) addsym (xstrdup(ccltxt),
(char *) 0, cclnum, ccltab, CCL_HASH_SIZE);
}
@@ -137,23 +127,18 @@ void cclinstal (ccltxt, cclnum)
* Returns 0 if there's no CCL associated with the text.
*/
int ccllookup (ccltxt)
Char ccltxt[];
int ccllookup (char ccltxt[])
{
return findsym ((char *) ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
return findsym (ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
}
/* findsym - find symbol in symbol table */
static struct hash_entry *findsym (sym, table, table_size)
const char *sym;
hash_table table;
int table_size;
static struct hash_entry *findsym (const char *sym, hash_table table, int table_size)
{
static struct hash_entry empty_entry = {
(struct hash_entry *) 0, (struct hash_entry *) 0,
(char *) 0, (char *) 0, 0,
NULL, NULL, NULL, NULL, 0,
};
struct hash_entry *sym_entry =
@@ -170,9 +155,7 @@ static struct hash_entry *findsym (sym, table, table_size)
/* hashfunct - compute the hash value for "str" and hash size "hash_size" */
static int hashfunct (str, hash_size)
const char *str;
int hash_size;
static int hashfunct (const char *str, int hash_size)
{
int hashval;
int locstr;
@@ -191,13 +174,11 @@ static int hashfunct (str, hash_size)
/* ndinstal - install a name definition */
void ndinstal (name, definition)
const char *name;
Char definition[];
void ndinstal (const char *name, char definition[])
{
if (addsym (copy_string (name),
(char *) copy_unsigned_string (definition), 0,
if (addsym (xstrdup(name),
xstrdup(definition), 0,
ndtbl, NAME_TABLE_HASH_SIZE))
synerr (_("name defined twice"));
}
@@ -208,16 +189,15 @@ void ndinstal (name, definition)
* Returns a nil pointer if the name definition does not exist.
*/
Char *ndlookup (nd)
const char *nd;
char *ndlookup (const char *nd)
{
return (Char *) findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
return findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
}
/* scextend - increase the maximum number of start conditions */
void scextend ()
void scextend (void)
{
current_max_scs += MAX_SCS_INCREMENT;
@@ -237,17 +217,15 @@ void scextend ()
* The start condition is "exclusive" if xcluflg is true.
*/
void scinstal (str, xcluflg)
const char *str;
int xcluflg;
void scinstal (const char *str, int xcluflg)
{
if (++lastsc >= current_max_scs)
scextend ();
scname[lastsc] = copy_string (str);
scname[lastsc] = xstrdup(str);
if (addsym (scname[lastsc], (char *) 0, lastsc,
if (addsym(scname[lastsc], NULL, lastsc,
sctbl, START_COND_HASH_SIZE))
format_pinpoint_message (_
("start condition %s declared twice"),
@@ -265,8 +243,7 @@ str);
* Returns 0 if no such start condition.
*/
int sclookup (str)
const char *str;
int sclookup (const char *str)
{
return findsym (str, sctbl, START_COND_HASH_SIZE)->int_val;
}
+33 -33
View File
@@ -55,7 +55,7 @@
int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v);
int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v);
int yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v);
int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len);
int yytbl_writen (struct yytbl_writer *wr, void *v, int len);
static flex_int32_t yytbl_data_geti (const struct yytbl_data *tbl, int i);
/* XXX Not used
static flex_int32_t yytbl_data_getijk (const struct yytbl_data *tbl, int i,
@@ -86,12 +86,12 @@ int yytbl_hdr_init (struct yytbl_hdr *th, const char *version_str,
memset (th, 0, sizeof (struct yytbl_hdr));
th->th_magic = YYTBL_MAGIC;
th->th_hsize = 14 + strlen (version_str) + 1 + strlen (name) + 1;
th->th_hsize = (flex_uint32_t) (14 + strlen (version_str) + 1 + strlen (name) + 1);
th->th_hsize += yypad64 (th->th_hsize);
th->th_ssize = 0; // Not known at this point.
th->th_flags = 0;
th->th_version = copy_string (version_str);
th->th_name = copy_string (name);
th->th_version = xstrdup(version_str);
th->th_name = xstrdup(name);
return 0;
}
@@ -115,8 +115,7 @@ int yytbl_data_init (struct yytbl_data *td, enum yytbl_id id)
*/
int yytbl_data_destroy (struct yytbl_data *td)
{
if (td->td_data)
free (td->td_data);
free(td->td_data);
td->td_data = 0;
free (td);
return 0;
@@ -159,12 +158,12 @@ int yytbl_hdr_fwrite (struct yytbl_writer *wr, const struct yytbl_hdr *th)
flex_die (_("th_ssize|th_flags write failed"));
bwritten += 6;
sz = strlen (th->th_version) + 1;
sz = (int) strlen (th->th_version) + 1;
if ((rv = yytbl_writen (wr, th->th_version, sz)) != sz)
flex_die (_("th_version writen failed"));
bwritten += rv;
sz = strlen (th->th_name) + 1;
sz = (int) strlen (th->th_name) + 1;
if ((rv = yytbl_writen (wr, th->th_name, sz)) != sz)
flex_die (_("th_name writen failed"));
bwritten += rv;
@@ -214,13 +213,13 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
for (i = 0; i < total_len; i++) {
switch (YYTDFLAGS2BYTES (td->td_flags)) {
case sizeof (flex_int8_t):
rv = yytbl_write8 (wr, yytbl_data_geti (td, i));
rv = yytbl_write8 (wr, (flex_uint8_t) yytbl_data_geti (td, i));
break;
case sizeof (flex_int16_t):
rv = yytbl_write16 (wr, yytbl_data_geti (td, i));
rv = yytbl_write16 (wr, (flex_uint16_t) yytbl_data_geti (td, i));
break;
case sizeof (flex_int32_t):
rv = yytbl_write32 (wr, yytbl_data_geti (td, i));
rv = yytbl_write32 (wr, (flex_uint32_t) yytbl_data_geti (td, i));
break;
default:
flex_die (_("invalid td_flags detected"));
@@ -233,7 +232,7 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
}
/* Sanity check */
if (bwritten != (int) (12 + total_len * YYTDFLAGS2BYTES (td->td_flags))) {
if (bwritten != (12 + total_len * (int) YYTDFLAGS2BYTES (td->td_flags))) {
flex_die (_("insanity detected"));
return -1;
}
@@ -248,14 +247,14 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
/* Now go back and update the th_hsize member */
if (fgetpos (wr->out, &pos) != 0
|| fsetpos (wr->out, &(wr->th_ssize_pos)) != 0
|| yytbl_write32 (wr, wr->total_written) < 0
|| yytbl_write32 (wr, (flex_uint32_t) wr->total_written) < 0
|| fsetpos (wr->out, &pos)) {
flex_die (_("get|set|fwrite32 failed"));
return -1;
}
else
/* Don't count the int we just wrote. */
wr->total_written -= sizeof (flex_int32_t);
wr->total_written -= (int) sizeof (flex_int32_t);
return bwritten;
}
@@ -265,11 +264,11 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
* @param len number of bytes
* @return -1 on error. number of bytes written on success.
*/
int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len)
int yytbl_writen (struct yytbl_writer *wr, void *v, int len)
{
int rv;
rv = fwrite (v, 1, len, wr->out);
rv = (int) fwrite (v, 1, (size_t) len, wr->out);
if (rv != len)
return -1;
wr->total_written += len;
@@ -284,11 +283,11 @@ int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len)
int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v)
{
flex_uint32_t vnet;
size_t bytes, rv;
int bytes, rv;
vnet = htonl (v);
bytes = sizeof (flex_uint32_t);
rv = fwrite (&vnet, bytes, 1, wr->out);
bytes = (int) sizeof (flex_uint32_t);
rv = (int) fwrite (&vnet, (size_t) bytes, 1, wr->out);
if (rv != 1)
return -1;
wr->total_written += bytes;
@@ -303,11 +302,11 @@ int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v)
int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v)
{
flex_uint16_t vnet;
size_t bytes, rv;
int bytes, rv;
vnet = htons (v);
bytes = sizeof (flex_uint16_t);
rv = fwrite (&vnet, bytes, 1, wr->out);
bytes = (int) sizeof (flex_uint16_t);
rv = (int) fwrite (&vnet, (size_t) bytes, 1, wr->out);
if (rv != 1)
return -1;
wr->total_written += bytes;
@@ -321,10 +320,10 @@ int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v)
*/
int yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v)
{
size_t bytes, rv;
int bytes, rv;
bytes = sizeof (flex_uint8_t);
rv = fwrite (&v, bytes, 1, wr->out);
bytes = (int) sizeof (flex_uint8_t);
rv = (int) fwrite (&v, (size_t) bytes, 1, wr->out);
if (rv != 1)
return -1;
wr->total_written += bytes;
@@ -428,7 +427,7 @@ static void yytbl_data_seti (const struct yytbl_data *tbl, int i,
*/
static size_t min_int_size (struct yytbl_data *tbl)
{
flex_uint32_t i, total_len;
flex_int32_t i, total_len;
flex_int32_t max = 0;
total_len = yytbl_calc_total_len (tbl);
@@ -438,7 +437,7 @@ static size_t min_int_size (struct yytbl_data *tbl)
n = abs (yytbl_data_geti (tbl, i));
if (n > max)
if (max < n)
max = n;
}
@@ -461,7 +460,8 @@ static size_t min_int_size (struct yytbl_data *tbl)
*/
void yytbl_data_compress (struct yytbl_data *tbl)
{
flex_int32_t i, newsz, total_len;
flex_int32_t i, total_len;
size_t newsz;
struct yytbl_data newtbl;
yytbl_data_init (&newtbl, tbl->td_id);
@@ -472,19 +472,19 @@ void yytbl_data_compress (struct yytbl_data *tbl)
newsz = min_int_size (tbl);
if (newsz == (int) YYTDFLAGS2BYTES (tbl->td_flags))
if (newsz == YYTDFLAGS2BYTES (tbl->td_flags))
/* No change in this table needed. */
return;
if (newsz > (int) YYTDFLAGS2BYTES (tbl->td_flags)) {
if (newsz > YYTDFLAGS2BYTES (tbl->td_flags)) {
flex_die (_("detected negative compression"));
return;
}
total_len = yytbl_calc_total_len (tbl);
newtbl.td_data = calloc (total_len, newsz);
newtbl.td_flags =
TFLAGS_CLRDATA (newtbl.td_flags) | BYTES2TFLAG (newsz);
newtbl.td_data = calloc ((size_t) total_len, newsz);
newtbl.td_flags = (flex_uint16_t)
(TFLAGS_CLRDATA (newtbl.td_flags) | BYTES2TFLAG (newsz));
for (i = 0; i < total_len; i++) {
flex_int32_t g;
+1 -1
View File
@@ -45,7 +45,7 @@ extern "C" {
#include "tables_shared.h"
struct yytbl_writer {
FILE *out;
flex_uint32_t total_written;
int total_written;
/**< bytes written so far */
fpos_t th_ssize_pos;
/**< position of th_ssize */
+2 -2
View File
@@ -57,7 +57,7 @@ dnl
*/
yyskel_static flex_int32_t yytbl_calc_total_len (const struct yytbl_data *tbl)
{
flex_int32_t n;
flex_uint32_t n;
/* total number of ints */
n = tbl->td_lolen;
@@ -66,5 +66,5 @@ yyskel_static flex_int32_t yytbl_calc_total_len (const struct yytbl_data *tbl)
if (tbl->td_id == YYTD_ID_TRANSITION)
n *= 2;
return n;
return (flex_int32_t) n;
}
+25 -37
View File
@@ -36,11 +36,11 @@
/* declarations for functions that have forward references */
void mkentry PROTO ((int *, int, int, int, int));
void mkprot PROTO ((int[], int, int));
void mktemplate PROTO ((int[], int, int));
void mv2front PROTO ((int));
int tbldiff PROTO ((int[], int, int[]));
void mkentry(int *, int, int, int, int);
void mkprot(int[], int, int);
void mktemplate(int[], int, int);
void mv2front(int);
int tbldiff(int[], int, int[]);
/* bldtbl - build table entries for dfa state
@@ -78,8 +78,7 @@ int tbldiff PROTO ((int[], int, int[]));
* cost only one difference.
*/
void bldtbl (state, statenum, totaltrans, comstate, comfreq)
int state[], statenum, totaltrans, comstate, comfreq;
void bldtbl (int state[], int statenum, int totaltrans, int comstate, int comfreq)
{
int extptr, extrct[2][CSIZE + 1];
int mindiff, minprot, i, d;
@@ -221,7 +220,7 @@ void bldtbl (state, statenum, totaltrans, comstate, comfreq)
* classes.
*/
void cmptmps ()
void cmptmps (void)
{
int tmpstorage[CSIZE + 1];
int *tmp = tmpstorage, i, j;
@@ -289,7 +288,7 @@ void cmptmps ()
/* expand_nxt_chk - expand the next check arrays */
void expand_nxt_chk ()
void expand_nxt_chk (void)
{
int old_max = current_max_xpairs;
@@ -300,8 +299,7 @@ void expand_nxt_chk ()
nxt = reallocate_integer_array (nxt, current_max_xpairs);
chk = reallocate_integer_array (chk, current_max_xpairs);
zero_out ((char *) (chk + old_max),
(size_t) (MAX_XPAIRS_INCREMENT * sizeof (int)));
memset(chk + old_max, 0, MAX_XPAIRS_INCREMENT * sizeof(int));
}
@@ -324,8 +322,7 @@ void expand_nxt_chk ()
* and an action number will be added in [-1].
*/
int find_table_space (state, numtrans)
int *state, numtrans;
int find_table_space (int *state, int numtrans)
{
/* Firstfree is the position of the first possible occurrence of two
* consecutive unused records in the chk and nxt arrays.
@@ -419,13 +416,11 @@ int find_table_space (state, numtrans)
* Initializes "firstfree" to be one beyond the end of the table. Initializes
* all "chk" entries to be zero.
*/
void inittbl ()
void inittbl (void)
{
int i;
zero_out ((char *) chk,
(size_t) (current_max_xpairs * sizeof (int)));
memset(chk, 0, (size_t) current_max_xpairs * sizeof(int));
tblend = 0;
firstfree = tblend + 1;
@@ -451,7 +446,7 @@ void inittbl ()
/* mkdeftbl - make the default, "jam" table entries */
void mkdeftbl ()
void mkdeftbl (void)
{
int i;
@@ -500,9 +495,8 @@ void mkdeftbl ()
* state array.
*/
void mkentry (state, numchars, statenum, deflink, totaltrans)
int *state;
int numchars, statenum, deflink, totaltrans;
void mkentry (int *state, int numchars, int statenum, int deflink,
int totaltrans)
{
int minec, maxec, i, baseaddr;
int tblbase, tbllast;
@@ -616,8 +610,7 @@ void mkentry (state, numchars, statenum, deflink, totaltrans)
* has only one out-transition
*/
void mk1tbl (state, sym, onenxt, onedef)
int state, sym, onenxt, onedef;
void mk1tbl (int state, int sym, int onenxt, int onedef)
{
if (firstfree < sym)
firstfree = sym;
@@ -642,8 +635,7 @@ void mk1tbl (state, sym, onenxt, onedef)
/* mkprot - create new proto entry */
void mkprot (state, statenum, comstate)
int state[], statenum, comstate;
void mkprot (int state[], int statenum, int comstate)
{
int i, slot, tblbase;
@@ -680,11 +672,10 @@ void mkprot (state, statenum, comstate)
* to it
*/
void mktemplate (state, statenum, comstate)
int state[], statenum, comstate;
void mktemplate (int state[], int statenum, int comstate)
{
int i, numdiff, tmpbase, tmp[CSIZE + 1];
Char transset[CSIZE + 1];
unsigned char transset[CSIZE + 1];
int tsptr;
++numtemps;
@@ -712,7 +703,8 @@ void mktemplate (state, statenum, comstate)
if (state[i] == 0)
tnxt[tmpbase + i] = 0;
else {
transset[tsptr++] = i;
/* Note: range 1..256 is mapped to 1..255,0 */
transset[tsptr++] = (unsigned char) i;
tnxt[tmpbase + i] = comstate;
}
@@ -732,8 +724,7 @@ void mktemplate (state, statenum, comstate)
/* mv2front - move proto queue element to front of queue */
void mv2front (qelm)
int qelm;
void mv2front (int qelm)
{
if (firstprot != qelm) {
if (qelm == lastprot)
@@ -759,8 +750,7 @@ void mv2front (qelm)
* Transnum is the number of out-transitions for the state.
*/
void place_state (state, statenum, transnum)
int *state, statenum, transnum;
void place_state (int *state, int statenum, int transnum)
{
int i;
int *state_ptr;
@@ -802,8 +792,7 @@ void place_state (state, statenum, transnum)
* no room, we process the sucker right now.
*/
void stack1 (statenum, sym, nextstate, deflink)
int statenum, sym, nextstate, deflink;
void stack1 (int statenum, int sym, int nextstate, int deflink)
{
if (onesp >= ONE_STACK_SIZE - 1)
mk1tbl (statenum, sym, nextstate, deflink);
@@ -832,8 +821,7 @@ void stack1 (statenum, sym, nextstate, deflink)
* number is "numecs" minus the number of "SAME_TRANS" entries in "ext".
*/
int tbldiff (state, pr, ext)
int state[], pr, ext[];
int tbldiff (int state[], int pr, int ext[])
{
int i, *sp = state, *ep = ext, *protp;
int numdiff = 0;
+8 -7
View File
@@ -37,18 +37,19 @@
/* yylex - scan for a regular expression token */
extern char *yytext;
extern FILE *yyout;
bool no_section3_escape = false;
int yylex (void)
{
int toktype;
static int beglin = false;
if (eofseen)
if (eofseen) {
toktype = EOF;
else
} else {
toktype = flexscan ();
}
if (toktype == EOF || toktype == 0) {
eofseen = 1;
@@ -174,12 +175,12 @@ int yylex (void)
fprintf (stderr, "<<EOF>>");
break;
case OPTION_OP:
case TOK_OPTION:
fprintf (stderr, "%s ", yytext);
break;
case OPT_OUTFILE:
case OPT_PREFIX:
case TOK_OUTFILE:
case TOK_PREFIX:
case CCE_ALNUM:
case CCE_ALPHA:
case CCE_BLANK:
+4 -4
View File
@@ -31,6 +31,8 @@ cxx_basic
cxx_basic.cc
cxx_multiple_scanners
cxx_multiple_scanners_[12].cc
cxx_restart
cxx_restart.cc
cxx_yywrap.i3
cxx_yywrap.cc
debug_nr
@@ -63,10 +65,6 @@ multiple_scanners_nr
multiple_scanners_nr_[12].[ch]
multiple_scanners_r
multiple_scanners_r_[12].[ch]
noansi_nr
noansi_nr.c
noansi_r
noansi_r.c
posix
posix.c
posixly_correct
@@ -89,6 +87,8 @@ rescan_nr.direct
rescan_nr.direct.c
rescan_r.direct
rescan_r.direct.c
quote_in_comment
quote_in_comment.c
quotes
quotes.c
string_nr
+200 -111
View File
@@ -19,6 +19,8 @@
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE.
AM_CFLAGS = $(WARNINGFLAGS)
TESTS = $(check_PROGRAMS) options.cn
# The script testwrapper.sh will run most tests as is. A couple tests
@@ -29,31 +31,32 @@ TESTS = $(check_PROGRAMS) options.cn
TEST_EXTENSIONS = .reject .table .direct .cn .i3 .pthread .one .opt .ser .ver
LOG_COMPILER = $(srcdir)/testwrapper.sh
LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_LOG_FLAGS = -d $(srcdir) -r
REJECT_LOG_COMPILER = $(srcdir)/testwrapper.sh
AM_REJECT_LOG_FLAGS = -d $(srcdir) -i reject.txt -r
REJECT_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_REJECT_LOG_FLAGS = -d $(srcdir) -i $(srcdir)/reject.txt -r
TABLE_LOG_COMPILER = $(srcdir)/testwrapper.sh
AM_TABLE_LOG_FLAGS = -d $(srcdir) -i reject.txt -t
TABLE_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_TABLE_LOG_FLAGS = -d $(builddir) -i $(srcdir)/reject.txt -t
DIRECT_LOG_COMPILER=$(srcdir)/testwrapper.sh
AM_DIRECT_LOG_FLAGS = -d $(srcdir)
DIRECT_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper-direct.sh
AM_DIRECT_LOG_FLAGS = -b $(abs_builddir) -s $(srcdir)
CN_LOG_COMPILER=$(srcdir)/options.cn
AM_CN_LOG_FLAGS=$(FLEX)
CN_LOG_COMPILER = $(SHELL) $(srcdir)/options.cn
AM_CN_LOG_FLAGS = $(FLEX)
I3_LOG_COMPILER=$(srcdir)/testwrapper.sh
AM_I3_LOG_FLAGS=-i $(srcdir)/cxx_yywrap.txt -i $(srcdir)/cxx_yywrap.txt -i $(srcdir)/cxx_yywrap.txt
I3_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_I3_LOG_FLAGS = -i $(srcdir)/cxx_yywrap.txt -i $(srcdir)/cxx_yywrap.txt -i $(srcdir)/cxx_yywrap.txt
PTHREAD_LOG_COMPILER=$(srcdir)/testwrapper.sh
AM_PTHREAD_LOG_FLAGS=-i $(srcdir)/pthread_1.txt -i $(srcdir)/pthread_2.txt -i $(srcdir)/pthread_3.txt -i $(srcdir)/pthread_4.txt -i $(srcdir)/pthread_5.txt
PTHREAD_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_PTHREAD_LOG_FLAGS = -i $(srcdir)/pthread_1.txt -i $(srcdir)/pthread_2.txt -i $(srcdir)/pthread_3.txt -i $(srcdir)/pthread_4.txt -i $(srcdir)/pthread_5.txt
ONE_LOG_COMPILER = $(srcdir)/testwrapper.sh
ONE_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_ONE_LOG_FLAGS = -1 -d $(srcdir)
AM_YFLAGS = -d -p test
AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src
check_PROGRAMS = $(simple_tests) $(reject_tests) $(TABLE_TESTS) $(DIRECT_TESTS) $(I3_TESTS) $(PTHREAD_TESTS) $(ONE_TESTS) $(TABLEOPTS_TESTS)
@@ -71,6 +74,7 @@ simple_tests = \
ccl \
cxx_basic \
cxx_multiple_scanners \
cxx_restart \
debug_nr \
debug_r \
extended \
@@ -80,15 +84,14 @@ simple_tests = \
mem_r \
multiple_scanners_nr \
multiple_scanners_r \
noansi_nr \
noansi_r \
posix \
posixly_correct \
prefix_nr \
prefix_r \
quote_in_comment \
quotes \
string_nr \
string_r \
string_r \
top \
yyextra
@@ -107,38 +110,49 @@ DIRECT_TESTS = \
rescan_nr.direct \
rescan_r.direct
I3_TESTS = \
I3_TESTS = \
cxx_yywrap.i3
if want_pthread
PTHREAD_TESTS = \
pthread.pthread
endif
ONE_TESTS = \
lineno_nr.one \
lineno_r.one \
lineno_trailing.one
quote_in_comment_SOURCES = quote_in_comment.l
alloc_extra_SOURCES = alloc_extra.l
array_nr_SOURCES = array_nr.l
array_r_SOURCES = array_r.l
basic_nr_SOURCES = basic_nr.l
basic_r_SOURCES = basic_r.l
if HAVE_BISON
bison_nr_SOURCES = bison_nr_scanner.l bison_nr_parser.y bison_nr_main.c
nodist_bison_nr_SOURCES = bison_nr_parser.h bison_nr_scanner.h
bison_yylloc_SOURCES = bison_yylloc_scanner.l bison_yylloc_parser.y bison_yylloc_main.c
nodist_bison_yylloc_SOURCES = bison_yylloc_parser.h bison_yylloc_scanner.h
bison_yylval_SOURCES = bison_yylval_scanner.l bison_yylval_parser.y bison_yylval_main.c
nodist_bison_yylval_SOURCES = bison_yylval_parser.h bison_yylval_scanner.h
else
bison_nr_SOURCES = no_bison_stub.c
bison_yylloc_SOURCES = no_bison_stub.c
bison_yylval_SOURCES = no_bison_stub.c
endif
c_cxx_nr_SOURCES = c_cxx_nr.lll
c_cxx_r_SOURCES = c_cxx_r.lll
ccl_SOURCES = ccl.l
cxx_basic_SOURCES = cxx_basic.ll
cxx_restart_SOURCES = cxx_restart.ll
cxx_multiple_scanners_SOURCES = cxx_multiple_scanners_main.cc cxx_multiple_scanners_1.ll cxx_multiple_scanners_2.ll
cxx_yywrap_i3_SOURCES = cxx_yywrap.ll
debug_nr_SOURCES = debug_nr.l
debug_r_SOURCES = debug_r.l
extended_SOURCES = extended.l
header_nr_SOURCES = header_nr_scanner.l header_nr_main.c
nodist_header_nr_SOURCES = header_nr_scanner.h
header_r_SOURCES = header_r_scanner.l header_r_main.c
nodist_header_r_SOURCES = header_r_scanner.h
include_by_buffer_direct_SOURCES = include_by_buffer.direct.l
include_by_push_direct_SOURCES = include_by_push.direct.l
include_by_reentrant_direct_SOURCES = include_by_reentrant.direct.l
@@ -148,9 +162,9 @@ lineno_trailing_one_SOURCES = lineno_trailing.l
mem_nr_SOURCES = mem_nr.l
mem_r_SOURCES = mem_r.l
multiple_scanners_nr_SOURCES = multiple_scanners_nr_main.c multiple_scanners_nr_1.l multiple_scanners_nr_2.l
nodist_multiple_scanners_nr_SOURCES = multiple_scanners_nr_1.h multiple_scanners_nr_2.h
multiple_scanners_r_SOURCES = multiple_scanners_r_main.c multiple_scanners_r_1.l multiple_scanners_r_2.l
noansi_nr_SOURCES = noansi_nr.l
noansi_r_SOURCES = noansi_r.l
nodist_multiple_scanners_r_SOURCES = multiple_scanners_nr_1.h multiple_scanners_nr_2.h
posix_SOURCES = posix.l
posixly_correct_SOURCES = posixly_correct.l
prefix_nr_SOURCES = prefix_nr.l
@@ -166,58 +180,116 @@ rescan_r_direct_SOURCES = rescan_r.direct.l
string_nr_SOURCES = string_nr.l
string_r_SOURCES = string_r.l
top_SOURCES = top.l top_main.c
nodist_top_SOURCES = top.h
yyextra_SOURCES = yyextra.l
BUILT_SOURCES = \
bison_nr_scanner.h \
# Normally, automake would distribute files built by flex. Since the
# point of the test suite is to test the files that flex builds, and
# since anyone who has the flex distribution can build a flex binary
# without having a flex binary, we want to not distribute the files
# built by flex in the test suite. The dist-hook target accomplishes
# this goal. It's also handy to have the list of files to clean since
# automake doesn't know about the whacky ways in which we're abusing
# it.
CLEANFILES = \
alloc_extra.c \
array_nr.c \
array_r.c \
basic_nr.c \
basic_r.c \
bison_nr_parser.c \
bison_nr_parser.h \
bison_nr_scanner.c \
bison_nr_scanner.h \
bison_yylloc_parser.c \
bison_yylloc_parser.h \
bison_yylloc_scanner.c \
bison_yylloc_scanner.h \
bison_yylval_parser.c \
bison_yylval_parser.h \
bison_yylval_scanner.c \
bison_yylval_scanner.h \
c_cxx_nr.cc \
c_cxx_r.cc \
ccl.c \
cxx_basic.cc \
cxx_multiple_scanners_1.cc \
cxx_multiple_scanners_2.cc \
cxx_restart.cc \
cxx_yywrap.cc \
debug_nr.c \
debug_r.c \
extended.c \
header_nr_scanner.c \
header_nr_scanner.h \
header_r_scanner.c \
header_r_scanner.h \
include_by_buffer.direct.c \
include_by_push.direct.c \
include_by_reentrant.direct.c \
lineno_nr.c \
lineno_r.c \
lineno_trailing.c \
mem_nr.c \
mem_r.c \
multiple_scanners_nr_1.c \
multiple_scanners_nr_1.h \
multiple_scanners_nr_2.c \
multiple_scanners_nr_2.h \
multiple_scanners_r_1.c \
multiple_scanners_r_1.h \
multiple_scanners_r_2.c \
multiple_scanners_r_2.h \
posix.c \
posixly_correct.c \
prefix_nr.c \
prefix_r.c \
pthread.c \
quote_in_comment.c \
quotes.c \
reject_nr.reject.c \
reject_r.reject.c \
reject_ver.table.c \
reject_ser.table.c \
top.h \
$(tableopts_c)
reject_ser.table.tables \
reject_ver.table.c \
reject_ver.table.tables \
rescan_nr.direct.c \
rescan_r.direct.c \
string_nr.c \
string_r.c \
top.c \
top.h \
yyextra.c \
$(tableopts_c) \
$(tableopts_tables)
dist-hook:
for file in $(CLEANFILES) ; do \
rm -f $(distdir)/$$file \
; done
EXTRA_DIST = \
README \
testwrapper.sh \
alloc_extra.txt \
array_nr.txt \
array_r.txt \
basic_nr.txt \
basic_nr.txt \
basic_r.txt \
bison_nr_scanner.h \
bison_nr.txt \
bison_yylloc_scanner.h \
bison_yylloc.txt \
bison_yylval_scanner.h \
bison_yylval.txt \
c_cxx_nr.cc \
c_cxx_nr.txt \
c_cxx_r.cc \
c_cxx_r.txt \
ccl.txt \
cxx_basic.txt \
cxx_multiple_scanners.txt \
cxx_restart.txt \
cxx_yywrap.txt \
debug_nr.txt \
debug_r.txt \
extended.txt \
header_nr_scanner.h \
header_nr.txt \
header_r_scanner.h \
header_r.txt \
include_by_buffer.direct.txt \
include_by_buffer.direct_2.txt \
@@ -233,12 +305,6 @@ basic_nr.txt \
lineno_trailing.one.txt \
mem_nr.txt \
mem_r.txt \
noansi_nr.txt \
multiple_scanners_nr_1.h \
multiple_scanners_nr_2.h \
multiple_scanners_r_1.h \
multiple_scanners_r_2.h \
noansi_r.txt \
prefix_nr.txt \
prefix_r.txt \
pthread_1.txt \
@@ -247,105 +313,128 @@ basic_nr.txt \
pthread_4.txt \
pthread_5.txt \
reject.txt \
reject_nr.reject.c \
reject_r.reject.c \
reject_ver.table.c \
reject_ver.table.tables \
reject_ser.table.c \
reject_ser.table.tables \
rescan_nr.direct.txt \
rescan_r.direct.txt \
quote_in_comment.txt \
quotes.txt \
top.h \
top.txt \
yyextra.txt \
$(tableopts_c) \
$(tableopts_tables) \
tableopts.txt \
options.cn
tableopts.txt
pthread_pthread_LDADD = -lpthread
dist_noinst_SCRIPTS = \
tableopts.sh
dist_check_SCRIPTS = \
options.cn \
testwrapper-direct.sh \
testwrapper.sh
pthread_pthread_LDADD = @LIBPTHREAD@
# specify how to process .l files in order to test the flex built by make all
FLEX = $(top_builddir)/src/flex
.l.c:
$(FLEX) -o $@ $<
.l.c: $(FLEX)
$(AM_V_LEX)$(FLEX) -o $@ $<
.ll.cc:
$(FLEX) -+ -o $@ $<
.ll.cc: $(FLEX)
$(AM_V_LEX)$(FLEX) -+ -o $@ $<
bison_nr_main.$(OBJEXT): bison_nr_parser.h bison_nr_scanner.h
bison_nr_scanner.$(OBJEXT): bison_nr_parser.h
bison_nr_main.($OBJEXT): bison_nr_parser.h bison_nr_scanner.h
bison_nr_scanner.h: bison_nr_scanner.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
bison_yylloc_main.$(OBJEXT): bison_yylloc_parser.h bison_yylloc_scanner.h
bison_yylloc_scanner.$(OBJEXT): bison_yylloc_parser.h
bison_yylloc_scanner.h: bison_yylloc_scanner.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
bison_yylval_main.$(OBJEXT): bison_yylval_parser.h bison_yylval_scanner.h
bison_yylval_scanner.$(OBJEXT): bison_yylval_parser.h
bison_yylval_scanner.h: bison_yylval_scanner.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
# automake does not support compiling flex scanners output in C as C++
# so we explicitly sayhow, using the .lll suffix for the lex input file
.lll.cc:
$(FLEX) -o $@ $<
.lll.cc: $(FLEX)
$(AM_V_LEX)$(FLEX) -o $@ $<
header_nr_main.$(OBJEXT): header_nr_scanner.h
header_nr_scanner.h: header_nr_scanner.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
header_r_main.$(OBJEXT): header_r_scanner.h
header_r_scanner.h: header_r_scanner.c
include_by_buffer.direct$(EXE): include_by_buffer.direct.txt include_by_buffer.direct_2.txt include_by_buffer.direct_3.txt
include_by_push.direct$(EXE): include_by_push.direct.txt include_by_push.direct_2.txt include_by_push.direct_3.txt
include_by_reentrant.direct$(EXE): include_by_reentrant.direct.txt include_by_reentrant.direct_2.txt include_by_reentrant.direct_3.txt
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
multiple_scanners_nr_main.$(OBJEXT): multiple_scanners_nr_1.h multiple_scanners_nr_2.h
multiple_scanners_nr_1.h: multiple_scanners_nr_1.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
multiple_scanners_nr_2.h: multiple_scanners_nr_2.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
multiple_scanners_r_main.$(OBJEXT): multiple_scanners_r_1.h multiple_scanners_r_2.h
multiple_scanners_r_1.h: multiple_scanners_r_1.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
multiple_scanners_r_2.h: multiple_scanners_r_2.c
@if test ! -f $@; then rm -f $<; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) $<; else :; fi
posixly_correct.c: posixly_correct.l
POSIXLY_CORRECT=1 $(FLEX) -o $@ $<
posixly_correct.c: posixly_correct.l $(FLEX)
$(AM_V_LEX)POSIXLY_CORRECT=1 $(FLEX) -o $@ $<
reject_nr.reject.c: reject.l4
$(FLEX) -o $@ $<
reject_nr.reject.c: reject.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -o $@ $<
reject_nr.reject$(EXEEXT): reject_nr.reject.$(OBJEXT)
$(LINK) $^
$(AM_V_CCLD)$(LINK) $^
reject_r.reject.c: reject.l4
$(FLEX) --reentrant -o $@ $<
reject_r.reject.c: reject.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape --reentrant -o $@ $<
reject_r.reject.$(OBJEXT): reject_r.reject.c
$(COMPILE) -DTEST_IS_REENTRANT -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_IS_REENTRANT -c -o $@ $<
reject_r.reject$(EXEEXT): reject_r.reject.$(OBJEXT)
$(LINK) $^
$(AM_V_CCLD)$(LINK) $^
reject_ver.table.c: reject.l4
$(FLEX) -o $@ --tables-verify --tables-file=$(basename $@).tables $<
reject_ver.table.c: reject.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -o $@ --tables-verify --tables-file=$(basename $@).tables $<
reject_ver.table.$(OBJEXT): reject_ver.table.c
$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
reject_ver.table$(EXEEXT): reject_ver.table.$(OBJEXT)
$(LINK) $^
$(AM_V_CCLD)$(LINK) $^
reject_ser.table.c: reject.l4
$(FLEX) -o $@ --tables-file=$(basename $@).tables $<
reject_ser.table.c: reject.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) -o $@ --unsafe-no-m4-sect3-escape --tables-file=$(basename $@).tables $<
reject_ser.table.$(OBJEXT): reject_ser.table.c
$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
reject_ser.table$(EXEEXT): reject_ser.table.$(OBJEXT)
$(LINK) $^
$(AM_V_CCLD)$(LINK) $^
top_main.$(OBJEXT): top.h
top.h: top.c
@@ -357,9 +446,9 @@ top.h: top.c
# it can be / is generated by a shell script, tableopts.sh.
tableopts.am: tableopts.sh
$(srcdir)/tableopts.sh > $(srcdir)/tableopts.am
$(SHELL) $(srcdir)/tableopts.sh > $(srcdir)/tableopts.am
include tableopts.am
include $(srcdir)/tableopts.am
tableopts := -Ca -Ce -Cf -CF -Cm -Cem -Cae -Caef -CaeF -Cam -Caem
tableopts_opt_tests := $(foreach opt,$(tableopts), tableopts_opt_nr$(opt) tableopts_opt_r$(opt))
@@ -369,50 +458,50 @@ tableopts_tests := $(tableopts_opttests) $(tableopts_vertests) $(tableopts_sert
tableopts_c := $(addsuffix .c,$(tableopts_tests))
OPT_LOG_COMPILER = $(srcdir)/testwrapper.sh
AM_OPT_LOG_FLAGS = -d $(srcdir) -i tableopts.txt -r
OPT_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_OPT_LOG_FLAGS = -d $(srcdir) -i $(srcdir)/tableopts.txt -r
tableopts_opt_nr%.c: tableopts.l4
$(FLEX) -P $(subst -,_,$(basename $(*F))) $* -o $@ $<
tableopts_opt_nr%.c: tableopts.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) $* -o $@ $<
tableopts_opt_nr%.$(OBJEXT): tableopts_opt_nr%.c
$(COMPILE) -c -o $@ $<
$(AM_V_CC)$(COMPILE) -c -o $@ $<
tableopts_opt_r%.c: tableopts.l4
$(FLEX) -P $(subst -,_,$(basename $(*F))) --reentrant $* -o $@ $<
tableopts_opt_r%.c: tableopts.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --reentrant $* -o $@ $<
tableopts_opt_r%.$(OBJEXT): tableopts_opt_r%.c
$(COMPILE) -DTEST_IS_REENTRANT -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_IS_REENTRANT -c -o $@ $<
SER_LOG_COMPILER = $(srcdir)/testwrapper.sh
AM_SER_LOG_FLAGS = -d $(srcdir) -i tableopts.txt -r -t
SER_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_SER_LOG_FLAGS = -d $(builddir) -i $(srcdir)/tableopts.txt -r -t
tableopts_ser_nr%.c: tableopts.l4
$(FLEX) -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ser_nr$*.ser.tables" $* -o $@ $<
tableopts_ser_nr%.c: tableopts.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ser_nr$*.ser.tables" $* -o $@ $<
tableopts_ser_nr%.$(OBJEXT): tableopts_ser_nr%.c
$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
tableopts_ser_r%.c: tableopts.l4
$(FLEX) -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ser_r$*.ser.tables" $* -o $@ $<
tableopts_ser_r%.c: tableopts.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ser_r$*.ser.tables" $* -o $@ $<
tableopts_ser_r%.$(OBJEXT): tableopts_ser_r%.c
$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -DTEST_IS_REENTRANT -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -DTEST_IS_REENTRANT -c -o $@ $<
VER_LOG_COMPILER = $(srcdir)/testwrapper.sh
AM_VER_LOG_FLAGS = -d $(srcdir) -i tableopts.txt -r -t
VER_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_VER_LOG_FLAGS = -d $(builddir) -i $(srcdir)/tableopts.txt -r -t
tableopts_ver_nr%.c: tableopts.l4
$(FLEX) -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ver_nr$*.ver.tables" --tables-verify $* -o $@ $<
tableopts_ver_nr%.c: tableopts.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ver_nr$*.ver.tables" --tables-verify $* -o $@ $<
tableopts_ver_nr%.$(OBJEXT): tableopts_ver_nr%.c
$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -c -o $@ $<
tableopts_ver_nr%.ver$(EXEEXT): tableopts_ver_nr%.$(OBJEXT)
$(LINK) -o $@ $^
$(AM_V_CCLD)$(LINK) -o $@ $^
tableopts_ver_r%.c: tableopts.l4
$(FLEX) -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ver_r$*.ver.tables" --tables-verify $* -o $@ $<
tableopts_ver_r%.c: tableopts.l4 $(FLEX)
$(AM_V_LEX)$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ver_r$*.ver.tables" --tables-verify $* -o $@ $<
tableopts_ver_r%.$(OBJEXT): tableopts_ver_r%.c
$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -DTEST_IS_REENTRANT -c -o $@ $<
$(AM_V_CC)$(COMPILE) -DTEST_HAS_TABLES_EXTERNAL -DTEST_IS_REENTRANT -c -o $@ $<
+2 -1
View File
@@ -50,7 +50,8 @@ stderr, which will have been redirected to the log file created by the
automake test suite harness.
** If your test is skipped (e.g., because bison was not found), then
the test should return 2 (two).
the test should return 77 (seventy-seven). This is the exit status that
would be recognized by automake's "test-driver" as _skipped_.
** Once your work is done, submit a patch via the flex development
mailing list, the github pull request mechanism or some other
+4 -7
View File
@@ -43,9 +43,6 @@ struct Check {
/* Save char into junk array at next position. */
static void check_extra ( yyscan_t scanner );
/* Special yyalloc */
void *yyalloc ( size_t size, yyscan_t scanner );
%}
%option 8bit prefix="test"
@@ -65,7 +62,7 @@ void *yyalloc ( size_t size, yyscan_t scanner );
int main(void);
int
main ()
main (void)
{
yyscan_t scanner;
struct Check check;
@@ -78,8 +75,8 @@ main ()
testset_in(stdin, scanner);
testset_out(stdout, scanner);
/* Test to confirm that yyalloc was called from
* yylex_init_extra with the yyextra argument.
/* Test to confirm that testalloc was called from
* testlex_init_extra with the testextra argument.
*/
check_extra(scanner);
@@ -89,7 +86,7 @@ main ()
return 0;
}
void *yyalloc(size_t size, yyscan_t scanner)
void *testalloc(size_t size, yyscan_t scanner)
{
struct Check *check;
check = testget_extra(scanner);
+1 -1
View File
@@ -45,7 +45,7 @@
int main (void);
int
main ()
main (void)
{
yyin = stdin;
yyout = stdout;
+1 -1
View File
@@ -45,7 +45,7 @@
int main(void);
int
main ()
main (void)
{
yyscan_t lexer;
+1 -1
View File
@@ -52,7 +52,7 @@ WS [[:blank:]]
int main(void);
int main ()
int main (void)
{
yyin = stdin;
yyout = stdout;
+6 -6
View File
@@ -52,16 +52,16 @@ WS [[:blank:]]
int main(void);
int main ()
int main (void)
{
yyscan_t lexer;
yylex_init( &lexer );
yyset_out ( stdout,lexer);
yyset_in ( stdin, lexer);
while( yylex(lexer) )
testlex_init( &lexer );
testset_out ( stdout,lexer);
testset_in ( stdin, lexer);
while( testlex(lexer) )
{
}
yylex_destroy( lexer );
testlex_destroy( lexer );
printf("TEST RETURNING OK.\n");
return 0;
}
-2
View File
@@ -23,9 +23,7 @@
#include "bison_nr_parser.h"
#include "bison_nr_scanner.h"
#include "bison_nr_scanner_char.h"
extern int testparse(void);
int main ( int argc, char** argv )
{
+3 -5
View File
@@ -32,18 +32,16 @@
#include "config.h"
#include "bison_nr_parser.h"
#include "bison_nr_scanner.h"
#include "bison_nr_scanner_char.h"
#define YYERROR_VERBOSE 1
/* #define YYPARSE_PARAM scanner */
/* #define YYLEX_PARAM scanner */
int yyerror(const char* msg);
extern int testget_lineno(void);
/* A dummy function. A check against seg-faults in yylval->str. */
int process_text(YY_CHAR* s) {
static int process_text(char* s) {
int total =0;
while(*s) {
total += (int) *s;
@@ -55,11 +53,11 @@ int process_text(YY_CHAR* s) {
%}
%pure_parser
%pure-parser
%union {
int lineno;
YY_CHAR * str;
char * str;
}
%token <str> IDENT
%token <lineno> LINENO
+9 -4
View File
@@ -26,8 +26,8 @@
#include <stdio.h>
#include <stdlib.h>
#include "bison_nr_parser.h"
#include "strutils.h"
#include "config.h"
static char* STRDUP(char* s1);
#define YY_EXTRA_TYPE int
%}
@@ -35,23 +35,28 @@
%option bison-locations yylineno
%option prefix="test" header="bison_nr_scanner.h" yylineno
%option nomain nounput noyy_top_state noyywrap nodefault noinput warn
%option header-char="bison_nr_scanner_char.h"
%%
^[[:digit:]]+ {
yylval->lineno = yylineno;
yylloc->first_line = (int)yy_utils_strtol(yytext,NULL,10);
yylloc->first_line = (int)strtol(yytext,NULL,10);
return LINENO;
}
":" { return COLON; }
" " { return SPACE; }
"=" { return EQUAL; }
[[:alnum:]_]+ { yylval->str = yy_utils_strdup(yytext); return IDENT;}
[[:alnum:]_]+ { yylval->str = STRDUP(yytext); return IDENT;}
\r|\n { }
. { yyterminate();}
%%
static char* STRDUP(char* s1)
{
char* s2 = malloc(strlen(s1)+1);
sprintf(s2,"%s",s1);
return s2;
}
-1
View File
@@ -23,7 +23,6 @@
#include "bison_yylloc_parser.h"
#include "bison_yylloc_scanner.h"
#include "bison_yylloc_scanner_char.h"
int main ( int argc, char** argv )
{
+2 -5
View File
@@ -35,17 +35,14 @@
#include "config.h"
#include "bison_yylloc_parser.h"
#include "bison_yylloc_scanner.h"
#include "bison_yylloc_scanner_char.h"
int yyerror(YYLTYPE *location, void* scanner, const char* msg);
#define YYERROR_VERBOSE 1
extern int testget_lineno(void*);
/* A dummy function. A check against seg-faults in yylval->str. */
int process_text(YY_CHAR* s) {
static int process_text(char* s) {
int total =0;
while(*s) {
total += (int) *s;
@@ -61,7 +58,7 @@ int process_text(YY_CHAR* s) {
%union {
int lineno;
YY_CHAR * str;
char * str;
}
%token <str> IDENT
%token <lineno> LINENO
+11 -5
View File
@@ -27,7 +27,7 @@
#include <stdlib.h>
#include "bison_yylloc_parser.h"
#include "config.h"
#include "strutils.h"
static char* STRDUP(char* s1);
#define YY_EXTRA_TYPE int
%}
@@ -35,8 +35,6 @@
%option reentrant bison-bridge bison-locations yylineno
%option header="bison_yylloc_scanner.h"
%option nomain nounput noyy_top_state noyywrap nodefault noinput warn
%option nomain nounput noyy_top_state noyywrap nodefault warn
%option header-char="bison_yylloc_scanner_char.h"
%%
@@ -46,14 +44,22 @@
^[[:digit:]]+ {
yylval->lineno = yyextra++;
yylloc->first_line = (int)yy_utils_strtol(yytext,NULL,10);
yylloc->first_line = (int)strtol(yytext,NULL,10);
return LINENO;
}
":" { return COLON; }
" " { return SPACE; }
"=" { return EQUAL; }
[[:alnum:]_]+ { yylval->str = yy_utils_strdup(yytext); return IDENT;}
[[:alnum:]_]+ { yylval->str = STRDUP(yytext); return IDENT;}
\r|\n { }
. { yyterminate();}
%%
static char* STRDUP(char* s1)
{
char* s2 = malloc(strlen(s1)+1);
sprintf(s2,"%s",s1);
return s2;
}
+1 -2
View File
@@ -21,9 +21,8 @@
* PURPOSE.
*/
<<<#include "bison_yylval_parser.h"
#include "bison_yylval_parser.h"
#include "bison_yylval_scanner.h"
#include "bison_yylval_scanner_char.h"
int main ( int argc, char** argv )
{
+2 -3
View File
@@ -34,14 +34,13 @@
#include "config.h"
#include "bison_yylval_parser.h"
#include "bison_yylval_scanner.h"
#include "bison_yylval_scanner_char.h"
#define YYERROR_VERBOSE 1
int yyerror(void* scanner, const char* msg);
/* A dummy function. A check against seg-faults in yylval->str. */
int process_text(YY_CHAR* s) {
static int process_text(char* s) {
int total =0;
while(*s) {
total += (int) *s;
@@ -57,7 +56,7 @@ int process_text(YY_CHAR* s) {
%union {
long unused;
YY_CHAR * str;
char * str;
}
%token <str> TAGNAME TEXT
+11 -5
View File
@@ -27,7 +27,7 @@
#include <stdlib.h>
#include "bison_yylval_parser.h"
#include "config.h"
#include "strutils.h"
static char* STRDUP(char* s1);
enum yesno_t { no=0, yes=1 };
#define YY_EXTRA_TYPE enum yesno_t
@@ -37,8 +37,6 @@ enum yesno_t { no=0, yes=1 };
%option reentrant bison-bridge
%option header="bison_yylval_scanner.h"
%option noyywrap nomain nounput noyy_top_state noyywrap nodefault noinput warn
%option noyywrap nomain nounput noyy_top_state noyywrap nodefault warn
%option header-char="bison_yylval_scanner_char.h"
%option stack
@@ -54,14 +52,14 @@ enum yesno_t { no=0, yes=1 };
"</" { NEED_TAG_NAME= yes; yy_push_state( IN_TAG, yyscanner); return LTSLASH;}
"<"[^[:alpha:]] { yy_push_state(DISCARD_THRU_GT,yyscanner); }
"<" { NEED_TAG_NAME= yes; yy_push_state( IN_TAG, yyscanner); return LT; }
[^<]{1,512} { yyget_lval(yyscanner)->str = yy_utils_strdup(yytext); return TEXT;}
[^<]{1,512} { testget_lval(yyscanner)->str = STRDUP(yytext); return TEXT;}
}
<IN_TAG>{
">" { yy_pop_state( yyscanner ); return GT; }
[[:alpha:]][[:alnum:]]* {
if( NEED_TAG_NAME == yes){
NEED_TAG_NAME=no;
yylval->str = yy_utils_strdup(yytext);
yylval->str = STRDUP(yytext);
return TAGNAME;
}
}
@@ -73,3 +71,11 @@ enum yesno_t { no=0, yes=1 };
">" { yy_pop_state(yyscanner);}
}
%%
static char* STRDUP(char* s1)
{
char* s2 = malloc(strlen(s1)+1);
sprintf(s2,"%s",s1);
return s2;
}
+4 -4
View File
@@ -48,10 +48,10 @@ int main(void);
int
main ()
{
yyin = stdin;
yyout = stdout;
yylex();
yylex_destroy();
testin = stdin;
testout = stdout;
testlex();
testlex_destroy();
printf("TEST RETURNING OK.\n");
return 0;
}
+5 -5
View File
@@ -49,13 +49,13 @@ int
main ()
{
yyscan_t lexer;
yylex_init( &lexer );
yyset_out ( stdout,lexer);
yyset_in ( stdin, lexer);
while( yylex(lexer) )
testlex_init( &lexer );
testset_out ( stdout,lexer);
testset_in ( stdin, lexer);
while( testlex(lexer) )
{
}
yylex_destroy( lexer );
testlex_destroy( lexer );
printf("TEST RETURNING OK.\n");
return 0;
}
+1 -1
View File
@@ -84,7 +84,7 @@
int main(void);
int
main ()
main (void)
{
yyin = stdin;
yyout = stdout;
+7 -11
View File
@@ -38,17 +38,13 @@ main ( int argc, char** argv )
S1_FlexLexer* S1 = new S1_FlexLexer;
S2_FlexLexer* S2 = new S2_FlexLexer;
while(testlex(scanner)) {
YY_CHAR * text;
int line;
line = testget_lineno(scanner);
text = testget_text(scanner);
if( (char*)testget_extra(scanner) != extra)
break;
if ( !text || line < 0)
continue;
// scan simultaneously.
while(S1_ok || S2_ok)
{
if (S1_ok)
S1_ok = S1->yylex();
if (S2_ok)
S2_ok = S2->yylex();
}
printf("TEST RETURNING OK.\n");
delete S1;
+13 -29
View File
@@ -21,47 +21,31 @@
* PURPOSE.
*/
/* TEST scanner.
Basic non-reentrant scanner, but with non-ansi function defs.
Compile with: flex scanner.l
Sample Input:
# this is a comment
foo = true
bar = "string value"
integer = 43
*/
%{
#include "config.h"
%}
%option prefix="test"
%option nounput noyywrap noyylineno warn nodefault noinput
%option noansi-prototypes noansi-definitions
%option 8bit prefix="test"
%option warn c++
%option nounput nomain noinput noyywrap
IDENT [[:alnum:]_-]
WS [[:blank:]]
%%
^{IDENT}+{WS}*={WS}*(true|false){WS}*\r?\n { return 100;}
^{IDENT}+{WS}*={WS}*\"[^\"\n\r]*\"{WS}*\r?\n { return 101;}
^{IDENT}+{WS}*={WS}*[[:digit:]]+{WS}*\r?\n { return 102;}
^{WS}*#.*\r?\n { }
^{WS}*\r?\n { }
.|\n { fprintf(stderr,"Invalid line.\n"); exit(-1);}
. { }
%%
int main(void);
int main ()
int
main (void)
{
yyin = stdin;
yyout = stdout;
while( yylex() )
{
}
printf("TEST RETURNING OK.\n");
yyFlexLexer f;
f.switch_streams(&std::cin, &std::cout);
f.yylex();
f.yyrestart(NULL);
std::cout << "TEST RETURNING OK." << std::endl;
return 0;
}
+2
View File
@@ -0,0 +1,2 @@
0000 foo 1111 foo 0000 bar
0000 foo 1111 foo 0000 bar
+1 -1
View File
@@ -41,7 +41,7 @@
int main(void);
int
main ()
main (void)
{
yyin = stdin;
yyout = stdout;
+6 -6
View File
@@ -40,20 +40,20 @@
int main(void);
int main ()
int main (void)
{
yyscan_t lexer;
yylex_init( &lexer );
yyset_out ( stdout,lexer);
yyset_in ( stdin, lexer);
testlex_init( &lexer );
testset_out ( stdout,lexer);
testset_in ( stdin, lexer);
/* Just see if the next line compiles. */
testset_debug (testget_debug(lexer), lexer);
while( yylex(lexer) )
while( testlex(lexer) )
{
}
yylex_destroy( lexer );
testlex_destroy( lexer );
printf("TEST RETURNING OK.\n");
return 0;
}
+1 -1
View File
@@ -63,7 +63,7 @@ A(?x: B
int main(void);
int
main ()
main (void)
{
yyin = stdin;
yyout = stdout;
+1 -1
View File
@@ -50,7 +50,7 @@ main ( int argc, char** argv )
assert(fp == stdout);
while(testlex(scanner)) {
YY_CHAR * text;
char * text;
int line;
line = testget_lineno(scanner);
text = testget_text(scanner);

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