BRL-CAD/flex
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: BRL-CAD/flex:v2.6.3
Branches Tags
BRL-CAD/flex:master BRL-CAD/flex:westes-install BRL-CAD/flex:pull/460 BRL-CAD/flex:go BRL-CAD/flex:feature/am_gettext_require_version BRL-CAD/flex:RELEASE BRL-CAD/flex:gh-pages BRL-CAD/flex:unicode
BRL-CAD/flex:v2.6.4 BRL-CAD/flex:v2.6.3 BRL-CAD/flex:v2.6.2 BRL-CAD/flex:v2.6.1 BRL-CAD/flex:v2.6.0 BRL-CAD/flex:flex-2.5.39 BRL-CAD/flex:flex-2-5-10 BRL-CAD/flex:flex-2-5-5c BRL-CAD/flex:flex-2-5-5b
..
compare: BRL-CAD/flex:pull/460
Branches Tags
BRL-CAD/flex:master BRL-CAD/flex:westes-install BRL-CAD/flex:pull/460 BRL-CAD/flex:go BRL-CAD/flex:feature/am_gettext_require_version BRL-CAD/flex:RELEASE BRL-CAD/flex:gh-pages BRL-CAD/flex:unicode
BRL-CAD/flex:v2.6.4 BRL-CAD/flex:v2.6.3 BRL-CAD/flex:v2.6.2 BRL-CAD/flex:v2.6.1 BRL-CAD/flex:v2.6.0 BRL-CAD/flex:flex-2.5.39 BRL-CAD/flex:flex-2-5-10 BRL-CAD/flex:flex-2-5-5c BRL-CAD/flex:flex-2-5-5b
201 Commits
v2.6.3 .. pull/460
Author SHA1 Message Date
Eric S. Raymond 585889745c Clean up the indentation and brace usage in the skeleton file. 
It was in a mix of several different styles tht made it hard
to read.  I've massaged it all ibto K&R with tabs and mandatory
braces.  No logic changes.
 2020-09-27 14:26:29 -04:00
Will Estes f8fd9731d4 build: set dependency info involving cpp-skel.h 2020-09-26 20:09:29 -04:00
Eric S. Raymond 695cab8a1e Fold documentation on how to write bac ends into the Texinfo manual 2020-09-26 20:08:02 -04:00
Eric S. Raymond c842b49f83 Finish the retargeting patch series with a couple of small fixups. 
Pull the C mode setting for M4_YYL_BASE into m4.

Use if/then/else extension of m4_ifdef to simplify how yy_flex_debug
is set.  In the process, fix a bug introduced earlier in this patchest
where yy_flex_debug initialization was inverted.

Remove unused skel breakpoints and renumber those left.

Diffs have only commenmt and whitespace changes *except* for the
corrected initialzation of yy_flex_debug.

#40 in the retargeting patch series
 2020-09-25 18:09:44 -04:00
Eric S. Raymond 8521281aef indent_puts and friends go away, they're no longer needed. 
I did some indentation of the end-of-file case statements with tabs to
make the generated code a bit more readable.  So there are trivial
whitespace diffs in generated code.

#39 in the retargeting patch series
 2020-09-25 15:40:03 -04:00
Eric S. Raymond 219db78e6a Last procedural-code generation in C goes to m4. 
Diffs are comments and whiespace, as usual.

#38 in the retargeting patch series
 2020-09-25 15:26:06 -04:00
Eric S. Raymond efeb6ef019 m4ize the code for handling NUL transitions. 
Finally, scavenge trailing skel breakpoints that are no
longer used, as theey no longer carry information.

Diffs in generated code are all comments and whitesoace, as usual

#37 in the retargeting patch series
 2020-09-24 20:40:47 -04:00
Eric S. Raymond 31b751703f Chase down some methodization details missed earlier. 
No generated-code diffs from this change.

#36 in the retargeting patch series
 2020-09-24 06:52:27 -04:00
Eric S. Raymond d7cb3bf631 Dump the state of the m4 conditionals near start of generated code. 
Of course, this produces exactly that in diffs.

#35 in the retargeting patch series
 2020-09-24 05:14:05 -04:00
Eric S. Raymond 5cb26ac3f9 Conditionalization of the debug flag moves to m4. 
Turned out to be mildly trick because %if/%endif pairs have push/pop
behavior rather than combining.

In generated code, the location of the debug declarations moves,
and that's all.

#34 in the retargeting patch series
 2020-09-23 22:21:03 -04:00
Eric S. Raymond c9ade3f92b Methodize whether fullspd mode can use a pointer table. 
Presently only C can do this.  Otherwise we fall through to storing
numeric indices for a tiny loss of performance.

No generated-code changes from this.

#33 in the retargeting patch series
 2020-09-23 19:49:31 -04:00
Eric S. Raymond ca94d99782 m4ize code generation associated with skel breakpoint 11.0. 
Moves one table initializer in the generated code, but doesn't alter
it.

Leaves one FIXME. The computation of M4_YYL_BASE really ought to be
done in m4, but for some unknown reason I couldn't beat it into
dping the right thing.  Do be revisited, bu right now finishing
off the last bits of code generation is more important.

#32 in the retargeting patch series
 2020-09-23 19:00:56 -04:00
Eric S. Raymond d45bd0692e Code formerly generated at skel breakpoint 8.0 goes to m4. 
No generated-code diffs from this change.

#31 in the retargeting patch series
 2020-09-23 19:00:56 -04:00
Eric S. Raymond 2eb82096a4 Move code generation of YY_DO_BEFORE_ACTION to m4. 
Generated-code diffs are blank lines with ] continuations and
shifted %% commends made by skel breakpoint directives.  I could garbage
collect those, but I plan to do that all at once in a commit of its
own for clarity's sake.

#30 in the retargeting patch series
 2020-09-23 19:00:56 -04:00
Eric S. Raymond d694cb8d3f Push C-generated code for YYINPUT to the m4 skeleton. 
Diffs in generated code are trivial, a couple of
blank lines with continuations due to % directives.

#29 in the retargeting patch series
 2020-09-23 11:24:11 -04:00
Eric S. Raymond 9cfe5b9b09 All the M4_MODE settings now live in one place where they can be audited. 
No changes in generated code.

#28 in the retargeting patch series
 2020-09-23 10:50:07 -04:00
Eric S. Raymond 0f2a58a818 Partial m4ization of nultrans code. 
Also, remove two insertion points in the skel file
that are no longer used because we're now using m4
conditionals instead.

In the generated C, two magic comments from the insertion points go
away.

#27 in the retargeting patch series
 2020-09-23 10:20:48 -04:00
Eric S. Raymond b101188a76 Push the definition of struct yy_trans_info out to m4. 
Required defining a new method table entry and shuffling the order in
which things are generated a bit, but the generated-code diffs are all
trivial.  Some comments from the previous C code are now in the
skeleton.

#26 in the retargeting patch series
 2020-09-22 20:52:58 -04:00
Eric S. Raymond d5574c7387 Banish gcc warnings so errors won't get lost in the clutter. 2020-09-22 18:44:26 -04:00
Eric S. Raymond feeba9873f Tie up loose ends in the abstraction of table initializer syntax... 
...and case statements.  Add guidance to backend.adoc.  This is the
"eventually" promised in the comment on #10 of this series.

No diffs in generated code.

#25 in the retargeting patch series
 2020-09-22 12:52:32 -04:00
Eric S. Raymond 9a501a4238 Replace last use of gen_next_compressed_state*( with equivalent m4... 
...and then inline the code of gen_NUL_trans() at its callsite.  This
contains all remaining procedural code generation in make_tables(),
on the way to moving it to m4.

Generated code diffs are like those of #20 and #22, for the same
reasons.  They add comments, whitespace changes, and uses of the
YY_NUL_EC and YY+JAMSTATE macros equivalent to the old numeric
literals.

#24 in the retargeting patch series
 2020-09-22 11:52:50 -04:00
Eric S. Raymond e7b3a67adf Code to do back-up for compressed tables and set up yy_cp goes to m4. 
Also, move the yymatch label to the skeleton. Remove an unused
prototype. And fix a typo.

In generated C, comment and whitespace changes only.

#23 in the retargeting patch series
 2020-09-22 10:59:30 -04:00
Eric S. Raymond 01f4aaddd9 gen_next_state(true) becomes m4 code. 
As with patch #20 in this series, the changes in generated code fall in the classes:

1. Addition of comments.  I elected to copy the comments from the
   generator functions into their corresponding m4 macros in hopes of
   making the generated code less nasty to read.

2. Lines like "if ( yy_current_state >= 12 )" changing so the numeric
   literal is replaced by YY_JAMSTATE + 1. This was a consequence of the
   change in #15 to simplify the C code generators so they could be
   translated into static nacros.

3. "YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : YY_NUL_EC);:
   being replaced by "YY_CHAR yy_c = (*yy_cp ?
   *(yy_ec+YY_SC_TO_UI(*yy_cp)) : YY_NUL_EC);" The strange way of
   indexing yy_ec avoids a syntactic collision with the use of [] as
   m4 quotes.

The gen_next_state(false) case was translated to m4 at patch #20

#22 in the retargeting patch series
 2020-09-22 10:51:23 -04:00
Eric S. Raymond e6fa974cd7 gen_bu_action() becomes m4 code. 
Also, two GEN_START_STATE calls get inlined in the skeleton file.

Changes in generated C from the tests are all comments and whitespace.

#21 in the retargeting patch series
 2020-09-22 06:08:10 -04:00
Eric S. Raymond 30788806b9 gen_next_match() becomes m4 code. 
To verify this patch, notice that the non-whitespace changes in the
generated C from the tests are of only three kinds:

1. Addition of comments.  I elected to copy the comments from the
generator functions into their corresponding m4 macros in hopes of
making the generated code less nasty to read.

2. Lines like "if ( yy_current_state >= 12 )" changing so the numeric
literal is replaced by YY_JAMSTATE + 1. This was a consequence of the
change in #15 to simplify the C code generators so they could be
translated into static nacros.

3. "YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]" being replaced by
"YY_CHAR yy_c = *(yy_ec+YY_SC_TO_UI(*yy_cp));".  The strange way of indexing yy_ec
avoids a syntactic collision with the use of [] as m4 quotes.

#20 in the retargeting patch series
 2020-09-22 04:47:05 -04:00
Eric S. Raymond 6711981a2d gen_backing_up() becomes an m4 macro. 
Generated-code changes consist of whitespace and a comment.

Thus patch also fixes the computation of two guard symbols
that weren't actually used yet, prospectively introduced in
patch #15 of this series. At the time I wrote that I didn't
understand what num_backing_up was doing and failed to
translate it properly.

#19 in the retargeting patch series
 2020-09-22 03:16:04 -04:00
Eric S. Raymond abe63d33d1 Push code generation for some housekeeping from gen.c to m4. 
The pieces are BOL checking, yylineno updating, and YY_RULE_SETUP
generation.

No generated code changes at all from this.

#18 in the retargeting patch series
 2020-09-22 01:32:40 -04:00
Eric S. Raymond feac8a6abf Clean up a couple of methodization loose ends. 
Generated-code differences are trivial whitespace.

#17 in the retargeting patch series
 2020-09-22 00:14:56 -04:00
Eric S. Raymond 2ab6a3baf7 Move debug code generation from C to m4. 
Differences in generated code are trivial. Some integer
literals turn into symbol expressions as a side effect
of the previous patch.

#16 in the retargeting patch series
 2020-09-21 23:04:50 -04:00
Eric S. Raymond 90bf7c7bcb Create m4 symbols for things that used to be generated as int literals. 
Changes the generated C sources from the tests, but only by making
them easier to read.  In future patches this is going to make them
easier to compare by eyeball as well.

#15 in the retargeting patch series
 2020-09-21 22:01:41 -04:00
Eric S. Raymond f858b63e23 Turn gen_start_state() into an M4 macro. 
This is the first patch in the retargeting series to substantively
modify the skeleton file.  (The only previous one to touch it just
renamed a mode switch.)

Adds some comments and whitespace to the generated code in the tests,
but produces no logic changes.

#14 in the retargeting patch series
 2020-09-21 17:11:29 -04:00
Eric S. Raymond 5f41ac5a99 Create a TESTOPTS variable that can be used to pass options to flex in testing. 
Presently this is used to pass -L, making it easier to compare changes
in generared C code cross revisions.

To perform such comparisons, do this at a base (before) revision:

# Make generated code
make clean; (cd tests; make clean); make check

