'--skeleton': fixed codegen error with '-b' (don't forget last bitmap element).

'--skeleton': added missing newline in the generated code.

'--skeleton': tell function name when reporting errors and warnings.

'--skeleton': respect empty string match.

Fixed skeleton generation in '-r' mode.

'-r' is different from normal mode in two aspects:
    - single DFA may be used multiple times (unchanged, we only
      need a single copy for skeleton)
    - DFA may be generated but not used at all

Split skeleton arc count limits for permutations, cover and default paths.

Docs: updated descriptions of some inplace configurations.

Unified meaning and mutual relations of some inplace configurations.

This commit changes the behaviour of three groups of options:

    re2c:define:YYSETCONDITION
    re2c:define:YYSETCONDITION@cond
    re2c:define:YYSETCONDITION:naked

    re2c:define:YYSETSTATE
    re2c:define:YYSETSTATE@state
    re2c:define:YYSETSTATE:naked (added by this commit)

    re2c:define:YYFILL
    re2c:define:YYFILL@len
    re2c:yyfill:parameter
    re2c:define:YYFILL:naked

The changes should be backwards compatible (meaning that old code that
compiled should still compile), but it may add empty statements or statements
with no effect for some configurations, e.g.:
    YYSETCONDTITION(0);(0);
These changes were necessary to unify re2c behaviour, remove counter-intuitive
cases and make it possible to write comprehensible option descriptions.

In short, the changes are:
    - 'naked' triggers generation of argument-in-braces and semicolon;
    - 'parameter' triggers generation of argument-in-braces (when applicable,
      'naked' has priority over 'parameter');
    - argument templates ('@cond', '@state', '@len') don't force other
      configurations, they also don't influence on argument-in-braces;

Added test generator and autogenerated tests.

run_tests.sh: preserve nested directory structure when dumping errors.

Don't hang forever trying to replace empty configuration arguments.

Default options should be syncronized as well.

Reduced redundant global flags.

Handle all inplace configurations in a uniform way.

This commit removes check (and error) for overwritten configurations
(like setting 're2c:define:YYCYRSOR' twice in the same block).
This check was in principle useful, but it was applied to somehow
randomly chosen set of parameters. If in future we'll feel a need
for such check, it should respect all options equally and report
warning rather than error.

Automatically resync options on read acccess (if they have been updated).

Merged 'DFlag' and 'flag_skeleton' into one option 'target'.

The nature of these options makes them mutually exclusive; so instead
of checking that they are not both set just make them a single option.

Separated user config and effective config.

Prepare to separate user config and effective config.

Keep name table together with other options.

Grouped options together in a struct.

Documentation: added warning descriptions to manpage and online manual.

Documentation: added warning descriptions to '-h, -?, --help' option.

Removed unused method declaration.

Gather some DFA statistics and use it to omit unused code with '--skeleton'.

Omit usseless 'yyaccept' variable in '--skeleton' programs.

Normally re2c generates single 'yyaccept' variable for all conditions.
With '--skeleton' re2c handles conditions separately, so each condition
needs (or needs not) its own 'yyaccept'.

Prior to this commit re2c used the same criterion to determine if
'yyaccept' is needed with '--skeleton' as it uses generally: whether
'yyaccept' was used in any of conditions. Now re2c looks if 'yyaccept'
was used with this particular condition.

Generate better code with '--skeleton': C90-compliant, free resources on errors.

Check 'fread' return value in program generated with '--skeleton'.

Support '--skeleton' with conditions and multiple re2c blocks.

Make 'filesize' function for '--skeleton' preserve original file position.

Fixed MINGW builds where 'sizeof (int)' is equal to 'sizeof (long)'.

Changed '-Wcondition-order' to warn even if 'YYSETCONDITION' is used.

Tests 'condtype_yysetcondition.c{s,g}.re' show the reason why I changed
how '-Wcondition-order' works in presence of 'YYSETCONDITION' calls:
programs generated from these tests work differently depending on
condition numbering. Explicit use of condition names cannot guarantee
that these explicit names were generated by re2c (and not hardcoded as
in these examples).

More accurate handling of default rule for '--skeleton'.

The generated '--skeleton' program now warns about undefined control flow.

Fixed error in calculation of maximal path length in skeleton.

Compacted keys representation (with '--skeleton').

Determine maximal path length and maximal rule number while constructing
skeleton; take maximim of these two values; choose unsigned integer type
of minimal width capable of holding maximim.

Note: re2c operates on exact-width integers, but the generated program
doesn't (it might not have <stdint.h>). When generating the program,
re2c choses one of unsigned 'char', 'short', 'int' and 'long' types
(that one 'sizeof' which is equal to the disired key size). re2c makes
some implicit assumptions (generated program is run on the same platform
as re2c, byte consists of 8 bits, etc.). Perhaps re2c should hardcode
these assumptions in the generated program and check them on start.

Store keys for '--skeleton' in binary.

A single key is formed of three values:
    1. the length of string
    2. the length of matched part of string
    3. the number of matched rule
All these values are guaranteed to fit 32 bits, so for now we just
dump them as 'uint32_t' and read as 'unsigned int'. re2c asserts that
'sizeof (uint32_t) == sizeof (unsigned int)'.

Avoid structs, as they cause padding issues.

Estimate maximal path length in skeleton and abort if it overflows.

Maximal skeleton path length is a bit different from YYMAXFILL:
it assumes that loops are iterated once (unlike YYMAXFILL calculation,
which disregards loops) and returns zero for empty regexp.

We need to know it in order:
    - to be sure it won't overflow
    - to store keys in a compact form (yet to be done)

This commit also makes DFA and skeleton store condition name and
source file line corresponding to current condition: it gets quite
annoying to pass these things around. This change caused another
change of test results (line numbers in error messages changed
for tests that use '-r' and reuse old DFA (don't reconstruct DFA
in 'use:re2c' blocks).

Fixed memleaks (skeleton nodes were not destructed properly).

Found with 'make vtests'

Make skeleton a part of DFA.

This let us create skeletom right after DFA creation (but befor DFA
has been mangled in different ways), but call skeleton methods any time.

Undefined control flow is now checked at the time of real code generation,
that's why all those tests that use '-r' changed: re2c stopped reporting
'rules:re2c' blocks and reports 'use:re2c' blocks instead.

Suffixes of skeleton end nodes should be initialized by algorithm that uses them.

Renamed function.

A more logical way to update rules when constructing skeleton paths.

There's no need to keep rule one step behind path's arcs and update
it manually. Also, it is reasonable to set rule in constructor.

Reduced the time of path generation with '--skeleton'.

The algorithm now stores partially constructed paths in a compact
form and delays expansion until it reaches the end of current
branch of recursion. This has several advantages:
    - no need to store large structures in memory
    - write data to file in large chunks
    - path expansion is faster than step-by-step construction

Speedup is actually tenfold (but the way keys are dumped to file is
still not optimized and spoils benchmarks). Real speedup can be
observed on such files as:
    test/php20150211_zend_ini_scanner_trimmed.icF.re
, which cause ~5Gb dumps. Time has gone down: 8.5m -> 2.5m and will
be furter reduced to ~1m when key dumps are fixed. This will result
in generation speed ~20Mb/s which is quite good.

Renamed and restructured various kinds of skeleton paths.

Fixed eternal loop in path cover generation algorithm for '--skeleton'.

The simplest example I was able to come up with that reveals eternal
loop is the following:
    /*!re2c
        ( [^acf] | "0b" | "a"[^] | "a0"[^] )+ {}
    */
The problem was caused by my assumption that from any node there is
at least one non-looping path to end node. The assumption is true;
what I didn't take into account was that all such paths may go via
nodes that have already occured twice on the way to current node
(their loop counter is greater than 1). In this case the algorithm
would find no path to end node. Since not all prefixes would have
been covered (exactly none of them) the algorithm would loop forever.

Such branch may be abandoned safely: the algorithm will later find
another path to current state without loops.

As soon as I realized the problem the fix was trivial: if all outgoing
arcs have been exhausted and none of them yielded any results, abandon
current branch.

With '--skeleton', store input data in binary form (rather than C/C++ code).

There's a limitation on the size of input files for C/C++ compiler and
the compiled binary will have to contain all that data (and thus may grow
very large).

Storing data in binary form and reading it from file dynamically is
the way it should be.

With '-skeleton', dump data to file immediately as it is generated.

This way re2c won't consume memory even on large inputs.

Changed '.keys' file format (generated with '--skeleton').

Store length of strings instead of pointers to string start and end.

Storing pointers requires us to remember total length of strings already
written to file by the time we want to write next string. This is very
inconvenient if we want to dump strings as we perform DFS on graph:
we'll have to track size all the time (path-cover-generator already does
that, but all-paths-generator doesn't).

This adds a new local variable to the generated code ('token'), which
is used to backup cursor position when enterind DFA.

Split ".data" files (generated with '--skeleton') into two parts.

This is necessary to dump generated data as soon as possible instead
of keeping it until all data has been generated: we generate input
strings and keys simultaneously, but have to write all input strings
at once as one big string. Keys alone occupy lots of space, so
keeping only keys instead of keys and strings won't help.

Combined path cover generation with path cover size estimation.

We don't have any fallback algorithm in case path cover is too large.
We want to generate some paths anyway, so we have to construct path cover.
We shouldn't generate arbitrary large amounts of data.

Omit some highly unlikely conditional exits from deep-first search.

With '--skeleton' re2c builds DFA skeleton and performs DFS in order to
estimate the size of data to be generated. It maintains size counter: as
soon as the counter reaches certain limit, DFS should stop.

Size counter is always checked when recursion returns.
Sometimes it is clear that size counter will overflow upon recursion
return (when arguments overflow already) and DFS can exit early (before
entering recursion).

This commit omits checks of some arguments (and correponding early exits
from DFS): first, path length is very unlikely to overflow (one has to
write/generate a regular expression with length of ~1Gb, in which case
skeleton generation won't be the worst problem); second, the number of
outgoing arcs in each vertex is also highly unlikely to exceed 1Gb limit.

Split large source file into smaller files with distinct functionality.

Narrowed the scope of ".data" file.

Hid internals of skeleton paths under construction.

Renamed and fixed warning about undefined control flow in generated lexer.

Renamed '-Wnaked-default' to '-Wundefined-control-flow': the latter sounds
much scarier. :D

Completely changed the algorithm that is used to determine if default case
is not handled properly. Prior to this commit a simple and incorrent criterion
was used: whether there are code units that (alone) do not match any rule.
This gived false positives in cases like this:
    [^] [^] { rule }
here all code units meet the criterion: no single code unit matches a rule.
But obviously, default case is handled properly, because any input string
matches 'rule' (strictly speaking, any input string of length 2 or more, but
that's YYFILL's problem).

The new algorithm is more complex (in terms of time and space), yet it is
less heuristic: re2c parforms exhaustive deep-first-search on graph skeleton
and collects all bad paths.

No need to NULL-terminate array of known size.

For some reason (which I yet do not understand) re2c uses size of DFA
state's "kernel" to determine whether a new state should be constructed
or some already constructed state (of the same "kernel" size) will do.

Since re2c knows "kernel" size for each state anyway, there's no need
to NULL-terminate "kernel" array while iterating over it: we can use
pre-calculated size instead.

Narrowed scope of local variables.

Simplified array bounds check.

Comparing against pointer to the end of array is easier than calculating
array length, then setting next-to-last element to NULL and iterating
while not NULL.

Another minor simplification of control flow.

Clarified control flow in nested loops.

Narrowed scope of local variables.

Pass signed integer to 'std::setw' to avoid [-Wsign-conversion] warning.

Don't mix up empty code block with nonexistent one in rule actions.

Turns out that re2c allows empty code blocks:
    /*!re2c
    <a> "a" :=
    */

re2c up to 0.14.3 handled this correctly (generated empty action).
Since then this behaviour has been broken: re2c started to autogenerate
jump to nonexistent condition.

Delay '-Wcondition-order' reporting until we have necessary info.

'-Wcondition-order' depends on 'YYSETCONDITION' calls and 'types:re2c'
directive which may occur after condition dispatch is generated.

Added warning '-Wcondition-order'.

See parent commit 8c1fe4f0113685b599bf906360814e4715e05447
"Simplified tracking of condition order." for details.

Simplified tracking of condition order.

In theory re2c makes no guarantee about the order of conditions in
the generated lexer. Users should use 'YYGETCONDITION'/'YYSETCONDITION'
interface and generate enum with condition names using either '-t'
option or '/*!types:re2c*/' directive. Only members of the generated
enum should be used with 'YYGETCONDITION' and 'YYSETCONDITION'.
This way code is independent of internal re2c condition numbering.

However, it turns out that some users (and notably, PHP) rely on
internal condition numbering: they manually hardcode condition numbers
and make re2c generate condition dispatch in such a way that it
doesn't mention condition names at all (e.g. with in the form of nested
'if' statements with '-b' or in the form of 'goto' table with '-g').
The code compiles, but change of code generation mode may break
compilation. Even worse, change of internal re2c condition numbering
may lead to epic runtime failures.

So re2c cannot just change internal condition numbering: it has to
preserve the existing numbering scheme (rather illogical and not
alphabetically sorted).

This commit tries to simplify tracking of condition numbers.

Fixed bug #119: "-f with -b/-g generates incorrect dispatch on fill labels".

Consider the following example 1.re:
    /*!re2c
        "" {}
    */
With -if, re2c would generate correct dispatch:
    $ re2c -if 1.re
    /* Generated by re2c 0.14.3 on Tue Aug 25 10:41:45 2015 */
            switch (YYGETSTATE()) {
            default: goto yy0;
            case 0: goto yyFillLabel0;
            }
    yy0:
            YYSETSTATE(0);
    yyFillLabel0:
            {}

With -bif all positive YYGETSTATE() values will lead to yyFillLabel0,
which is clearly an error: values that are greater than 0 should lead
to yy0:
    $ re2c -bif 1.re
    /* Generated by re2c 0.14.3 on Tue Aug 25 10:40:32 2015 */
            if (YYGETSTATE() < 0) {
                    goto yy0;
            } else {
                    goto yyFillLabel0;
            }
    yy0:
            YYSETSTATE(0);
    yyFillLabel0:
            {}

With -gif the error is different: all values greater than 0 now cause
undefined behaviour (access to memory not within array bounds):
    $ re2c -gif 1.re
    /* Generated by re2c 0.14.3 on Tue Aug 25 10:47:41 2015 */
    {
            static void *yystable[] = {
                    &&yyFillLabel0,
            };
            if (YYGETSTATE() < 0) {
                    goto yy0;
            }
            goto *yystable[YYGETSTATE()];
    yy0:
            YYSETSTATE(0);
    yyFillLabel0:
            {}
    }

The situation gets even more tricky with re2c:state:abort configuration.
Besides, YYGETSTATE() macro is called multiple times with -b and -g,
which is not so good. Additional checks with -g don't help gain performance
either.

Fix: always generate simple switch.

Makefile.am: update bootstrap parser when necessary.

The mechanism of updating bootstrap parser was broken by commit
b2bc24704ebd2a0e6050f755dbd93a5cd987a418 : "Support 'make distcheck'."

Before that commit bootstrap parser was updated every time when autogenerated
parser was updated. This approach contradicted with 'make distcheck' which
mounts top source directory read-only (including bootstrap files). That commit
tried to solve the problem by checking if the autogenerated parser has changed
and only then copying it to bootstrap parser.

I made two mistakes:
    - philisophic mistake: autogenerated parser was actually altered by
      'make distcheck' because of altered paths in '#line' info;
    - shell scripting mistake: the check if the autogenerated parser has
      changed was inverted, so bootstrap parser was never updated;

This commit makes use of two observations:
    - bootstrap parser depends on the source parser, not on the autogenerated
      parser;
    - bootstrap parser shouldn't at all contain line information: at the time
      it is copied to build directory the relative path from build directory
      to source directory may be completely different (as it is with 'make
      distcheck');

distcheck.sh can only run from top source directory.

Explicit cast of signed nonnegative to unsigned (found with [-Wsign-conversion]).

Parse configuration strings in the same way as character strings and classes.

re2c allows configuration strings to contain escape sequencs as long
as the escaped code points fit into 1-byte range.

Finally both 'Scanner::unescape' functions can be removed along with
a whole bunch of [-Wsign-conversion] warnings. :)

Tests: simple tests for parsing inplace configurations.

Tests do not ensure that configurations are handled correctly or
have any impact on re2c behaviour. They only ensure that these
configuration names are recognized as valid.

Parse inplace configuration names in lexer.

Make re2c do all the dirty work instead of barely recognizing
configuration-like lexeme and manually matching the lexeme against
all allowed configuration names.

This commit adds many new tokens, which means that re2c-generated lexer
and bison-generated parser have both become larger. The difference
is not as great as one might expect: ~60 Kb -> ~80 Kb in both cases.

Zero-extend code units when casing them from 'signed char' to 'uint32_t'.

The problem starts with lexer: it should operate on unsigned chars
(as re2c wants). Then these casts won't be needed at all. Mixing
signed and unsigned chars is bad and lexer should be rewritten to
use unsigned chars.

Forbid newline in strings and character classes.

Like C language, re2c allows all characters of current charset excapt for
newline and backslash to apper unescaped in string and class literals.

Added tests:
    - all possible characters in strings and classes (omitting
      newline, escaping backslash and quotes/closing bracket)
      with different encodings (re2c up to 0.14.x would segfault
      on this test with '-u' and '-w')
    - string with newline
    - string with unescaped backslash followed by newline (so that
      it won't stick to next character)

Tests: code points that exceed maximum for current encoding.

Test changes introduced by commit 0346d1666f58da5dbe35d156e0487d95354153ff:
"Check if code point exceeds maximum. Correctly cast 'char' to 'uint32_t'."

Check if code point exceeds maximum. Correctly cast 'char' to 'uint32_t'.

First fix:
re2c used to check if code point exceeds maximal value for current
encoding when parsing it. When I moved parsing code points to lexer
I forgot the check.

Second fix:
I assumed that 'static_cast<uint32_t>' on 'signed char' zero-extends.
But I was wrong: it sign-extends. Need to cast to 'unsigned char'
instead.

Parse unquoted flex-like strings in lexer.

Such strings can only contain ASCII letters, digits and uderscore:
no escapes. So there's very little parsing to do: just map code units
directly to code points.

Parse character strings in lexer.

This commit is a continuation of e42f271e4b284cd6ed590dc06a5239ce13942fc5:
"Parse character classes in lexer." It makes lexer parse individual code
points instead of barely recognizing string of code points.

Since the contents of case sensitive strings, case insensitive strings
and character classes are lexically the same (except for escaped quotes
or closing bracket), we can parse them all in the same lexer block.

Note that re2c allows any 1-byte code points. Maybe we should report
non-ASCII or non-printables.

Removed unused function.

Added warning '-Wuseless-escape'.

This is to warn about escaped printable ASCII characters that
shouldn't be escaped in the current context (e.g. quotes inside of
a character class).

Added warning '-Wswapped-range'.

When re2c parses character class and finds a range with lower bound
greater than upper bound, it silently swaps bounds. Warn about such
cases.

Parse character classes in lexer.

Before this commit, lexer would barely recognize class as a whole
lexeme and pass it to functions that would further parse is by manually
picking individual code points and control characters out of the lexeme.

Heh, re2c is made for such kind of stuff (and it does it much better).
So now lexer parses individual code points or control characters and
stores them as a sequence of code points. Then an outer function
splits this sequence into ranges and individual characters.

I tried to preserve existing behaviour (judging from test suite only
the text of some error messages has changed). Added some autogenerated
tests (and the generator script itself), but these tests are not exhaustive.

Lexer: no need to have "{0,}" special case.

Now "{0,}" is handled by general case for counted repetition. Had to
fix test because of swapped alternatives in construction of regexps
of the form "r*" and "r{n,".

Added some tests for counted repetition.

Restored explicit cast that was removed in 7af5d437e49878ea4e8de73a02d99ad4e5751933.

Found with [-Wsign-compare] while building with MINGW: pointer
difference is of different size on linux and windows.

Force definition of some conditionally defined parts of <stdint.h>.

Got some errors about undefined 'UINT32_MAX' and others while trying
to build re2c with MINGW. These variables are defined conditionally in
<stdint.h> depending on the following defines:
    __STDC_LIMIT_MACROS
    __STDC_CONSTANT_MACROS
Fix: defined these symbols in the beginning of "src/util/c99_stdint.h".

Also found out that "src/util/c99_stdint.h" didn't compile in the
absense of system <stdint.h> (which is exactly the case when it was
written for). THe problem was caused by incorrect use of 'typedef'
statement; fixed easily. What a shame I didn't compile it before ;D

Fixed [-Wsign-conversion] warnings in 'testrange' sources.

Use custom function instead of 'atoi' to read 32-bit integers.

Using 'atoi' displeased me for several reasons:
    - 'atoi' doesn't check for overflow
    - by the time 'atoi' was called, re2c has already parsed input
      string and knows that it is well-formed, no need to do it twice
    - atoi returns 'int', custom function allows to refine types and
      avoid casts between signed/unsigned values or [-Wsign-conversion]
      warnings

Added test for new conversion functions.

Don't use special regexp type for counted repetitions.

Counted repetitions are regexps of the form:
    r{n}
    r{n,m}
    r{n,}

They can be expressed in terms of concatenation, alternation and
iteration:
    r{0}      <empty regexp>
    r{n}      r{n-1} r
    r{n,m}    r{n} (r{0} | ... | r{m-n})
    r{n,}     r{n} r*

Reducing special regexp type to represent counted repetitions allows
us substitute complex code that compiles them to bytecode instructions
with simpler code that constructs counted repetitions using concatenation,
alternation and iteration.

Removed unused struct field.

Store lexer buffer size inside of lexer class.

Some more explicit casts in lexer fill procedure (found with [-Wsign-conversion]).

Lexer tries to maintain certain layout of pointers to buffer.
Buffer refilling procedure relies on that layout.

Lexer: unified token length calculation.

Token length equals the difference between two pointers: YYCURSOR
value on the moment of successful match and YYCURSOR value when
entering DFA. This difference should be nonnegative and fit buffer
size.

Use different local variables for unrelated tasks.

Fixed '#27 re2c crashes reading files containing %{ %}' (patch by Rui)

merged commit b068f3ad2ea7b01aa1eb63cb655c3357f856e85b from master.

Lexer: reduced unnecessary macro.

Lexer: glued together two variables with almost identical functionality.

These two variables ('ScannerState' class member 'cur' and local variable
'cursor') both played the role of YYCURSOR: YYCURSOR was defined to
'cursor', but the code had to adjust 'cur' to 'cursor' on every return
and restore it when reentering lexing procedures.

There was only two obscure places in which they were not completely
syncronized. Both looked the same:

    cur = ptr > tok ? ptr - 1 : cursor;

However, 'ptr' is effectively YYMARKER and is never changed manually
by lexing procedures; 'tok' should point to the beginning of current
lexeme; this check doesn't make sense to me. This is an attempt to
resume lexing one character before YYMARKER, but what for? YYMARKER
isn't even used in Scanner::scan (look at the the generated code),
so 'ptr > tok' is always false.

This check is present since the initial commit, so I cannot trace back
it's origin.

As it doesn't break any tests I hereby simply remove it.

Added tests for occasionally fixed bug in code generation.

The bug was triggered by the following conditions: '-b'
(or any flag that implies '-b') and encoding with code units
wider than 1 byte (that is, UTF-16, UTF-32 and UCS-2).

The bug itself: re2c omitted 'goto <some state>;' when it
should have been generated. The absense of goto caused incorrect
control flow. One cas verify it in two ways using the minimal test
added by this commit:
    - manually compare the code generated before and after fix
      and ensure that newer version generates correct code;
    - run the test with --skeleton, then try to add/remove
      the goto statement, compile and run: the code without
      goto will fail, the code with goto will not;

git-bisected commit which fixed bug:
    commit e42003d80529ab53413459c41a51114c7d437822
    Author: Ulya Trofimovich <skvadrik@gmail.com>
    Date:   Wed Mar 11 12:46:58 2015 +0000

        Pass limited span instead of checking range all the time.

Also gound commit that introduced bug:
    commit d10fb601f3ba257bae0845945daf1dfa754d6146
    Author: helly <helly@642ea486-5414-0410-9d7f-a0204ed87703>
    Date:   Fri Dec 30 16:24:07 2005 +0000

        - Allow to use -w with -b
        # Still quite some work to do but it is possible

More accurate loop counting (inspired by [-Wsign-compare]).

Loop counter should be unsigned (found with [-Wsign-compare]).

Simplified regexp construction for case insensitive strings.

As for now, we only support ASCII. This should be fixed.