Continued adding "--skeleton" switch.

Check possible overflow immediately.

Continued adding "--skeleton" switch.

Estimate the size of data to be generated rather than the number
of paths in DFA. Returns precise size or 'Skeleton::MAX_PATHS',
whatever is less. Estimate data size in both cases for all paths
or path cover.

Continued adding "--skeleton" switch.

Use RAII-style object to auto-decrement visit counter when
leaving local scope.

Continued adding "--skeleton" switch.

Improved readability of overflow checks when counting the number
of paths.

Added portable version of <stdint.h>, converted the whole project.

Continued adding "--skeleton" switch.

Generate all possible paths (with respect to range lower/upper
bounds) in case their total amount is less than
'Skeleton::PATHS_OVERFLOW'.

Continued adding "--skeleton" switch.

Be even more careful not to overflow path counter, check possible
multiplication overflow.

Continued adding "--skeleton" switch.

Fixed backtracking error introduced by previous commit: shouldn't
return prematurely, need to unmark state as visited first.

Some renaming.

Continued adding "--skeleton" switch.

Give up counting data when reached certain limit
('Skeleton::MAX_PATHS').

Continued adding "--skeleton" switch.

Code cleanup.

Continued adding "--skeleton" switch.

Keep all generated paths in memory (we are careful not to generate
too much of them, and we keep second part of data (positions) in
memory anyway).

Continued adding "--skeleton" switch.

Simplified traversal of outgoing arrows when extending prefixes.
Instead of adding outgoing arrow sets (which was erroneous anyway:
they should remain unmodified for another recursion entry), simply
wrap iterator and keep iterating until both ingoing and outgoing
arrows are counted.

Continued adding "--skeleton" switch.

Simplified construction of prefixes.

Continued adding "--skeleton" switch.

Renamed: 'Prefix' -> 'Path'.

Continued adding "--skeleton" switch.

More code cleanup: pre-initialize paths for final states and
default state, so that NULL can be used as a terminating condition
for path-generating function. Fixed memleaks.

Continued adding "--skeleton" switch.

Code cleanup.

Continued adding "--skeleton" switch.

Tried to simplify data generation a bit: construct skeleton states
so that there's no links to NULL state. Default state is
represented with a state that has no rule and zero outgoing
arrows. Final states are represented with a state that has a rule,
but zero outgoing labels.

Continued adding "--skeleton" switch.

Code cleanup.

Continued adding "--skeleton" switch.

Code cleanup.

Continued adding "--skeleton" switch.

Reduced the amount of generated data (no exponential growth now).
Generate enough paths to cover all DFA transition (well, not
exactly all: only upper and lower bounds of a range). Respect
cycles (loop once).

Code cleanup.

Continued adding "--skeleton" switch.

Use a separate DFA-like structure for DFA skeleton. This allows
to optimize skeleton states for fast traversal (group transitions
by destination state) and avoid messing with the original DFA.

Added 'count' method to estimate the the amount of data that will
be generated (it worked too slow for the origianl DFA with
ungrouped transitions).

Continued adding "--skeleton" switch.

Output input data to a separate file (otherwize we'll have to
keep all generated data in memory, cause output has a complex
structure and cannot be written to file until it's fully
generated)

This reduces memory usage significantly (so that there remain no
memory consumption problems with "--skeleton" switch). However
on some files re2c generated too much data, e.g. case-insensitive
strings:

/*!re2c
'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' {}
*/

Exponential growth is a bad thing; must deal with it somehow.
Time grows exponentially as well, of course.

Continued adding "--skeleton" switch.

Check for rule match in final states.

Continued adding "--skeleton" switch.

Generate check for input position in final states: first check
that input position equals to the expected one; second advance
input position to the beginning of next DFA path (this may be
necessary when the generated lexer rollbacks: it should resume
with a new DFA path rather than some default characters remaining
after rollback).

Continued adding "--skeleton" switch.

Fixed range lower bound tracking when generating input strings
from DFA.

Continued adding "--skeleton" switch.

When generating DFA paths respect range lower bound as well as
upper bound.

Continued adding "--skeleton" switch.

Output generated strings directly to file instead of storing them
in memory.

Continued adding "--skeleton" switch.

Track exact number of characters to be consumed on each input
string. Note that it's not equal to string length, since many
strings end up with characters from default transitions: on such
strings lexer must rollback to the latest backtracking point (that
is, the latest accepting state).

Continued adding "--skeleton" switch.

Moved input-string-generation-from-DFA algorithm earlier, to the
point when DFA is barely constructed and contains only 'Match'
states and starting state (no saving, accepting or split states).
This simplifies string generation: if destination state is NULL,
it is either next to final state (if all spans lead to it), or
default state (if some spans lead to other states).

Removed useless type of DFA state.

'Enter' was encapsulated by 'Initial' and never used on its own.

Continued adding "--skeleton" switch.

Fixed backtracking in deriving-input-data-from-DFA algorithm.

Determine action type in a simpler way.

Continued adding "--skeleton" switch.

Tried to sort out various DFA states and how they influence code
generation. Added explicit type field to all actions.

Removed useless NULL check (all NULL destination states handled in DFA::prepare).

Continued adding "--skeleton" switch.

A naive attempt to generate input strings from DFA. The problem is,
if the number of spans equals 1, it's hard to determine whether
it's some kind of a 'transit' state or a normal state with just one
span. All states have spans, but do they use them? The situation is
further complicated with 'readCh' which makes it hard to trace how
actions influence input operations.

Omit useless check for NULL: default transitions are handled in DFA::prepare

Some output should be generated with "--skeleton", but not with "-D"

