Output condition name with '-Wnaked-default' in '-c' mode.

Updated tests.

Line info changed in warning messages since commit
929c87fdf3a3de5f08206a258dfabbc0a068c561:
"Unified location output in warning messages.

Unified location output in warning messages.

Renames '-Wempty-rule' -> '-Wmatch-empty-string' and improved message.

Enable warnings globally for tests.

Fixed reference results for tests that trigger warnings.

Don't lose stdout and stderr when testing with -o.

Don't output generated code when failed with -Werror.

Added warinigs: -W, -Werror.

    -W: enable all warnings
    -Werror: turn all enabled (hereafter) warnings into errors

Specific warnings added by this commit:
    -Wempty-character-class
    -Wempty-rule
    -Wnaked-default

For each warning there are -Wno-, -Werror-, -Wno-error- options.

Fixed typos in release script, updated release guidelines.

Split release script into tw parts: distcheck and everything else.

Makefile.am: remved nonexistent file 'doc/index.html'.

Site front page 'doc/index.html' gone to branch 'gh-pages'.

Note that anther site page, manual.html, is autogenerated from
'doc/re2c.ad.in' which is also used to generate documentation.

Makefile.am: added forgotten header.

Fixed re2c behaviour with "--" command line option.

All arguments after "--" are treated as non-options. This can be
used to handle option-like filenames (those starting with "-" and "--").

Allow to specify exacly one input file and at most one output and header file.

Fixed GXX warning '-Wsuggest-attribute=format'.

g++ warns if function with '__attribute__((format (printf, ...)))'
has wrong number of arguments or argument type is wrong.

Use 'vfprintf' instead of 'fprintf' to print variadic arguments.

Added GCC warninigs -Wformat=2 (reveals this error) and
-Wsuggest-attribute=format.

Modified release script to try build with bmake as well as make.

Makefile.am: drop non-POSIX make feature: '$<' in target rules.

POSIX make allows '$<' only in inferencee rule.
Found while trying to build with bmake.

Makefile.am: respect various 'make' alternatives: use '$(MAKE)'.

Makefile.am: use inference rule '.re.cc' to avoid rule duplication.

Inference rules is a standard POSIX make feature.

New re2c-based parser for command line options.

Removed unused class variable.

Don't check range bounds in pretty-printing function.

Removed unused function.

Comment on test for character class operations.

Added test for operations on character classes (addition and subtraction).

Test is built into a separate binary. Both test building and running
is triggered by `make check`.

Operations on character classes: fixed subtraction, simplified addition.

Subtraction was broken by commit f56196d29f6c29b37e3e95a6777714c237e1c71c:
"Simplified implementation of range union and difference."

More tests for "--empty-class" option.

This time I found all tests that are affected by this option
(that is, contain empty ranges) and added explicit option variants
for most of them (excluding 'test/empty_range.*' group, as we already
have 'test/bug61_positive.*' group that checks the same thing).

Updated docs (added new options an long variants for all options).

Makefile.am: added forgotten header.

Added cmd option "--empty-class <match-empty|match-none|error>".

This option controls re2c actions when it encounters empty character
class (e.g. [], [^\0x00-\xFF] or [\0x00-\xFF]\[\0x00-\xFF]):
    match-empty (default) - match on empty input
    match-none - fail to match on any input
    error - compilation error

This is a final fix for bug #61 "empty character class [] matches empty string".

Partial fix for bug #61 "empty character class [] matches empty string".

Given the following code:
    /*!re2c
        [] {}
    */

    /*!re2c
        [^\x00-\xFF] {}
    */

    /*!re2c
        [\x00-\xFF]\[\x00-\xFF] {}
    */
re2c versions <=0.13.6 and >=0.13.7 behaved differently.
0.13.6 consistently considered that empty range should match empty string.
Since 0.13.7 empty positive range [] and empty difference (e.g. [a-z][a-z])
still match empty string, but empty negative range (e.g. [^\x00-\xFF])
matches nothing (always fails). The faulty commit is
28ee7c95bca46ad3cdb965741c5c29e21c50df14
"Added UTF-8 encoding support and tests for it."

This commit brings back consistent behaviour of 0.13.6: empty range,
however it was constructed, always matches empty string. Whether this
behaviour is sane or not is another question.

Construct non-NULL regexps from NULL ranges (for variable-length encodings).

