Here is a full list of configurations supported by |re2c|:

``re2c:api``, ``re2c:input``
    Same as the ``--api`` option.

``re2c:api:sigil``
    Specify the marker ("sigil") that is used for argument placeholders in the
    API primitives. The default is ``@@``. A placeholder starts with sigil
    followed by the argument name in curly braces. For example, if sigil is set
    to ``$``, then placeholders will have the form ``${name}``. Single-argument
    APIs may use shorthand notation without the name in braces. This option can
    be overridden by options for individual API primitives, e.g.
    ``re2c:YYFILL@len`` for ``YYFILL``.

``re2c:api:style``
    Specify API style. Possible values are ``functions`` (the default for C) and
    ``free-form`` (the default for Go and Rust).
    In ``functions`` style API primitives are generated with an argument list in
    parentheses following the name of the primitive. The arguments are provided
    only for autogenerated parameters (such as the number of characters passed
    to ``YYFILL``), but not for the general lexer context, so the primitives
    behave more like macros in C/C++ or closures in Go and Rust.
    In free-form style API primitives do not have a fixed form: they should be
    defined as strings containing free-form pieces of code with interpolated
    variables of the form ``@@{var}`` or ``@@`` (they correspond to arguments in
    function-like style).
    This configuration may be overridden for individual API primitives, see for
    example ``re2c:YYFILL:naked`` configuration for ``YYFILL``.

``re2c:bit-vectors``, ``re2c:flags:bit-vectors``, ``re2c:flags:b``
    Same as the ``--bit-vectors`` option, but can be configured on per-block
    basis.

``re2c:captures``, ``re2c:leftmost-captures``
    Same as the ``--leftmost-captures`` option, but can be configured on
    per-block basis.

``re2c:captvars``, ``re2c:leftmost-captvars``
    Same as the ``--leftmost-captvars`` option, but can be configured on
    per-block basis.

``re2c:case-insensitive``, ``re2c:flags:case-insensitive``
    Same as the ``--case-insensitive`` option, but can be configured on
    per-block basis.

``re2c:case-inverted``, ``re2c:flags:case-inverted``
    Same as the ``--case-inverted`` option, but can be configured on per-block
    basis.

``re2c:case-ranges``, ``re2c:flags:case-ranges``
    Same as the ``--case-ranges`` option, but can be configured on per-block
    basis.

``re2c:computed-gotos``, ``re2c:flags:computed-gotos``, ``re2c:flags:g``
    Same as the ``--computed-gotos`` option, but can be configured on per-block
    basis.

``re2c:computed-gotos:relative``, ``re2c:cgoto:relative``
    Same as the ``--computed-gotos-relative`` option, but can be configured on
    per-block basis.

``re2c:computed-gotos:threshold``, ``re2c:cgoto:threshold``
    If computed ``goto`` is used, this configuration specifies the complexity
    threshold that triggers the generation of jump tables instead of nested
    ``if`` statements and bitmaps. The default value is ``9``.

``re2c:cond:abort``
    If set to a positive integer value, the default case in the generated
    condition dispatch aborts program execution.

``re2c:cond:goto``
    Specifies a piece of code used for the autogenerated shortcut rules ``:=>``
    in conditions. The default is ``goto @@;``.
    The ``@@`` placeholder is substituted with condition name (see
    configurations ``re2c:api:sigil`` and ``re2c:cond:goto@cond``).

``re2c:cond:goto@cond``
    Specifies the sigil used for argument substitution in ``re2c:cond:goto``
    definition. The default value is ``@@``.
    Overrides the more generic ``re2c:api:sigil`` configuration.

``re2c:cond:divider``
    Defines the divider for condition blocks.
    The default value is ``/* *********************************** */``.
    Placeholders are substituted with condition name (see ``re2c:api;sigil`` and
    ``re2c:cond:divider@cond``).

``re2c:cond:divider@cond``
    Specifies the sigil used for argument substitution in ``re2c:cond:divider``
    definition. The default is ``@@``.
    Overrides the more generic ``re2c:api:sigil`` configuration.

