Removed obsolete 're2c::Str' stuff.

Pass unquoted strings to parsing functions.

In most cases re2c accepts single-quoted or double-quoted strings
in regexp specifications, but if flex-like syntax if enabled, then
re2c accepts unquoted strings.

Before this commit, functions that parse strings into regexps
expected quoted strings, and we had to add quotes in case of
flex-like syntax. That was very inconvenient and in fact
unnecessary, since the first thing parsing functions do is get rid
of quotes.

Now 're2c::Token' uses 'std::string' instead of 're2c::Str'.

Simplified handling of named definitions in parser.

Don't bother with named definitions in lexer, just pass them as
strings to parser. Parser will recognize named definitions, insert
them into symbol table and handle conflicts.

Use simple 'std::map' instead 're2c::Symbol' class (that hides
symbol table in class static member).

Use 'std::string' instead of 're2c::Str'. Due to bison limitations
we have to pass pointers to strings allocated on the heap and
carefully destroy them. The whole thing is quite error prone, so
maybe I'll make a small slab allocator for parser later on.

Fixed mismatched new/delelte (found by valgrind).

What is allocated with 're2c::allocate<T>' (operator new), should
be freed with 'operator delete', not with 'delete' or 'delete []'.

Moved 're2c::Symbol' class to a separate header and source file.

Replaced 're2c::Str' with 'std::string'.

There's no point in using self-invented strings if one always
converts them to 'std::string' before actually using them.

CXXFLAGS: removed -DPEDANTIC, added -Weffc++. Fixed warnings.

Split 'src/dfa/dfa.h' into parts: DFA states, DFA actions, DFA.

Moved functions declarations and typedefs to a proper place.

Merged 'src/codegen/translate.cc' into 'src/codegen/print.cc'.

Split 'src/codegen/code.cc' into parts.

First, DFA is built ('re2c::DFA::DFA'), then it must be prepared
for code generation: some states must be split, backtracking points
must be marked, etc. ('re2c::DFA::prepare'), then finally code
can be generated ('re2c::DFA::genCode').

I haven't yet fully decided whether second stage (preparing) is
closer to DFA construction in general (and thus should be moved to
'src/dfa') or to code generation (and should be moved to 'src/codegen').
Since it deals a lot with bitmaps, second variant will suffice for
now. Perhaps later on I'll split preparation into general and
codegen-related parts.

Renamed struct to avoid confusion.

're2c::BitMap' represents actual bitmaps used for code generation,
while 're2c::GoBitmap' (former 're2c::Bitmap') is a node type in
graph representation of the program right before code generation.

Names used in 're2c::Go' subsystem are really ugly and will be
renamed to something more sensible later on.

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.