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

Makefile.am: added forgotten header.

Makefile.am: removed obsolete MSVC files and added forgotten header.

Updated CHANGELOG and index.html

Updated docs.

Added tests from PHP repository: https://github.com/php/php-src

Test results are almost identical to re2c-0.13.6
(there're some few changes, I believe they are due to
commit 255262b02928d3f38c00dd91952e3253c11c78f1 and
completely harmless).

Renamed YYEOI -> YYLESSTHAN

Revert "Renamed re2c primitives:"

This reverts commit 7f816a85b03dd26f279868b1d0eaddb50bc8eb4c.

Renamed re2c primitives:

    YYPEEK       ---> RE2C_PEEK
    YYSKIP       ---> RE2C_SKIP
    YYBACKUP     ---> RE2C_BACKUP
    YYBACKUPCTX  ---> RE2C_BACKUP_CTX
    YYRESTORE    ---> RE2C_RESTORE
    YYRESTORECTX ---> RE2C_RESTORE_CTX
    YYEOI        ---> RE2C_LESS_THAN

Updated tests and examples accordingly.

Renamed functions:

    expr_eoi        ---> expr_less_than
    expr_eoi_one    ---> expr_less_than_one
    stmt_backupctx  ---> stmt_backup_ctx
    stmt_restorectx ---> stmt_restore_ctx

Fixed changelog formatting on re2c.org.

Added some examples of "--input custom" usage.

Had to modify .gitignore to unmask README in subfolders.

Replaced "YYHAS (n)" with "YYEOI (n)".

The actual meaning of this primitive is to check if
there's not enough characters left in the input stream,
e.g. "(YYLIMIT - YYCURSOR) < n" or whatever else.

Added tests for "--input custom".

This implied modifying runtests.sh, as it couldn't handle
test names of the form "basename.--long-switch.re":
it inserted '-' in front of all switches.

Removed "--input istream".

It's impossible to correctly implement this switch in general,
since not all istreams support seek (simplest counterexample:
std::cin).

Even for simple istreams like std::istringstream, proper
error handling requires adding something like "YYERROR ()".

A little cleanup of new input API:

- moved enum and pretty-printing functions to a class
- renamed files 'input.{h,cc}' to 'input_api.{h,cc}'
- for "--input istream": moved input position increment to 'stmt_restorectx'
- main.cc: removed useless include

New input API.

- command-line switch "--input <default | istream | custom>"
- with "--input default" (the default) no changes to generated code
- with "--input istream" assume YYCURSOR is std::istream object
    and YYLIMIT is length of input stream
- with "--input custom" expose primitives:
    YYPEEK ()
    YYSKIP ()
    YYBACKUP ()
    YYBACKUPCTX ()
    YYRESTORE ()
    YYRESTORECTX ()
    YYHAS (n)

Added test for bug #46.