Compare commits

..
160 Commits
Author SHA1 Message Date
Ulya Trofimovich 349a97c831 CMake: create output directory before building docs.
Previously trying to run rst2man.py with an output file in a nonexistent
directory resulted in the following build error:

  $ cmake --preset=linux-gcc-debug-ootree-skeleton-full
  $ cmake --build --preset=linux-gcc-debug-ootree-skeleton-full
  ...
  [  1%] Generating src/msg/help.cc
  Unable to open destination file for writing:
    OutputError: [Errno 2] No such file or directory:
      '[...]/linux-gcc-debug-ootree-skeleton-full/src/msg/help.cc.1'
2021-11-28 16:38:51 +00:00
Ulya Trofimovich e07052b566 CMakePresets.json: inherit "full" configuration before "fast".
Otherwise variable definitions from "fast" configuration take precedence
over the "full" configuration, resulting in disabling some important
configrations, such as Go language support.

For example, if "fast" is inherited before "full" we have the following
incorrect configrations that sets RE2C_BUILD_RE2GO:BOOL="FALSE":

  $ cmake -S .. --preset=linux-gcc-release-ootree-skeleton-full
  Preset CMake variables:

    CMAKE_BUILD_TYPE="Release"
    CMAKE_CXX_COMPILER="g++"
    CMAKE_C_COMPILER="gcc"
    CMAKE_INSTALL_PREFIX:PATH="[CUT]/re2c/install"
    RE2C_BUILD_LIBS:BOOL="TRUE"
    RE2C_BUILD_RE2GO:BOOL="FALSE"
    RE2C_FOR_BUILD="[CUT]/re2c/install/bin/re2c"
    RE2C_REBUILD_DOCS:BOOL="TRUE"
    RE2C_REBUILD_LEXERS:BOOL="TRUE"

But if "full" is inherited after "fast" we have the following (correct):

  $ cmake -S .. --preset=linux-gcc-release-ootree-skeleton-full
  Preset CMake variables:

    CMAKE_BUILD_TYPE="Release"
    CMAKE_CXX_COMPILER="g++"
    CMAKE_C_COMPILER="gcc"
    CMAKE_INSTALL_PREFIX:PATH="[CUT]/re2c/install-2"
    RE2C_BUILD_LIBS:BOOL="TRUE"
    RE2C_BUILD_RE2GO:BOOL="TRUE"
    RE2C_FOR_BUILD="[CUT]/re2c/install/bin/re2c"
    RE2C_REBUILD_DOCS:BOOL="TRUE"
    RE2C_REBUILD_LEXERS:BOOL="TRUE"
2021-11-28 16:38:51 +00:00
Ulya Trofimovich 8a4772cee8 Make --loop-switch work with conditions.
Merge all conditions in one loop/switch where DFA for each condition has
its own set of cases. Use `yystate` variable to switch between
conditions in the same way as between DFA states.

The => rules set user-defined condition variable with YYSETCONDITION.
The :=> rules set `yystate` and continue to the head of the loop/switch.
2021-11-27 00:05:53 +00:00
Ulya Trofimovich b031e27437 Respect define:YYGETSTATE:naked configuration in loop/switch mode. 2021-11-26 23:15:51 +00:00
Ulya Trofimovich c643db456c For skeleton and .dot targets merge header file into the output file.
Header file may contain blocks with regular expressions and rules. They
should be handled as well as the blocks in the output file.

This patch fixed a failing skeleton test.
2021-11-22 23:53:15 +00:00
Ulya Trofimovich dcbbd01055 Use initial state indices as condition numbers with --loop-switch.
Normally with the goto/label approach condition enumeration uses
implicit consecutive indices starting from zero. With the loop/switch
approach it is more convenient to represent conditions with their
initial DFA state index. This allows one to assign condition numbers to
the state variable `yystate` and get rid of the entry condition switch.
2021-11-21 21:41:26 +00:00
Ulya Trofimovich d2cf8a37e9 Factor out block list construction into a separate function. 2021-11-21 20:42:02 +00:00
Ulya Trofimovich c5179da5f8 Delay YYMAXFILL / YYMAXNMATCH computation until handling the directive.
The `maxfill:re2c` and `maxnmatch:re2c` directives may specify an
optional list of block names. If the list is specified, the directives
compute maximum value over the specified blocks, otherwise they compute
global maximum across all blocks in the program.

Previously the global maximum was prepared in advance even if the
directives were not used. This patch delays the computation of global
YYMAXFILL / YYMAXNMATCH until they are needed, as is already done in
the case when the directive specifies a list of blocks.
2021-11-21 17:57:20 +00:00
Ulya Trofimovich 4edb6ca2d9 Delay global tag list construction until handling the directive.
The `stags:re2c` and `mtags:re2c` directives may specify an optional
list of block names. If the list is specified, the directives gather
condition nems from the specified blocks, otherwise they use a global
set of tag names gathered across all blocks.

Previously the global set was prepared in advance even if the directives
were not used, but a set for specific block list was constructed only if
needed. This patch delays global set construction until it is needed and
unifies it with the case of a specific block list.
2021-11-21 10:36:35 +00:00
Ulya Trofimovich 8b93728f93 Do not autogenerate condition enum if there is an explicit types:re2c.
The rationale is, if the user specified an explicit `types:re2c`
directive, they probably do not want the autogenerated enum as well. If
for some reason they need multiple enum definitions (either in the
output file or in the header file), they can use multiple `types:re2c`
directives.
2021-11-21 10:04:13 +00:00
Ulya Trofimovich e551a4918b Search for named blocks both in the output file and in header.
This fixes a test for condition enum: previously re2c emitted an error
because one of the `types:re2c` directives listed block name for a block
defined in another file, and re2c failed to find it. Now it finds it.
2021-11-21 09:44:50 +00:00
Ulya Trofimovich 51f769133b Do not generate empty condition enum.
Some compilers or language standards allow it, but generally it's more
likely to indicate an error in user code.

Fix a few tests that generated empty condition enum by mistake.
2021-11-21 09:41:31 +00:00
Ulya Trofimovich df50c25fc3 Clean up old tests for condition enum and header.
Replace a bunch of simple and similar tests with a few more
comprehensive ones that cover recent re2c features like named blocks and
block lists in the `types:re2c` directive, in addition to older features
such as the --type-header option.

One of the new tests reveals an error in re2c: it fails to find
conditions in header. The error will be fixed in a follow-up commit.
2021-11-21 09:41:31 +00:00
Sergei Trofimovich ac672c9ce4 avoid using reserved identifiers (underscores)
clang with -Weverything detects these as:

    ./src/util/free_list.h:9:16:
      warning: identifier '_Ty' is reserved
      because it starts with '_' followed by a capital letter [-Wreserved-identifier]
    template<class _Ty>
                   ^
2021-11-17 22:52:30 +00:00
Sergei Trofimovich 59edd763bf fix struct/class declaration mismatch (-Wmismatched-tags)
Detected by clang's-Weverything:

    ./src/regexp/re.h:17:1: warning: struct 'Msg' was previously declared as a class;
      this is valid, but may result in linker errors under the Microsoft C++ ABI [-Wmismatched-tags]
    struct Msg;
    ^
2021-11-17 22:52:02 +00:00
Ulya Trofimovich 66c6b1cd96 Make --loop-switch work with storable state.
With the loop/switch approach there is no `goto` statement, so it is
impossible to jump from a `getstate:re2c` block to an YYFILL label,
bypassing all the user-defined code in the middle (as it normally
happens with the goto/label approach).

Therefore `getstate:re2c` is forbidden with --loop-switch, and the
initial switch on storable state is merged into the `yystate` switch:

  - case -1 falls through to case 0 (the initial state)

  - transitions to YYFILL states are moved to cases that occupy
    contiguous numbers after the last regular DFA state

In order to make it possible to wrap the generated lexer in a
user-defined loop, an `YYSETSTATE(1)` statement is emitted in each final
state before the user-defined semantic action: if the action jumps to
the head of the outer loop, the next iteration will start from state -1,
as the user might expect. Note that `YYSETSTATE(1)` is not needed with
goto/label approach, because one can jump directly to the start label.
2021-11-17 21:26:48 +00:00
Ulya Trofimovich e42b3db26a Make --loop-switch and --eager-skip options non-configurable.
Having configuration for the --loop-switch option is only useful if one
needs to enable loop/switch approach on a per-block basis. Mixing the
two approaches (goto/label and loop/switch) would mean that some of the
blocks have start labels and can use cross-block transitions, while
others cannot. This would create confusion for whole-program directives
like `getstate:re2c` that cover multiple blocks.

With the loop/switch approach `getstate:re2c` should be forbidden, as it
requires a cross-block transition from the state switch to the lexer
entry, which is unsupported in the absence of the `goto` statement.
2021-11-16 07:32:01 +00:00
Ulya Trofimovich 1def5f1874 With --loop-switch, start state enumeration from zero in each block.
Normally with the goto/label approach re2c uses a program-wide state
enumeration that starts from zero and increases with each block. Since
each state has a label, global enumeration allows one to have multiple
blocks in the same function without the risk of label collision.
Moreover, different blocks can be connected with cross-block `goto`
transitions, so all state labels should have different numbers.

The situation is different with the loop/switch approach: there are no
labels and no cross-block `goto` transtions; instead every state has a
switch on the `yystate` variable. Since different block have different
switches, it makes sense to start state enumeration from zero in each
block (so that switch cases start from zero, and the zeroth case
corresponds to the start state of every block).
2021-11-14 18:54:37 +00:00
Ulya Trofimovich 29d6adcee1 Drop useless -c option in some of the Go examples.
These examples do not use conditions, so -c does nothing. It has been
accidentally copy-pasted from another example that uses conditions.
2021-11-09 23:08:44 +00:00
Ulya Trofimovich 81feecfbfe Add tests for the new --loop-switch option (for C and Go backends).
The added tests are copy-pasted from examples, but the generated code is
different: it uses loop/switch constructs instead of goto/label. All
tests except for conditions and storable state are valid programs that
can be compiled and run without errors.
2021-11-09 23:02:21 +00:00
Raekye a03b3b4d54 Initial implementation of the --loop-switch option.
With this option, instead of the usual goto/label approach DFA is
wrapped in a loop with a `switch` statement on `yystate` variable. Each
DFA state is an individual `case`. Transitions between states are done
by setting the `yystate` variable to the numeric index of the target
state and executing `continue` that jumps to the head of the loop and
goes via the `switch` again. This is less efficient than direct jumps
with the goto/label approach, but it is the only way we can implement a
DFA for languages that do not have `goto` statement (such as Rust).

YYFILL labels are problematic for the loop/switch approach, because they
are normally in the middle of a DFA state (after the YYSKIP operation,
but before YYPEEK and transitions to other states). To fix this, we use
the --eager-skip option that moves YYSKIP operations from DFA states to
transitions.

The initial value of `yystate` is the numeric index (label) of the first
DFA state. It is _not_ the intiial label, because initial label does not
have a state (so there is no `case` in the `switch` for it), and it is
only needed to bypass YYSKIP operation in the first DFA state (which is
not there anyway because of the --eager-skip option).

Current limitations:
  - Conditions are not supported. We need a per-condition `yystate`, and
    ideally transitions between conditions should also use a loop/switch
    approach instead of goto/label (it will be required for Rust, but it
    is optional for C and Go).

  - Storable state is not supported. We need to rewrite user-defined
    code to use the same state variable as `yystate` and the one in
    `YYGETSTATE`/`YYSETSTATE`, as well as to put `getstate` block
    immediately before DFA entry (if there is any code between state
    dispatch and DFA entry, it needs to be bypassed when re-entering
    the lexer after YYFILL, which is easily done with goto/label
    approach in C and Go, but not in Rust that has no `goto`).

Test results with the --loop-switch option enabled by default:
  - Skeleton tests pass (320 soft errors).

  - Examples for C and Go compile and run without errors, except for
    conditions, storable state and cases when user-defined code needs to
    be rewritten (e.g. when it uses an outer loop and `continue`/`break`
    statements end up referring to the wrong loop).
2021-11-09 21:54:48 +00:00
Raekye 10f84e73ed Don't generate initial label if --eager-skip option is used.
The initial label is not needed in such cases as there is no need to
bypass YYSKIP statement (--eager-skip moves it from states to
transitions).
2021-11-09 21:54:48 +00:00
Raekye bddcb93fa9 Add stubs for --loop-switch option and related configurations.
The following has been added:
  - option --loop-switch
  - configuration `re2c:flags:loop-switch`
  - configuration `re2c:variable:yystate`

Currently they are no-ops.
2021-11-09 21:54:48 +00:00
Raekye 1c8451883f Move --eager-skip option from constant to mutable.
This is necessary to support the future --loop-switch option.

With --loop-switch we cannot have labels (goto targets) in the middle of
a state. This affects YYFILL labels which normally go after YYSKIP but
before YYPEEK. The --eager-skip option resolves the problem by moving
YYSKIP statements from states to transitions. The plan is to enforce it
automatically if --loop-switch is enabled, but since --loop-switch will
be a mutable option, --eager-skip also needs to be mutable.
2021-11-09 21:54:48 +00:00
Raekye e3e76b0fe4 Skeleton: use goto-loop instead of for-loop.
To support the future --loop-switch option, this change avoids
unexpected control flow with `continue`.

The skeleton tests are verified and updated.
2021-11-09 21:54:48 +00:00
Ulya Trofimovich 68e1ab7160 Correctly compute fixed tags in trailing context.
Tags in trailing context may be fixed on the rightmost cursor position.
Their values must be updated before cursor is reset to the position of
the trailing context, otherwise the values would be incorrect.
Previously this was not so, which resulted in incorrect tag values.

This fixes bug #380 "Tags incorrectly set with lookahead" reported by
Terry Sanders .
2021-11-04 23:51:01 +00:00
Ryan Mast 8920ef895b Setup Java for the benchmarks workflow using actions/setup-java 2021-11-02 07:25:00 +00:00
Perry E. Metzger 73dc6295a7 minor fixes to interface.rst_
Improve grammar, make some small style improvements, and keep the
lines consistently under 80 columns. Also update boostrap docs for
resulting changes.
2021-10-31 20:30:35 +00:00
Ulya Trofimovich 6d7c3cbb47 Small fixes in distcheck script.
Changes:
  - use 'sh' instead of 'bash' as interpreter
  - split build into stages 1 and 2 and rebuild lexers at stage 2
  - double-quote shell variables to make shellcheck happy
2021-10-24 13:10:47 +01:00
Ulya Trofimovich 072d49e59c Autotools: link google-benchmark binaries with pthread. 2021-10-22 16:52:36 +01:00
Ulya Trofimovich eb8720d5ea Use unsigned integers for register versions in TDFA states.
Previously we used negative numbers for register versions that were
allocated for transitions on negative tags. This is pointless, because
state mapping may biject positive versions to negative ones or vice
versa, erasing the distinction. And it wasn't used anyway.
2021-09-15 22:42:55 +01:00
Ulya Trofimovich b90b78c79c Mark each register as not interfering with itself.
Exclude diagonal pairs from interference table. This does not affect
subsequent register allocation, because the algorithm that partitions
registers into non-interfering classes does not check is a register
interferes with itself. So the fix does not affect the generated code,
except for one test that draws the interference table.
2021-09-04 09:41:08 +01:00
Ulya Trofimovich 6b434e934c run_tests.py: make tests fast again by fixing Wine check.
Commit ec1dc2b3ec incorrectly compared
Wine path against `None` to determine if the tests run under Wine. That
doesn't work as expected because the default value is empty string, not
`None`, so the checks always succeeded and as a result the script did
unnecessary work (patched newlines in the generated output). That made
it a few times slower.
2021-09-04 09:16:04 +01:00
Biswapriyo Nath 15376f4393 Define _POSIX_SOURCE for fdopen in cygwin
This fixes the error:
error: ‘fdopen’ was not declared in this scope; did you mean ‘fopen’?
2021-09-03 16:35:42 +01:00
Serghei Iakovlev dff1b6cd36 Provide support of CMake Presets
Since 3.19.8 CMake looks in the top source directory of a project for files
named CMakePresets.json and CMakeUserPresets.json. Neither file is required
to be present, but if the user tries to list or use presets, at least one of
the files must exist. If both files are present, they will effectively be
merged by reading the CMakePresets.json file first and then the
CMakeUserPresets.json file.

CMakePresets.json can be used to define presets for things like continuous
integration jobs or cross-compilation setups using toolchains provided as
part of the project. In general this feature allows us to simplify CI
configuration phase by taking out all the logic into presets-file and helps
us to make reproducible builds. From now on, you no longer need to carefully
read and copy all the flags locally in order to reproduce CI configuration or
build. Simple use the same one line command as at CI.

As a bonus, users of modern CMake can use a cross-platform and portable way
instead of build/__cmake*.sh scripts.

To see the list of available presets use:
    cmake --list-presets

To configure re2c use:
    cmake --preset=<NAME>

To build re2c use:
    cmake --build --preset=<NAME>

To test re2c use:
    cmake --build --preset=<NAME> --target tests

References:

- https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html
- https://gitlab.kitware.com/cmake/cmake/-/issues/21164
- https://cmake.org/cmake/help/latest/guide/user-interaction/index.html#presets
2021-08-12 12:30:44 +01:00
Ulya Trofimovich aa2da70299 Release 2.2. 2021-08-01 10:05:50 +01:00
Ulya Trofimovich cf13205c63 Update CHANGELOG. 2021-08-01 08:34:40 +01:00
Ulya Trofimovich ec1dc2b3ec run_tests.py: patch newlines under Wine and get rid of Wine warnings. 2021-07-31 20:42:52 +01:00
Ulya Trofimovich a9ba2c4d91 Add forgotten includes to make headers self-contained. 2021-07-31 20:42:52 +01:00
Ulya Trofimovich 36e4a0e5ee run_tests.py: use a local reimplementation of shutil.copytree.
We need to copy multiple directories (test/ and examples/) into one
(temporary test directory). `shutil.copytree` is problematic for two
reasons:

 1) it requires `dirs_exist_ok` parameter which was added only in
    python-3.8

 2) `make distcheck` fails when trying to copy the second directory
    because it makes source files read-only
2021-07-31 09:10:28 +01:00
Ulya Trofimovich a779585cb3 split_man.sh: allow substitution RE2C_LANG_NAME -> {C,Go}. 2021-07-31 09:10:28 +01:00
Ulya Trofimovich 53ee23a54f Update docs: rewrite the introduction section of the manual. 2021-07-25 21:13:51 +01:00
Ulya Trofimovich 477f35b567 Travis CI: use Ubuntu 20.04 (Focal Fossa) to have Python 3 by default. 2021-07-25 11:08:03 +01:00
Ulya Trofimovich 1d84bb9816 Update Travis CI config. 2021-07-25 10:25:54 +01:00
Ulya Trofimovich f67f489281 Simplify interface code in Go tests with re2c:api:style = functions;. 2021-07-24 13:15:15 +01:00
Ulya Trofimovich 0bd2b72155 Add BUILD.md with build/test instructions. 2021-07-18 18:57:05 +01:00
Ulya Trofimovich 423c56ca55 Update documentation for directives. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 58f47cd066 Use new re2c features in re2c lexers to have some real-world coverage. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich fd2e96394f Slightly relax !use and !include directive format.
- allow optional spaces before the semicolon
- allow whitespace or the end of block after the semicolon (previously
  only a newline was allowed)
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 2a973270d9 Don't fail when meging symtabs with pointer-identical name definitions.
This may happen if a name is defined in global scope and inherited by a
`rules:re2c` block that is followed by another block that uses the rules
block with a `!use` directive:

  /*!re2c
      x = [x];
  */

  /*!rules:re2c:R
      // inherits 'x' definition from global scope
      y = [y];
  */

  /*!re2c
      // inherits 'x' definition from global scope
      // imports the same 'x' definition from 'R'
      !use:R;
  */

At the time when symtab from the rules block is merged with the
inherited one, there is a collision on the global names that are present
in both symtabs. It's harmless.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich a20d8965a9 Unify handling of getstate:re2c with other directives. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich a096166f83 Allow 'format' and 'separator' configuration in types:re2c.
Now it is possible to customize this directive:

  /*!types:re2c
      format = "static const int @@{cond} = @@{num}";
      separator = "\n";
  */
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 19be0e3ab7 Unify #line info for directives max, maxnmatch, stags, mtags.
Tests have been updated because `#line` directives are now generated in
more cases than previously.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 144dbc4146 Unify handling of directives max, maxnmatch, stags, mtags. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 7262325fbe Move the definition of codegen block kinds to constants.h. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 6bfd78133e Move constant definitions to a top-level header to reduce dependencies.
Also, add and remove a few files.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 92b98e9781 Deprecate configurations flags:i and flags:no-debug-info.
Global options `-i` and `--no-debug-info` can be used instead.

