Moved 're2c::BitMap' methods to a separate source file.

Removed some useless includes from 'src/codegen/code.cc'.

Moved lexing functions to proper file.

For some reason 're2c::Scanner' methods were defined in file
'src/codegen/code.cc'. Mpved them to 'src/parser/scanner.cc'
and renamed 'src/parser/scanner.re' to 'src/parser/scanner_lex.re'.

Removed useless include.

Reduced "src/codegen/print.h" dependency for some unrelated files.

This is the first part of effort to reduce the total number of
interdependencies between different files.

"src/codegen/print.h" contains some pretty-printing functions
mostly used for code generation. There two other cases where.
these functions can also be useful:
    1. debug: it's not yet well developed, just some messy chunks
       of code that are commented out
    2. error messages: character pretty-printing is not actually
       very useful, since error messages mostly contain printable
       characters (pieces of user-supplied input)
From the above I conclude that non-codegen files don't really need
"src/codegen/print.h". If this will change, I'll consider moving
this functions to src/util.

Improved source files layout.

Created a directory tree to group logically related source files
and clean up top source directory.

Added mingw builds for windows.

To enable mingw build, confugure with "--host i686-w64-mingw32".
Simple 'make' will then build re2c.exe executable for windows.
Note that 'make bootstrap' will not work: it will try to run
re2c.exe in order to recompile scanner and this will surely fail.

Testing with wine can be done using 'make wtests'.

Don't recompile scanner by default.

Since it will cause insignifacant changes in bootstrap files
which we'll have to commit every time.

Don't rebuild docs by default.

If we configure with "--enable-docs", then docs get rebuild every
time make is executed, and we'll have to commit these insignificant
changes every time, which is bad.

Updated build system.

Major changes:
- Moved all re2c source files to a separate directory. Top source
  directory should only contain autotools source files and a few other
  files like README.

- Enabled out-of-source builds (and wrote a simple script build.sh
  that makes out-of-source build).

- Improved portable variant of <stdint.h> header (src/c99_stdint.h):
  now it relies only on some few defines in configure-generated
  src/config.h (instead of checking for MSVC version and relying
  on MSVC-defined stuff). Implementation follows C99 standard closely.

- Removed all windows-related build stuff. It was no use keeping it:
  it's been broken for a long time and I can't maintain it.

- Removed all RPM stuff: distro-maintainers use their own hacks anyway.
  Makefile.am is definetely the wrong place to keep such things.
  A separete script and .spec file is a better idea, but again, nobody
  uses it.

- added make target 'bootstrap' to make mainteiners' job easier.

- Merged lessons and examples into one.

- Updated README and doc/index.html.

- Run tests in parallel by default.

Changes concerning particular files:
- configure.ac:
    - removed autoconf version check: developers will need the right
      version anyway (otherwize autoconf will reject to work);
      users should use configure script provided by package
      distribution

    - removed GCC version (3 or above) check: it's pretty ancient
      and I don't know which features are missing anyway

    - removed some useless checks (which resulted in defines in
      src/config,h used by no one)

    - introduced some new checks (used by src/c99_stdint.h)

    - followed the advices of autoupdate

Makefile.am:
    - explicitly prefixed all file names with $(srcdir) or $(builddir)

    - removed windows and RPM related rules and targets

    - added target 'bootstrap'

    - sorted out automake variables

Continued adding "--skeleton" switch.

Some renaming and cleanup.

Continued adding "--skeleton" switch.

Simplified 'generate_paths_cover' a bit: NULL-state case is not
really needed, it's artificial and should be embedded into the
only case that needs it.

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.