NULL range represents empty range: range union and difference functions
return NULL for empty ranges. Thus NULL can be passed to functions
that construct regexp from range ('MatchOp', 'UTF8Range' and 'UTF16Range').
All these functions must behave return non-NULL for NULL ranges, since
further code relies on this.

Crash on attempt to create range with lower bound greater or equal to lower bound.

Better have an assert than nothing until we handle such cases properly.
As for now, if the user inputs range like [9-0], it will be tranformed
to [0-9]. Later re2c should at least warn about such cases.

Now range internals are only visible to union/difference functions.

Ranges must be constructed so that linked ranges don't overlap and
are monotonous. This is always true for one-link ranges created by
range constructor, and we construct larger ranges from them using
union and difference functions (that maintain the invariant).

Simplified implementation of range union and difference.

Explicitly shallow-copy ranges instead of using obscure copy constructor.

Restructured sources layout, improved formatting.

Unified macro names in header guards.

Inspired by sudden collision with '__COUNTER__' I occasionally got
while guarding 'src/util/counter.h'.

Now all headers use guards of the form '_RE2C_PATH_TO_HEADER_BASENAME_'.
Some compilers (e.g. clang++) would warn about [-Wreserved-id-macro],
but their reasonong about reserved macro names is quite crude and re2c
is not able to confirm their standards anyway (e.g. autoconf-generated
macro name 'SIZEOF___INT64').

Distinct restricted type for rule priority.

As with labels, try to control how rule priorities are created:
make a special counter that creates new priorities and disallow
everyone but this counter do it.

Simplified creation of rule states and backup states.

New simpler implementation uses STL containers instaed of sparse
array. It's less efficient, but the place is not a bottleneck and
simplicity is more important than efficiency.

A better data structure for mapping 'yyaccept' values to DFA rule states.

'yyaccept' values must be continuous natural numbers starting from 0,
so array indices represent them ideally.

Tried to improve code readability.

Now rule states and default state are added to DFA in separate
independent passes.

Removed 'bSaveOnHead' DFA property as it can be calculated right
before setting initial state action.

Track backup states only if DFA has default state.

Reduced redundant variable.

Variables 'accept' and 'accfixup' were assigned both only once and
in the same place and used to do the same thing.

Fixed bug #60 "redundant use of YYMARKER".

Bug description: sometimes re2c would generate code that backups
current input position (e.g. 'YYMARKER = YYCURSOR'), but wouldn't
generate code that restores backuped position (e.g. 'YYCURSOR =
YYMARKER').

Analyses: DFA may have overlapping rules (e.g. "a" and "aaa").
In such cases, if the shorter rule matched, lexer must attempt to
match the longer one. If the longer rule also mathed, then lexer
prefers it to the shorter rule. If the longer rule didn't match,
lexer must backtrack input position to the point when the shorter
rule matched. In order to be able to backtrack, re2c must generate
backup code (e.g. 'YYMARKER = YYCURSOR') and restore code (e.g.
'YYCURSOR = YYMARKER').
In some rare cases DFA has overlapping rules, but if the shorter rule
matched, then the longer rule will always match (perhaps on an
arbitrary long input string), e.g.:
    /*!re2c
        [^]+ "a" { 1st }
        "b"      { 2nd }
    */
In this cases there's no need to generate backup code for 2nd rule:
lexer will either encounter final "a" and the 1st rule will match
or YYFILL will not return; anyway, restore code will never be run.
re2c used to output backup code but not restore code in such cases.
This is the bug: backup code is useless without restore code and
should be omitted.

In future re2c should warn about such cases (when the shorter of
two overlapping rules is shadowed by the longer one).

The fix: postpone insertion of save actions (those with backup code)
untill it is known if restore code will be generated.
I also removed obsolete global variable 'bUsedYYMarker', which was
always set to 'true' (it should be per-DFA, not per-block configuration
anyway).

Fixed bug #59 "bogus 'yyaccept' in '-c' mode".

We have one 'yyaccept' initialization per re2c block. Each block
consists of one or more DFA (multiple DFA in '-c' mode in case of
multiple conditions). Each DFA may or may not use 'yyaccept'
(that is, save 'yyaccept' in some states and have a dispatch state
based on saved 'yyaccept' value).

Description of the bug: in '-c' mode, sometimes a DFA would have
states that save 'yyaccept', but no dispatch state that uses that
saved values. DFA didn't actually need 'yyaccept' (all the
assignments vanished if other conditions that need 'yyaccept' were
removed).