# Save a smashot of it
rm -fr snapshot && mkdir snapshot && cp tests/*.c snapshot

Then rebuild at the later revision and do this:

# Compare gemerated code to snapshot
do diff -b -B -u $x tests/`basename $x`; done

#13 in the retargeting patch series
 2020-09-21 10:35:18 -04:00
Eric S. Raymond cd01f7ff4e Remove a redundant macro guard setting.... 
...and clean up some comments.

Removal should have happened in #11 when the
guard symbol was renamed.

#12 in the retargeting patch series
 2020-09-21 00:45:47 -04:00
Eric S. Raymond cdb639cd7b Add code to initialize the macro conditional symbols we'll need. 
These aren't used yet.  They will be as we push code feneration out
of gen.c into the epansion of the m4 skeleton.

This is the first revision to touch the C skeleton file, changing
M4_YY_USES_REJECT to M4_MODE_USES_REJECT for uniformity with the other
mode switches.

C code generated from the tests is still unchanged at this revision.

#11 in the retargeting patch series
 2020-09-21 00:21:42 -04:00
Eric S. Raymond ef4f78f43b Continue methodization, with some target-language-specific formats... 
...and one additional method.

This almost finushes off all language-specfic detauks outside of
gen.c.  The one exception is just below the comment "add terminator
for initialization" in dfa.c; we'll get to this eventually.

#10 in the retargeting patch series
 2020-09-21 00:05:05 -04:00
Eric S. Raymond c0ca7faab9 Two member name changes in the method table. 
Cosmetic change,

#9 in the retargeting patch series
 2020-09-20 23:17:00 -04:00
Eric S. Raymond e58cdd1de0 Start a HOWTO on writing target-language back ends. 
#8 in the retargeting patch series
 2020-09-20 22:38:31 -04:00
Eric S. Raymond 673f2caf34 Methodize generation of C initializers for automaton tables. 
A large patch, but conceptually simple. Takes a bunch of functions and
callsites that knew details of C initializer and declaration syntax
and moves them into methods in the C backend table.

This is a pure refactoring step.  At this point in the patch series,
not only do all tests pass but nothing in the lex-generated C code
from the tests has changed.

#7 in the retargeting patch series
 2020-09-20 21:55:07 -04:00
Eric S. Raymond 2cce209b58 The C/C++ back end moves to its own source file. 
Someday, there might be go-backend.c etc.

#6 in the retargeting patch series
 2020-09-20 20:52:01 -04:00
Eric S. Raymond bb9f458eb1 Generated skel data is now stuffed in an array in the C/C++ back end. 
This means it's possible to have multiple language-specific skel
files.  All go through the same double m4 macroexpansion.

#5 in the retargeting patch series
 2020-09-20 20:52:01 -04:00
Eric S. Raymond f754c608ff Pull the format for error-tracking lines into the method table. 
#4 in the retargeting patch series.
 2020-09-20 18:36:39 -04:00
Eric S. Raymond f1bfe65b3d Create a method table for the C back end, 
#3 in the retargeting patch series.
 2020-09-20 18:36:39 -04:00
Eric S. Raymond a05e39ae47 Factor out the wrap function for C/C++ parser generation. 
#2 in the retargeting patch series.
 2020-09-20 18:36:39 -04:00
Eric S. Raymond f0161f217e Refactoring step - separate output generation from option processing. 
#1 in the retargeting patch series.
 2020-09-20 18:36:39 -04:00
Joerg Sonnenberger a631f5da8d correct some indentation in skeleton 2020-04-24 12:06:24 -04:00
Will Estes 8b1fbf674f doc: document release page in README 2019-09-12 16:42:40 -04:00
Will Estes d3de49f842 doc: new translations 2019-06-20 14:05:30 -04:00
Explorer09 98018e3f58 scanner: Include-guard flexint_shared.h 
This prevents compiler's "redefinition of typedef" warnings or errors
when we could include flexint_shared.h twice, when building flex's own
scanner (scan.c) or in the "multiple_scanners" test in the testsuite.

(Depending on the compiler's flags this might or might not produce
errors, but it's good to guard it anyway.)

Fixes: #329

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-05-22 16:56:52 -04:00
jannick0 21121feec9 scanner: no YYTABLES_NAME macro unless requested 2018-05-22 16:51:26 -04:00
Will Estes 4c7e3a5a67 po: include update_linguas script in distribution. 
Since automake takes a hands off approach to the po/ directory, we
need to list update_linguas.sh in the top Makefile.am. We list it as a
dist_noinst_SCRIPT so that it will get distributed with executeable
permissions. We also list autogen.sh in the same way for the same
reason.
 2018-05-07 15:53:26 -04:00
viktor.shepel a752d7c1c2 doc: display build status badge in README 2018-05-07 14:58:48 -04:00
Simon Sobisch 60b578fdaa doc: describe mailing list usage in more detail 2018-04-07 13:26:34 -04:00
Jannick b33fd4c43a doc: amend manual section on state stack functions. 2018-03-13 10:45:56 -04:00
jannick0 3971b6146a scanner: fix default of yy_top_state() 
extend fix when `YY_G` is used (reentrant scanner).
 2018-03-13 10:45:42 -04:00
jannick0 67b3e44872 scanner: fix default of yy_top_state() 
For an _empty_ state stack the top of the state stack defaults to the state as if no state stack were present.

NB: sanity check for `yy_start_stack_ptr` could be added in `yy_top_state()`.
 2018-03-13 10:45:16 -04:00
Explorer09 6a6e69af76 build: Add "-f" flag to "mv" in makefiles. 
Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-12 10:34:36 +08:00
Explorer09 dcd8e8b401 build: Fix makefile dist-hook directory permissions. 
Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-12 10:15:31 +08:00
Explorer09 e1f6b4a263 scanner: More compatible flex integer type definitions. 
Visual C++ 2010 does not define __STDC_VERSION__, and (before Visual
C++ 2013) has <stdint.h> and not <inttypes.h>.

ANSI/ISO C only requires at least 16 bits for int type (not 32 bits as
required by POSIX since SUSv2), so check the bit length before the
typedef.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-08 16:00:24 -05:00
Explorer09 5574881ff4 scanner: Skeleton no longer includes integer limit macros. 
The [U]INT{8,16,32}_{MIN,MAX} macros are never used in skeleton code.
Having them in skeleton just increases the chance of conflicts in case
that user defines them in non-C99 environment (see issue #307, when
flex code is built in Visual C++ (before VS2013)).

flexint.h is now split in two files. Only "flexint_shared.h" will be
included in skeleton now, which defines flex integral types.
flexint.h contains integer limits macros that would be used in flex
only.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-08 16:00:24 -05:00
Explorer09 ec4f23d5d2 scanner: Add a fallback INT_MAX definition. 
Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-08 16:00:24 -05:00
Explorer09 1985bb3c7a scanner: correct comments about __STDC_LIMIT_MACROS. 
No code changes.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-08 16:00:24 -05:00
Explorer09 4081efa083 scanner: Fix glibc features.h dependency in skeleton. 
Commit a17d79e9c7 defines _POSIX_C_SOURCE
to the minimum of 1 if it's not defined in the user's scanner code or
the compiling environment. However in glibc the macros are not yet set
up until one of the libc headers is included. This unfortunately have
made us overwrite the default _POSIX_C_SOURCE value that would be
defined by glibc (200809L at the time of writing), causing regressions
in user code.

Now in this patch:
1. Ensure feature test macros have been set up in glibc before checking
or defining any of them in our skeleton code.
2. Have a more conservative logic when determining the need to define
_POSIX_C_SOURCE (required for fileno()).

Fixes: #313

Note:
It could be tricky for application code to ensure feature test macros
have been set up in glibc, since <features.h> is no portable header and
not meant to be included directly by applications. The way to do it is
to include a libc header which in turn includes <features.h>. However,
many of the glibc headers check __USE_POSIX (a glibc internal macro
defined if _POSIX_C_SOURCE is defined) and determine which interfaces
to expose already, making the headers inappropriate for our goal.
Those which don't depend on _POSIX_C_SOURCE, and are also available
since ANSI C89, are only <assert.h>, <errno.h> and <math.h>.

<assert.h> is finally favored due to other considerations:
- <math.h> check for __USE_XOPEN in glibc, making a dependency on
_XOPEN_SOURCE, besides it exposes much more interfaces than we need.
- In djgpp, <errno.h> depends on _POSIX_SOURCE to hide definitions of
some errno values when it's defined.
- <assert.h> exposes the fewest interfaces among the 3 headers and, at
the time of writing, checks for only C99 (for __func__), C11 (for
_Static_assert), and _GNU_SOURCE when needed.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-08 10:04:36 +08:00
Explorer09 d5023f5a48 scanner: Fix scan.l xgettext warnings. 
xgettext was not very clever at interpreting lex patterns and can get
confused when seeing unquoted quotation marks, and emit warnings for
them. Now fix the warnings by properly quoting the quotation marks in
lex regex patterns.

Example
    Original: \"[^"\n]*\" -> "warning: unterminated string literal"
    Fixed:    "\""[^""\n]*"\"" -> OK

My basic build test shows that the generated stage1scan.c is
bit-identical to the original.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-03-04 20:51:38 +08:00
Explorer09 e104f5589c travis: '--disable-acl' when building gettext 
This silences a configure warning about libacl not found in Travis
build log.
 2018-03-01 14:08:54 -05:00
Explorer09 6aa652b089 travis: Silence build output of automake and gettext 
Only when a build error occurs on building any of these dependent
packages do we dump some sensible logs to standard output.
 2018-03-01 14:08:54 -05:00
Kang-Che Sung e63c0bb6b6 travis: Hard-code hashes for verifying tarballs 
GPG signatures require an external keyserver which might be offline,
which is undesirable for build server use. It's equally secure to just
hard-code the hashes, provided they're trusted (i.e. you verify a hash
against a GPG signature once).

Fixes: #311.

As a side note: the original two signatures
(gettext-0.19.8.1.tar.lz.sig and automake-1.15.1.tar.gz.sig) are signed
against the files' SHA-1 hash.
 2018-03-01 14:08:54 -05:00
Explorer09 c42de062bb build: Move dnl comments out of AC_CHECK_FUNCS 
Due to a bug, autoheader (2.69) will treat M4 dnl comments in a quoted
argument of AC_CHECK_FUNCS as function tokens and generate a lot of
redundant and useless HAVE_* macros in config.h.in.
(Examples: HAVE_DNL, HAVE_AVAILABLE_, HAVE_BY)

It seems to be this commit dbb4e94dc7 of
mine that revealed this autoheader bug, and the affected config.h.in
had been shipped within flex-2.6.4 release tarball.

I have reported the autoheader bug here:
<https://lists.gnu.org/archive/html/bug-autoconf/2018-02/msg00005.html>

As a workaround, let's move comments out of AC_CHECK_FUNCS.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2018-02-28 19:30:56 -05:00
Explorer09 065c9fbe22 test: Remove redundant '-o $@' in tableopts.am 
$(LINK) in Automake already contains the '-o $@' arguments.
 2018-02-24 23:12:09 +08:00
Will Estes ff7bc8af46 doc: list travis in NEWS [skip ci] 2018-01-03 08:49:00 -05:00
Will Estes c0508df61d initial .travis.yml file 2018-01-03 08:49:00 -05:00
Explorer09 e7d45afc6a scanner: Allow "--" as option argument. 
Previously, invocations such as:

    flex --outfile -- wc1.l

 would fail with "requires an
argument" error message.

Fixes #285
 2017-12-09 16:29:52 -05:00
Explorer09 c984ab0fd0 scanner: scanopt_err() now returns void 2017-12-08 09:56:18 -05:00
Explorer09 aa775c8711 scanner: simplify scanopt_usage(). 
In-function macro CALC_LEN removed and no longer needed.

Local variable renames:

    maxlen[0] => opt_col_width

    maxlen[1] => desc_col_width

    indent now explicitly const
 2017-12-08 09:55:19 -05:00
Explorer09 23882383d4 scanner: prevent overflow in add_action() 2017-12-06 16:23:25 -05:00
Michael W. Bombardieri 08e1b25b0e scanner: use calloc to allocate new filter memory 2017-11-29 08:11:22 -05:00
Explorer09 87472f5aa7 Obsolete yypad64() macro. 
Slightly rewrite the logic in yytbl_data_load() and yytbl_write_pad64()
so they simply check if the bytes read/written are in 8-byte boundary.
No need to calculate how many bytes we need to pad. (Incidentally this
makes smaller code in x86_64.)

For yytbl_hdr_init(), just expand the calculation from the macro.
 2017-11-28 15:06:10 -05:00
Explorer09 12d2f86080 scanner: temporarily protect against ccl overflow & overwriting. 
For ccladd(), if cclp given is a non-last ccl, adding a char into it
will overflow the buffer and overwrite the first char in the next ccl.

For now, add a temporary detection and protection code.  (Not sure if
this could happen in user input, but if it could, then you can expect
some "corrupted" behavior for generated scanners.)
 2017-11-28 14:56:42 -05:00
Explorer09 ea1faa2d09 build: fix ENABLE_NLS preprocessor check. 
Because ENABLE_NLS may be defined to 0 (manually, not through
autoconf) and it's semantically incorrect to only check whether it's
defined.

This is a correction to commit
661d603b65.
 2017-11-28 14:09:04 -05:00
Explorer09 11b7512664 scanner: Rename genecs() local variables. No code changes. 2017-11-03 19:12:49 -04:00
Explorer09 3c0f34cf12 scanner: Remove unused BASENAME() macro. 
(Simply forgot to do so in commit fb731ac022)
 2017-11-03 18:41:16 -04:00
Alex Richardson 661d603b65 build: use #ifdef for ENABLE_NLS check. 
config.h will have either define ENABLE_NLS or not define it. If it is
not defined we get a -Wundef warning due to using #if with an
undefined macro
 2017-11-03 10:39:32 -04:00
Explorer09 a17d79e9c7 scanner: Define _POSIX_C_SOURCE when needed in skeleton. 
The function fileno() is defined by POSIX. When flex would otherwise not provide that feature macro, we define it.

Fixes #263
 2017-11-03 10:19:21 -04:00
Lukasz Baj 0db9f8903a build: Remove custom reallocarray() declaration. 
Use one from <stdlib.h> instead because that is more portable.
 2017-10-05 11:31:18 -04:00
Explorer09 37a6184dab scanner: Simplify PRINT_SPACES() macro 2017-10-05 11:27:54 -04:00
Explorer09 24fd055133 build: AC_USE_SYSTEM_EXTENSIONS in configure.ac. 
This would, e.g. define _GNU_SOURCE in config.h, enabling the
reallocarray() prototype in glibc 2.26+ on Linux systems with that
version of glibc.

Fixes #241.
 2017-09-04 11:22:30 -04:00
Will Estes 1d62d3eb24 doc: document config.h inclusion by flex itself 2017-09-03 21:25:57 -04:00
Explorer09 4b5111d977 scanner: Include flexdef.h at %top block of scan.l 
config.h may define macros that alter the API of the standard library
funtions, and so it should be included before any other standard
header, even before the skeleton's standard header inclusion.

For example: config.h may #define _GNU_SOURCE that would expose the
reallocarray() prototype from <stdlib.h> on glibc 2.26+ systems. If we
include <stdlib.h> before config.h, reallocarray() would not be
available for use in lex file since the second include doesn't help
due to header guard.

For now our config.h might `#define malloc rpl_malloc` -- this
substitution must work before including stdlib.h, or else the compiler
will complain about missing prototypes, and may result in incorrect
code in scan.l (gcc warning: return makes pointer from integer without
a cast [-Wint-conversion]).

Fixes #247.
 2017-09-03 21:17:59 -04:00
Explorer09 f2943389fd {re,}allocate_array code cleanup 2017-09-02 15:09:28 -04:00
Will Estes 71d3525ad2 doc: document libfl targets in Makefile 2017-09-02 15:07:52 -04:00
Explorer09 dd1afa37e1 build: Add convenience targets to build libfl only 
These are wrappers around automake- and libtool-generated targets,
allowing users to build libfl only, without the main flex program.

See GH-256 for discussion.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>
 2017-08-31 15:54:02 -04:00
Will Estes b84ad149c9 doc: document src/libfl in NEWS 2017-08-31 15:51:25 -04:00
Explorer09 08e19c55ca Don't install libfl.pc if --disable-libfl. 2017-08-27 00:18:44 +08:00
Explorer09 e199cb6bdf libfl.pc: Rewrite descriptions, remove unneeded Cflags. 
There's no need to include any header when linking with `-lfl`.
 2017-08-27 00:18:32 +08:00
Explorer09 7e06407175 Move libfl.pc.in to src subdirectory. 2017-08-27 00:17:57 +08:00
Will Estes 931d29bdea doc: NEWS updates 2017-08-24 09:26:02 -04:00
Explorer09 b115f389b2 Hardcode flex name in --help text 
Don't use program_name in the description of -T/--trace or -V/--version
option. It's ugly when user invokes flex with a long path like
"/home/username/tools/bin/my-custom-built-flex".

This solution is not long term. If possible, the help text should be
modified so that the "flex" name is no longer needed below the first
"Usage:" line. All translations of help text will need to be updated
as well.
 2017-08-24 08:34:23 -04:00
Explorer09 a657f0c6f5 Remove an unneeded gettext() in --version output 
"%s %s\n" is not translatable
 2017-08-24 08:34:23 -04:00
Explorer09 fb731ac022 scanner: remove BASENAME(); don't strip path from program_name 
There's no technical need of stripping path from program_name. I think
the users should be fine if they see the path they use to invoke flex
is diagnostic messages and help texts.

Yes, users will see "Usage: ../flex [OPTIONS]..." now if they invoke
flex with the path "../flex".

The --version output has been changed so that the name field will be
always "flex" or "flex++". If the flex program has been renamed to
"lex" (for compatibility or other reason) this will allow identifying
the implementation name ("flex"). (And it's a recommended practice in
GNU Coding Standards)
 2017-08-24 08:34:23 -04:00
Will Estes d64a5263cf build: sort .gitignore 2017-08-24 08:18:11 -04:00
Michael Haubenwallner 24e73c4446 have libobjs depend on libobjdir (#244) 2017-08-24 08:15:00 -04:00
Will Estes aa50a492fc build: git ignore libfl.pc 2017-08-24 08:02:19 -04:00
Tyler Slabinski c1ed5df2f6 Create libfl.pc target for pkgconfig 2017-08-24 07:52:13 -04:00
Jannick 535524ea6b scanner: #define BASENAME, remove #include libgen.h 2017-07-17 21:12:44 -04:00
Jannick 3f2b9a4d63 mkskel.sh: fix EOL issue for CRLF systems 2017-07-18 02:03:45 +02:00
jannick0 7af066b952 scanner: Ignore comment lines in skeleton files. 
In skeleton files comments are indicated by leading `%#` and when
directly read in using `flex -S <skeleton.skl>` they should be
ignored. Example: `flex.skl`.

Amending commit 2f21edac99 which removed
this conditional branch.
 2017-07-15 18:52:28 -04:00
Explorer09 e784a805ef filter: faster is_blank_line implementation 
Using regex_t regex_blank_line is *slow*.
 2017-07-15 18:31:41 -04:00
Explorer09 0f370436e1 filter: new internal function is_blank_line() 
It's simply to return (regexec(&regex_blank_line, str, 0, NULL, 0) == 0);
The reason for encapsulation is to allow replacing this with a
non-regex method if necessary.
 2017-07-13 15:15:29 -04:00
Will Estes 19cffb0ff0 build: require automake, gettext versions as per maintainer dev setup 2017-07-13 15:14:58 -04:00
Will Estes 36c2c0a2e8 doc: NEWS memory leak fix 2017-07-03 11:49:36 -04:00
viktor.shepel faa877a843 scanner: memory leak free scanner generator. 
**Issue:**
Scanner generation leaks memory for transition tables when invoked
without `--tables-file` option.

**Root cause:**
`gentabs` function has different memory acquire/release conditions.

**Solution:**
Reclaim memory at the same scope where it was alloacated.
 2017-07-03 11:45:55 -04:00
viktor.shepel 8a044dbe6d filter: memory leak free scanner postprocessing. 
**Issue:**
Scanner postprocessing leaks memory during correction of `#line`
directives values and generation of C header file.

**Root cause:**
`filter_fix_linedirs` and `filter_tee_header` functions do not
dispose allocated memory.

**Solution:**
Automatically reclaim affected memory by allocating it on stack
insted of heap. Stack allocation should not be a problem as its
only 512 bytes and there is no recursive calls.
 2017-07-03 11:45:37 -04:00
Will Estes ef32155253 doc: NEWS c{i,j} 2017-07-03 11:34:14 -04:00
NieDzejkob ea4b0a129e scanner: c{i,j} should preserve case. 
Fixes #193
 2017-07-03 11:34:00 -04:00
Will Estes 6bebb264a9 doc: document --backup-file in NEWS 2017-07-03 09:46:48 -04:00
EricSharkey c55bf919cc scanner: add optionn to specify backup filename. 
In a directory containing multiple scanners, we want to allow
specifying the name of the backup file else the backup files will be
overwritten.
 2017-07-03 09:41:42 -04:00
Will Estes 8bd14f1387 doc: new uk translation 2017-06-18 13:56:06 -04:00
Translation Project 90c62441b3 doc: new uk translation from the Translation Project 2017-06-18 13:55:11 -04:00
Explorer09 9e00f250f6 doc: formatting fixes in README 2017-06-04 16:20:04 -04:00
Explorer09 b4735d6925 test: echo 'set -v' before setting so in shell. 2017-06-04 16:15:23 -04:00
Will Estes 71b9c0cedc doc: tableopts rule portability mentioned in NEWS 2017-05-26 11:23:12 -04:00
Will Estes 2c0152a0c3 test: remove duplicate shell options line 2017-05-26 11:21:16 -04:00
Explorer09 1f3db3aeb3 test: use portable pattern substitution in tableopts.sh 
Fixes: #222
 2017-05-24 15:33:09 +08:00
Will Estes db4f5e0fe5 doc: document NetBSD build crash fix 2017-05-19 08:05:51 -04:00
Will Estes 2ae437ad54 build: remove automake check-news 2017-05-19 08:03:48 -04:00
Thomas Klausner 2b290d8ebd scanner: Use reallocarr() when available. 
NetBSD had a crash during build. Since the provided substitute for
reallocarray() wasn't working, use NetBSD's reallocarr(). Let
configure choose that function whenever it is available. Use
reallocarray if available. Still fallback if neither is available.

Fixes #219
 2017-05-19 07:29:15 -04:00
Will Estes 3a70bac04a doc: list line number directives in NEWS 2017-05-14 07:16:45 -04:00
Jeff Smith 2c7e34bb95 filter: Output correct #line value for current file. 
A #line pre-processor directive specifies the line number and source
file of the following lines. If the source file _is_ the current file,
the line number should be that of the line following the directive. So
the specified line number should be the current line number plus 1.
 2017-05-14 06:31:56 -04:00
Will Estes 596a221844 scanner: corrected typo 2017-05-13 17:24:55 -04:00
Will Estes 0be3198908 doc: noyyget/set_column options documented 2017-05-13 17:23:18 -04:00
Will Estes 5cadd124f8 scanner: finish support for noyy{get,set}_column. 
Unattributed patch carried over from sourceforge bug tracker.
 2017-05-13 15:15:45 -04:00
Will Estes 7284970311 build: .mailmap for cleaning up shortlog 2017-05-13 14:24:17 -04:00
Hans-Bernhard Broeker 2c3f463909 test: rename some files for non-case-sensitive filesystems. 
-C*f and -C*F option-specific test files collide on case-insensitive
file systems, and cause tests to either not be run at all, or to
overwrite each other's files at build time.  So rename -C*F ones to
-C*_F.
 2017-05-06 20:46:20 -04:00
Will Estes af72e9e222 build: 2.6.4 is previous version 2017-05-06 20:26:28 -04:00
Will Estes 385766c5cf build: ignore .sig files. 
We generate gpg signatures in place for releases. Since these should
not be tracked in the flex repo itself, we tell git to ignore them.
 2017-05-06 16:54:54 -04:00
Will Estes 5dfc45ef5a build: no longer ignore *.tar.bz2 
Since we no longer generate *.tar.bz2 archives, we do not need to tell
git to ignore them.
 2017-05-06 16:53:14 -04:00
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
79 changed files with 12470 additions and 7620 deletions
Expand all files Collapse all files
.gitignore
+3 -3
View File
@@ -1,6 +1,6 @@
*.orig
*.rej
*.tar.bz2
*.sig
*.tar.gz
*.tar.lz
*~
@@ -14,12 +14,12 @@ Makefile.in
aclocal.m4
autom4te.cache
autoscan.log
build-aux/
config.log
config.status
configure
configure.scan
flex-*/
libtool
stamp-*
m4/
build-aux/
stamp-*
.mailmap
+50
View File
@@ -0,0 +1,50 @@
Aaron Stone <sodabrew@users.sourceforge.net>
Akim Demaille <akim@lrde.epita.fr>
Alastair Hughes <hobbitalastair@gmail.com>
Alex Kennedy <alexzanderkennedy@gmail.com>
Alexis La Goutte <alexis.lagoutte@gmail.com>
Bastian Köcher <git@kchr.de>
Christoph Junghans <ottxor@gentoo.org>
Christos Zoulas <christos@zoulas.com>
Cyril Brulebois <kibi@debian.org>
Demi Obenour <demiobenour@gmail.com>
Dennis Clarke <dclarke@blastwave.org>
Egor Pugin <egor.pugin@gmail.com>
Elias Pipping <pipping@users.sourceforge.net>
Explorer09 <explorer09@gmail.com>
Hans-Bernhard Broeker <HBBroeker@T-Online.de>
Harald van Dijk <harald@gigawatt.nl>
Hugh Sasse <hgs@dmu.ac.uk>
Jaska Uimonen <jaska.uimonen@helsinki.fi>
Jeff Smith <whydoubt@gmail.com>
John Millaway <john43@users.sourceforge.net>
Manoj Srivastava <srivasta@golden-gryphon.com>
Mariusz Pluciński <mplucinski@mplucinski.com>
Michael Haubenwallner <michael.haubenwallner@ssi-schaefer.com>
Michael McConville <mmcconville@mykolab.com> <mmcco@mykolab.com>
Michael Reed <m.reed@mykolab.com>
Michael van Elst <mlelstv@NetBSD.org>
Mightyjo <mightyjo@gmail.com>
Mike Frysinger <vapier@gentoo.org>
OBATA Akio <obache@NetBSD.org>
Robert Larice <Robert.Larice@t-online.de> rlar <rlar>
Robert Larice <Robert.Larice@t-online.de> Robert.Larice Robert Larice <Robert.Larice@t-online.de>
Robert Minsk <rminsk@users.sourceforge.net>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Sean McBride <sean@rogue-research.com>
Serguey Parkhomovsky <sergueyparkhomovsky@gmail.com> <xindigo@gmail.com>
Simon Sobisch <simonsobisch@web.de>
Stefan Reinauer <stefan.reinauer@coreboot.org>
Thomas Klausner <wiz@NetBSD.org>
Till Varoquaux <till.varoquaux@gmail.com>
Tobias Klauser <tklauser@distanz.ch>
Todd C. Miller <Todd.Miller@courtesan.com>
Translation Project <coordinator@translationproject.org> <coordinators@translationproject.org>
Translation Project <coordinator@translationproject.org> <translation@translationproject.org>
Vern Paxson <vern@ee.lbl.gov>
Will Estes <westes575@gmail.com> <wlestes@users.sourceforge.net>
Yuri <yuri@tsoft.com>
luistung <dongliang1986@gmail.com>
lukeallardyce <lukeallardyce@users.sourceforge.net>
nomis52 <nomis52@users.sourceforge.net>
viktor.shepel <shepelvictor@bigmir.net>
.prev-version
+1
View File
@@ -0,0 +1 @@
2.6.4
.travis.yml
+24
View File
@@ -0,0 +1,24 @@
language: c
compiler:
- gcc
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- autoconf
- bison
- gcc-6
- help2man
- lzip
- texinfo
- texlive
before_script:
- ./.travis/install-gettext.sh
- ./.travis/install-automake.sh
- export PATH=$HOME/bin:$PATH
script: ./autogen.sh && ./configure && make && make check && make distcheck
.travis/install-automake.sh
Executable
+24
View File
@@ -0,0 +1,24 @@
#!/bin/bash -ex
wget -nv https://ftp.gnu.org/gnu/automake/automake-1.15.1.tar.gz
# Verify tarball against hard-coded hashes. GPG signatures require an external
# keyserver which might be offline, which is undesirable for build server use.
# It's equally secure to just hard-code hashes, provided they're trusted (i.e.
# you verify a hash against a GPG signature once).
echo 'd3cd5fc9bbea9f977b51799180cde5d253dcba96 *automake-1.15.1.tar.gz'|
sha1sum -c || :
printf '%s *automake-1.15.1.tar.gz\n' \
f0d4717ebe2c76cec5d487de090f6e1c0f784b0d382fd964ffa846287e2a364a\
52531a26ab98b7033ac04ed302a247b3b114299def54819a03439bfc962ff61b|
sha512sum -c || :
tar xf automake-1.15.1.tar.gz
cd automake-1.15.1
# Don't flood Travis CI build log with dependency packages unless error occurs.
./configure --quiet --prefix="$HOME" ||
{ s=$? && cat config.log && (exit $s); }
make -s V=0 >/dev/null 2>&1 || make -s V=1
make -s install >make_install.log 2>&1 ||
{ s=$? && cat make_install.log && (exit $s); }
rm make_install.log || :
.travis/install-gettext.sh
Executable
+25
View File
@@ -0,0 +1,25 @@
#!/bin/bash -ex
wget -nv https://ftp.gnu.org/gnu/gettext/gettext-0.19.8.1.tar.lz
# Verify tarball against hard-coded hashes. GPG signatures require an external
# keyserver which might be offline, which is undesirable for build server use.
# It's equally secure to just hard-code hashes, provided they're trusted (i.e.
# you verify a hash against a GPG signature once).
echo '404e072c455f79be4a2458863c19fb55a217771e *gettext-0.19.8.1.tar.lz'|
sha1sum -c || :
printf '%s *gettext-0.19.8.1.tar.lz\n' \
27c7a15be1ffd30a0182e264d0bf896850a295160872e1b1b9d1e9a15bc486cd\
93465c131f948206fa0bbe2e3eacfc8489dd0cfc5ea5dcf05eff3829e27fc60f|
sha512sum -c || :
tar xf gettext-0.19.8.1.tar.lz
cd gettext-0.19.8.1
# Don't flood Travis CI build log with dependency packages unless error occurs.
# libacl is not used in this Travis build system.
./configure --quiet --prefix="$HOME" --disable-acl ||
{ s=$? && cat config.log && (exit $s); }
make -s V=0 >/dev/null 2>&1 || make -s V=1
make -s install >make_install.log 2>&1 ||
{ s=$? && cat make_install.log && (exit $s); }
rm make_install.log || :
Makefile.am
+33 -5
View File
@@ -29,7 +29,6 @@
# to DEFS.
ACLOCAL_AMFLAGS = -I m4
indent = @INDENT@
dist_doc_DATA = \
AUTHORS \
@@ -39,11 +38,13 @@ dist_doc_DATA = \
README.md
EXTRA_DIST = \
.indent.pro \
autogen.sh
.indent.pro
dist_noinst_SCRIPTS = \
autogen.sh \
po/update_linguas.sh
SUBDIRS = \
lib \
src \
doc \
examples \
@@ -51,6 +52,29 @@ SUBDIRS = \
tests \
tools
# Convenience targets to build libfl only
# These are actually wrappers around automake- and libtool-generated targets
libfl:
cd src && $(MAKE) $(AM_MAKEFLAGS) libfl.la libfl.pc
install-libfl:
cd src && \
$(MAKE) $(AM_MAKEFLAGS) lib_LTLIBRARIES=libfl.la \
pkgconfig_DATA=libfl.pc install-libLTLIBRARIES install-pkgconfigDATA
uninstall-libfl:
cd src && \
$(MAKE) $(AM_MAKEFLAGS) \
lib_LTLIBRARIES=libfl.la pkgconfig_DATA=libfl.pc \
uninstall-libLTLIBRARIES uninstall-pkgconfigDATA
# libfl.pc is cleaned via 'distclean' target
clean-libfl:
cd src && \
$(MAKE) $(AM_MAKEFLAGS) lib_LTLIBRARIES=libfl.la clean-libLTLIBRARIES \
clean-libtool
# Create the ChangeLog, but only if we're inside a git working directory
ChangeLog: $(srcdir)/tools/git2cl
@@ -58,8 +82,12 @@ 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: libfl install-libfl uninstall-libfl clean-libfl \
ChangeLog indent
NEWS
+116 -4
View File
@@ -1,9 +1,119 @@
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 ?.? (????-??-??) [?]
* version 2.6.3 released 2016-12-30
** build
*** Flex now includes its own <config.h> header before including
system headers so that any system specific features detected by
configure are taken into account during compilation of flex
itself.
*** The flex build system now includes Makefile targets at the top
level to allow just building and installing libfl.
*** The flex distribution now includes a file, src/libfl.pc, to allow
using pkgconfig to find out what flags to use when building
against libfl from flex.
*** Various edge cases, mostly involving out-of-tree builds have been
accounted for in the autotools build system.
*** A crash during building on NetBSD has been fixed.
*** Flex is now automatically built by travis-ci. That should increase
the visibility of bugs and help prevent regressions.
** documentation
*** new bg, pt, uk translations from the translation project
** scanner
*** Some memory leaks have been fixed.
*** A long standing bug that effected expressions of the form c{i,j}
where 'c' is a character and {i,j} describes the number of times
to match against 'c' when case sensitivity was turned on has been
fixed.
*** New option: --backup-file allows setting the name of the file
written containing backing up information. Useful if you need
backing up information from multiple scanners in the same
directory.
*** flex emits correct line number directives when line numbers refer
to the file containing the line number directives.
*** The options {no,}yy{get,set}_column are now supported.
** test
*** Generating the various tableoptions make rules is now more portable.
*** Tests of the options -C*f and -C*F will now run correctly on
filesystems that are not case sensitive.
* Noteworthy changes in release 2.6.4 (2017-05-06) [stable]
** 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
@@ -682,6 +792,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
README.md
+12 -7
View File
@@ -1,10 +1,12 @@
[![Build Status](https://travis-ci.org/westes/flex.svg?branch=master)](https://travis-ci.org/westes/flex)
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)
[Git on GitHub.](https://github.com/westes/flex) Source releases of flex with some intermediate files already built can be found on [the github releases page.](https://github.com/westes/flex/releases)
Use GitHub's [issues](https://github.com/westes/flex/issues) and
[pull request](https://github.com/westes/flex) features to file bugs
@@ -19,9 +21,10 @@ There are several mailing lists available as well:
* 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
Find information on subscribing to the mailing lists or search in the
archive at: https://sourceforge.net/p/flex/mailman/
Note: Posting is only allowed from addresses that are subscribed to
the lists.
The flex distribution contains the following files which may be of
interest:
@@ -33,7 +36,7 @@ interest:
* 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
few other things. See the file examples/README for more
details.
* tests/ - regression tests. See TESTS/README for details.
* po/ - internationalization support files.
@@ -43,7 +46,7 @@ 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
* 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
@@ -74,12 +77,14 @@ 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:
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
autogen.sh
+20 -2
View File
@@ -24,10 +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
libtoolize --install --force || glibtoolize --install --force
if ! test -f ChangeLog; then
touch ChangeLog
fi
"$LIBTOOLIZE" --install --force
autoreconf --install --force
configure.ac
+44 -37
View File
@@ -24,11 +24,13 @@
# autoconf requirements and initialization
AC_INIT([the fast lexical analyser generator],[2.6.3],[flex-help@lists.sourceforge.net],[flex])
AC_INIT([the fast lexical analyser generator],[2.6.4],[flex-help@lists.sourceforge.net],[flex])
AC_PREREQ([2.60])
AC_CONFIG_SRCDIR([src/scan.l])
AC_CONFIG_AUX_DIR([build-aux])
AC_USE_SYSTEM_EXTENSIONS
LT_INIT
AM_INIT_AUTOMAKE([-Wno-portability foreign check-news std-options dist-lzip parallel-tests subdir-objects 1.14.1])
AM_INIT_AUTOMAKE([1.15 -Wno-portability foreign std-options dist-lzip parallel-tests subdir-objects])
AC_CONFIG_HEADER([src/config.h])
AC_CONFIG_LIBOBJ_DIR([lib])
AC_CONFIG_MACRO_DIR([m4])
@@ -38,16 +40,25 @@ AC_SUBST(SHARED_VERSION_INFO)
# checks for programs
AM_GNU_GETTEXT([external])
AM_GNU_GETTEXT_VERSION([0.19])
AM_GNU_GETTEXT_VERSION([0.19.7])
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
pkgconfigdir=${libdir}/pkgconfig
AC_SUBST(pkgconfigdir)
# allow passing a variable `WARNINGFLAGS',
# either when invoking `configure', or when invoking `make'
# default to something useful if GCC was detected
@@ -75,11 +86,7 @@ AC_ARG_ENABLE([bootstrap],
[], [enable_bootstrap=yes])
AM_CONDITIONAL([ENABLE_BOOTSTRAP], [test "x$enable_bootstrap" = xyes])
AC_PATH_PROG([BISON], bison, no)
AS_IF([test "$BISON" != no],[],
[ AC_SUBST([BISON], [\${top_srcdir}/build-aux/missing bison])
AC_MSG_NOTICE(no bison program found: only required for maintainers)
])
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"],
@@ -102,23 +109,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_CHECK_HEADERS([inttypes.h libintl.h limits.h locale.h malloc.h netinet/in.h regex.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
@@ -126,12 +130,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)
@@ -154,16 +158,19 @@ AC_FUNC_REALLOC
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
pow dnl
regcomp dnl
setlocale dnl
strchr dnl
strdup dnl
strtol)
dnl Autoheader (<= 2.69) bug: "dnl" comments in a quoted argument of
dnl AC_CHECK_FUNCS will expand wierdly in config.h.in.
dnl (https://lists.gnu.org/archive/html/bug-autoconf/2018-02/msg00005.html)
AC_REPLACE_FUNCS(reallocarray)
AC_CHECK_FUNCS([dup2 memset regcomp strcasecmp strchr strdup strtol], [],
[AC_MSG_ERROR(required library function not found on your system)])
# Optional library functions:
# pow - Used only by "examples/manual/expr".
# setlocale - Needed only if NLS is enabled.
# reallocarr - NetBSD function. Use reallocarray if not available.
# reallocarray - OpenBSD function. We have replacement if not available.
AC_CHECK_FUNCS([pow setlocale reallocarr reallocarray])
AC_CONFIG_FILES(
Makefile
@@ -171,8 +178,8 @@ doc/Makefile
examples/Makefile
examples/fastwc/Makefile
examples/manual/Makefile
lib/Makefile
po/Makefile.in
src/libfl.pc
src/Makefile
tools/Makefile
tests/Makefile
doc/Makefile.am
+4 -22
View File
@@ -1,32 +1,14 @@
help2man = @HELP2MAN@
FLEX = $(top_builddir)/src/flex$(EXEEXT)
info_TEXINFOS = flex.texi
dist_man_MANS = flex.1
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
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 \
flex.1: $(top_srcdir)/configure.ac $(top_srcdir)/src/cpp-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 $@
doc/flex.texi
+129 -11
View File
@@ -192,7 +192,7 @@ FAQ
* How can I build a two-pass scanner?::
* How do I match any string not matched in the preceding rules?::
* I am trying to port code from AT&T lex that uses yysptr and yysbuf.::
* Is there a way to make flex treat NULL like a regular character?::
* Is there a way to make flex treat NUL like a regular character?::
* Whenever flex can not match the input it says "flex scanner jammed".::
* Why doesn't flex have non-greedy operators like perl does?::
* Memory leak - 16386 bytes allocated by malloc.::
@@ -269,6 +269,7 @@ Appendices
* Bison Bridge::
* M4 Dependency::
* Common Patterns::
* Adding More Target Languages
Indices
@@ -734,7 +735,7 @@ if X is @samp{a}, @samp{b}, @samp{f}, @samp{n}, @samp{r}, @samp{t}, or
@samp{v}, then the ANSI-C interpretation of @samp{\x}. Otherwise, a
literal @samp{X} (used to escape operators such as @samp{*})
@cindex NULL character in patterns, syntax of
@cindex NUL character in patterns, syntax of
@item \0
a NUL character (ASCII code 0)
@@ -1978,15 +1979,23 @@ as though you had used
@deftypefun void yy_pop_state ()
pops the top of the stack and switches to it via
@code{BEGIN}.
The program execution aborts, if there is no state on the stack.
@end deftypefun
@deftypefun int yy_top_state ()
returns the top of the stack without altering the stack's contents.
returns the top of the stack without altering the stack's contents
if a top state on the stack exists or the current state via
@code{YY_START}
otherwise.
@end deftypefun
@cindex memory, for start condition stacks
The start condition stack grows dynamically and so has no built-in size
limitation. If memory is exhausted, program execution aborts.
The stack is not automatically reset. The function
@code{yylex_destroy}
should be called to reset and destroy the state stack which then frees
other resources used by the scanner.
To use start condition stacks, your scanner must include a @code{%option
stack} directive (@pxref{Scanner Options}).
@@ -2182,7 +2191,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();
}
@@ -5140,10 +5149,10 @@ the version of flex that was used to create the serialized tables.
@item th_name[]
Contains the name of this table set. The default is @samp{yytables},
and is prefixed accordingly, e.g., @samp{footables}. Must be NULL-terminated.
and is prefixed accordingly, e.g., @samp{footables}. Must be NUL-terminated.
@item th_pad64[]
Zero or more NULL bytes, padding the entire header to the next 64-bit boundary
Zero or more NUL bytes, padding the entire header to the next 64-bit boundary
as calculated from the beginning of the header.
@end table
@@ -5231,7 +5240,7 @@ The table data. This array may be a one- or two-dimensional array, of type
@code{td_flags}, @code{td_hilen}, and @code{td_lolen} fields.
@item td_pad64[]
Zero or more NULL bytes, padding the entire table to the next 64-bit boundary as
Zero or more NUL bytes, padding the entire table to the next 64-bit boundary as
calculated from the beginning of this table.
@end table
@@ -5439,7 +5448,7 @@ publish them here.
* How can I build a two-pass scanner?::
* How do I match any string not matched in the preceding rules?::
* I am trying to port code from AT&T lex that uses yysptr and yysbuf.::
* Is there a way to make flex treat NULL like a regular character?::
* Is there a way to make flex treat NUL like a regular character?::
* Whenever flex can not match the input it says "flex scanner jammed".::
* Why doesn't flex have non-greedy operators like perl does?::
* Memory leak - 16386 bytes allocated by malloc.::
@@ -6052,8 +6061,8 @@ what they're doing, and then replace @code{input()} with an appropriate definiti
@code{YY_INPUT}. You shouldn't need to (and must not) replace
@code{flex}'s @code{unput()} function.
@node Is there a way to make flex treat NULL like a regular character?
@unnumberedsec Is there a way to make flex treat NULL like a regular character?
@node Is there a way to make flex treat NUL like a regular character?
@unnumberedsec Is there a way to make flex treat NUL like a regular character?
Yes, @samp{\0} and @samp{\x00} should both do the trick. Perhaps you have an ancient
version of @code{flex}. The latest release is version @value{VERSION}.
@@ -7689,6 +7698,7 @@ to declare local variables.
@end example
@c TODO: Evaluate this faq.
@c Note that the file is now named cpp-flex.skl
@node unnamed-faq-87
@unnumberedsec unnamed-faq-87
@example
@@ -8158,6 +8168,7 @@ See @ref{Top, , , bison, the GNU Bison Manual}.
* Bison Bridge::
* M4 Dependency::
* Common Patterns::
* Retargeting Flex::
@end menu
@node Makefiles and Flex, Bison Bridge, Appendices, Appendices
@@ -8404,7 +8415,7 @@ removing such sequences from your code.
@code{m4} is only required at the time you run @code{flex}. The generated
scanner is ordinary C or C++, and does @emph{not} require @code{m4}.
@node Common Patterns, ,M4 Dependency, Appendices
@node Common Patterns,Retargeting Flex,M4 Dependency, Appendices
@section Common Patterns
@cindex patterns, common
@@ -8552,6 +8563,113 @@ to appear in a URI, including spaces and control characters. See
@end table
@node Retargeting Flex, ,Common Patterns, Appendices
@section Retargeting Flex
@cindex retargeting
@cindex language independence
This appendix describes how to add support for a new target language
to Flex.
The flex code has been factored to isolate knowledge of the specifics
of each target language from the logic for building the lexer state
tables.
The only assumption that is absolutely baked into all of Flex is that
the bodies of initializers for arrays of integers consist of decimal
numeric literals separated by commas (and optional whitespace).
Otherwise, knowledge of each target langage's syntax lives in two
places: (1) a table of language-specific syntax-generator methods,
and (2) A language-specific skeleton file.
For example: The methods for the C and C++ back end live in a source
file named @file{cpp_backend.c} (so named because both languages use the C
preprocessor), and in a skeleton file named @file{cpp-flex.skl}.
All the code that accesses language-specific code generators goes
through a global pointer named "backend" to a method table. The
results of these generators are used to fill in some parts of the
language-specific skeleton file and conditionalize others.
Read the definition of struct backend_t in @file{src/flexdefs.h}, and
attached comments, to get a feel for the methods. Don't worry
about understandng table generator names at first.
To write support for a language, you'll want to do the following
steps:
@enumerate
@item
Clone one of the existing back-end/skeleton pairs. If the language
you are supporting is named @var{foo}, you should create files named
@file{foo_backend.c} and @file{foo-flex.skl}.
@item
Add @file{foo_backend.c} to COMMON_SOURCES in @file{src/Makefile.am}. Add the
name of your skeleton file to EXTRA_DIST.
@item
Add a production to @file{src/Makefile.am} parallel to the one that
produces @file{cpp-skel.h}. Your objective is to make a string list
initializer from your skeleton file that can be linked with flex and
is pointed at by the skel nember of your language back end.
@item
Add some logic to @file{main.c} that enables the new back end with a
new command-line option. Following this step you should be
able to run Flex on a specification and get code out in the
language of whatever back end you cloned.
@item
The interesting part: mutate your new back end and skeleton so they
produce code in your desired target langage.
@item
Add a test suite for your back end. You should be able to clone
one of the existing sets of test loads to get good coverage. Note
that is highly unlikely your back end will be accepted into the
flex distribution without a test suite.
@end enumerate
Syntactically C-like languages such as Go, Rust, and Java should be easy
targets. Almost anything generally descended from Algol shouldn't be
much more difficult; this certainly includes the whole
Pascal/Modula/Oberon family.
A hint about the interesting part:
@itemize
@item
Don't bother supporting non-reentrant parser generation.
The interface of original Lex with all those globals hanging out
needs to be supported in C for backwards compatibility, but
there is no need to carry it forward.
@end itemize
The following assumptions in the code might trip you up and
require fixes outside a back end.
@enumerate
@item
The item separator in data initializers is a comma.
@item
The language has a case-arm syntax that looks like
a (possibly empty) prefix, followed by a value
expression, followed by a colon.
@item
Either case arms can be stacked as in C; that is, there is
an implicit fallthrough if the case arm has no code. Or,
there is an explicit fallthrough keyword that enables this,
as in Go.
@end enumerate
By putting a @code{yyterminate()} call in the fallthrough member
and a null pointer in the endcase member, you could handle
languages like Pascal.
@node Indices, , Appendices, Top
@unnumbered Indices
lib/Makefile.am
-3
View File
@@ -1,3 +0,0 @@
# Files in the lib/ subdirectory are picked up as needed by the flex
# build system. As such, we don't need to specify anything beyond
# having a Makefile.am for automake to generate a Makefile.in from.
lib/reallocarray.c
-49
View File
@@ -1,49 +0,0 @@
/* $OpenBSD: reallocarray.c,v 1.2 2014/12/08 03:45:00 bcook Exp $ */
/*
* Copyright (c) 2008 Otto Moerbeek <otto@drijf.net>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* OPENBSD ORIGINAL: lib/libc/stdlib/reallocarray.c */
#include <config.h>
#ifndef HAVE_REALLOCARRAY
#undef reallocarray
#include <sys/types.h>
#include <errno.h>
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#include <stdlib.h>
void *reallocarray(void *, size_t, size_t);
/*
* This is sqrt(SIZE_MAX+1), as s1*s2 <= SIZE_MAX
* if both s1 < MUL_NO_OVERFLOW and s2 < MUL_NO_OVERFLOW
*/
#define MUL_NO_OVERFLOW ((size_t)1 << (sizeof(size_t) * 4))
void *
reallocarray(void *optr, size_t nmemb, size_t size)
{
if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) &&
nmemb > 0 && SIZE_MAX / nmemb < size) {
errno = ENOMEM;
return NULL;
}
return realloc(optr, size * nmemb);
}
#endif /* HAVE_REALLOCARRAY */
m4/ax_prog_cc_for_build.m4
+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
])
po/LINGUAS
+2 -23
View File
@@ -1,23 +1,2 @@
ca
da
de
en@quot
en@boldquot
eo
es
fi
fr
ga
hr
ko
nl
pl
pt_BR
ro
ru
sr
sv
tr
vi
zh_CN
zh_TW
# List of available languages.
bg ca da de en@boldquot en@quot eo es fi fr ga hr ko nl pl pt pt_BR ro ru sr sv tr uk vi zh_CN zh_TW
po/Makevars
+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
po/Rules-getpo
-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
po/bg.po
+932
View File
@@ -0,0 +1,932 @@
# Bulgarian translation of flex po-file.
# Copyright (C) 2019 The Flex Project (msgids)
# This file is distributed under the same license as the flex package.
# Alexander Shopov <ash@kambanaria.org>, 2019.
msgid ""
msgstr ""
"Project-Id-Version: flex 2.5.38\n"
"Report-Msgid-Bugs-To: flex-devel@lists.sourceforge.net\n"
"POT-Creation-Date: 2014-02-11 16:15-0500\n"
"PO-Revision-Date: 2019-06-20 18:39+0200\n"
"Last-Translator: Alexander Shopov <ash@kambanaria.org>\n"
"Language-Team: Bulgarian <dict@ludost.net>\n"
"Language: bg\n"
"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=2; plural=(n != 1);\n"
#: buf.c:78
msgid "Allocation of buffer to print string failed"
msgstr "Неуспешно заделяне на буфер за отпечатване на низ"
#: buf.c:100
msgid "Allocation of buffer for line directive failed"
msgstr "Неуспешно заделяне на буфер за редова директива"
#: buf.c:177
msgid "Allocation of buffer for m4 def failed"
msgstr "Неуспешно заделяне на буфер за добавяне на дефиниция за „m4“"
#: buf.c:197
msgid "Allocation of buffer for m4 undef failed"
msgstr "Неуспешно заделяне на буфер за премахване на дефиниция за „m4“"
#: dfa.c:61
#, c-format
msgid "State #%d is non-accepting -\n"
msgstr "Състояние №%d не приема —\n"
#: dfa.c:124
msgid "dangerous trailing context"
msgstr "опасен последващ контекст"
#: dfa.c:166
#, c-format
msgid " associated rule line numbers:"
msgstr " номера на редове на съответното правило:"
#: dfa.c:202
#, c-format
msgid " out-transitions: "
msgstr " изходни преходи: "
#: dfa.c:210
#, c-format
msgid ""
"\n"
" jam-transitions: EOF "
msgstr ""
"\n"
" същински преходи: край на файл"
#: dfa.c:341
msgid "consistency check failed in epsclosure()"
msgstr "неуспешна проверка за консистентност в „epsclosure()“"
#: dfa.c:429
msgid ""
"\n"
"\n"
"DFA Dump:\n"
"\n"
msgstr ""
"\n"
"\n"
"Извеждане на ДКА:\n"
"\n"
#: dfa.c:604
msgid "could not create unique end-of-buffer state"
msgstr "уникалното състояние за край на буфер не може да се създаде"
#: dfa.c:625
#, c-format
msgid "state # %d:\n"
msgstr "състояние №%d:\n"
#: dfa.c:785
msgid "Could not write yynxt_tbl[][]"
msgstr "„yynxt_tbl[][]“ не може да се запише"
#: dfa.c:1049
msgid "bad transition character detected in sympartition()"
msgstr "в „sympartition()“ има неправилен знак за преход"
#: gen.c:478
msgid ""
"\n"
"\n"
"Equivalence Classes:\n"
"\n"
msgstr ""
"\n"
"\n"
"Класове на еквивалентност:\n"
"\n"
#: gen.c:662 gen.c:691 gen.c:1215
#, c-format
msgid "state # %d accepts: [%d]\n"
msgstr "състояние №%d приема: [%d]\n"
#: gen.c:1110
#, c-format
msgid "state # %d accepts: "
msgstr "състояние №%d приема: "
#: gen.c:1157
msgid "Could not write yyacclist_tbl"
msgstr "„yyacclist_tbl“ не може да се запише"
#: gen.c:1233
msgid "Could not write yyacc_tbl"
msgstr "„yyacc_tbl“ не може да се запише"
#: gen.c:1248 gen.c:1633 gen.c:1656
msgid "Could not write ecstbl"
msgstr "„ecstbl“ не може да се запише"
#: gen.c:1271
msgid ""
"\n"
"\n"
"Meta-Equivalence Classes:\n"
msgstr ""
"\n"
"\n"
"Класове за мета-еквивалентност:\n"
#: gen.c:1293
msgid "Could not write yymeta_tbl"
msgstr "„yymeta_tbl“ не може да се запише"
#: gen.c:1354
msgid "Could not write yybase_tbl"
msgstr "„yybase_tbl“ не може да се запише"
#: gen.c:1388
msgid "Could not write yydef_tbl"
msgstr "„yydef_tbl“ не може да се запише"
#: gen.c:1428
msgid "Could not write yynxt_tbl"
msgstr "„yynxt_tbl“ не може да се запише"
#: gen.c:1464
msgid "Could not write yychk_tbl"
msgstr "„yychk_tbl“ не може да се запише"
#: gen.c:1618 gen.c:1647
msgid "Could not write ftbl"
msgstr "„ftbl“ не може да се запише"
#: gen.c:1624
msgid "Could not write ssltbl"
msgstr "„ssltbl“ не може да се запише"
#: gen.c:1675
msgid "Could not write eoltbl"
msgstr "„eoltbl“ не може да се запише"
#: gen.c:1735
msgid "Could not write yynultrans_tbl"
msgstr "„yynultrans_tbl“ не може да се запише"
#: main.c:191
msgid "rule cannot be matched"
msgstr "правилото не напасва"
#: main.c:196
msgid "-s option given but default rule can be matched"
msgstr "зададена е опцията „-s“, но стандартното правило напасва"
#: main.c:236
msgid "Can't use -+ with -l option"
msgstr "опциите „-+“ и „-l“ са несъвместими"
#: main.c:239
msgid "Can't use -f or -F with -l option"
msgstr "опциите „-f“/„-F“ и „-l“ са несъвместими"
#: main.c:243
msgid "Can't use --reentrant or --bison-bridge with -l option"
msgstr "опциите „--reentrant“/„--bison-bridge“ и „-l“ са несъвместими"
#: main.c:275
msgid "-Cf/-CF and -Cm don't make sense together"
msgstr "опциите „-Cf“/„-CF“ и „-Cm“ са несъвместими"
#: main.c:278
msgid "-Cf/-CF and -I are incompatible"
msgstr "опциите „-Cf“/„-CF“ и „-I“ са несъвместими"
#: main.c:282
msgid "-Cf/-CF are incompatible with lex-compatibility mode"
msgstr "опциите „-Cf“/„-CF“ са несъвместими с режима за съвместимост с „lex“"
#: main.c:287
msgid "-Cf and -CF are mutually exclusive"
msgstr "опциите „-Cf“ и „-CF“ са несъвместими"
#: main.c:291
msgid "Can't use -+ with -CF option"
msgstr "опциите „-+“ и „-CF“ са несъвместими"
#: main.c:294
#, c-format
msgid "%array incompatible with -+ option"
msgstr "опцията „-+“ e несъвместима с декларация „%array“"
#: main.c:299
msgid "Options -+ and --reentrant are mutually exclusive."
msgstr "Опциите „-+“ и „--reentrant“ са несъвместими."
#: main.c:302
msgid "bison bridge not supported for the C++ scanner."
msgstr "анализатори, които са на C++, не поддържат допълнителната поддръжка за „bison“."
#: main.c:357 main.c:403
#, c-format
msgid "could not create %s"
msgstr "„%s“ не може да се създаде"
#: main.c:416
msgid "could not write tables header"
msgstr "заглавният файл за таблиците не може за се запише"
#: main.c:420
#, c-format
msgid "can't open skeleton file %s"
msgstr "файлът-скеле „%s“ не може да се отвори"
#: main.c:456
msgid "allocation of macro definition failed"
msgstr "неуспешно заделяне на памет за дефиниция на макрос"
#: main.c:504
#, c-format
msgid "input error reading skeleton file %s"
msgstr "входна грешка при изчитане на файла-скеле „%s“"
#: main.c:508
#, c-format
msgid "error closing skeleton file %s"
msgstr "грешка при затваряне на файла-скеле „%s“"
#: main.c:693
#, c-format
msgid "error creating header file %s"
msgstr "грешка при създаването на заглавен файл „%s“"
#: main.c:701
#, c-format
msgid "error writing output file %s"
msgstr "грешка при записването на изходния файл „%s“"
#: main.c:705
#, c-format
msgid "error closing output file %s"
msgstr "грешка при затварянето на изходния файл „%s“"
#: main.c:709
#, c-format
msgid "error deleting output file %s"
msgstr "грешка при изтриването на изходния файл „%s“"
#: main.c:716
#, c-format
msgid "No backing up.\n"
msgstr "Без връщане назад.\n"
#: main.c:720
#, c-format
msgid "%d backing up (non-accepting) states.\n"
msgstr "%d състояния за връщане (без приемане)\n"
#: main.c:724
#, c-format
msgid "Compressed tables always back up.\n"
msgstr "Компресираните таблици винаги водят до връщане назад.\n"
#: main.c:727
#, c-format
msgid "error writing backup file %s"
msgstr "грешка при записа на файла с връщанията назад „%s“"
#: main.c:731
#, c-format
msgid "error closing backup file %s"
msgstr "грешка при затварянето на файла с връщанията назад „%s“"
#: main.c:736
#, c-format
msgid "%s version %s usage statistics:\n"
msgstr "Статистика за употреба на %s, версия %s:\n"
#: main.c:739
#, c-format
msgid " scanner options: -"
msgstr " опции на лексическия анализатор: -"
#: main.c:818
#, c-format
msgid " %d/%d NFA states\n"
msgstr " %d/%d състояния на НКА\n"
#: main.c:820
#, c-format
msgid " %d/%d DFA states (%d words)\n"
msgstr " %d/%d състояния на ДКА (%d думи)\n"
#: main.c:822
#, c-format
msgid " %d rules\n"
msgstr " %d правила\n"
#: main.c:827
#, c-format
msgid " No backing up\n"
msgstr " Без връщане назад\n"
#: main.c:831
#, c-format
msgid " %d backing-up (non-accepting) states\n"
msgstr " %d състояния за връщане (без приемане)\n"
#: main.c:836
#, c-format
msgid " Compressed tables always back-up\n"
msgstr " Компресираните таблици винаги водят до връщане\n"
#: main.c:840
#, c-format
msgid " Beginning-of-line patterns used\n"
msgstr " Използвани са правила за начало на ред\n"
#: main.c:842
#, c-format
msgid " %d/%d start conditions\n"
msgstr " %d/%d начални състояния\n"
#: main.c:846
#, c-format
msgid " %d epsilon states, %d double epsilon states\n"
msgstr " %d ε-състояния, %d двойни ε-състояния\n"
#: main.c:850
#, c-format
msgid " no character classes\n"
msgstr " няма класове знаци\n"
#: main.c:854
#, 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:859
#, c-format
msgid " %d state/nextstate pairs created\n"
msgstr " %d двойки състояние/преход\n"
#: main.c:862
#, c-format
msgid " %d/%d unique/duplicate transitions\n"
msgstr " %d/%d уникални/повтарящи се преходи\n"
#: main.c:867
#, c-format
msgid " %d table entries\n"
msgstr " %d таблични записи\n"
#: main.c:875
#, c-format
msgid " %d/%d base-def entries created\n"
msgstr " %d/%d записи за основни дефиниции\n"
#: main.c:879
#, c-format
msgid " %d/%d (peak %d) nxt-chk entries created\n"
msgstr " %d/%d (максимум %d) записи\n"
#: main.c:883
#, c-format
msgid " %d/%d (peak %d) template nxt-chk entries created\n"
msgstr " %d/%d (максимум %d) шаблонни записи\n"
#: main.c:887
#, c-format
msgid " %d empty table entries\n"
msgstr " %d празни таблични записи\n"
#: main.c:889
#, c-format
msgid " %d protos created\n"
msgstr " %d създадени прототипи\n"
#: main.c:892
#, c-format
msgid " %d templates created, %d uses\n"
msgstr " %d създадени шаблони, %d употреби\n"
#: main.c:900
#, c-format
msgid " %d/%d equivalence classes created\n"
msgstr " създадени са %d/%d класове за еквивалентност\n"
#: main.c:908
#, c-format
msgid " %d/%d meta-equivalence classes created\n"
msgstr " създадени са %d/%d класове за мета-еквивалентност\n"
#: main.c:914
#, c-format
msgid " %d (%d saved) hash collisions, %d DFAs equal\n"
msgstr " %d (%d запазени) конфликти по суми, %d ДКА са еднакви\n"
#: main.c:916
#, c-format
msgid " %d sets of reallocations needed\n"
msgstr " необходими са %d пъти заделяния на памет наново\n"
#: main.c:918
#, c-format
msgid " %d total table entries needed\n"
msgstr " необходими са общо %d записи в таблица\n"
#: main.c:995
#, c-format
msgid "Internal error. flexopts are malformed.\n"
msgstr "Вътрешна грешка. Неправилни опции за flex.\n"
#: main.c:1005
#, c-format
msgid "Try `%s --help' for more information.\n"
msgstr "За повече информация изпълнете „%s --help“.\n"
#: main.c:1062
#, c-format
msgid "unknown -C option '%c'"
msgstr "непозната опция към „-C“: „%c“"
#: main.c:1191
#, c-format
msgid "%s %s\n"
msgstr "%s %s\n"
#: main.c:1466
msgid "fatal parse error"
msgstr "фатална грешка на анализатора"
#: main.c:1498
#, c-format
msgid "could not create backing-up info file %s"
msgstr "файлът с информация за връщане назад не може да се създаде: „%s“"
#: main.c:1519
#, c-format
msgid "-l AT&T lex compatibility option entails a large performance penalty\n"
msgstr "опцията за съвместимост с „lex“ на AT&T: „-l“, води до голяма загуба на производителност\n"
#: main.c:1522
#, c-format
msgid " and may be the actual source of other reported performance penalties\n"
msgstr " и може да доведе до допълнителни проблеми с производителността\n"
#: main.c:1528
#, c-format
msgid "%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"
msgstr "директивата за „%%option“ — „yylineno“ води до загуба на производителност, само за правилата, които напасват знак за нов ред\n"
#: main.c:1535
#, c-format
msgid "-I (interactive) entails a minor performance penalty\n"
msgstr "„-I“ (интерактивният режим) води до малка загуба на производителност\n"
#: main.c:1540
#, c-format
msgid "yymore() entails a minor performance penalty\n"
msgstr "„yymore()“ води до малка загуба на производителност\n"
#: main.c:1546
#, c-format
msgid "REJECT entails a large performance penalty\n"
msgstr "Отхвърлянето (REJECT) води до голяма загуба на производителност\n"
#: main.c:1551
#, c-format
msgid "Variable trailing context rules entail a large performance penalty\n"
msgstr "Правила с последващ контекст, който не е константен, водят до голяма загуба на производителност\n"
#: main.c:1563
msgid "REJECT cannot be used with -f or -F"
msgstr "Отхвърлянето (REJECT) е несъвместимо с „-f“ или „-F“"
#: main.c:1566
#, c-format
msgid "%option yylineno cannot be used with REJECT"
msgstr "директивата за „%option“ — „yylineno“ е несъвместима с отхвърляне (REJECT)"
#: main.c:1569
msgid "variable trailing context rules cannot be used with -f or -F"
msgstr "правила с последващ контекст, който не е константен, не може да се ползват заедно с „-f“ или „-F“"
#: main.c:1692
#, c-format
msgid "%option yyclass only meaningful for C++ scanners"
msgstr "директивата за „%option“ — „yyclass“ важи само за анализаторите, които са на C++"
#: main.c:1799
#, c-format
msgid "Usage: %s [OPTIONS] [FILE]...\n"
msgstr "Употреба: %s [ОПЦИЯ] [ФАЙЛ]…\n"
#: main.c:1802
#, c-format
msgid ""
"Generates programs that perform pattern-matching on text.\n"
"\n"
"Table Compression:\n"
" -Ca, --align trade off larger tables for better memory alignment\n"
" -Ce, --ecs construct equivalence classes\n"
" -Cf do not compress tables; use -f representation\n"
" -CF do not compress tables; use -F representation\n"
" -Cm, --meta-ecs construct meta-equivalence classes\n"
" -Cr, --read use read() instead of stdio for scanner input\n"
" -f, --full generate fast, large scanner. Same as -Cfr\n"
" -F, --fast use alternate table representation. Same as -CFr\n"
" -Cem default compression (same as --ecs --meta-ecs)\n"
"\n"
"Debugging:\n"
" -d, --debug enable debug mode in scanner\n"
" -b, --backup write backing-up information to %s\n"
" -p, --perf-report write performance report to stderr\n"
" -s, --nodefault suppress default rule to ECHO unmatched text\n"
" -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"
"\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"
" --tables-file[=FILE] write tables to FILE\n"
"\n"
"Scanner behavior:\n"
" -7, --7bit generate 7-bit scanner\n"
" -8, --8bit generate 8-bit scanner\n"
" -B, --batch generate batch scanner (opposite of -I)\n"
" -i, --case-insensitive ignore case in patterns\n"
" -l, --lex-compat maximal compatibility with original lex\n"
" -X, --posix-compat maximal compatibility with POSIX lex\n"
" -I, --interactive generate interactive scanner (opposite of -B)\n"
" --yylineno track line count in yylineno\n"
"\n"
"Generated code:\n"
" -+, --c++ generate C++ scanner class\n"
" -Dmacro[=defn] #define macro defn (default defn is '1')\n"
" -L, --noline suppress #line directives in scanner\n"
" -P, --prefix=STRING use STRING as prefix instead of \"yy\"\n"
" -R, --reentrant generate a reentrant C scanner\n"
" --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"
" -c do-nothing POSIX option\n"
" -n do-nothing POSIX option\n"
" -?\n"
" -h, --help produce this help message\n"
" -V, --version report %s version\n"
msgstr ""
"Генериране на програма за лексически анализ на текст.\n"
"\n"
"Компресиране на таблиците\n"
" -Ca, --align по-точно подравняване в паметта, но по-големи таблици\n"
" -Ce, --ecs създаване на класовете за еквивалентност\n"
" -Cf без компресия на таблиците, представяне както с „-f“\n"
" -CF без компресия на таблиците, представяне както с „-F“\n"
" -Cm, --meta-ecs създаване на класовете за мета-еквивалентност\n"
" -Cr, --read четене чрез „read()“, а не от стандартния вход\n"
" -f, --full генериране на голям, но бърз анализатор, (≡„-Cfr“)\n"
" -F, --fast алтернативно представяне на таблиците (≡„-CFr“)\n"
" -Cem стандартна компресия (≡„--ecs --meta-ecs“)\n"
"\n"
"Изчистване на грешки:\n"
" -d, --debug режим на изчистване на грешки в анализатора\n"
" -b, --backup запазване на информацията за връщане назад в „%s“\n"
" -p, --perf-report доклад-производителността към стандартната грешка\n"
" -s, --nodefault потискане на стандартното правило за извеждане на\n"
" текста, който не напасва\n"
" -T, --trace „%s“ да се изпълнява в режим на трасиране\n"
" -w, --nowarn без предупреждения\n"
" -v, --verbose доклад-статистика за анализатора към стандартния изход\n"
"\n"
"Файлове:\n"
" -o, --outfile=ФАЙЛ задаване на изходния ФАЙЛ\n"
" -S, --skel=ФАЙЛ задаване на ФАЙЛа-скеле\n"
" -t, --stdout извеждане на анализатора на стандартния изход, а\n"
" не в „%s“\n"
" --yyclass=ИМЕ ИМЕ на клас за C++\n"
" --header-file=ФАЙЛ създаване и на заглавен файл на Cr\n"
" --tables-file[=ФАЙЛ] извеждане на таблиците във ФАЙЛа\n"
"\n"
"Поведение на анализатора:\n"
" -7, --7bit анализатор за 7-битов вход\n"
" -8, --8bit анализатор за 8-битов вход\n"
" -B, --batch пакетен анализатор (обратното на „-I“)\n"
" -i, --case-insensitive без разлика между главни и малки знаци\n"
" -l, --lex-compat максимална съвместимост с оригиналния „lex“\n"
" -X, --posix-compat максимална съвместимост с „lex“ по POSIX\n"
" -I, --interactive интерактивен анализатор (обратното на „-B“)\n"
" --yylineno следене на броя на редовете чрез „yylineno“\n"
"\n"
"Генериран код:\n"
" -+, --c++ генериране на анализатор като клас на C++\n"
" -DМАКРОС[=ДЕФИНИЦИЯ] „#define МАКРОС ДЕФИНИЦИЯ“ (стандартно\n"
" ДЕФИНИЦИЯта е „1“)\n"
" -L, --noline без директиви „#line“ в анализатора\n"
" -P, --prefix=НИЗ използване на този НИЗ за префикс вместо обичайния „yy“\n"
" -R, --reentrant анализатор на C с възможност за повторно извикване\n"
" --bison-bridge допълнителна поддръжка за „bison“\n"
" --bison-locations поддръжка на „yylloc“\n"
" --stdinit първоначалните стойности на „yyin“ и „yyout“ да са\n"
" съответно стандартният вход и изход\n"
" --noansi-definitions\n"
" остаряло дефиниране на функциите на C (преди ANSI)\n"
" --noansi-prototypes празен списък с параметри в прототипите\n"
" --nounistd без ползване на „<unistd.h>“\n"
" --noФУНКЦИЯ без създаването на определена ФУНКЦИЯ\n"
"\n"
"Други:\n"
" -c опция по POSIX, която не прави нищо\n"
" -n опция по POSIX, която не прави нищо\n"
" -?\n"
" -h, --help извеждане на това помощно съобщение\n"
" -V, --version извеждане на версията на „%s“\n"
#: misc.c:65
msgid "allocation of sko_stack failed"
msgstr "неуспешно заделяне на памет за „sko_stack“"
#: misc.c:102 misc.c:128
#, c-format
msgid "name \"%s\" ridiculously long"
msgstr "прекалено дълго име: „%s“"
#: misc.c:177
msgid "memory allocation failed in allocate_array()"
msgstr "неуспешно заделяне на памет в „allocate_array()“"
#: misc.c:230
#, c-format
msgid "bad character '%s' detected in check_char()"
msgstr "„check_char()“ се натъкна на неправилен знак: „%s“"
#: misc.c:235
#, 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 "проблем с динамичната памет в „copy_string()“"
#: misc.c:367
#, c-format
msgid "%s: fatal internal error, %s\n"
msgstr "%s: фатална вътрешна грешка — %s\n"
#: misc.c:803
msgid "attempt to increase array size failed"
msgstr "неуспешен опит за увеличаване на размер на масив"
#: misc.c:930
msgid "bad line in skeleton file"
msgstr "неправилен файл във файл-скеле"
#: misc.c:979
msgid "memory allocation failed in yy_flex_xmalloc()"
msgstr "неуспешно заделяне на памет в „yy_flex_xmalloc()“"
#: nfa.c:104
#, c-format
msgid ""
"\n"
"\n"
"********** beginning dump of nfa with start state %d\n"
msgstr ""
"\n"
"\n"
"•••••••••• начало на извеждането на НКА с начално състояние %d\n"
#: nfa.c:115
#, c-format
msgid "state # %4d\t"
msgstr "състояние №%4d"
#: nfa.c:130
#, c-format
msgid "********** end of dump\n"
msgstr "•••••••••• край на извеждането\n"
#: nfa.c:174
msgid "empty machine in dupmachine()"
msgstr "празен автомат в „dupmachine()“"
#: nfa.c:240
#, c-format
msgid "Variable trailing context rule at line %d\n"
msgstr "Правило с последващ контекст, който не е константен, на ред %d\n"
#: nfa.c:364
msgid "bad state type in mark_beginning_as_normal()"
msgstr "неправилен вид състояние в „mark_beginning_as_normal()“"
#: nfa.c:609
#, c-format
msgid "input rules are too complicated (>= %d NFA states)"
msgstr "входните правила са прекалено сложни (≥ %d състояния на НКА)"
#: nfa.c:688
msgid "found too many transitions in mkxtion()"
msgstr "прекалено много преходи в „mkxtion()“"
#: nfa.c:714
#, c-format
msgid "too many rules (> %d)!"
msgstr "прекалено много правила (> %d)!"
#: parse.y:159
msgid "unknown error processing section 1"
msgstr "непозната грешка при обработка на 1ви раздел"
#: parse.y:184 parse.y:351
msgid "bad start condition list"
msgstr "неправилен списък на началните състояния"
#: parse.y:315
msgid "unrecognized rule"
msgstr "непознато правило"
#: parse.y:434 parse.y:447 parse.y:516
msgid "trailing context used twice"
msgstr "двукратно ползване на последващ контекст"
#: parse.y:552 parse.y:562 parse.y:635 parse.y:645
msgid "bad iteration values"
msgstr "неправилни стойности на итерация"
#: parse.y:580 parse.y:598 parse.y:663 parse.y:681
msgid "iteration value must be positive"
msgstr "стойността на итерацията трябва да е положителна"
#: parse.y:804 parse.y:814
#, c-format
msgid "the character range [%c-%c] is ambiguous in a case-insensitive scanner"
msgstr "диапазонът знаци [%c-%c] не е еднозначен при лексичен анализатор, който не прави разлика между главни и малки знаци"
#: parse.y:819
msgid "negative range in character class"
msgstr "изключващ диапазон в клас знаци"
#: parse.y:916
msgid "[:^lower:] is ambiguous in case insensitive scanner"
msgstr "диапазонът знаци [:^lower:] не е еднозначен при лексичен анализатор, който не прави разлика между главни и малки знаци"
#: parse.y:922
msgid "[:^upper:] ambiguous in case insensitive scanner"
msgstr "диапазонът знаци [:^upper:] не е еднозначен при лексичен анализатор, който не прави разлика между главни и малки знаци"
#: scan.l:75 scan.l:618 scan.l:676
msgid "Input line too long\n"
msgstr "Входният ред е твърде дълъг\n"
#: scan.l:161
#, c-format
msgid "malformed '%top' directive"
msgstr "неправилна директива „%top“"
#: scan.l:183
#, no-c-format
msgid "unrecognized '%' directive"
msgstr "непозната директива, започваща с „%“"
#: scan.l:192
msgid "Definition name too long\n"
msgstr "Името на дефиницията е твърде дълго\n"
#: scan.l:284
msgid "Unmatched '{'"
msgstr "„{“ без еш"
#: scan.l:300
#, c-format
msgid "Definition value for {%s} too long\n"
msgstr "Стойността на дефиницията „{%s}“ е твърде дълга\n"
#: scan.l:317
msgid "incomplete name definition"
msgstr "дефиниция с непълно име"
#: scan.l:443
msgid "Option line too long\n"
msgstr "Редът за опция е твърде дълъг\n"
#: scan.l:451
#, c-format
msgid "unrecognized %%option: %s"
msgstr "непозната опция „%%option“: „%s“"
#: scan.l:633 scan.l:800
msgid "bad character class"
msgstr "неправилен клас знаци"
#: scan.l:683
#, c-format
msgid "undefined definition {%s}"
msgstr "липсваща дефиниция „{%s}“"
#: scan.l:755
#, c-format
msgid "bad <start condition>: %s"
msgstr "лошо начално условие: „%s“"
#: scan.l:768
msgid "missing quote"
msgstr "липсваща кавичка"
#: scan.l:834
#, c-format
msgid "bad character class expression: %s"
msgstr "неправилен израз за клас от знаци: „%s“"
#: scan.l:856
msgid "bad character inside {}'s"
msgstr "неправилен знак между „{“ и „}“"
#: scan.l:862
msgid "missing }"
msgstr "липсва „}“"
#: scan.l:940
msgid "EOF encountered inside an action"
msgstr "край на файл в действие"
#: scan.l:945
msgid "EOF encountered inside pattern"
msgstr "край на файл в шаблон"
#: scan.l:967
#, c-format
msgid "bad character: %s"
msgstr "неправилен знак: %s"
#: scan.l:996
#, c-format
msgid "can't open %s"
msgstr "„%s“ не може да се отвори"
#: scanopt.c:291
#, c-format
msgid "Usage: %s [OPTIONS]...\n"
msgstr "Употреба: %s [ОПЦИЯ]…\n"
#: scanopt.c:564
#, c-format
msgid "option `%s' doesn't allow an argument\n"
msgstr "опцията „%s“ се използва без аргументи\n"
#: scanopt.c:569
#, c-format
msgid "option `%s' requires an argument\n"
msgstr "опцията „%s“ изисква аргумент\n"
#: scanopt.c:573
#, c-format
msgid "option `%s' is ambiguous\n"
msgstr "опцията „%s“ не е еднозначна\n"
#: scanopt.c:577
#, c-format
msgid "Unrecognized option `%s'\n"
msgstr "непозната опция „%s“\n"
#: scanopt.c:581
#, c-format
msgid "Unknown error=(%d)\n"
msgstr "Неизвестна грешка=(%d)\n"
#: sym.c:100
msgid "symbol table memory allocation failed"
msgstr "неуспешно заделяне на памет за таблицата със символите"
#: sym.c:202
msgid "name defined twice"
msgstr "името е дефинирано двукратно"
#: sym.c:253
#, c-format
msgid "start condition %s declared twice"
msgstr "началното условие „%s“ е дефинирано двукратно"
#: yylex.c:56
msgid "premature EOF"
msgstr "преждевременен край (EOF)"
#: yylex.c:198
#, c-format
msgid "End Marker\n"
msgstr "Маркер за край\n"
#: yylex.c:204
#, c-format
msgid "*Something Weird* - tok: %d val: %d\n"
msgstr "•Нещо странно• — лекс.: %d ст-ст: %d\n"
po/ca.po
+260 -202
View File
File diff suppressed because it is too large Load Diff
po/da.po
+208 -180
View File
File diff suppressed because it is too large Load Diff
po/de.po
+230 -189
View File
File diff suppressed because it is too large Load Diff
po/eo.po
+212 -182
View File
File diff suppressed because it is too large Load Diff
po/es.po
+398 -191
View File
File diff suppressed because it is too large Load Diff
po/fi.po
+238 -194
View File
File diff suppressed because it is too large Load Diff
po/fr.po
+249 -199
View File
File diff suppressed because it is too large Load Diff
po/ga.po
+284 -212
View File
File diff suppressed because it is too large Load Diff
po/hr.po
+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"
po/ko.po
+908 -524
View File
File diff suppressed because it is too large Load Diff
po/nl.po
+228 -188
View File
File diff suppressed because it is too large Load Diff
po/pl.po
+224 -187
View File
File diff suppressed because it is too large Load Diff
po/pt.po
+929
View File
@@ -0,0 +1,929 @@
# Portuguese (Portugal) translation for the flex package.
# Copyright (C) 2019 The Flex Project (msgids)
# This file is put in the public domain.
# Pedro Albuquerque <palbuquerque73@gmail.com>, 2019.
#
msgid ""
msgstr ""
"Project-Id-Version: flex 2.5.38\n"
"Report-Msgid-Bugs-To: flex-devel@lists.sourceforge.net\n"
"POT-Creation-Date: 2014-02-11 16:15-0500\n"
"PO-Revision-Date: 2019-05-23 10:15+0100\n"
"Last-Translator: Pedro Albuquerque <palbuquerque73@gmail.com>\n"
"Language-Team: Portuguese <translation-team-pt@lists.sourceforge.net>\n"
"Language: pt\n"
"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=2; plural=n != 1;\\n\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
#: buf.c:78
msgid "Allocation of buffer to print string failed"
msgstr "Falha ao alocar buffer para imprimir a cadeia"
#: buf.c:100
msgid "Allocation of buffer for line directive failed"
msgstr "Falha ao alocar buffer para directiva de linha"
#: buf.c:177
msgid "Allocation of buffer for m4 def failed"
msgstr "Falha ao alocar buffer para m4 def"
#: buf.c:197
msgid "Allocation of buffer for m4 undef failed"
msgstr "Falha ao alocar buffer para m4 undef"
#: dfa.c:61
#, c-format
msgid "State #%d is non-accepting -\n"
msgstr "Estado nº %d não está a aceitar -\n"
#: dfa.c:124
msgid "dangerous trailing context"
msgstr "conteúdo final perigoso"
#: dfa.c:166
#, c-format
msgid " associated rule line numbers:"
msgstr " números de linha de regra associada:"
#: dfa.c:202
#, c-format
msgid " out-transitions: "
msgstr " out-transitions: "
#: dfa.c:210
#, c-format
msgid ""
"\n"
" jam-transitions: EOF "
msgstr ""
"\n"
" jam-transitions: EOF "
#: dfa.c:341
msgid "consistency check failed in epsclosure()"
msgstr "falha no teste de consistência em epsclosure()"
#: dfa.c:429
msgid ""
"\n"
"\n"
"DFA Dump:\n"
"\n"
msgstr ""
"\n"
"\n"
"DFA Dump:\n"
"\n"
#: dfa.c:604
msgid "could not create unique end-of-buffer state"
msgstr "impossível criar estado end-of-buffer exclusivo"
#: dfa.c:625
#, c-format
msgid "state # %d:\n"
msgstr "estado nº %d\n"
#: dfa.c:785
msgid "Could not write yynxt_tbl[][]"
msgstr "Impossível escrever yynxt_tbl[][]"
#: dfa.c:1049
msgid "bad transition character detected in sympartition()"
msgstr "detectado um mau carácter de transição em sympartition()"
#: gen.c:478
msgid ""
"\n"
"\n"
"Equivalence Classes:\n"
"\n"
msgstr ""
"\n"
"\n"
"Classes de equivalência:\n"
"\n"
#: gen.c:662 gen.c:691 gen.c:1215
#, c-format
msgid "state # %d accepts: [%d]\n"
msgstr "estado nº %d aceita: [%d]\n"
#: gen.c:1110
#, c-format
msgid "state # %d accepts: "
msgstr "estado nº %d aceita: "
#: gen.c:1157
msgid "Could not write yyacclist_tbl"
msgstr "Impossível escrever yyacclist_tbl"
#: gen.c:1233
msgid "Could not write yyacc_tbl"
msgstr "Impossível escrever yyacc_tbl"
#: gen.c:1248 gen.c:1633 gen.c:1656
msgid "Could not write ecstbl"
msgstr "Impossível escrever ecstbl"
#: gen.c:1271
msgid ""
"\n"
"\n"
"Meta-Equivalence Classes:\n"
msgstr ""
"\n"
"\n"
"Classes de meta-equivalência:\n"
#: gen.c:1293
msgid "Could not write yymeta_tbl"
msgstr "Impossível escrever yymeta_tbl"
#: gen.c:1354
msgid "Could not write yybase_tbl"
msgstr "Impossível escrever yybase_tbl"
#: gen.c:1388
msgid "Could not write yydef_tbl"
msgstr "Impossível escrever yydef_tbl"
#: gen.c:1428
msgid "Could not write yynxt_tbl"
msgstr "Impossível escrever yynxt_tbl"
#: gen.c:1464
msgid "Could not write yychk_tbl"
msgstr "Impossível escrever yychk_tbl"
#: gen.c:1618 gen.c:1647
msgid "Could not write ftbl"
msgstr "Impossível escrever ftbl"
#: gen.c:1624
msgid "Could not write ssltbl"
msgstr "Impossível escrever ssltbl"
#: gen.c:1675
msgid "Could not write eoltbl"
msgstr "Impossível escrever eoltbl"
#: gen.c:1735
msgid "Could not write yynultrans_tbl"
msgstr "Impossível escrever yynultrans_tbl"
#: main.c:191
msgid "rule cannot be matched"
msgstr "impossível comparar a regra"
#: main.c:196
msgid "-s option given but default rule can be matched"
msgstr "indicada a opção -s, mas a regra predefinida pode ser comparada"
#: main.c:236
msgid "Can't use -+ with -l option"
msgstr "Impossível usar -+ com a opção -l"
#: main.c:239
msgid "Can't use -f or -F with -l option"
msgstr "Impossível usar -f ou -F com a opção -l"
#: main.c:243
msgid "Can't use --reentrant or --bison-bridge with -l option"
msgstr "Impossível usar --reentrant ou --bison-bridge com a opção -l"
#: main.c:275
msgid "-Cf/-CF and -Cm don't make sense together"
msgstr "-Cf/-CF e -Cm não fazem sentido em conjunto"
#: main.c:278
msgid "-Cf/-CF and -I are incompatible"
msgstr "-Cf/-CF e -I são incompatíveis"
#: main.c:282
msgid "-Cf/-CF are incompatible with lex-compatibility mode"
msgstr "-Cf/-CF são incompatíveis com o modo lex-compatibility"
#: main.c:287
msgid "-Cf and -CF are mutually exclusive"
msgstr "-Cf e -CF são mutuamente exclusivas"
#: main.c:291
msgid "Can't use -+ with -CF option"
msgstr "Impossível usar -+ com a opção -CF"
#: main.c:294
#, c-format
msgid "%array incompatible with -+ option"
msgstr "%array incompatível com a opção -+"
#: main.c:299
msgid "Options -+ and --reentrant are mutually exclusive."
msgstr "As opções -+ e --reentrant são mutuamente exclusivas."
#: main.c:302
msgid "bison bridge not supported for the C++ scanner."
msgstr "bison bridge não suportada no analisador C++."
#: main.c:357 main.c:403
#, c-format
msgid "could not create %s"
msgstr "impossível criar %s"
#: main.c:416
msgid "could not write tables header"
msgstr "impossível criar cabeçalho de tabelas"
#: main.c:420
#, c-format
msgid "can't open skeleton file %s"
msgstr "impossível abrir ficheiro esqueleto %s"
#: main.c:456
msgid "allocation of macro definition failed"
msgstr "falha ao alocar definição de macro"
#: main.c:504
#, c-format
msgid "input error reading skeleton file %s"
msgstr "erro de entrada ao ler ficheiro esqueleto %s"
#: main.c:508
#, c-format
msgid "error closing skeleton file %s"
msgstr "erro ao fechar ficheiro esqueleto %s"
#: main.c:693
#, c-format
msgid "error creating header file %s"
msgstr "erro ao criar ficheiro de cabeçalho %s"
#: main.c:701
#, c-format
msgid "error writing output file %s"
msgstr "erro ao escrever ficheiro de saída %s"
#: main.c:705
#, c-format
msgid "error closing output file %s"
msgstr "erro ao fechar ficheiro de saída %s"
#: main.c:709
#, c-format
msgid "error deleting output file %s"
msgstr "erro ao eliminar ficheiro de saída %s"
#: main.c:716
#, c-format
msgid "No backing up.\n"
msgstr "Sem seguranças.\n"
#: main.c:720
#, c-format
msgid "%d backing up (non-accepting) states.\n"
msgstr "%d estados de segurança (não aceitando).\n"
#: main.c:724
#, c-format
msgid "Compressed tables always back up.\n"
msgstr "Tabelas comprimidas têm sempre segurança.\n"
#: main.c:727
#, c-format
msgid "error writing backup file %s"
msgstr "erro ao escrever segurança %s"
#: main.c:731
#, c-format
msgid "error closing backup file %s"
msgstr "erro ao fechar segurança %s"
#: main.c:736
#, c-format
msgid "%s version %s usage statistics:\n"
msgstr "%s versão %s estatisticas de uso:\n"
#: main.c:739
#, c-format
msgid " scanner options: -"
msgstr " opções do analisador: -"
#: main.c:818
#, c-format
msgid " %d/%d NFA states\n"
msgstr " estados NFA %d/%d\n"
#: main.c:820
#, c-format
msgid " %d/%d DFA states (%d words)\n"
msgstr " estados DFA %d/%d (%d palavras)\n"
#: main.c:822
#, c-format
msgid " %d rules\n"
msgstr " %d regras\n"
#: main.c:827
#, c-format
msgid " No backing up\n"
msgstr " Sem seguranças\n"
#: main.c:831
#, c-format
msgid " %d backing-up (non-accepting) states\n"
msgstr " %d estados de segurança (não aceitando).\n"
#: main.c:836
#, c-format
msgid " Compressed tables always back-up\n"
msgstr "Tabelas comprimidas têm sempre segurança.\n"
#: main.c:840
#, c-format
msgid " Beginning-of-line patterns used\n"
msgstr " Padrões de início de linha usados\n"
#: main.c:842
#, c-format
msgid " %d/%d start conditions\n"
msgstr " condições iniciais %d/%d\n"
#: main.c:846
#, c-format
msgid " %d epsilon states, %d double epsilon states\n"
msgstr " estados epsilon %d, estados duplo epsilon %d\n"
#: main.c:850
#, c-format
msgid " no character classes\n"
msgstr " sem classes de carácter\n"
#: main.c:854
#, c-format
msgid " %d/%d character classes needed %d/%d words of storage, %d reused\n"
msgstr " classes de carácter %d/%d necessárias %d/%d palavras de armazenamento, %d reutilizadas\n"
#: main.c:859
#, c-format
msgid " %d state/nextstate pairs created\n"
msgstr " %d pares estado/estado seguinte criados\n"
#: main.c:862
#, c-format
msgid " %d/%d unique/duplicate transitions\n"
msgstr " %d/%d transições únicas/duplicadas\n"
#: main.c:867
#, c-format
msgid " %d table entries\n"
msgstr " %d entradas de tabela\n"
#: main.c:875
#, c-format
msgid " %d/%d base-def entries created\n"
msgstr " %d/%d entradas base-def criadas\n"
#: main.c:879
#, c-format
msgid " %d/%d (peak %d) nxt-chk entries created\n"
msgstr " %d/%d (pico %d) entradas nxt-chk criadas\n"
#: main.c:883
#, c-format
msgid " %d/%d (peak %d) template nxt-chk entries created\n"
msgstr " %d/%d (pico %d) entradas modelo nxt-chk criadas\n"
#: main.c:887
#, c-format
msgid " %d empty table entries\n"
msgstr " %d entradas de tabela vazias\n"
#: main.c:889
#, c-format
msgid " %d protos created\n"
msgstr " %d protos criados\n"
#: main.c:892
#, c-format
msgid " %d templates created, %d uses\n"
msgstr " %d modelos criados, %d usos\n"
#: main.c:900
#, c-format
msgid " %d/%d equivalence classes created\n"
msgstr " %d/%d classes de equivalência criadas\n"
#: main.c:908
#, c-format
msgid " %d/%d meta-equivalence classes created\n"
msgstr " %d/%d classes de meta-equivalência criadas\n"
#: main.c:914
#, c-format
msgid " %d (%d saved) hash collisions, %d DFAs equal\n"
msgstr " %d (%d gravadas) colisões de hash, %d DFAs iguais\n"
#: main.c:916
#, c-format
msgid " %d sets of reallocations needed\n"
msgstr " %d conjuntos de re-alocação necessários\n"
#: main.c:918
#, c-format
msgid " %d total table entries needed\n"
msgstr " %d entradas de tabela totais necessárias\n"
#: main.c:995
#, c-format
msgid "Internal error. flexopts are malformed.\n"
msgstr "Erro interno. flexopts mal formados.\n"
#: main.c:1005
#, c-format
msgid "Try `%s --help' for more information.\n"
msgstr "Tente \"%s --help\" para mais informação.\n"
#: main.c:1062
#, c-format
msgid "unknown -C option '%c'"
msgstr "Opção -C \"%c\" desconhecida"
#: main.c:1191
#, c-format
msgid "%s %s\n"
msgstr "%s %s\n"
#: main.c:1466
msgid "fatal parse error"
msgstr "erro de processamento fatal"
#: main.c:1498
#, c-format
msgid "could not create backing-up info file %s"
msgstr "impossível criar ficheiro de informação de segurança %s"
#: main.c:1519
#, c-format
msgid "-l AT&T lex compatibility option entails a large performance penalty\n"
msgstr "a opção de compatibilidade -l AT&T lex implica uma grande perda de desempenho\n"
#: main.c:1522
#, c-format
msgid " and may be the actual source of other reported performance penalties\n"
msgstr " e pode ser a fonte actual de outras penalizações de desempenho reportadas\n"
#: main.c:1528
#, c-format
msgid "%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"
msgstr "a %%opção yylineno implica uma perda de desempenho SÓ em regras que possam comparar caracteres de nova linha\n"
#: main.c:1535
#, c-format
msgid "-I (interactive) entails a minor performance penalty\n"
msgstr "-I (interactiva) implica uma perda menor de desempenho\n"
#: main.c:1540
#, c-format
msgid "yymore() entails a minor performance penalty\n"
msgstr "yymore() implica uma perda menor de desempenho\n"
#: main.c:1546
#, c-format
msgid "REJECT entails a large performance penalty\n"
msgstr "REJECT implica uma grave perda de desempenho\n"
#: main.c:1551
#, c-format
msgid "Variable trailing context rules entail a large performance penalty\n"
msgstr "Regras variáveis de contexto final implicam uma grave perda de desempenho\n"
#: main.c:1563
msgid "REJECT cannot be used with -f or -F"
msgstr "REJECT não ode ser usado com -f ou -F"
#: main.c:1566
#, c-format
msgid "%option yylineno cannot be used with REJECT"
msgstr "a %opção yylineno não pode ser usada com REJECT"
#: main.c:1569
msgid "variable trailing context rules cannot be used with -f or -F"
msgstr "regras variáveis de contexto final não podem ser usadas com -f ou -F"
#: main.c:1692
#, c-format
msgid "%option yyclass only meaningful for C++ scanners"
msgstr "a %opção yyclass só tem significado para analisadores C++"
#: main.c:1799
#, c-format
msgid "Usage: %s [OPTIONS] [FILE]...\n"
msgstr "Uso: %s [OPÇÕES] [FICHEIRO]...\n"
#: main.c:1802
#, c-format
msgid ""
"Generates programs that perform pattern-matching on text.\n"
"\n"
"Table Compression:\n"
" -Ca, --align trade off larger tables for better memory alignment\n"
" -Ce, --ecs construct equivalence classes\n"
" -Cf do not compress tables; use -f representation\n"
" -CF do not compress tables; use -F representation\n"
" -Cm, --meta-ecs construct meta-equivalence classes\n"
" -Cr, --read use read() instead of stdio for scanner input\n"
" -f, --full generate fast, large scanner. Same as -Cfr\n"
" -F, --fast use alternate table representation. Same as -CFr\n"
" -Cem default compression (same as --ecs --meta-ecs)\n"
"\n"
"Debugging:\n"
" -d, --debug enable debug mode in scanner\n"
" -b, --backup write backing-up information to %s\n"
" -p, --perf-report write performance report to stderr\n"
" -s, --nodefault suppress default rule to ECHO unmatched text\n"
" -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"
"\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"
" --tables-file[=FILE] write tables to FILE\n"
"\n"
"Scanner behavior:\n"
" -7, --7bit generate 7-bit scanner\n"
" -8, --8bit generate 8-bit scanner\n"
" -B, --batch generate batch scanner (opposite of -I)\n"
" -i, --case-insensitive ignore case in patterns\n"
" -l, --lex-compat maximal compatibility with original lex\n"
" -X, --posix-compat maximal compatibility with POSIX lex\n"
" -I, --interactive generate interactive scanner (opposite of -B)\n"
" --yylineno track line count in yylineno\n"
"\n"
"Generated code:\n"
" -+, --c++ generate C++ scanner class\n"
" -Dmacro[=defn] #define macro defn (default defn is '1')\n"
" -L, --noline suppress #line directives in scanner\n"
" -P, --prefix=STRING use STRING as prefix instead of \"yy\"\n"
" -R, --reentrant generate a reentrant C scanner\n"
" --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"
" -c do-nothing POSIX option\n"
" -n do-nothing POSIX option\n"
" -?\n"
" -h, --help produce this help message\n"
" -V, --version report %s version\n"
msgstr ""
"Gera programas que realizam comparação de padrões em texto.\n"
"\n"
"Compressão de tabela:\n"
" -Ca, --align troca tabelas maiores para melhor alinhamento da memória\n"
" -Ce, --ecs constrói classes de equivalência\n"
" -Cf não comprime tabelas; usa representação -f\n"
" -CF não comprime tabelas; usa representação -F\n"
" -Cm, --meta-ecs constrói classes de meta-equivalência\n"
" -Cr, --read usa read() em vez de stdio para entrada do analisador\n"
" -f, --full gera analisador rápido e grande. Igual a -Cfr\n"
" -F, --fast usa representação de tabela alternativa. Igual a -CFr\n"
" -Cem compressão predefinida (igual a --ecs --meta-ecs)\n"
"\n"
"Depuração:\n"
" -d, --debug activa modo de depuração no analisador\n"
" -b, --backup escreve informação de segurança em %s\n"
" -p, --perf-report escreve relatório de desempenho em stderr\n"
" -s, --nodefault suprime regra predefinida para texto não comparado em ECHO\n"
" -T, --trace %s deve correr em modo de rasto\n"
" -w, --nowarn não gera avisos\n"
" -v, --verbose escreve resumo das estatísticas do analisador em stdout\n"
"\n"
"Ficheiros:\n"
" -o, --outfile=FICH especifica o ficheiro de saída\n"
" -S, --skel=FICH especifica o ficheiro esqueleto\n"
" -t, --stdout escreve o analisador em stdout em vez de %s\n"
" --yyclass=NOME nome da classe C++\n"
" --header-file=FICH cria um ficheiro de cabeçalho C além do analisador\n"
" --tables-file[=FICH] escreve tabelas em FICH\n"
"\n"
"Comportamento do analisador:\n"
" -7, --7bit gera analisador de 7-bit\n"
" -8, --8bit gera analisador de 8-bit\n"
" -B, --batch gera analisador em lote (oposto de -I)\n"
" -i, --case-insensitive ignora maiúsculas em padrões\n"
" -l, --lex-compat compatibilidade máxima com o léxico original\n"
" -X, --posix-compat compatibilidade máxima com o léxico POSIX\n"
" -I, --interactive gera analisador interactivo (oposto de -B)\n"
" --yylineno segue o total de linhas em yylineno\n"
"\n"
"Código gerado:\n"
" -+, --c++ gera classe de analisador C++\n"
" -Dmacro[=defn] #define macro defn (defn predefinido é \"1\")\n"
" -L, --noline suprime directivas #line no analisador\n"
" -P, --prefix=CADEIA usa CADEIA como prefixo em vez de \"yy\"\n"
" -R, --reentrant gera um analisador reentrant C\n"
" --bison-bridge analisador para processador de bison puro.\n"
" --bison-locations inclui suporte yylloc.\n"
" --stdinit inicializa yyin/yyout para stdin/stdout\n"
" --noansi-definitions definições de funções de estilo antigo\n"
" --noansi-prototypes lista de parâmetros em protótipos\n"
" --nounistd não inclui <unistd.h>\n"
" --noFUNÇÃO não gera uma FUNÇÃO em particular\n"
"\n"
"Mistas:\n"
" -c opção POSIX não-fazer-nada\n"
" -n opção POSIX não-fazer-nada\n"
" -?\n"
" -h, --help mostra esta mensagem de ajuda\n"
" -V, --version mostra a versão %s\n"
#: misc.c:65
msgid "allocation of sko_stack failed"
msgstr "falha ao alocar sko_stack"
#: misc.c:102 misc.c:128
#, c-format
msgid "name \"%s\" ridiculously long"
msgstr "nome \"%s\" ridiculamente longo"
#: misc.c:177
msgid "memory allocation failed in allocate_array()"
msgstr "falha ao alocar memória em allocate_array()"
#: misc.c:230
#, c-format
msgid "bad character '%s' detected in check_char()"
msgstr "mau carácter \"%s\" detectado em check_char()"
#: misc.c:235
#, c-format
msgid "scanner requires -8 flag to use the character %s"
msgstr "o analisador requer bandeira -8 para usar o carácter %s"
#: misc.c:268
msgid "dynamic memory failure in copy_string()"
msgstr "falha de memória dinâmica copy_string()"
#: misc.c:367
#, c-format
msgid "%s: fatal internal error, %s\n"
msgstr "%s: erro interno fatal, %s\n"
#: misc.c:803
msgid "attempt to increase array size failed"
msgstr "falha ao tentar aumentar o tamanho da matriz"
#: misc.c:930
msgid "bad line in skeleton file"
msgstr "má linha em ficheiro esqueleto"
#: misc.c:979
msgid "memory allocation failed in yy_flex_xmalloc()"
msgstr "falha ao alocar memória em yy_flex_xmalloc()"
#: nfa.c:104
#, c-format
msgid ""
"\n"
"\n"
"********** beginning dump of nfa with start state %d\n"
msgstr ""
"\n"
"\n"
"********** a começar o despejo de nfa com estado inicial %d\n"
#: nfa.c:115
#, c-format
msgid "state # %4d\t"
msgstr "estado nº %4d\t"
#: nfa.c:130
#, c-format
msgid "********** end of dump\n"
msgstr "********** fim de despejo\n"
#: nfa.c:174
msgid "empty machine in dupmachine()"
msgstr "máquina vazia em dupmachine()"
#: nfa.c:240
#, c-format
msgid "Variable trailing context rule at line %d\n"
msgstr "Regra variável de contexto final na linha %d\n"
#: nfa.c:364
msgid "bad state type in mark_beginning_as_normal()"
msgstr "mau tipo de estado em mark_beginning_as_normal()"
#: nfa.c:609
#, c-format
msgid "input rules are too complicated (>= %d NFA states)"
msgstr "regras de entrada muito complicadas (>= %d estados NFA)"
#: nfa.c:688
msgid "found too many transitions in mkxtion()"
msgstr "encontradas demasiadas transições em mkxtion()"
#: nfa.c:714
#, c-format
msgid "too many rules (> %d)!"
msgstr "demasiadas regras (> %d)!"
#: parse.y:159
msgid "unknown error processing section 1"
msgstr "erro desconhecido ao processar a secção 1"
#: parse.y:184 parse.y:351
msgid "bad start condition list"
msgstr "má lista de condição inicial"
#: parse.y:315
msgid "unrecognized rule"
msgstr "regra não reconhecida"
#: parse.y:434 parse.y:447 parse.y:516
msgid "trailing context used twice"
msgstr "contexto final usado duas vezes"
#: parse.y:552 parse.y:562 parse.y:635 parse.y:645
msgid "bad iteration values"
msgstr "maus valores de iteração"
#: parse.y:580 parse.y:598 parse.y:663 parse.y:681
msgid "iteration value must be positive"
msgstr "o valor de iteração tem de ser positivo"
#: parse.y:804 parse.y:814
#, c-format
msgid "the character range [%c-%c] is ambiguous in a case-insensitive scanner"
msgstr "o intervalo de caracteres [%c-%c] é ambíguo num analisador que ignora maiúsculas"
#: parse.y:819
msgid "negative range in character class"
msgstr "intervalo negativo em classe de carácter"
#: parse.y:916
msgid "[:^lower:] is ambiguous in case insensitive scanner"
msgstr "[:^lower:] é ambíguo num analisador que ignora maiúsculas"
#: parse.y:922
msgid "[:^upper:] ambiguous in case insensitive scanner"
msgstr "[:^upper:] é ambíguo num analisador que ignora maiúsculas"
#: scan.l:75 scan.l:618 scan.l:676
msgid "Input line too long\n"
msgstr "Linha de entrada muito grande\n"
#: scan.l:161
#, c-format
msgid "malformed '%top' directive"
msgstr "directiva \"%top\" mal formada"
#: scan.l:183
#, no-c-format
msgid "unrecognized '%' directive"
msgstr "directiva \"%\" não reconhecida"
#: scan.l:192
msgid "Definition name too long\n"
msgstr "Nome de definição muito longo\n"
#: scan.l:284
msgid "Unmatched '{'"
msgstr "{ sem par"
#: scan.l:300
#, c-format
msgid "Definition value for {%s} too long\n"
msgstr "Valor de definição para {%s} muito longo\n"
#: scan.l:317
msgid "incomplete name definition"
msgstr "Definição de nome incompleta"
#: scan.l:443
msgid "Option line too long\n"
msgstr "Linha de opção muito longa\n"
#: scan.l:451
#, c-format
msgid "unrecognized %%option: %s"
msgstr "%%opção não reconhecida: %s"
#: scan.l:633 scan.l:800
msgid "bad character class"
msgstr "má classe de carácter"
#: scan.l:683
#, c-format
msgid "undefined definition {%s}"
msgstr "definição {%s} indefinida"
#: scan.l:755
#, c-format
msgid "bad <start condition>: %s"
msgstr "má <condição inicial>: %s"
#: scan.l:768
msgid "missing quote"
msgstr "aspa em falta"
#: scan.l:834
#, c-format
msgid "bad character class expression: %s"
msgstr "má expressão de classe de carácter: %s"
#: scan.l:856
msgid "bad character inside {}'s"
msgstr "mau carácter dentro de {}"
#: scan.l:862
msgid "missing }"
msgstr "} em falta"
#: scan.l:940
msgid "EOF encountered inside an action"
msgstr "EOF encontrado dentro de uma acção"
#: scan.l:945
msgid "EOF encountered inside pattern"
msgstr "EOF encontrado dentro de um padrão"
#: scan.l:967
#, c-format
msgid "bad character: %s"
msgstr "mau carácter: %s"
#: scan.l:996
#, c-format
msgid "can't open %s"
msgstr "impossível abrir %s"
#: scanopt.c:291
#, c-format
msgid "Usage: %s [OPTIONS]...\n"
msgstr "Uso: %s [OPÇÕES]...\n"
#: scanopt.c:564
#, c-format
msgid "option `%s' doesn't allow an argument\n"
msgstr "a opção \"%s\" não permite um argumento\n"
#: scanopt.c:569
#, c-format
msgid "option `%s' requires an argument\n"
msgstr "a opção \"%s\" requer um argumento\n"
#: scanopt.c:573
#, c-format
msgid "option `%s' is ambiguous\n"
msgstr "a opção \"%s\" é ambígua\n"
#: scanopt.c:577
#, c-format
msgid "Unrecognized option `%s'\n"
msgstr "Opção \"%s\" não reconhecida\n"
#: scanopt.c:581
#, c-format
msgid "Unknown error=(%d)\n"
msgstr "Erro desconhecido=(%d)\n"
#: sym.c:100
msgid "symbol table memory allocation failed"
msgstr "falha ao alocar memória de tabela de símbolos"
#: sym.c:202
msgid "name defined twice"
msgstr "nome definido duas vezes"
#: sym.c:253
#, c-format
msgid "start condition %s declared twice"
msgstr "condição inicial %s declarada duas vezes"
#: yylex.c:56
msgid "premature EOF"
msgstr "EOF prematuro"
#: yylex.c:198
#, c-format
msgid "End Marker\n"
msgstr "Marcador final\n"
#: yylex.c:204
#, c-format
msgid "*Something Weird* - tok: %d val: %d\n"
msgstr "*Algo esquisito* - tok: %d val: %d\n"
po/pt_BR.po
+222 -186
View File
File diff suppressed because it is too large Load Diff
po/ro.po
+292 -178
View File
File diff suppressed because it is too large Load Diff
po/ru.po
+222 -184
View File
File diff suppressed because it is too large Load Diff
po/sr.po
+226 -189
View File
File diff suppressed because it is too large Load Diff
po/sv.po
+206 -179
View File
File diff suppressed because it is too large Load Diff
po/tr.po
+276 -172
View File
File diff suppressed because it is too large Load Diff
po/uk.po
+975
View File
@@ -0,0 +1,975 @@
# Ukrainian translations for flex.
# Copyright (C) 2017 The Flex Project (msgids)
# This file is distributed under the same license as the flex package.
#
# Viktor Shepel <shepelvictor@bigmir.net>, 2017.
# Yuri Chornoivan <yurchor@ukr.net>, 2017.
msgid ""
msgstr ""
"Project-Id-Version: flex 2.5.38\n"
"Report-Msgid-Bugs-To: flex-devel@lists.sourceforge.net\n"
"POT-Creation-Date: 2017-05-24 18:00-0400\n"
"PO-Revision-Date: 2017-06-17 09:26+0300\n"
"Last-Translator: Yuri Chornoivan <yurchor@ukr.net>\n"
"Language-Team: Ukrainian <translation-team-uk@lists.sourceforge.net>\n"
"Language: uk\n"
"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=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.5\n"
#: src/buf.c:79
msgid "Allocation of buffer to print string failed"
msgstr "Не вдалось виділити буфер для рядка, що виводиться"
#: src/buf.c:107
msgid "Allocation of buffer for line directive failed"
msgstr "Не вдалось виділити буфер для рядкової директиви"
#: src/buf.c:177
msgid "Allocation of buffer for m4 def failed"
msgstr "Не вдалось виділити буфер для m4 def"
#: src/buf.c:198
msgid "Allocation of buffer for m4 undef failed"
msgstr "Не вдалось виділити буфер для m4 undef"
#: src/dfa.c:59
#, c-format
msgid "State #%d is non-accepting -\n"
msgstr "Стан #%d не є допустимим -\n"
#: src/dfa.c:119
msgid "dangerous trailing context"
msgstr "небезпечний замикаючий контекст"
#: src/dfa.c:159
#, c-format
msgid " associated rule line numbers:"
msgstr " номера рядків асоційованого правила:"
#: src/dfa.c:193
#, c-format
msgid " out-transitions: "
msgstr " out-переходи: "
#: src/dfa.c:201
#, c-format
msgid ""
"\n"
" jam-transitions: EOF "
msgstr ""
"\n"
" jam-переходи: EOF "
#: src/dfa.c:331
msgid "consistency check failed in epsclosure()"
msgstr "помилка при перевірці на цілісність у epsclosure()"
#: src/dfa.c:419
msgid ""
"\n"
"\n"
"DFA Dump:\n"
"\n"
msgstr ""
"\n"
"\n"
"Дамп ДСА:\n"
"\n"
#: src/dfa.c:587
msgid "could not create unique end-of-buffer state"
msgstr "неможливо створити унікальний стан end_of_buffer"
#: src/dfa.c:608
#, c-format
msgid "state # %d:\n"
msgstr "стан # %d:\n"
#: src/dfa.c:768
msgid "Could not write yynxt_tbl[][]"
msgstr "Неможливо записати yynxt_tbl[][]"
#: src/dfa.c:1028
msgid "bad transition character detected in sympartition()"
msgstr "виявлено невірний символ переходу в sympartition()"
#: src/gen.c:480
msgid ""
"\n"
"\n"
"Equivalence Classes:\n"
"\n"
msgstr ""
"\n"
"\n"
"Класи еквівалентності:\n"
"\n"
#: src/gen.c:669 src/gen.c:698 src/gen.c:1218
#, c-format
msgid "state # %d accepts: [%d]\n"
msgstr "стан # %d приймає: [%d]\n"
#: src/gen.c:1115
#, c-format
msgid "state # %d accepts: "
msgstr "стан # %d приймає: "
#: src/gen.c:1162
msgid "Could not write yyacclist_tbl"
msgstr "Неможливо записати yyacclist_tbl"
#: src/gen.c:1236
msgid "Could not write yyacc_tbl"
msgstr "Неможливо записати yyacc_tbl"
#: src/gen.c:1251 src/gen.c:1623 src/gen.c:1646
msgid "Could not write ecstbl"
msgstr "Неможливо записати ecstbl"
#: src/gen.c:1271
msgid ""
"\n"
"\n"
"Meta-Equivalence Classes:\n"
msgstr ""
"\n"
"\n"
"Мета-Еквівалентні Класи:\n"
#: src/gen.c:1293
msgid "Could not write yymeta_tbl"
msgstr "Неможливо записати yymeta_tbl"
#: src/gen.c:1352
msgid "Could not write yybase_tbl"
msgstr "Неможливо записати yybase_tbl"
#: src/gen.c:1384
msgid "Could not write yydef_tbl"
msgstr "Неможливо записати yydef_tbl"
#: src/gen.c:1422
msgid "Could not write yynxt_tbl"
msgstr "Неможливо записати yynxt_tbl"
#: src/gen.c:1456
msgid "Could not write yychk_tbl"
msgstr "Неможливо записати yychk_tbl"
#: src/gen.c:1608 src/gen.c:1637
msgid "Could not write ftbl"
msgstr "Неможливо записати ftbl"
#: src/gen.c:1614
msgid "Could not write ssltbl"
msgstr "Неможливо записати ssltbl"
#: src/gen.c:1665
msgid "Could not write eoltbl"
msgstr "Неможливо записати eoltbl"
#: src/gen.c:1722
msgid "Could not write yynultrans_tbl"
msgstr "Неможливо записати yynultrans_tbl"
#: src/main.c:178
msgid "rule cannot be matched"
msgstr "неможливо застосувати правило"
#: src/main.c:183
msgid "-s option given but default rule can be matched"
msgstr ""
"вказано параметр -s, але правило за замовчуванням може бути застосоване"
#: src/main.c:221
msgid "Can't use -+ with -l option"
msgstr "Неможливо використовувати -+ з параметром -l"
#: src/main.c:224
msgid "Can't use -f or -F with -l option"
msgstr "Неможливо використовувати -f або -F з параметром -l"
#: src/main.c:228
msgid "Can't use --reentrant or --bison-bridge with -l option"
msgstr ""
"Неможливо використовувати --reentrant або --bison-bridge з параметром -l"
#: src/main.c:260
msgid "-Cf/-CF and -Cm don't make sense together"
msgstr "Параметри -Cf/-CF і -Cm разом не мають сенсу"
#: src/main.c:263
msgid "-Cf/-CF and -I are incompatible"
msgstr "Параметри -Cf/-CF і -I несумісні"
#: src/main.c:267
msgid "-Cf/-CF are incompatible with lex-compatibility mode"
msgstr "Параметри -Cf/-CF несумісні з режимом lex-compatibility"
#: src/main.c:272
msgid "-Cf and -CF are mutually exclusive"
msgstr "Параметри -Cf і -CF є взаємовиключними"
#: src/main.c:276
msgid "Can't use -+ with -CF option"
msgstr "Неможливо використовувати -+ з параметром -CF"
#: src/main.c:279
#, c-format
msgid "%array incompatible with -+ option"
msgstr "%array несумісний з параметром -+"
#: src/main.c:284
msgid "Options -+ and --reentrant are mutually exclusive."
msgstr "Параметри -+ і --reentrant є взаємовиключними."
#: src/main.c:287
msgid "bison bridge not supported for the C++ scanner."
msgstr "bison bridge не підтримується для сканера C++."
#: src/main.c:336 src/main.c:419
#, c-format
msgid "could not create %s"
msgstr "неможливо створити %s"
#: src/main.c:431
msgid "could not write tables header"
msgstr "Неможливо записати заголовок таблиць"
#: src/main.c:435
#, c-format
msgid "can't open skeleton file %s"
msgstr "Неможливо відкрити файл-каркас %s"
#: src/main.c:450
msgid "Prefix cannot include '[' or ']'"
msgstr "Префікс не може містити «[» або «]»"
#: src/main.c:474
msgid "allocation of macro definition failed"
msgstr "Не вдалось розмістити визначення макросу"
#: src/main.c:521
#, c-format
msgid "input error reading skeleton file %s"
msgstr "помилка читання файла-каркаса %s"
#: src/main.c:525
#, c-format
msgid "error closing skeleton file %s"
msgstr "помилка при закритті файла-каркаса %s"
#: src/main.c:711
#, c-format
msgid "error creating header file %s"
msgstr "помилка створення файла-заголовку %s"
#: src/main.c:719
#, c-format
msgid "error writing output file %s"
msgstr "помилка запису у вихідний файл %s"
#: src/main.c:723
#, c-format
msgid "error closing output file %s"
msgstr "помилка закриття вихідного файла %s"
#: src/main.c:727
#, c-format
msgid "error deleting output file %s"
msgstr "помилка видалення вихідного файла %s"
#: src/main.c:734
#, c-format
msgid "No backing up.\n"
msgstr "Резервне копіювання вимкнено.\n"
#: src/main.c:738
#, c-format
msgid "%d backing up (non-accepting) states.\n"
msgstr "резервне копіювання %d (недопустимих) станів.\n"
#: src/main.c:742
#, c-format
msgid "Compressed tables always back up.\n"
msgstr "Створення резервних копій стислих таблиць виконується завжди.\n"
#: src/main.c:745
#, c-format
msgid "error writing backup file %s"
msgstr "помилка запису резервної копії файла %s"
#: src/main.c:749
#, c-format
msgid "error closing backup file %s"
msgstr "помилка закриття резервної копії файла %s"
#: src/main.c:754
#, c-format
msgid "%s version %s usage statistics:\n"
msgstr "статистика використання %s версії %s:\n"
#: src/main.c:757
#, c-format
msgid " scanner options: -"
msgstr " параметри сканера: -"
#: src/main.c:836
#, c-format
msgid " %d/%d NFA states\n"
msgstr " %d/%d станів НСА\n"
#: src/main.c:838
#, c-format
msgid " %d/%d DFA states (%d words)\n"
msgstr " %d/%d станів ДСА (%d слів)\n"
#: src/main.c:840
#, c-format
msgid " %d rules\n"
msgstr " %d правил\n"
#: src/main.c:845
#, c-format
msgid " No backing up\n"
msgstr " Резервне копіювання вимкнено\n"
#: src/main.c:849
#, c-format
msgid " %d backing-up (non-accepting) states\n"
msgstr " резервне копіювання %d (недопустимих) станів\n"
#: src/main.c:854
#, c-format
msgid " Compressed tables always back-up\n"
msgstr " Створення резервних копій стислих таблиць виконується завжди\n"
#: src/main.c:858
#, c-format
msgid " Beginning-of-line patterns used\n"
msgstr " Використовуються шаблони початку рядка\n"
#: src/main.c:860
#, c-format
msgid " %d/%d start conditions\n"
msgstr " %d/%d початкових умов\n"
#: src/main.c:864
#, c-format
msgid " %d epsilon states, %d double epsilon states\n"
msgstr " %d епсилон-станів, %d подвійних епсилон-станів\n"
#: src/main.c:868
#, c-format
msgid " no character classes\n"
msgstr " відсутні класи символів\n"
#: src/main.c:872
#, c-format
msgid " %d/%d character classes needed %d/%d words of storage, %d reused\n"
msgstr ""
" %d/%d символьних класів потребують %d/%d слів для зберігання, %d "
"використано вдруге\n"
#: src/main.c:877
#, c-format
msgid " %d state/nextstate pairs created\n"
msgstr " створено %d пар стан/наступний-стан\n"
#: src/main.c:880
#, c-format
msgid " %d/%d unique/duplicate transitions\n"
msgstr " %d/%d унікальних/повторюваних переходів\n"
#: src/main.c:885
#, c-format
msgid " %d table entries\n"
msgstr " %d елементів таблиці\n"
#: src/main.c:893
#, c-format
msgid " %d/%d base-def entries created\n"
msgstr " створено %d/%d base-def елементів\n"
#: src/main.c:897
#, c-format
msgid " %d/%d (peak %d) nxt-chk entries created\n"
msgstr " створено %d/%d (пік %d) записів nxt-chk\n"
#: src/main.c:901
#, c-format
msgid " %d/%d (peak %d) template nxt-chk entries created\n"
msgstr " створено %d/%d (пік %d) шаблонних записів nxt-chk\n"
#: src/main.c:905
#, c-format
msgid " %d empty table entries\n"
msgstr " %d порожніх елементів таблиці\n"
#: src/main.c:907
#, c-format
msgid " %d protos created\n"
msgstr " створено %d прототипів\n"
#: src/main.c:910
#, c-format
msgid " %d templates created, %d uses\n"
msgstr " створено %d шаблонів, %d використовується\n"
#: src/main.c:918
#, c-format
msgid " %d/%d equivalence classes created\n"
msgstr " створено класів еквівалентності %d/%d\n"
#: src/main.c:926
#, c-format
msgid " %d/%d meta-equivalence classes created\n"
msgstr " створено класів мета-еквівалентності %d/%d\n"
#: src/main.c:932
#, c-format
msgid " %d (%d saved) hash collisions, %d DFAs equal\n"
msgstr " %d (%d записано) колізій хеш-таблиці, %d еквівалентних ДСА\n"
#: src/main.c:934
#, c-format
msgid " %d sets of reallocations needed\n"
msgstr " потрібно %d наборів повторних розміщень\n"
#: src/main.c:936
#, c-format
msgid " %d total table entries needed\n"
msgstr " всього потрібно %d елементів таблиці\n"
#: src/main.c:1010
#, c-format
msgid "Internal error. flexopts are malformed.\n"
msgstr "Внутрішня помилка. Неправильне значення flexopts.\n"
#: src/main.c:1020
#, c-format
msgid "Try `%s --help' for more information.\n"
msgstr "Спробуйте «%s --help» для отримання більш докладного опису.\n"
#: src/main.c:1077
#, c-format
msgid "unknown -C option '%c'"
msgstr "невідоме значення «%c» для параметру -C"
#: src/main.c:1206
#, c-format
msgid "%s %s\n"
msgstr "%s %s\n"
#: src/main.c:1486
msgid "fatal parse error"
msgstr "фатальна помилка розбору"
#: src/main.c:1518
#, c-format
msgid "could not create backing-up info file %s"
msgstr "неможливо створити резервну копію інформаційного файла %s"
#: src/main.c:1539
#, c-format
msgid "-l AT&T lex compatibility option entails a large performance penalty\n"
msgstr ""
"Параметр -l сумісності з AT&T lex спричиняє значне зниження продуктивності\n"
#: src/main.c:1542
#, c-format
msgid " and may be the actual source of other reported performance penalties\n"
msgstr "і також може бути істинним джерелом проблем з продуктивністю\n"
#: src/main.c:1548
#, c-format
msgid ""
"%%option yylineno entails a performance penalty ONLY on rules that can match "
"newline characters\n"
msgstr ""
"%%option yylineno спричиняе значне зниження продуктивності ТІЛЬКИ для "
"правил, котрі описують символи нового рядка\n"
#: src/main.c:1555
#, c-format
msgid "-I (interactive) entails a minor performance penalty\n"
msgstr "-I (інтерактивний) спричиняе незначне зниження продуктивності\n"
#: src/main.c:1560
#, c-format
msgid "yymore() entails a minor performance penalty\n"
msgstr "yymore() спричиняе незначне зниження продуктивності\n"
#: src/main.c:1566
#, c-format
msgid "REJECT entails a large performance penalty\n"
msgstr "REJECT спричиняе значне зниження продуктивності\n"
#: src/main.c:1571
#, c-format
msgid "Variable trailing context rules entail a large performance penalty\n"
msgstr ""
"Правила котрі мають замикаючий контекст змінної довжини значно знижують "
"продуктивність\n"
#: src/main.c:1583
msgid "REJECT cannot be used with -f or -F"
msgstr "REJECT не може бути використано разом з -f або -F"
#: src/main.c:1586
#, c-format
msgid "%option yylineno cannot be used with REJECT"
msgstr "%option yylineno не може бути використано з REJECT"
#: src/main.c:1589
msgid "variable trailing context rules cannot be used with -f or -F"
msgstr ""
"Правила котрі мають замикаючий контекст змінної довжини не можуть бути "
"використані з -f or -F"
#: src/main.c:1714
#, c-format
msgid "%option yyclass only meaningful for C++ scanners"
msgstr "%option yyclass має сенс тільки для сканерів C++"
#: src/main.c:1801
#, c-format
msgid "Usage: %s [OPTIONS] [FILE]...\n"
msgstr "Використання: %s [ПАРАМЕТРИ] [ФАЙЛ]…\n"
#: src/main.c:1804
#, fuzzy, c-format
msgid ""
"Generates programs that perform pattern-matching on text.\n"
"\n"
"Table Compression:\n"
" -Ca, --align trade off larger tables for better memory alignment\n"
" -Ce, --ecs construct equivalence classes\n"
" -Cf do not compress tables; use -f representation\n"
" -CF do not compress tables; use -F representation\n"
" -Cm, --meta-ecs construct meta-equivalence classes\n"
" -Cr, --read use read() instead of stdio for scanner input\n"
" -f, --full generate fast, large scanner. Same as -Cfr\n"
" -F, --fast use alternate table representation. Same as -CFr\n"
" -Cem default compression (same as --ecs --meta-ecs)\n"
"\n"
"Debugging:\n"
" -d, --debug enable debug mode in scanner\n"
" -b, --backup write backing-up information to %s\n"
" -p, --perf-report write performance report to stderr\n"
" -s, --nodefault suppress default rule to ECHO unmatched text\n"
" -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"
" --tables-file[=FILE] write tables to FILE\n"
"\n"
"Scanner behavior:\n"
" -7, --7bit generate 7-bit scanner\n"
" -8, --8bit generate 8-bit scanner\n"
" -B, --batch generate batch scanner (opposite of -I)\n"
" -i, --case-insensitive ignore case in patterns\n"
" -l, --lex-compat maximal compatibility with original lex\n"
" -X, --posix-compat maximal compatibility with POSIX lex\n"
" -I, --interactive generate interactive scanner (opposite of -B)\n"
" --yylineno track line count in yylineno\n"
"\n"
"Generated code:\n"
" -+, --c++ generate C++ scanner class\n"
" -Dmacro[=defn] #define macro defn (default defn is '1')\n"
" -L, --noline suppress #line directives in scanner\n"
" -P, --prefix=STRING use STRING as prefix instead of \"yy\"\n"
" -R, --reentrant generate a reentrant C scanner\n"
" --bison-bridge scanner for bison pure parser.\n"
" --bison-locations include yylloc support.\n"
" --stdinit initialize yyin/yyout to stdin/stdout\n"
" --nounistd do not include <unistd.h>\n"
" --noFUNCTION do not generate a particular FUNCTION\n"
"\n"
"Miscellaneous:\n"
" -c do-nothing POSIX option\n"
" -n do-nothing POSIX option\n"
" -?\n"
" -h, --help produce this help message\n"
" -V, --version report %s version\n"
msgstr ""
"Генерує програми, що знаходять шаблони у тексті.\n"
"\n"
"Стиснення таблиць:\n"
" -Ca, --align вирівняти таблиці у пам'яті збільшивши розмір\n"
" їх елементів\n"
" -Ce, --ecs створювати класи еквівалентності\n"
" -Cf не стискати таблиці; використовувати -f представлення\n"
" -CF не стискати таблиці; використовувати -F представлення\n"
" -Cm, --meta-ecs створювати класи мета-еквівалентності\n"
" -Cr, --read використати read() замість stdio як\n"
" вхідні дані сканера\n"
" -f, --full створити швидкий, великий сканер. Теж саме, що -Cfr\n"
" -F, --fast застосувати альтернативний опис таблиць.\n"
" Теж саме, що -CFr\n"
" -Cem степінь стиснення за замовчуванням\n"
" (теж саме, що --ecs --meta-ecs)\n"
"\n"
"Налагодження:\n"
" -d, --debug увімкнути режим налагодження сканера\n"
" -b, --backup записати резервну копію до %s\n"
" -p, --perf-report записати звіт про продуктивність до stderr\n"
" -s, --nodefault припинити вивід тексту (ECHO до stdout)\n"
" що не збігається з жодним правилом\n"
" -T, --trace %s повинен запускатися у режимі трасування\n"
" -w, --nowarn не видавати попереджень\n"
" -v, --verbose записати підсумкову статистику сканера до stdout\n"
"\n"
"Файли:\n"
" -o, --outfile=ФАЙЛ вказати ім'я вихідного файла\n"
" -S, --skel=ФАЙЛ вказати файл каркасу\n"
" -t, --stdout записати сканер до stdout замість %s\n"
" --yyclass=ІМ'Я ім'я класу C++\n"
" --header-file=ФАЙЛ створити C файл заголовок сканера\n"
" --tables-file[=ФАЙЛ] записати таблиці у ФАЙЛ\n"
"\n"
"Поведінка сканера:\n"
" -7, --7bit створити 7-бітний сканер\n"
" -8, --8bit створити 8-бітний сканер\n"
" -B, --batch створити пакетний сканер\n"
" (протилежна за властивостями до опції -I)\n"
" -i, --case-insensitive ігнорувати регістр символів у шаблонах\n"
" -l, --lex-compat максимальна сумісність з оригінальним lex\n"
" -X, --posix-compat максимальна сумісність з POSIX lex\n"
" -I, --interactive створити інтерактивний сканер\n"
" (протилежна за властивостями до опції -B)\n"
" --yylineno відслідковувати число рядків у yylineno\n"
"\n"
"Генерація коду:\n"
" -+, --c++ створити C++ клас сканера\n"
" -Dmacro[=defn] #define macro defn (за замовчуванням defn='1')\n"
" -L, --noline не створювати #line директиви для сканера\n"
" -P, --prefix=РЯДОК використати РЯДОК як префікс замість «yy»\n"
" -R, --reentrant генерувати реентерабельний C-сканер\n"
" --bison-bridge сканер тільки для bison аналізатору\n"
" --bison-locations додати підтримку yylloc\n"
" --stdinit ініціалізувати yyin/yyout до stdin/stdout\n"
" --noansi-definitions визначення функцій у застарілому стилі\n"
" --noansi-prototypes порожній список параметрів у прототипах\n"
" --nounistd не додавати <unistd.h>\n"
" --noФУНКЦІЯ не генерувати задану функцію ФУНКЦІЯ\n"
"\n"
"Інше:\n"
" -с недіючий POSIX параметр\n"
" -n недіючий POSIX параметр\n"
" -?\n"
" -h, --help показати цю довідку\n"
" -V, --version показати версію %s\n"
#: src/misc.c:64
msgid "allocation of sko_stack failed"
msgstr "не вдалось отримати пам’ять під sko_stack"
#: src/misc.c:100
#, c-format
msgid "name \"%s\" ridiculously long"
msgstr "ім'я «%s» занадто довге"
#: src/misc.c:149 src/misc.c:162
msgid "memory allocation failed in allocate_array()"
msgstr "помилка виділення пам'яті у allocate_array()"
#: src/misc.c:212
#, c-format
msgid "bad character '%s' detected in check_char()"
msgstr "check_char() виявив недопустимий символ «%s»"
#: src/misc.c:217
#, c-format
msgid "scanner requires -8 flag to use the character %s"
msgstr "для використання символу %s сканер потребує опцію -8"
#: src/misc.c:236
msgid "memory allocation failure in xstrdup()"
msgstr "помилка виділення пам'яті у xstrdup()"
#: src/misc.c:310
#, c-format
msgid "%s: fatal internal error, %s\n"
msgstr "%s: фатальна внутрішня помилка, %s\n"
#: src/misc.c:671 src/misc.c:683
msgid "attempt to increase array size failed"
msgstr "помилка при спробі збільшити розмір масиву"
#: src/misc.c:807
msgid "bad line in skeleton file"
msgstr "невідомий рядок у файлі-каркасі"
#: src/misc.c:857
msgid "memory allocation failed in yy_flex_xmalloc()"
msgstr "помилка виділення пам'яті у yy_flex_xmalloc()"
#: src/nfa.c:100
#, c-format
msgid ""
"\n"
"\n"
"********** beginning dump of nfa with start state %d\n"
msgstr ""
"\n"
"\n"
"********** початок дампу НСА з початковим станом %d\n"
#: src/nfa.c:111
#, c-format
msgid "state # %4d\t"
msgstr "стан # %4d\t"
#: src/nfa.c:126
#, c-format
msgid "********** end of dump\n"
msgstr "********** кінець дампу\n"
#: src/nfa.c:169
msgid "empty machine in dupmachine()"
msgstr "порожній автомат у dupmachine()"
#: src/nfa.c:234
#, c-format
msgid "Variable trailing context rule at line %d\n"
msgstr "Правило із замикаючим контекстом змінної довжини у стрічці %d\n"
#: src/nfa.c:357
msgid "bad state type in mark_beginning_as_normal()"
msgstr "невідомий тип стану у mark_beginning_as_normal()"
#: src/nfa.c:595
#, c-format
msgid "input rules are too complicated (>= %d NFA states)"
msgstr "вхідні правила занадто складні (>= %d станів НСА)"
#: src/nfa.c:673
msgid "found too many transitions in mkxtion()"
msgstr "знайдено занадто багато переходів у mkxtion()"
#: src/nfa.c:699
#, c-format
msgid "too many rules (> %d)!"
msgstr "занадто багато правил (> %d)!"
#: src/parse.y:159
msgid "unknown error processing section 1"
msgstr "невідома помилка при обробці розділу 1"
#: src/parse.y:184 src/parse.y:353
msgid "bad start condition list"
msgstr "невірний список початкових умов"
#: src/parse.y:204
msgid "Prefix must not contain [ or ]"
msgstr "Префікс не може містити символи «[» або «]»"
#: src/parse.y:317
msgid "unrecognized rule"
msgstr "нерозпізнане правило"
#: src/parse.y:436 src/parse.y:449 src/parse.y:518
msgid "trailing context used twice"
msgstr "замикаючий контекст використано двічі"
#: src/parse.y:554 src/parse.y:564 src/parse.y:637 src/parse.y:647
msgid "bad iteration values"
msgstr "невірно сформований діапазон ітерацій"
#: src/parse.y:582 src/parse.y:600 src/parse.y:665 src/parse.y:683
msgid "iteration value must be positive"
msgstr "кількість ітерацій повинна бути додатнім числом"
#: 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] є двозначним для сканера, що не "
"чутливий до регістру символів"
#: src/parse.y:821
msgid "negative range in character class"
msgstr ""
"символьний клас описано діапазоном, перший елемент котрого більший за "
"останній"
#: src/parse.y:918
msgid "[:^lower:] is ambiguous in case insensitive scanner"
msgstr ""
"використання [:^lower:] є невизначеним для сканера, що не чутливий до "
"регістру символів"
#: src/parse.y:924
msgid "[:^upper:] ambiguous in case insensitive scanner"
msgstr ""
"використання [:^upper:] є невизначеним для сканера, що не чутливий до "
"регістру символів"
#: src/scan.l:82 src/scan.l:646 src/scan.l:704
msgid "Input line too long\n"
msgstr "Занадто довгий вхідний рядок\n"
#: src/scan.l:183
#, c-format
msgid "malformed '%top' directive"
msgstr "нерозпізнана директива «%top»"
#: src/scan.l:205
#, no-c-format
msgid "unrecognized '%' directive"
msgstr "нерозпізнана директива «%»"
#: src/scan.l:214
msgid "Definition name too long\n"
msgstr "Визначення має занадто довге ім'я\n"
#: src/scan.l:309
msgid "Unmatched '{'"
msgstr "Непарна «{»"
#: src/scan.l:325
#, c-format
msgid "Definition value for {%s} too long\n"
msgstr "Визначення {%s} має занадто довге значення\n"
#: src/scan.l:342
msgid "incomplete name definition"
msgstr "неповне визначення імені"
#: src/scan.l:469
msgid "Option line too long\n"
msgstr "Занадто довгий параметр\n"
#: src/scan.l:477
#, c-format
msgid "unrecognized %%option: %s"
msgstr "нерозпізнаний %%option: %s"
#: src/scan.l:661 src/scan.l:834
msgid "bad character class"
msgstr "помилковий символьний клас"
#: src/scan.l:711
#, c-format
msgid "undefined definition {%s}"
msgstr "нерозпізнане визначення {%s}"
#: src/scan.l:774
msgid "unbalanced parenthesis"
msgstr "незбалансовані круглі дужки"
#: src/scan.l:789
#, c-format
msgid "bad <start condition>: %s"
msgstr "невірно сформованана <умова, що активує правило>: %s"
#: src/scan.l:802
msgid "missing quote"
msgstr "відсутні лапки"
#: src/scan.l:868
#, c-format
msgid "bad character class expression: %s"
msgstr "символьний клас заданий некоректним виразом: %s"
#: src/scan.l:890
msgid "bad character inside {}'s"
msgstr "неприйнятний символ всередині {}"
#: src/scan.l:896
msgid "missing }"
msgstr "відсутній }"
#: src/scan.l:974
msgid "EOF encountered inside an action"
msgstr "знайдено EOF всередині коду котрий асоційований з правилом"
#: src/scan.l:979
msgid "EOF encountered inside pattern"
msgstr "знайдено EOF всередині шаблону, що задає правило"
#: src/scan.l:1012
#, c-format
msgid "bad character: %s"
msgstr "неочікуваний символ: %s"
#: src/scan.l:1040
#, c-format
msgid "can't open %s"
msgstr "неможливо відкрити %s"
#: src/scanopt.c:259
#, c-format
msgid "Usage: %s [OPTIONS]...\n"
msgstr "Використання: %s [ПАРАМЕТРИ]…\n"
#: src/scanopt.c:524
#, c-format
msgid "option `%s' doesn't allow an argument\n"
msgstr "параметр «%s» повинен використовуватись без аргументу\n"
#: src/scanopt.c:529
#, c-format
msgid "option `%s' requires an argument\n"
msgstr "параметр «% s» повинен використовуватись з аргументом\n"
#: src/scanopt.c:533
#, c-format
msgid "option `%s' is ambiguous\n"
msgstr "параметр «%s» є двозначним\n"
#: src/scanopt.c:537
#, c-format
msgid "Unrecognized option `%s'\n"
msgstr "Нерозпізнаний параметр «%s»\n"
#: src/scanopt.c:541
#, c-format
msgid "Unknown error=(%d)\n"
msgstr "Невідома помилка=(%d)\n"
#: src/sym.c:92
msgid "symbol table memory allocation failed"
msgstr "помилка виділення пам'яті для таблиці символів"
#: src/sym.c:183
msgid "name defined twice"
msgstr "ім'я визначено двічі"
#: src/sym.c:231
#, c-format
msgid "start condition %s declared twice"
msgstr "початкова умова %s описана двічі"
#: src/yylex.c:57
msgid "premature EOF"
msgstr "неочікуваний EOF"
#: src/yylex.c:200
#, c-format
msgid "End Marker\n"
msgstr "Мітка кінця\n"
#: 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 "помилка під час роботи з динамічною пам’яттю у copy_string()"
po/update_linguas.sh
Executable
+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
po/vi.po
+239 -194
View File
File diff suppressed because it is too large Load Diff
po/zh_CN.po
+194 -174
View File
File diff suppressed because it is too large Load Diff
po/zh_TW.po
+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() 中動態記憶體失敗"
src/.gitignore
+2 -1
View File
@@ -4,9 +4,10 @@
config.h
config.h.in
flex
libfl.pc
parse.c
parse.h
scan.c
skel.c
cpp-skel.h
stage1scan.[cl]
stage1flex
src/Makefile.am
+56 -26
View File
@@ -1,7 +1,7 @@
AM_YFLAGS = -d
localedir = $(datadir)/locale
AM_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\" -I$(top_srcdir)/intl
AM_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\"
LIBS = @LIBS@
pkgconfigdir = @pkgconfigdir@
m4 = @M4@
@@ -12,6 +12,7 @@ endif
if ENABLE_LIBFL
lib_LTLIBRARIES = libfl.la
pkgconfig_DATA = libfl.pc
endif
libfl_la_SOURCES = \
libmain.c \
@@ -22,12 +23,30 @@ 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 = \
cpp-skel.h \
stage1scan.c
flex_CFLAGS = $(AM_CFLAGS) $(WARNINGFLAGS)
@@ -35,11 +54,13 @@ flex_CFLAGS = $(AM_CFLAGS) $(WARNINGFLAGS)
COMMON_SOURCES = \
buf.c \
ccl.c \
cpp_backend.c \
dfa.c \
ecs.c \
filter.c \
flexdef.h \
flexint.h \
flexint_shared.h \
gen.c \
main.c \
misc.c \
@@ -51,7 +72,6 @@ COMMON_SOURCES = \
scanflags.c \
scanopt.c \
scanopt.h \
skel.c \
sym.c \
tables.c \
tables.h \
@@ -63,40 +83,48 @@ COMMON_SOURCES = \
LDADD = $(LIBOBJS) @LIBINTL@
$(LIBOBJS): $(LIBOBJDIR)$(am__dirstamp)
include_HEADERS = \
FlexLexer.h
EXTRA_DIST = \
flex.skl \
cpp-flex.skl \
mkskel.sh \
gettext.h
CLEANFILES = stage1scan.c stage1flex$(EXEEXT)
CLEANFILES = stage1scan.c stage1flex$(EXEEXT) cpp-skel.h
MAINTAINERCLEANFILES = skel.c
MAINTAINERCLEANFILES = c9pp-skel.h
skel.c: flex.skl mkskel.sh flexint.h tables_shared.h tables_shared.c
sed 's/4_/a4_/g; s/m4preproc_/m4_/g' $< | \
$(m4) -P -I $(srcdir) \
-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 .` | \
$(SHELL) $(srcdir)/mkskel.sh > $@.tmp
mv $@.tmp $@
flex-cpp_backend.$(OBJEXT): cpp-skel.h
cpp-skel.h: cpp-flex.skl mkskel.sh flexint_shared.h tables_shared.h tables_shared.c
$(SHELL) $(srcdir)/mkskel.sh cpp $(srcdir) $(m4) $(VERSION) > $@.tmp
mv -f $@.tmp $@
if ENABLE_BOOTSTRAP
stage1scan.c: scan.l stage1flex$(EXEEXT)
./stage1flex$(EXEEXT) $(AM_LFLAGS) $(LFLAGS) -o $@ $<
./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) && \
./flex$(EXEEXT) -o scan.c $< && \
mv -f scan.c $(distdir)
# make needs to be told to make parse.h so that parallelized runs will
# not fail.
main.c: parse.h
yylex.c: parse.h
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
@@ -135,12 +163,14 @@ indentfiles = \
tables_shared.h \
tblcmp.c
indent:
if [ -f .indent.pro ] ; then \
for f in $(indentfiles);\
do\
echo indenting $$f ;\
f='$(srcdir)'/$$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
src/buf.c
+1 -1
View File
@@ -259,7 +259,7 @@ struct Buf *buf_append (struct Buf *buf, const void *ptr, int n_elem)
buf->nmax = n_alloc;
}
memcpy (buf->elts + (size_t) buf->nelts * buf->elt_size, ptr,
memcpy ((char *) buf->elts + (size_t) buf->nelts * buf->elt_size, ptr,
(size_t) n_elem * buf->elt_size);
buf->nelts += n_elem;
src/ccl.c
+7
View File
@@ -73,6 +73,13 @@ void ccladd (int cclp, int ch)
newpos = ind + len;
/* For a non-last cclp, expanding the set will overflow and overwrite a
* char in the next cclp.
* FIXME: Need another allocation scheme for ccl's. */
if (cclp != lastccl) {
flexfatal(_("internal error: trying to add a char to a non-last ccl.\n"));
}
if (newpos >= current_max_ccl_tbl_size) {
current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT;
src/flex.skl → src/cpp-flex.skl
+1602 -1035
View File
File diff suppressed because it is too large Load Diff
src/cpp_backend.c
+639
View File
@@ -0,0 +1,639 @@
/* flex - tool to generate fast lexical analyzers */
/* Copyright (c) 1990 The Regents of the University of California. */
/* All rights reserved. */
/* 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. */
/* This file is part of flex. */
/* 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. */
#include "flexdef.h"
/* Code specific to the C/C++ back end starts here */
static const char *cpp_suffix (void)
{
char *suffix;
if (C_plus_plus)
suffix = "cc";
else
suffix = "c";
return suffix;
}
/* cpp_prolog - make rules prolog specific to cpp-using languages.
*
* If you don't ship this, you will effectively be assuming that your
* parsers are always reentrant, always allow reject, always have a
* yywrap() method, have a debug member in the wrapper class, and are
* interactive. This eliminates most of the boilerplate in the C/C++
* scanner prolog. It means such parsers will be a bit larger and
* slower than C/C++ ones, but since we're not running on 1987's
* hardware we officially do not care.
*
* A detail to beware of: If you're not issuing this prologue, you may
* want to write your own definition of YY_CHAR in your skel
* file. It's a typedef to an unsigned octet in C/C++, but if your
* target language has a Unicode code-point type like Go's 'rune' is
* may be appropriate.
*/
static void cpp_prolog (void)
{
static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
static char yy_nostdinit[] =
"FILE *yyin = NULL, *yyout = NULL;";
if (!do_yywrap) {
if (!C_plus_plus) {
if (reentrant)
out_str ("\n#define %swrap(yyscanner) (/*CONSTCOND*/1)\n", prefix);
else
out_str ("\n#define %swrap() (/*CONSTCOND*/1)\n", prefix);
}
outn ("#define YY_SKIP_YYWRAP");
}
if (ddebug)
outn ("\n#define FLEX_DEBUG");
OUT_BEGIN_CODE ();
outn ("typedef flex_uint8_t YY_CHAR;");
OUT_END_CODE ();
if (C_plus_plus) {
outn ("#define yytext_ptr yytext");
if (interactive)
outn ("#define YY_INTERACTIVE");
}
else {
OUT_BEGIN_CODE ();
/* In reentrant scanner, stdinit is handled in flex.skl. */
if (do_stdinit) {
if (reentrant){
outn ("#ifdef VMS");
outn ("#ifdef __VMS_POSIX");
outn ("#define YY_STDINIT");
outn ("#endif");
outn ("#else");
outn ("#define YY_STDINIT");
outn ("#endif");
}
outn ("#ifdef VMS");
outn ("#ifndef __VMS_POSIX");
outn (yy_nostdinit);
outn ("#else");
outn (yy_stdinit);
outn ("#endif");
outn ("#else");
outn (yy_stdinit);
outn ("#endif");
}
else {
if(!reentrant)
outn (yy_nostdinit);
}
OUT_END_CODE ();
}
OUT_BEGIN_CODE ();
if (fullspd)
outn ("typedef const struct yy_trans_info *yy_state_type;");
else if (!C_plus_plus)
outn ("typedef int yy_state_type;");
OUT_END_CODE ();
if (lex_compat)
outn ("#define YY_FLEX_LEX_COMPAT");
if (!C_plus_plus && !reentrant) {
outn ("extern int yylineno;");
OUT_BEGIN_CODE ();
outn ("int yylineno = 1;");
OUT_END_CODE ();
}
if (C_plus_plus) {
outn ("\n#include <FlexLexer.h>");
if (!do_yywrap) {
outn("\nint yyFlexLexer::yywrap() { return 1; }");
}
if (yyclass) {
outn ("int yyFlexLexer::yylex()");
outn ("\t{");
outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );");
outn ("\treturn 0;");
outn ("\t}");
out_str ("\n#define YY_DECL int %s::yylex()\n",
yyclass);
}
}
else {
/* Watch out: yytext_ptr is a variable when yytext is an array,
* but it's a macro when yytext is a pointer.
*/
if (yytext_is_array) {
if (!reentrant)
outn ("extern char yytext[];\n");
}
else {
if (reentrant) {
outn ("#define yytext_ptr yytext_r");
}
else {
outn ("extern char *yytext;");
outn("#ifdef yytext_ptr");
outn("#undef yytext_ptr");
outn("#endif");
outn ("#define yytext_ptr yytext");
}
}
if (yyclass)
flexerror (_
("%option yyclass only meaningful for C++ scanners"));
}
}
static void cpp_epilog (void)
{
#if 0
fprintf (header_out,
"#ifdef YY_HEADER_EXPORT_START_CONDITIONS\n");
fprintf (header_out,
"/* Beware! Start conditions are not prefixed. */\n");
/* Special case for "INITIAL" */
fprintf (header_out,
"#undef INITIAL\n#define INITIAL 0\n");
for (i = 2; i <= lastsc; i++)
fprintf (header_out, "#define %s %d\n", scname[i], i - 1);
fprintf (header_out,
"#endif /* YY_HEADER_EXPORT_START_CONDITIONS */\n\n");
/* Kill ALL flex-related macros. This is so the user
* can #include more than one generated header file. */
fprintf (header_out, "#ifndef YY_HEADER_NO_UNDEFS\n");
fprintf (header_out,
"/* Undefine all internal macros, etc., that do no belong in the header. */\n\n");
{
const char * undef_list[] = {
"BEGIN",
"ECHO",
"EOB_ACT_CONTINUE_SCAN",
"EOB_ACT_END_OF_FILE",
"EOB_ACT_LAST_MATCH",
"FLEX_SCANNER",
"REJECT",
"YYFARGS0",
"YYFARGS1",
"YYFARGS2",
"YYFARGS3",
"YYLMAX",
"YYSTATE",
"YY_AT_BOL",
"YY_BREAK",
"YY_BUFFER_EOF_PENDING",
"YY_BUFFER_NEW",
"YY_BUFFER_NORMAL",
"YY_BUF_SIZE",
"M4_YY_CALL_LAST_ARG",
"M4_YY_CALL_ONLY_ARG",
"YY_CURRENT_BUFFER",
"YY_DECL",
"M4_YY_DECL_LAST_ARG",
"M4_YY_DEF_LAST_ARG",
"M4_YY_DEF_ONLY_ARG",
"YY_DO_BEFORE_ACTION",
"YY_END_OF_BUFFER",
"YY_END_OF_BUFFER_CHAR",
"YY_EXIT_FAILURE",
"YY_EXTRA_TYPE",
"YY_FATAL_ERROR",
"YY_FLEX_DEFINED_ECHO",
"YY_FLEX_LEX_COMPAT",
"YY_FLEX_MAJOR_VERSION",
"YY_FLEX_MINOR_VERSION",
"YY_FLEX_SUBMINOR_VERSION",
"YY_FLUSH_BUFFER",
"YY_G",
"YY_INPUT",
"YY_INTERACTIVE",
"YY_INT_ALIGNED",
"YY_LAST_ARG",
"YY_LESS_LINENO",
"YY_LEX_ARGS",
"YY_LEX_DECLARATION",
"YY_LEX_PROTO",
"YY_MAIN",
"YY_MORE_ADJ",
"YY_NEED_STRLEN",
"YY_NEW_FILE",
"YY_NULL",
"YY_NUM_RULES",
"YY_ONLY_ARG",
"YY_PARAMS",
"YY_PROTO",
"M4_YY_PROTO_LAST_ARG",
"M4_YY_PROTO_ONLY_ARG void",
"YY_READ_BUF_SIZE",
"YY_REENTRANT",
"YY_RESTORE_YY_MORE_OFFSET",
"YY_RULE_SETUP",
"YY_SC_TO_UI",
"YY_SKIP_YYWRAP",
"YY_START",
"YY_START_STACK_INCR",
"YY_STATE_EOF",
"YY_STDINIT",
"YY_TRAILING_HEAD_MASK",
"YY_TRAILING_MASK",
"YY_USER_ACTION",
"YY_USE_CONST",
"YY_USE_PROTOS",
"unput",
"yyTABLES_NAME",
"yy_create_buffer",
"yy_delete_buffer",
"yy_flex_debug",
"yy_flush_buffer",
"yy_init_buffer",
"yy_load_buffer_state",
"yy_new_buffer",
"yy_scan_buffer",
"yy_scan_bytes",
"yy_scan_string",
"yy_set_bol",
"yy_set_interactive",
"yy_switch_to_buffer",
"yypush_buffer_state",
"yypop_buffer_state",
"yyensure_buffer_stack",
"yyalloc",
"const",
"yyextra",
"yyfree",
"yyget_debug",
"yyget_extra",
"yyget_in",
"yyget_leng",
"yyget_column",
"yyget_lineno",
"yyget_lloc",
"yyget_lval",
"yyget_out",
"yyget_text",
"yyin",
"yyleng",
"yyless",
"yylex",
"yylex_destroy",
"yylex_init",
"yylex_init_extra",
"yylineno",
"yylloc",
"yylval",
"yymore",
"yyout",
"yyrealloc",
"yyrestart",
"yyset_debug",
"yyset_extra",
"yyset_in",
"yyset_column",
"yyset_lineno",
"yyset_lloc",
"yyset_lval",
"yyset_out",
"yytables_destroy",
"yytables_fload",
"yyterminate",
"yytext",
"yytext_ptr",
"yywrap",
/* must be null-terminated */
NULL};
for (i=0; undef_list[i] != NULL; i++)
fprintf (header_out, "#undef %s\n", undef_list[i]);
}
/* undef any of the auto-generated symbols. */
for (i = 0; i < defs_buf.nelts; i++) {
/* don't undef start conditions */
if (sclookup (((char **) defs_buf.elts)[i]) > 0)
continue;
fprintf (header_out, "#undef %s\n",
((char **) defs_buf.elts)[i]);
}
fprintf (header_out,
"#endif /* !YY_HEADER_NO_UNDEFS */\n");
fprintf (header_out, "\n");
fprintf (header_out, "#undef %sIN_HEADER\n", prefix);
fprintf (header_out, "#endif /* %sHEADER_H */\n", prefix);
if (ferror (header_out))
lerr (_("error creating header file %s"),
headerfilename);
fflush (header_out);
fclose (header_out);
#endif
}
static const char *cpp_yy_int_aligned(void)
{
return long_align ? "long int" : "short int";
}
static void cpp_comment(const char *txt)
{
out_str("/* [[%s]] */\n", txt);
}
static const char *cpp_get_int16_decl (void)
{
return (gentables)
? "static const flex_int16_t %s[%d] =\n { 0,\n"
: "static const flex_int16_t * %s = 0;\n";
}
static const char *cpp_get_int32_decl (void)
{
return (gentables)
? "static const flex_int32_t %s[%d] =\n { 0,\n"
: "static const flex_int32_t * %s = 0;\n";
}
static const char *cpp_get_state_decl (void)
{
return (gentables)
? "static const yy_state_type %s[%d] =\n { 0,\n"
: "static const yy_state_type * %s = 0;\n";
}
static const char *cpp_get_yy_char_decl (void)
{
return (gentables)
? "static const YY_CHAR %s[%d] =\n { 0,\n"
: "static const YY_CHAR * %s = 0;\n";
}
static void cpp_ntod(size_t num_full_table_rows)
// Generate nxt table for ntod
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
long_align ? "flex_int32_t" : "flex_int16_t");
/* Unless -Ca, declare it "short" because it's a real
* long-shot that that won't be large enough.
*/
if (gentables)
out_str_dec
("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 const %s *yy_nxt =0;\n",
long_align ? "flex_int32_t" : "flex_int16_t");
}
}
static void cpp_mkeoltbl()
// Make end-of-line-table - only used when yylinemo tracking is on
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(%s)},\n",
"flex_int32_t");
}
static void cpp_geneoltbl(size_t sz)
// Generate end-of-line-transitions - only used when yylineno tracking is on
{
outn ("/* Table of booleans, true if rule could match eol. */");
out_str_dec (cpp_get_int32_decl (), "yy_rule_can_match_eol", sz);
}
static void cpp_mkctbl (size_t sz)
// Make full-speed compressed transition table
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(%s)},\n",
(sz >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_mkssltbl (void)
// Make start_state_list table
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(%s)},\n",
"struct yy_trans_info*");
}
static void cpp_gen_yy_trans(size_t sz)
// Table of verify for transition and offset to next state. (sic)
{
if (gentables)
out_dec ("static const struct yy_trans_info yy_transition[%d] =\n {\n", sz);
else
outn ("static const struct yy_trans_info *yy_transition = 0;");
}
static void cpp_start_state_list(size_t sz)
// Start initializer for table of pointers to start state
{
/* Table of pointers to start states. */
if (gentables)
out_dec ("static const struct yy_trans_info *yy_start_state_list[%d] =\n", sz);
else
outn ("static const struct yy_trans_info **yy_start_state_list =0;");
}
static void cpp_mkecstbl(void)
// Make equivalence-class tables
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_EC, (void**)&yy_ec, sizeof(%s)},\n",
"YY_CHAR");
}
static void cpp_mkftbl(void)
// Make full table
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
long_align ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_gentabs_acclist(void)
// Generate accept list initializer
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n",
long_align ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_gentabs_accept(void)
// Generate accept table initializer
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
long_align ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_gentabs_yy_meta(void)
// Generate yy_meta table initializer
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_META, (void**)&yy_meta, sizeof(%s)},\n",
"YY_CHAR");
}
static void cpp_gentabs_yy_base(void)
// Generate yy_meta base initializer
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n",
(tblend >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_gentabs_yy_def(size_t total_states)
// Generate yy_def initializer
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_DEF, (void**)&yy_def, sizeof(%s)},\n",
(total_states >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_gentabs_yy_nxt(size_t total_states)
// Generate yy_nxt initializer
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
(total_states >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_gentabs_yy_chk(size_t total_states)
// Generate yy_chk initializer
{
buf_prints (&yydmap_buf,
"\t{YYTD_ID_CHK, (void**)&yy_chk, sizeof(%s)},\n",
(total_states >= INT16_MAX
|| long_align) ? "flex_int32_t" : "flex_int16_t");
}
static void cpp_nultrans(int fullspd)
// Generate nulltrans initializer
{
// Making this a backend method may be overzealous.
// How many other languages have to sprcial-case NUL
// because it's a string terminator?
buf_prints (&yydmap_buf,
"\t{YYTD_ID_NUL_TRANS, (void**)&yy_NUL_trans, sizeof(%s)},\n",
(fullspd) ? "struct yy_trans_info*" :
"flex_int32_t");
}
static const char *cpp_trans_offset_type(int total_table_size)
{
return (total_table_size >= INT16_MAX || long_align) ?
"flex_int32_t" : "flex_int16_t";
}
const char *cpp_skel[] = {
#include "cpp-skel.h"
0,
};
/* This backend is only accessed through this method table */
struct flex_backend_t cpp_backend = {
.suffix = cpp_suffix,
.prolog = cpp_prolog,
.skel = cpp_skel,
.epilog = cpp_epilog,
.yy_int_aligned = cpp_yy_int_aligned,
.trace_fmt = "#line %d \"%s\"\n",
.int_define_fmt = "#define %s %d\n",
.string_define_fmt = "#define %s %s\n",
.table_opener = " {",
.table_continuation = " },\n",
.table_closer = " };\n",
.dyad = " {%4d,%4d },",
.comment = cpp_comment,
.get_int16_decl = cpp_get_int16_decl,
.get_int32_decl = cpp_get_int32_decl,
.get_state_decl = cpp_get_state_decl,
.get_yy_char_decl = cpp_get_yy_char_decl,
.ntod = cpp_ntod,
.mkeoltbl = cpp_mkeoltbl,
.geneoltbl = cpp_geneoltbl,
.mkctbl = cpp_mkctbl,
.mkssltbl = cpp_mkssltbl,
.gen_yy_trans = cpp_gen_yy_trans,
.start_state_list = cpp_start_state_list,
.state_entry_fmt = " &yy_transition[%d],\n",
.mkecstbl = cpp_mkecstbl,
.mkftbl = cpp_mkftbl,
.gentabs_acclist = cpp_gentabs_acclist,
.gentabs_accept = cpp_gentabs_accept,
.gentabs_yy_meta = cpp_gentabs_yy_meta,
.gentabs_yy_base = cpp_gentabs_yy_base,
.gentabs_yy_def = cpp_gentabs_yy_def,
.gentabs_yy_nxt = cpp_gentabs_yy_nxt,
.gentabs_yy_chk = cpp_gentabs_yy_chk,
.nultrans = cpp_nultrans,
.trans_offset_type = cpp_trans_offset_type,
.caseprefix = "case ",
.fallthrough = NULL,
.endcase = "yyterminate();",
.c_like = 1,
};
src/dfa.c
+8 -32
View File
@@ -463,14 +463,9 @@ void ntod (void)
/* 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)
@@ -522,27 +517,10 @@ void ntod (void)
sizeof (flex_int32_t));
yynxt_curr = 0;
buf_prints (&yydmap_buf,
"\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
long_align ? "flex_int32_t" : "flex_int16_t");
/* Unless -Ca, declare it "short" because it's a real
* long-shot that that won't be large enough.
*/
if (gentables)
out_str_dec
("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 const %s *yy_nxt =0;\n",
long_align ? "flex_int32_t" : "flex_int16_t");
}
backend->ntod(num_full_table_rows);
if (gentables)
outn (" {");
outn (backend->table_opener);
/* Generate 0 entries for state #0. */
for (i = 0; i < num_full_table_rows; ++i) {
@@ -552,7 +530,7 @@ void ntod (void)
dataflush ();
if (gentables)
outn (" },\n");
outn (backend->table_continuation);
}
/* Create the first states. */
@@ -705,10 +683,8 @@ void ntod (void)
yynxt_tbl->td_hilen *
yynxt_tbl->td_lolen *
sizeof (flex_int32_t));
if (gentables)
outn (" {");
outn (backend->table_opener);
/* Supply array's 0-element. */
if (ds == end_of_buffer_state) {
@@ -733,7 +709,7 @@ void ntod (void)
dataflush ();
if (gentables)
outn (" },\n");
out (backend->table_continuation);
}
else if (fullspd)
src/filter.c
+22 -26
View File
@@ -47,10 +47,9 @@ struct filter *filter_create_ext (struct filter *chain, const char *cmd,
va_list ap;
/* allocate and initialize new filter */
f = malloc(sizeof(struct filter));
f = calloc(sizeof(struct filter), 1);
if (!f)
flexerror(_("malloc failed (f) in filter_create_ext"));
memset (f, 0, sizeof (*f));
flexerror(_("calloc failed (f) in filter_create_ext"));
f->filter_func = NULL;
f->extra = NULL;
f->next = NULL;
@@ -100,10 +99,9 @@ struct filter *filter_create_int (struct filter *chain,
struct filter *f;
/* allocate and initialize new filter */
f = malloc(sizeof(struct filter));
f = calloc(sizeof(struct filter), 1);
if (!f)
flexerror(_("malloc failed in filter_create_int"));
memset (f, 0, sizeof (*f));
flexerror(_("calloc failed in filter_create_int"));
f->next = NULL;
f->argc = 0;
f->argv = NULL;
@@ -176,7 +174,7 @@ clearerr(stdin);
if ((r = chain->filter_func (chain)) == -1)
flexfatal (_("filter_func failed"));
exit (0);
FLEX_EXIT (0);
}
else {
execvp (chain->argv[0],
@@ -185,7 +183,7 @@ clearerr(stdin);
chain->argv[0]);
}
exit (1);
FLEX_EXIT (1);
}
/* Parent */
@@ -230,8 +228,7 @@ int filter_tee_header (struct filter *chain)
* header file at the same time.
*/
const int readsz = 512;
char *buf;
char buf[512];
int to_cfd = -1;
FILE *to_c = NULL, *to_h = NULL;
bool write_header;
@@ -283,10 +280,7 @@ int filter_tee_header (struct filter *chain)
fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
outfilename ? outfilename : "<stdout>");
buf = malloc((size_t) readsz);
if (!buf)
flexerror(_("malloc failed in filter_tee_header"));
while (fgets (buf, readsz, stdin)) {
while (fgets (buf, sizeof buf, stdin)) {
fputs (buf, to_c);
if (write_header)
fputs (buf, to_h);
@@ -296,7 +290,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);
@@ -323,10 +318,17 @@ int filter_tee_header (struct filter *chain)
while (wait (0) > 0) ;
exit (0);
FLEX_EXIT (0);
return 0;
}
static bool is_blank_line (const char *str)
{
while (isspace(*str))
str++;
return (*str == '\0');
}
/** Adjust the line numbers in the #line directives of the generated scanner.
* After the m4 expansion, the line numbers are incorrect since the m4 macros
* can add or remove lines. This only adjusts line numbers for generated code,
@@ -335,8 +337,8 @@ int filter_tee_header (struct filter *chain)
*/
int filter_fix_linedirs (struct filter *chain)
{
char *buf;
const size_t readsz = 512;
char buf[4096];
const size_t readsz = sizeof buf;
int lineno = 1;
bool in_gen = true; /* in generated code */
bool last_was_blank = false;
@@ -344,10 +346,6 @@ int filter_fix_linedirs (struct filter *chain)
if (!chain)
return 0;
buf = malloc(readsz);
if (!buf)
flexerror(_("malloc failed in filter_fix_linedirs"));
while (fgets (buf, (int) readsz, stdin)) {
regmatch_t m[10];
@@ -390,7 +388,7 @@ int filter_fix_linedirs (struct filter *chain)
/* Adjust the line directives. */
in_gen = true;
snprintf (buf, readsz, "#line %d \"%s\"\n",
lineno, filename);
lineno + 1, filename);
}
else {
/* it's a #line directive for code we didn't write */
@@ -402,9 +400,7 @@ int filter_fix_linedirs (struct filter *chain)
}
/* squeeze blank lines from generated code */
else if (in_gen
&& regexec (&regex_blank_line, buf, 0, NULL,
0) == 0) {
else if (in_gen && is_blank_line(buf)) {
if (last_was_blank)
continue;
else
src/flexdef.h
+70 -46
View File
@@ -44,7 +44,6 @@
#include <stdarg.h>
#include <setjmp.h>
#include <ctype.h>
#include <libgen.h> /* for XPG version of basename(3) */
#include <string.h>
#include <math.h>
@@ -57,27 +56,30 @@
#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_STAT_H
/* Required: stat() in <sys/stat.h> */
#include <sys/stat.h>
#endif
/* Required: wait() in <sys/wait.h> */
#include <sys/wait.h>
#include <stdbool.h>
#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 _() */
#ifdef ENABLE_NLS
/* We use gettext. So, when we write strings which should be translated, we
* mark them with _()
*/
#if defined(ENABLE_NLS) && ENABLE_NLS
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif /* HAVE_LOCALE_H */
@@ -108,6 +110,8 @@
#define ABS(x) ((x) < 0 ? -(x) : (x))
#endif
/* Whether an integer is a power of two */
#define is_power_of_2(n) ((n) > 0 && ((n) & ((n) - 1)) == 0)
#define unspecified -1
@@ -299,6 +303,56 @@
*/
#define MAX_SHORT 32700
/* Method table describing a language-specific back end */
struct flex_backend_t {
const char *(*suffix)(void); // Generate suffix for lexer source code
void (*prolog)(void);
const char **skel;
void (*epilog)(void);
const char *(*yy_int_aligned)(void); // Generate aligned type for this back end
char *trace_fmt; // Trace message format
// Language syntax generation
char *int_define_fmt; // Format for integer constant definitions
char *string_define_fmt; // Format for string constant definitions
char *table_opener; // Open an array initializer with this
char *table_continuation; // Open an array initializer with this
char *table_closer; // How to continue a two-level initializer
char *dyad; // How to format and int[2] initializer
void (*comment)(const char *); // Wrap a comment line
const char *(*get_int16_decl)(void); // Format for declaring array initializer of int16s
const char *(*get_int32_decl)(void); // Format for declaring array initializer of int32s
const char *(*get_state_decl)(void); // Format for declaring array initializer of state values
const char *(*get_yy_char_decl)(void); // Format for declaring array initializer of input chars
// Flex table generation
void (*ntod)(size_t); // Generate nxt table for ntod
void (*mkeoltbl)(void); // Make end-of-line table
void (*geneoltbl)(size_t); // Generate end-of-line transitions
void (*mkctbl)(size_t); // Make full-speed compressed table
void (*mkssltbl)(void); // Make start_state_list table
void (*gen_yy_trans)(size_t); // Table of verify for transition and offset to next state. (sic)
void (*start_state_list)(size_t); // Start initializer for table of pointers to start states
void (*mkftbl)(); // Make full table
const char *state_entry_fmt; // Format of state table entry
void (*mkecstbl)(void); // Make equivalence-class tables
void (*gentabs_acclist)(void); // Generate accept list initializer
void (*gentabs_accept)(void); // Generate accept table initializer
void (*gentabs_yy_meta)(void); // Generate yy_meta table initializer
void (*gentabs_yy_base)(void); // Generate yy_base table initializer
void (*gentabs_yy_def)(size_t); // Generate yy_def initializer
void (*gentabs_yy_nxt)(size_t); // Generate yy_nxt initializer
void (*gentabs_yy_chk)(size_t); // Generate yy_chk initializer
void (*nultrans)(int); // Generate nulltrans initializer
const char *(*trans_offset_type)(int); // Compute an efficient type for transition tables
char *caseprefix; // Prefix of an arm in the language's case construct
char *fallthrough; // Finish a case arm with this to fall through
char *endcase; // What to ship after all EOF-state case arms
int c_like; // Will &yy_transition[%d]," produce a pointer table entry?
};
extern bool gentables;
extern struct flex_backend_t cpp_backend;
/* Declarations for global variables. */
@@ -365,6 +419,8 @@ extern int yymore_used, reject, real_reject, continued_action, in_rule;
extern int yymore_really_used, reject_really_used;
extern int trace_hex;
extern struct flex_backend_t *backend;
/* Variables used in the flex input routines:
* datapos - characters on current output line
* dataline - number of contiguous lines of data in current data
@@ -628,10 +684,6 @@ 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;
#ifndef HAVE_REALLOCARRAY
void *reallocarray(void *, size_t, size_t);
#endif
void *allocate_array(int, size_t);
void *reallocate_array(void *, int, size_t);
@@ -732,34 +784,11 @@ extern void mkechar(int, int[], int[]);
extern void do_indent(void); /* indent to the current level */
/* Generate the code to keep backing-up information. */
extern void gen_backing_up(void);
/* Generate the code to perform the backing up. */
extern void gen_bu_action(void);
/* Generate full speed compressed transition table. */
extern void genctbl(void);
/* Generate the code to find the action number. */
extern void gen_find_action(void);
extern void genftbl(void); /* generate full transition table */
/* Generate the code to find the next compressed-table state. */
extern void gen_next_compressed_state(char *);
/* Generate the code to find the next match. */
extern void gen_next_match(void);
/* Generate the code to find the next state. */
extern void gen_next_state(int);
/* Generate the code to make a NUL transition. */
extern void gen_NUL_trans(void);
/* Generate the code to find the start state. */
extern void gen_start_state(void);
/* generate full transition table */
extern void genftbl(void);
/* Generate data statements for the transition tables. */
extern void gentabs(void);
@@ -842,9 +871,6 @@ extern void flexfatal(const char *);
}while(0)
#endif /* ! HAVE_DECL___func__ */
/* Convert a hexadecimal digit string to an integer value. */
extern unsigned int htoui(unsigned char[]);
/* Report an error message formatted */
extern void lerr(const char *, ...)
#if defined(__GNUC__) && __GNUC__ >= 3
@@ -881,9 +907,6 @@ extern int myctoi(const char *);
/* Return character corresponding to escape sequence. */
extern unsigned char myesc(unsigned char[]);
/* Convert an octal digit string to an integer value. */
extern unsigned int otoui(unsigned char[]);
/* Output a (possibly-formatted) string to the generated scanner. */
extern void out(const char *);
extern void out_dec(const char *, int);
@@ -974,8 +997,9 @@ extern void line_pinpoint(const char *, int);
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 warn(const char *); /* report a warning */
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 */
@@ -1133,7 +1157,7 @@ extern int filter_fix_linedirs(struct filter *chain);
* From "regex.c"
*/
extern regex_t regex_linedir, regex_blank_line;
extern regex_t regex_linedir;
bool flex_init_regex(void);
void flex_regcomp(regex_t *preg, const char *regex, int cflags);
char *regmatch_dup (regmatch_t * m, const char *src);
src/flexint.h
+12 -21
View File
@@ -3,31 +3,17 @@
#ifndef FLEXINT_H
#define FLEXINT_H
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
* if you want the limit (max/min) macros for int types.
/* C++ systems might need __STDC_LIMIT_MACROS defined before including
* <stdint.h>, if you want the limit (max/min) macros for int types.
*/
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif
#include <inttypes.h>
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
/* "flexint_shared.h" will be included also in skeleton. It will include
* <inttypes.h> (if available) and define flex's integral types.
*/
#include "flexint_shared.h"
/* Limits of integral types. */
#ifndef INT8_MIN
@@ -58,6 +44,11 @@ typedef unsigned int flex_uint32_t;
#define UINT32_MAX (4294967295U)
#endif
#endif /* ! C99 */
#ifndef INT_MAX
#define INT_MAX ((int)(~0U)>>1)
#endif
#ifndef SIZE_MAX
#define SIZE_MAX (~(size_t)0)
#endif
#endif /* ! FLEXINT_H */
src/flexint_shared.h
+50
View File
@@ -0,0 +1,50 @@
/* flex integer type definitions */
#ifndef YYFLEX_INTTYPES_DEFINED
#define YYFLEX_INTTYPES_DEFINED
/* Prefer C99 integer types if available. */
# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* Include <inttypes.h> and not <stdint.h> because Solaris 2.6 has the former
* and not the latter.
*/
#include <inttypes.h>
# define YYFLEX_USE_STDINT
# else
# if defined(_MSC_VER) && _MSC_VER >= 1600
/* Visual C++ 2010 does not define __STDC_VERSION__ and has <stdint.h> but not
* <inttypes.h>.
*/
#include <stdint.h>
# define YYFLEX_USE_STDINT
# endif
# endif
# ifdef YYFLEX_USE_STDINT
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
# else
typedef unsigned char flex_uint8_t;
typedef short int flex_int16_t;
typedef unsigned short int flex_uint16_t;
# ifdef __STDC__
typedef signed char flex_int8_t;
/* ISO C only requires at least 16 bits for int. */
#include <limits.h>
# if UINT_MAX >= 4294967295
# define YYFLEX_INT32_DEFINED
typedef int flex_int32_t;
typedef unsigned int flex_uint32_t;
# endif
# else
typedef char flex_int8_t;
# endif
# ifndef YYFLEX_INT32_DEFINED
typedef long int flex_int32_t;
typedef unsigned long int flex_uint32_t;
# endif
# endif
#endif /* YYFLEX_INTTYPES_DEFINED */
src/gen.c
+241 -1212
View File
File diff suppressed because it is too large Load Diff
src/gettext.h
+1 -1
View File
@@ -20,7 +20,7 @@
#define _LIBGETTEXT_H 1
/* NLS can be disabled through the configure --disable-nls option. */
#if ENABLE_NLS
#ifdef ENABLE_NLS
/* Get declarations of GNU message catalog functions. */
# include <libintl.h>
src/libfl.pc.in
+8
View File
@@ -0,0 +1,8 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
Name: libfl
Description: Flex (the fast lexical analyzer) support library
Version: @PACKAGE_VERSION@
Libs: -L${libdir} -lfl
src/main.c
+76 -380
View File
@@ -46,7 +46,6 @@ void flexinit(int, char **);
void readin(void);
void set_up_initial_allocations(void);
/* these globals are all defined and commented in flexdef.h */
int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
int interactive, lex_compat, posix_compat, do_yylineno,
@@ -107,6 +106,8 @@ jmp_buf flex_main_jmp_buf;
bool *rule_has_nl, *ccl_has_nl;
int nlch = '\n';
struct flex_backend_t *backend;
bool tablesext, tablesverify, gentables;
char *tablesfilename=0,*tablesname=0;
struct yytbl_writer tableswr;
@@ -117,7 +118,7 @@ struct yytbl_writer tableswr;
char *program_name = "flex";
static const char outfile_template[] = "lex.%s.%s";
static const char backing_name[] = "lex.backup";
static const char *backing_name = "lex.backup";
static const char tablesfile_template[] = "lex.%s.tables";
/* From scan.l */
@@ -169,6 +170,9 @@ int flex_main (int argc, char *argv[])
readin ();
if (backend->prolog)
backend->prolog ();
skelout ();
/* %% [1.5] DFA */
ntod ();
@@ -197,7 +201,7 @@ int flex_main (int argc, char *argv[])
/* Wrapper around flex_main, so flex_main can be built as a library. */
int main (int argc, char *argv[])
{
#if ENABLE_NLS
#if defined(ENABLE_NLS) && ENABLE_NLS
#if HAVE_LOCALE_H
setlocale (LC_MESSAGES, "");
setlocale (LC_CTYPE, "");
@@ -276,7 +280,7 @@ void check_options (void)
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;
}
@@ -310,22 +314,15 @@ void check_options (void)
}
}
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;
if (!did_outfilename) {
char *suffix;
if (C_plus_plus)
suffix = "cc";
else
suffix = "c";
snprintf (outfile_path, sizeof(outfile_path), outfile_template,
prefix, suffix);
prefix, backend->suffix());
outfilename = outfile_path;
}
@@ -361,16 +358,17 @@ void check_options (void)
endOfDir = path+length;
{
char m4_path[endOfDir-path + 1 + m4_length + 1];
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 = strdup(m4_path);
m4 = m4_path;
break;
}
free(m4_path);
}
path = endOfDir+1;
} while (path[0]);
@@ -456,42 +454,44 @@ void check_options (void)
buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL);
/* Create the alignment type. */
buf_strdefine (&userdef_buf, "YY_INT_ALIGNED",
long_align ? "long int" : "short int");
buf_strdefine (&userdef_buf, "YY_INT_ALIGNED", backend->yy_int_aligned());
/* Define the start condition macros. */
{
struct Buf tmpbuf;
buf_init(&tmpbuf, sizeof(char));
for (i = 1; i <= lastsc; i++) {
char *str, *fmt = "#define %s %d\n";
size_t strsz;
/* Define the start condition macros. */
{
struct Buf tmpbuf;
buf_init(&tmpbuf, sizeof(char));
for (i = 1; i <= lastsc; i++) {
char *str, *fmt = backend->int_define_fmt;
size_t strsz;
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);
buf_strappend(&tmpbuf, str);
free(str);
}
buf_m4_define(&m4defs_buf, "M4_YY_SC_DEFS", tmpbuf.elts);
buf_destroy(&tmpbuf);
}
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);
buf_strappend(&tmpbuf, str);
free(str);
}
buf_m4_define(&m4defs_buf, "M4_YY_SC_DEFS", tmpbuf.elts);
buf_destroy(&tmpbuf);
}
/* This is where we begin writing to the file. */
/* This is where we begin writing to the file. */
/* Dump the %top code. */
if( top_buf.elts)
outn((char*) top_buf.elts);
/* Dump the %top code. */
if( top_buf.elts)
outn((char*) top_buf.elts);
/* Dump the m4 definitions. */
buf_print_strings(&m4defs_buf, stdout);
m4defs_buf.nelts = 0; /* memory leak here. */
/* Dump the m4 definitions. */
buf_print_strings(&m4defs_buf, stdout);
m4defs_buf.nelts = 0; /* memory leak here. */
/* Place a bogus line directive, it will be fixed in the filter. */
if (gen_line_dirs)
outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
/* Place a bogus line directive, it will be fixed in the filter. */
if (gen_line_dirs && backend->trace_fmt) {
char buf2[4096];
snprintf(buf2, sizeof(buf2), backend->trace_fmt, 0, "M4_YY_OUTFILE_NAME");
outn(buf2);
}
/* Dump the user defined preproc directives. */
if (userdef_buf.elts)
@@ -525,191 +525,8 @@ void flexend (int exit_status)
skelname);
}
#if 0
fprintf (header_out,
"#ifdef YY_HEADER_EXPORT_START_CONDITIONS\n");
fprintf (header_out,
"/* Beware! Start conditions are not prefixed. */\n");
/* Special case for "INITIAL" */
fprintf (header_out,
"#undef INITIAL\n#define INITIAL 0\n");
for (i = 2; i <= lastsc; i++)
fprintf (header_out, "#define %s %d\n", scname[i], i - 1);
fprintf (header_out,
"#endif /* YY_HEADER_EXPORT_START_CONDITIONS */\n\n");
/* Kill ALL flex-related macros. This is so the user
* can #include more than one generated header file. */
fprintf (header_out, "#ifndef YY_HEADER_NO_UNDEFS\n");
fprintf (header_out,
"/* Undefine all internal macros, etc., that do no belong in the header. */\n\n");
{
const char * undef_list[] = {
"BEGIN",
"ECHO",
"EOB_ACT_CONTINUE_SCAN",
"EOB_ACT_END_OF_FILE",
"EOB_ACT_LAST_MATCH",
"FLEX_SCANNER",
"REJECT",
"YYFARGS0",
"YYFARGS1",
"YYFARGS2",
"YYFARGS3",
"YYLMAX",
"YYSTATE",
"YY_AT_BOL",
"YY_BREAK",
"YY_BUFFER_EOF_PENDING",
"YY_BUFFER_NEW",
"YY_BUFFER_NORMAL",
"YY_BUF_SIZE",
"M4_YY_CALL_LAST_ARG",
"M4_YY_CALL_ONLY_ARG",
"YY_CURRENT_BUFFER",
"YY_DECL",
"M4_YY_DECL_LAST_ARG",
"M4_YY_DEF_LAST_ARG",
"M4_YY_DEF_ONLY_ARG",
"YY_DO_BEFORE_ACTION",
"YY_END_OF_BUFFER",
"YY_END_OF_BUFFER_CHAR",
"YY_EXIT_FAILURE",
"YY_EXTRA_TYPE",
"YY_FATAL_ERROR",
"YY_FLEX_DEFINED_ECHO",
"YY_FLEX_LEX_COMPAT",
"YY_FLEX_MAJOR_VERSION",
"YY_FLEX_MINOR_VERSION",
"YY_FLEX_SUBMINOR_VERSION",
"YY_FLUSH_BUFFER",
"YY_G",
"YY_INPUT",
"YY_INTERACTIVE",
"YY_INT_ALIGNED",
"YY_LAST_ARG",
"YY_LESS_LINENO",
"YY_LEX_ARGS",
"YY_LEX_DECLARATION",
"YY_LEX_PROTO",
"YY_MAIN",
"YY_MORE_ADJ",
"YY_NEED_STRLEN",
"YY_NEW_FILE",
"YY_NULL",
"YY_NUM_RULES",
"YY_ONLY_ARG",
"YY_PARAMS",
"YY_PROTO",
"M4_YY_PROTO_LAST_ARG",
"M4_YY_PROTO_ONLY_ARG void",
"YY_READ_BUF_SIZE",
"YY_REENTRANT",
"YY_RESTORE_YY_MORE_OFFSET",
"YY_RULE_SETUP",
"YY_SC_TO_UI",
"YY_SKIP_YYWRAP",
"YY_START",
"YY_START_STACK_INCR",
"YY_STATE_EOF",
"YY_STDINIT",
"YY_TRAILING_HEAD_MASK",
"YY_TRAILING_MASK",
"YY_USER_ACTION",
"YY_USE_CONST",
"YY_USE_PROTOS",
"unput",
"yyTABLES_NAME",
"yy_create_buffer",
"yy_delete_buffer",
"yy_flex_debug",
"yy_flush_buffer",
"yy_init_buffer",
"yy_load_buffer_state",
"yy_new_buffer",
"yy_scan_buffer",
"yy_scan_bytes",
"yy_scan_string",
"yy_set_bol",
"yy_set_interactive",
"yy_switch_to_buffer",
"yypush_buffer_state",
"yypop_buffer_state",
"yyensure_buffer_stack",
"yyalloc",
"const",
"yyextra",
"yyfree",
"yyget_debug",
"yyget_extra",
"yyget_in",
"yyget_leng",
"yyget_lineno",
"yyget_lloc",
"yyget_lval",
"yyget_out",
"yyget_text",
"yyin",
"yyleng",
"yyless",
"yylex",
"yylex_destroy",
"yylex_init",
"yylex_init_extra",
"yylineno",
"yylloc",
"yylval",
"yymore",
"yyout",
"yyrealloc",
"yyrestart",
"yyset_debug",
"yyset_extra",
"yyset_in",
"yyset_lineno",
"yyset_lloc",
"yyset_lval",
"yyset_out",
"yytables_destroy",
"yytables_fload",
"yyterminate",
"yytext",
"yytext_ptr",
"yywrap",
/* must be null-terminated */
NULL};
for (i=0; undef_list[i] != NULL; i++)
fprintf (header_out, "#undef %s\n", undef_list[i]);
}
/* undef any of the auto-generated symbols. */
for (i = 0; i < defs_buf.nelts; i++) {
/* don't undef start conditions */
if (sclookup (((char **) defs_buf.elts)[i]) > 0)
continue;
fprintf (header_out, "#undef %s\n",
((char **) defs_buf.elts)[i]);
}
fprintf (header_out,
"#endif /* !YY_HEADER_NO_UNDEFS */\n");
fprintf (header_out, "\n");
fprintf (header_out, "#undef %sIN_HEADER\n", prefix);
fprintf (header_out, "#endif /* %sHEADER_H */\n", prefix);
if (ferror (header_out))
lerr (_("error creating header file %s"),
headerfilename);
fflush (header_out);
fclose (header_out);
#endif
if (backend->epilog)
backend->epilog();
if (exit_status != 0 && outfile_created) {
if (ferror (stdout))
@@ -993,7 +810,7 @@ void flexinit (int argc, char **argv)
flex_init_regex();
/* Enable C++ if program name ends with '+'. */
program_name = basename (argv[0]);
program_name = argv[0];
if (program_name != NULL &&
program_name[strlen (program_name) - 1] == '+')
@@ -1032,6 +849,11 @@ void flexinit (int argc, char **argv)
backing_up_report = true;
break;
case OPT_BACKUP_FILE:
backing_up_report = true;
backing_name = arg;
break;
case OPT_DONOTHING:
break;
@@ -1200,7 +1022,7 @@ void flexinit (int argc, char **argv)
break;
case OPT_VERSION:
printf (_("%s %s\n"), program_name, flex_version);
printf ("%s %s\n", (C_plus_plus ? "flex++" : "flex"), flex_version);
FLEX_EXIT (0);
case OPT_WARN:
@@ -1267,24 +1089,16 @@ void flexinit (int argc, char **argv)
{
/* arg is "symbol" or "symbol=definition". */
char *def;
char buf2[4096];
for (def = arg;
*def != '\0' && *def != '='; ++def) ;
*def != '\0' && *def != '='; ++def)
continue;
if (*def == '\0')
def = "1";
buf_strappend (&userdef_buf, "#define ");
if (*def == '\0') {
buf_strappend (&userdef_buf, arg);
buf_strappend (&userdef_buf,
" 1\n");
}
else {
buf_strnappend (&userdef_buf, arg,
(int) (def - arg));
buf_strappend (&userdef_buf, " ");
buf_strappend (&userdef_buf,
def + 1);
buf_strappend (&userdef_buf, "\n");
}
snprintf(buf2, sizeof(buf2), backend->string_define_fmt, arg, def);
buf_strappend (&userdef_buf, buf2);
}
break;
@@ -1393,6 +1207,14 @@ void flexinit (int argc, char **argv)
//buf_strdefine (&userdef_buf, "YY_NO_SET_LINENO", "1");
buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LINENO",0);
break;
case OPT_NO_YYGET_COLUMN:
//buf_strdefine (&userdef_buf, "YY_NO_GET_COLUMN", "1");
buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_COLUMN",0);
break;
case OPT_NO_YYSET_COLUMN:
//buf_strdefine (&userdef_buf, "YY_NO_SET_COLUMN", "1");
buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_COLUMN",0);
break;
case OPT_NO_YYGET_IN:
//buf_strdefine (&userdef_buf, "YY_NO_GET_IN", "1");
buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_IN",0);
@@ -1458,6 +1280,8 @@ void flexinit (int argc, char **argv)
lastprot = 1;
set_up_initial_allocations ();
backend = &cpp_backend;
}
@@ -1465,10 +1289,6 @@ void flexinit (int argc, char **argv)
void readin (void)
{
static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
static char yy_nostdinit[] =
"FILE *yyin = NULL, *yyout = NULL;";
line_directive_out(NULL, 1);
if (yyparse ()) {
@@ -1578,131 +1398,6 @@ void readin (void)
("variable trailing context rules cannot be used with -f or -F"));
}
if (reject){
out_m4_define( "M4_YY_USES_REJECT", NULL);
//outn ("\n#define YY_USES_REJECT");
}
if (!do_yywrap) {
if (!C_plus_plus) {
if (reentrant)
outn ("\n#define yywrap(yyscanner) (/*CONSTCOND*/1)");
else
outn ("\n#define yywrap() (/*CONSTCOND*/1)");
}
outn ("#define YY_SKIP_YYWRAP");
}
if (ddebug)
outn ("\n#define FLEX_DEBUG");
OUT_BEGIN_CODE ();
outn ("typedef flex_uint8_t YY_CHAR;");
OUT_END_CODE ();
if (C_plus_plus) {
outn ("#define yytext_ptr yytext");
if (interactive)
outn ("#define YY_INTERACTIVE");
}
else {
OUT_BEGIN_CODE ();
/* In reentrant scanner, stdinit is handled in flex.skl. */
if (do_stdinit) {
if (reentrant){
outn ("#ifdef VMS");
outn ("#ifdef __VMS_POSIX");
outn ("#define YY_STDINIT");
outn ("#endif");
outn ("#else");
outn ("#define YY_STDINIT");
outn ("#endif");
}
outn ("#ifdef VMS");
outn ("#ifndef __VMS_POSIX");
outn (yy_nostdinit);
outn ("#else");
outn (yy_stdinit);
outn ("#endif");
outn ("#else");
outn (yy_stdinit);
outn ("#endif");
}
else {
if(!reentrant)
outn (yy_nostdinit);
}
OUT_END_CODE ();
}
OUT_BEGIN_CODE ();
if (fullspd)
outn ("typedef const struct yy_trans_info *yy_state_type;");
else if (!C_plus_plus)
outn ("typedef int yy_state_type;");
OUT_END_CODE ();
if (lex_compat)
outn ("#define YY_FLEX_LEX_COMPAT");
if (!C_plus_plus && !reentrant) {
outn ("extern int yylineno;");
OUT_BEGIN_CODE ();
outn ("int yylineno = 1;");
OUT_END_CODE ();
}
if (C_plus_plus) {
outn ("\n#include <FlexLexer.h>");
if (!do_yywrap) {
outn("\nint yyFlexLexer::yywrap() { return 1; }");
}
if (yyclass) {
outn ("int yyFlexLexer::yylex()");
outn ("\t{");
outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );");
outn ("\treturn 0;");
outn ("\t}");
out_str ("\n#define YY_DECL int %s::yylex()\n",
yyclass);
}
}
else {
/* Watch out: yytext_ptr is a variable when yytext is an array,
* but it's a macro when yytext is a pointer.
*/
if (yytext_is_array) {
if (!reentrant)
outn ("extern char yytext[];\n");
}
else {
if (reentrant) {
outn ("#define yytext_ptr yytext_r");
}
else {
outn ("extern char *yytext;");
outn("#ifdef yytext_ptr");
outn("#undef yytext_ptr");
outn("#endif");
outn ("#define yytext_ptr yytext");
}
}
if (yyclass)
flexerror (_
("%option yyclass only meaningful for C++ scanners"));
}
if (useecs)
numecs = cre8ecs (nextecm, ecgroup, csize);
else
@@ -1716,7 +1411,6 @@ void readin (void)
ccl2ecl ();
}
/* set_up_initial_allocations - allocate memory for internal tables */
void set_up_initial_allocations (void)
@@ -1816,7 +1510,8 @@ void usage (void)
" -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"
" --tables-file[=FILE] write tables to FILE\n" "\n"
" --tables-file[=FILE] write tables to FILE\n"
" --backup-file=FILE write backing-up information to FILE\n" "\n"
"Scanner behavior:\n"
" -7, --7bit generate 7-bit scanner\n"
" -8, --8bit generate 8-bit scanner\n"
@@ -1843,6 +1538,7 @@ void usage (void)
" -?\n"
" -h, --help produce this help message\n"
" -V, --version report %s version\n"),
backing_name, program_name, outfile_path, program_name);
backing_name, "flex", outfile_path, "flex");
}
src/misc.c
+59 -68
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"
@@ -117,15 +116,14 @@ void add_action (const char *new_text)
int len = (int) strlen (new_text);
while (len + action_index >= action_size - 10 /* slop */ ) {
int new_size = action_size * 2;
if (new_size <= 0)
if (action_size > INT_MAX / 2)
/* Increase just a little, to try to avoid overflow
* on 16-bit machines.
*/
action_size += action_size / 8;
else
action_size = new_size;
action_size = action_size * 2;
action_array =
reallocate_character_array (action_array,
@@ -142,15 +140,24 @@ void add_action (const char *new_text)
void *allocate_array (int size, size_t element_size)
{
void *mem;
size_t num_bytes = element_size * (size_t) size;
mem = malloc(num_bytes);
if (!mem)
flexfatal (_
("memory allocation failed in allocate_array()"));
return mem;
void *new_array;
#if HAVE_REALLOCARR
new_array = NULL;
if (reallocarr(&new_array, (size_t) size, element_size))
flexfatal (_("memory allocation failed in allocate_array()"));
#else
# if HAVE_REALLOCARRAY
new_array = reallocarray(NULL, (size_t) size, element_size);
# else
/* Do manual overflow detection */
size_t num_bytes = (size_t) size * element_size;
new_array = (size && SIZE_MAX / (size_t) size < element_size) ? NULL :
malloc(num_bytes);
# endif
if (!new_array)
flexfatal (_("memory allocation failed in allocate_array()"));
#endif
return new_array;
}
@@ -253,7 +260,7 @@ void dataend (void)
dataflush ();
/* add terminator for initialization; { for vi */
outn (" } ;\n");
outn (backend->table_closer);
}
dataline = 0;
datapos = 0;
@@ -302,18 +309,6 @@ void flexfatal (const char *msg)
}
/* htoui - convert a hexadecimal digit string to an unsigned integer value */
unsigned int htoui (unsigned char str[])
{
unsigned int result;
(void) sscanf ((char *) str, "%x", &result);
return result;
}
/* lerr - report an error message */
void lerr (const char *msg, ...)
@@ -346,9 +341,8 @@ void lerr_fatal (const char *msg, ...)
void line_directive_out (FILE *output_file, int do_infile)
{
char directive[MAXLINE], filename[MAXLINE];
char directive[MAXLINE*2], filename[MAXLINE];
char *s1, *s2, *s3;
static const char *line_fmt = "#line %d \"%s\"\n";
if (!gen_line_dirs)
return;
@@ -371,11 +365,12 @@ void line_directive_out (FILE *output_file, int do_infile)
*s2 = '\0';
if (do_infile)
snprintf (directive, sizeof(directive), line_fmt, linenum, filename);
else {
snprintf (directive, sizeof(directive), line_fmt, 0, filename);
}
if (backend->trace_fmt)
if (do_infile)
snprintf (directive, sizeof(directive), backend->trace_fmt, linenum, filename);
else {
snprintf (directive, sizeof(directive), backend->trace_fmt, 0, filename);
}
/* If output_file is nil then we should put the directive in
* the accumulated actions.
@@ -513,18 +508,14 @@ unsigned char myesc (unsigned char array[])
int sptr = 1;
while (sptr <= 3 &&
isascii (array[sptr]) &&
isdigit (array[sptr]))
/* Don't increment inside loop control
* because if isdigit() is a macro it might
* expand into multiple increments ...
*/
array[sptr] >= '0' && array[sptr] <= '7') {
++sptr;
}
c = array[sptr];
array[sptr] = '\0';
esc_char = (unsigned char) otoui (array + 1);
esc_char = (unsigned char) strtoul (array + 1, NULL, 8);
array[sptr] = c;
@@ -535,18 +526,18 @@ unsigned char myesc (unsigned char 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 = (unsigned char) htoui (array + 2);
esc_char = (unsigned char) strtoul (array + 2, NULL, 16);
array[sptr] = c;
@@ -559,17 +550,6 @@ unsigned char myesc (unsigned char array[])
}
/* otoui - convert an octal digit string to an unsigned integer value */
unsigned int otoui (unsigned 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.
*/
@@ -682,12 +662,22 @@ char *readable_form (int c)
void *reallocate_array (void *array, int size, size_t element_size)
{
void *new_array;
size_t num_bytes = element_size * (size_t) size;
new_array = realloc(array, num_bytes);
#if HAVE_REALLOCARR
new_array = array;
if (reallocarr(&new_array, (size_t) size, element_size))
flexfatal (_("attempt to increase array size failed"));
#else
# if HAVE_REALLOCARRAY
new_array = reallocarray(array, (size_t) size, element_size);
# else
/* Do manual overflow detection */
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"));
#endif
return new_array;
}
@@ -712,11 +702,11 @@ void skelout (void)
/* Loop pulling lines either from the skelfile, if we're using
* one, or from the skel[] array.
* one, or from the selected back end's skel[] array.
*/
while (skelfile ?
(fgets (buf, MAXLINE, skelfile) != NULL) :
((buf = (char *) skel[skel_ind++]) != 0)) {
((buf = (char *) backend->skel[skel_ind++]) != 0)) {
if (skelfile)
chomp (buf);
@@ -738,7 +728,10 @@ void skelout (void)
*/
#define cmd_match(s) (strncmp(buf,(s),strlen(s))==0)
if (buf[1] == '%') {
if (buf[1] == '#') {
/* %# indicates comment line to be ignored */
}
else if (buf[1] == '%') {
/* %% is a break point for skelout() */
return;
}
@@ -783,8 +776,9 @@ void skelout (void)
outn ((char *) (yydmap_buf.elts));
}
else if (cmd_match (CMD_DEFINE_YYTABLES)) {
out_str("#define YYTABLES_NAME \"%s\"\n",
tablesname?tablesname:"yytables");
if ( tablesext )
out_str( "#define YYTABLES_NAME \"%s\"\n",
tablesname ? tablesname : "yytables" );
}
else if (cmd_match (CMD_IF_CPP_ONLY)) {
/* only for C++ */
@@ -809,9 +803,6 @@ void skelout (void)
/* %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"));
}
@@ -836,7 +827,7 @@ void transition_struct_out (int element_v, int element_n)
if (!gentables)
return;
out_dec2 (" {%4d,%4d },", element_v, element_n);
out_dec2 (backend->dyad, element_v, element_n);
datapos += TRANS_STRUCT_PRINT_LENGTH;
src/mkskel.sh
+22 -11
View File
@@ -21,16 +21,27 @@
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE.
echo '/* File created from flex.skl via mkskel.sh */
#include "flexdef.h"
const char *skel[] = {'
sed 's/m4_/m4preproc_/g
if test ! $# = 4; then
echo 'Usage: mkskel.sh lang srcdir m4 version' >&2
exit 1
fi
lang=$1
srcdir=$2
m4=$3
VERSION=$4
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/${lang}-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/.*/ "&",/'
echo ' 0
};'
s/[^\r]*/ "&",/'
src/nfa.c
+2
View File
@@ -499,6 +499,8 @@ int mkor (int first, int second)
}
}
firstst[first] = MIN(firstst[first], firstst[second]);
finalst[first] = orend;
return first;
}
src/options.c
+6
View File
@@ -62,6 +62,8 @@ optspec_t flexopts[] = {
,
{"--backup", OPT_BACKUP, 0}
, /* Generate backing-up information to lex.backup. */
{"--backup-file=FILE", OPT_BACKUP_FILE, 0}
, /* Generate backing-up information to FILE. */
{"-B", OPT_BATCH, 0}
,
{"--batch", OPT_BATCH, 0}
@@ -255,6 +257,10 @@ optspec_t flexopts[] = {
,
{"--noyyset_lineno", OPT_NO_YYSET_LINENO, 0}
,
{"--noyyget_column", OPT_NO_YYGET_COLUMN, 0}
,
{"--noyyset_column", OPT_NO_YYSET_COLUMN, 0}
,
{"--noyyget_in", OPT_NO_YYGET_IN, 0}
,
{"--noyyset_in", OPT_NO_YYSET_IN, 0}
src/options.h
+3
View File
@@ -46,6 +46,7 @@ enum flexopt_flag_t {
OPT_ALWAYS_INTERACTIVE,
OPT_ARRAY,
OPT_BACKUP,
OPT_BACKUP_FILE,
OPT_BATCH,
OPT_BISON_BRIDGE,
OPT_BISON_BRIDGE_LOCATIONS,
@@ -83,6 +84,7 @@ enum flexopt_flag_t {
OPT_NO_YYGET_IN,
OPT_NO_YYGET_LENG,
OPT_NO_YYGET_LINENO,
OPT_NO_YYGET_COLUMN,
OPT_NO_YYGET_LLOC,
OPT_NO_YYGET_LVAL,
OPT_NO_YYGET_OUT,
@@ -92,6 +94,7 @@ enum flexopt_flag_t {
OPT_NO_YYSET_EXTRA,
OPT_NO_YYSET_IN,
OPT_NO_YYSET_LINENO,
OPT_NO_YYSET_COLUMN,
OPT_NO_YYSET_LLOC,
OPT_NO_YYSET_LVAL,
OPT_NO_YYSET_OUT,
src/parse.y
+9 -9
View File
@@ -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. */
@@ -305,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
@@ -400,7 +400,7 @@ rule : re2 re
* erroneously.
*/
if ( ! varlength || headcnt != 0 )
warn(
lwarn(
"trailing context made variable due to preceding '|' action" );
/* Mark as variable. */
@@ -455,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;
@@ -915,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);
}
@@ -1018,13 +1018,13 @@ 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( const char *str )
void lwarn( const char *str )
{
line_warning( str, linenum );
}
src/regex.c
+6 -14
View File
@@ -25,10 +25,8 @@
static const char* REGEXP_LINEDIR = "^#line ([[:digit:]]+) \"(.*)\"";
static const char* REGEXP_BLANK_LINE = "^[[:space:]]*$";
regex_t regex_linedir; /**< matches line directives */
regex_t regex_blank_line; /**< matches blank lines */
/** Initialize the regular expressions.
@@ -37,8 +35,6 @@ regex_t regex_blank_line; /**< matches blank lines */
bool flex_init_regex(void)
{
flex_regcomp(&regex_linedir, REGEXP_LINEDIR, REG_EXTENDED);
flex_regcomp(&regex_blank_line, REGEXP_BLANK_LINE, REG_EXTENDED);
return true;
}
@@ -54,21 +50,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 size_t errbuf_sz = 200;
char *errbuf, *rxerr;
const size_t errbuf_sz = 200;
char *errbuf;
int n;
errbuf = malloc(errbuf_sz * sizeof(char));
if (!errbuf)
flexfatal(_("Unable to allocate buffer to report regcomp"));
rxerr = malloc(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) */
}
}
src/scan.l
+38 -32
View File
@@ -1,5 +1,11 @@
/* scan.l - scanner for flex input -*-C-*- */
%top{
/* flexdef.h includes config.h, which may contain macros that alter the API */
/* of libc functions. Must include first before any libc header. */
#include "flexdef.h"
}
%{
/* Copyright (c) 1990 The Regents of the University of California. */
/* All rights reserved. */
@@ -32,7 +38,6 @@
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/* PURPOSE. */
#include "flexdef.h"
#include "parse.h"
extern bool tablesverify, tablesext;
extern int trlcontxt; /* Set in parse.y for each rule. */
@@ -74,7 +79,7 @@ extern const char *escaped_qstart, *escaped_qend;
#define RETURNNAME \
if(yyleng < MAXLINE) \
{ \
strcpy( nmstr, yytext ); \
strncpy( nmstr, yytext, sizeof(nmstr) ); \
return NAME; \
} \
else \
@@ -207,7 +212,7 @@ M4QEND "]""]"
^{NAME} {
if(yyleng < MAXLINE)
{
strcpy( nmstr, yytext );
strncpy( nmstr, yytext, sizeof(nmstr) );
}
else
{
@@ -256,15 +261,14 @@ M4QEND "]""]"
\n yy_pop_state();
[[:digit:]]+ linenum = myctoi( yytext );
\"[^"\n]*\" {
"\""[^""\n]*"\"" {
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>{
<ACTION,CODEBLOCK,ACTION_STRING,PERCENT_BRACE_ACTION,CHARACTER_CONSTANT,COMMENT,CODE_COMMENT>{
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
}
@@ -319,7 +323,7 @@ COMMENT,CODE_COMMENT>{
{NOT_WS}[^\r\n]* {
if(yyleng < MAXLINE)
{
strcpy( nmdef, yytext );
strncpy( nmdef, yytext, sizeof(nmdef) );
}
else
{
@@ -434,6 +438,8 @@ COMMENT,CODE_COMMENT>{
yyset_extra ACTION_M4_IFDEF("M4""_YY_NO_SET_EXTRA", ! option_sense);
yyget_leng ACTION_M4_IFDEF("M4""_YY_NO_GET_LENG", ! option_sense);
yyget_text ACTION_M4_IFDEF("M4""_YY_NO_GET_TEXT", ! option_sense);
yyget_column ACTION_M4_IFDEF("M4""_YY_NO_GET_COLUMN", ! option_sense);
yyset_column ACTION_M4_IFDEF("M4""_YY_NO_SET_COLUMN", ! option_sense);
yyget_lineno ACTION_M4_IFDEF("M4""_YY_NO_GET_LINENO", ! option_sense);
yyset_lineno ACTION_M4_IFDEF("M4""_YY_NO_SET_LINENO", ! option_sense);
yyget_in ACTION_M4_IFDEF("M4""_YY_NO_GET_IN", ! option_sense);
@@ -458,10 +464,10 @@ COMMENT,CODE_COMMENT>{
}
\"[^"\n]*\" {
"\""[^""\n]*"\"" {
if(yyleng-1 < MAXLINE)
{
strcpy( nmstr, yytext + 1 );
strncpy( nmstr, yytext + 1, sizeof(nmstr) );
}
else
{
@@ -528,7 +534,7 @@ COMMENT,CODE_COMMENT>{
return '<';
}
^{OPTWS}"^" return '^';
\" BEGIN(QUOTE); return '"';
"\"" BEGIN(QUOTE); return '"';
"{"/[[:digit:]] {
BEGIN(NUM);
if ( lex_compat || posix_compat )
@@ -638,7 +644,7 @@ COMMENT,CODE_COMMENT>{
if(yyleng < MAXLINE)
{
strcpy( nmstr, yytext );
strncpy( nmstr, yytext, sizeof(nmstr) );
}
else
{
@@ -696,7 +702,7 @@ COMMENT,CODE_COMMENT>{
if(yyleng-1 < MAXLINE)
{
strcpy( nmstr, yytext + 1 );
strncpy( nmstr, yytext + 1, sizeof(nmstr) );
}
else
{
@@ -794,8 +800,8 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
<QUOTE>{
[^"\n] RETURNCHAR;
\" BEGIN(SECT2); return '"';
[^""\n] RETURNCHAR;
"\"" BEGIN(SECT2); return '"';
{NL} {
synerr( _( "missing quote" ) );
@@ -920,7 +926,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
{NL} {
++linenum;
ACTION_ECHO;
if (bracelevel == 0 || (doing_codeblock && indented_code)) {
if (bracelevel <= 0 || (doing_codeblock && indented_code)) {
if ( doing_rule_action )
add_action( "\tYY_BREAK]""]\n" );
@@ -935,37 +941,37 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
<ACTION>{
"{" ACTION_ECHO; ++bracelevel;
"}" ACTION_ECHO; --bracelevel;
[^[:alpha:]_{}\"'/\n\[\]]+ ACTION_ECHO;
[^[:alpha:]_{}""''/\n\[\]]+ ACTION_ECHO;
{NAME} ACTION_ECHO;
"'"([^\'\\\n]|\\.)"'" ACTION_ECHO; /* character constant */
"'"([^''\\\n]|\\.)"'" ACTION_ECHO; /* character constant */
"'" ACTION_ECHO; BEGIN(CHARACTER_CONSTANT);
\" ACTION_ECHO; BEGIN(ACTION_STRING);
"\"" ACTION_ECHO; BEGIN(ACTION_STRING);
{NL} {
++linenum;
ACTION_ECHO;
if (bracelevel == 0) {
if ( doing_rule_action )
add_action( "\tYY_BREAK]""]\n" );
++linenum;
ACTION_ECHO;
if (bracelevel <= 0) {
if ( doing_rule_action )
add_action( "\tYY_BREAK]""]\n" );
doing_rule_action = false;
BEGIN(SECT2);
}
}
doing_rule_action = false;
BEGIN(SECT2);
}
}
. ACTION_ECHO;
}
<ACTION_STRING>{
[^\[\]\"\\\n]+ ACTION_ECHO;
\" ACTION_ECHO; BEGIN(ACTION);
[^\[\]""\\\n]+ ACTION_ECHO;
"\"" ACTION_ECHO; BEGIN(ACTION);
}
<CHARACTER_CONSTANT>{
[^\[\]\'\\\n]+ ACTION_ECHO;
\' ACTION_ECHO; BEGIN(ACTION);
[^\[\]''\\\n]+ ACTION_ECHO;
"'" ACTION_ECHO; BEGIN(ACTION);
}
<ACTION_STRING,CHARACTER_CONSTANT>{
(\\\n)* ACTION_ECHO;
\\(\\\n)*. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO; BEGIN(ACTION);
{NL} ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); }
. ACTION_ECHO;
}
src/scanopt.c
+33 -72
View File
@@ -68,7 +68,7 @@ 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 void 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);
@@ -229,34 +229,23 @@ typedef struct usg_elem usg_elem;
int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
{
struct _scanopt_t *s;
int i, columns, indent = 2;
int i, columns;
const int indent = 2;
usg_elem *byr_val = NULL; /* option indices sorted by r_val */
usg_elem *store; /* array of preallocated elements. */
int store_idx = 0;
usg_elem *ue;
int maxlen[2];
int desccol = 0;
int opt_col_width = 0, desc_col_width = 0;
int desccol;
int print_run = 0;
maxlen[0] = 0;
maxlen[1] = 0;
s = (struct _scanopt_t *) scanner;
if (usage) {
fprintf (fp, "%s\n", usage);
}
else {
/* Find the basename of argv[0] */
const char *p;
p = s->argv[0] + strlen (s->argv[0]);
while (p != s->argv[0] && *p != '/')
--p;
if (*p == '/')
p++;
fprintf (fp, _("Usage: %s [OPTIONS]...\n"), p);
fprintf (fp, _("Usage: %s [OPTIONS]...\n"), s->argv[0]);
}
fprintf (fp, "\n");
@@ -324,65 +313,36 @@ int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
/* first pass calculate how much room we need. */
for (ue = byr_val; ue; ue = ue->next) {
usg_elem *ap;
int len = 0;
int nshort = 0, nlong = 0;
int len;
len = PRINTLEN(s, ue->idx);
#define CALC_LEN(i) do {\
if(FLAGS(s,i) & IS_LONG) \
len += (nlong++||nshort) ? 2+PRINTLEN(s,i) : PRINTLEN(s,i);\
else\
len += (nshort++||nlong)? 2+PRINTLEN(s,i) : PRINTLEN(s,i);\
}while(0)
if (!(FLAGS (s, ue->idx) & IS_LONG))
CALC_LEN (ue->idx);
/* do short aliases first. */
for (ap = ue->alias; ap; ap = ap->next) {
if (FLAGS (s, ap->idx) & IS_LONG)
continue;
CALC_LEN (ap->idx);
len += PRINTLEN(s, ap->idx) + (int) strlen(", ");
}
if (FLAGS (s, ue->idx) & IS_LONG)
CALC_LEN (ue->idx);
/* repeat the above loop, this time for long aliases. */
for (ap = ue->alias; ap; ap = ap->next) {
if (!(FLAGS (s, ap->idx) & IS_LONG))
continue;
CALC_LEN (ap->idx);
}
if (len > maxlen[0])
maxlen[0] = len;
if (len > opt_col_width)
opt_col_width = len;
/* It's much easier to calculate length for description column! */
len = (int) strlen (DESC (s, ue->idx));
if (len > maxlen[1])
maxlen[1] = len;
if (len > desc_col_width)
desc_col_width = len;
}
/* Determine how much room we have, and how much we will allocate to each col.
* Do not address pathological cases. Output will just be ugly. */
columns = get_cols () - 1;
if (maxlen[0] + maxlen[1] + indent * 2 > columns) {
/* col 0 gets whatever it wants. we'll wrap the desc col. */
maxlen[1] = columns - (maxlen[0] + indent * 2);
if (maxlen[1] < 14) /* 14 is arbitrary lower limit on desc width. */
maxlen[1] = INT_MAX;
if (opt_col_width + desc_col_width + indent * 2 > columns) {
/* opt col gets whatever it wants. we'll wrap the desc col. */
desc_col_width = columns - (opt_col_width + indent * 2);
if (desc_col_width < 14) /* 14 is arbitrary lower limit on desc width. */
desc_col_width = INT_MAX;
}
desccol = maxlen[0] + indent * 2;
#define PRINT_SPACES(fp,n)\
do{\
int _n;\
_n=(n);\
while(_n-- > 0)\
fputc(' ',(fp));\
}while(0)
desccol = opt_col_width + indent * 2;
#define PRINT_SPACES(fp,n) \
fprintf((fp), "%*s", (n), "")
/* Second pass (same as above loop), this time we print. */
/* Sloppy hack: We iterate twice. The first time we print short and long options.
@@ -436,7 +396,7 @@ int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
/* pad to desccol */
PRINT_SPACES (fp, desccol - nchars);
/* Print description, wrapped to maxlen[1] columns. */
/* Print description, wrapped to desc_col_width columns. */
if (1) {
const char *pstart;
@@ -447,7 +407,7 @@ int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
p = pstart;
while (*p && n < maxlen[1]
while (*p && n < desc_col_width
&& *p != '\n') {
if (isspace ((unsigned char)(*p))
|| *p == '-') lastws =
@@ -497,7 +457,7 @@ int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
#endif /* no scanopt_usage */
static int scanopt_err (struct _scanopt_t *s, int is_short, int err)
static void scanopt_err(struct _scanopt_t *s, int is_short, int err)
{
const char *optname = "";
char optchar[2];
@@ -542,7 +502,6 @@ static int scanopt_err (struct _scanopt_t *s, int is_short, int err)
break;
}
}
return err;
}
@@ -729,7 +688,8 @@ int scanopt (scanopt_t *svoid, char **arg, int *optindex)
if (!find_opt
(s, 0, pstart, namelen, &errcode, &opt_offset)) {
return scanopt_err (s, 1, errcode);
scanopt_err(s, 1, errcode);
return errcode;
}
optarg = pstart + 1;
@@ -748,8 +708,7 @@ int scanopt (scanopt_t *svoid, char **arg, int *optindex)
/* Look ahead in argv[] to see if there is something
* that we can use as an argument (if needed). */
has_next = s->index + 1 < s->argc
&& strcmp ("--", s->argv[s->index + 1]) != 0;
has_next = s->index + 1 < s->argc;
optp = s->options + opt_offset;
auxp = s->aux + opt_offset;
@@ -757,9 +716,9 @@ int scanopt (scanopt_t *svoid, char **arg, int *optindex)
/* case: no args allowed */
if (auxp->flags & ARG_NONE) {
if (optarg && !is_short) {
scanopt_err (s, is_short, errcode = SCANOPT_ERR_ARG_NOT_ALLOWED);
scanopt_err(s, is_short, SCANOPT_ERR_ARG_NOT_ALLOWED);
INC_INDEX (s, 1);
return errcode;
return SCANOPT_ERR_ARG_NOT_ALLOWED;
}
else if (!optarg)
INC_INDEX (s, 1);
@@ -770,8 +729,10 @@ int scanopt (scanopt_t *svoid, char **arg, int *optindex)
/* case: required */
if (auxp->flags & ARG_REQ) {
if (!optarg && !has_next)
return scanopt_err (s, is_short, SCANOPT_ERR_ARG_NOT_FOUND);
if (!optarg && !has_next) {
scanopt_err(s, is_short, SCANOPT_ERR_ARG_NOT_FOUND);
return SCANOPT_ERR_ARG_NOT_FOUND;
}
if (!optarg) {
/* Let the next argv element become the argument. */
src/tables.c
+4 -4
View File
@@ -87,7 +87,7 @@ int yytbl_hdr_init (struct yytbl_hdr *th, const char *version_str,
th->th_magic = YYTBL_MAGIC;
th->th_hsize = (flex_uint32_t) (14 + strlen (version_str) + 1 + strlen (name) + 1);
th->th_hsize += yypad64 (th->th_hsize);
th->th_hsize += (8 - (th->th_hsize % 8)) % 8; // Pad to 64-bit boundary
th->th_ssize = 0; // Not known at this point.
th->th_flags = 0;
th->th_version = xstrdup(version_str);
@@ -124,14 +124,14 @@ int yytbl_data_destroy (struct yytbl_data *td)
/** Write enough padding to bring the file pointer to a 64-bit boundary. */
static int yytbl_write_pad64 (struct yytbl_writer *wr)
{
int pad, bwritten = 0;
int bwritten = 0;
pad = yypad64 (wr->total_written);
while (pad-- > 0)
while (wr->total_written % (8 * sizeof(flex_uint8_t)) > 0) {
if (yytbl_write8 (wr, 0) < 0)
return -1;
else
bwritten++;
}
return bwritten;
}
src/tables_shared.h
-6
View File
@@ -63,12 +63,6 @@ dnl flex code (hence the name "_shared").
#define YYTBL_MAGIC 0xF13C57B1
#endif
/** Calculate (0-7) = number bytes needed to pad n to next 64-bit boundary. */
#ifndef yypad64
#define yypad64(n) ((8-((n)%8))%8)
#endif
#ifndef YYTABLES_TYPES
#define YYTABLES_TYPES
/** Possible values for td_id field. Each one corresponds to a
tests/Makefile.am
+94 -64
View File
@@ -31,28 +31,28 @@ 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
REJECT_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_REJECT_LOG_FLAGS = -d $(srcdir) -i $(srcdir)/reject.txt -r
TABLE_LOG_COMPILER = $(srcdir)/testwrapper.sh
TABLE_LOG_COMPILER = $(SHELL) $(srcdir)/testwrapper.sh
AM_TABLE_LOG_FLAGS = -d $(builddir) -i $(srcdir)/reject.txt -t
DIRECT_LOG_COMPILER=$(srcdir)/testwrapper-direct.sh
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
@@ -113,10 +113,8 @@ DIRECT_TESTS = \
I3_TESTS = \
cxx_yywrap.i3
if want_pthread
PTHREAD_TESTS = \
pthread.pthread
endif
ONE_TESTS = \
lineno_nr.one \
@@ -129,9 +127,18 @@ 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
@@ -143,7 +150,9 @@ 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
@@ -153,7 +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
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
@@ -169,23 +180,9 @@ 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_parser.h \
bison_nr_scanner.h \
bison_yylloc_parser.h \
bison_yylloc_scanner.h \
bison_yylval_parser.h \
bison_yylval_scanner.h \
header_nr_scanner.h \
header_r_scanner.h \
multiple_scanners_nr_1.h \
multiple_scanners_nr_2.h \
multiple_scanners_r_1.h \
multiple_scanners_r_2.h \
top.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
@@ -196,6 +193,7 @@ BUILT_SOURCES = \
# it.
CLEANFILES = \
alloc_extra.c \
array_nr.c \
array_r.c \
basic_nr.c \
@@ -263,11 +261,11 @@ CLEANFILES = \
top.c \
top.h \
yyextra.c \
alloc_extra.c \
$(tableopts_c) \
$(tableopts_tables)
dist-hook:
chmod u+w $(distdir) && \
for file in $(CLEANFILES) ; do \
rm -f $(distdir)/$$file \
; done
@@ -332,82 +330,114 @@ dist_check_SCRIPTS = \
testwrapper-direct.sh \
testwrapper.sh
pthread_pthread_LDADD = -lpthread
pthread_pthread_LDADD = @LIBPTHREAD@
# specify how to process .l files in order to test the flex built by make all
TESTOPTS = -L
FLEX = $(top_builddir)/src/flex
.l.c: $(FLEX)
$(FLEX) -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) -o $@ $<
.ll.cc: $(FLEX)
$(FLEX) -+ -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) -+ -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)
$(FLEX) -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) -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
@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 $(FLEX)
POSIXLY_CORRECT=1 $(FLEX) -o $@ $<
$(AM_V_LEX)POSIXLY_CORRECT=1 $(FLEX) $(TESTOPTS) -o $@ $<
reject_nr.reject.c: reject.l4 $(FLEX)
$(FLEX) --unsafe-no-m4-sect3-escape -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --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)
$(FLEX) --unsafe-no-m4-sect3-escape --reentrant -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --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)
$(FLEX) --unsafe-no-m4-sect3-escape -o $@ --tables-verify --tables-file=$(basename $@).tables $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --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)
$(FLEX) -o $@ --unsafe-no-m4-sect3-escape --tables-file=$(basename $@).tables $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) -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
@@ -418,8 +448,8 @@ top.h: top.c
# things) and the resultant list is both long an unenlightening. And
# it can be / is generated by a shell script, tableopts.sh.
tableopts.am: tableopts.sh
$(srcdir)/tableopts.sh > $(srcdir)/tableopts.am
$(srcdir)/tableopts.am: tableopts.sh
$(SHELL) $(srcdir)/tableopts.sh > $(srcdir)/tableopts.am
include $(srcdir)/tableopts.am
@@ -431,50 +461,50 @@ tableopts_tests := $(tableopts_opttests) $(tableopts_vertests) $(tableopts_sert
tableopts_c := $(addsuffix .c,$(tableopts_tests))
OPT_LOG_COMPILER = $(srcdir)/testwrapper.sh
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)
$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) $* -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) $(*:_F=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)
$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --reentrant $* -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --reentrant $(subst _F,F,$*) -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
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)
$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ser_nr$*.ser.tables" $* -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ser_nr$*.ser.tables" $(subst _F,F,$*) -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)
$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ser_r$*.ser.tables" $* -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ser_r$*.ser.tables" $(subst _F,F,$*) -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
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)
$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ver_nr$*.ver.tables" --tables-verify $* -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) --tables-file="tableopts_ver_nr$*.ver.tables" --tables-verify $(subst _F,F,$*) -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)
$(FLEX) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ver_r$*.ver.tables" --tables-verify $* -o $@ $<
$(AM_V_LEX)$(FLEX) $(TESTOPTS) --unsafe-no-m4-sect3-escape -P $(subst -,_,$(basename $(*F))) -R --tables-file="tableopts_ver_r$*.ver.tables" --tables-verify $(subst _F,F,$*) -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 $@ $<
tests/README
+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
tests/no_bison_stub.c
+39
View File
@@ -0,0 +1,39 @@
/* This stub will be used when Bison is not available on the user's host. */
/* This file is part of flex.
*
* 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.
*/
#include <stdio.h>
int main (int argc, char *argv[])
{
(void)argc;
(void)argv;
puts(
"This test requires Bison. Install Bison and re-run \"configure && make check\"\n"
"to perform this test. (This file is stub code.)"
);
/* Exit status for a skipped test */
return 77;
}
/* vim:set tabstop=8 softtabstop=4 shiftwidth=4: */
tests/options.cn
+1 -1
View File
@@ -1,4 +1,4 @@
#!/bin/bash
#!/bin/sh
# Test that flex handles the grouped noop options -c and -n properly.
tests/pthread.l
+9 -9
View File
@@ -27,7 +27,7 @@
We create N_THREADS number of threads. Each thread has it's own scanner.
Each thread selects one of the files specified in ARGV, scans it, then
closes it. This is repeated N_SCANS numebr of times for each thread.
closes it. This is repeated N_SCANS number of times for each thread.
The idea is to press the scanner to break under threads.
If we see "Scanner Jammed", then we know
@@ -90,18 +90,18 @@ static int process_text(char* s, yyscan_t scanner)
int main(int ARGC, char *ARGV[]);
#ifndef HAVE_LIBPTHREAD
int main (int ARGC, char *ARGV[]) {
printf(
#ifndef HAVE_PTHREAD_H
int main (int ARGC, char *ARGV[]) {
puts(
"TEST ABORTED because pthread library not available \n"
"-- This is expected on some systems. It is not a flex error.\n" );
return 0;
}
"-- This is expected on some systems. It is not a flex error.");
/* Exit status for a skipped test */
return 77;
}
#else
#define N_THREADS 4
#define N_SCANS 20
#define INPUT_FILE "test.input"
/* Each thread selects the next file to scan in round-robin fashion.
If there are less files than threads, some threads may block. */
@@ -204,5 +204,5 @@ int main (int ARGC, char *ARGV[])
return 0;
}
#endif /* HAVE_LIBPTHREAD */
#endif /* HAVE_PTHREAD_H */
tests/tableopts.am
+92 -92
View File
@@ -1,333 +1,333 @@
tableopts_opt_nr_Ca_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Ca.opt$(EXEEXT): tableopts_opt_nr-Ca.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Ce_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Ce.opt$(EXEEXT): tableopts_opt_nr-Ce.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Cf_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Cf.opt$(EXEEXT): tableopts_opt_nr-Cf.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_CF_opt_SOURCES = tableopts.l4
tableopts_opt_nr_C_F_opt_SOURCES = tableopts.l4
tableopts_opt_nr-CF.opt$(EXEEXT): tableopts_opt_nr-CF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_opt_nr-C_F.opt$(EXEEXT): tableopts_opt_nr-C_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Cm_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Cm.opt$(EXEEXT): tableopts_opt_nr-Cm.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Cem_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Cem.opt$(EXEEXT): tableopts_opt_nr-Cem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Cae_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Cae.opt$(EXEEXT): tableopts_opt_nr-Cae.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Caef_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Caef.opt$(EXEEXT): tableopts_opt_nr-Caef.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_CaeF_opt_SOURCES = tableopts.l4
tableopts_opt_nr_Cae_F_opt_SOURCES = tableopts.l4
tableopts_opt_nr-CaeF.opt$(EXEEXT): tableopts_opt_nr-CaeF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_opt_nr-Cae_F.opt$(EXEEXT): tableopts_opt_nr-Cae_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Cam_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Cam.opt$(EXEEXT): tableopts_opt_nr-Cam.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_nr_Caem_opt_SOURCES = tableopts.l4
tableopts_opt_nr-Caem.opt$(EXEEXT): tableopts_opt_nr-Caem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Ca_opt_SOURCES = tableopts.l4
tableopts_opt_r-Ca.opt$(EXEEXT): tableopts_opt_r-Ca.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Ce_opt_SOURCES = tableopts.l4
tableopts_opt_r-Ce.opt$(EXEEXT): tableopts_opt_r-Ce.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Cf_opt_SOURCES = tableopts.l4
tableopts_opt_r-Cf.opt$(EXEEXT): tableopts_opt_r-Cf.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_CF_opt_SOURCES = tableopts.l4
tableopts_opt_r_C_F_opt_SOURCES = tableopts.l4
tableopts_opt_r-CF.opt$(EXEEXT): tableopts_opt_r-CF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_opt_r-C_F.opt$(EXEEXT): tableopts_opt_r-C_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Cm_opt_SOURCES = tableopts.l4
tableopts_opt_r-Cm.opt$(EXEEXT): tableopts_opt_r-Cm.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Cem_opt_SOURCES = tableopts.l4
tableopts_opt_r-Cem.opt$(EXEEXT): tableopts_opt_r-Cem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Cae_opt_SOURCES = tableopts.l4
tableopts_opt_r-Cae.opt$(EXEEXT): tableopts_opt_r-Cae.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Caef_opt_SOURCES = tableopts.l4
tableopts_opt_r-Caef.opt$(EXEEXT): tableopts_opt_r-Caef.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_CaeF_opt_SOURCES = tableopts.l4
tableopts_opt_r_Cae_F_opt_SOURCES = tableopts.l4
tableopts_opt_r-CaeF.opt$(EXEEXT): tableopts_opt_r-CaeF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_opt_r-Cae_F.opt$(EXEEXT): tableopts_opt_r-Cae_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Cam_opt_SOURCES = tableopts.l4
tableopts_opt_r-Cam.opt$(EXEEXT): tableopts_opt_r-Cam.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_opt_r_Caem_opt_SOURCES = tableopts.l4
tableopts_opt_r-Caem.opt$(EXEEXT): tableopts_opt_r-Caem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Ca_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Ca.ser$(EXEEXT): tableopts_ser_nr-Ca.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Ce_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Ce.ser$(EXEEXT): tableopts_ser_nr-Ce.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Cf_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Cf.ser$(EXEEXT): tableopts_ser_nr-Cf.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_CF_ser_SOURCES = tableopts.l4
tableopts_ser_nr_C_F_ser_SOURCES = tableopts.l4
tableopts_ser_nr-CF.ser$(EXEEXT): tableopts_ser_nr-CF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ser_nr-C_F.ser$(EXEEXT): tableopts_ser_nr-C_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Cm_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Cm.ser$(EXEEXT): tableopts_ser_nr-Cm.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Cem_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Cem.ser$(EXEEXT): tableopts_ser_nr-Cem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Cae_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Cae.ser$(EXEEXT): tableopts_ser_nr-Cae.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Caef_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Caef.ser$(EXEEXT): tableopts_ser_nr-Caef.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_CaeF_ser_SOURCES = tableopts.l4
tableopts_ser_nr_Cae_F_ser_SOURCES = tableopts.l4
tableopts_ser_nr-CaeF.ser$(EXEEXT): tableopts_ser_nr-CaeF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ser_nr-Cae_F.ser$(EXEEXT): tableopts_ser_nr-Cae_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Cam_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Cam.ser$(EXEEXT): tableopts_ser_nr-Cam.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_nr_Caem_ser_SOURCES = tableopts.l4
tableopts_ser_nr-Caem.ser$(EXEEXT): tableopts_ser_nr-Caem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Ca_ser_SOURCES = tableopts.l4
tableopts_ser_r-Ca.ser$(EXEEXT): tableopts_ser_r-Ca.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Ce_ser_SOURCES = tableopts.l4
tableopts_ser_r-Ce.ser$(EXEEXT): tableopts_ser_r-Ce.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Cf_ser_SOURCES = tableopts.l4
tableopts_ser_r-Cf.ser$(EXEEXT): tableopts_ser_r-Cf.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_CF_ser_SOURCES = tableopts.l4
tableopts_ser_r_C_F_ser_SOURCES = tableopts.l4
tableopts_ser_r-CF.ser$(EXEEXT): tableopts_ser_r-CF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ser_r-C_F.ser$(EXEEXT): tableopts_ser_r-C_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Cm_ser_SOURCES = tableopts.l4
tableopts_ser_r-Cm.ser$(EXEEXT): tableopts_ser_r-Cm.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Cem_ser_SOURCES = tableopts.l4
tableopts_ser_r-Cem.ser$(EXEEXT): tableopts_ser_r-Cem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Cae_ser_SOURCES = tableopts.l4
tableopts_ser_r-Cae.ser$(EXEEXT): tableopts_ser_r-Cae.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Caef_ser_SOURCES = tableopts.l4
tableopts_ser_r-Caef.ser$(EXEEXT): tableopts_ser_r-Caef.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_CaeF_ser_SOURCES = tableopts.l4
tableopts_ser_r_Cae_F_ser_SOURCES = tableopts.l4
tableopts_ser_r-CaeF.ser$(EXEEXT): tableopts_ser_r-CaeF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ser_r-Cae_F.ser$(EXEEXT): tableopts_ser_r-Cae_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Cam_ser_SOURCES = tableopts.l4
tableopts_ser_r-Cam.ser$(EXEEXT): tableopts_ser_r-Cam.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ser_r_Caem_ser_SOURCES = tableopts.l4
tableopts_ser_r-Caem.ser$(EXEEXT): tableopts_ser_r-Caem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Ca_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Ca.ver$(EXEEXT): tableopts_ver_nr-Ca.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Ce_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Ce.ver$(EXEEXT): tableopts_ver_nr-Ce.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Cf_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Cf.ver$(EXEEXT): tableopts_ver_nr-Cf.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_CF_ver_SOURCES = tableopts.l4
tableopts_ver_nr_C_F_ver_SOURCES = tableopts.l4
tableopts_ver_nr-CF.ver$(EXEEXT): tableopts_ver_nr-CF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ver_nr-C_F.ver$(EXEEXT): tableopts_ver_nr-C_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Cm_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Cm.ver$(EXEEXT): tableopts_ver_nr-Cm.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Cem_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Cem.ver$(EXEEXT): tableopts_ver_nr-Cem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Cae_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Cae.ver$(EXEEXT): tableopts_ver_nr-Cae.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Caef_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Caef.ver$(EXEEXT): tableopts_ver_nr-Caef.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_CaeF_ver_SOURCES = tableopts.l4
tableopts_ver_nr_Cae_F_ver_SOURCES = tableopts.l4
tableopts_ver_nr-CaeF.ver$(EXEEXT): tableopts_ver_nr-CaeF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ver_nr-Cae_F.ver$(EXEEXT): tableopts_ver_nr-Cae_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Cam_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Cam.ver$(EXEEXT): tableopts_ver_nr-Cam.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_nr_Caem_ver_SOURCES = tableopts.l4
tableopts_ver_nr-Caem.ver$(EXEEXT): tableopts_ver_nr-Caem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Ca_ver_SOURCES = tableopts.l4
tableopts_ver_r-Ca.ver$(EXEEXT): tableopts_ver_r-Ca.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Ce_ver_SOURCES = tableopts.l4
tableopts_ver_r-Ce.ver$(EXEEXT): tableopts_ver_r-Ce.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Cf_ver_SOURCES = tableopts.l4
tableopts_ver_r-Cf.ver$(EXEEXT): tableopts_ver_r-Cf.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_CF_ver_SOURCES = tableopts.l4
tableopts_ver_r_C_F_ver_SOURCES = tableopts.l4
tableopts_ver_r-CF.ver$(EXEEXT): tableopts_ver_r-CF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ver_r-C_F.ver$(EXEEXT): tableopts_ver_r-C_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Cm_ver_SOURCES = tableopts.l4
tableopts_ver_r-Cm.ver$(EXEEXT): tableopts_ver_r-Cm.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Cem_ver_SOURCES = tableopts.l4
tableopts_ver_r-Cem.ver$(EXEEXT): tableopts_ver_r-Cem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Cae_ver_SOURCES = tableopts.l4
tableopts_ver_r-Cae.ver$(EXEEXT): tableopts_ver_r-Cae.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Caef_ver_SOURCES = tableopts.l4
tableopts_ver_r-Caef.ver$(EXEEXT): tableopts_ver_r-Caef.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_CaeF_ver_SOURCES = tableopts.l4
tableopts_ver_r_Cae_F_ver_SOURCES = tableopts.l4
tableopts_ver_r-CaeF.ver$(EXEEXT): tableopts_ver_r-CaeF.$(OBJEXT)
$(LINK) -o $@ $<
tableopts_ver_r-Cae_F.ver$(EXEEXT): tableopts_ver_r-Cae_F.$(OBJEXT)
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Cam_ver_SOURCES = tableopts.l4
tableopts_ver_r-Cam.ver$(EXEEXT): tableopts_ver_r-Cam.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
tableopts_ver_r_Caem_ver_SOURCES = tableopts.l4
tableopts_ver_r-Caem.ver$(EXEEXT): tableopts_ver_r-Caem.$(OBJEXT)
$(LINK) -o $@ $<
$(AM_V_CCLD)$(LINK) $<
TABLEOPTS_TESTS = tableopts_opt_nr-Ca.opt tableopts_opt_nr-Ce.opt tableopts_opt_nr-Cf.opt tableopts_opt_nr-CF.opt tableopts_opt_nr-Cm.opt tableopts_opt_nr-Cem.opt tableopts_opt_nr-Cae.opt tableopts_opt_nr-Caef.opt tableopts_opt_nr-CaeF.opt tableopts_opt_nr-Cam.opt tableopts_opt_nr-Caem.opt tableopts_opt_r-Ca.opt tableopts_opt_r-Ce.opt tableopts_opt_r-Cf.opt tableopts_opt_r-CF.opt tableopts_opt_r-Cm.opt tableopts_opt_r-Cem.opt tableopts_opt_r-Cae.opt tableopts_opt_r-Caef.opt tableopts_opt_r-CaeF.opt tableopts_opt_r-Cam.opt tableopts_opt_r-Caem.opt tableopts_ser_nr-Ca.ser tableopts_ser_nr-Ce.ser tableopts_ser_nr-Cf.ser tableopts_ser_nr-CF.ser tableopts_ser_nr-Cm.ser tableopts_ser_nr-Cem.ser tableopts_ser_nr-Cae.ser tableopts_ser_nr-Caef.ser tableopts_ser_nr-CaeF.ser tableopts_ser_nr-Cam.ser tableopts_ser_nr-Caem.ser tableopts_ser_r-Ca.ser tableopts_ser_r-Ce.ser tableopts_ser_r-Cf.ser tableopts_ser_r-CF.ser tableopts_ser_r-Cm.ser tableopts_ser_r-Cem.ser tableopts_ser_r-Cae.ser tableopts_ser_r-Caef.ser tableopts_ser_r-CaeF.ser tableopts_ser_r-Cam.ser tableopts_ser_r-Caem.ser tableopts_ver_nr-Ca.ver tableopts_ver_nr-Ce.ver tableopts_ver_nr-Cf.ver tableopts_ver_nr-CF.ver tableopts_ver_nr-Cm.ver tableopts_ver_nr-Cem.ver tableopts_ver_nr-Cae.ver tableopts_ver_nr-Caef.ver tableopts_ver_nr-CaeF.ver tableopts_ver_nr-Cam.ver tableopts_ver_nr-Caem.ver tableopts_ver_r-Ca.ver tableopts_ver_r-Ce.ver tableopts_ver_r-Cf.ver tableopts_ver_r-CF.ver tableopts_ver_r-Cm.ver tableopts_ver_r-Cem.ver tableopts_ver_r-Cae.ver tableopts_ver_r-Caef.ver tableopts_ver_r-CaeF.ver tableopts_ver_r-Cam.ver tableopts_ver_r-Caem.ver
TABLEOPTS_TESTS = tableopts_opt_nr-Ca.opt tableopts_opt_nr-Ce.opt tableopts_opt_nr-Cf.opt tableopts_opt_nr-C_F.opt tableopts_opt_nr-Cm.opt tableopts_opt_nr-Cem.opt tableopts_opt_nr-Cae.opt tableopts_opt_nr-Caef.opt tableopts_opt_nr-Cae_F.opt tableopts_opt_nr-Cam.opt tableopts_opt_nr-Caem.opt tableopts_opt_r-Ca.opt tableopts_opt_r-Ce.opt tableopts_opt_r-Cf.opt tableopts_opt_r-C_F.opt tableopts_opt_r-Cm.opt tableopts_opt_r-Cem.opt tableopts_opt_r-Cae.opt tableopts_opt_r-Caef.opt tableopts_opt_r-Cae_F.opt tableopts_opt_r-Cam.opt tableopts_opt_r-Caem.opt tableopts_ser_nr-Ca.ser tableopts_ser_nr-Ce.ser tableopts_ser_nr-Cf.ser tableopts_ser_nr-C_F.ser tableopts_ser_nr-Cm.ser tableopts_ser_nr-Cem.ser tableopts_ser_nr-Cae.ser tableopts_ser_nr-Caef.ser tableopts_ser_nr-Cae_F.ser tableopts_ser_nr-Cam.ser tableopts_ser_nr-Caem.ser tableopts_ser_r-Ca.ser tableopts_ser_r-Ce.ser tableopts_ser_r-Cf.ser tableopts_ser_r-C_F.ser tableopts_ser_r-Cm.ser tableopts_ser_r-Cem.ser tableopts_ser_r-Cae.ser tableopts_ser_r-Caef.ser tableopts_ser_r-Cae_F.ser tableopts_ser_r-Cam.ser tableopts_ser_r-Caem.ser tableopts_ver_nr-Ca.ver tableopts_ver_nr-Ce.ver tableopts_ver_nr-Cf.ver tableopts_ver_nr-C_F.ver tableopts_ver_nr-Cm.ver tableopts_ver_nr-Cem.ver tableopts_ver_nr-Cae.ver tableopts_ver_nr-Caef.ver tableopts_ver_nr-Cae_F.ver tableopts_ver_nr-Cam.ver tableopts_ver_nr-Caem.ver tableopts_ver_r-Ca.ver tableopts_ver_r-Ce.ver tableopts_ver_r-Cf.ver tableopts_ver_r-C_F.ver tableopts_ver_r-Cm.ver tableopts_ver_r-Cem.ver tableopts_ver_r-Cae.ver tableopts_ver_r-Caef.ver tableopts_ver_r-Cae_F.ver tableopts_ver_r-Cam.ver tableopts_ver_r-Caem.ver
tableopts_tables = tableopts_ser_nr-Ca.ser.tables tableopts_ser_nr-Ce.ser.tables tableopts_ser_nr-Cf.ser.tables tableopts_ser_nr-CF.ser.tables tableopts_ser_nr-Cm.ser.tables tableopts_ser_nr-Cem.ser.tables tableopts_ser_nr-Cae.ser.tables tableopts_ser_nr-Caef.ser.tables tableopts_ser_nr-CaeF.ser.tables tableopts_ser_nr-Cam.ser.tables tableopts_ser_nr-Caem.ser.tables tableopts_ser_r-Ca.ser.tables tableopts_ser_r-Ce.ser.tables tableopts_ser_r-Cf.ser.tables tableopts_ser_r-CF.ser.tables tableopts_ser_r-Cm.ser.tables tableopts_ser_r-Cem.ser.tables tableopts_ser_r-Cae.ser.tables tableopts_ser_r-Caef.ser.tables tableopts_ser_r-CaeF.ser.tables tableopts_ser_r-Cam.ser.tables tableopts_ser_r-Caem.ser.tables tableopts_ver_nr-Ca.ver.tables tableopts_ver_nr-Ce.ver.tables tableopts_ver_nr-Cf.ver.tables tableopts_ver_nr-CF.ver.tables tableopts_ver_nr-Cm.ver.tables tableopts_ver_nr-Cem.ver.tables tableopts_ver_nr-Cae.ver.tables tableopts_ver_nr-Caef.ver.tables tableopts_ver_nr-CaeF.ver.tables tableopts_ver_nr-Cam.ver.tables tableopts_ver_nr-Caem.ver.tables tableopts_ver_r-Ca.ver.tables tableopts_ver_r-Ce.ver.tables tableopts_ver_r-Cf.ver.tables tableopts_ver_r-CF.ver.tables tableopts_ver_r-Cm.ver.tables tableopts_ver_r-Cem.ver.tables tableopts_ver_r-Cae.ver.tables tableopts_ver_r-Caef.ver.tables tableopts_ver_r-CaeF.ver.tables tableopts_ver_r-Cam.ver.tables tableopts_ver_r-Caem.ver.tables
tableopts_tables = tableopts_ser_nr-Ca.ser.tables tableopts_ser_nr-Ce.ser.tables tableopts_ser_nr-Cf.ser.tables tableopts_ser_nr-C_F.ser.tables tableopts_ser_nr-Cm.ser.tables tableopts_ser_nr-Cem.ser.tables tableopts_ser_nr-Cae.ser.tables tableopts_ser_nr-Caef.ser.tables tableopts_ser_nr-Cae_F.ser.tables tableopts_ser_nr-Cam.ser.tables tableopts_ser_nr-Caem.ser.tables tableopts_ser_r-Ca.ser.tables tableopts_ser_r-Ce.ser.tables tableopts_ser_r-Cf.ser.tables tableopts_ser_r-C_F.ser.tables tableopts_ser_r-Cm.ser.tables tableopts_ser_r-Cem.ser.tables tableopts_ser_r-Cae.ser.tables tableopts_ser_r-Caef.ser.tables tableopts_ser_r-Cae_F.ser.tables tableopts_ser_r-Cam.ser.tables tableopts_ser_r-Caem.ser.tables tableopts_ver_nr-Ca.ver.tables tableopts_ver_nr-Ce.ver.tables tableopts_ver_nr-Cf.ver.tables tableopts_ver_nr-C_F.ver.tables tableopts_ver_nr-Cm.ver.tables tableopts_ver_nr-Cem.ver.tables tableopts_ver_nr-Cae.ver.tables tableopts_ver_nr-Caef.ver.tables tableopts_ver_nr-Cae_F.ver.tables tableopts_ver_nr-Cam.ver.tables tableopts_ver_nr-Caem.ver.tables tableopts_ver_r-Ca.ver.tables tableopts_ver_r-Ce.ver.tables tableopts_ver_r-Cf.ver.tables tableopts_ver_r-C_F.ver.tables tableopts_ver_r-Cm.ver.tables tableopts_ver_r-Cem.ver.tables tableopts_ver_r-Cae.ver.tables tableopts_ver_r-Caef.ver.tables tableopts_ver_r-Cae_F.ver.tables tableopts_ver_r-Cam.ver.tables tableopts_ver_r-Caem.ver.tables
tests/tableopts.sh
+16 -10
View File
@@ -1,12 +1,15 @@
#!/bin/bash
set -euo pipefail
IFS=$'\n\t'
#!/bin/sh
set -eu
# IFS=$'\n\t'
IFS='
'' '
# This script is present to generate the automake _SOURCES variables
# for the tableopts_* tests. It also generates the linking rules for
# each test since automake isn't able to handle the pattern rules that
# would be natural to use. Output is written to standard output for
# inclusion in a Makefile.am, typically by redirecting the output and then an automake include directive.
# inclusion in a Makefile.am, typically by redirecting the output and
# then an automake include directive.
TABLEOPTS_TESTS=""
tableopts_tables=""
@@ -14,25 +17,28 @@ tableopts_tables=""
for kind in opt ser ver ; do
for threading in nr r ; do
for opt in -Ca -Ce -Cf -CF -Cm -Cem -Cae -Caef -CaeF -Cam -Caem ; do
testname=tableopts_${kind}_${threading}${opt}.${kind}
bare_opt=${opt#-}
# The filenames must work on case-insensitive filesystems.
bare_opt=`echo ${bare_opt}| sed 's/F$/_F/'`
testname=tableopts_${kind}_${threading}-${bare_opt}.${kind}
if [ "${TABLEOPTS_TESTS}" = "" ] ;then
TABLEOPTS_TESTS=${testname}
if [ "$kind" = "ser" -o "$kind" = "ver" ] ; then
if [ "$kind" = "ser" ] || [ "$kind" = "ver" ] ; then
tableopts_tables=${testname}.tables
fi
else
TABLEOPTS_TESTS="${TABLEOPTS_TESTS} ${testname}"
if [ "$kind" = "ser" -o "$kind" = "ver" ] ; then
if [ "$kind" = "ser" ] || [ "$kind" = "ver" ] ; then
tableopts_tables="${tableopts_tables} ${testname}.tables"
fi
fi
bare_opt=${opt#-}
cat << EOF
tableopts_${kind}_${threading}_${bare_opt}_${kind}_SOURCES = tableopts.l4
${testname}\$(EXEEXT): tableopts_${kind}_${threading}${opt}.\$(OBJEXT)
\$(LINK) -o \$@ \$<
${testname}\$(EXEEXT): tableopts_${kind}_${threading}-${bare_opt}.\$(OBJEXT)
\$(AM_V_CCLD)\$(LINK) \$<
EOF
done
tests/testwrapper-direct.sh
+9 -6
View File
@@ -1,17 +1,20 @@
#!/bin/bash -vx
set -euo pipefail
#!/bin/sh
echo 'set -euvx'
set -euvx
# testwrapper-direct.sh: run some specialized flex tests that care where they're run from.
# testwrapper-direct.sh: run some specialized flex tests that care where
# they're run from.
while getopts :b:s: OPTION ; do
case $OPTION in
b) BINARY_DIR=$OPTARG ;;
b) BINARY_DIR=$OPTARG ;;
s) SOURCE_DIR=$OPTARG ;;
esac
done
TESTNAME="${!OPTIND}"
shift $(($OPTIND-1))
TESTNAME=$1
INPUT_NAME=`basename ${TESTNAME%.exe}`.txt
INPUT_NAME=`basename "${TESTNAME%.exe}"`.txt
cd ${SOURCE_DIR} && ${BINARY_DIR}/${TESTNAME} ${INPUT_NAME}
tests/testwrapper.sh
+17 -12
View File
@@ -1,9 +1,11 @@
#!/bin/bash -vx
set -euo pipefail
#!/bin/sh
echo 'set -euvx'
set -euvx
# testwrapper.sh: run a flex test, typically called by a Makefile
# Each test will exercise some feature or aspect of flex. Run the test with any input it may need.
# Each test will exercise some feature or aspect of flex. Run the test with any
# input it may need.
INPUT_DIRECTORY=""
INPUT_NAME=""
@@ -15,7 +17,7 @@ while getopts :d:i:rt1 OPTION ; do
case $OPTION in
d) INPUT_DIRECTORY=$OPTARG ;;
i)
if [ "$INPUT_NAME" == "" ] ; then
if [ "$INPUT_NAME" = "" ] ; then
INPUT_NAME="$OPTARG"
else
INPUT_NAME="$INPUT_NAME $OPTARG"
@@ -26,24 +28,27 @@ while getopts :d:i:rt1 OPTION ; do
t) USE_TABLES=1 ;;
1) DO_COMPARISON=1 ;;
esac
done
done
TESTNAME="${!OPTIND}"
shift $(($OPTIND-1))
TESTNAME=$1
INPUT_NAME=${INPUT_NAME:-$INPUT_DIRECTORY/`basename ${TESTNAME%.exe}`.txt}
INPUT_NAME=${INPUT_NAME:-$INPUT_DIRECTORY/`basename "${TESTNAME%.exe}"`.txt}
if [ "$DO_COMPARISON" -eq "1" ] ; then
test `$TESTNAME 1 < $INPUT_NAME` -eq `$TESTNAME < $INPUT_NAME`
if [ $DO_COMPARISON = 1 ] ; then
TEST_OUTPUT=`$TESTNAME < $INPUT_NAME`
REF_OUTPUT=`$TESTNAME 1 < $INPUT_NAME`
test "$TEST_OUTPUT" -eq "$REF_OUTPUT"
exit $?
fi
fi
if [ $INPUT_COUNT -gt 1 ] ; then
$TESTNAME ${USE_TABLES:+${INPUT_DIRECTORY}/${TESTNAME%.exe}.tables} ${INPUT_NAME}
exit $?
fi
fi
if [ -f ${INPUT_NAME} ] ; then
if [ $USE_REDIRECT == 1 ] ; then
if [ $USE_REDIRECT = 1 ] ; then
$TESTNAME ${USE_TABLES:+${INPUT_DIRECTORY}/${TESTNAME%.exe}.tables} < $INPUT_NAME
else
$TESTNAME ${USE_TABLES:+${INPUT_DIRECTORY}/${TESTNAME%.exe}.tables} $INPUT_NAME