Block start and end markers are either ``/*!re2c`` and ``*/``, or ``%{`` and
``%}`` (both styles are supported). Starting from version 2.2 blocks may have
optional names that allow them to be referenced in other blocks.
There are different kinds of blocks:

``/*!re2c[:<name>] ... */`` or ``%{[:<name>] ... %}``
    A *global block* contains definitions, configurations, rules and directives.
    |re2c| compiles regular expressions associated with each rule into a
    deterministic finite automaton, encodes it in the form of conditional jumps
    in the target language and replaces the block with the generated code. Names
    and configurations defined in a global block are added to the global scope
    and become visible to subsequent blocks. At the start of the program the
    global scope is initialized with command-line `options`_.

``/*!local:re2c[:<name>] ... */`` or ``%{local[:<name>] ... %}``
    A *local block* is like a global block, but the names and configurations in
    it have local scope (they do not affect other blocks).

``/*!rules:re2c[:<name>] ... */`` or ``%{rules[:<name>] ... %}``
    A *rules block* is like a local block, but it does not generate any code by
    itself, nor does it add any definitions to the global scope -- it is meant 
    to be reused in other blocks. This is a way of sharing code (more details in
    the `reusable blocks`_ section). Prior to |re2c| version 2.2 rules blocks
    required ``-r --reusable`` option.

``/*!use:re2c[:<name>] ... */`` or ``%{use[:<name>] ... %}``
    A use block that references a previously defined rules block. If the name is
    specified, |re2c| looks for a rules blocks with this name. Otherwise the most
    recent rules block is used (either a named or an unnamed one). A use block
    can add definitions, configurations and rules of its own, which are added to
    those of the referenced rules block. Prior to |re2c| version 2.2 use blocks
    required ``-r --reusable`` option.

``/*!max:re2c[:<name1>[:<name2>...]] ... */`` or ``%{max[:<name1>[:<name2>...]] ... %}``
    A block that generates ``YYMAXFILL`` definition. An optional list of block
    names specifies which blocks should be included when computing ``YYMAXFILL``
    value (if the list is empty, all blocks are included).
    By default the generated code is a macro-definition for C
    (``#define YYMAXFILL <n>``), or a global variable for Go
    (``var YYMAXFILL int = <n>``). It can be customized with an optional
    configuration ``format`` that specifies a template string where ``@@{max}``
    (or ``@@`` for short) is replaced with the numeric value of ``YYMAXFILL``.

``/*!maxnmatch:re2c[:<name1>[:<name2>...]] ... */`` or ``%{maxnmatch[:<name1>[:<name2>...]] ... %}``
    A block that generates ``YYMAXNMATCH`` definition (it requires
    ``-P --posix-captures`` option). An optional list of block names specifies
    which blocks should be included when computing ``YYMAXNMATCH`` value (if the
    list is empty, all blocks are included).
    By default the generated code is a macro-definition for C
    (``#define YYMAXNMATCH <n>``), or a global variable for Go
    (``var YYMAXNMATCH int = <n>``). It can be customized with an optional
    configuration ``format`` that specifies a template string where ``@@{max}``
    (or ``@@`` for short) is replaced with the numeric value of ``YYMAXNMATCH``.

``/*!stags:re2c[:<name1>[:<name2>...]] ... */``, ``/*!mtags:re2c[:<name1>[:<name2>...]] ... */`` or ``%{stags[:<name1>[:<name2>...]] ... %}``, ``%{mtags[:<name1>[:<name2>...]] ... %{``
    Blocks that specify a template piece of code that is expanded for each
    s-tag/m-tag variable generated by |re2c|. An optional list of block names
    specifies which blocks should be included when computing the set of tag
    variables (if the list is empty, all blocks are included).
    There are two optional configurations: ``format`` and ``separator``.
    Configuration ``format`` specifies a template string where ``@@{tag}`` (or
    ``@@`` for short) is replaced with the name of each tag variable.
    Configuration ``separator`` specifies a piece of code used to join the
    generated ``format`` pieces for different tag variables.

``/*!svars:re2c[:<name1>[:<name2>...]] ... */``, ``/*!mvars:re2c[:<name1>[:<name2>...]] ... */`` or ``%{svars[:<name1>[:<name2>...]] ... %}``, ``%{mvars[:<name1>[:<name2>...]] ... %{``
    Blocks that specify a template piece of code that is expanded for each
    s-tag/m-tag that is either explicitly mentioned by the rules (with
    ``--tags`` option) or implicitly generated by |re2c| (with ``--captvars`` or
    ``--posix-captvars`` options). An optional list of block names specifies
    which blocks should be included when computing the set of tags (if the list
    is empty, all blocks are included).
    There are two optional configurations: ``format`` and ``separator``.
    Configuration ``format`` specifies a template string where ``@@{tag}`` (or
    ``@@`` for short) is replaced with the name of each tag.
    Configuration ``separator`` specifies a piece of code used to join the
    generated ``format`` pieces for different tags.

``/*!getstate:re2c[:<name1>[:<name2>...]] ... */`` or ``%{getstate[:<name1>[:<name2>...]] ... %}``
    A block that generates conditional dispatch on the lexer state (it requires
    ``--storable-state`` option). An optional list of block names specifies
    which blocks should be included in the state dispatch. The default
    transition goes to the start label of the first block on the list. If the
    list is empty, all blocks are included, and the default transition goes to
    the first block in the file that has a start label.
    This block type is incompatible with the ``--loop-switch`` option, as it
    requires cross-block transitions that are unsupported without ``goto`` or
    function calls.

``/*!conditions:re2c[:<name1>[:<name2>...]] ... */``, ``/*!types:re2c... */`` or ``%{conditions[:<name1>[:<name2>...]] ... %}``, ``%{types... %}``
    A block that generates condition enumeration (it requires ``--conditions``
    option). An optional list of block names specifies which blocks should be
    included when computing the set of conditions (if the list is empty, all
    blocks are included).
    By default the generated code is an enumeration ``YYCONDTYPE``. It can be
    customized with optional configurations ``format`` and ``separator``.
    Configuration ``format`` specifies a template string where ``@@{cond}`` (or
    ``@@`` for short) is replaced with the name of each condition, and
    ``@@{num}`` is replaced with a numeric index of that condition.
    Configuration ``separator`` specifies a piece of code used to join the
    generated ``format`` pieces for different conditions.

``/*!include:re2c <file> */`` or ``%{include <file> %}``
    This block allows one to include ``<file>``, which must be a double-quoted
    file path. The contents of the file are literally substituted in place of
    the block, in the same way as ``#include`` works in C/C++. This block can be
    used together with the ``--depfile`` option to generate build system
    dependencies on the included files.

``/*!header:re2c:on*/`` or ``%{header:on %}``
    This block marks the start of header file. Everything after it and up to the
    following ``header:off`` block is processed by |re2c| and written to the
    header file specified with ``-t --type-header`` option.

``/*!header:re2c:off*/`` or ``%{header:off %}``
    This block marks the end of header file started with ``header:on*/`` block.

``/*!ignore:re2c ... */`` or ``%{ignore ... %}``
    A block which contents are ignored and removed from the output file.