The essence of the bug: re2c decided whether to output 'yyaccept'
related stuff on a per-block basis: for multiple conditions in the
same block, the same decision was made (if any condition needed
'yyaccept', all of them would to output it).

The fix: 'yyaccept' initialization should be done on a per-block
basis, while assignments to 'yyaccept' should be done on a per-DFA
basis. Also, 'yyaccept' initialization must be delayed, while
assignments to 'yyaccept' must not.

Note: we may consider per-DFA 'yyaccept' initialization (have a
local 'yyaccept' variable per DFA). This wouldn't conflict with '-f'
switch (as it might seem) as long as we name all the variables
'yyaccept' and don't generate any 'yyaccept' initializations with '-f'.

Use autoconf to locate bison.

Respect user CXXFLAGS.

As automake manual (chapter 27.6 "Flag Variables Ordering") states,
CXXFLAGS is a user variable and should be left for users to override
C++ compiler flags. Thus we should leave CXXFLAGS as is and modify
AM_CXXFLAGS insted.

Added missing header (revealed by mingw build).

Check CXXFLAGS in configure.

Instead of unconditionally setting CXXFLAGS in Makefile.am,
check the presence of a flag in configure.ac. If the flag is
present (that is, an attempt to compile an empty C++ program with
this flag is successful), then it is added to CXXFLAGS.

Now one can add *any* compiler flag in configure.ac without
worrying about portability.

Support 'make distcheck'.

The only problem with 'make distcheck' was that we needed write
access to top source directory ('make' wanted to overwrite bootstrap
parser if it was built with bison and 'make check' wanted to create
temporary files in 'test/' directory).

This commit fixes it:
    - 'make' doesn't try to overwrite bootstrap if it is identical
      to the existing one (must always be true for 'make distcheck')
    - testing script makes a temporary directory and keeps all
      temporary files there. If some tests failed, temporary files
      for them are left and test sources and reference results are
      copied into temporary directory to make debug more convenient.

This commit makes use of 'make distcheck' in release script.

Fixed build system to support automake's 'subdir-objects' feature.

As I updated automake to version 1.15 it began to produce lots of
warnings about 'subdir-objects' not used when it should have been.
Turns out that 'subdir-objects' will be on by default in 2.0.

So I tried to turn on 'subdir-objects' and builds began to fail:
automake didn't expand '$(sourcedir)' and '$(builddir)' prefixes.
I erroneously prepended these prefixes in commit
38f526d04415adb7b5e6bca228fc26409833f5c3 "Updated build system.",
as commit message says:
...
    Makefile.am:
        - explicitly prefixed all file names with $(srcdir) or $(builddir)
...

But automake prepends these prefixes already where necessary, except
for custom rules with side effects: if a custom rule touches some
files that are not explicit targets or dependencies of this rule,
then automake won't find these files unless they are in build directory.
We have such side-effectful custom rules:
    - parser rule produces multiple files and touches bootstrap files
    - scanner rule touches bootstrap file
    - doc rules touch bootstrap files
Multiple files is a common problem of make. Bootstrap introduces
circular dependency, since bootstrap files need to be updated after
they've been used. So it's hard to get rid of side effects in these
rules.

This commit enabels 'subdir-objects' feature and removes all prefixes
in variables and adds them in side-effectful custom rules (for files
from source directory, not for files from build directory). It also
makes use of '$@' and '$<' special variables in custom rules (which
makes side effects more explicit).

Still I don't yet fully understand how automake uses things like
'$(sourcedir)' and '$(builddir)' and their relation with 'subdir-objects'
(it's probably related with non-recursive makefiles).

Enable silent builds by default.

Ignore one more autoconf-generated script.

Removed remnants of CVS ("# $Id$" in the beginning of some files)

Use autoreconf.

As stated by autoconf manual, autoreconf is more portable than
self-written scripts because aclocal may be removed in future.

Split header and appropriate source file into smaller parts.

Moved another utility class to a separate file in 'src/util/'.

Moved utility class to a separate file in 'src/util/'.

Don't output newline instead if label in initial DFA state.

Rationale: the equivalence of initial label to
're2c::label_counter_t::FIRST' is NOT a proper criterion
and pretty-printing shouldn't rely on it. The real criterion
is something like "(first re2c block OR any use block in '-r'
mode) AND first condition in'-c' mode", but it's spurious and
introduces unnecessary complications.