``re2c:cond:prefix``, ``re2c:condprefix``
    Specifies the prefix used for condition labels.
    The default is ``yyc_``.

``re2c:cond:enumprefix``, ``re2c:condenumprefix``
    Specifies the prefix used for condition identifiers.
    The default is ``yyc``.

``re2c:debug-output``, ``re2c:flags:debug-output``, ``re2c:flags:d``
    Same as the ``--debug-output`` option, but can be configured on per-block
    basis.

``re2c:empty-class``, ``re2c:flags:empty-class``
    Same as the ``--empty-class`` option, but can be configured on per-block
    basis.

``re2c:encoding:ebcdic``, ``re2c:flags:ecb``, ``re2c:flags:e``
    Same as the ``--ebcdic`` option, but can be configured on per-block basis.

``re2c:encoding:ucs2``, ``re2c:flags:wide-chars``, ``re2c:flags:w``
    Same as the ``--ucs2`` option, but can be configured on per-block basis.

``re2c:encoding:utf8``, ``re2c:flags:utf-8``, ``re2c:flags:8``
    Same as the ``--utf8`` option, but can be configured on per-block basis.

``re2c:encoding:utf16``, ``re2c:flags:utf-16``, ``re2c:flags:x``
    Same as the ``--utf16`` option, but can be configured on per-block basis.

``re2c:encoding:utf32``, ``re2c:flags:unicode``, ``re2c:flags:u``
    Same as the ``--utf32`` option, but can be configured on per-block basis.

``re2c:encoding-policy``, ``re2c:flags:encoding-policy``
    Same as the ``--encoding-policy`` option, but can be configured on per-block
    basis.

``re2c:eof``
    Specifies the sentinel symbol used with the end-of-input rule ``$``. The
    default value is ``-1`` (``$`` rule is not used). Other possible values
    include all valid code units. Only decimal numbers are recognized.

``re2c:header``, ``re2c:flags:type-header``, ``re2c:flags:t``
    Specifies the name of the generated header file relative to the directory of
    the output file. Same as the ``--header`` option except that the file path
    is relative.

``re2c:indent:string``
    Specifies the string used for indentation. The default is a single tab
    character ``"\t"``. Indent string should contain whitespace characters only.
    To disable indentation entirely, set this configuration to an empty string.

``re2c:indent:top``
    Specifies the minimum amount of indentation to use. The default value is
    zero. The value should be a non-negative integer number.

``re2c:invert-captures``
    Same as the ``--invert-captures`` option, but can be configured on per-block
    basis.

``re2c:label:prefix``, ``re2c:labelprefix``
    Specifies the prefix used for DFA state labels. The default is ``yy``.

``re2c:label:start``, ``re2c:startlabel``
    Controls the generation of a block start label. The default value is zero,
    which means that the start label is generated only if it is used. An integer
    value greater than zero forces the generation of start label even if it is
    unused by the lexer. A string value also forces start label generation and
    sets the label name to the specified string. This configuration applies only
    to the current block (it is reset to default for the next block).

``re2c:label:yyFillLabel``
    Specifies the prefix of ``YYFILL`` labels used with ``re2c:eof`` and in
    storable state mode.

``re2c:label:yyloop``
    Specifies the name of the label marking the start of the lexer loop with
    ``--loop-switch`` option. The default is ``yyloop``.

``re2c:label:yyNext``
    Specifies the name of the optional label that follows ``YYGETSTATE`` switch
    in storable state mode (enabled with ``re2c:state:nextlabel``). The default
    is ``yyNext``.

``re2c:lookahead``, ``re2c:flags:lookahead``
    Deprecated (see the deprecated ``--no-lookahead`` option).

``re2c:monadic``
    If set to non-zero, the generated lexer will use monadic notation (this
    configuration is specific to Haskell).

``re2c:nested-ifs``, ``re2c:flags:nested-ifs``, ``re2c:flags:s``
    Same as the ``--nested-ifs`` option, but can be configured on per-block
    basis.

``re2c:posix-captures``, ``re2c:flags:posix-captures``, ``re2c:flags:P``
    Same as the ``--posix-captures`` option, but can be configured on per-block
    basis.