Configurations allow to enable/disable `#line` directives on a more
fine-grained basis (for selected parts of the file), but there's not
much point in doing so and there are no known real-world use cases.
Having them as global options is convenient, because a global option
can be used in parser (unlike a configuration, which can change and for
which the final value is unknown until the whole block is parsed).
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 7c278733fa Clean up a few places in codegen that have to use global options.
The few places are:
  - condition enum (this one should always use whole-program options)
  - state switch (this one should either use whole-program options, or
    block-local options if this is a `use:re2c` block

Add comments.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 02da15a2ef Store block pointer in codegen context instead on inlining its fields. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 2d1aec19ba Handle block lists in types:re2c directive. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 958ac86e51 Use block-specific condition prefix when generating condition enum. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich ca0ebe9c58 Handle block lists in stags:re2c and mtags:re2c directives. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 20236a1b04 Skeleton: emit global m-tag definitions only once (to avoid collisions). 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 43b6533936 Allow 'format' configuration in max:re2c and maxnmatch:re2c.
Now it is possible to customize these directives:

  /*!max:re2c
      format = "static const int YYMAXFILL = @@";
  */

  /*!maxnmatch:re2c
      format = "static const int YYMAXNMATCH = @@";
  */

This commit breaks backward compatibilty, because it forbids arbitrary
garbage at the end of `max:re2c` directive. It was historically allowed
and even used in one test, but it doesn't add any practical value and
it's getting in the way of adding 'format' option (or any other option).
The following code that was previously accepted now triggers an error:

  /*!max:re2c
      ... arbitrary g4rbage ...
  */
2021-07-17 21:38:36 +01:00
Ulya Trofimovich fa8e24f844 Pass struct to functions to reduce the number of parameters. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich e1fc740020 Split 1st pass codegen context into global and block-local parts. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich d91e137ca0 Handle block lists in maxnmatch:re2c directive. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 9383114bd6 Handle block lists in max:re2c directive. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 78c77ab417 Rename test subdirectory. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich d81c2ecd4e Point at the beginning of a block in warnings and error messages. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich ac4aaed276 Forbid duplicate names in block lists.
For example, emit an error on `/*!getstate:re2c:x:y:x */`. Previously
this resulted in code that would not compile (due to duplicate cases in
the generated state switch), but an explicit error message from re2c
is more user-friendly (and it covers all block lists, not just the case
of `getstate:re2c` directive).
2021-07-17 21:38:36 +01:00
Ulya Trofimovich ba7eec131c Forbid blocks to have identical names (including autogenerated ones). 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 480010a043 Append block number to autogenerated block name.
Previously autogenerated names were identified by block line, but it may
be non-unique (it is possible to have multiple blocks on the same line,
included files may define blocks at the same line, and line directives
may reset line number).
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 62ef4235cf Add tests for state switch (with -f --storable-state option). 2021-07-17 21:38:36 +01:00
Ulya Trofimovich f2fb9ac94c Improve error reporting when generating state switch.
Emit error messages instead of failing debug checks when:
- there are no blocks with code in the global state switch
- first named block on the list is empty (has no start label)
- a named block is missing (reworked error message)

Also, rewrite the code in a way that avoids looping over the block list
twice. Previosuly the first loop was used to to find a start label, and
the second loop was to generate switch cases. Now we do both in the same
loop and prepend the default case with the start label to other cases.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 89841a7a23 Split "expand" code generation pass into first and second passes.
The first pass expands everything except labels (they have to wait until
the second pass because the first pass may generate some additional uses
for previously unused labels). The second pass expands labels.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 93d39f384d Rework codegen for state switch with -f --storable-state option.
State switch is generated differenly for `use:re2c` blocks and for all
other blocks.

For use blocks there is a block-local switch that is automatically
generated at the beginning of the block. Previously use blocks had a
separate enumeration of YYFILL states starting from zero, and they used
a block-specific prefix in YYFILL state labels. Now use blocks
participate in the global YYFILL state enumeration, and their labels no
longer require a block-specific prefix (because label numbers are unique
across the whole file).

For all other blocks there is a global state switch that is generated
either at the point where `getstate:re2c` directive is specified by the
user, or (if there are no user-defined `getstate:re2c` directives) at
the beginning of the first non-use block that has a start label. Code
generation of the global state switch hasn't changed.

Now it has become possible to generate a state switch for the subset of
blocks specified in a `getstate:re2c` directive. The code is still
slightly incorrect, as the start label for the first block on the list
is not always generated (only if this block is the first non-use block
in the file). This happens because the generation of labels happens too
early, before the generation of the state switch that marks the start
label as used.

The tests that have use blocks have been updated (only the labels and
the autogenerated YYFILL state numbers have changed).

As a result of this patch the cases in a state switch no longer have to
start from zero and be sequential: 0, 1, 2,... . Now they can start with
any number and consist of block-local sequential ranges (the numbers are
unique and non-decreasing). State numbering is an internal re2c detail,
so it should not affect any users. State -1 (or any other negative
number) is handled in the same way as before (as a special case).

To facilitate the generation of state switch based on block names, the
code has been rewritten to find blocks by their name. Each block now
stores start and end YYFILL indices and a link to the start label. This
information is used in the generation of state switch instead of an
implicit assumption that indices start from zero and occupy sequential
numbers. Use blocks are also handled via the new name-based mechanism:
they use a special autogenerated block name which is passed to the
autogenerated block-local state switch.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 410c81e060 Give all input blocks a name (a user-defined or an autogenerated one). 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 703af40334 Rename input block enum and move it to a header with fewer dependencies. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich ac2c9ff132 Always count start label with -f --storable-state option.
Start label is not always used, only in cases when there is a transition
to the start state or if it is explicitly enforced by the user.

Previously re2c did not include start label in the global label
enumeration unless it was actually generated. This required knowing in
advance if the label was used or not. Currently we do have such
knowledge, because the default transition in the state switch goes to
the first block in the file (except for reuse blocks, which have
individual state switch).

But this is problematic for the new `getstate:re2c` that is allowed to
specify a list of block names, because the default transition now needs
to go to the first block on the list, not the first block in the file.

This commit adds start label to the global label enumeration, even if it
is not generated. As a result, label numbers in some tests have changed.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich f502e54357 Allow generating user-defined state switch multiple times. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 0ae6ed4675 Allow specifying block names in re2c blocks and directives.
Don't do anything with the specified names yet, just parse them and save
for future use. Follow-up changes will handle block names for each type
of block or directive.

The following block types now have an optional name:

    /*!re2c[:name] ... */
    /*!local:re2c[:name] ... */

The following directives now have an optional list of colon-separated
block names:

    /*!max:re2c[:name1[:name2...]] ... */
    /*!maxnmatch:re2c[:name1[:name2...]] ... */
    /*!types:re2c[:name1[:name2...]] ... */
    /*!getstate:re2c[:name1[:name2...]] ... */
    /*!stags:re2c[:name1[:name2...]] ... */
    /*!mtags:re2c[:name1[:name2...]] ... */
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 15cc78861a Add local blocks (declared with /*!local:re2c ... */).
The new type of blocks differs from the usual `/*!re2c ... */` blocks
in that the names and configurations it defines are local: they have the
scope of a block and aren't visible outside of it in the global scope.
This allows one to reuse the same names multiple times in different
blocks, and to avoid "polluting" the global scope.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich ac5a710548 Use correct symbol table for each block.
Symbol table (a.k.a. the mapping of named definitions to regexps) should
obey the same scoping rules as configurations. Before this commit it was
broken: there was one global symbol table that accumulated all named
definitions along the way.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 8d97e4b5be Make run_tests.py executable on UNIX (lost when migrating to python). 2021-07-17 21:38:36 +01:00
Ulya Trofimovich 2c4d5c8c06 run_tests.py: don't pass nonexistent parameter to function. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich b6c96f92ea run_tests.py: don't crash if some expected output files are missing. 2021-07-17 21:38:36 +01:00
Ulya Trofimovich ae4e534bc8 run_tests.py: don't crash when reference results are missing.
Run tests to the end and produce results for all test cases that are
missing reference results. This is convenient when adding new tests, as
it allows one to drop *.re files in the test directory, run the tests
(failure is expected), manually verify the generated results and copy
them to the test directory.
2021-07-17 21:38:36 +01:00
Ulya Trofimovich 88ff1e5a2a run_tests.py: patch newlines and backslashes in test results on windows. 2021-06-27 16:23:28 +01:00
Ulya Trofimovich c581194f7a Properly escape backslashes in the generated file paths.
Add escaping in some previously forgotten cases.

Avoid double escaping (previously this happened for some include files
for which file path was constructed as a concatenaton of an already
escaped directory part and the yet unescaped file path in the include
directive).

This only affects platforms that use backslashes in file paths (such as
Windows).
2021-06-27 16:23:28 +01:00
Ulya Trofimovich ad98410b00 run_tests.py: skip overflow-1 on windows (failing due to small stack). 2021-06-27 16:23:28 +01:00
Ulya Trofimovich ebfd61a3db Rewrite recursion into iteration for stats function.
This helps to avoid overflow on systems with small stack.
2021-06-27 16:23:28 +01:00
Ulya Trofimovich c4be6d05d3 run_tests.py: fix tests on Wine.
This fixes `make wtests` (--wine option to run_tests.py).

A few things were broken:
  - re2c binary should have '.exe' file extension
  - `re2c --version` on wine is rather slow, so drop the 2s timeout
2021-06-27 16:23:28 +01:00
Ulya Trofimovich 0ea48c905e GitHub Actions CI: unmask Windows tests. 2021-06-27 16:23:28 +01:00
Ulya Trofimovich b8a47acfa1 GitHub Actions CI: upload test build directory, not source directory. 2021-06-27 16:23:28 +01:00
Sergei Trofimovich d363c06980 configure.ac: allow user to set non-standard PYTHON
Useful on systems with multiple python implementations.
While at it allow both 'python3' (preferred) and 'python' spellings.

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>
2021-06-24 23:36:05 +01:00
Ulya Trofimovich e7d43c7655 Use unique names for header files generated by the tests.
Header files may be created in the same directory, so that one header
overwrites the other. It also causes races in run_tests.py when it tries
to clean up intermediate files created by each test.
2021-06-22 23:38:46 +01:00
Serghei Iakovlev beb0fe59bb Make remove() function simpler
The previous version of this function has multiple responsibilities and
actually had knowledge for which it was not intended.

These changes are about "S" in SOLID.
2021-06-20 22:24:00 +03:00
Ulya Trofimovich 3e14320a87 run_tests.py: don't shard tests, use chunk size 1.
Previously the script divided all tests into chunks of equal size, which
is suboptimal as different tests take different time, and often large
tests end up in the same chunk. This adds imbalance and makes the test
runner slower than it could be with chunk size 1.

Also, use a more pythonic way to gather results from threads. The old
bash script did that via per-thread log files because it is hard to do
it otherwise in bash. But in python one can simply return results from
each thread, avoiding the overhead on file I/O.
2021-06-20 15:59:38 +01:00
Ulya Trofimovich 75881ab9c6 Remove an old useless test that revealed races in run_tests.py.
The removed test was a trivial modification of another test (with -i
option turned off). It was useful long ago, but not anymore as we have
many tests with or without -i option.

The removed test was problematic because it created a header file with
the same name as the other test, which revealed a race in test runner
that removed the generated header before the other file processed it.

This got uncovered while debugging run_test.py, when I changed
multiprocessing.Pool.map() to multiprocessing.Pool.imap(). The race
happened only once in a few runs.
2021-06-20 15:59:38 +01:00
Serghei Iakovlev 43025a8793 Run regular tests under Windows
These changes are intended to prepare the project to run tests under
Windows.  Currently Windows tests are disabled until we dealing with
failures.
2021-06-20 10:59:58 +01:00
Ulya Trofimovich 60773997a6 Update information about #re2c IRC channels.
After the downfall of freenode #re2c channel has migrated to OFTC and
Libera.Chat.
2021-06-19 21:24:32 +01:00
Serghei Iakovlev 9c9981190b Rewrite re2c test runner in Python
This pull request introduces a completely rewritten test runner
in Python.

The main goals of this change:

- Provide a OS-independent way to run tests (at least using CMake)
- Getting rid of dependence on Unix utilities in tests
  (grep, cat, tr, etc.)
- Flexibility
- Ease of maintenance
2021-06-19 14:20:35 +01:00
Serghei Iakovlev cf57858bce Add step names to benchmark workflow 2021-06-16 00:23:40 +01:00
Ulya Trofimovich 150b2d38b1 benchmarks.yml: quote Python version to prevent parsing it as float. 2021-06-16 00:23:40 +01:00
Ulya Trofimovich 5de6ae6328 run_tests.sh: bring back --keep-tmp-files option.
This reverts commits:
  - ec9eecd077
  - f710983c23

By default if some tests fail, the corresponding temporary files are
kept (for investigation). For the passing tests temporary files are
removed. But in some cases it is convenient to keep temporary files for
the passing tests as well.
2021-06-15 22:49:17 +01:00
Ulya Trofimovich f710983c23 run_tests.sh: remove obsolete '--keep-temp-files' option from help.
Note: the option itself was removed in commit
ec9eecd077, but the obsolete description
remained until now.
2021-06-15 08:51:23 +01:00
Ulya Trofimovich 424dfed352 Submatch Java benchmark: update REgen submodule. 2021-06-15 07:53:22 +01:00
Ulya Trofimovich 3dce73623c Submatch Java benchmark: account for varying RE size within each group.
REgen procduces input data with variable RE size within each group, so
in order to generate truthful plot it is necessary to take that variance
into account.

For JS plot, compute the x-coordinate as the average RE size withing
each group (also average the y-coordinate within each group, as before).

For PGF plot, don't average RE size, instead use individual RE size as
the x-coordinate. Do a few transformations on the benchmark results:
remove outliers using centered moving median, then smooth the curve
using centered moving average.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich ff6382b5bc Submatch Java benchmark: copy JS chart to the build directory.
It is a runtime dependency of ReTdfa.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich 6dbaae39bd Submatch Java benchmark: add a small samples file (zipped). 2021-06-15 07:53:22 +01:00
Ulya Trofimovich f8f10c201a Submatch Java benchmark: add REgen as a Git submodule.
REgen is a program that generates input data for the benchmark. We use a
fork of the original repo in order to be able to apply local patches.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich 82623c3e8c json2pgfplot.py: escape backslash when generating TeX code. 2021-06-15 07:53:22 +01:00
Ulya Trofimovich f70d5a8364 Java submatch benchmark: generate PGF plot. 2021-06-15 07:53:22 +01:00
Ulya Trofimovich 0f63fed70d Submatch DFA AOT benchmark (run script): fail if output file is not set.
Exception is verification mode, when there is no need to log output.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich e60fbdcc8f Submatch DFA JIT benchmark: drop leftmost greedy variants.
Although leftmost greedy results are different from POSIX ones, the
relative difference of register/registerless variants is similar, so
it suffices to keep only the POSIX variants.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich 80b3249e00 Remove the old build script for ReTdfa benchmark. 2021-06-15 07:53:22 +01:00
Ulya Trofimovich a38f46396d GitHub Actions (benchmarks workflow): add ReTdfa benchmark. 2021-06-15 07:53:22 +01:00
Ulya Trofimovich 2c1b39cff0 Add Makefile.am for the ReTdfa benchmark.
The benchmark is built if configure option --enable-benchmarks is set
and environment variable JAVA_HOME is non-empty.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich 9079ce8614 Add CMakeLists.txt for the ReTdfa benchmark.
The benchmark is built if configuration option RE2C_BUILD_BENCHMAKRS has
been set and CMake is able to find Java.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich 25d881dc2a Add regular expression library and benchmark by Angelo Borsotti.
ReTdfa is a Java library that contains a family of algorithms for
regular expression parsing and submatch extraction based on TNFA and
TDFA. It is also a benchmark for various algorithms, including some
that are based on libre2c.

This commit also adds Java bindings to libre2c.
2021-06-15 07:53:22 +01:00
Ulya Trofimovich c15ef2d410 libre2c: don't allocate/free memory for pmatch[] in the library.
This should be done by the user, and the library may only store a
pointer to the allocated memory in the regex_t structure (this is
convenient for the foreign bindings).
2021-06-15 07:53:22 +01:00
Ulya Trofimovich 6fe4df03ae libre2c: do not include project-local headers in regex.h.
The regex.h header is included by the users of the library. Including
other local headers in it is problematic, because the user then has to
specify additional include search paths (and do so by trial and error
rather than by some general rule).

Strictly speaking, this commit breaks C++98 compatibility as <stdint.h>
is non-standard in C++98. But in practice this is unlikely to cause any
problem, as libre2c is a recently added experimental library which
hardly has any users that do not have a C++11 toolchain.
2021-06-15 07:53:22 +01:00
Serghei Iakovlev 4a89dc2d6e Speedup CI workflow by removing not used cache step 2021-06-13 21:13:17 +01:00
Ulya Trofimovich 7f27352602 Better handling of syntax errors in re2c directives.
- Fail with an error in some confusing cases like
  `/*!include:re2c x.re */` that are likely to be unintentional syntax
  errors (double quotes missing around the filename), but previously did
  not fail and were treated like comments (no code was generated).

- Improve error messages for syntax errors such as a bad block name.

AFL tests had to be updated, because the original tests that crashed the
lexer now fail earlier due to an unrelated reason, so a space character
had to be added in some tests to make them hit the same error as before.
2021-05-28 12:16:45 +01:00
Ulya Trofimovich 536f097936 Update docs regarding precedence of special rules in reused blocks. 2021-05-28 00:18:55 +01:00
Ulya Trofimovich 11af1f43c7 Allow overriding special rules inherited from reusable blocks.
Within one block special rules *, $ and <!> cannot be redefined (it is
an error). However, when reusing other blocks it might be convenient to
override inherited special rules with local ones. This commit separates
inherited and local special rules by storing them in separate containers
that are merged at the end.

Also, this commit merges functions that validite and "normalize"
specifications into one function. This has to be done because some of
the validation checks must be performed before merging special rules,
and some must be done after that.
2021-05-28 00:18:55 +01:00
Ulya Trofimovich db641794fd Update documentation and add more examples for reusable blocks. 2021-05-28 00:18:55 +01:00
Ulya Trofimovich 4fff2e35fb Enable reuse blocks by default and deprecate -r, --reusable option.
Now that `/*!rules:re2c ... */` and `/*!use:re2c ... */` blocks can be
mixed freely with the ordinary `/*!re2c ... */` blocks, there is no
reason not to allow reuse mode by default.
2021-05-28 00:18:55 +01:00
Ulya Trofimovich 4f8adcb3cc Clean up data structures that represent reuse blocks.
Also, fix memory leak in the parser (found by LeakSanitizer): don't
forget to free std::string that was allocated to hold block name in the
inline `!use` directive.
2021-05-28 00:18:55 +01:00
Ulya Trofimovich 261a4b91ed Disallow garbage at the end of directives (with a few exceptions).
Historically re2c allows arbitrary text before the closing comment of
the directives such as `/*!ignore:re2c ... */` and `/*!max:re2c ... */`.
It only makes sense for the ignore directive (which is just a multiline
comment), but not for other directives. This commit disallows garbage at
the end of all directives, except `/*!ignore:re2c ... */` and (for the
reasons of backward compatibility) `/*!max:re2c ... */`.
2021-05-28 00:18:55 +01:00
Ulya Trofimovich 2262fe7dbe Don't forget to adjust line count after inline !include directive. 2021-05-28 00:18:55 +01:00
Ulya Trofimovich 7e66ba5334 Add inline !use directive.
The inline `!use:<block-name>;` directive  can be used in the middle of
a re2c block. It allows one to merge a block named <block-name> into the
currect block: rules of the used block are added to the current set of
rules, and configurations are added to the current options. Overlapping
rules and configuraitons have the usual priority, as if the used block
was literally inserted in place of the `!use` directive (the first rule
wins, and the last configuration wins).
2021-05-28 00:18:55 +01:00
Ulya Trofimovich ee37e0f03f Initial implementation of named blocks.
Named blocks allow one to reuse any rules block, not only the last one.
The syntax named blocks extends existing syntax for unnamed blocks:

    /*!rules:re2c:<name>
        ...
    */

An optional name is specified after a semicolon. The block can then be
used by specifying its name in a use block:

    /*!use:re2c:<name>
        ...
    */
2021-05-28 00:18:55 +01:00
Ulya Trofimovich 867cf7522c Update docs and examples for the inline include directive. 2021-05-21 08:55:34 +01:00
Ulya Trofimovich cb6d9025ad Allow include directives in the middle of a block.
This commit addresses issue #351 "include directive limitations",
reported by Henry Harvey.

An include directive in the middle of a block is useful in cases when
the include file contains additional rules overlapping with the rules in
the including file. In such cases the usual directive won't work, as it
would crate a new re2c block with its own set of rules (rather than
merge the included rules into the current set).

The inline directive syntax is slightly different from the usual re2c
directive syntax: comment markers '/*' and '*/' are dropped to avoid
nested multiline (which are unsupported in C/C++), and the ':re2c' part
is also dropped because it is redundant (the inline directive is already
inside of a re2c block).
2021-05-21 08:55:34 +01:00
Ulya Trofimovich db219561ec libre2c: add option REG_AUTOTAGS that enables full parsing mode.
The new option automatically adds tags for all subexpressions, as if
they were wrapped in capturing parentheses. This is only useful for
experimental purposes (to measure parsing speed in the case of fully
tagged RE and study performace degradation of different algorithms as
the density of submatch increases).
2021-05-12 23:39:51 +01:00
Ulya Trofimovich a703a46586 libre2c: use t-string fragments instead of trie for regless algorithms.
Unwinding tag history from its trie representation is rather slow. This
can be done in advance at regcomp() time, and the resulting t-string
fragments can be stored in backlinks (this is what regtstring() already
uses). For offset construction t-string fragments also need to include
negative tags.
2021-05-11 22:43:34 +01:00
Ulya Trofimovich 62fe269e84 libre2c: use common forward pass for all regless-TDFA algorithms.
The forward pass is the same for regexec(), regparse() and regtstring().
2021-05-10 09:12:00 +01:00
Ulya Trofimovich 44611fe7f8 libre2c: add some comments for regparse() and regtstring(). 2021-05-10 09:12:00 +01:00
Ulya Trofimovich 478fe2576a libre2c: add an algorithm that constructs a t-string.
This CL adds a new flag REG_TSTRING and a new API function regtstring()
that returns a t-string (a flattened representation a parse tree where
characters of the input string are interleaved with tags).

The goal of this algorithm is to construct parse results in the cheapest
possible way. There is no standard representation of a parse tree, and
any nontrivial representation would likely incur a significant overhead
(the algorithm would spend most of the time constructing parse results
rather doing the actual parsing).

The t-string representation requires very little effort to construct,
provided that the t-string fragments corresponding to the tagged paths
in the epsilon-closure are prepared in advance at regcomp() time. The
fragments are stored as arrays of tags, so that they can be easily
copied to the resulting t-string. Importantly, this does not require
unwinding of tag history stored in a trie form, which is rather slow.

A t-string is represented as a sequence of 16-bit values that are either
ASCII characters (that occupy the lower byte, leaving the higher byte as
zero) or tags (that are numeric value shifted to the upper half of the
16-bit range).

16-bit size for t-string characters is chosen to align with the
experimental Java implementation by Angelo Borsotti.

T-string allocation is done on the library side, and the t-string is
stored in the regexp structure. The user gets an immutable view of the
resulting t-string and is not expected to free memory after calling
regtstring(). Moreover, the library reuses the same memory on each
regtstring() call and reallocates it only if the new t-string does not
fit into the old memory area.

All in all, the new regtstring() API is primarily intended for
benchmarking the speed of the parsing algorithms, and not for "official"
use.
2021-05-10 09:12:00 +01:00
Ulya Trofimovich 308b434e1d libre2c: add algorithms for submatch extraction on all repetitions.
This patch adds a new flag REG_SUBHIST and new API functions regparse()
and regfreesub().

regparse() returns parse results as an array of nmatch size, where each
element is an array of offset pairs for the correspoinding capturing
group. If a group has matched repeatedly at different parts of the input
string, then its array will contain multiple offset pairs; otherwise, a
single pair. This differs from the standard POSIX API, where onl the
last offset pair for each group is returned.

The allocation of memory for the parse results is done by the library
(the user cannot know how much memory will be needed). The ownership of
parse results is transferred to the user, who is expected to deallocate
memory allocated by regparse() with regfreesub().
2021-05-10 09:12:00 +01:00
Ulya Trofimovich e3d5973eb6 libre2c: don't forget to set fallback tags in regexec_dfa.
In order to do that, it is necessary to compute fallback states and
insert fallback tags.
2021-05-10 09:12:00 +01:00
Alexander Shemetovskiy 58b5e89439 Fix link to CONTRIBUTING.md 2021-04-26 00:00:53 +01:00
Ulya Trofimovich b1d3afe144 Rename directory for SIMPA article. 2021-04-06 07:30:42 +01:00
Ulya Trofimovich 07e417fa94 Fix typo in documentation (add missing space). 2021-04-05 10:25:45 +01:00
Ulya Trofimovich 1ae96895a8 CMake: pass re2c options for benchmark as two distinct arguments.
Otherwise the build fails with error:
    re2c: error: bad long option: --no-generation-date --no-version
2021-04-04 10:18:33 +01:00
Ulya Trofimovich b4efac3cc0 Add benchmark results on April 2, 2021.
The measurements have been taken on an Intel(R) Core(TM) i7-8750H CPU
with 32 KiB L1 Data cache (x6 cores), 32 KiB L1 Instruction cache (x6
cores), 256 KiB L2 Unified cache (x6 cores), 9216 KiB L3 Unified cache,
32 GiB RAM.

Software versions:
- ragel-7.0.4
- kleenex built from Git at commit d474c60
- re2c built from Git at commit 1c3bead
- re2-2020-11-01
- GCC-10.2.0
- Clang-11.0.0
2021-04-02 11:50:50 +01:00
Ulya Trofimovich 1c3bead790 Benchmarks: update ragel to 7.0.4 (and update autogenerated files). 2021-04-02 11:10:51 +01:00
Ulya Trofimovich a13d86491e Benchmarks: create directory for kleenex before building it. 2021-04-02 11:10:51 +01:00
Ulya Trofimovich b55ab37a22 Generate benchmarks with --no-version to avoid updates on every release. 2021-04-01 23:51:20 +01:00
Ulya Trofimovich 042cf6b671 json2pgfplot.py: fix accidentally swapped 'symbols' and 'captures'.
Also, take care of the singular/plural form.
2021-04-01 23:51:20 +01:00
Ulya Trofimovich 116873e30a json2pgfplot.py: use 'fixed relative' number format.
It reduces the visual noise on the plot: there are no exponents, but
the number of printed decimal places depends on the magnitude. In
combination with very high precision and some custom code that rounds
fractional part but keeps integer part intact, this allows one to have
numbers that are not too precise, but not too rounded either.

This format also has the advantage that it does not need math font, so
fonts like Comic Neue that don't have math support can be used as well.
2021-04-01 23:51:20 +01:00
Ulya Trofimovich 1177560f5e json2pgfplot.py: add option --font <comicneue | cmbright>.
The new option allows one to select the font to be used in the generated
PGF plot. Currently the supported fonts are 'comicneue' (Comic Neue) and
'cmbright' (Computer Modern Bright).
2021-04-01 23:51:20 +01:00
Sergei Trofimovich 1b402b0e88 configure.ac: avoid bash-specific '==' comparison
In https://bugs.gentoo.org/779187 Matt noticed errors when running ./configure
on dash:
    ./configure: 5339: test: x: unexpected operator
    ./configure: 5386: test: x: unexpected operator

The change is to use POSIX '=' comparison instead of bash-specific ==.

Patch-by: Matt Whitlock
Bug: https://bugs.gentoo.org/779187
Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>
2021-03-31 22:09:44 +01:00
Ulya Trofimovich 568d4226f7 Move variable initialization before goto statement.
This is to avoid compiler errors on Solaris 10, see #347.
2021-03-29 07:57:50 +01:00
Ulya Trofimovich 342e53a71e Release 2.1.1. 2021-03-27 18:28:33 +00:00
Ulya Trofimovich a609454ebe Update CHANGELOG for release 2.1.1. 2021-03-27 18:23:13 +00:00
Ulya Trofimovich a051e673de Distcheck: test that release tarball can be built with CMake.
This is to prevent bugs like #346 "No CMakelists.txt file in new 2.1
release".
2021-03-27 18:16:32 +00:00
Ulya Trofimovich 27f42a454d Add CMakeLists.txt to release tarballs.
It was accidentally dropeed from EXTRA_DIST in commit
9959efed38. This was reported in #346
"No CMakelists.txt file in new 2.1 release".
2021-03-27 15:05:08 +00:00
859 changed files with 66480 additions and 28253 deletions
+19 -3
View File
@@ -32,16 +32,27 @@ jobs:
# no Windows, as Kleenex generates non-portable C code
steps:
- name: Checkout
- name: Checkout Code
uses: actions/checkout@v2
- name: Setup
- name: Setup Python
uses: actions/setup-python@v2
with:
python-version: '3.8'
- name: Setup Java
uses: actions/setup-java@v2
with:
distribution: 'adopt'
java-version: '11'
- name: Setup Common Prerequisites
run: |
case ${{ runner.os }} in
Linux*)
echo "CC=gcc" >> $GITHUB_ENV
echo "CXX=g++" >> $GITHUB_ENV
sudo apt-get install libre2-dev libbenchmark-dev
sudo apt install libre2-dev libbenchmark-dev
;;
macOS*)
sudo xcode-select -switch /Applications/Xcode.app
@@ -52,6 +63,7 @@ jobs:
brew install re2 google-benchmark
;;
esac
pip install psutil
- name: Configure
run: |
@@ -76,6 +88,10 @@ jobs:
working-directory: .build/benchmarks/submatch_dfa_jit
run: ./bench_submatch_dfa_jit
- name: Run submatch Java benchmark (ReTdfa)
working-directory: .build/benchmarks/submatch_java
run: ./run.py
- name: Run submatch NFA benchmark
working-directory: .build/benchmarks/submatch_nfa
run: ./bench_submatch_nfa
+43 -147
View File
@@ -14,95 +14,48 @@ jobs:
runs-on: ${{ matrix.os }}
strategy:
# When set to true, GitHub cancels
# all in-progress jobs if any matrix job fails.
fail-fast: false
matrix:
include:
# Linux
- name: linux-gcc-ubsan-ootree
os: ubuntu-latest
generator: Unix Makefiles
build-type: Ubsan
build-dir: .build
cxx-flags: -O2
skeleton: ${{ false }}
- name: linux-gcc-asan-ootree
os: ubuntu-latest
generator: Unix Makefiles
build-type: Asan
build-dir: .build
cxx-flags: -O2
skeleton: ${{ false }}
- name: linux-gcc-debug-ootree-skeleton
os: ubuntu-latest
generator: Unix Makefiles
build-type: Debug
build-dir: .build
cxx-flags: -O2
skeleton: ${{ true }}
- name: linux-gcc-debug-intree-m32-skeleton
os: ubuntu-latest
generator: Unix Makefiles
build-type: Debug
build-dir: .
cxx-flags: -O2 -m32
ld-flags: -m32
skeleton: ${{ true }}
- name: linux-gcc-release-ootree-skeleton
os: ubuntu-latest
generator: Unix Makefiles
build-type: Release
build-dir: .build
skeleton: ${{ true }}
# macOS
- name: macos-clang-debug-ootree-skeleton
os: macos-latest
generator: Unix Makefiles
build-type: Debug
build-dir: .build
cxx-flags: -O2
skeleton: ${{ true }}
- name: macos-clang-debug-intree-skeleton
os: macos-latest
generator: Unix Makefiles
build-type: Debug
build-dir: .
cxx-flags: -O2
skeleton: ${{ true }}
- name: macos-clang-release-ootree-skeleton
os: macos-latest
generator: Unix Makefiles
build-type: Release
build-dir: .build
skeleton: ${{ true }}
# Windows
- name: windows-msvc-debug-ootree
os: windows-latest
generator: Visual Studio 16 2019
build-type: Debug
build-dir: .build
skeleton: ${{ false }}
- name: windows-msvc-debug-intree
os: windows-latest
generator: Visual Studio 16 2019
build-type: Debug
build-dir: .
skeleton: ${{ false }}
- name: windows-msvc-release-ootree
os: windows-latest
generator: Visual Studio 16 2019
build-type: Release
build-dir: .build
skeleton: ${{ false }}
steps:
- name: Checkout Code
@@ -123,16 +76,10 @@ jobs:
case ${{ runner.os }} in
Linux*)
sudo apt install gcc-multilib g++-multilib # for -m32
echo "CC=gcc" >> $GITHUB_ENV
echo "CXX=g++" >> $GITHUB_ENV
;;
macOS*)
sudo xcode-select -switch /Applications/Xcode.app
echo "CC=$(xcrun -f clang)" >> $GITHUB_ENV
echo "CXX=$(xcrun -f clang++)" >> $GITHUB_ENV
echo "SDKROOT=$(xcodebuild -version -sdk macosx Path)" >> $GITHUB_ENV
echo "$(xcodebuild -version -sdk macosx Path)" >> $GITHUB_PATH
;;
Windows*)
@@ -146,119 +93,68 @@ jobs:
python-version: 3.x
architecture: x64
- name: Get PIP Cache Key
id: pip-cache
run: |
python -c "from pip._internal.locations import USER_CACHE_DIR; \
print('::set-output name=dir::' + USER_CACHE_DIR)"
- name: Install Python Dependencies
# Disabled until this https://github.com/skvadrik/re2c/issues/327
# will be implemented
if: startsWith(runner.os, 'Windows') == false
run: |
python -m pip install --upgrade pip
pip install docutils pygments
python -m pip install docutils pygments
- name: Prepare Configure Command
id: configure-command
run: |
# Common CMake arguments
args=( -S . -B ${{ matrix.build-dir }} )
# Generator's specific stuff.
args+=( -G "${{ matrix.generator }}" )
case "${{ matrix.generator }}" in
'Visual Studio'*)
args+=( -A x64 )
;;
*)
# CMAKE_BUILD_TYPE is not used by multi-config build
# types (e.g Visual Studio) at the configure time
# thus we add it only for single-config build types
args+=( -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} )
;;
esac
# CFLAGS, CXXFLAGS, LDFLAGS
args+=( -DCMAKE_C_FLAGS="${{ matrix.cxx-flags }}" )
args+=( -DCMAKE_CXX_FLAGS="${{ matrix.cxx-flags }}" )
args+=( -DCMAKE_EXE_LINKER_FLAGS="${{ matrix.ld-flags }}" )
args+=( -DCMAKE_SHARED_LINKER_FLAGS="${{ matrix.ld-flags }}" )
# Quote each argument to prevent word split.
echo "::set-output name=cmake::$(printf " '%s'" "${args[@]}")"
- name: Check Available Configure Presets
run: cmake --list-presets
- name: Fast Configure
run: |
# Read prepared command into an array
args=( ${{ steps.configure-command.outputs.cmake }} )
# Amend Build Options
args+=( -DCMAKE_INSTALL_PREFIX="$(pwd)/install" )
# Disable some defaults for now to speed up the build as
# they are not necessary in a minimal installation
args+=( -DRE2C_BUILD_RE2GO=OFF )
# Print the resulting command line for debugging purposes
printf "cmake" && printf " '%s'" "${args[@]}" && printf "\n"
# Run CMake, pass quoted arguments to prevent word split.
printf " '%s'" "${args[@]}" | xargs cmake
run: cmake --preset=${{ matrix.name }}-fast
- name: Fast Build
run: cmake --build ${{ matrix.build-dir }} --config ${{ matrix.build-type }}
run: cmake --build --preset=${{ matrix.name }}-fast
- name: Install
run: |
cmake --build ${{ matrix.build-dir }} --config ${{ matrix.build-type }} --target install
echo -e "Install tree:\n$(find install | sed 's/^/-- /')"
run: cmake --build --preset=${{ matrix.name }}-fast --target install
- name: Minimal Install Test
working-directory: ./install/bin
run: ./re2c --version
- name: Full Configure
run: |
# Read prepared command into an array
args=( ${{ steps.configure-command.outputs.cmake }} )
# Amend Build Options
args+=( -DCMAKE_INSTALL_PREFIX="$(pwd)/install-2" -DRE2C_BUILD_RE2GO=ON -DRE2C_BUILD_LIBS=ON )
args+=( -DRE2C_REBUILD_LEXERS=ON -DRE2C_FOR_BUILD="$(pwd)/install/bin/re2c" )
# Windows does not have a native 'man' and 'sed' commands.
# Disabled until this https://github.com/skvadrik/re2c/issues/327
# will be implemented
case ${{ runner.os }} in
Windows*)
args+=( -DRE2C_REBUILD_DOCS=OFF )
;;
*)
args+=( -DRE2C_REBUILD_DOCS=ON )
;;
esac
# Print the resulting command line for debugging purposes
printf "cmake" && printf " '%s'" "${args[@]}" && printf "\n"
# Run CMake, pass quoted arguments to prevent word split.
printf " '%s'" "${args[@]}" | xargs cmake
run: cmake --preset=${{ matrix.name }}-full
- name: Full Build
run: |
find src -name '*.re' | xargs touch
cmake --build ${{ matrix.build-dir }} --config ${{ matrix.build-type }} --verbose
cmake --build --preset=${{ matrix.name }}-full
- name: Test
if: startsWith(runner.os, 'Windows') == false
working-directory: ${{ matrix.build-dir }}
- name: Run Main Test Suite
run: cmake --build --preset=${{ matrix.name }}-full --target tests
- name: Get build dir
id: build-info
run: |
# main test suite
cmake --build . --target check
# skeleton tests (if enabled)
if [[ "x${{ matrix.skeleton }}" == "xtrue" ]] ; then
./run_tests.sh --skeleton
if echo "${{ matrix.name }}" | grep -q "ootree"; then
BUILD_DIR="$(pwd)/.build/${{ matrix.name }}-full"
else
BUILD_DIR="$(pwd)"
fi
echo "::set-output name=BUILD_DIR::$BUILD_DIR"
- name: Run Skeleton Tests
if: "contains(matrix.name, 'skeleton')"
# Remove the following line after fix Windows tests
working-directory: ${{ steps.build-info.outputs.BUILD_DIR }}
run: python run_tests.py --skeleton
- name: Archive test artifacts
# Run this step only if tests failed (otherwise there is nothing to upload).
if: failure()
uses: actions/upload-artifact@v2
with:
# To ensure that jobs don't overwrite existing artifacts,
# use a different name per job.
name: test-${{ matrix.name }}
# Tests run in a temporary directory that has a name test_<timestamp>.
path: ${{ steps.build-info.outputs.BUILD_DIR }}/test_[0-9]*
# Artifacts are retained for 90 days by default.
# In fact, we don't need such long period.
retention-days: 30
+3
View File
@@ -12,6 +12,9 @@
/test_*
/.build*
# Ignore user defined CMake presets
CMakeUserPresets.json
# The files autogenerated by automake.
Makefile.in
aclocal.m4
+3
View File
@@ -0,0 +1,3 @@
[submodule "benchmarks/submatch_java/REgen"]
path = benchmarks/submatch_java/REgen
url = https://github.com/skvadrik/REgen.git
+4 -1
View File
@@ -1,5 +1,8 @@
language: cpp
# use Ubuntu 20.04 (Focal Fossa) that defaults to Python 3
dist: focal
# speed up incremental builds
cache: ccache
@@ -75,7 +78,7 @@ script:
- make -j$(nproc)
- |
if [ x${SKELETON} = "xyes" ]; then
./run_tests.sh --skeleton
./run_tests.py --skeleton
else
make -j$(nproc) check VERBOSE=1
fi
+198
View File
@@ -0,0 +1,198 @@
How to build
============
Dependencies
------------
To build re2c from a release tarball one needs only a C++ compiler and
optionally Python 3 to run the tests.
To develop re2c one also needs CMake or Autotools. Re2c can be built with either
of the two build systems, and they are both maintained and tested on CI. Other
build dependencies include Bison (to rebuild parsers), rst2man (to rebuild
documentation), Sphinx (to rebuild the website), and optionally Mingw and Wine
(to run Windows tests on Linux). A few helper scripts are written in Haskell,
but they are not essential for re2c development.
Re2c is a self-hosting lexer generator, meaning that parts of its source code
are written in re2c (namely, all the source files that have a *.re* extension).
By default re2c builds from pregenerated bootstrap files. To regenerate these
files it is necessary to configure re2c in a special way and provide a path to
an existing re2c binary (see the details below). Normally this is not necessary,
and the pregenerated files can be used as long as the *.re* files are unchanged.
Build (Autotools)
-----------------
If you are building from a release tarball, the configure script is already
there. Otherwise it is necessary to generate it:
```
$ autoreconf -i -W all
```
An in-tree build (objects are generated side by side with sources):
```
$ ./configure && make && make install
```
An out-of-tree build (objects are generated in a separate directory):
```
$ mkdir .build && cd .build && ../configure && make && make install
```
The configure script has many options (to see them all, run
`configure --help`). The options specific to re2c are the following:
* `--enable-debug`
Enable debug checks in the re2c source code. Also enables debug options.
* `--enable-golang`
Build re2go (identical to `re2c --lang go`). This is on by default.
* `--enable-lexers`
Enable regeneration of *.re* files (as opposed to using bootstrap files).
This requires setting `RE2C_FOR_BUILD` to an existing re2c executable
path.
* `--enable-docs`
Enable regeneration of documentation (requires rst2man).
* `--enable-benchmarks`
Build benchmarks (requires google benchmarks library).
* `--enable-benchmarks-regenerate`
Regenerate C code for Ragel and Kleenex benchmarks (this will download and
build Ragel and Kleenex). Re2c benchmarks are always regenerated.
* `--enable-libs`
Build the experimental libre2c library that provides POSIX
`regcomp`/`regexec`/`regfree` interface to re2c.
Cross-compile re2c for Windows (for some Mingw versions you might have to use
`-std=gnu++11` compiler option):
```
$ ./configure --host i686-w64-ming32 \
LDFLAGS="-static -static-libstdc++ -static-libgcc"
```
There is a bunch of build scripts for specialized builds with Asan, Ubsan,
GLIBCXX_DEBUG, etc. in the ``build`` subdirectory.
Build (CMake)
-------------
CMake supports different build modes, which can be further customized with
individual options. By default re2c builds with `-O2 -g` and does not set any
particular mode to allow the user complete freedom in overriding the build
options. To enable a build mode at configure phase, use
`-DCMAKE_BUILD_TYPE=<mode>` option (this works with single-config generators,
such as Makefiles or Ninja). At build phase use `--config <mode>` option.
The following modes are supported:
* `Release`
This is an optimized `-O3 -DNDEBUG` build without debug symbols, asserts
and debug checks.
* `Debug`
This is a non-optimized `-g -DRE2C_DEBUG` build with debug symbols, asserts,
and debug checks.
* `RelWithDebInfo`
This is an optimized `-O2 -g -DNDEBUG` build with debug symbols, but
without asserts and debug checks.
* `MinSizeRel`
This is an optimized for size `-Os -DNDEBUG` build without debug symbols,
asserts and debug checks.
* `Asan`
This is a non-optimized `-g -fsanitize=address` build that instruments the
code with Address Sanitizer to check for memory errors.
* `Ubsan`
This is a non-optimized `-g -fsanitize=undefined` build that instruments
the code with Undefined Behavior Sanitizer to check for undefined behavior
errors.
A simple build (objects are generated in a separate build directory):
```
$ mkdir .build && cd .build && cmake .. && cmake --build .
```
CMake supports a lot of configuration options. Here is the list of options
specific to re2c:
* `-DRE2C_BUILD_RE2GO=yes`
Build re2go executable (an alias to `re2c --lang go`). Enabled by default.
* `-DRE2C_REBUILD_LEXERS=yes`
Enable regeneration of *.re* files (as opposed to using bootstrap files).
This requires setting `-DRE2C_FOR_BUILD` to an existing re2c executable
path.
* `-DRE2C_REBUILD_DOCS=yes`
Enable regeneration of documentation (requires rst2man).
* `-DRE2C_BUILD_BENCHMARKS=yes`
Build benchmarks (requires google benchmarks library).
* `-DRE2C_REGEN_BENCHMARKS=yes`
Regenerate C code for Ragel and Kleenex benchmarks (this will download and
build Ragel and Kleenex). Re2c benchmarks are always regenerated.
* `-DRE2C_BUILD_LIBS=yes`
Build the experimental libre2c library that provides POSIX
`regcomp`/`regexec`/`regfree` interface to re2c.
Cross-compile re2c for Windows using Mingw:
```
$ cmake . -DCMAKE_TOOLCHAIN_FILE=cmake/Toolchain-cross-mingw32-linux.cmake \
-DCMAKE_EXE_LINKER_FLAGS="-static -static-libstdc++ -static-libgcc" \
-DBUILD_SHARED_LIBS=no
```
There is a bunch of build scripts for specialized builds with Asan, Ubsan,
GLIBCXX_DEBUG, etc. in the ``build`` subdirectory.
Test
----
Re2c has a main test suite and a number of unit tests. Run them all:
```
$ make check
```
Run only the main test suite and watch the progress dumped on stdout:
```
$ python3 run_tests.py -j<N>
```
Run the main test suite with `--skeleton` re2c option:
```
$ python3 run_tests.py --skeleton
```
Run the test suite under Valgrind (takes some time and memory):
```
$ python3 run_tests.py --valgrind
```
Test Mingw builds with Wine:
```
$ make wtests
```
Check the distribution (works with Autotools):
```
$ make distcheck
```
Re2c provides a helper script `build/__alltest.sh` that builds and tests
various re2c build flavours with Asan, Ubsan, GLIBCXX_DEBUG, etc. There is a
couple of fuzz-testing Haskell scripts in the *fuzz* subdirectory; they are
based on the QuickCheck library and can be easily modified to fuzz-test various
aspects of re2c by comparing current re2c version against older versions or
against other regular expression libraries.
+45
View File
@@ -1,10 +1,55 @@
Changelog
=========
----
2.2x
----
2.2 (2021-08-01)
~~~~~~~~~~~~~~~~
- Added named blocks and block lists in directives.
- Added local blocks ``/*!local:re2c ... */``.
- Added in-block ``!include`` directive.
- Added in-block ``!use`` directive.
- Allowed reusable blocks without ``-r --reusable`` option.
- Allowed customizing the generated code with configurations for directives
``max:re2c``, ``maxnmatch:re2c``, ``stags:re2c``, ``mtags:re2c`` and
``types:re2c`` (see directive descriptions for details).
- Forbid arbitrary text at the end of ``max:re2c`` directive. This may break
backwards compatibility, although it is unlikely that this was used by anyone.
The change was necessary in order to allow customization of the generated code
with configurations.
- Deprecated configurations ``flags:i``, ``flags:no-debug-info`` in favour of
the global options ``-i``, ``--no-debug-info``.
- Reimplemented re2c test runner in Python (thanks to
`Serghei Iakovlev <https://github.com/sergeyklay>`_). Improved integration
with GitHub Actions.
- Changes in the experimental libre2c library: added new algorithms that
construct t-string or extract submatch on all repetitions; added TDFA
benchmark written in Java by Angelo Borsotti.
- Updated documentation.
----
2.1x
----
2.1.1 (2021-03-27)
~~~~~~~~~~~~~~~~~~
- Added missing CMakeLists.txt to release tarballs
(`#346 <https://github.com/skvadrik/re2c/issues/346>`_).
2.1 (2021-03-26)
~~~~~~~~~~~~~~~~
+29 -11
View File
@@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.12)
project(re2c VERSION 2.1 HOMEPAGE_URL "https://re2c.org/")
project(re2c VERSION 2.2 HOMEPAGE_URL "https://re2c.org/")
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
@@ -48,6 +48,7 @@ option(RE2C_REGEN_BENCHMARKS "Regenerate C code for benchmarks" OFF)
# checks for programs
find_package(BISON)
find_package(Python3 COMPONENTS Interpreter)
# checks for C++ compiler flags
set(CMAKE_CXX_STANDARD 98)
@@ -95,11 +96,14 @@ set(re2c_docs
)
set(top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")
set(top_builddir "${CMAKE_CURRENT_BINARY_DIR}")
set(PYTHON "${Python3_EXECUTABLE}")
configure_file(doc/manpage.rst.in doc/manpage.rst @ONLY)
configure_file(doc/help.rst.in doc/help.rst @ONLY)
configure_file(run_tests.sh.in run_tests.sh @ONLY)
set(RE2C_RUN_TESTS "${CMAKE_CURRENT_BINARY_DIR}/run_tests.sh")
configure_file(run_tests.py.in run_tests.py @ONLY)
set(RE2C_RUN_TESTS "${CMAKE_CURRENT_BINARY_DIR}/run_tests.py")
if(CMAKE_HOST_UNIX)
execute_process(COMMAND chmod +x "${RE2C_RUN_TESTS}")
endif()
@@ -143,10 +147,10 @@ set(re2c_sources
src/codegen/helpers.cc
src/codegen/render.cc
src/options/opt.cc
src/options/symtab.cc
src/nfa/estimate_size.cc
src/nfa/re_to_nfa.cc
src/adfa/adfa.cc
src/adfa/prepare.cc
src/debug/dump_adfa.cc
src/debug/dump_cfg.cc
src/debug/dump_dfa.cc
@@ -186,6 +190,7 @@ set(re2c_sources
src/regexp/default_tags.cc
src/regexp/fixed_tags.cc
src/regexp/nullable.cc
src/regexp/re.cc
src/regexp/rule.cc
src/regexp/split_charset.cc
src/regexp/tag.cc
@@ -197,11 +202,10 @@ set(re2c_sources
src/skeleton/skeleton.cc
src/parse/ast.cc
src/parse/input.cc
src/parse/normalize.cc
src/parse/parse.cc
src/parse/scanner.cc
src/parse/unescape.cc
src/parse/validate.cc
src/util/get_dir.cc
src/util/file_utils.cc
src/util/s_to_n32_unsafe.cc
src/util/temp_file.cc
src/util/range.cc
@@ -228,7 +232,6 @@ re2c_bootstrap_parser("src/parse/parser.ypp" "src/parse/parser.cc" "src/parse/pa
# docs
set(re2c_docs_sources
"${re2c_manpage_source}"
"doc/manual/api/api.rst_"
"doc/manual/api/interface.rst_"
"doc/manual/conditions/conditions.rst_"
"doc/manual/configurations/configurations.rst_"
@@ -258,6 +261,10 @@ set(re2c_docs_sources
"doc/manual/submatch/submatch_example_stags_fill.rst_"
"doc/manual/submatch/submatch.rst_"
"doc/manual/syntax/syntax.rst_"
"doc/manual/syntax/api1.rst_"
"doc/manual/syntax/api2_c.rst_"
"doc/manual/syntax/api2_go.rst_"
"doc/manual/syntax/api3.rst_"
"doc/manual/warnings/warnings_general.rst_"
"doc/manual/warnings/warnings_list.rst_"
"examples/c/01_basic.re"
@@ -274,6 +281,7 @@ set(re2c_docs_sources
"examples/c/includes/include.re"
"examples/c/includes/definitions.h"
"examples/c/reuse/reuse.re"
"examples/c/reuse/usedir.re"
"examples/c/state/push.re"
"examples/c/submatch/01_stags.re"
"examples/c/submatch/01_stags_fill.re"
@@ -293,6 +301,7 @@ set(re2c_docs_sources
"examples/go/includes/include.re"
"examples/go/includes/definitions.go"
"examples/go/reuse/reuse.re"
"examples/go/reuse/usedir.re"
"examples/go/state/push.re"
"examples/go/submatch/01_stags.re"
"examples/go/submatch/02_mtags.re"
@@ -325,19 +334,19 @@ if (CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
add_custom_target(tests
DEPENDS "${RE2C_RUN_TESTS}"
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
COMMAND "${RE2C_RUN_TESTS}"
COMMAND "${Python3_EXECUTABLE}" "${RE2C_RUN_TESTS}"
)
add_dependencies(tests re2c)
add_custom_target(vtests
DEPENDS "${RE2C_RUN_TESTS}"
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
COMMAND "${RE2C_RUN_TESTS}" --valgrind
COMMAND "${Python3_EXECUTABLE}" "${RE2C_RUN_TESTS}" --valgrind
)
add_dependencies(vtests re2c)
add_custom_target(wtests
DEPENDS "${RE2C_RUN_TESTS}"
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
COMMAND "${RE2C_RUN_TESTS}" --wine -j1
COMMAND "${Python3_EXECUTABLE}" "${RE2C_RUN_TESTS}" --wine -j1
)
add_dependencies(wtests re2c)
add_executable(re2c_test_range
@@ -387,6 +396,11 @@ if (RE2C_BUILD_LIBS)
re2c_bootstrap_lexer("lib/lex.re" "lib/lex.cc")
re2c_bootstrap_parser("lib/parse.ypp" "lib/parse.cc" "lib/parse.h")
add_library(test_libre2c_objects_autogen OBJECT
"${CMAKE_CURRENT_BINARY_DIR}/lib/test_helper.cc"
)
re2c_bootstrap_lexer("lib/test_helper.re" "lib/test_helper.cc")
add_library(libre2c_objects OBJECT
lib/regcomp.cc
lib/regexec.cc
@@ -403,6 +417,7 @@ if (RE2C_BUILD_LIBS)
src/parse/ast.cc
src/parse/unescape.cc
src/options/opt.cc
src/options/symtab.cc
src/cfg/cfg.cc
src/cfg/compact.cc
src/cfg/dce.cc
@@ -444,6 +459,7 @@ if (RE2C_BUILD_LIBS)
src/regexp/default_tags.cc
src/regexp/fixed_tags.cc
src/regexp/nullable.cc
src/regexp/re.cc
src/regexp/rule.cc
src/regexp/split_charset.cc
src/regexp/tag.cc
@@ -490,6 +506,7 @@ if (RE2C_BUILD_LIBS)
# libre2c test
add_executable(test_libre2c lib/test.cc)
target_link_libraries(test_libre2c libre2c)
target_link_libraries(test_libre2c test_libre2c_objects_autogen)
add_custom_target(check_libre2c
COMMAND ./test_libre2c
)
@@ -497,6 +514,7 @@ if (RE2C_BUILD_LIBS)
if(RE2C_BUILD_BENCHMARKS)
add_subdirectory(benchmarks/submatch_nfa)
add_subdirectory(benchmarks/submatch_dfa_jit)
add_subdirectory(benchmarks/submatch_java)
endif()
else()
# empty check target
+471
View File
@@ -0,0 +1,471 @@
{
"version": 3,
"cmakeMinimumRequired": {
"major": 3,
"minor": 21,
"patch": 1
},
"configurePresets": [
{
"name": "default-full-configuration",
"hidden": true,
"installDir": "${sourceDir}/install-2",
"cacheVariables": {
"RE2C_BUILD_RE2GO": true,
"RE2C_BUILD_LIBS": true,
"RE2C_REBUILD_LEXERS": true,
"RE2C_REBUILD_DOCS": true,
"RE2C_FOR_BUILD": "${sourceDir}/install/bin/re2c"
}
},
{
"name": "linux-config-base",
"hidden": true,
"generator": "Unix Makefiles",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Linux"
},
"architecture": {
"value": "x64",
"strategy": "external"
},
"cacheVariables": {
"CMAKE_C_COMPILER": "gcc",
"CMAKE_CXX_COMPILER": "g++"
}
},
{
"name": "linux-gcc-ubsan-ootree-fast",
"displayName": "Linux x86_64: GCC / Ubsan / Out of tree (fast)",
"inherits": "linux-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Ubsan",
"CMAKE_C_FLAGS": "-O2",
"CMAKE_CXX_FLAGS": "-O2",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "linux-gcc-ubsan-ootree-full",
"displayName": "Linux x86_64: GCC / Ubsan / Out of tree (full)",
"inherits": ["default-full-configuration", "linux-gcc-ubsan-ootree-fast"]
},
{
"name": "linux-gcc-asan-ootree-fast",
"displayName": "Linux x86_64: GCC / Asan / Out of tree (fast)",
"inherits": "linux-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Asan",
"CMAKE_C_FLAGS": "-O2",
"CMAKE_CXX_FLAGS": "-O2",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "linux-gcc-asan-ootree-full",
"displayName": "Linux x86_64: GCC / Asan / Out of tree (full)",
"inherits": ["default-full-configuration", "linux-gcc-asan-ootree-fast"]
},
{
"name": "linux-gcc-debug-ootree-skeleton-fast",
"displayName": "Linux x86_64: GCC / Debug / Skeleton / Out of tree (fast)",
"inherits": "linux-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_C_FLAGS": "-O2",
"CMAKE_CXX_FLAGS": "-O2",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "linux-gcc-debug-ootree-skeleton-full",
"displayName": "Linux x86_64: GCC / Debug / Skeleton / Out of tree (full)",
"inherits": ["default-full-configuration", "linux-gcc-debug-ootree-skeleton-fast"]
},
{
"name": "linux-gcc-debug-intree-m32-skeleton-fast",
"displayName": "Linux x86: GCC / Debug / Skeleton / In tree (fast)",
"inherits": "linux-config-base",
"binaryDir": "${sourceDir}",
"installDir": "${sourceDir}/install",
"architecture": {
"value": "x86",
"strategy": "external"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_C_FLAGS": "-O2 -m32",
"CMAKE_CXX_FLAGS": "-O2 -m32",
"CMAKE_EXE_LINKER_FLAGS": "-m32",
"CMAKE_SHARED_LINKER_FLAGS": "-m32",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "linux-gcc-debug-intree-m32-skeleton-full",
"displayName": "Linux x86: GCC / Debug / Skeleton / In tree (full)",
"inherits": ["default-full-configuration", "linux-gcc-debug-intree-m32-skeleton-fast"]
},
{
"name": "linux-gcc-release-ootree-skeleton-fast",
"displayName": "Linux x86_64: GCC / Release / Skeleton / Out of tree (fast)",
"inherits": "linux-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "linux-gcc-release-ootree-skeleton-full",
"displayName": "Linux x86_64: GCC / Release / Skeleton / Out of tree (full)",
"inherits": ["default-full-configuration", "linux-gcc-release-ootree-skeleton-fast"]
},
{
"name": "macos-config-base",
"hidden": true,
"generator": "Unix Makefiles",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Darwin"
},
"architecture": {
"value": "x64",
"strategy": "external"
},
"cacheVariables": {
"CMAKE_C_COMPILER": "clang",
"CMAKE_CXX_COMPILER": "clang++"
}
},
{
"name": "macos-clang-debug-ootree-skeleton-fast",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / Out of tree (fast)",
"inherits": "macos-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_C_FLAGS": "-O2",
"CMAKE_CXX_FLAGS": "-O2",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "macos-clang-debug-ootree-skeleton-full",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / Out of tree (full)",
"inherits": ["default-full-configuration", "macos-clang-debug-ootree-skeleton-fast"]
},
{
"name": "macos-clang-debug-intree-skeleton-fast",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / In tree (fast)",
"inherits": "macos-config-base",
"binaryDir": "${sourceDir}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_C_FLAGS": "-O2",
"CMAKE_CXX_FLAGS": "-O2",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "macos-clang-debug-intree-skeleton-full",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / In tree (full)",
"inherits": ["default-full-configuration", "macos-clang-debug-intree-skeleton-fast"]
},
{
"name": "macos-clang-release-ootree-skeleton-fast",
"displayName": "macOS x86_64: CLang / Release / Skeleton / Out of tree (fast)",
"inherits": "macos-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "macos-clang-release-ootree-skeleton-full",
"displayName": "macOS x86_64: CLang / Release / Skeleton / Out of tree (full)",
"inherits": ["default-full-configuration", "macos-clang-release-ootree-skeleton-fast"]
},
{
"name": "windows-config-base",
"hidden": true,
"generator": "Visual Studio 16 2019",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Windows"
},
"architecture": {
"value": "x64",
"strategy": "external"
},
"cacheVariables": {
"CMAKE_C_COMPILER": "cl",
"CMAKE_CXX_COMPILER": "cl"
}
},
{
"name": "windows-msvc-debug-ootree-fast",
"displayName": "Windows x86_64: MSVC / Debug / Out of tree (fast)",
"inherits": "windows-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "windows-msvc-debug-ootree-full",
"displayName": "Windows x86_64: MSVC / Debug / Out of tree (full)",
"inherits": ["default-full-configuration", "windows-msvc-debug-ootree-fast"],
"cacheVariables": {
"RE2C_REBUILD_DOCS": false
}
},
{
"name": "windows-msvc-debug-intree-fast",
"displayName": "Windows x86_64: MSVC / Debug / In tree (fast)",
"inherits": "windows-config-base",
"binaryDir": "${sourceDir}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "windows-msvc-debug-intree-full",
"displayName": "Windows x86_64: MSVC / Debug / In tree (full)",
"inherits": ["default-full-configuration", "windows-msvc-debug-intree-fast"],
"cacheVariables": {
"RE2C_REBUILD_DOCS": false
}
},
{
"name": "windows-msvc-release-ootree-fast",
"displayName": "Windows x86_64: MSVC / Release / Out of tree (fast)",
"inherits": "windows-config-base",
"binaryDir": "${sourceDir}/.build/${presetName}",
"installDir": "${sourceDir}/install",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"RE2C_BUILD_RE2GO": false
}
},
{
"name": "windows-msvc-release-ootree-full",
"displayName": "Windows x86_64: MSVC / Release / Out of tree (full)",
"inherits": ["default-full-configuration", "windows-msvc-release-ootree-fast"],
"cacheVariables": {
"RE2C_REBUILD_DOCS": false
}
}
],
"buildPresets": [
{
"name": "linux-build-base",
"hidden": true,
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Linux"
}
},
{
"name": "linux-gcc-ubsan-ootree-fast",
"displayName": "Linux x86_64: GCC / Ubsan / Out of tree (fast)",
"configurePreset": "linux-gcc-ubsan-ootree-fast",
"inherits": "linux-build-base",
"configuration": "Ubsan"
},
{
"name": "linux-gcc-ubsan-ootree-full",
"displayName": "Linux x86_64: GCC / Ubsan / Out of tree (full)",
"configurePreset": "linux-gcc-ubsan-ootree-full",
"inherits": "linux-build-base",
"configuration": "Ubsan"
},
{
"name": "linux-gcc-asan-ootree-fast",
"displayName": "Linux x86_64: GCC / Asan / Out of tree (fast)",
"configurePreset": "linux-gcc-asan-ootree-fast",
"inherits": "linux-build-base",
"configuration": "Asan"
},
{
"name": "linux-gcc-asan-ootree-full",
"displayName": "Linux x86_64: GCC / Asan / Out of tree (full)",
"configurePreset": "linux-gcc-asan-ootree-full",
"inherits": "linux-build-base",
"configuration": "Asan"
},
{
"name": "linux-gcc-debug-ootree-skeleton-fast",
"displayName": "Linux x86_64: GCC / Debug / Skeleton / Out of tree (fast)",
"configurePreset": "linux-gcc-debug-ootree-skeleton-fast",
"inherits": "linux-build-base",
"configuration": "Debug"
},
{
"name": "linux-gcc-debug-ootree-skeleton-full",
"displayName": "Linux x86_64: GCC / Debug / Skeleton / Out of tree (full)",
"configurePreset": "linux-gcc-debug-ootree-skeleton-full",
"inherits": "linux-build-base",
"configuration": "Debug"
},
{
"name": "linux-gcc-debug-intree-m32-skeleton-fast",
"displayName": "Linux x86: GCC / Debug / Skeleton / In tree (fast)",
"configurePreset": "linux-gcc-debug-intree-m32-skeleton-fast",
"inherits": "linux-build-base",
"configuration": "Debug"
},
{
"name": "linux-gcc-debug-intree-m32-skeleton-full",
"displayName": "Linux x86: GCC / Debug / Skeleton / In tree (full)",
"configurePreset": "linux-gcc-debug-intree-m32-skeleton-full",
"inherits": "linux-build-base",
"configuration": "Debug"
},
{
"name": "linux-gcc-release-ootree-skeleton-fast",
"displayName": "Linux x86_64: GCC / Release / Skeleton / Out of tree (fast)",
"configurePreset": "linux-gcc-release-ootree-skeleton-fast",
"inherits": "linux-build-base",
"configuration": "Release"
},
{
"name": "linux-gcc-release-ootree-skeleton-full",
"displayName": "Linux x86_64: GCC / Release / Skeleton / Out of tree (full)",
"configurePreset": "linux-gcc-release-ootree-skeleton-full",
"inherits": "linux-build-base",
"configuration": "Release"
},
{
"name": "macos-build-base",
"hidden": true,
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Darwin"
}
},
{
"name": "macos-clang-debug-ootree-skeleton-fast",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / Out of tree (fast)",
"configurePreset": "macos-clang-debug-ootree-skeleton-fast",
"inherits": "macos-build-base",
"configuration": "Debug"
},
{
"name": "macos-clang-debug-ootree-skeleton-full",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / Out of tree (full)",
"configurePreset": "macos-clang-debug-ootree-skeleton-full",
"inherits": "macos-build-base",
"configuration": "Debug"
},
{
"name": "macos-clang-debug-intree-skeleton-fast",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / In tree (fast)",
"configurePreset": "macos-clang-debug-intree-skeleton-fast",
"inherits": "macos-build-base",
"configuration": "Debug"
},
{
"name": "macos-clang-debug-intree-skeleton-full",
"displayName": "macOS x86_64: Clang / Debug / Skeleton / In tree (full)",
"configurePreset": "macos-clang-debug-intree-skeleton-full",
"inherits": "macos-build-base",
"configuration": "Debug"
},
{
"name": "macos-clang-release-ootree-skeleton-fast",
"displayName": "macOS x86_64: CLang / Release / Skeleton / Out of tree (fast)",
"configurePreset": "macos-clang-release-ootree-skeleton-fast",
"inherits": "macos-build-base",
"configuration": "Release"
},
{
"name": "macos-clang-release-ootree-skeleton-full",
"displayName": "macOS x86_64: CLang / Release / Skeleton / Out of tree (full)",
"configurePreset": "macos-clang-release-ootree-skeleton-full",
"inherits": "macos-build-base",
"configuration": "Release"
},
{
"name": "windows-build-base",
"hidden": true,
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Windows"
}
},
{
"name": "windows-msvc-debug-ootree-fast",
"displayName": "Windows x86_64: MSVC / Debug / Out of tree (fast)",
"configurePreset": "windows-msvc-debug-ootree-fast",
"inherits": "windows-build-base",
"configuration": "Debug"
},
{
"name": "windows-msvc-debug-ootree-full",
"displayName": "Windows x86_64: MSVC / Debug / Out of tree (full)",
"configurePreset": "windows-msvc-debug-ootree-full",
"inherits": "windows-build-base",
"configuration": "Debug"
},
{
"name": "windows-msvc-debug-intree-fast",
"displayName": "Windows x86_64: MSVC / Debug / In tree (fast)",
"configurePreset": "windows-msvc-debug-intree-fast",
"inherits": "windows-build-base",
"configuration": "Debug"
},
{
"name": "windows-msvc-debug-intree-full",
"displayName": "Windows x86_64: MSVC / Debug / In tree (full)",
"configurePreset": "windows-msvc-debug-intree-full",
"inherits": "windows-build-base",
"configuration": "Debug"
},
{
"name": "windows-msvc-release-ootree-fast",
"displayName": "Windows x86_64: MSVC / Release / Out of tree (fast)",
"configurePreset": "windows-msvc-release-ootree-fast",
"inherits": "windows-build-base",
"configuration": "Release"
},
{
"name": "windows-msvc-release-ootree-full",
"displayName": "Windows x86_64: MSVC / Release / Out of tree (full)",
"configurePreset": "windows-msvc-release-ootree-full",
"inherits": "windows-build-base",
"configuration": "Release"
}
]
}
+19 -10
View File
@@ -18,10 +18,11 @@ noinst_PROGRAMS =
# sources
re2c_HDR = \
src/constants.h \
src/codegen/code.h \
src/codegen/helpers.h \
src/options/opt.h \
src/adfa/action.h \
src/options/symtab.h \
src/adfa/adfa.h \
src/cfg/cfg.h \
src/dfa/closure_leftmost.h \
@@ -47,7 +48,6 @@ re2c_HDR = \
src/msg/msg.h \
src/msg/ver_to_vernum.h \
src/msg/warn.h \
src/regexp/empty_class_policy.h \
src/regexp/re.h \
src/regexp/rule.h \
src/regexp/tag.h \
@@ -64,10 +64,10 @@ re2c_HDR = \
src/util/allocate.h \
src/util/attribute.h \
src/util/c99_stdint.h \
src/util/file_utils.h \
src/util/fixed_allocator.h \
src/util/forbid_copy.h \
src/util/free_list.h \
src/util/get_dir.h \
src/util/hash32.h \
src/util/local_increment.h \
src/util/lookup.h \
@@ -92,10 +92,10 @@ re2c_SRC = \
src/codegen/helpers.cc \
src/codegen/render.cc \
src/options/opt.cc \
src/options/symtab.cc \
src/nfa/estimate_size.cc \
src/nfa/re_to_nfa.cc \
src/adfa/adfa.cc \
src/adfa/prepare.cc \
src/debug/dump_adfa.cc \
src/debug/dump_cfg.cc \
src/debug/dump_dfa.cc \
@@ -135,6 +135,7 @@ re2c_SRC = \
src/regexp/default_tags.cc \
src/regexp/fixed_tags.cc \
src/regexp/nullable.cc \
src/regexp/re.cc \
src/regexp/rule.cc \
src/regexp/split_charset.cc \
src/regexp/tag.cc \
@@ -146,11 +147,10 @@ re2c_SRC = \
src/skeleton/skeleton.cc \
src/parse/ast.cc \
src/parse/input.cc \
src/parse/normalize.cc \
src/parse/parse.cc \
src/parse/scanner.cc \
src/parse/unescape.cc \
src/parse/validate.cc \
src/util/get_dir.cc \
src/util/file_utils.cc \
src/util/s_to_n32_unsafe.cc \
src/util/temp_file.cc \
src/util/range.cc
@@ -215,7 +215,6 @@ re2c_CUSTOM = \
# docs
re2c_SRC_DOC = doc/manpage.rst
re2c_SRC_DOC_EXT = \
doc/manual/api/api.rst_ \
doc/manual/api/interface.rst_ \
doc/manual/conditions/conditions.rst_ \
doc/manual/configurations/configurations.rst_ \
@@ -245,6 +244,10 @@ re2c_SRC_DOC_EXT = \
doc/manual/submatch/submatch_example_stags_fill.rst_ \
doc/manual/submatch/submatch.rst_ \
doc/manual/syntax/syntax.rst_ \
doc/manual/syntax/api1.rst_ \
doc/manual/syntax/api2_c.rst_ \
doc/manual/syntax/api2_go.rst_ \
doc/manual/syntax/api3.rst_ \
doc/manual/warnings/warnings_general.rst_ \
doc/manual/warnings/warnings_list.rst_ \
examples/c/01_basic.re \
@@ -261,6 +264,7 @@ re2c_SRC_DOC_EXT = \
examples/c/includes/include.re \
examples/c/includes/definitions.h \
examples/c/reuse/reuse.re \
examples/c/reuse/usedir.re \
examples/c/state/push.re \
examples/c/submatch/01_stags.re \
examples/c/submatch/01_stags_fill.re \
@@ -280,6 +284,7 @@ re2c_SRC_DOC_EXT = \
examples/go/includes/include.re \
examples/go/includes/definitions.go \
examples/go/reuse/reuse.re \
examples/go/reuse/usedir.re \
examples/go/state/push.re \
examples/go/submatch/01_stags.re \
examples/go/submatch/02_mtags.re \
@@ -296,17 +301,21 @@ man_MANS = $(DOCS)
# include files (stdlib)
dist_stdlib_DATA = include/unicode_categories.re
CMAKEFILES := \
CMakeLists.txt \
cmake
EXTRA_DIST = \
$(re2c_BOOT) \
$(re2c_CUSTOM) \
$(re2c_SRC_DOC_EXT) \
$(CMAKEFILES) \
CHANGELOG \
LICENSE \
NO_WARRANTY \
README.md \
autogen.sh \
build \
cmake \
examples \
test
@@ -402,7 +411,7 @@ endif
all-local: docs $(re2c_BOOT_PARSER)
# tests
re2c_TESTSUITE = run_tests.sh
re2c_TESTSUITE = run_tests.py
.PHONY: tests
tests: all $(re2c_TESTSUITE)
$(top_builddir)/$(re2c_TESTSUITE)
+18 -5
View File
@@ -10,9 +10,11 @@ libre2c_la_HDR = \
lib/regcomp_dfa_regless.h \
lib/regex.h \
lib/regex_impl.h \
lib/regoff_trie.h \
src/constants.h \
src/codegen/code.h \
src/options/opt.h \
src/adfa/action.h \
src/options/symtab.h \
src/adfa/adfa.h \
src/cfg/cfg.h \
src/dfa/closure_leftmost.h \
@@ -38,7 +40,6 @@ libre2c_la_HDR = \
src/msg/msg.h \
src/msg/ver_to_vernum.h \
src/msg/warn.h \
src/regexp/empty_class_policy.h \
src/regexp/re.h \
src/regexp/rule.h \
src/regexp/tag.h \
@@ -55,9 +56,9 @@ libre2c_la_HDR = \
src/util/allocate.h \
src/util/attribute.h \
src/util/c99_stdint.h \
src/util/file_utils.h \
src/util/forbid_copy.h \
src/util/free_list.h \
src/util/get_dir.h \
src/util/hash32.h \
src/util/local_increment.h \
src/util/lookup.h \
@@ -86,6 +87,7 @@ libre2c_la_SRC = \
src/parse/ast.cc \
src/parse/unescape.cc \
src/options/opt.cc \
src/options/symtab.cc \
src/cfg/cfg.cc \
src/cfg/compact.cc \
src/cfg/dce.cc \
@@ -127,6 +129,7 @@ libre2c_la_SRC = \
src/regexp/default_tags.cc \
src/regexp/fixed_tags.cc \
src/regexp/nullable.cc \
src/regexp/re.cc \
src/regexp/rule.cc \
src/regexp/split_charset.cc \
src/regexp/tag.cc \
@@ -143,11 +146,13 @@ libre2c_la_SOURCES = \
libre2c_la_CUSTOM = \
lib/lex.re \
lib/parse.ypp \
lib/test_helper.re \
src/msg/ver_to_vernum.re
libre2c_la_GEN_SRC = \
lib/lex.cc \
lib/parse.cc \
lib/test_helper.cc \
src/msg/ver_to_vernum.cc
libre2c_la_GEN_HDR = \
lib/parse.h
@@ -162,6 +167,7 @@ libre2c_la_BOOTSTRAP = \
bootstrap/lib/parse.cc \
bootstrap/lib/parse.h \
bootstrap/lib/lex.cc \
bootstrap/lib/test_helper.cc \
bootstrap/src/msg/ver_to_vernum.cc
nodist_libre2c_la_SOURCES = $(libre2c_la_GEN)
@@ -176,7 +182,10 @@ CLEANFILES += $(libre2c_la_GEN)
lib/lex.cc: lib/parse.cc
# tests
test_libre2c_SOURCES = lib/test.cc
test_libre2c_SOURCES = \
lib/test.cc \
lib/test_helper.h \
lib/test_helper.cc
test_libre2c_LDADD = libre2c.la
check_PROGRAMS += test_libre2c
@@ -186,4 +195,8 @@ SUBDIRS += benchmarks/submatch_nfa
SUBDIRS += benchmarks/submatch_dfa_jit
EXTRA_DIST += benchmarks/submatch_nfa
EXTRA_DIST += benchmarks/submatch_dfa_jit
endif
if WITH_JAVA
SUBDIRS += benchmarks/submatch_java
EXTRA_DIST += benchmarks/submatch_java
endif # WITH_JAVA
endif # WITH_BENCHMARKS
+5 -5
View File
@@ -40,15 +40,14 @@ CONTRIBUTING
------------
re2c is an Open Source, community-driven project. See
[CONTRIBUTING.md](https://github.com/skvadrik/re2c/blob/master/README.md) for
[CONTRIBUTING.md](https://github.com/skvadrik/re2c/blob/master/CONTRIBUTING.md) for
details about contributions to this repository.
BUILD
-----
re2c has two build systems: Autotools and CMake. Both are maintained and tested
on Travis CI. See [the documentation](http://re2c.org/install/install.html) for
See BUILD.md or the [online docs](https://re2c.org/build/build.html) for
instructions how to build re2c.
@@ -64,9 +63,10 @@ Mailing lists:
- re2c-general@lists.sourceforge.net
- re2c-devel@lists.sourceforge.net
IRC channel:
IRC channels:
- freenode/#re2c
- irc.oftc.net/#re2c
- irc.libera.chat/#re2c
You are welcome to ask for help or share your thoughts and ideas.
+16 -4
View File
@@ -46,12 +46,24 @@ void bench_regexec_re2c(benchmark::State& state, const alg_t &alg, const bench_t
state.SkipWithError("regcomp failed");
}
const bool with_hist = alg.flags & REG_SUBHIST;
const size_t nmatch = re.re_nsub;
regmatch_t *pmatch = new regmatch_t[nmatch];
regmatch_t *pmatch = with_hist ? NULL : new regmatch_t[nmatch];
for (auto _ : state) {
for (const char **strings = bench.strings; *strings; ++strings) {
err |= regexec(&re, *strings, nmatch, pmatch, 0);
// Do not move condition inside of the loop to avoid overhead.
if (with_hist) {
for (auto _ : state) {
for (const char **strings = bench.strings; *strings; ++strings) {
subhistory_t *h = regparse(&re, *strings, nmatch);
err |= h ? 0 : 1;
regfreesub(h);
}
}
} else {
for (auto _ : state) {
for (const char **strings = bench.strings; *strings; ++strings) {
err |= regexec(&re, *strings, nmatch, pmatch, 0);
}
}
}
if (err) {
+67 -14
View File
@@ -2,16 +2,40 @@
import argparse
import json
import math
import sys
from collections import OrderedDict
plot_begin = """
plot_preamble = """
\\documentclass[tikz]{standalone}
\\usepackage[utf8]{inputenc}
\\usepackage{amsmath, amssymb, amsfonts}
\\usepackage{tikz, pgfplots, pgfplotstable}
"""
# Use Comic Neue font.
plot_font_comicneue = """
\\usepackage{comicneue}
\\usepackage[T1]{fontenc}
\\renewcommand{\\familydefault}{\\sfdefault}
"""
# Use Computer Modern Bright font.
plot_font_cmbright = """
\\usepackage{cmbright}
\\usepackage[T1]{fontenc}
\\renewcommand{\\familydefault}{\\sfdefault}
"""
# Counterintuitively, 'assume math mode' tricks pgfmathprintnumber into not
# setting math mode, which is needed because Comic Neue does not support math.
#
# Use 'fixed relative' number format with very high precision (the numbers have
# been previously rounded to a few non-zero digits in the fractional part, so
# the trailing zeroes will will not be printed).
plot_begin = """
\\begin{document}
\\def\\plotwidth{%lfin}
@@ -22,7 +46,6 @@ plot_begin = """
xbar,
axis y line*=none,
axis x line=none,
nodes near coords style={/pgf/number format/.cd,1000 sep={\\,}},
y=0.12in,
width=(\\plotwidth * 0.75),
bar width=\\barwidth,
@@ -39,21 +62,24 @@ plot_begin = """
clip=false,
visualization depends on={x > \\xmax \\as \\xoverflow},
visualization depends on={x > \\xmax ? -x + \\xmax : 0 \\as \\xshift},
every node near coord/.style={shift={(axis direction cs:\\xshift,0)}},
nodes near coords={
\\ifdim \\xoverflow pt=1pt \\!\\Large{...}\\scriptsize\\! \\fi
\\pgfmathprintnumber{\\pgfplotspointmeta}
\\pgfmathprintnumber[assume math mode=true]{\\pgfplotspointmeta}
},
nodes near coords style={shift={(axis direction cs:\\xshift,0)}},
nodes near coords style={/pgf/number format/.cd,
fixed relative,
precision = 10,
1000 sep = {\\,}
},
}}
"""
plot_begin_picture = """
\\begin{tikzpicture}
\\def\\xmax{%lf}
"""
plot_middle = """
\\def\\xplotshift{%lfin}
\\def\\yplotshift{%lfin}
@@ -68,12 +94,10 @@ plot_middle = """
\\end{axis}
"""
plot_end_picture = """
\\end{tikzpicture}
"""
plot_end = """
\\end{document}
"""
@@ -85,6 +109,8 @@ def parse_args():
parser.add_argument("output", help="output TeX file")
parser.add_argument("--relative-to",
help="output CPU time relative to the specified algorithm")
parser.add_argument("--font",
help="use the specified font (supported fonts: cmbright, comicneue)")
return parser.parse_args()
@@ -118,6 +144,20 @@ def index_of_algo(group, stem):
return 0
# Time format: keep integer part precise, round fractional part relative to the
# exponent (similar to PGFPLOTS's "fixed relative, precision = 2" numer format,
# but doesn't round integer part). This is to reduce visual noise on the plot.
#
# Examples: 1004, 195, 13, 3.8, 0.85, 0.017, 0.0048
#
def time_format(time):
order = math.floor(math.log(time, 10))
if order > 0:
return '%.0lf'
else:
return '%%.%dlf' % (-order + 1)
# Split benchmarks into groups by regexp (the first component of the name).
# If the relative mode is on, normalize CPU time by the time of the first
# benchmark in each group.
@@ -169,7 +209,7 @@ def group_benchmarks(benchmarks, relative_to):
time = time / (cputime0 if relative_to != None else 1)
maxtime = max(maxtime, time)
avgtime += time
table += '{%s} %lf\n' % (algo, time)
table += ('{%s} ' + time_format(time) + '\n') % (algo, time)
timetbl = table
sizetbl = None
@@ -183,7 +223,7 @@ def group_benchmarks(benchmarks, relative_to):
title = gen_title(name)
nrows = len(group)
benchgroups[title] = (timetbl, sizetbl, nrows, captures, regsize)
benchgroups[title] = (timetbl, sizetbl, nrows, regsize, captures)
nbench += nrows
maxrows = max(maxrows, nrows)
@@ -198,7 +238,7 @@ def group_benchmarks(benchmarks, relative_to):
# Generate a Tikz picture with a PGF plot for each benchmark group. Crop
# very long bars, so that they do not squash other bars to the left.
def generate_plot(groups):
def generate_plot(groups, font):
(benchgroups, maxtime, maxsize, maxrows) = groups
# Plot width is approximately half the usual page width.
@@ -220,7 +260,9 @@ def generate_plot(groups):
yshift = -plotheight * (i if even else i - 1)
title = '\\textbf{%s}' % name
if regsize != None and captures != None:
title += ' \\, (%d sym, %d cap)' % (regsize, captures)
title += ' \\, (%d symbol%s, %d capture%s)' % (
regsize, 's' if regsize > 1 else '',
captures, 's' if captures > 1 else '')
# Generate CPU time plots.
if timetbl != None:
@@ -231,11 +273,22 @@ def generate_plot(groups):
plot_size += plot_middle % (xshift, yshift, nrows, title, sizetbl)
# Glue plots together in one TeX document
plot = plot_begin % (plotwidth, barwidth)
plot = plot_preamble
if font == 'comicneue':
plot += plot_font_comicneue
elif font == 'cmbright':
plot += plot_font_cmbright
elif font != None:
sys.exit('error: unsupported font: "%s"' % font)
plot += plot_begin % (plotwidth, barwidth)
if plot_time != '':
plot += (plot_begin_picture % maxtime) + plot_time + plot_end_picture
if plot_size != '':
plot += (plot_begin_picture % maxsize) + plot_size + plot_end_picture
plot += plot_end
return plot
@@ -248,7 +301,7 @@ def main():
input = json.load(f)
groups = group_benchmarks(input['benchmarks'], args.relative_to)
plot = generate_plot(groups)
plot = generate_plot(groups, args.font)
with open(args.output, 'w') as f:
f.write(plot)
+1 -1
View File
@@ -127,7 +127,7 @@ endforeach()
# re2c
file(MAKE_DIRECTORY "${GEN_DIR}/re2c/")
set(RE2C "${CMAKE_BINARY_DIR}/re2c")
set(RE2C_FLAGS "--reusable" "--tags" "--no-generation-date")
set(RE2C_FLAGS "--reusable" "--tags" "--no-generation-date" "--no-version")
set(COMMON_RE2C
"${SRC_DIR}/re2c/common.re"
"${SRC_DIR}/re2c/include/fill.re"
+2 -1
View File
@@ -8,7 +8,7 @@ CFLAGS = -O3 -I $(SRC_DIR)
RAGEL = $(ENG_DIR)/ragel/ragel7
KLEENEX = $(ENG_DIR)/kleenex/kexc
RE2C = $(top_builddir)/re2c
RE2C_FLAGS_COMMON = --reusable --tags --no-generation-date
RE2C_FLAGS_COMMON = --reusable --tags --no-generation-date --no-version
RE2C_FLAGS = $(RE2C_FLAGS_COMMON) -I $(SRC_DIR)/re2c/include
RE2C_FLAGS_EOF = $(RE2C_FLAGS_COMMON) -I $(SRC_DIR)/re2c/include-eof
@@ -181,6 +181,7 @@ $(DAT): $(DAT_DIR)/%/big: $(DAT_DIR)/%/small
$(AM_V_GEN)( cd $(@D) && ../../$(srcdir)/data/gen.py )
$(KLEENEX):
$(AM_V_at)mkdir -p $(@D) && cp $(srcdir)/engines/kleenex/getkleenex.sh $(@D)
$(AM_V_GEN)( cd $(@D) && ./getkleenex.sh )
$(RAGEL):
@@ -5,8 +5,8 @@ if [ -e ragel7 ] ; then
exit 0
fi
COLM_DIR=colm-0.13.0.7
RAGEL_DIR=ragel-7.0.0.12
COLM_DIR=colm-0.14.7
RAGEL_DIR=ragel-7.0.4
wget http://www.colm.net/files/colm/"$COLM_DIR".tar.gz -O - | tar zx \
&& cd "$COLM_DIR" \
@@ -17,7 +17,10 @@ wget http://www.colm.net/files/colm/"$COLM_DIR".tar.gz -O - | tar zx \
wget http://www.colm.net/files/ragel/"$RAGEL_DIR".tar.gz -O - | tar zx \
&& cd "$RAGEL_DIR" \
&& ./configure --prefix=$(pwd)/install --with-colm="$(pwd)/../$COLM_DIR/install" \
&& ./configure \
--prefix=$(pwd)/install \
--with-colm="$(pwd)/../$COLM_DIR/install" \
--disable-manual \
&& make -j$(nproc) \
&& make install \
&& cd ..
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -39,8 +39,6 @@ static void lex(Input *in, Output *out)
#line 41 "gen/ragel/04__apache_log.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 25:
goto st_case_25;
@@ -95,13 +93,12 @@ static void lex(Input *in, Output *out)
case 24:
goto st_case_24;
}
goto st_out;
_ctr41:
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
g2 = p; }
#line 105 "gen/ragel/04__apache_log.c"
#line 102 "gen/ragel/04__apache_log.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
@@ -118,40 +115,37 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 122 "gen/ragel/04__apache_log.c"
#line 119 "gen/ragel/04__apache_log.c"
goto _st25;
_st25:
p+= 1;
if ( p == pe )
goto _test_eof25;
st_case_25:
if ( p == pe )
goto _out25;
if ( ( (*( p))) == 46 ) {
goto _ctr44;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr44;
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr44:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
h1 = p; }
#line 148 "gen/ragel/04__apache_log.c"
#line 142 "gen/ragel/04__apache_log.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 9: {
goto _ctr2;
@@ -166,22 +160,20 @@ static void lex(Input *in, Output *out)
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st1;
}
{
goto _st0;
}
goto _st0;
_ctr2:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
h2 = p; }
#line 178 "gen/ragel/04__apache_log.c"
#line 170 "gen/ragel/04__apache_log.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 9: {
goto _st2;
@@ -193,22 +185,20 @@ static void lex(Input *in, Output *out)
goto _ctr4;
}
}
{
goto _st0;
}
goto _st0;
_ctr4:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
i1 = p; }
#line 205 "gen/ragel/04__apache_log.c"
#line 195 "gen/ragel/04__apache_log.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 9: {
goto _ctr6;
@@ -217,22 +207,20 @@ static void lex(Input *in, Output *out)
goto _ctr6;
}
}
{
goto _st0;
}
goto _st0;
_ctr6:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
i2 = p; }
#line 229 "gen/ragel/04__apache_log.c"
#line 217 "gen/ragel/04__apache_log.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 9: {
goto _st4;
@@ -244,22 +232,20 @@ static void lex(Input *in, Output *out)
goto _ctr8;
}
}
{
goto _st0;
}
goto _st0;
_ctr8:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
a1 = p; }
#line 256 "gen/ragel/04__apache_log.c"
#line 242 "gen/ragel/04__apache_log.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 9: {
goto _ctr10;
@@ -268,22 +254,20 @@ static void lex(Input *in, Output *out)
goto _ctr10;
}
}
{
goto _st0;
}
goto _st0;
_ctr10:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
a2 = p; }
#line 280 "gen/ragel/04__apache_log.c"
#line 264 "gen/ragel/04__apache_log.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
switch( ( (*( p))) ) {
case 9: {
goto _st6;
@@ -295,22 +279,20 @@ static void lex(Input *in, Output *out)
goto _ctr12;
}
}
{
goto _st0;
}
goto _st0;
_ctr12:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
d1 = p; }
#line 307 "gen/ragel/04__apache_log.c"
#line 289 "gen/ragel/04__apache_log.c"
goto _st7;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
switch( ( (*( p))) ) {
case 10: {
goto _st0;
@@ -319,14 +301,12 @@ static void lex(Input *in, Output *out)
goto _st0;
}
}
{
goto _st8;
}
goto _st8;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 10: {
goto _st0;
@@ -335,14 +315,12 @@ static void lex(Input *in, Output *out)
goto _st9;
}
}
{
goto _st8;
}
goto _st8;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
switch( ( (*( p))) ) {
case 9: {
goto _ctr16;
@@ -351,22 +329,20 @@ static void lex(Input *in, Output *out)
goto _ctr16;
}
}
{
goto _st0;
}
goto _st0;
_ctr16:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
d2 = p; }
#line 363 "gen/ragel/04__apache_log.c"
#line 339 "gen/ragel/04__apache_log.c"
goto _st10;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
switch( ( (*( p))) ) {
case 9: {
goto _st10;
@@ -378,22 +354,20 @@ static void lex(Input *in, Output *out)
goto _ctr18;
}
}
{
goto _st0;
}
goto _st0;
_ctr18:
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
r1 = p; }
#line 390 "gen/ragel/04__apache_log.c"
#line 364 "gen/ragel/04__apache_log.c"
goto _st11;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
switch( ( (*( p))) ) {
case 10: {
goto _st0;
@@ -402,14 +376,12 @@ static void lex(Input *in, Output *out)
goto _st0;
}
}
{
goto _st12;
}
goto _st12;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
switch( ( (*( p))) ) {
case 10: {
goto _st0;
@@ -418,14 +390,12 @@ static void lex(Input *in, Output *out)
goto _st13;
}
}
{
goto _st12;
}
goto _st12;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
switch( ( (*( p))) ) {
case 9: {
goto _ctr22;
@@ -434,22 +404,20 @@ static void lex(Input *in, Output *out)
goto _ctr22;
}
}
{
goto _st0;
}
goto _st0;
_ctr22:
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
r2 = p; }
#line 446 "gen/ragel/04__apache_log.c"
#line 414 "gen/ragel/04__apache_log.c"
goto _st14;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
switch( ( (*( p))) ) {
case 9: {
goto _st14;
@@ -461,22 +429,20 @@ static void lex(Input *in, Output *out)
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr24;
}
{
goto _st0;
}
goto _st0;
_ctr24:
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
s1 = p; }
#line 473 "gen/ragel/04__apache_log.c"
#line 439 "gen/ragel/04__apache_log.c"
goto _st15;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
if ( p == pe )
goto _out15;
switch( ( (*( p))) ) {
case 9: {
goto _ctr26;
@@ -488,22 +454,20 @@ static void lex(Input *in, Output *out)
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st15;
}
{
goto _st0;
}
goto _st0;
_ctr26:
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
s2 = p; }
#line 500 "gen/ragel/04__apache_log.c"
#line 464 "gen/ragel/04__apache_log.c"
goto _st16;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
switch( ( (*( p))) ) {
case 9: {
goto _st16;
@@ -518,22 +482,20 @@ static void lex(Input *in, Output *out)
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr29;
}
{
goto _st0;
}
goto _st0;
_ctr28:
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
z1 = p; }
#line 530 "gen/ragel/04__apache_log.c"
#line 492 "gen/ragel/04__apache_log.c"
goto _st17;
_st17:
p+= 1;
if ( p == pe )
goto _test_eof17;
st_case_17:
if ( p == pe )
goto _out17;
switch( ( (*( p))) ) {
case 9: {
goto _ctr31;
@@ -542,22 +504,20 @@ static void lex(Input *in, Output *out)
goto _ctr31;
}
}
{
goto _st0;
}
goto _st0;
_ctr31:
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
z2 = p; }
#line 554 "gen/ragel/04__apache_log.c"
#line 514 "gen/ragel/04__apache_log.c"
goto _st18;
_st18:
p+= 1;
if ( p == pe )
goto _test_eof18;
st_case_18:
if ( p == pe )
goto _out18;
switch( ( (*( p))) ) {
case 9: {
goto _st18;
@@ -569,22 +529,20 @@ static void lex(Input *in, Output *out)
goto _ctr33;
}
}
{
goto _st0;
}
goto _st0;
_ctr33:
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
u1 = p; }
#line 581 "gen/ragel/04__apache_log.c"
#line 539 "gen/ragel/04__apache_log.c"
goto _st19;
_st19:
p+= 1;
if ( p == pe )
goto _test_eof19;
st_case_19:
if ( p == pe )
goto _out19;
switch( ( (*( p))) ) {
case 10: {
goto _st0;
@@ -593,14 +551,12 @@ static void lex(Input *in, Output *out)
goto _st20;
}
}
{
goto _st19;
}
goto _st19;
_st20:
p+= 1;
if ( p == pe )
goto _test_eof20;
st_case_20:
if ( p == pe )
goto _out20;
switch( ( (*( p))) ) {
case 9: {
goto _ctr36;
@@ -609,22 +565,20 @@ static void lex(Input *in, Output *out)
goto _ctr36;
}
}
{
goto _st0;
}
goto _st0;
_ctr36:
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
u2 = p; }
#line 621 "gen/ragel/04__apache_log.c"
#line 575 "gen/ragel/04__apache_log.c"
goto _st21;
_st21:
p+= 1;
if ( p == pe )
goto _test_eof21;
st_case_21:
if ( p == pe )
goto _out21;
switch( ( (*( p))) ) {
case 9: {
goto _st21;
@@ -636,22 +590,20 @@ static void lex(Input *in, Output *out)
goto _ctr38;
}
}
{
goto _st0;
}
goto _st0;
_ctr38:
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
g1 = p; }
#line 648 "gen/ragel/04__apache_log.c"
#line 600 "gen/ragel/04__apache_log.c"
goto _st22;
_st22:
p+= 1;
if ( p == pe )
goto _test_eof22;
st_case_22:
if ( p == pe )
goto _out22;
switch( ( (*( p))) ) {
case 10: {
goto _st0;
@@ -660,33 +612,29 @@ static void lex(Input *in, Output *out)
goto _st23;
}
}
{
goto _st22;
}
goto _st22;
_st23:
p+= 1;
if ( p == pe )
goto _test_eof23;
st_case_23:
if ( p == pe )
goto _out23;
if ( ( (*( p))) == 10 ) {
goto _ctr41;
}
{
goto _st0;
}
goto _st0;
_ctr29:
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/04__apache_log.rl"
z1 = p; }
#line 683 "gen/ragel/04__apache_log.c"
#line 631 "gen/ragel/04__apache_log.c"
goto _st24;
_st24:
p+= 1;
if ( p == pe )
goto _test_eof24;
st_case_24:
if ( p == pe )
goto _out24;
switch( ( (*( p))) ) {
case 9: {
goto _ctr31;
@@ -698,39 +646,33 @@ static void lex(Input *in, Output *out)
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st24;
}
{
goto _st0;
}
st_out:
_test_eof25: cs = 25; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof16: cs = 16; goto _test_eof;
_test_eof17: cs = 17; goto _test_eof;
_test_eof18: cs = 18; goto _test_eof;
_test_eof19: cs = 19; goto _test_eof;
_test_eof20: cs = 20; goto _test_eof;
_test_eof21: cs = 21; goto _test_eof;
_test_eof22: cs = 22; goto _test_eof;
_test_eof23: cs = 23; goto _test_eof;
_test_eof24: cs = 24; goto _test_eof;
_test_eof: {}
if ( cs >= 25 )
goto _out; _pop: {}
goto _st0;
_out25: cs = 25; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out16: cs = 16; goto _out;
_out17: cs = 17; goto _out;
_out18: cs = 18; goto _out;
_out19: cs = 19; goto _out;
_out20: cs = 20; goto _out;
_out21: cs = 21; goto _out;
_out22: cs = 22; goto _out;
_out23: cs = 23; goto _out;
_out24: cs = 24; goto _out;
_out: {}
}
@@ -39,8 +39,6 @@ static void lex(Input *in, Output *out)
#line 41 "gen/ragel/05__datetime.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 35:
goto st_case_35;
@@ -115,13 +113,12 @@ static void lex(Input *in, Output *out)
case 34:
goto st_case_34;
}
goto st_out;
_ctr43:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
z2 = p; }
#line 125 "gen/ragel/05__datetime.c"
#line 122 "gen/ragel/05__datetime.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
@@ -136,92 +133,81 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 140 "gen/ragel/05__datetime.c"
#line 137 "gen/ragel/05__datetime.c"
goto _st35;
_st35:
p+= 1;
if ( p == pe )
goto _test_eof35;
st_case_35:
if ( p == pe )
goto _out35;
if ( ( (*( p))) == 48 ) {
goto _ctr53;
}
if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr54;
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr53:
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
y1 = p; }
#line 166 "gen/ragel/05__datetime.c"
#line 160 "gen/ragel/05__datetime.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 45 ) {
goto _ctr5;
}
{
goto _st0;
}
goto _st0;
_ctr5:
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
y2 = p; }
#line 218 "gen/ragel/05__datetime.c"
#line 204 "gen/ragel/05__datetime.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 48: {
goto _ctr7;
@@ -230,52 +216,46 @@ static void lex(Input *in, Output *out)
goto _ctr8;
}
}
{
goto _st0;
}
goto _st0;
_ctr7:
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
m1 = p; }
#line 242 "gen/ragel/05__datetime.c"
#line 226 "gen/ragel/05__datetime.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 45 ) {
goto _ctr11;
}
{
goto _st0;
}
goto _st0;
_ctr11:
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
m2 = p; }
#line 272 "gen/ragel/05__datetime.c"
#line 252 "gen/ragel/05__datetime.c"
goto _st8;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 48: {
goto _ctr13;
@@ -287,183 +267,161 @@ static void lex(Input *in, Output *out)
if ( 49 <= ( (*( p))) && ( (*( p))) <= 50 ) {
goto _ctr14;
}
{
goto _st0;
}
goto _st0;
_ctr13:
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
d1 = p; }
#line 299 "gen/ragel/05__datetime.c"
#line 277 "gen/ragel/05__datetime.c"
goto _st9;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 84 ) {
goto _ctr18;
}
{
goto _st0;
}
goto _st0;
_ctr18:
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
d2 = p; }
#line 329 "gen/ragel/05__datetime.c"
#line 303 "gen/ragel/05__datetime.c"
goto _st11;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
if ( ( (*( p))) == 50 ) {
goto _ctr21;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 49 ) {
goto _ctr20;
}
{
goto _st0;
}
goto _st0;
_ctr20:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
h1 = p; }
#line 351 "gen/ragel/05__datetime.c"
#line 323 "gen/ragel/05__datetime.c"
goto _st12;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
if ( ( (*( p))) == 58 ) {
goto _ctr24;
}
{
goto _st0;
}
goto _st0;
_ctr24:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
h2 = p; }
#line 381 "gen/ragel/05__datetime.c"
#line 349 "gen/ragel/05__datetime.c"
goto _st14;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 53 ) {
goto _ctr26;
}
{
goto _st0;
}
goto _st0;
_ctr26:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
M1 = p; }
#line 400 "gen/ragel/05__datetime.c"
#line 366 "gen/ragel/05__datetime.c"
goto _st15;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
if ( p == pe )
goto _out15;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st16;
}
{
goto _st0;
}
goto _st0;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
if ( ( (*( p))) == 58 ) {
goto _ctr29;
}
{
goto _st0;
}
goto _st0;
_ctr29:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
M2 = p; }
#line 430 "gen/ragel/05__datetime.c"
#line 392 "gen/ragel/05__datetime.c"
goto _st17;
_st17:
p+= 1;
if ( p == pe )
goto _test_eof17;
st_case_17:
if ( p == pe )
goto _out17;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 53 ) {
goto _ctr31;
}
{
goto _st0;
}
goto _st0;
_ctr31:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
s1 = p; }
#line 449 "gen/ragel/05__datetime.c"
#line 409 "gen/ragel/05__datetime.c"
goto _st18;
_st18:
p+= 1;
if ( p == pe )
goto _test_eof18;
st_case_18:
if ( p == pe )
goto _out18;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st19;
}
{
goto _st0;
}
goto _st0;
_st19:
p+= 1;
if ( p == pe )
goto _test_eof19;
st_case_19:
if ( p == pe )
goto _out19;
switch( ( (*( p))) ) {
case 43: {
goto _ctr34;
@@ -475,288 +433,252 @@ static void lex(Input *in, Output *out)
goto _ctr35;
}
}
{
goto _st0;
}
goto _st0;
_ctr34:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
s2 = p; }
#line 487 "gen/ragel/05__datetime.c"
#line 443 "gen/ragel/05__datetime.c"
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
z1 = p; }
#line 493 "gen/ragel/05__datetime.c"
#line 449 "gen/ragel/05__datetime.c"
goto _st20;
_st20:
p+= 1;
if ( p == pe )
goto _test_eof20;
st_case_20:
if ( p == pe )
goto _out20;
if ( ( (*( p))) == 50 ) {
goto _st26;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 49 ) {
goto _st21;
}
{
goto _st0;
}
goto _st0;
_st21:
p+= 1;
if ( p == pe )
goto _test_eof21;
st_case_21:
if ( p == pe )
goto _out21;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st22;
}
{
goto _st0;
}
goto _st0;
_st22:
p+= 1;
if ( p == pe )
goto _test_eof22;
st_case_22:
if ( p == pe )
goto _out22;
if ( ( (*( p))) == 58 ) {
goto _st23;
}
{
goto _st0;
}
goto _st0;
_st23:
p+= 1;
if ( p == pe )
goto _test_eof23;
st_case_23:
if ( p == pe )
goto _out23;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 53 ) {
goto _st24;
}
{
goto _st0;
}
goto _st0;
_st24:
p+= 1;
if ( p == pe )
goto _test_eof24;
st_case_24:
if ( p == pe )
goto _out24;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st25;
}
{
goto _st0;
}
goto _st0;
_ctr35:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
s2 = p; }
#line 559 "gen/ragel/05__datetime.c"
#line 505 "gen/ragel/05__datetime.c"
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
z1 = p; }
#line 565 "gen/ragel/05__datetime.c"
#line 511 "gen/ragel/05__datetime.c"
goto _st25;
_st25:
p+= 1;
if ( p == pe )
goto _test_eof25;
st_case_25:
if ( p == pe )
goto _out25;
if ( ( (*( p))) == 10 ) {
goto _ctr43;
}
{
goto _st0;
}
goto _st0;
_st26:
p+= 1;
if ( p == pe )
goto _test_eof26;
st_case_26:
if ( p == pe )
goto _out26;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 51 ) {
goto _st22;
}
{
goto _st0;
}
goto _st0;
_ctr21:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
h1 = p; }
#line 595 "gen/ragel/05__datetime.c"
#line 537 "gen/ragel/05__datetime.c"
goto _st27;
_st27:
p+= 1;
if ( p == pe )
goto _test_eof27;
st_case_27:
if ( p == pe )
goto _out27;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 51 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_ctr14:
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
d1 = p; }
#line 614 "gen/ragel/05__datetime.c"
#line 554 "gen/ragel/05__datetime.c"
goto _st28;
_st28:
p+= 1;
if ( p == pe )
goto _test_eof28;
st_case_28:
if ( p == pe )
goto _out28;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_ctr15:
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
d1 = p; }
#line 633 "gen/ragel/05__datetime.c"
#line 571 "gen/ragel/05__datetime.c"
goto _st29;
_st29:
p+= 1;
if ( p == pe )
goto _test_eof29;
st_case_29:
if ( p == pe )
goto _out29;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 49 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_ctr8:
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
m1 = p; }
#line 652 "gen/ragel/05__datetime.c"
#line 588 "gen/ragel/05__datetime.c"
goto _st30;
_st30:
p+= 1;
if ( p == pe )
goto _test_eof30;
st_case_30:
if ( p == pe )
goto _out30;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 50 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_ctr54:
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/05__datetime.rl"
y1 = p; }
#line 671 "gen/ragel/05__datetime.c"
#line 605 "gen/ragel/05__datetime.c"
goto _st31;
_st31:
p+= 1;
if ( p == pe )
goto _test_eof31;
st_case_31:
if ( p == pe )
goto _out31;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st32;
}
{
goto _st0;
}
goto _st0;
_st32:
p+= 1;
if ( p == pe )
goto _test_eof32;
st_case_32:
if ( p == pe )
goto _out32;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st33;
}
{
goto _st0;
}
goto _st0;
_st33:
p+= 1;
if ( p == pe )
goto _test_eof33;
st_case_33:
if ( p == pe )
goto _out33;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st34;
}
{
goto _st0;
}
goto _st0;
_st34:
p+= 1;
if ( p == pe )
goto _test_eof34;
st_case_34:
if ( p == pe )
goto _out34;
if ( ( (*( p))) == 45 ) {
goto _ctr5;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st34;
}
{
goto _st0;
}
st_out:
_test_eof35: cs = 35; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof16: cs = 16; goto _test_eof;
_test_eof17: cs = 17; goto _test_eof;
_test_eof18: cs = 18; goto _test_eof;
_test_eof19: cs = 19; goto _test_eof;
_test_eof20: cs = 20; goto _test_eof;
_test_eof21: cs = 21; goto _test_eof;
_test_eof22: cs = 22; goto _test_eof;
_test_eof23: cs = 23; goto _test_eof;
_test_eof24: cs = 24; goto _test_eof;
_test_eof25: cs = 25; goto _test_eof;
_test_eof26: cs = 26; goto _test_eof;
_test_eof27: cs = 27; goto _test_eof;
_test_eof28: cs = 28; goto _test_eof;
_test_eof29: cs = 29; goto _test_eof;
_test_eof30: cs = 30; goto _test_eof;
_test_eof31: cs = 31; goto _test_eof;
_test_eof32: cs = 32; goto _test_eof;
_test_eof33: cs = 33; goto _test_eof;
_test_eof34: cs = 34; goto _test_eof;
_test_eof: {}
if ( cs >= 35 )
goto _out; _pop: {}
goto _st0;
_out35: cs = 35; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out16: cs = 16; goto _out;
_out17: cs = 17; goto _out;
_out18: cs = 18; goto _out;
_out19: cs = 19; goto _out;
_out20: cs = 20; goto _out;
_out21: cs = 21; goto _out;
_out22: cs = 22; goto _out;
_out23: cs = 23; goto _out;
_out24: cs = 24; goto _out;
_out25: cs = 25; goto _out;
_out26: cs = 26; goto _out;
_out27: cs = 27; goto _out;
_out28: cs = 28; goto _out;
_out29: cs = 29; goto _out;
_out30: cs = 30; goto _out;
_out31: cs = 31; goto _out;
_out32: cs = 32; goto _out;
_out33: cs = 33; goto _out;
_out34: cs = 34; goto _out;
_out: {}
}
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/06__email.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 9:
goto st_case_9;
@@ -61,7 +59,6 @@ static void lex(Input *in, Output *out)
case 8:
goto st_case_8;
}
goto st_out;
_ctr10:
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/06__email.rl"
@@ -73,14 +70,14 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 77 "gen/ragel/06__email.c"
#line 74 "gen/ragel/06__email.c"
goto _st9;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
switch( ( (*( p))) ) {
case 10: {
goto _st9;
@@ -113,33 +110,29 @@ static void lex(Input *in, Output *out)
} else {
goto _ctr12;
}
{
goto _st0;
}
goto _st0;
_st0:
p+= 1;
if ( p == pe )
goto _test_eof0;
st_case_0:
if ( p == pe )
goto _out0;
if ( ( (*( p))) == 10 ) {
goto _st9;
}
{
goto _st0;
}
goto _st0;
_ctr12:
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/06__email.rl"
p1 = p; }
#line 136 "gen/ragel/06__email.c"
#line 129 "gen/ragel/06__email.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _st9;
@@ -175,14 +168,12 @@ static void lex(Input *in, Output *out)
} else {
goto _st1;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _st9;
@@ -215,14 +206,12 @@ static void lex(Input *in, Output *out)
} else {
goto _st1;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 10 ) {
goto _st9;
}
@@ -233,22 +222,20 @@ static void lex(Input *in, Output *out)
} else if ( ( (*( p))) >= 48 ) {
goto _ctr5;
}
{
goto _st0;
}
goto _st0;
_ctr5:
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/06__email.rl"
p2 = p; }
#line 245 "gen/ragel/06__email.c"
#line 232 "gen/ragel/06__email.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 10: {
goto _st9;
@@ -267,14 +254,12 @@ static void lex(Input *in, Output *out)
} else if ( ( (*( p))) >= 48 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _st9;
@@ -290,14 +275,12 @@ static void lex(Input *in, Output *out)
} else if ( ( (*( p))) >= 48 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 10 ) {
goto _st9;
}
@@ -308,14 +291,12 @@ static void lex(Input *in, Output *out)
} else if ( ( (*( p))) >= 48 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
switch( ( (*( p))) ) {
case 10: {
goto _ctr10;
@@ -334,14 +315,12 @@ static void lex(Input *in, Output *out)
} else if ( ( (*( p))) >= 48 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 10: {
goto _st9;
@@ -357,24 +336,18 @@ static void lex(Input *in, Output *out)
} else if ( ( (*( p))) >= 48 ) {
goto _st7;
}
{
goto _st0;
}
st_out:
_test_eof9: cs = 9; goto _test_eof;
_test_eof0: cs = 0; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof: {}
if ( cs >= 9 )
goto _out; _out: {}
goto _st0;
_out9: cs = 9; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out: {}
}
#line 38 "../../../benchmarks/submatch_dfa_aot/src/ragel/06__email.rl"
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/07__ipv4.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 16:
goto st_case_16;
@@ -75,7 +73,6 @@ static void lex(Input *in, Output *out)
case 15:
goto st_case_15;
}
goto st_out;
_ctr14:
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/07__ipv4.rl"
@@ -90,266 +87,229 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 94 "gen/ragel/07__ipv4.c"
#line 91 "gen/ragel/07__ipv4.c"
goto _st16;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr21;
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr21:
{
#line 11 "../../../benchmarks/submatch_dfa_aot/src/ragel/07__ipv4.rl"
p1 = p; }
#line 117 "gen/ragel/07__ipv4.c"
#line 111 "gen/ragel/07__ipv4.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 46 ) {
goto _st2;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st14;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr4;
}
{
goto _st0;
}
goto _st0;
_ctr4:
{
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/07__ipv4.rl"
p2 = p; }
#line 150 "gen/ragel/07__ipv4.c"
#line 140 "gen/ragel/07__ipv4.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 46 ) {
goto _st4;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st12;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr8;
}
{
goto _st0;
}
goto _st0;
_ctr8:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/07__ipv4.rl"
p3 = p; }
#line 183 "gen/ragel/07__ipv4.c"
#line 169 "gen/ragel/07__ipv4.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 46 ) {
goto _st6;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _ctr12;
}
{
goto _st0;
}
goto _st0;
_ctr12:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/07__ipv4.rl"
p4 = p; }
#line 216 "gen/ragel/07__ipv4.c"
#line 198 "gen/ragel/07__ipv4.c"
goto _st7;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 10 ) {
goto _ctr14;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st8;
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
if ( ( (*( p))) == 10 ) {
goto _ctr14;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st9;
}
{
goto _st0;
}
goto _st0;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( ( (*( p))) == 10 ) {
goto _ctr14;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 46 ) {
goto _st6;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st11;
}
{
goto _st0;
}
goto _st0;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
if ( ( (*( p))) == 46 ) {
goto _st6;
}
{
goto _st0;
}
goto _st0;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( ( (*( p))) == 46 ) {
goto _st4;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
if ( ( (*( p))) == 46 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
if ( ( (*( p))) == 46 ) {
goto _st2;
}
if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
goto _st15;
}
{
goto _st0;
}
goto _st0;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
if ( p == pe )
goto _out15;
if ( ( (*( p))) == 46 ) {
goto _st2;
}
{
goto _st0;
}
st_out:
_test_eof16: cs = 16; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof: {}
if ( cs >= 16 )
goto _out; _pop: {}
goto _st0;
_out16: cs = 16; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out: {}
}
@@ -40,8 +40,6 @@ static void lex(Input *in, Output *out)
#line 42 "gen/ragel/10__alt1_2.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 3:
goto st_case_3;
@@ -52,13 +50,12 @@ static void lex(Input *in, Output *out)
case 2:
goto st_case_2;
}
goto st_out;
_ctr2:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 62 "gen/ragel/10__alt1_2.c"
#line 59 "gen/ragel/10__alt1_2.c"
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
@@ -68,7 +65,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 72 "gen/ragel/10__alt1_2.c"
#line 69 "gen/ragel/10__alt1_2.c"
goto _st3;
_ctr4:
@@ -76,7 +73,7 @@ static void lex(Input *in, Output *out)
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 80 "gen/ragel/10__alt1_2.c"
#line 77 "gen/ragel/10__alt1_2.c"
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
@@ -86,7 +83,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 90 "gen/ragel/10__alt1_2.c"
#line 87 "gen/ragel/10__alt1_2.c"
goto _st3;
_ctr6:
@@ -94,25 +91,25 @@ static void lex(Input *in, Output *out)
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
b1 = p; }
#line 98 "gen/ragel/10__alt1_2.c"
#line 95 "gen/ragel/10__alt1_2.c"
{
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 104 "gen/ragel/10__alt1_2.c"
#line 101 "gen/ragel/10__alt1_2.c"
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
a1 = p; }
#line 110 "gen/ragel/10__alt1_2.c"
#line 107 "gen/ragel/10__alt1_2.c"
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 116 "gen/ragel/10__alt1_2.c"
#line 113 "gen/ragel/10__alt1_2.c"
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
@@ -122,14 +119,14 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 126 "gen/ragel/10__alt1_2.c"
#line 123 "gen/ragel/10__alt1_2.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr6;
@@ -141,26 +138,23 @@ static void lex(Input *in, Output *out)
goto _ctr8;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr7:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
a1 = p; }
#line 157 "gen/ragel/10__alt1_2.c"
#line 151 "gen/ragel/10__alt1_2.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _ctr2;
@@ -169,22 +163,20 @@ static void lex(Input *in, Output *out)
goto _st1;
}
}
{
goto _st0;
}
goto _st0;
_ctr8:
{
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/10__alt1_2.rl"
b1 = p; }
#line 181 "gen/ragel/10__alt1_2.c"
#line 173 "gen/ragel/10__alt1_2.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr4;
@@ -193,17 +185,11 @@ static void lex(Input *in, Output *out)
goto _st2;
}
}
{
goto _st0;
}
st_out:
_test_eof3: cs = 3; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof: {}
if ( cs >= 3 )
goto _out; _pop: {}
goto _st0;
_out3: cs = 3; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out: {}
}
@@ -40,8 +40,6 @@ static void lex(Input *in, Output *out)
#line 42 "gen/ragel/11__alt1_4.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 5:
goto st_case_5;
@@ -56,13 +54,12 @@ static void lex(Input *in, Output *out)
case 4:
goto st_case_4;
}
goto st_out;
_ctr2:
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = NULL; }
#line 66 "gen/ragel/11__alt1_4.c"
#line 63 "gen/ragel/11__alt1_4.c"
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
@@ -74,7 +71,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 78 "gen/ragel/11__alt1_4.c"
#line 75 "gen/ragel/11__alt1_4.c"
goto _st5;
_ctr4:
@@ -82,7 +79,7 @@ static void lex(Input *in, Output *out)
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = NULL; }
#line 86 "gen/ragel/11__alt1_4.c"
#line 83 "gen/ragel/11__alt1_4.c"
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
@@ -94,7 +91,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 98 "gen/ragel/11__alt1_4.c"
#line 95 "gen/ragel/11__alt1_4.c"
goto _st5;
_ctr6:
@@ -102,7 +99,7 @@ static void lex(Input *in, Output *out)
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = NULL; }
#line 106 "gen/ragel/11__alt1_4.c"
#line 103 "gen/ragel/11__alt1_4.c"
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
@@ -114,7 +111,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 118 "gen/ragel/11__alt1_4.c"
#line 115 "gen/ragel/11__alt1_4.c"
goto _st5;
_ctr8:
@@ -122,7 +119,7 @@ static void lex(Input *in, Output *out)
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = NULL; }
#line 126 "gen/ragel/11__alt1_4.c"
#line 123 "gen/ragel/11__alt1_4.c"
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
@@ -134,7 +131,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 138 "gen/ragel/11__alt1_4.c"
#line 135 "gen/ragel/11__alt1_4.c"
goto _st5;
_ctr10:
@@ -142,49 +139,49 @@ static void lex(Input *in, Output *out)
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
b1 = p; }
#line 146 "gen/ragel/11__alt1_4.c"
#line 143 "gen/ragel/11__alt1_4.c"
{
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = NULL; }
#line 152 "gen/ragel/11__alt1_4.c"
#line 149 "gen/ragel/11__alt1_4.c"
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
c1 = p; }
#line 158 "gen/ragel/11__alt1_4.c"
#line 155 "gen/ragel/11__alt1_4.c"
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = NULL; }
#line 164 "gen/ragel/11__alt1_4.c"
#line 161 "gen/ragel/11__alt1_4.c"
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
d1 = p; }
#line 170 "gen/ragel/11__alt1_4.c"
#line 167 "gen/ragel/11__alt1_4.c"
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = NULL; }
#line 176 "gen/ragel/11__alt1_4.c"
#line 173 "gen/ragel/11__alt1_4.c"
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
a1 = p; }
#line 182 "gen/ragel/11__alt1_4.c"
#line 179 "gen/ragel/11__alt1_4.c"
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = NULL; }
#line 188 "gen/ragel/11__alt1_4.c"
#line 185 "gen/ragel/11__alt1_4.c"
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
@@ -196,14 +193,14 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 200 "gen/ragel/11__alt1_4.c"
#line 197 "gen/ragel/11__alt1_4.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr10;
@@ -221,26 +218,23 @@ static void lex(Input *in, Output *out)
goto _ctr14;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr11:
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
a1 = p; }
#line 237 "gen/ragel/11__alt1_4.c"
#line 231 "gen/ragel/11__alt1_4.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _ctr2;
@@ -249,22 +243,20 @@ static void lex(Input *in, Output *out)
goto _st1;
}
}
{
goto _st0;
}
goto _st0;
_ctr12:
{
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
b1 = p; }
#line 261 "gen/ragel/11__alt1_4.c"
#line 253 "gen/ragel/11__alt1_4.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr4;
@@ -273,22 +265,20 @@ static void lex(Input *in, Output *out)
goto _st2;
}
}
{
goto _st0;
}
goto _st0;
_ctr13:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
c1 = p; }
#line 285 "gen/ragel/11__alt1_4.c"
#line 275 "gen/ragel/11__alt1_4.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr6;
@@ -297,22 +287,20 @@ static void lex(Input *in, Output *out)
goto _st3;
}
}
{
goto _st0;
}
goto _st0;
_ctr14:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/11__alt1_4.rl"
d1 = p; }
#line 309 "gen/ragel/11__alt1_4.c"
#line 297 "gen/ragel/11__alt1_4.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 10: {
goto _ctr8;
@@ -321,19 +309,13 @@ static void lex(Input *in, Output *out)
goto _st4;
}
}
{
goto _st0;
}
st_out:
_test_eof5: cs = 5; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof: {}
if ( cs >= 5 )
goto _out; _pop: {}
goto _st0;
_out5: cs = 5; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out: {}
}
@@ -40,8 +40,6 @@ static void lex(Input *in, Output *out)
#line 42 "gen/ragel/12__alt1_8.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 9:
goto st_case_9;
@@ -64,13 +62,12 @@ static void lex(Input *in, Output *out)
case 8:
goto st_case_8;
}
goto st_out;
_ctr2:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 74 "gen/ragel/12__alt1_8.c"
#line 71 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -86,7 +83,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 90 "gen/ragel/12__alt1_8.c"
#line 87 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr4:
@@ -94,7 +91,7 @@ static void lex(Input *in, Output *out)
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 98 "gen/ragel/12__alt1_8.c"
#line 95 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -110,7 +107,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 114 "gen/ragel/12__alt1_8.c"
#line 111 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr6:
@@ -118,7 +115,7 @@ static void lex(Input *in, Output *out)
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 122 "gen/ragel/12__alt1_8.c"
#line 119 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -134,7 +131,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 138 "gen/ragel/12__alt1_8.c"
#line 135 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr8:
@@ -142,7 +139,7 @@ static void lex(Input *in, Output *out)
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 146 "gen/ragel/12__alt1_8.c"
#line 143 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -158,7 +155,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 162 "gen/ragel/12__alt1_8.c"
#line 159 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr10:
@@ -166,7 +163,7 @@ static void lex(Input *in, Output *out)
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
e2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 170 "gen/ragel/12__alt1_8.c"
#line 167 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -182,7 +179,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 186 "gen/ragel/12__alt1_8.c"
#line 183 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr12:
@@ -190,7 +187,7 @@ static void lex(Input *in, Output *out)
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
f2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = g1 = g2 = h1 = h2 = NULL; }
#line 194 "gen/ragel/12__alt1_8.c"
#line 191 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -206,7 +203,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 210 "gen/ragel/12__alt1_8.c"
#line 207 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr14:
@@ -214,7 +211,7 @@ static void lex(Input *in, Output *out)
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
g2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = h1 = h2 = NULL; }
#line 218 "gen/ragel/12__alt1_8.c"
#line 215 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -230,7 +227,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 234 "gen/ragel/12__alt1_8.c"
#line 231 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr16:
@@ -238,7 +235,7 @@ static void lex(Input *in, Output *out)
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
h2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = NULL; }
#line 242 "gen/ragel/12__alt1_8.c"
#line 239 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -254,7 +251,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 258 "gen/ragel/12__alt1_8.c"
#line 255 "gen/ragel/12__alt1_8.c"
goto _st9;
_ctr18:
@@ -262,97 +259,97 @@ static void lex(Input *in, Output *out)
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
b1 = p; }
#line 266 "gen/ragel/12__alt1_8.c"
#line 263 "gen/ragel/12__alt1_8.c"
{
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 272 "gen/ragel/12__alt1_8.c"
#line 269 "gen/ragel/12__alt1_8.c"
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
c1 = p; }
#line 278 "gen/ragel/12__alt1_8.c"
#line 275 "gen/ragel/12__alt1_8.c"
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 284 "gen/ragel/12__alt1_8.c"
#line 281 "gen/ragel/12__alt1_8.c"
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
d1 = p; }
#line 290 "gen/ragel/12__alt1_8.c"
#line 287 "gen/ragel/12__alt1_8.c"
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 296 "gen/ragel/12__alt1_8.c"
#line 293 "gen/ragel/12__alt1_8.c"
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
e1 = p; }
#line 302 "gen/ragel/12__alt1_8.c"
#line 299 "gen/ragel/12__alt1_8.c"
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
e2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 308 "gen/ragel/12__alt1_8.c"
#line 305 "gen/ragel/12__alt1_8.c"
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
f1 = p; }
#line 314 "gen/ragel/12__alt1_8.c"
#line 311 "gen/ragel/12__alt1_8.c"
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
f2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = g1 = g2 = h1 = h2 = NULL; }
#line 320 "gen/ragel/12__alt1_8.c"
#line 317 "gen/ragel/12__alt1_8.c"
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
g1 = p; }
#line 326 "gen/ragel/12__alt1_8.c"
#line 323 "gen/ragel/12__alt1_8.c"
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
g2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = h1 = h2 = NULL; }
#line 332 "gen/ragel/12__alt1_8.c"
#line 329 "gen/ragel/12__alt1_8.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
h1 = p; }
#line 338 "gen/ragel/12__alt1_8.c"
#line 335 "gen/ragel/12__alt1_8.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
h2 = p; a1 = a2 = b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = NULL; }
#line 344 "gen/ragel/12__alt1_8.c"
#line 341 "gen/ragel/12__alt1_8.c"
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
a1 = p; }
#line 350 "gen/ragel/12__alt1_8.c"
#line 347 "gen/ragel/12__alt1_8.c"
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = e1 = e2 = f1 = f2 = g1 = g2 = h1 = h2 = NULL; }
#line 356 "gen/ragel/12__alt1_8.c"
#line 353 "gen/ragel/12__alt1_8.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
@@ -368,14 +365,14 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 372 "gen/ragel/12__alt1_8.c"
#line 369 "gen/ragel/12__alt1_8.c"
goto _st9;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
switch( ( (*( p))) ) {
case 10: {
goto _ctr18;
@@ -405,26 +402,23 @@ static void lex(Input *in, Output *out)
goto _ctr26;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr19:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
a1 = p; }
#line 421 "gen/ragel/12__alt1_8.c"
#line 415 "gen/ragel/12__alt1_8.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _ctr2;
@@ -433,22 +427,20 @@ static void lex(Input *in, Output *out)
goto _st1;
}
}
{
goto _st0;
}
goto _st0;
_ctr20:
{
#line 12 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
b1 = p; }
#line 445 "gen/ragel/12__alt1_8.c"
#line 437 "gen/ragel/12__alt1_8.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr4;
@@ -457,22 +449,20 @@ static void lex(Input *in, Output *out)
goto _st2;
}
}
{
goto _st0;
}
goto _st0;
_ctr21:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
c1 = p; }
#line 469 "gen/ragel/12__alt1_8.c"
#line 459 "gen/ragel/12__alt1_8.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr6;
@@ -481,22 +471,20 @@ static void lex(Input *in, Output *out)
goto _st3;
}
}
{
goto _st0;
}
goto _st0;
_ctr22:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
d1 = p; }
#line 493 "gen/ragel/12__alt1_8.c"
#line 481 "gen/ragel/12__alt1_8.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 10: {
goto _ctr8;
@@ -505,22 +493,20 @@ static void lex(Input *in, Output *out)
goto _st4;
}
}
{
goto _st0;
}
goto _st0;
_ctr23:
{
#line 15 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
e1 = p; }
#line 517 "gen/ragel/12__alt1_8.c"
#line 503 "gen/ragel/12__alt1_8.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr10;
@@ -529,22 +515,20 @@ static void lex(Input *in, Output *out)
goto _st5;
}
}
{
goto _st0;
}
goto _st0;
_ctr24:
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
f1 = p; }
#line 541 "gen/ragel/12__alt1_8.c"
#line 525 "gen/ragel/12__alt1_8.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
switch( ( (*( p))) ) {
case 10: {
goto _ctr12;
@@ -553,22 +537,20 @@ static void lex(Input *in, Output *out)
goto _st6;
}
}
{
goto _st0;
}
goto _st0;
_ctr25:
{
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
g1 = p; }
#line 565 "gen/ragel/12__alt1_8.c"
#line 547 "gen/ragel/12__alt1_8.c"
goto _st7;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
switch( ( (*( p))) ) {
case 10: {
goto _ctr14;
@@ -577,22 +559,20 @@ static void lex(Input *in, Output *out)
goto _st7;
}
}
{
goto _st0;
}
goto _st0;
_ctr26:
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/12__alt1_8.rl"
h1 = p; }
#line 589 "gen/ragel/12__alt1_8.c"
#line 569 "gen/ragel/12__alt1_8.c"
goto _st8;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 10: {
goto _ctr16;
@@ -601,23 +581,17 @@ static void lex(Input *in, Output *out)
goto _st8;
}
}
{
goto _st0;
}
st_out:
_test_eof9: cs = 9; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof: {}
if ( cs >= 9 )
goto _out; _pop: {}
goto _st0;
_out9: cs = 9; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out: {}
}
@@ -42,8 +42,6 @@ static void lex(Input *in, Output *out)
#line 44 "gen/ragel/13__alt2_2.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 5:
goto st_case_5;
@@ -58,37 +56,36 @@ static void lex(Input *in, Output *out)
case 4:
goto st_case_4;
}
goto st_out;
_ctr2:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 68 "gen/ragel/13__alt2_2.c"
#line 65 "gen/ragel/13__alt2_2.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b3 = p; }
#line 74 "gen/ragel/13__alt2_2.c"
#line 71 "gen/ragel/13__alt2_2.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 80 "gen/ragel/13__alt2_2.c"
#line 77 "gen/ragel/13__alt2_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a3 = p; }
#line 86 "gen/ragel/13__alt2_2.c"
#line 83 "gen/ragel/13__alt2_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 92 "gen/ragel/13__alt2_2.c"
#line 89 "gen/ragel/13__alt2_2.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
@@ -100,7 +97,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 104 "gen/ragel/13__alt2_2.c"
#line 101 "gen/ragel/13__alt2_2.c"
goto _st5;
_ctr5:
@@ -108,7 +105,7 @@ static void lex(Input *in, Output *out)
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 112 "gen/ragel/13__alt2_2.c"
#line 109 "gen/ragel/13__alt2_2.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
@@ -120,7 +117,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 124 "gen/ragel/13__alt2_2.c"
#line 121 "gen/ragel/13__alt2_2.c"
goto _st5;
_ctr7:
@@ -128,31 +125,31 @@ static void lex(Input *in, Output *out)
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 132 "gen/ragel/13__alt2_2.c"
#line 129 "gen/ragel/13__alt2_2.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b3 = p; }
#line 138 "gen/ragel/13__alt2_2.c"
#line 135 "gen/ragel/13__alt2_2.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 144 "gen/ragel/13__alt2_2.c"
#line 141 "gen/ragel/13__alt2_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a3 = p; }
#line 150 "gen/ragel/13__alt2_2.c"
#line 147 "gen/ragel/13__alt2_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 156 "gen/ragel/13__alt2_2.c"
#line 153 "gen/ragel/13__alt2_2.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
@@ -164,7 +161,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 168 "gen/ragel/13__alt2_2.c"
#line 165 "gen/ragel/13__alt2_2.c"
goto _st5;
_ctr10:
@@ -172,7 +169,7 @@ static void lex(Input *in, Output *out)
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 176 "gen/ragel/13__alt2_2.c"
#line 173 "gen/ragel/13__alt2_2.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
@@ -184,7 +181,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 188 "gen/ragel/13__alt2_2.c"
#line 185 "gen/ragel/13__alt2_2.c"
goto _st5;
_ctr12:
@@ -192,49 +189,49 @@ static void lex(Input *in, Output *out)
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b1 = p; }
#line 196 "gen/ragel/13__alt2_2.c"
#line 193 "gen/ragel/13__alt2_2.c"
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 202 "gen/ragel/13__alt2_2.c"
#line 199 "gen/ragel/13__alt2_2.c"
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a1 = p; }
#line 208 "gen/ragel/13__alt2_2.c"
#line 205 "gen/ragel/13__alt2_2.c"
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 214 "gen/ragel/13__alt2_2.c"
#line 211 "gen/ragel/13__alt2_2.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b3 = p; }
#line 220 "gen/ragel/13__alt2_2.c"
#line 217 "gen/ragel/13__alt2_2.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 226 "gen/ragel/13__alt2_2.c"
#line 223 "gen/ragel/13__alt2_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a3 = p; }
#line 232 "gen/ragel/13__alt2_2.c"
#line 229 "gen/ragel/13__alt2_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 238 "gen/ragel/13__alt2_2.c"
#line 235 "gen/ragel/13__alt2_2.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
@@ -246,14 +243,14 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 250 "gen/ragel/13__alt2_2.c"
#line 247 "gen/ragel/13__alt2_2.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr12;
@@ -265,26 +262,23 @@ static void lex(Input *in, Output *out)
goto _ctr14;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr13:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a1 = p; }
#line 281 "gen/ragel/13__alt2_2.c"
#line 275 "gen/ragel/13__alt2_2.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _ctr2;
@@ -296,28 +290,26 @@ static void lex(Input *in, Output *out)
goto _ctr3;
}
}
{
goto _st0;
}
goto _st0;
_ctr3:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 308 "gen/ragel/13__alt2_2.c"
#line 300 "gen/ragel/13__alt2_2.c"
{
#line 23 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b3 = p; }
#line 314 "gen/ragel/13__alt2_2.c"
#line 306 "gen/ragel/13__alt2_2.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr5;
@@ -326,22 +318,20 @@ static void lex(Input *in, Output *out)
goto _st2;
}
}
{
goto _st0;
}
goto _st0;
_ctr14:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b1 = p; }
#line 338 "gen/ragel/13__alt2_2.c"
#line 328 "gen/ragel/13__alt2_2.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr7;
@@ -353,28 +343,26 @@ static void lex(Input *in, Output *out)
goto _st3;
}
}
{
goto _st0;
}
goto _st0;
_ctr8:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 365 "gen/ragel/13__alt2_2.c"
#line 353 "gen/ragel/13__alt2_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/13__alt2_2.rl"
a3 = p; }
#line 371 "gen/ragel/13__alt2_2.c"
#line 359 "gen/ragel/13__alt2_2.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 10: {
goto _ctr10;
@@ -383,19 +371,13 @@ static void lex(Input *in, Output *out)
goto _st4;
}
}
{
goto _st0;
}
st_out:
_test_eof5: cs = 5; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof: {}
if ( cs >= 5 )
goto _out; _pop: {}
goto _st0;
_out5: cs = 5; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out: {}
}
@@ -42,8 +42,6 @@ static void lex(Input *in, Output *out)
#line 44 "gen/ragel/14__alt2_4.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 9:
goto st_case_9;
@@ -66,61 +64,60 @@ static void lex(Input *in, Output *out)
case 8:
goto st_case_8;
}
goto st_out;
_ctr2:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = NULL; }
#line 76 "gen/ragel/14__alt2_4.c"
#line 73 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 82 "gen/ragel/14__alt2_4.c"
#line 79 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b4 = p; a3 = a4 = c3 = c4 = d3 = d4 = NULL; }
#line 88 "gen/ragel/14__alt2_4.c"
#line 85 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 94 "gen/ragel/14__alt2_4.c"
#line 91 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c4 = p; a3 = a4 = b3 = b4 = d3 = d4 = NULL; }
#line 100 "gen/ragel/14__alt2_4.c"
#line 97 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 106 "gen/ragel/14__alt2_4.c"
#line 103 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d4 = p; a3 = a4 = b3 = b4 = c3 = c4 = NULL; }
#line 112 "gen/ragel/14__alt2_4.c"
#line 109 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 118 "gen/ragel/14__alt2_4.c"
#line 115 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a4 = p; b3 = b4 = c3 = c4 = d3 = d4 = NULL; }
#line 124 "gen/ragel/14__alt2_4.c"
#line 121 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -136,7 +133,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 140 "gen/ragel/14__alt2_4.c"
#line 137 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr7:
@@ -144,7 +141,7 @@ static void lex(Input *in, Output *out)
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b4 = p; a3 = a4 = c3 = c4 = d3 = d4 = NULL; }
#line 148 "gen/ragel/14__alt2_4.c"
#line 145 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -160,7 +157,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 164 "gen/ragel/14__alt2_4.c"
#line 161 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr9:
@@ -168,7 +165,7 @@ static void lex(Input *in, Output *out)
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c4 = p; a3 = a4 = b3 = b4 = d3 = d4 = NULL; }
#line 172 "gen/ragel/14__alt2_4.c"
#line 169 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -184,7 +181,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 188 "gen/ragel/14__alt2_4.c"
#line 185 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr11:
@@ -192,7 +189,7 @@ static void lex(Input *in, Output *out)
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d4 = p; a3 = a4 = b3 = b4 = c3 = c4 = NULL; }
#line 196 "gen/ragel/14__alt2_4.c"
#line 193 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -208,7 +205,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 212 "gen/ragel/14__alt2_4.c"
#line 209 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr13:
@@ -216,55 +213,55 @@ static void lex(Input *in, Output *out)
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = NULL; }
#line 220 "gen/ragel/14__alt2_4.c"
#line 217 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 226 "gen/ragel/14__alt2_4.c"
#line 223 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b4 = p; a3 = a4 = c3 = c4 = d3 = d4 = NULL; }
#line 232 "gen/ragel/14__alt2_4.c"
#line 229 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 238 "gen/ragel/14__alt2_4.c"
#line 235 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c4 = p; a3 = a4 = b3 = b4 = d3 = d4 = NULL; }
#line 244 "gen/ragel/14__alt2_4.c"
#line 241 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 250 "gen/ragel/14__alt2_4.c"
#line 247 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d4 = p; a3 = a4 = b3 = b4 = c3 = c4 = NULL; }
#line 256 "gen/ragel/14__alt2_4.c"
#line 253 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 262 "gen/ragel/14__alt2_4.c"
#line 259 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a4 = p; b3 = b4 = c3 = c4 = d3 = d4 = NULL; }
#line 268 "gen/ragel/14__alt2_4.c"
#line 265 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -280,7 +277,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 284 "gen/ragel/14__alt2_4.c"
#line 281 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr18:
@@ -288,7 +285,7 @@ static void lex(Input *in, Output *out)
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a4 = p; b3 = b4 = c3 = c4 = d3 = d4 = NULL; }
#line 292 "gen/ragel/14__alt2_4.c"
#line 289 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -304,7 +301,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 308 "gen/ragel/14__alt2_4.c"
#line 305 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr20:
@@ -312,55 +309,55 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = NULL; }
#line 316 "gen/ragel/14__alt2_4.c"
#line 313 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 322 "gen/ragel/14__alt2_4.c"
#line 319 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b4 = p; a3 = a4 = c3 = c4 = d3 = d4 = NULL; }
#line 328 "gen/ragel/14__alt2_4.c"
#line 325 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 334 "gen/ragel/14__alt2_4.c"
#line 331 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c4 = p; a3 = a4 = b3 = b4 = d3 = d4 = NULL; }
#line 340 "gen/ragel/14__alt2_4.c"
#line 337 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 346 "gen/ragel/14__alt2_4.c"
#line 343 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d4 = p; a3 = a4 = b3 = b4 = c3 = c4 = NULL; }
#line 352 "gen/ragel/14__alt2_4.c"
#line 349 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 358 "gen/ragel/14__alt2_4.c"
#line 355 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a4 = p; b3 = b4 = c3 = c4 = d3 = d4 = NULL; }
#line 364 "gen/ragel/14__alt2_4.c"
#line 361 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -376,7 +373,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 380 "gen/ragel/14__alt2_4.c"
#line 377 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr25:
@@ -384,55 +381,55 @@ static void lex(Input *in, Output *out)
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = NULL; }
#line 388 "gen/ragel/14__alt2_4.c"
#line 385 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 394 "gen/ragel/14__alt2_4.c"
#line 391 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b4 = p; a3 = a4 = c3 = c4 = d3 = d4 = NULL; }
#line 400 "gen/ragel/14__alt2_4.c"
#line 397 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 406 "gen/ragel/14__alt2_4.c"
#line 403 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c4 = p; a3 = a4 = b3 = b4 = d3 = d4 = NULL; }
#line 412 "gen/ragel/14__alt2_4.c"
#line 409 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 418 "gen/ragel/14__alt2_4.c"
#line 415 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d4 = p; a3 = a4 = b3 = b4 = c3 = c4 = NULL; }
#line 424 "gen/ragel/14__alt2_4.c"
#line 421 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 430 "gen/ragel/14__alt2_4.c"
#line 427 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a4 = p; b3 = b4 = c3 = c4 = d3 = d4 = NULL; }
#line 436 "gen/ragel/14__alt2_4.c"
#line 433 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -448,7 +445,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 452 "gen/ragel/14__alt2_4.c"
#line 449 "gen/ragel/14__alt2_4.c"
goto _st9;
_ctr30:
@@ -456,97 +453,97 @@ static void lex(Input *in, Output *out)
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b1 = p; }
#line 460 "gen/ragel/14__alt2_4.c"
#line 457 "gen/ragel/14__alt2_4.c"
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = NULL; }
#line 466 "gen/ragel/14__alt2_4.c"
#line 463 "gen/ragel/14__alt2_4.c"
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c1 = p; }
#line 472 "gen/ragel/14__alt2_4.c"
#line 469 "gen/ragel/14__alt2_4.c"
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = NULL; }
#line 478 "gen/ragel/14__alt2_4.c"
#line 475 "gen/ragel/14__alt2_4.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d1 = p; }
#line 484 "gen/ragel/14__alt2_4.c"
#line 481 "gen/ragel/14__alt2_4.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = NULL; }
#line 490 "gen/ragel/14__alt2_4.c"
#line 487 "gen/ragel/14__alt2_4.c"
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a1 = p; }
#line 496 "gen/ragel/14__alt2_4.c"
#line 493 "gen/ragel/14__alt2_4.c"
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = NULL; }
#line 502 "gen/ragel/14__alt2_4.c"
#line 499 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 508 "gen/ragel/14__alt2_4.c"
#line 505 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b4 = p; a3 = a4 = c3 = c4 = d3 = d4 = NULL; }
#line 514 "gen/ragel/14__alt2_4.c"
#line 511 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 520 "gen/ragel/14__alt2_4.c"
#line 517 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c4 = p; a3 = a4 = b3 = b4 = d3 = d4 = NULL; }
#line 526 "gen/ragel/14__alt2_4.c"
#line 523 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 532 "gen/ragel/14__alt2_4.c"
#line 529 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d4 = p; a3 = a4 = b3 = b4 = c3 = c4 = NULL; }
#line 538 "gen/ragel/14__alt2_4.c"
#line 535 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 544 "gen/ragel/14__alt2_4.c"
#line 541 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a4 = p; b3 = b4 = c3 = c4 = d3 = d4 = NULL; }
#line 550 "gen/ragel/14__alt2_4.c"
#line 547 "gen/ragel/14__alt2_4.c"
{
#line 30 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
@@ -562,14 +559,14 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 566 "gen/ragel/14__alt2_4.c"
#line 563 "gen/ragel/14__alt2_4.c"
goto _st9;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
switch( ( (*( p))) ) {
case 10: {
goto _ctr30;
@@ -587,26 +584,23 @@ static void lex(Input *in, Output *out)
goto _ctr34;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr31:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a1 = p; }
#line 603 "gen/ragel/14__alt2_4.c"
#line 597 "gen/ragel/14__alt2_4.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _ctr2;
@@ -624,21 +618,19 @@ static void lex(Input *in, Output *out)
goto _ctr5;
}
}
{
goto _st0;
}
goto _st0;
_ctr3:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = NULL; }
#line 636 "gen/ragel/14__alt2_4.c"
#line 628 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 642 "gen/ragel/14__alt2_4.c"
#line 634 "gen/ragel/14__alt2_4.c"
goto _st2;
_ctr22:
@@ -646,13 +638,13 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = NULL; }
#line 650 "gen/ragel/14__alt2_4.c"
#line 642 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 656 "gen/ragel/14__alt2_4.c"
#line 648 "gen/ragel/14__alt2_4.c"
goto _st2;
_ctr27:
@@ -660,20 +652,20 @@ static void lex(Input *in, Output *out)
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = NULL; }
#line 664 "gen/ragel/14__alt2_4.c"
#line 656 "gen/ragel/14__alt2_4.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b3 = p; }
#line 670 "gen/ragel/14__alt2_4.c"
#line 662 "gen/ragel/14__alt2_4.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr7;
@@ -682,21 +674,19 @@ static void lex(Input *in, Output *out)
goto _st2;
}
}
{
goto _st0;
}
goto _st0;
_ctr4:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = NULL; }
#line 694 "gen/ragel/14__alt2_4.c"
#line 684 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 700 "gen/ragel/14__alt2_4.c"
#line 690 "gen/ragel/14__alt2_4.c"
goto _st3;
_ctr15:
@@ -704,13 +694,13 @@ static void lex(Input *in, Output *out)
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = NULL; }
#line 708 "gen/ragel/14__alt2_4.c"
#line 698 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 714 "gen/ragel/14__alt2_4.c"
#line 704 "gen/ragel/14__alt2_4.c"
goto _st3;
_ctr28:
@@ -718,20 +708,20 @@ static void lex(Input *in, Output *out)
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = NULL; }
#line 722 "gen/ragel/14__alt2_4.c"
#line 712 "gen/ragel/14__alt2_4.c"
{
#line 26 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c3 = p; }
#line 728 "gen/ragel/14__alt2_4.c"
#line 718 "gen/ragel/14__alt2_4.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr9;
@@ -740,21 +730,19 @@ static void lex(Input *in, Output *out)
goto _st3;
}
}
{
goto _st0;
}
goto _st0;
_ctr5:
{
#line 22 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a2 = p; b1 = b2 = c1 = c2 = d1 = d2 = NULL; }
#line 752 "gen/ragel/14__alt2_4.c"
#line 740 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 758 "gen/ragel/14__alt2_4.c"
#line 746 "gen/ragel/14__alt2_4.c"
goto _st4;
_ctr16:
@@ -762,13 +750,13 @@ static void lex(Input *in, Output *out)
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = NULL; }
#line 766 "gen/ragel/14__alt2_4.c"
#line 754 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 772 "gen/ragel/14__alt2_4.c"
#line 760 "gen/ragel/14__alt2_4.c"
goto _st4;
_ctr23:
@@ -776,20 +764,20 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = NULL; }
#line 780 "gen/ragel/14__alt2_4.c"
#line 768 "gen/ragel/14__alt2_4.c"
{
#line 27 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d3 = p; }
#line 786 "gen/ragel/14__alt2_4.c"
#line 774 "gen/ragel/14__alt2_4.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 10: {
goto _ctr11;
@@ -798,22 +786,20 @@ static void lex(Input *in, Output *out)
goto _st4;
}
}
{
goto _st0;
}
goto _st0;
_ctr32:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b1 = p; }
#line 810 "gen/ragel/14__alt2_4.c"
#line 796 "gen/ragel/14__alt2_4.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr13;
@@ -831,21 +817,19 @@ static void lex(Input *in, Output *out)
goto _ctr16;
}
}
{
goto _st0;
}
goto _st0;
_ctr14:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
b2 = p; a1 = a2 = c1 = c2 = d1 = d2 = NULL; }
#line 843 "gen/ragel/14__alt2_4.c"
#line 827 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 849 "gen/ragel/14__alt2_4.c"
#line 833 "gen/ragel/14__alt2_4.c"
goto _st6;
_ctr21:
@@ -853,13 +837,13 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c2 = p; a1 = a2 = b1 = b2 = d1 = d2 = NULL; }
#line 857 "gen/ragel/14__alt2_4.c"
#line 841 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 863 "gen/ragel/14__alt2_4.c"
#line 847 "gen/ragel/14__alt2_4.c"
goto _st6;
_ctr26:
@@ -867,20 +851,20 @@ static void lex(Input *in, Output *out)
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d2 = p; a1 = a2 = b1 = b2 = c1 = c2 = NULL; }
#line 871 "gen/ragel/14__alt2_4.c"
#line 855 "gen/ragel/14__alt2_4.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
a3 = p; }
#line 877 "gen/ragel/14__alt2_4.c"
#line 861 "gen/ragel/14__alt2_4.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
switch( ( (*( p))) ) {
case 10: {
goto _ctr18;
@@ -889,22 +873,20 @@ static void lex(Input *in, Output *out)
goto _st6;
}
}
{
goto _st0;
}
goto _st0;
_ctr33:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
c1 = p; }
#line 901 "gen/ragel/14__alt2_4.c"
#line 883 "gen/ragel/14__alt2_4.c"
goto _st7;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
switch( ( (*( p))) ) {
case 10: {
goto _ctr20;
@@ -922,22 +904,20 @@ static void lex(Input *in, Output *out)
goto _ctr23;
}
}
{
goto _st0;
}
goto _st0;
_ctr34:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/14__alt2_4.rl"
d1 = p; }
#line 934 "gen/ragel/14__alt2_4.c"
#line 914 "gen/ragel/14__alt2_4.c"
goto _st8;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 10: {
goto _ctr25;
@@ -955,23 +935,17 @@ static void lex(Input *in, Output *out)
goto _st8;
}
}
{
goto _st0;
}
st_out:
_test_eof9: cs = 9; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof: {}
if ( cs >= 9 )
goto _out; _pop: {}
goto _st0;
_out9: cs = 9; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out: {}
}
File diff suppressed because it is too large Load Diff
@@ -46,8 +46,6 @@ static void lex(Input *in, Output *out)
#line 48 "gen/ragel/16__alt4_2.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 9:
goto st_case_9;
@@ -70,85 +68,84 @@ static void lex(Input *in, Output *out)
case 8:
goto st_case_8;
}
goto st_out;
_ctr2:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 80 "gen/ragel/16__alt4_2.c"
#line 77 "gen/ragel/16__alt4_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b3 = p; }
#line 86 "gen/ragel/16__alt4_2.c"
#line 83 "gen/ragel/16__alt4_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 92 "gen/ragel/16__alt4_2.c"
#line 89 "gen/ragel/16__alt4_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a3 = p; }
#line 98 "gen/ragel/16__alt4_2.c"
#line 95 "gen/ragel/16__alt4_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 104 "gen/ragel/16__alt4_2.c"
#line 101 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b5 = p; }
#line 110 "gen/ragel/16__alt4_2.c"
#line 107 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b6 = p; a5 = a6 = NULL; }
#line 116 "gen/ragel/16__alt4_2.c"
#line 113 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a5 = p; }
#line 122 "gen/ragel/16__alt4_2.c"
#line 119 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a6 = p; b5 = b6 = NULL; }
#line 128 "gen/ragel/16__alt4_2.c"
#line 125 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 134 "gen/ragel/16__alt4_2.c"
#line 131 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 140 "gen/ragel/16__alt4_2.c"
#line 137 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 146 "gen/ragel/16__alt4_2.c"
#line 143 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 152 "gen/ragel/16__alt4_2.c"
#line 149 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -164,7 +161,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 168 "gen/ragel/16__alt4_2.c"
#line 165 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr5:
@@ -172,55 +169,55 @@ static void lex(Input *in, Output *out)
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 176 "gen/ragel/16__alt4_2.c"
#line 173 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b5 = p; }
#line 182 "gen/ragel/16__alt4_2.c"
#line 179 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b6 = p; a5 = a6 = NULL; }
#line 188 "gen/ragel/16__alt4_2.c"
#line 185 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a5 = p; }
#line 194 "gen/ragel/16__alt4_2.c"
#line 191 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a6 = p; b5 = b6 = NULL; }
#line 200 "gen/ragel/16__alt4_2.c"
#line 197 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 206 "gen/ragel/16__alt4_2.c"
#line 203 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 212 "gen/ragel/16__alt4_2.c"
#line 209 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 218 "gen/ragel/16__alt4_2.c"
#line 215 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 224 "gen/ragel/16__alt4_2.c"
#line 221 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -236,7 +233,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 240 "gen/ragel/16__alt4_2.c"
#line 237 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr8:
@@ -244,31 +241,31 @@ static void lex(Input *in, Output *out)
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a6 = p; b5 = b6 = NULL; }
#line 248 "gen/ragel/16__alt4_2.c"
#line 245 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 254 "gen/ragel/16__alt4_2.c"
#line 251 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 260 "gen/ragel/16__alt4_2.c"
#line 257 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 266 "gen/ragel/16__alt4_2.c"
#line 263 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 272 "gen/ragel/16__alt4_2.c"
#line 269 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -284,7 +281,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 288 "gen/ragel/16__alt4_2.c"
#line 285 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr11:
@@ -292,7 +289,7 @@ static void lex(Input *in, Output *out)
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 296 "gen/ragel/16__alt4_2.c"
#line 293 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -308,7 +305,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 312 "gen/ragel/16__alt4_2.c"
#line 309 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr13:
@@ -316,79 +313,79 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 320 "gen/ragel/16__alt4_2.c"
#line 317 "gen/ragel/16__alt4_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b3 = p; }
#line 326 "gen/ragel/16__alt4_2.c"
#line 323 "gen/ragel/16__alt4_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 332 "gen/ragel/16__alt4_2.c"
#line 329 "gen/ragel/16__alt4_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a3 = p; }
#line 338 "gen/ragel/16__alt4_2.c"
#line 335 "gen/ragel/16__alt4_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 344 "gen/ragel/16__alt4_2.c"
#line 341 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b5 = p; }
#line 350 "gen/ragel/16__alt4_2.c"
#line 347 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b6 = p; a5 = a6 = NULL; }
#line 356 "gen/ragel/16__alt4_2.c"
#line 353 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a5 = p; }
#line 362 "gen/ragel/16__alt4_2.c"
#line 359 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a6 = p; b5 = b6 = NULL; }
#line 368 "gen/ragel/16__alt4_2.c"
#line 365 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 374 "gen/ragel/16__alt4_2.c"
#line 371 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 380 "gen/ragel/16__alt4_2.c"
#line 377 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 386 "gen/ragel/16__alt4_2.c"
#line 383 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 392 "gen/ragel/16__alt4_2.c"
#line 389 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -404,7 +401,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 408 "gen/ragel/16__alt4_2.c"
#line 405 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr16:
@@ -412,55 +409,55 @@ static void lex(Input *in, Output *out)
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 416 "gen/ragel/16__alt4_2.c"
#line 413 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b5 = p; }
#line 422 "gen/ragel/16__alt4_2.c"
#line 419 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b6 = p; a5 = a6 = NULL; }
#line 428 "gen/ragel/16__alt4_2.c"
#line 425 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a5 = p; }
#line 434 "gen/ragel/16__alt4_2.c"
#line 431 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a6 = p; b5 = b6 = NULL; }
#line 440 "gen/ragel/16__alt4_2.c"
#line 437 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 446 "gen/ragel/16__alt4_2.c"
#line 443 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 452 "gen/ragel/16__alt4_2.c"
#line 449 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 458 "gen/ragel/16__alt4_2.c"
#line 455 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 464 "gen/ragel/16__alt4_2.c"
#line 461 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -476,7 +473,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 480 "gen/ragel/16__alt4_2.c"
#line 477 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr19:
@@ -484,31 +481,31 @@ static void lex(Input *in, Output *out)
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b6 = p; a5 = a6 = NULL; }
#line 488 "gen/ragel/16__alt4_2.c"
#line 485 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 494 "gen/ragel/16__alt4_2.c"
#line 491 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 500 "gen/ragel/16__alt4_2.c"
#line 497 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 506 "gen/ragel/16__alt4_2.c"
#line 503 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 512 "gen/ragel/16__alt4_2.c"
#line 509 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -524,7 +521,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 528 "gen/ragel/16__alt4_2.c"
#line 525 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr22:
@@ -532,7 +529,7 @@ static void lex(Input *in, Output *out)
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 536 "gen/ragel/16__alt4_2.c"
#line 533 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -548,7 +545,7 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 552 "gen/ragel/16__alt4_2.c"
#line 549 "gen/ragel/16__alt4_2.c"
goto _st9;
_ctr24:
@@ -556,97 +553,97 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b1 = p; }
#line 560 "gen/ragel/16__alt4_2.c"
#line 557 "gen/ragel/16__alt4_2.c"
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 566 "gen/ragel/16__alt4_2.c"
#line 563 "gen/ragel/16__alt4_2.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a1 = p; }
#line 572 "gen/ragel/16__alt4_2.c"
#line 569 "gen/ragel/16__alt4_2.c"
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 578 "gen/ragel/16__alt4_2.c"
#line 575 "gen/ragel/16__alt4_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b3 = p; }
#line 584 "gen/ragel/16__alt4_2.c"
#line 581 "gen/ragel/16__alt4_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 590 "gen/ragel/16__alt4_2.c"
#line 587 "gen/ragel/16__alt4_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a3 = p; }
#line 596 "gen/ragel/16__alt4_2.c"
#line 593 "gen/ragel/16__alt4_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 602 "gen/ragel/16__alt4_2.c"
#line 599 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b5 = p; }
#line 608 "gen/ragel/16__alt4_2.c"
#line 605 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b6 = p; a5 = a6 = NULL; }
#line 614 "gen/ragel/16__alt4_2.c"
#line 611 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a5 = p; }
#line 620 "gen/ragel/16__alt4_2.c"
#line 617 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a6 = p; b5 = b6 = NULL; }
#line 626 "gen/ragel/16__alt4_2.c"
#line 623 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 632 "gen/ragel/16__alt4_2.c"
#line 629 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b8 = p; a7 = a8 = NULL; }
#line 638 "gen/ragel/16__alt4_2.c"
#line 635 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 644 "gen/ragel/16__alt4_2.c"
#line 641 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a8 = p; b7 = b8 = NULL; }
#line 650 "gen/ragel/16__alt4_2.c"
#line 647 "gen/ragel/16__alt4_2.c"
{
#line 35 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
@@ -662,14 +659,14 @@ static void lex(Input *in, Output *out)
outc(out, '\n');
}
#line 666 "gen/ragel/16__alt4_2.c"
#line 663 "gen/ragel/16__alt4_2.c"
goto _st9;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
switch( ( (*( p))) ) {
case 10: {
goto _ctr24;
@@ -681,26 +678,23 @@ static void lex(Input *in, Output *out)
goto _ctr26;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr25:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a1 = p; }
#line 697 "gen/ragel/16__alt4_2.c"
#line 691 "gen/ragel/16__alt4_2.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _ctr2;
@@ -712,28 +706,26 @@ static void lex(Input *in, Output *out)
goto _ctr3;
}
}
{
goto _st0;
}
goto _st0;
_ctr3:
{
#line 21 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a2 = p; b1 = b2 = NULL; }
#line 724 "gen/ragel/16__alt4_2.c"
#line 716 "gen/ragel/16__alt4_2.c"
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b3 = p; }
#line 730 "gen/ragel/16__alt4_2.c"
#line 722 "gen/ragel/16__alt4_2.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr5;
@@ -745,28 +737,26 @@ static void lex(Input *in, Output *out)
goto _st2;
}
}
{
goto _st0;
}
goto _st0;
_ctr6:
{
#line 24 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b4 = p; a3 = a4 = NULL; }
#line 757 "gen/ragel/16__alt4_2.c"
#line 747 "gen/ragel/16__alt4_2.c"
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a5 = p; }
#line 763 "gen/ragel/16__alt4_2.c"
#line 753 "gen/ragel/16__alt4_2.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr8;
@@ -778,28 +768,26 @@ static void lex(Input *in, Output *out)
goto _ctr9;
}
}
{
goto _st0;
}
goto _st0;
_ctr9:
{
#line 29 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a6 = p; b5 = b6 = NULL; }
#line 790 "gen/ragel/16__alt4_2.c"
#line 778 "gen/ragel/16__alt4_2.c"
{
#line 32 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b7 = p; }
#line 796 "gen/ragel/16__alt4_2.c"
#line 784 "gen/ragel/16__alt4_2.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 10: {
goto _ctr11;
@@ -808,22 +796,20 @@ static void lex(Input *in, Output *out)
goto _st4;
}
}
{
goto _st0;
}
goto _st0;
_ctr26:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b1 = p; }
#line 820 "gen/ragel/16__alt4_2.c"
#line 806 "gen/ragel/16__alt4_2.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr13;
@@ -835,28 +821,26 @@ static void lex(Input *in, Output *out)
goto _st5;
}
}
{
goto _st0;
}
goto _st0;
_ctr14:
{
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b2 = p; a1 = a2 = NULL; }
#line 847 "gen/ragel/16__alt4_2.c"
#line 831 "gen/ragel/16__alt4_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a3 = p; }
#line 853 "gen/ragel/16__alt4_2.c"
#line 837 "gen/ragel/16__alt4_2.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
switch( ( (*( p))) ) {
case 10: {
goto _ctr16;
@@ -868,28 +852,26 @@ static void lex(Input *in, Output *out)
goto _ctr17;
}
}
{
goto _st0;
}
goto _st0;
_ctr17:
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a4 = p; b3 = b4 = NULL; }
#line 880 "gen/ragel/16__alt4_2.c"
#line 862 "gen/ragel/16__alt4_2.c"
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b5 = p; }
#line 886 "gen/ragel/16__alt4_2.c"
#line 868 "gen/ragel/16__alt4_2.c"
goto _st7;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
switch( ( (*( p))) ) {
case 10: {
goto _ctr19;
@@ -901,28 +883,26 @@ static void lex(Input *in, Output *out)
goto _st7;
}
}
{
goto _st0;
}
goto _st0;
_ctr20:
{
#line 28 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
b6 = p; a5 = a6 = NULL; }
#line 913 "gen/ragel/16__alt4_2.c"
#line 893 "gen/ragel/16__alt4_2.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/16__alt4_2.rl"
a7 = p; }
#line 919 "gen/ragel/16__alt4_2.c"
#line 899 "gen/ragel/16__alt4_2.c"
goto _st8;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 10: {
goto _ctr22;
@@ -931,23 +911,17 @@ static void lex(Input *in, Output *out)
goto _st8;
}
}
{
goto _st0;
}
st_out:
_test_eof9: cs = 9; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof: {}
if ( cs >= 9 )
goto _out; _pop: {}
goto _st0;
_out9: cs = 9; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out: {}
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -39,8 +39,6 @@ static void lex(Input *in, Output *out)
#line 41 "gen/ragel/20__cat2_0.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 5:
goto st_case_5;
@@ -55,25 +53,24 @@ static void lex(Input *in, Output *out)
case 4:
goto st_case_4;
}
goto st_out;
_ctr2:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b0 = p; }
#line 65 "gen/ragel/20__cat2_0.c"
#line 62 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 71 "gen/ragel/20__cat2_0.c"
#line 68 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 77 "gen/ragel/20__cat2_0.c"
#line 74 "gen/ragel/20__cat2_0.c"
{
#line 11 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
@@ -82,7 +79,7 @@ static void lex(Input *in, Output *out)
outs(out, a1, b1); outc(out, '.'); outs(out, b1, p + 1);
}
#line 86 "gen/ragel/20__cat2_0.c"
#line 83 "gen/ragel/20__cat2_0.c"
goto _st5;
_ctr6:
@@ -90,13 +87,13 @@ static void lex(Input *in, Output *out)
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 94 "gen/ragel/20__cat2_0.c"
#line 91 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 100 "gen/ragel/20__cat2_0.c"
#line 97 "gen/ragel/20__cat2_0.c"
{
#line 11 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
@@ -105,7 +102,7 @@ static void lex(Input *in, Output *out)
outs(out, a1, b1); outc(out, '.'); outs(out, b1, p + 1);
}
#line 109 "gen/ragel/20__cat2_0.c"
#line 106 "gen/ragel/20__cat2_0.c"
goto _st5;
_ctr10:
@@ -113,7 +110,7 @@ static void lex(Input *in, Output *out)
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 117 "gen/ragel/20__cat2_0.c"
#line 114 "gen/ragel/20__cat2_0.c"
{
#line 11 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
@@ -122,7 +119,7 @@ static void lex(Input *in, Output *out)
outs(out, a1, b1); outc(out, '.'); outs(out, b1, p + 1);
}
#line 126 "gen/ragel/20__cat2_0.c"
#line 123 "gen/ragel/20__cat2_0.c"
goto _st5;
_ctr13:
@@ -133,7 +130,7 @@ static void lex(Input *in, Output *out)
outs(out, a1, b1); outc(out, '.'); outs(out, b1, p + 1);
}
#line 137 "gen/ragel/20__cat2_0.c"
#line 134 "gen/ragel/20__cat2_0.c"
goto _st5;
_ctr15:
@@ -141,25 +138,25 @@ static void lex(Input *in, Output *out)
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a0 = p; }
#line 145 "gen/ragel/20__cat2_0.c"
#line 142 "gen/ragel/20__cat2_0.c"
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b0 = p; }
#line 151 "gen/ragel/20__cat2_0.c"
#line 148 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 157 "gen/ragel/20__cat2_0.c"
#line 154 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 163 "gen/ragel/20__cat2_0.c"
#line 160 "gen/ragel/20__cat2_0.c"
{
#line 11 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
@@ -168,14 +165,14 @@ static void lex(Input *in, Output *out)
outs(out, a1, b1); outc(out, '.'); outs(out, b1, p + 1);
}
#line 172 "gen/ragel/20__cat2_0.c"
#line 169 "gen/ragel/20__cat2_0.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr15;
@@ -187,25 +184,22 @@ static void lex(Input *in, Output *out)
goto _ctr17;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr3:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b0 = p; }
#line 203 "gen/ragel/20__cat2_0.c"
#line 197 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 209 "gen/ragel/20__cat2_0.c"
#line 203 "gen/ragel/20__cat2_0.c"
goto _st1;
_ctr16:
@@ -213,26 +207,26 @@ static void lex(Input *in, Output *out)
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a0 = p; }
#line 217 "gen/ragel/20__cat2_0.c"
#line 211 "gen/ragel/20__cat2_0.c"
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b0 = p; }
#line 223 "gen/ragel/20__cat2_0.c"
#line 217 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 229 "gen/ragel/20__cat2_0.c"
#line 223 "gen/ragel/20__cat2_0.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
switch( ( (*( p))) ) {
case 10: {
goto _ctr2;
@@ -244,27 +238,25 @@ static void lex(Input *in, Output *out)
goto _ctr4;
}
}
{
goto _st0;
}
goto _st0;
_ctr4:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b0 = p; }
#line 256 "gen/ragel/20__cat2_0.c"
#line 248 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 262 "gen/ragel/20__cat2_0.c"
#line 254 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 268 "gen/ragel/20__cat2_0.c"
#line 260 "gen/ragel/20__cat2_0.c"
goto _st2;
_ctr8:
@@ -272,13 +264,13 @@ static void lex(Input *in, Output *out)
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 276 "gen/ragel/20__cat2_0.c"
#line 268 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 282 "gen/ragel/20__cat2_0.c"
#line 274 "gen/ragel/20__cat2_0.c"
goto _st2;
_ctr17:
@@ -286,32 +278,32 @@ static void lex(Input *in, Output *out)
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a0 = p; }
#line 290 "gen/ragel/20__cat2_0.c"
#line 282 "gen/ragel/20__cat2_0.c"
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b0 = p; }
#line 296 "gen/ragel/20__cat2_0.c"
#line 288 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 302 "gen/ragel/20__cat2_0.c"
#line 294 "gen/ragel/20__cat2_0.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 308 "gen/ragel/20__cat2_0.c"
#line 300 "gen/ragel/20__cat2_0.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr6;
@@ -323,22 +315,20 @@ static void lex(Input *in, Output *out)
goto _ctr8;
}
}
{
goto _st0;
}
goto _st0;
_ctr7:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
a1 = p; }
#line 335 "gen/ragel/20__cat2_0.c"
#line 325 "gen/ragel/20__cat2_0.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr10;
@@ -350,22 +340,20 @@ static void lex(Input *in, Output *out)
goto _ctr11;
}
}
{
goto _st0;
}
goto _st0;
_ctr11:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/20__cat2_0.rl"
b1 = p; }
#line 362 "gen/ragel/20__cat2_0.c"
#line 350 "gen/ragel/20__cat2_0.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 10: {
goto _ctr13;
@@ -374,19 +362,13 @@ static void lex(Input *in, Output *out)
goto _st4;
}
}
{
goto _st0;
}
st_out:
_test_eof5: cs = 5; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof: {}
if ( cs >= 5 )
goto _out; _pop: {}
goto _st0;
_out5: cs = 5; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out: {}
}
@@ -39,8 +39,6 @@ static void lex(Input *in, Output *out)
#line 41 "gen/ragel/21__cat2_4.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 16:
goto st_case_16;
@@ -77,7 +75,6 @@ static void lex(Input *in, Output *out)
case 15:
goto st_case_15;
}
goto st_out;
_ctr17:
{
#line 11 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
@@ -86,100 +83,91 @@ static void lex(Input *in, Output *out)
outs(out, a1, b1); outc(out, '.'); outs(out, b1, p + 1);
}
#line 90 "gen/ragel/21__cat2_4.c"
#line 87 "gen/ragel/21__cat2_4.c"
goto _st16;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
if ( ( (*( p))) == 97 ) {
goto _ctr29;
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr29:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
a0 = p; }
#line 113 "gen/ragel/21__cat2_4.c"
#line 107 "gen/ragel/21__cat2_4.c"
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 119 "gen/ragel/21__cat2_4.c"
#line 113 "gen/ragel/21__cat2_4.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _ctr2;
}
{
goto _st0;
}
goto _st0;
_ctr2:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 138 "gen/ragel/21__cat2_4.c"
#line 130 "gen/ragel/21__cat2_4.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _ctr4;
}
{
goto _st0;
}
goto _st0;
_ctr4:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 157 "gen/ragel/21__cat2_4.c"
#line 147 "gen/ragel/21__cat2_4.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _ctr6;
}
{
goto _st0;
}
goto _st0;
_ctr6:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 176 "gen/ragel/21__cat2_4.c"
#line 164 "gen/ragel/21__cat2_4.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
switch( ( (*( p))) ) {
case 97: {
goto _ctr8;
@@ -188,34 +176,32 @@ static void lex(Input *in, Output *out)
goto _st15;
}
}
{
goto _st0;
}
goto _st0;
_ctr8:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 200 "gen/ragel/21__cat2_4.c"
#line 186 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
a1 = p; }
#line 206 "gen/ragel/21__cat2_4.c"
#line 192 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 212 "gen/ragel/21__cat2_4.c"
#line 198 "gen/ragel/21__cat2_4.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 97: {
goto _ctr11;
@@ -224,34 +210,32 @@ static void lex(Input *in, Output *out)
goto _st15;
}
}
{
goto _st0;
}
goto _st0;
_ctr11:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 236 "gen/ragel/21__cat2_4.c"
#line 220 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
a1 = p; }
#line 242 "gen/ragel/21__cat2_4.c"
#line 226 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 248 "gen/ragel/21__cat2_4.c"
#line 232 "gen/ragel/21__cat2_4.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
switch( ( (*( p))) ) {
case 97: {
goto _ctr13;
@@ -260,34 +244,32 @@ static void lex(Input *in, Output *out)
goto _st15;
}
}
{
goto _st0;
}
goto _st0;
_ctr13:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 272 "gen/ragel/21__cat2_4.c"
#line 254 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
a1 = p; }
#line 278 "gen/ragel/21__cat2_4.c"
#line 260 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 284 "gen/ragel/21__cat2_4.c"
#line 266 "gen/ragel/21__cat2_4.c"
goto _st7;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
switch( ( (*( p))) ) {
case 97: {
goto _ctr15;
@@ -296,34 +278,32 @@ static void lex(Input *in, Output *out)
goto _st15;
}
}
{
goto _st0;
}
goto _st0;
_ctr15:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b0 = p; }
#line 308 "gen/ragel/21__cat2_4.c"
#line 288 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
a1 = p; }
#line 314 "gen/ragel/21__cat2_4.c"
#line 294 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 320 "gen/ragel/21__cat2_4.c"
#line 300 "gen/ragel/21__cat2_4.c"
goto _st8;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 10: {
goto _ctr17;
@@ -335,14 +315,12 @@ static void lex(Input *in, Output *out)
goto _st9;
}
}
{
goto _st0;
}
goto _st0;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
switch( ( (*( p))) ) {
case 10: {
goto _ctr17;
@@ -354,85 +332,77 @@ static void lex(Input *in, Output *out)
goto _st9;
}
}
{
goto _st0;
}
goto _st0;
_ctr19:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
a1 = p; }
#line 366 "gen/ragel/21__cat2_4.c"
#line 342 "gen/ragel/21__cat2_4.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 372 "gen/ragel/21__cat2_4.c"
#line 348 "gen/ragel/21__cat2_4.c"
goto _st10;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 97 ) {
goto _ctr21;
}
{
goto _st0;
}
goto _st0;
_ctr21:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 391 "gen/ragel/21__cat2_4.c"
#line 365 "gen/ragel/21__cat2_4.c"
goto _st11;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
if ( ( (*( p))) == 97 ) {
goto _ctr23;
}
{
goto _st0;
}
goto _st0;
_ctr23:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 410 "gen/ragel/21__cat2_4.c"
#line 382 "gen/ragel/21__cat2_4.c"
goto _st12;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( ( (*( p))) == 97 ) {
goto _ctr25;
}
{
goto _st0;
}
goto _st0;
_ctr25:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/21__cat2_4.rl"
b1 = p; }
#line 429 "gen/ragel/21__cat2_4.c"
#line 399 "gen/ragel/21__cat2_4.c"
goto _st13;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
switch( ( (*( p))) ) {
case 10: {
goto _ctr17;
@@ -444,14 +414,12 @@ static void lex(Input *in, Output *out)
goto _st14;
}
}
{
goto _st0;
}
goto _st0;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
switch( ( (*( p))) ) {
case 10: {
goto _ctr17;
@@ -460,14 +428,12 @@ static void lex(Input *in, Output *out)
goto _st14;
}
}
{
goto _st0;
}
goto _st0;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
if ( p == pe )
goto _out15;
switch( ( (*( p))) ) {
case 97: {
goto _ctr19;
@@ -476,30 +442,24 @@ static void lex(Input *in, Output *out)
goto _st15;
}
}
{
goto _st0;
}
st_out:
_test_eof16: cs = 16; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof: {}
if ( cs >= 16 )
goto _out; _pop: {}
goto _st0;
_out16: cs = 16; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out: {}
}
@@ -39,8 +39,6 @@ static void lex(Input *in, Output *out)
#line 41 "gen/ragel/22__cat2_8.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 28:
goto st_case_28;
@@ -101,7 +99,6 @@ static void lex(Input *in, Output *out)
case 27:
goto st_case_27;
}
goto st_out;
_ctr33:
{
#line 11 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
@@ -110,176 +107,159 @@ static void lex(Input *in, Output *out)
outs(out, a1, b1); outc(out, '.'); outs(out, b1, p + 1);
}
#line 114 "gen/ragel/22__cat2_8.c"
#line 111 "gen/ragel/22__cat2_8.c"
goto _st28;
_st28:
p+= 1;
if ( p == pe )
goto _test_eof28;
st_case_28:
if ( p == pe )
goto _out28;
if ( ( (*( p))) == 97 ) {
goto _ctr53;
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr53:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a0 = p; }
#line 137 "gen/ragel/22__cat2_8.c"
#line 131 "gen/ragel/22__cat2_8.c"
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 143 "gen/ragel/22__cat2_8.c"
#line 137 "gen/ragel/22__cat2_8.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _ctr2;
}
{
goto _st0;
}
goto _st0;
_ctr2:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 162 "gen/ragel/22__cat2_8.c"
#line 154 "gen/ragel/22__cat2_8.c"
goto _st2;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _ctr4;
}
{
goto _st0;
}
goto _st0;
_ctr4:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 181 "gen/ragel/22__cat2_8.c"
#line 171 "gen/ragel/22__cat2_8.c"
goto _st3;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _ctr6;
}
{
goto _st0;
}
goto _st0;
_ctr6:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 200 "gen/ragel/22__cat2_8.c"
#line 188 "gen/ragel/22__cat2_8.c"
goto _st4;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _ctr8;
}
{
goto _st0;
}
goto _st0;
_ctr8:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 219 "gen/ragel/22__cat2_8.c"
#line 205 "gen/ragel/22__cat2_8.c"
goto _st5;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 97 ) {
goto _ctr10;
}
{
goto _st0;
}
goto _st0;
_ctr10:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 238 "gen/ragel/22__cat2_8.c"
#line 222 "gen/ragel/22__cat2_8.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 97 ) {
goto _ctr12;
}
{
goto _st0;
}
goto _st0;
_ctr12:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 257 "gen/ragel/22__cat2_8.c"
#line 239 "gen/ragel/22__cat2_8.c"
goto _st7;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 97 ) {
goto _ctr14;
}
{
goto _st0;
}
goto _st0;
_ctr14:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 276 "gen/ragel/22__cat2_8.c"
#line 256 "gen/ragel/22__cat2_8.c"
goto _st8;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
switch( ( (*( p))) ) {
case 97: {
goto _ctr16;
@@ -288,34 +268,32 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
goto _st0;
_ctr16:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 300 "gen/ragel/22__cat2_8.c"
#line 278 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 306 "gen/ragel/22__cat2_8.c"
#line 284 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 312 "gen/ragel/22__cat2_8.c"
#line 290 "gen/ragel/22__cat2_8.c"
goto _st9;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
switch( ( (*( p))) ) {
case 97: {
goto _ctr19;
@@ -324,34 +302,32 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
goto _st0;
_ctr19:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 336 "gen/ragel/22__cat2_8.c"
#line 312 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 342 "gen/ragel/22__cat2_8.c"
#line 318 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 348 "gen/ragel/22__cat2_8.c"
#line 324 "gen/ragel/22__cat2_8.c"
goto _st10;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
switch( ( (*( p))) ) {
case 97: {
goto _ctr21;
@@ -360,34 +336,32 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
goto _st0;
_ctr21:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 372 "gen/ragel/22__cat2_8.c"
#line 346 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 378 "gen/ragel/22__cat2_8.c"
#line 352 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 384 "gen/ragel/22__cat2_8.c"
#line 358 "gen/ragel/22__cat2_8.c"
goto _st11;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
switch( ( (*( p))) ) {
case 97: {
goto _ctr23;
@@ -396,34 +370,32 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
goto _st0;
_ctr23:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 408 "gen/ragel/22__cat2_8.c"
#line 380 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 414 "gen/ragel/22__cat2_8.c"
#line 386 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 420 "gen/ragel/22__cat2_8.c"
#line 392 "gen/ragel/22__cat2_8.c"
goto _st12;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
switch( ( (*( p))) ) {
case 97: {
goto _ctr25;
@@ -432,34 +404,32 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
goto _st0;
_ctr25:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 444 "gen/ragel/22__cat2_8.c"
#line 414 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 450 "gen/ragel/22__cat2_8.c"
#line 420 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 456 "gen/ragel/22__cat2_8.c"
#line 426 "gen/ragel/22__cat2_8.c"
goto _st13;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
switch( ( (*( p))) ) {
case 97: {
goto _ctr27;
@@ -468,34 +438,32 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
goto _st0;
_ctr27:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 480 "gen/ragel/22__cat2_8.c"
#line 448 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 486 "gen/ragel/22__cat2_8.c"
#line 454 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 492 "gen/ragel/22__cat2_8.c"
#line 460 "gen/ragel/22__cat2_8.c"
goto _st14;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
switch( ( (*( p))) ) {
case 97: {
goto _ctr29;
@@ -504,14 +472,46 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
goto _st0;
_ctr29:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 482 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 488 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 494 "gen/ragel/22__cat2_8.c"
goto _st15;
_st15:
p+= 1;
st_case_15:
if ( p == pe )
goto _out15;
switch( ( (*( p))) ) {
case 97: {
goto _ctr31;
}
case 98: {
goto _st27;
}
}
goto _st0;
_ctr31:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 516 "gen/ragel/22__cat2_8.c"
{
@@ -526,48 +526,12 @@ static void lex(Input *in, Output *out)
#line 528 "gen/ragel/22__cat2_8.c"
goto _st15;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
switch( ( (*( p))) ) {
case 97: {
goto _ctr31;
}
case 98: {
goto _st27;
}
}
{
goto _st0;
}
_ctr31:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b0 = p; }
#line 552 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 558 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 564 "gen/ragel/22__cat2_8.c"
goto _st16;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
switch( ( (*( p))) ) {
case 10: {
goto _ctr33;
@@ -579,14 +543,12 @@ static void lex(Input *in, Output *out)
goto _st17;
}
}
{
goto _st0;
}
goto _st0;
_st17:
p+= 1;
if ( p == pe )
goto _test_eof17;
st_case_17:
if ( p == pe )
goto _out17;
switch( ( (*( p))) ) {
case 10: {
goto _ctr33;
@@ -598,161 +560,145 @@ static void lex(Input *in, Output *out)
goto _st17;
}
}
{
goto _st0;
}
goto _st0;
_ctr35:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
a1 = p; }
#line 610 "gen/ragel/22__cat2_8.c"
#line 570 "gen/ragel/22__cat2_8.c"
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 616 "gen/ragel/22__cat2_8.c"
#line 576 "gen/ragel/22__cat2_8.c"
goto _st18;
_st18:
p+= 1;
if ( p == pe )
goto _test_eof18;
st_case_18:
if ( p == pe )
goto _out18;
if ( ( (*( p))) == 97 ) {
goto _ctr37;
}
{
goto _st0;
}
goto _st0;
_ctr37:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 635 "gen/ragel/22__cat2_8.c"
#line 593 "gen/ragel/22__cat2_8.c"
goto _st19;
_st19:
p+= 1;
if ( p == pe )
goto _test_eof19;
st_case_19:
if ( p == pe )
goto _out19;
if ( ( (*( p))) == 97 ) {
goto _ctr39;
}
{
goto _st0;
}
goto _st0;
_ctr39:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 654 "gen/ragel/22__cat2_8.c"
#line 610 "gen/ragel/22__cat2_8.c"
goto _st20;
_st20:
p+= 1;
if ( p == pe )
goto _test_eof20;
st_case_20:
if ( p == pe )
goto _out20;
if ( ( (*( p))) == 97 ) {
goto _ctr41;
}
{
goto _st0;
}
goto _st0;
_ctr41:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 673 "gen/ragel/22__cat2_8.c"
#line 627 "gen/ragel/22__cat2_8.c"
goto _st21;
_st21:
p+= 1;
if ( p == pe )
goto _test_eof21;
st_case_21:
if ( p == pe )
goto _out21;
if ( ( (*( p))) == 97 ) {
goto _ctr43;
}
{
goto _st0;
}
goto _st0;
_ctr43:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 692 "gen/ragel/22__cat2_8.c"
#line 644 "gen/ragel/22__cat2_8.c"
goto _st22;
_st22:
p+= 1;
if ( p == pe )
goto _test_eof22;
st_case_22:
if ( p == pe )
goto _out22;
if ( ( (*( p))) == 97 ) {
goto _ctr45;
}
{
goto _st0;
}
goto _st0;
_ctr45:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 711 "gen/ragel/22__cat2_8.c"
#line 661 "gen/ragel/22__cat2_8.c"
goto _st23;
_st23:
p+= 1;
if ( p == pe )
goto _test_eof23;
st_case_23:
if ( p == pe )
goto _out23;
if ( ( (*( p))) == 97 ) {
goto _ctr47;
}
{
goto _st0;
}
goto _st0;
_ctr47:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 730 "gen/ragel/22__cat2_8.c"
#line 678 "gen/ragel/22__cat2_8.c"
goto _st24;
_st24:
p+= 1;
if ( p == pe )
goto _test_eof24;
st_case_24:
if ( p == pe )
goto _out24;
if ( ( (*( p))) == 97 ) {
goto _ctr49;
}
{
goto _st0;
}
goto _st0;
_ctr49:
{
#line 10 "../../../benchmarks/submatch_dfa_aot/src/ragel/22__cat2_8.rl"
b1 = p; }
#line 749 "gen/ragel/22__cat2_8.c"
#line 695 "gen/ragel/22__cat2_8.c"
goto _st25;
_st25:
p+= 1;
if ( p == pe )
goto _test_eof25;
st_case_25:
if ( p == pe )
goto _out25;
switch( ( (*( p))) ) {
case 10: {
goto _ctr33;
@@ -764,14 +710,12 @@ static void lex(Input *in, Output *out)
goto _st26;
}
}
{
goto _st0;
}
goto _st0;
_st26:
p+= 1;
if ( p == pe )
goto _test_eof26;
st_case_26:
if ( p == pe )
goto _out26;
switch( ( (*( p))) ) {
case 10: {
goto _ctr33;
@@ -780,14 +724,12 @@ static void lex(Input *in, Output *out)
goto _st26;
}
}
{
goto _st0;
}
goto _st0;
_st27:
p+= 1;
if ( p == pe )
goto _test_eof27;
st_case_27:
if ( p == pe )
goto _out27;
switch( ( (*( p))) ) {
case 97: {
goto _ctr35;
@@ -796,42 +738,36 @@ static void lex(Input *in, Output *out)
goto _st27;
}
}
{
goto _st0;
}
st_out:
_test_eof28: cs = 28; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof16: cs = 16; goto _test_eof;
_test_eof17: cs = 17; goto _test_eof;
_test_eof18: cs = 18; goto _test_eof;
_test_eof19: cs = 19; goto _test_eof;
_test_eof20: cs = 20; goto _test_eof;
_test_eof21: cs = 21; goto _test_eof;
_test_eof22: cs = 22; goto _test_eof;
_test_eof23: cs = 23; goto _test_eof;
_test_eof24: cs = 24; goto _test_eof;
_test_eof25: cs = 25; goto _test_eof;
_test_eof26: cs = 26; goto _test_eof;
_test_eof27: cs = 27; goto _test_eof;
_test_eof: {}
if ( cs >= 28 )
goto _out; _pop: {}
goto _st0;
_out28: cs = 28; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out16: cs = 16; goto _out;
_out17: cs = 17; goto _out;
_out18: cs = 18; goto _out;
_out19: cs = 19; goto _out;
_out20: cs = 20; goto _out;
_out21: cs = 21; goto _out;
_out22: cs = 22; goto _out;
_out23: cs = 23; goto _out;
_out24: cs = 24; goto _out;
_out25: cs = 25; goto _out;
_out26: cs = 26; goto _out;
_out27: cs = 27; goto _out;
_out: {}
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/30__rep_cat_5_3_2.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 11:
goto st_case_11;
@@ -65,7 +63,6 @@ static void lex(Input *in, Output *out)
case 10:
goto st_case_10;
}
goto st_out;
_ctr13:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/30__rep_cat_5_3_2.rl"
@@ -75,13 +72,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 79 "gen/ragel/30__rep_cat_5_3_2.c"
#line 76 "gen/ragel/30__rep_cat_5_3_2.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/30__rep_cat_5_3_2.rl"
outc(out, '\n'); }
#line 85 "gen/ragel/30__rep_cat_5_3_2.c"
#line 82 "gen/ragel/30__rep_cat_5_3_2.c"
goto _st11;
_ctr16:
@@ -89,14 +86,14 @@ static void lex(Input *in, Output *out)
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/30__rep_cat_5_3_2.rl"
outc(out, '\n'); }
#line 93 "gen/ragel/30__rep_cat_5_3_2.c"
#line 90 "gen/ragel/30__rep_cat_5_3_2.c"
goto _st11;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
switch( ( (*( p))) ) {
case 10: {
goto _ctr16;
@@ -105,13 +102,10 @@ static void lex(Input *in, Output *out)
goto _st1;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr14:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/30__rep_cat_5_3_2.rl"
@@ -121,64 +115,54 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 125 "gen/ragel/30__rep_cat_5_3_2.c"
#line 119 "gen/ragel/30__rep_cat_5_3_2.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 97 ) {
goto _ctr6;
}
{
goto _st0;
}
goto _st0;
_ctr6:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/30__rep_cat_5_3_2.rl"
@@ -188,42 +172,36 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 192 "gen/ragel/30__rep_cat_5_3_2.c"
#line 176 "gen/ragel/30__rep_cat_5_3_2.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 97 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 97 ) {
goto _st8;
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
if ( ( (*( p))) == 97 ) {
goto _ctr10;
}
{
goto _st0;
}
goto _st0;
_ctr10:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/30__rep_cat_5_3_2.rl"
@@ -233,25 +211,23 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 237 "gen/ragel/30__rep_cat_5_3_2.c"
#line 215 "gen/ragel/30__rep_cat_5_3_2.c"
goto _st9;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( ( (*( p))) == 97 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
switch( ( (*( p))) ) {
case 10: {
goto _ctr13;
@@ -260,25 +236,19 @@ static void lex(Input *in, Output *out)
goto _ctr14;
}
}
{
goto _st0;
}
st_out:
_test_eof11: cs = 11; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof: {}
if ( cs >= 11 )
goto _out; _pop: {}
goto _st0;
_out11: cs = 11; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out: {}
}
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/31__rep_cat_13_11_7.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 32:
goto st_case_32;
@@ -107,7 +105,6 @@ static void lex(Input *in, Output *out)
case 31:
goto st_case_31;
}
goto st_out;
_ctr34:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/31__rep_cat_13_11_7.rl"
@@ -117,13 +114,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 121 "gen/ragel/31__rep_cat_13_11_7.c"
#line 118 "gen/ragel/31__rep_cat_13_11_7.c"
{
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/31__rep_cat_13_11_7.rl"
outc(out, '\n'); }
#line 127 "gen/ragel/31__rep_cat_13_11_7.c"
#line 124 "gen/ragel/31__rep_cat_13_11_7.c"
goto _st32;
_ctr37:
@@ -131,14 +128,14 @@ static void lex(Input *in, Output *out)
#line 25 "../../../benchmarks/submatch_dfa_aot/src/ragel/31__rep_cat_13_11_7.rl"
outc(out, '\n'); }
#line 135 "gen/ragel/31__rep_cat_13_11_7.c"
#line 132 "gen/ragel/31__rep_cat_13_11_7.c"
goto _st32;
_st32:
p+= 1;
if ( p == pe )
goto _test_eof32;
st_case_32:
if ( p == pe )
goto _out32;
switch( ( (*( p))) ) {
case 10: {
goto _ctr37;
@@ -147,13 +144,10 @@ static void lex(Input *in, Output *out)
goto _st1;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr35:
{
#line 19 "../../../benchmarks/submatch_dfa_aot/src/ragel/31__rep_cat_13_11_7.rl"
@@ -163,152 +157,126 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 167 "gen/ragel/31__rep_cat_13_11_7.c"
#line 161 "gen/ragel/31__rep_cat_13_11_7.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 97 ) {
goto _st6;
}
{
goto _st0;
}
goto _st0;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 97 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 97 ) {
goto _st8;
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
if ( ( (*( p))) == 97 ) {
goto _st9;
}
{
goto _st0;
}
goto _st0;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( ( (*( p))) == 97 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 97 ) {
goto _st11;
}
{
goto _st0;
}
goto _st0;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
if ( ( (*( p))) == 97 ) {
goto _st12;
}
{
goto _st0;
}
goto _st0;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( ( (*( p))) == 97 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
if ( ( (*( p))) == 97 ) {
goto _ctr14;
}
{
goto _st0;
}
goto _st0;
_ctr14:
{
#line 9 "../../../benchmarks/submatch_dfa_aot/src/ragel/31__rep_cat_13_11_7.rl"
@@ -318,130 +286,108 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 322 "gen/ragel/31__rep_cat_13_11_7.c"
#line 290 "gen/ragel/31__rep_cat_13_11_7.c"
goto _st14;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
if ( ( (*( p))) == 97 ) {
goto _st15;
}
{
goto _st0;
}
goto _st0;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
if ( p == pe )
goto _out15;
if ( ( (*( p))) == 97 ) {
goto _st16;
}
{
goto _st0;
}
goto _st0;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
if ( ( (*( p))) == 97 ) {
goto _st17;
}
{
goto _st0;
}
goto _st0;
_st17:
p+= 1;
if ( p == pe )
goto _test_eof17;
st_case_17:
if ( p == pe )
goto _out17;
if ( ( (*( p))) == 97 ) {
goto _st18;
}
{
goto _st0;
}
goto _st0;
_st18:
p+= 1;
if ( p == pe )
goto _test_eof18;
st_case_18:
if ( p == pe )
goto _out18;
if ( ( (*( p))) == 97 ) {
goto _st19;
}
{
goto _st0;
}
goto _st0;
_st19:
p+= 1;
if ( p == pe )
goto _test_eof19;
st_case_19:
if ( p == pe )
goto _out19;
if ( ( (*( p))) == 97 ) {
goto _st20;
}
{
goto _st0;
}
goto _st0;
_st20:
p+= 1;
if ( p == pe )
goto _test_eof20;
st_case_20:
if ( p == pe )
goto _out20;
if ( ( (*( p))) == 97 ) {
goto _st21;
}
{
goto _st0;
}
goto _st0;
_st21:
p+= 1;
if ( p == pe )
goto _test_eof21;
st_case_21:
if ( p == pe )
goto _out21;
if ( ( (*( p))) == 97 ) {
goto _st22;
}
{
goto _st0;
}
goto _st0;
_st22:
p+= 1;
if ( p == pe )
goto _test_eof22;
st_case_22:
if ( p == pe )
goto _out22;
if ( ( (*( p))) == 97 ) {
goto _st23;
}
{
goto _st0;
}
goto _st0;
_st23:
p+= 1;
if ( p == pe )
goto _test_eof23;
st_case_23:
if ( p == pe )
goto _out23;
if ( ( (*( p))) == 97 ) {
goto _st24;
}
{
goto _st0;
}
goto _st0;
_st24:
p+= 1;
if ( p == pe )
goto _test_eof24;
st_case_24:
if ( p == pe )
goto _out24;
if ( ( (*( p))) == 97 ) {
goto _ctr26;
}
{
goto _st0;
}
goto _st0;
_ctr26:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/31__rep_cat_13_11_7.rl"
@@ -451,80 +397,68 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 455 "gen/ragel/31__rep_cat_13_11_7.c"
#line 401 "gen/ragel/31__rep_cat_13_11_7.c"
goto _st25;
_st25:
p+= 1;
if ( p == pe )
goto _test_eof25;
st_case_25:
if ( p == pe )
goto _out25;
if ( ( (*( p))) == 97 ) {
goto _st26;
}
{
goto _st0;
}
goto _st0;
_st26:
p+= 1;
if ( p == pe )
goto _test_eof26;
st_case_26:
if ( p == pe )
goto _out26;
if ( ( (*( p))) == 97 ) {
goto _st27;
}
{
goto _st0;
}
goto _st0;
_st27:
p+= 1;
if ( p == pe )
goto _test_eof27;
st_case_27:
if ( p == pe )
goto _out27;
if ( ( (*( p))) == 97 ) {
goto _st28;
}
{
goto _st0;
}
goto _st0;
_st28:
p+= 1;
if ( p == pe )
goto _test_eof28;
st_case_28:
if ( p == pe )
goto _out28;
if ( ( (*( p))) == 97 ) {
goto _st29;
}
{
goto _st0;
}
goto _st0;
_st29:
p+= 1;
if ( p == pe )
goto _test_eof29;
st_case_29:
if ( p == pe )
goto _out29;
if ( ( (*( p))) == 97 ) {
goto _st30;
}
{
goto _st0;
}
goto _st0;
_st30:
p+= 1;
if ( p == pe )
goto _test_eof30;
st_case_30:
if ( p == pe )
goto _out30;
if ( ( (*( p))) == 97 ) {
goto _st31;
}
{
goto _st0;
}
goto _st0;
_st31:
p+= 1;
if ( p == pe )
goto _test_eof31;
st_case_31:
if ( p == pe )
goto _out31;
switch( ( (*( p))) ) {
case 10: {
goto _ctr34;
@@ -533,46 +467,40 @@ static void lex(Input *in, Output *out)
goto _ctr35;
}
}
{
goto _st0;
}
st_out:
_test_eof32: cs = 32; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof16: cs = 16; goto _test_eof;
_test_eof17: cs = 17; goto _test_eof;
_test_eof18: cs = 18; goto _test_eof;
_test_eof19: cs = 19; goto _test_eof;
_test_eof20: cs = 20; goto _test_eof;
_test_eof21: cs = 21; goto _test_eof;
_test_eof22: cs = 22; goto _test_eof;
_test_eof23: cs = 23; goto _test_eof;
_test_eof24: cs = 24; goto _test_eof;
_test_eof25: cs = 25; goto _test_eof;
_test_eof26: cs = 26; goto _test_eof;
_test_eof27: cs = 27; goto _test_eof;
_test_eof28: cs = 28; goto _test_eof;
_test_eof29: cs = 29; goto _test_eof;
_test_eof30: cs = 30; goto _test_eof;
_test_eof31: cs = 31; goto _test_eof;
_test_eof: {}
if ( cs >= 32 )
goto _out; _pop: {}
goto _st0;
_out32: cs = 32; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out16: cs = 16; goto _out;
_out17: cs = 17; goto _out;
_out18: cs = 18; goto _out;
_out19: cs = 19; goto _out;
_out20: cs = 20; goto _out;
_out21: cs = 21; goto _out;
_out22: cs = 22; goto _out;
_out23: cs = 23; goto _out;
_out24: cs = 24; goto _out;
_out25: cs = 25; goto _out;
_out26: cs = 26; goto _out;
_out27: cs = 27; goto _out;
_out28: cs = 28; goto _out;
_out29: cs = 29; goto _out;
_out30: cs = 30; goto _out;
_out31: cs = 31; goto _out;
_out: {}
}
File diff suppressed because it is too large Load Diff
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/33__rep_alt_5_3_2.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 6:
goto st_case_6;
@@ -55,7 +53,6 @@ static void lex(Input *in, Output *out)
case 5:
goto st_case_5;
}
goto st_out;
_ctr3:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/33__rep_alt_5_3_2.rl"
@@ -65,13 +62,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 69 "gen/ragel/33__rep_alt_5_3_2.c"
#line 66 "gen/ragel/33__rep_alt_5_3_2.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/33__rep_alt_5_3_2.rl"
outc(out, '\n'); }
#line 75 "gen/ragel/33__rep_alt_5_3_2.c"
#line 72 "gen/ragel/33__rep_alt_5_3_2.c"
goto _st6;
_ctr9:
@@ -79,20 +76,20 @@ static void lex(Input *in, Output *out)
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/33__rep_alt_5_3_2.rl"
s = p; }
#line 83 "gen/ragel/33__rep_alt_5_3_2.c"
#line 80 "gen/ragel/33__rep_alt_5_3_2.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/33__rep_alt_5_3_2.rl"
outc(out, '\n'); }
#line 89 "gen/ragel/33__rep_alt_5_3_2.c"
#line 86 "gen/ragel/33__rep_alt_5_3_2.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
switch( ( (*( p))) ) {
case 10: {
goto _ctr9;
@@ -101,13 +98,10 @@ static void lex(Input *in, Output *out)
goto _ctr10;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr7:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/33__rep_alt_5_3_2.rl"
@@ -117,7 +111,7 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 121 "gen/ragel/33__rep_alt_5_3_2.c"
#line 115 "gen/ragel/33__rep_alt_5_3_2.c"
goto _st1;
_ctr10:
@@ -125,25 +119,23 @@ static void lex(Input *in, Output *out)
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/33__rep_alt_5_3_2.rl"
s = p; }
#line 129 "gen/ragel/33__rep_alt_5_3_2.c"
#line 123 "gen/ragel/33__rep_alt_5_3_2.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
switch( ( (*( p))) ) {
case 10: {
goto _ctr3;
@@ -152,14 +144,12 @@ static void lex(Input *in, Output *out)
goto _st3;
}
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
switch( ( (*( p))) ) {
case 10: {
goto _ctr3;
@@ -168,25 +158,21 @@ static void lex(Input *in, Output *out)
goto _st4;
}
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr3;
@@ -195,20 +181,14 @@ static void lex(Input *in, Output *out)
goto _ctr7;
}
}
{
goto _st0;
}
st_out:
_test_eof6: cs = 6; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof: {}
if ( cs >= 6 )
goto _out; _pop: {}
goto _st0;
_out6: cs = 6; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out: {}
}
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/34__rep_alt_13_11_7.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 14:
goto st_case_14;
@@ -71,7 +69,6 @@ static void lex(Input *in, Output *out)
case 13:
goto st_case_13;
}
goto st_out;
_ctr8:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/34__rep_alt_13_11_7.rl"
@@ -81,13 +78,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 85 "gen/ragel/34__rep_alt_13_11_7.c"
#line 82 "gen/ragel/34__rep_alt_13_11_7.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/34__rep_alt_13_11_7.rl"
outc(out, '\n'); }
#line 91 "gen/ragel/34__rep_alt_13_11_7.c"
#line 88 "gen/ragel/34__rep_alt_13_11_7.c"
goto _st14;
_ctr17:
@@ -95,20 +92,20 @@ static void lex(Input *in, Output *out)
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/34__rep_alt_13_11_7.rl"
s = p; }
#line 99 "gen/ragel/34__rep_alt_13_11_7.c"
#line 96 "gen/ragel/34__rep_alt_13_11_7.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/34__rep_alt_13_11_7.rl"
outc(out, '\n'); }
#line 105 "gen/ragel/34__rep_alt_13_11_7.c"
#line 102 "gen/ragel/34__rep_alt_13_11_7.c"
goto _st14;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
switch( ( (*( p))) ) {
case 10: {
goto _ctr17;
@@ -117,13 +114,10 @@ static void lex(Input *in, Output *out)
goto _ctr18;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr15:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/34__rep_alt_13_11_7.rl"
@@ -133,7 +127,7 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 137 "gen/ragel/34__rep_alt_13_11_7.c"
#line 131 "gen/ragel/34__rep_alt_13_11_7.c"
goto _st1;
_ctr18:
@@ -141,80 +135,68 @@ static void lex(Input *in, Output *out)
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/34__rep_alt_13_11_7.rl"
s = p; }
#line 145 "gen/ragel/34__rep_alt_13_11_7.c"
#line 139 "gen/ragel/34__rep_alt_13_11_7.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 97 ) {
goto _st6;
}
{
goto _st0;
}
goto _st0;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 97 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
switch( ( (*( p))) ) {
case 10: {
goto _ctr8;
@@ -223,47 +205,39 @@ static void lex(Input *in, Output *out)
goto _st8;
}
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
if ( ( (*( p))) == 97 ) {
goto _st9;
}
{
goto _st0;
}
goto _st0;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( ( (*( p))) == 97 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 97 ) {
goto _st11;
}
{
goto _st0;
}
goto _st0;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
switch( ( (*( p))) ) {
case 10: {
goto _ctr8;
@@ -272,25 +246,21 @@ static void lex(Input *in, Output *out)
goto _st12;
}
}
{
goto _st0;
}
goto _st0;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( ( (*( p))) == 97 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
switch( ( (*( p))) ) {
case 10: {
goto _ctr8;
@@ -299,28 +269,22 @@ static void lex(Input *in, Output *out)
goto _ctr15;
}
}
{
goto _st0;
}
st_out:
_test_eof14: cs = 14; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof: {}
if ( cs >= 14 )
goto _out; _pop: {}
goto _st0;
_out14: cs = 14; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out: {}
}
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/35__rep_alt_23_19_17.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 24:
goto st_case_24;
@@ -91,7 +89,6 @@ static void lex(Input *in, Output *out)
case 23:
goto st_case_23;
}
goto st_out;
_ctr18:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/35__rep_alt_23_19_17.rl"
@@ -101,13 +98,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 105 "gen/ragel/35__rep_alt_23_19_17.c"
#line 102 "gen/ragel/35__rep_alt_23_19_17.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/35__rep_alt_23_19_17.rl"
outc(out, '\n'); }
#line 111 "gen/ragel/35__rep_alt_23_19_17.c"
#line 108 "gen/ragel/35__rep_alt_23_19_17.c"
goto _st24;
_ctr27:
@@ -115,20 +112,20 @@ static void lex(Input *in, Output *out)
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/35__rep_alt_23_19_17.rl"
s = p; }
#line 119 "gen/ragel/35__rep_alt_23_19_17.c"
#line 116 "gen/ragel/35__rep_alt_23_19_17.c"
{
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/35__rep_alt_23_19_17.rl"
outc(out, '\n'); }
#line 125 "gen/ragel/35__rep_alt_23_19_17.c"
#line 122 "gen/ragel/35__rep_alt_23_19_17.c"
goto _st24;
_st24:
p+= 1;
if ( p == pe )
goto _test_eof24;
st_case_24:
if ( p == pe )
goto _out24;
switch( ( (*( p))) ) {
case 10: {
goto _ctr27;
@@ -137,13 +134,10 @@ static void lex(Input *in, Output *out)
goto _ctr28;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr25:
{
#line 13 "../../../benchmarks/submatch_dfa_aot/src/ragel/35__rep_alt_23_19_17.rl"
@@ -153,7 +147,7 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 157 "gen/ragel/35__rep_alt_23_19_17.c"
#line 151 "gen/ragel/35__rep_alt_23_19_17.c"
goto _st1;
_ctr28:
@@ -161,190 +155,158 @@ static void lex(Input *in, Output *out)
#line 17 "../../../benchmarks/submatch_dfa_aot/src/ragel/35__rep_alt_23_19_17.rl"
s = p; }
#line 165 "gen/ragel/35__rep_alt_23_19_17.c"
#line 159 "gen/ragel/35__rep_alt_23_19_17.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 97 ) {
goto _st6;
}
{
goto _st0;
}
goto _st0;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 97 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 97 ) {
goto _st8;
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
if ( ( (*( p))) == 97 ) {
goto _st9;
}
{
goto _st0;
}
goto _st0;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( ( (*( p))) == 97 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 97 ) {
goto _st11;
}
{
goto _st0;
}
goto _st0;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
if ( ( (*( p))) == 97 ) {
goto _st12;
}
{
goto _st0;
}
goto _st0;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( ( (*( p))) == 97 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
if ( ( (*( p))) == 97 ) {
goto _st14;
}
{
goto _st0;
}
goto _st0;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
if ( ( (*( p))) == 97 ) {
goto _st15;
}
{
goto _st0;
}
goto _st0;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
if ( p == pe )
goto _out15;
if ( ( (*( p))) == 97 ) {
goto _st16;
}
{
goto _st0;
}
goto _st0;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
if ( ( (*( p))) == 97 ) {
goto _st17;
}
{
goto _st0;
}
goto _st0;
_st17:
p+= 1;
if ( p == pe )
goto _test_eof17;
st_case_17:
if ( p == pe )
goto _out17;
switch( ( (*( p))) ) {
case 10: {
goto _ctr18;
@@ -353,25 +315,21 @@ static void lex(Input *in, Output *out)
goto _st18;
}
}
{
goto _st0;
}
goto _st0;
_st18:
p+= 1;
if ( p == pe )
goto _test_eof18;
st_case_18:
if ( p == pe )
goto _out18;
if ( ( (*( p))) == 97 ) {
goto _st19;
}
{
goto _st0;
}
goto _st0;
_st19:
p+= 1;
if ( p == pe )
goto _test_eof19;
st_case_19:
if ( p == pe )
goto _out19;
switch( ( (*( p))) ) {
case 10: {
goto _ctr18;
@@ -380,47 +338,39 @@ static void lex(Input *in, Output *out)
goto _st20;
}
}
{
goto _st0;
}
goto _st0;
_st20:
p+= 1;
if ( p == pe )
goto _test_eof20;
st_case_20:
if ( p == pe )
goto _out20;
if ( ( (*( p))) == 97 ) {
goto _st21;
}
{
goto _st0;
}
goto _st0;
_st21:
p+= 1;
if ( p == pe )
goto _test_eof21;
st_case_21:
if ( p == pe )
goto _out21;
if ( ( (*( p))) == 97 ) {
goto _st22;
}
{
goto _st0;
}
goto _st0;
_st22:
p+= 1;
if ( p == pe )
goto _test_eof22;
st_case_22:
if ( p == pe )
goto _out22;
if ( ( (*( p))) == 97 ) {
goto _st23;
}
{
goto _st0;
}
goto _st0;
_st23:
p+= 1;
if ( p == pe )
goto _test_eof23;
st_case_23:
if ( p == pe )
goto _out23;
switch( ( (*( p))) ) {
case 10: {
goto _ctr18;
@@ -429,38 +379,32 @@ static void lex(Input *in, Output *out)
goto _ctr25;
}
}
{
goto _st0;
}
st_out:
_test_eof24: cs = 24; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof16: cs = 16; goto _test_eof;
_test_eof17: cs = 17; goto _test_eof;
_test_eof18: cs = 18; goto _test_eof;
_test_eof19: cs = 19; goto _test_eof;
_test_eof20: cs = 20; goto _test_eof;
_test_eof21: cs = 21; goto _test_eof;
_test_eof22: cs = 22; goto _test_eof;
_test_eof23: cs = 23; goto _test_eof;
_test_eof: {}
if ( cs >= 24 )
goto _out; _pop: {}
goto _st0;
_out24: cs = 24; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out16: cs = 16; goto _out;
_out17: cs = 17; goto _out;
_out18: cs = 18; goto _out;
_out19: cs = 19; goto _out;
_out20: cs = 20; goto _out;
_out21: cs = 21; goto _out;
_out22: cs = 22; goto _out;
_out23: cs = 23; goto _out;
_out: {}
}
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/36__rep_5_rep_3_rep_2.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 6:
goto st_case_6;
@@ -55,7 +53,6 @@ static void lex(Input *in, Output *out)
case 5:
goto st_case_5;
}
goto st_out;
_ctr6:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/36__rep_5_rep_3_rep_2.rl"
@@ -65,13 +62,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 69 "gen/ragel/36__rep_5_rep_3_rep_2.c"
#line 66 "gen/ragel/36__rep_5_rep_3_rep_2.c"
{
#line 31 "../../../benchmarks/submatch_dfa_aot/src/ragel/36__rep_5_rep_3_rep_2.rl"
outc(out, '\n'); }
#line 75 "gen/ragel/36__rep_5_rep_3_rep_2.c"
#line 72 "gen/ragel/36__rep_5_rep_3_rep_2.c"
goto _st6;
_ctr9:
@@ -79,20 +76,20 @@ static void lex(Input *in, Output *out)
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/36__rep_5_rep_3_rep_2.rl"
s = p; }
#line 83 "gen/ragel/36__rep_5_rep_3_rep_2.c"
#line 80 "gen/ragel/36__rep_5_rep_3_rep_2.c"
{
#line 31 "../../../benchmarks/submatch_dfa_aot/src/ragel/36__rep_5_rep_3_rep_2.rl"
outc(out, '\n'); }
#line 89 "gen/ragel/36__rep_5_rep_3_rep_2.c"
#line 86 "gen/ragel/36__rep_5_rep_3_rep_2.c"
goto _st6;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
switch( ( (*( p))) ) {
case 10: {
goto _ctr9;
@@ -101,13 +98,10 @@ static void lex(Input *in, Output *out)
goto _ctr10;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr7:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/36__rep_5_rep_3_rep_2.rl"
@@ -117,7 +111,7 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 121 "gen/ragel/36__rep_5_rep_3_rep_2.c"
#line 115 "gen/ragel/36__rep_5_rep_3_rep_2.c"
goto _st1;
_ctr10:
@@ -125,58 +119,50 @@ static void lex(Input *in, Output *out)
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/36__rep_5_rep_3_rep_2.rl"
s = p; }
#line 129 "gen/ragel/36__rep_5_rep_3_rep_2.c"
#line 123 "gen/ragel/36__rep_5_rep_3_rep_2.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
switch( ( (*( p))) ) {
case 10: {
goto _ctr6;
@@ -185,20 +171,14 @@ static void lex(Input *in, Output *out)
goto _ctr7;
}
}
{
goto _st0;
}
st_out:
_test_eof6: cs = 6; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof: {}
if ( cs >= 6 )
goto _out; _pop: {}
goto _st0;
_out6: cs = 6; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out: {}
}
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/37__rep_13_rep_11_rep_7.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 14:
goto st_case_14;
@@ -71,7 +69,6 @@ static void lex(Input *in, Output *out)
case 13:
goto st_case_13;
}
goto st_out;
_ctr14:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/37__rep_13_rep_11_rep_7.rl"
@@ -81,13 +78,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 85 "gen/ragel/37__rep_13_rep_11_rep_7.c"
#line 82 "gen/ragel/37__rep_13_rep_11_rep_7.c"
{
#line 31 "../../../benchmarks/submatch_dfa_aot/src/ragel/37__rep_13_rep_11_rep_7.rl"
outc(out, '\n'); }
#line 91 "gen/ragel/37__rep_13_rep_11_rep_7.c"
#line 88 "gen/ragel/37__rep_13_rep_11_rep_7.c"
goto _st14;
_ctr17:
@@ -95,20 +92,20 @@ static void lex(Input *in, Output *out)
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/37__rep_13_rep_11_rep_7.rl"
s = p; }
#line 99 "gen/ragel/37__rep_13_rep_11_rep_7.c"
#line 96 "gen/ragel/37__rep_13_rep_11_rep_7.c"
{
#line 31 "../../../benchmarks/submatch_dfa_aot/src/ragel/37__rep_13_rep_11_rep_7.rl"
outc(out, '\n'); }
#line 105 "gen/ragel/37__rep_13_rep_11_rep_7.c"
#line 102 "gen/ragel/37__rep_13_rep_11_rep_7.c"
goto _st14;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
switch( ( (*( p))) ) {
case 10: {
goto _ctr17;
@@ -117,13 +114,10 @@ static void lex(Input *in, Output *out)
goto _ctr18;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr15:
{
#line 14 "../../../benchmarks/submatch_dfa_aot/src/ragel/37__rep_13_rep_11_rep_7.rl"
@@ -133,7 +127,7 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 137 "gen/ragel/37__rep_13_rep_11_rep_7.c"
#line 131 "gen/ragel/37__rep_13_rep_11_rep_7.c"
goto _st1;
_ctr18:
@@ -141,146 +135,122 @@ static void lex(Input *in, Output *out)
#line 18 "../../../benchmarks/submatch_dfa_aot/src/ragel/37__rep_13_rep_11_rep_7.rl"
s = p; }
#line 145 "gen/ragel/37__rep_13_rep_11_rep_7.c"
#line 139 "gen/ragel/37__rep_13_rep_11_rep_7.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 97 ) {
goto _st6;
}
{
goto _st0;
}
goto _st0;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 97 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 97 ) {
goto _st8;
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
if ( ( (*( p))) == 97 ) {
goto _st9;
}
{
goto _st0;
}
goto _st0;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( ( (*( p))) == 97 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 97 ) {
goto _st11;
}
{
goto _st0;
}
goto _st0;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
if ( ( (*( p))) == 97 ) {
goto _st12;
}
{
goto _st0;
}
goto _st0;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( ( (*( p))) == 97 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
switch( ( (*( p))) ) {
case 10: {
goto _ctr14;
@@ -289,28 +259,22 @@ static void lex(Input *in, Output *out)
goto _ctr15;
}
}
{
goto _st0;
}
st_out:
_test_eof14: cs = 14; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof: {}
if ( cs >= 14 )
goto _out; _pop: {}
goto _st0;
_out14: cs = 14; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out: {}
}
@@ -37,8 +37,6 @@ static void lex(Input *in, Output *out)
#line 39 "gen/ragel/38__rep_23_rep_19_rep_17.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs ) {
case 24:
goto st_case_24;
@@ -91,7 +89,6 @@ static void lex(Input *in, Output *out)
case 23:
goto st_case_23;
}
goto st_out;
_ctr24:
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/38__rep_23_rep_19_rep_17.rl"
@@ -101,13 +98,13 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 105 "gen/ragel/38__rep_23_rep_19_rep_17.c"
#line 102 "gen/ragel/38__rep_23_rep_19_rep_17.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/38__rep_23_rep_19_rep_17.rl"
outc(out, '\n'); }
#line 111 "gen/ragel/38__rep_23_rep_19_rep_17.c"
#line 108 "gen/ragel/38__rep_23_rep_19_rep_17.c"
goto _st24;
_ctr27:
@@ -115,20 +112,20 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/38__rep_23_rep_19_rep_17.rl"
s = p; }
#line 119 "gen/ragel/38__rep_23_rep_19_rep_17.c"
#line 116 "gen/ragel/38__rep_23_rep_19_rep_17.c"
{
#line 33 "../../../benchmarks/submatch_dfa_aot/src/ragel/38__rep_23_rep_19_rep_17.rl"
outc(out, '\n'); }
#line 125 "gen/ragel/38__rep_23_rep_19_rep_17.c"
#line 122 "gen/ragel/38__rep_23_rep_19_rep_17.c"
goto _st24;
_st24:
p+= 1;
if ( p == pe )
goto _test_eof24;
st_case_24:
if ( p == pe )
goto _out24;
switch( ( (*( p))) ) {
case 10: {
goto _ctr27;
@@ -137,13 +134,10 @@ static void lex(Input *in, Output *out)
goto _ctr28;
}
}
{
goto _st0;
}
st_case_0:
goto _st0;
_st0:
cs = 0;
goto _pop;
st_case_0:
goto _out0;
_ctr25:
{
#line 16 "../../../benchmarks/submatch_dfa_aot/src/ragel/38__rep_23_rep_19_rep_17.rl"
@@ -153,7 +147,7 @@ static void lex(Input *in, Output *out)
s = p;
}
#line 157 "gen/ragel/38__rep_23_rep_19_rep_17.c"
#line 151 "gen/ragel/38__rep_23_rep_19_rep_17.c"
goto _st1;
_ctr28:
@@ -161,256 +155,212 @@ static void lex(Input *in, Output *out)
#line 20 "../../../benchmarks/submatch_dfa_aot/src/ragel/38__rep_23_rep_19_rep_17.rl"
s = p; }
#line 165 "gen/ragel/38__rep_23_rep_19_rep_17.c"
#line 159 "gen/ragel/38__rep_23_rep_19_rep_17.c"
goto _st1;
_st1:
p+= 1;
if ( p == pe )
goto _test_eof1;
st_case_1:
if ( p == pe )
goto _out1;
if ( ( (*( p))) == 97 ) {
goto _st2;
}
{
goto _st0;
}
goto _st0;
_st2:
p+= 1;
if ( p == pe )
goto _test_eof2;
st_case_2:
if ( p == pe )
goto _out2;
if ( ( (*( p))) == 97 ) {
goto _st3;
}
{
goto _st0;
}
goto _st0;
_st3:
p+= 1;
if ( p == pe )
goto _test_eof3;
st_case_3:
if ( p == pe )
goto _out3;
if ( ( (*( p))) == 97 ) {
goto _st4;
}
{
goto _st0;
}
goto _st0;
_st4:
p+= 1;
if ( p == pe )
goto _test_eof4;
st_case_4:
if ( p == pe )
goto _out4;
if ( ( (*( p))) == 97 ) {
goto _st5;
}
{
goto _st0;
}
goto _st0;
_st5:
p+= 1;
if ( p == pe )
goto _test_eof5;
st_case_5:
if ( p == pe )
goto _out5;
if ( ( (*( p))) == 97 ) {
goto _st6;
}
{
goto _st0;
}
goto _st0;
_st6:
p+= 1;
if ( p == pe )
goto _test_eof6;
st_case_6:
if ( p == pe )
goto _out6;
if ( ( (*( p))) == 97 ) {
goto _st7;
}
{
goto _st0;
}
goto _st0;
_st7:
p+= 1;
if ( p == pe )
goto _test_eof7;
st_case_7:
if ( p == pe )
goto _out7;
if ( ( (*( p))) == 97 ) {
goto _st8;
}
{
goto _st0;
}
goto _st0;
_st8:
p+= 1;
if ( p == pe )
goto _test_eof8;
st_case_8:
if ( p == pe )
goto _out8;
if ( ( (*( p))) == 97 ) {
goto _st9;
}
{
goto _st0;
}
goto _st0;
_st9:
p+= 1;
if ( p == pe )
goto _test_eof9;
st_case_9:
if ( p == pe )
goto _out9;
if ( ( (*( p))) == 97 ) {
goto _st10;
}
{
goto _st0;
}
goto _st0;
_st10:
p+= 1;
if ( p == pe )
goto _test_eof10;
st_case_10:
if ( p == pe )
goto _out10;
if ( ( (*( p))) == 97 ) {
goto _st11;
}
{
goto _st0;
}
goto _st0;
_st11:
p+= 1;
if ( p == pe )
goto _test_eof11;
st_case_11:
if ( p == pe )
goto _out11;
if ( ( (*( p))) == 97 ) {
goto _st12;
}
{
goto _st0;
}
goto _st0;
_st12:
p+= 1;
if ( p == pe )
goto _test_eof12;
st_case_12:
if ( p == pe )
goto _out12;
if ( ( (*( p))) == 97 ) {
goto _st13;
}
{
goto _st0;
}
goto _st0;
_st13:
p+= 1;
if ( p == pe )
goto _test_eof13;
st_case_13:
if ( p == pe )
goto _out13;
if ( ( (*( p))) == 97 ) {
goto _st14;
}
{
goto _st0;
}
goto _st0;
_st14:
p+= 1;
if ( p == pe )
goto _test_eof14;
st_case_14:
if ( p == pe )
goto _out14;
if ( ( (*( p))) == 97 ) {
goto _st15;
}
{
goto _st0;
}
goto _st0;
_st15:
p+= 1;
if ( p == pe )
goto _test_eof15;
st_case_15:
if ( p == pe )
goto _out15;
if ( ( (*( p))) == 97 ) {
goto _st16;
}
{
goto _st0;
}
goto _st0;
_st16:
p+= 1;
if ( p == pe )
goto _test_eof16;
st_case_16:
if ( p == pe )
goto _out16;
if ( ( (*( p))) == 97 ) {
goto _st17;
}
{
goto _st0;
}
goto _st0;
_st17:
p+= 1;
if ( p == pe )
goto _test_eof17;
st_case_17:
if ( p == pe )
goto _out17;
if ( ( (*( p))) == 97 ) {
goto _st18;
}
{
goto _st0;
}
goto _st0;
_st18:
p+= 1;
if ( p == pe )
goto _test_eof18;
st_case_18:
if ( p == pe )
goto _out18;
if ( ( (*( p))) == 97 ) {
goto _st19;
}
{
goto _st0;
}
goto _st0;
_st19:
p+= 1;
if ( p == pe )
goto _test_eof19;
st_case_19:
if ( p == pe )
goto _out19;
if ( ( (*( p))) == 97 ) {
goto _st20;
}
{
goto _st0;
}
goto _st0;
_st20:
p+= 1;
if ( p == pe )
goto _test_eof20;
st_case_20:
if ( p == pe )
goto _out20;
if ( ( (*( p))) == 97 ) {
goto _st21;
}
{
goto _st0;
}
goto _st0;
_st21:
p+= 1;
if ( p == pe )
goto _test_eof21;
st_case_21:
if ( p == pe )
goto _out21;
if ( ( (*( p))) == 97 ) {
goto _st22;
}
{
goto _st0;
}
goto _st0;
_st22:
p+= 1;
if ( p == pe )
goto _test_eof22;
st_case_22:
if ( p == pe )
goto _out22;
if ( ( (*( p))) == 97 ) {
goto _st23;
}
{
goto _st0;
}
goto _st0;
_st23:
p+= 1;
if ( p == pe )
goto _test_eof23;
st_case_23:
if ( p == pe )
goto _out23;
switch( ( (*( p))) ) {
case 10: {
goto _ctr24;
@@ -419,38 +369,32 @@ static void lex(Input *in, Output *out)
goto _ctr25;
}
}
{
goto _st0;
}
st_out:
_test_eof24: cs = 24; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof13: cs = 13; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof15: cs = 15; goto _test_eof;
_test_eof16: cs = 16; goto _test_eof;
_test_eof17: cs = 17; goto _test_eof;
_test_eof18: cs = 18; goto _test_eof;
_test_eof19: cs = 19; goto _test_eof;
_test_eof20: cs = 20; goto _test_eof;
_test_eof21: cs = 21; goto _test_eof;
_test_eof22: cs = 22; goto _test_eof;
_test_eof23: cs = 23; goto _test_eof;
_test_eof: {}
if ( cs >= 24 )
goto _out; _pop: {}
goto _st0;
_out24: cs = 24; goto _out;
_out0: cs = 0; goto _out;
_out1: cs = 1; goto _out;
_out2: cs = 2; goto _out;
_out3: cs = 3; goto _out;
_out4: cs = 4; goto _out;
_out5: cs = 5; goto _out;
_out6: cs = 6; goto _out;
_out7: cs = 7; goto _out;
_out8: cs = 8; goto _out;
_out9: cs = 9; goto _out;
_out10: cs = 10; goto _out;
_out11: cs = 11; goto _out;
_out12: cs = 12; goto _out;
_out13: cs = 13; goto _out;
_out14: cs = 14; goto _out;
_out15: cs = 15; goto _out;
_out16: cs = 16; goto _out;
_out17: cs = 17; goto _out;
_out18: cs = 18; goto _out;
_out19: cs = 19; goto _out;
_out20: cs = 20; goto _out;
_out21: cs = 21; goto _out;
_out22: cs = 22; goto _out;
_out23: cs = 23; goto _out;
_out: {}
}
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/00__http_rfc7230.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/00__http_rfc7230.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/00__http_rfc7230.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/00__http_rfc7230.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/00__http_rfc7230.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/00__http_rfc7230.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/01__http_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/01__http_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/01__http_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/01__http_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/01__http_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/01__http_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/02__uri_rfc3986.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/02__uri_rfc3986.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/02__uri_rfc3986.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/02__uri_rfc3986.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/02__uri_rfc3986.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/02__uri_rfc3986.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/03__uri_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/03__uri_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/03__uri_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/03__uri_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/03__uri_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/03__uri_simple.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/04__apache_log.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/04__apache_log.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/04__apache_log.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/04__apache_log.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/04__apache_log.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/04__apache_log.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/05__datetime.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/05__datetime.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/05__datetime.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/05__datetime.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/05__datetime.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/05__datetime.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/06__email.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/06__email.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/06__email.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/06__email.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/06__email.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/06__email.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/07__ipv4.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/07__ipv4.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/07__ipv4.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/07__ipv4.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/07__ipv4.re"
#include <assert.h>
#include <stdlib.h>
@@ -1,4 +1,4 @@
/* Generated by re2c 2.0.3 */
/* Generated by re2c */
#line 1 "../../../benchmarks/submatch_dfa_aot/src/re2c/07__ipv4.re"
#include <assert.h>
#include <stdlib.h>

Some files were not shown because too many files have changed in this diff Show More