Droping this newline allows us drop equivalence operator for
labels.

Used the following bash script to ensure that all the changes
in tests are caused by missing newline(s):

    #!/bin/bash

    for f2 in *.temp
    do
        f1=${f2%.temp}

        diff1=`diff $f1 $f2 | grep '^< ' | wc -l`
        diff1_line=`diff $f1 $f2 | grep '^< #line' | wc -l`
        diff1_newline=`diff $f1 $f2 | grep '^< $' | wc -l`
        diff2=`diff $f1 $f2 | grep '^> ' | wc -l`
        diff2_line=`diff $f1 $f2 | grep '^> #line' | wc -l`

        # missing: only newlines and line directives
        if [[ $diff1 -ne $((diff1_line + diff1_newline)) ]]
        then
            echo "FAIL1: $f1"
            exit 1
        fi

        # added: only line directives
        if [[ $diff2 -ne $diff2_line ]]
        then
            echo "FAIL2: $f1"
            exit 1
        fi

        # the number of missing line directives
        # equals to the number of added line directives
        if [[ $diff1_line -ne $diff2_line ]]
        then
            echo "FAIL4: $f1"
            exit 1
        fi
    done

    echo "OK"

Introduced a distinct type for labels.

Moved label assignment out of global scope to 're2c::OutputFile'.

Now label assignment is done with the help of a simple class
're2c::Label' that has very few operations.

Some renaming and comment updating.

Added some more on 're2c:startlabel = <integer>;' configuration.

Clarified which label is used.

Label of the first state must be used rather than some obscure label
relative to start label (which is itself quite obscure).

Isolated label counting.

Separated code generation for DFA actions and DFA states.

Removes debugging utilities for DFA states (we should either add
debug builds explicitely or throw away temporary debug stuff).

Gather all label counting in one place prior to code generation.

Moved start label configuration out of global scope.

There are two configurations:
1. re2c:startlabel = <integer>;
2. re2c:startlabel = <string>;
The scope of these configurations is the scope of current re2c block.

Output user-defines start label in the appropriate place.

Before this commit, given the following example:
    /*!re2c
            re2c:startlabel = "start";
            [^]* {}
    */
re2c would generate the following code:
    {
            YYCTYPE yych;
            goto yy0;
    yy1:
    start:
            ++YYCURSOR;
    yy0:
            if (YYLIMIT <= YYCURSOR) YYFILL(1);
            yych = *YYCURSOR;
            goto yy1;
            {}
    }
where "start:" falsely corresponds to "yy1:" rather to "yy0:".
(The important property of this example is that DFA has arrows
to initial state.) This commit fixes this behavior:
    {
            YYCTYPE yych;
    start:
            goto yy0;
    yy1:
            ++YYCURSOR;
    yy0:
            if (YYLIMIT <= YYCURSOR) YYFILL(1);
            yych = *YYCURSOR;
            goto yy1;
            {}
    }

Don't hide the ugly fact that default state in '-f' mode is always state 0.

In '-f' mode, state dispatch generation can be triggered in two ways.
Both ways use 're2c::OutputFile::insert_state_goto', which generates
state dispatch only if it hasn't been already generated. The two ways
are:
1. Explicitly, using '/*!getstate:re2c*/'. In this case default state
   must be state 0 because it's hardcoded in the invocation of
   're2c::OutputFile::insert_state_goto' in 'src/parse/scanner_lex.re'.
2. Implicitly, in 're2c::DFA::emit'. In this case default state must
   be state 0 because if 'prolog_label' is not 0, it means that it's
   not the first time 're2c::DFA::emit' is called and state dispatch
   has already been generated.

This commit makes it explicit that re2c always uses state 0.