``re2c:posix-captvars``
    Same as the ``--posix-captvars`` option, but can be configured on per-block
    basis.

``re2c:tags``, ``re2c:flags:tags``, ``re2c:flags:T``
    Same as the ``--tags`` option, but can be configured on per-block basis.

``re2c:tags:expression``
    Specifies the expression used for tag variables.
    By default |re2c| generates expressions of the form ``yyt<N>``. This might
    be inconvenient, for example if tag variables are defined as fields in a
    struct. All occurrences of ``@@{tag}`` or ``@@`` are replaced with the
    actual tag name. For example, ``re2c:tags:expression = "s.@@";`` results
    in expressions of the form ``s.yyt<N>`` in the generated code.
    See also ``re2c:api:sigil`` configuration.

``re2c:tags:negative``
    Specifies the constant expression that is used for negative tag value
    (typically this would be ``-1`` if tags are integer offsets in the input
    string, or null pointer if they are pointers).

``re2c:tags:prefix``
    Specifies the prefix for tag variable names. The default is ``yyt``.

``re2c:sentinel``
    Specifies the sentinel symbol used for the end-of-input checks (when bounds
    checks are disabled with ``re2c:yyfill:enable = 0;`` and ``re2c:eof`` is not
    set). This configuration does not affect code generation: its purpose is to
    verify that the sentinel is not allowed in the middle of a rule, and ensure
    that the lexer won't read past the end of buffer. The default value is
    `-1`` (in that case |re2c| assumes that the sentinel is zero, which is the
    most common case). Only decimal numbers are recognized.

``re2c:state:abort``
    If set to a positive integer value, the default case in the generated
    state dispatch aborts program execution, and an explicit ``-1`` case
    contains transition to the start of the block.

``re2c:state:nextlabel``
    Controls if the ``YYGETSTATE`` switch is followed by an ``yyNext`` label
    (the default value is zero, which corresponds to no label).
    Alternatively one can use ``re2c:label:start`` to generate a specific start
    label, or an explicit ``getstate`` block to generate the ``YYGETSTATE``
    switch separately from the lexer block.

``re2c:unsafe``, ``re2c:flags:unsafe``
    Same as the ``--no-unsafe`` option, but can be configured on per-block
    basis.
    If set to zero, it suppresses the generation of ``unsafe`` wrappers around
    ``YYPEEK``. The default is non-zero (wrappers are generated).
    This configuration is specific to Rust.

``re2c:YYBACKUP``, ``re2c:define:YYBACKUP``
    Defines generic API primitive ``YYBACKUP``.

``re2c:YYBACKUPCTX``, ``re2c:define:YYBACKUPCTX``
    Defines generic API primitive ``YYBACKUPCTX``.

``re2c:YYCONDTYPE``, ``re2c:define:YYCONDTYPE``
    Defines API primitive ``YYCONDTYPE``.

``re2c:YYCTYPE``, ``re2c:define:YYCTYPE``
    Defines API primitive ``YYCTYPE``.

``re2c:YYCTXMARKER``, ``re2c:define:YYCTXMARKER``
    Defines API primitive ``YYCTXMARKER``.

``re2c:YYCURSOR``, ``re2c:define:YYCURSOR``
    Defines API primitive ``YYCURSOR``.

``re2c:YYDEBUG``, ``re2c:define:YYDEBUG``
    Defines API primitive ``YYDEBUG``.

``re2c:YYFILL``, ``re2c:define:YYFILL``
    Defines API primitive ``YYFILL``.

``re2c:YYFILL@len``, ``re2c:define:YYFILL@len``
    Specifies the sigil used for argument substitution in ``YYFILL``
    definition. Defaults to ``@@``.
    Overrides the more generic ``re2c:api:sigil`` configuration.

``re2c:YYFILL:naked``, ``re2c:define:YYFILL:naked``
    Overrides the more generic ``re2c:api:style`` configuration for ``YYFILL``.
    Zero value corresponds to free-form API style.

``re2c:YYFN``
    Defines API primitive ``YYFN``.

``re2c:YYINPUT``
    Defines API primitive ``YYINPUT``.

``re2c:YYGETCOND``, ``re2c:define:YYGETCONDITION``
    Defines API primitive ``YYGETCOND``.

``re2c:YYGETCOND:naked``, ``re2c:define:YYGETCONDITION:naked``
    Overrides the more generic ``re2c:api:style`` configuration for
    ``YYGETCOND``. Zero value corresponds to free-form API style.

``re2c:YYGETSTATE``, ``re2c:define:YYGETSTATE``
    Defines API primitive ``YYGETSTATE``.

``re2c:YYGETSTATE:naked``, ``re2c:define:YYGETSTATE:naked``
    Overrides the more generic ``re2c:api:style`` configuration for
    ``YYGETSTATE``. Zero value corresponds to free-form API style.

``re2c:YYGETACCEPT``, ``re2c:define:YYGETACCEPT``
    Defines API primitive ``YYGETACCEPT``.

``re2c:YYLESSTHAN``, ``re2c:define:YYLESSTHAN``
    Defines generic API primitive ``YYLESSTHAN``.

``re2c:YYLIMIT``, ``re2c:define:YYLIMIT``
    Defines API primitive ``YYLIMIT``.

``re2c:YYMARKER``, ``re2c:define:YYMARKER``
    Defines API primitive ``YYMARKER``.

``re2c:YYMTAGN``, ``re2c:define:YYMTAGN``
    Defines generic API primitive ``YYMTAGN``.

``re2c:YYMTAGP``, ``re2c:define:YYMTAGP``
    Defines generic API primitive ``YYMTAGP``.

``re2c:YYPEEK``, ``re2c:define:YYPEEK``
    Defines generic API primitive ``YYPEEK``.

``re2c:YYRESTORE``, ``re2c:define:YYRESTORE``
    Defines generic API primitive ``YYRESTORE``.

``re2c:YYRESTORECTX``, ``re2c:define:YYRESTORECTX``
    Defines generic API primitive ``YYRESTORECTX``.

``re2c:YYRESTORETAG``, ``re2c:define:YYRESTORETAG``
    Defines generic API primitive ``YYRESTORETAG``.

``re2c:YYSETCOND``, ``re2c:define:YYSETCONDITION``
    Defines API primitive ``YYSETCOND``.

``re2c:YYSETCOND@cond``, ``re2c:define:YYSETCONDITION@cond``
    Specifies the sigil used for argument substitution in ``YYSETCOND``
    definition. The default value is ``@@``.
    Overrides the more generic ``re2c:api:sigil`` configuration.

``re2c:YYSETCOND:naked``, ``re2c:define:YYSETCONDITION:naked``
    Overrides the more generic ``re2c:api:style`` configuration for
    ``YYSETCOND``. Zero value corresponds to free-form API style.

``re2c:YYSETSTATE``, ``re2c:define:YYSETSTATE``
    Defines API primitive ``YYSETSTATE``.

``re2c:YYSETSTATE@state``, ``re2c:define:YYSETSTATE@state``
    Specifies the sigil used for argument substitution in ``YYSETSTATE``
    definition. The default value is ``@@``.
    Overrides the more generic ``re2c:api:sigil`` configuration.

``re2c:YYSETSTATE:naked``, ``re2c:define:YYSETSTATE:naked``
    Overrides the more generic ``re2c:api:style`` configuration for
    ``YYSETSTATE``. Zero value corresponds to free-form API style.

``re2c:YYSETACCEPT``, ``re2c:define:YYSETACCEPT``
    Defines API primitive ``YYSETACCEPT``.

``re2c:YYSKIP``, ``re2c:define:YYSKIP``
    Defines generic API primitive ``YYSKIP``.

``re2c:YYSHIFT``, ``re2c:define:YYSHIFT``
    Defines generic API primitive ``YYSHIFT``.

``re2c:YYCOPYMTAG``, ``re2c:define:YYCOPYMTAG``
    Defines generic API primitive ``YYCOPYMTAG``.

``re2c:YYCOPYSTAG``, ``re2c:define:YYCOPYSTAG``
    Defines generic API primitive ``YYCOPYSTAG``.

``re2c:YYSHIFTMTAG``, ``re2c:define:YYSHIFTMTAG``
    Defines generic API primitive ``YYSHIFTMTAG``.

``re2c:YYSHIFTSTAG``, ``re2c:define:YYSHIFTSTAG``
    Defines generic API primitive ``YYSHIFTSTAG``.

``re2c:YYSTAGN``, ``re2c:define:YYSTAGN``
    Defines generic API primitive ``YYSTAGN``.

``re2c:YYSTAGP``, ``re2c:define:YYSTAGP``
    Defines generic API primitive ``YYSTAGP``.

``re2c:yyaccept``, ``re2c:variable:yyaccept``
    Defines API primitive ``yyaccept``.

``re2c:yybm``, ``re2c:variable:yybm``
    Defines API primitive ``yybm``.

``re2c:yybm:hex``, ``re2c:variable:yybm:hex``
    If set to nonzero, bitmaps for the ``--bit-vectors`` option are generated
    in hexadecimal format. The default is zero (bitmaps are in decimal format).

``re2c:yych``, ``re2c:variable:yych``
    Defines API primitive ``yych``.

``re2c:yych:emit``, ``re2c:variable:yych:emit``
    If set to zero, ``yych`` definition is not generated.
    The default is non-zero.

``re2c:yych:conversion``, ``re2c:variable:yych:conversion``
    If set to non-zero, |re2c| automatically generates a conversion to ``YYCTYPE``
    every time ``yych`` is read. The default is to zero (no conversion).

``re2c:yych:literals``, ``re2c:variable:yych:literals``
    Specifies the form of literals that ``yych`` is matched against. Possible
    values are: ``char`` (character literals in single quotes, non-printable
    ones use escape sequences that start with backslash), ``hex`` (hexadecimal
    integers) and ``char_or_hex`` (a mixture of both, character literals for
    printable characters and hexadecimal integers for others).

``re2c:yyctable``, ``re2c:variable:yyctable``
    Defines API primitive ``yyctable``.

``re2c:yynmatch``, ``re2c:variable:yynmatch``
    Defines API primitive ``yynmatch``.

``re2c:yypmatch``, ``re2c:variable:yypmatch``
    Defines API primitive ``yypmatch``.

``re2c:yytarget``, ``re2c:variable:yytarget``
    Defines API primitive ``yytarget``.

``re2c:yystable``, ``re2c:variable:yystable``
    Deprecated.

``re2c:yystate``, ``re2c:variable:yystate``
    Defines API primitive ``yystate``.

``re2c:yyfill``, ``re2c:variable:yyfill``
    Defines API primitive ``yyfill``.

``re2c:yyfill:check``
    If set to zero, suppresses the generation of pre-``YYFILL`` check for the
    number of input characters (the ``YYLESSTHAN`` definition in generic API and
    the ``YYLIMIT``-based comparison in C pointer API). The default is non-zero
    (generate the check).

``re2c:yyfill:enable``
   If set to zero, suppresses the generation of ``YYFILL`` (together
   with the check). This should be used when the whole input fits into one piece
   of memory (there is no need for buffering) and the end-of-input checks do not
   rely on the ``YYFILL`` checks (e.g. if a sentinel character is used).
   Use warnings (``-W`` option) and ``re2c:sentinel`` configuration to verify
   that the generated lexer cannot read past the end of input.
   The default is non-zero (``YYFILL`` is enabled).

``re2c:yyfill:parameter``
    If set to zero, suppresses the generation of parameter passed to ``YYFILL``.
    The parameter is the minimum number of characters that must be supplied.
    Defaults to non-zero (the parameter is generated).
    This configuration can be overridden with ``re2c:YYFILL:naked`` or
    ``re2c:api:style``.

``re2c:yyfn:sep``
    Specifies separator used in ``YYFN`` elements (defaults to semicolon).

``re2c:yyfn:throw``
    Specifies exceptions thrown by ``YYFN`` function (defaults to empty, which
    means no exceptions).