Makefile.am: added "-O2" to CXXFLAGS

Prettified debug output.

Continued adding "--skeleton" switch.

Generate prolog and epilog in the form of a for-loop. The body
of the loop is the hard-coded DFA. The code in DFA final states
is substituted with "continue" statements.

Started adding "--skeleton" switch.

Testing script: trap SIGINT in child threads.

Now 'Ctrl+C' is handled as in single-threaded script: all threads
stop working.

A little code cleanup.

Don't output YYCTXMARKER stuff in .dot mode.

Added test that revealed error.

Run tests in parallel with "-j<threads>" option.

Comment

Added text file 'sf-cheatsheet' to make some notes about sourceforge administration.

Removed unused funtion.

Make 'Go' hierarchy independent of relabelling.

This allows to move 'Go' initialization loop to 'DFA::prepare'
and thus avoid ugly check if it is already initialized (it can
happen in '-r' mode when the same DFA is used multiple times).
Now that we store 'State *' pointers instead of labels in
'CpgotoTable', relabelling won't affect the generated code.

- Track used labels in a separate traversal of 'Go' graph
  (first part of effort to reduce codegen to null device)
- Properly destruct 'Go' graph (46 test failing with '--valgrind'
  because of early exiting on errors)

Abstracted common used constant in a class variable.

Separated 'Go' stuff: construction and output.

Reduced redundant parameter.

Split control flow codegen in two phases:

- First, re2c builds a complex structure where it stores
  all control flow codegen decisions: nested ifs or switches,
  bitmaps or computed gotos, etc.
- Second, this structure is traversed and code is generated.

This differentiation is necessary to compute some statistics
(e.g. used labels) in advance, before code generation.

Extracted duplicated code to a function.

Updated test results (changed due to the previous commit).

Removed YYDEBUG call before switch.

We don't call YYDEBUG in analogous situation (when if/else is used
insted of switch), and it seems redundant anyway.

Don't segfault if span has zero length.

Simplified codegen decision between switches/ifs.

All tests pass.
The previous condition made more sense: it was clear that the
author intended to consider some frequent corner cases.
But the condition was very tangled and yet too heuristic,
so I substituted it with a meaningless, but simple one.
I'm planning to simplify it even more later on.

Removed unreachable condition.

Number of high (wide) spans not necessarily depends on code unit size.

Moved bitmap statistics counting inside of 'Go' class.

Moved bitmap statistics to 'Go' class.

Moved methods out of class.

Reduced useless wrappers.

Pass limited span instead of checking range all the time.

Simplify handling of high/low spans.

Spans are already ordered, so to get high (wide) spans,
all we need is to find first span with upper bound >0x100
and point at it.

Moved wide span barrier to 0x100 rather than 0xFF.

0x100 corresponds to condition 'encoding.szCodeUnit () <= 1',
cause field 'ub' in 'Span' means upper bound of char interval.

Removed useless statistics counter.

Verified with 'assert (dSpans >= lTargets);'

Reclaced class member with a local variable.

Replaced class member with a local variable.

Eliminated redundant variable.

Removed unused variable.

Removed dead code.

Extracted common functionality in codegen -g and -b flags.

Removed obsolete condition (makes no sense in single-pass mode).

Simplified .dot codegen:

- draw a single arrow for all transitions between two given states
- label all arrows with corresponding character ranges in square
  brackests (no "default" label, single characters also appear in
  square brackets)
- .dot output became much smaller, thus pictures are drawn faster
  and generally look better: e.g. it takes ~10x less time to draw
  PHP lexer and the resulting graph is shaped better.

Simplified switch generetion in codegen.

Continued separating .dot case from other cases in codegen.

Continued separating .dot case from other cases in codegen.

Continued separating .dot case from other cases in codegen. Added test.

Continued separating .dot case from other cases in codegen.

Continued separating .dot case from other cases in codegen.

Started to separate .dot case from other cases in codegen.

Removed dead code.

Used 'if (next) assert(next->label == from->label + 1);'
to ensure that code is really dead (and 'next' is always
the next state to 'from').

Hided 'OutputFile' structure.

Code cleanup in input/output:

- Use 'open' function instead of checking return status
  (one may forget to check return status, but if one forgets to
  open file, the error will be obvious)
- Introduced separate file type for header.
  Header is much simpler than output, it doesn't need delayed
  code fragments and can be generated in destructor.

Finally get rid of 'file_info' and 'stream_lc.h'

Reduce 'file_info' usage (in order to get rid of 'stream_lc.h').

'token.h' no longer depends on 'file_info'.

Part of campaign to remove 'stream_lc.h'.

Now input stream is simple 'FILE *'.

This is first part of campaign to remove 'stream_lc.h'.

Dead code elimination.

Removed unused enum members.

I was unsure if delayed generation was also needed for genCondGoto
and genCondTable; so I kept those enum members as a reminder. Now
I know that all conditions are known by the moment re2c block is
parsed and code generation starts.

Moved operator definition to where it belongs.

One pass.

Second pass was used because some information (which influences
early parts of the generated code, e.g enum with condition names
or YYMAXFILL definition) becomes available only at the end of first
pass.

I isolate all (I hope so) these things and generate stubs for them,
which are filled later. I restructured output as follows: the whole
output consists of source and header, each of them is a list of
blocks (corresponding to re2c blocks in source file), each block
is a list of code fragments (which can be either regular strings
with code or stubs that will be filled later).

Updated version to 0.14.1.dev

Release 0.14.

Makefile.am: added bootstrap/re2c.1 to dist files.

Makefile.am: copy re2c.1 to bootstrap files