Note:
    Currently in '-f' mode re2c generates one global dispatch for
    the whole file (the enumeration of yyFillLabel's is also global).
    All re2c blocks share the same state dispatch, so in '-f' mode all
    re2c blocks must reside in the same function and must be parts of
    the same lexer (exception: in '-r' mode re2c generates one state
    dispatch per use block).

    This is clearly an ugly limitation: one is forced put disconnected
    lexers in different files in '-f' mode.

    Now re2c provides conditions as a way to express related blocks,
    so if users used multiple blocks only for unrelated lexers, we
    could safely limit the scope of state dispatch to a single block.
    But conditions can conflict with other re2c features, they are
    a bit broken and I'm pretty sure some users use multiple blocks
    (e.g. I used to do it).

    Thus we cannot just make '-f' generate state dispatch on per-block
    basis (there're some other obstacles: it's not quite clear which
    block '/*!getstate:re2c*/ directive is related to, etc.).

    I leave the situation 'as is' until better times (when lexer-
    parser loop is fixed and the whole code generation model is more
    robust).

Clarify which label is relevant to initial state.

(see commit 4ab969deca341820d03ffb979f023256b10c2f92)

Compare DFA states rather than labels.

(see commit 923f4c5559b1f8b43e63d1013d91698e7496e28c)

Clarify which label is relevant to initial state.

Initial state is different from all other states in that should
not advance YYCURSOR when it's entered first time (when DFA is
entered). But it should advance YYCURSOR like any normal state if
it's entered from any other part of DFA (other DFA states may well
lead to the inital state, e.g. '[^]*')

That's why inital state is split into two parts, each marked by a
separate label: normal state label points to the code that advances
YYCURSOR, and special label points right after that code (skips it).

It happens so that normal state label is equal to special initial
label plus one, but we shouldn't rely on that.

Clarify that initial state stores 'start_label', not some random label.

Compare DFA states rather than labels.

This is first step to postpone labelling states until all the
code is actually generated (in the form of some structure in
memory) and it's time to pretty-print it to file.

Labels shouldn't be mixed up with states (in particular, they
shouldn't be used as a state identifier).

Regenerated documentation (changed by previous commit).

Finally removed auxiliary code generation pass to 'null device'.

This pass was used to gather statistics:
    - which labels are used (to avoid 'unused label' warnings from
      C/C++ compiler)
    - in '-f' mode, how many times YYFILL is called (to generate
      dispatch to the arrpopriate YYFILL call and resume lexing from
      there)

This commit deals with second case: it makes counting YYFILL calls
independent of auxiliary pass. Counting relies on variable
're2c::last_fill_index', which is updated in 're2c::need' function
(note that it is crucial that 're2c::need' is always called prior
to generation of state dispatch).

Also fixed documentation for '-f'.

Pass only that part of output needed by 're2c::State::emit'.

Fixed clang's "warning: declaration shadows a local variable [-Wshadow]"

're2c::emit_init' doesn't generate anything useful in .dot mode.

Another part of tracking label usage moved out from codegen.

This is part of effort to reduce code generation to 'null device'
(the same code is generated twice only to gather statistics on
label usage). In order to reduce this evil pass, we should be able
to track label usage before code generation.

Simplified 're2c::Action' class and its usage.

Replaced inheritance hierarchy with tagged union.

Fixed clang's "warning: declaration shadows a local variable [-Wshadow]"

Don't copy <*> regexps for each condition.

There're two major things to care about in this situation:
1. <*> rules must have the lowest priority: in order to guarantee
   it, we re-iterate <*> regexps after all other rules have been
   parsed and fix <*> regexps priority.
2. <*> regexps must be compiled to instrictions separately for each
   condition: this is guaranteed by assigning them
   're2c::RegExp::PRIVATE' attribute.

Note that 're2c::RuleOp::accept' member stores rule priority.
These priorities don't have to be consecutive, only the right order
must be maintained. Later on in 're2c::DFA::prepare' they result in
consecutive 'yyaccept' values.

Forbid copying of 're2c::Substr'.

Removed useless methods (most of them became useless after
're2c::Str' removal) and obsolete autoconf check for 'strndup'.

Removed 'Scanner::token' methods. They used
'Scanner::check_token_length', which was pretty useless:
1. checking for the lower should have always succeed, because
   'Scanner::tok' is always set to buffer start in 'Scanner::fill'
   and if the token was too long, it's start will be lost anyway.
2. checking for the upper bound could fail if re2c dev passed some
   trash into it, but any normal function would do so and this is
   no particular reason to have special runtime checks here.
Now substrings are constructed in lexer, where all the lengths
and bounds are easier to verify from lexing context (for re2c dev).

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.