Rule Reference

July 2, 2026 ยท View on GitHub

The reference documentation for all rules and combinators.

The rules related to stream parsing are documented here.

Contents

Preamble

For how rule and combinators are implemented see Implementing Rules.

For additional and experimental rules and combinators see the Extra Reference and the Example Reference.

Namespaces

All rules reside in namespace tao::pegtl or a sub-namespace of tao::pegtl. This default can be changed via the macro TAO_PEGTL_NAMESPACE in tao/pegtl/config.hpp. The namespace tao::pegtl is generally omitted on this page.

Equivalence

Some rules are documented as being equivalent to a combination of other rules. This equivalence is with respect to which inputs are matched, but is not (necessarily) how the rule is implemented.

For rules other than must<> that contain "must" in their name, rule equivalence shows which rule will be used as template parameter to the control when calling the raise() function when certain sub-rules fail to match.

Implementation

The "meta data and implementation mapping" section of each rule's description shows both how the rule is implemented and what the meta data looks like. When the list of sub-rules is empty then the definition of subs_t is omitted from the description.

Remember that the default control tao::pegtl::normal does not call control functions for rules in the tao::pegtl::internal namespace.

Parameter Packs

The documentation will use (template parameter) packs when zero-or-more or one-or-more of a (template) parameter are allowed. For example seq< R... > accepts zero-or-more template parameters. In the zero case, i.e. seq<>, we also say R is "empty", otherwise R is "non-empty".

End Of Line Rules

Rules that can be used for end-of-line scanning mode and/or lazy end-of-line tracking are documented as being "also available in the scan and/or lazy sub-namespace". The different end-of-line modes that can be chosen for an input are documented in Inputs and Parsing.

Atomic

Atomic rules do not rely on other rules (but might have non-rule template parameters).

These rules are in namespace tao::pegtl.

bof
  • Succeeds at "beginning-of-file", i.e. when the input is at its start.
  • Does not consume input.
  • Requires an input in with an in.start() member function, and/or
  • requires an input in where in.direct_position().count is available.
  • Meta data and implementation mapping:
    • bof::rule_t is internal::bof
bol
  • Succeeds at "beginning-of-line", i.e. when the input's column() member function returns 1.
  • Does not consume input.
  • Requires an input with eager text position tracking, more precisely:
  • Requires an input in where in.direct_position().column is available.
  • Meta data and implementation mapping:
    • bol::rule_t is internal::bol
consume< Num >
  • Succeeds if the input contains at least Num further objects, and
  • unconditionally consumes Num objects from the input.
  • Limited to the buffer size when using a stream input.
  • Meta data and implementation mapping:
    • consume< 0 >::rule_t is internal::success
    • consume< N >::rule_t is internal::consume< N > for N > 0
eof
  • Succeeds at "end-of-file", i.e. when the input is empty (all input has been consumed).
  • Does not consume input.
  • Meta data and implementation mapping:
    • eof::rule_t is internal::eof
eol
  • Matches a single end-of-line as defined by the input.
  • The default definition of what constitutes a lines ending is system dependent.
    • On Unix-like systems a Unix line ending is matched, a single 'LF'.
    • On Windows the MS-DOS line ending 'CR LF' is also accepted.
  • Requires an input with an eol_rule type alias.
  • Meta data and implementation mapping:
    • eol::rule_t is internal::eol

Note that the default behavior can be changed either by defining TAO_PEGTL_DEFAULT_EOL before tao/pegtl/system.hpp is (indirectly) included or by supplying an end-of-line rule as template parameter to the input.

eolf
  • Matches a single end-of-line or the end-of-file.
  • Requires an input with an eol_rule type definition.
  • Equivalent to sor< eof, eol >.
  • Meta data and implementation mapping:
    • eolf::rule_t is internal::eolf
everything
failure
  • Rule that never succeeds.
  • Does not consume input.
  • Meta data and implementation mapping:
    • failure::rule_t is internal::failure
function< F, P = void >
  • Delegates matching to the function F.
  • The function F must return bool.
  • The function F can be noexcept( true ) or noexcept( false ).
Rule formFunction signatureBehavior
function< F >bool F( Input& )Calls F with the current input. The function is responsible for matching and consuming input.
function< F >bool F( Input&, States... )Calls F with the current input and the current state objects.
function< F, P >bool F( Data )Calls P::peek( in ) and then F with the peeked data.
function< F, P >bool F( Data, States... )Calls P::peek( in ) and then F with the peeked data and the current state objects.

When P is void, F is used as a match function and receives the current input directly. This form should usually consume input only when returning true. When P is not void, it is used as peek implementation; if peeking succeeds and F returns true, the rule consumes the size reported by the peek result. For this peeked-data form, if peeking fails, or if F returns false, the rule returns false and consumes no input.

  • Meta data and implementation mapping:
    • function< F, P >::rule_t is internal::function< P, decltype( F ), F >
    • function< F, P >::subs_t is empty_list
invert< R >
  • Takes any rule whose rule_t is internal::one, internal::ione, internal::range, internal::ranges, or one of their inverted forms.
  • This includes the ASCII rules and the corresponding Unicode one, range, and ranges rules when their meta data maps to these internal rules.
  • Rules whose meta data maps to another implementation, e.g. a single non-ASCII utf8::one< C > that maps to internal::ascii_string< U... >, are not supported.
  • Results in a rule with normal matching changed to inverted matching, or vice versa.
nested< R, P >
  • Uses the peek implementation P to extract an object from the input.
  • Performs a nested parsing run with rule R on the extracted object's contiguous data.
  • The extracted object must have value_type, data() and size() members suitable for constructing a view_input.
  • Consumes 1 object from the outer input when the nested parsing run succeeds.
  • Meta data and implementation mapping:
    • nested< R, P >::rule_t is internal::nested< P, R >
    • nested< R, P >::subs_t is empty_list
restart
  • Rule that always succeeds.
  • Rewinds the input to where it started.
  • Should generally be avoided!
  • Requires an input with start.
  • Meta data and implementation mapping:
    • restart::rule_t is internal::restart
source< R >
  • Requires an input with source.
  • Performs a nested parsing run with rule R on the input's direct_source().
  • Supports sources of type std::string, std::string_view and std::filesystem::path.
  • Does not consume input.
  • Meta data and implementation mapping:
    • source< R >::rule_t is internal::source< R >
    • source< R >::subs_t is empty_list
success
  • Rule that always succeeds.
  • Does not consume input.
  • Meta data and implementation mapping:
    • success::rule_t is internal::success

ASCII

The ASCII rules operate on any input of integral or enum type of size 1.

Unless noted otherwise they do not restrict the range of matched values to 7-bit ASCII values. For example rules like ascii::any or ascii::not_one< 'a' > will match all possible byte values, and all possible byte values excluding 'a', respectively. The rules any7, many7, not_one7, not_ione7 and not_range7 are like their respective counterparts without the trailing 7 but only match values that can be represented in 7 bits.

It is possible to match UTF-8 multi-byte characters with the non-seven ASCII rules. For example the Euro sign code point U+20AC, which is encoded by the UTF-8 sequence E2 82 AC, is matched by both ascii::string< 0xe2, 0x82, 0xac > and utf8::one< 0x20ac >. On closer inspection one would find that both rules are implemented via internal::ascii_string< 0xe2, 0x82, 0xac >.

These rules are in the inline namespace tao::pegtl::ascii.

For all ASCII rules the template parameters representing characters are of type char.

aistring< P, C... >
  • Similar to (ascii::)astring< P, C... >, but:
  • For ASCII letters the match is case insensitive.
  • The std::size_t P must be between 0 and sizeof C..., excluding edges.
  • If the complete string C... matches, consumes that complete string.
  • Otherwise, if the first P characters of C... match, consumes those P characters.
  • Meta data and implementation mapping:
    • ascii::aistring< P, C... >::rule_t is internal::ascii_aistring< P, C... >
alnum
  • Matches and consumes a single ASCII alphabetic or numeric character.
  • Equivalent to (ascii::)ranges< 'a', 'z', 'A', 'Z', '0', '9' >.
alpha
  • Matches and consumes a single ASCII alphabetic character.
  • Equivalent to (ascii::)ranges< 'a', 'z', 'A', 'Z' >.
any
  • Matches and consumes any single byte, including all ASCII characters.
  • Equivalent to (ascii::)many< 1 >.
  • Meta data and implementation mapping:
    • (ascii::)any::rule_t is internal::any< internal::peek_char >
any7
  • Matches and consumes any single "true" ASCII character that fits into 7 bits.
  • Equivalent to (ascii::)range< 0, 127 >.
  • Meta data and implementation mapping:
    • (ascii::)any7::rule_t is internal::any< internal::peek_seven >
astring< P, C... >
  • Like (ascii::)string< C... > but also matches one prefix of C....
  • The std::size_t P must be between 0 and sizeof C..., excluding edges.
  • If the complete string C... matches, consumes that complete string.
  • Otherwise, if the first P characters of C... match, consumes those P characters.
  • Meta data and implementation mapping:
    • ascii::astring< P, C... >::rule_t is internal::ascii_astring< P, C... >
bdigit
  • Matches and consumes a single ASCII binary digit.
  • Equivalent to (ascii::)one< '0', '1' >.
blank
  • Matches and consumes a single ASCII horizontal space or horizontal tabulator character.
  • Equivalent to (ascii::)one< ' ', '\t' >.
cntrl
  • Matches and consumes a single ASCII control character.
  • Equivalent to (ascii::)ranges< 0, 31, 127 >.
cr
cr_crlf
  • Matches and consumes a carriage return optionally followed by a line feed.
  • Equivalent to seq< (ascii::)cr, opt< (ascii::)lf > >.
  • Equivalent to sor< (ascii::)crlf, (ascii::)cr >.
  • Also available in the lazy sub-namespace.
cr_lf
cr_lf_crlf
crlf
digit
  • Matches and consumes a single ASCII decimal digit.
  • Equivalent to (ascii::)range< '0', '9' >.
ellipsis
  • Matches and consumes three dots.
  • Equivalent to (ascii::)three< '.' >.
esc
  • Matches and consumes a single ASCII escape character of value 27 or 0x1b.
  • Equivalent to (ascii::)one< 27 >.
ff
  • Matches and consumes a single ASCII form feed (new page) character of value 12 or 0x0c.
  • Equivalent to (ascii::)one< '\f' >.
graph
  • Matches and consumes a single ASCII character traditionally defined as "printable but not space".
  • Equivalent to (ascii::)range< 33, 126 >.
ht
  • Matches and consumes a single ASCII horizontal tab character of value 9.
  • Equivalent to (ascii::)one< '\t' >.
identifier_first
  • Matches and consumes a single ASCII character permissible as first character of a C identifier.
  • Equivalent to (ascii::)ranges< 'a', 'z', 'A', 'Z', '_' >.
  • Meta data and implementation mapping:
    • ascii::identifier_first::rule_t is internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '_' >
identifier_other
  • Matches and consumes a single ASCII character permissible as subsequent character of a C identifier.
  • Equivalent to (ascii::)ranges< 'a', 'z', 'A', 'Z', '0', '9', '_' >.
  • Meta data and implementation mapping:
    • ascii::identifier_other::rule_t is internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '0', '9', '_' >
identifier
  • Matches and consumes an ASCII identifier as defined for the C programming language.
  • Equivalent to seq< (ascii::)identifier_first, star< (ascii::)identifier_other > >.
  • Meta data and implementation mapping is subject to change.
ione< C... >
  • Similar to (ascii::)one< C... > but:
  • For ASCII letters the match is case insensitive.
  • C must be a non-empty character pack.
  • Meta data and implementation mapping:
    • ascii::ione< C... >::rule_t is internal::ione< internal::peek_char, C... >.
istring< C... >
  • Similar to (ascii::)string< C... >, but:
  • For ASCII letters the match is case insensitive.
  • Meta data and implementation mapping:
    • ascii::istring<>::rule_t is internal::success
    • ascii::istring< C >::rule_t is internal::ione< internal::peek_char, C >
    • ascii::istring< C... >::rule_t is internal::ascii_istring< C... >
keyword< C... >
  • Matches and consumes a non-empty string not followed by an identifier character.
  • Equivalent to seq< (ascii::)string< C... >, not_at< (ascii::)identifier_other > >.
  • C must be a non-empty character pack.
  • Meta data and implementation mapping:
    • ascii::keyword< C... >::rule_t is internal::seq< internal::ascii_string< C... >, internal::not_at< internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '0', '9', '_' > > >
lf
lf_crlf
lower
  • Matches and consumes a single ASCII lower-case alphabetic character.
  • Equivalent to (ascii::)range< 'a', 'z' >.
many< Num >
  • Succeeds when the input contains at least Num further bytes.
  • Consumes these Num bytes from the input.
  • Equivalent to (ascii::)rep< Num, any >.
  • Meta data and implementation mapping:
    • ascii::many< 0 >::rule_t is internal::success
    • ascii::many< 1 >::rule_t is internal::any< internal::peek_char >
    • ascii::many< Num >::rule_t is internal::many< Num, internal::peek_char > for Num > 1
many7< Num >
  • True ASCII version of many only matches input bytes between 0 and 127.
  • Equivalent to rep< Num, (ascii::)any7 >.
  • Meta data and implementation mapping:
    • ascii::many7< 0 >::rule_t is internal::success
    • ascii::many7< 1 >::rule_t is internal::any< internal::peek_seven >
    • ascii::many7< Num >::rule_t is internal::many< Num, internal::peek_seven > for Num > 1
not_ione< C... >
  • Similar to (ascii::)not_one< C... > but:
  • For ASCII letters the match is case insensitive.
  • C must be a non-empty character pack.
  • Meta data and implementation mapping:
    • ascii::not_ione< C... >::rule_t is internal::not_ione< internal::peek_char, C... >.
not_ione7< C... >
  • Like (ascii::)not_ione< C... > but only matches values that can be represented in 7 bits.
  • C must be a non-empty character pack.
  • Meta data and implementation mapping:
    • ascii::not_ione7< C... >::rule_t is internal::not_ione< internal::peek_seven, C... >.
not_one< C... >
  • Succeeds when the input is not empty, and:
  • C is a non-empty character pack and the next input byte is not one of C....
  • Consumes one byte on success.
  • Meta data and implementation mapping:
    • ascii::not_one< C... >::rule_t is internal::not_one< internal::peek_char, C... >.
not_one7< C... >
  • True ASCII version of not_one only matches input bytes between 0 and 127.
  • C must be a non-empty character pack.
  • Meta data and implementation mapping:
    • ascii::not_one7< C... >::rule_t is internal::not_one< internal::peek_seven, C... >.
not_range< C, D >
  • Succeeds when the input is not empty, and:
  • The next input byte is not in the closed range C ... D.
  • Consumes one byte on success.
  • Meta data and implementation mapping:
    • ascii::not_range< C, C >::rule_t is internal::not_one< internal::peek_char, C >.
    • ascii::not_range< C, D >::rule_t is internal::not_range< internal::peek_char, C, D > for C < D.
not_range7< C, D >
  • True ASCII version of not_range only matches input bytes between 0 and 127.
  • Meta data and implementation mapping:
    • ascii::not_range7< C, C >::rule_t is internal::not_one< internal::peek_seven, C >.
    • ascii::not_range7< C, D >::rule_t is internal::not_range< internal::peek_seven, C, D > for C < D.
not_ranges< C1, D1, C2, D2, ... >
not_ranges< C1, D1, C2, D2, ..., E >
  • Succeeds when the input is not empty, and:
  • The next input byte is not in any of the closed ranges C1 ... D1, C2 ... D2, ...
  • For the second form the next input byte must also not be E.
  • Consumes one byte on success.
  • The character pack must be non-empty.
  • Meta data and implementation mapping:
    • ascii::not_ranges< E >::rule_t is internal::not_one< internal::peek_char, E >.
    • ascii::not_ranges< C, C >::rule_t is internal::not_one< internal::peek_char, C >.
    • ascii::not_ranges< C, D >::rule_t is internal::not_range< internal::peek_char, C, D > for C < D.
    • ascii::not_ranges< C... >::rule_t is internal::not_ranges< internal::peek_char, C... > for packs with more than two characters.
nul
  • Matches and consumes an ASCII nul character of value 0.
  • Equivalent to (ascii::)one< '\0' >.
odigit
  • Matches and consumes a single ASCII octal digit.
  • Equivalent to (ascii::)range< '0', '7' >.
one< C... >
  • Succeeds when the input is not empty, and:
  • The next input byte is one of C....
  • Consumes one byte on success.
  • C must be a non-empty character pack.
  • Meta data and implementation mapping:
    • ascii::one< C... >::rule_t is internal::one< internal::peek_char, C... >.
print
  • Matches and consumes any single ASCII character traditionally defined as printable.
  • Equivalent to (ascii::)range< 32, 126 >.
punct
  • Matches and consumes any single ASCII character defined as punctuation.
  • Equivalent to (ascii::)ranges< '!', '/', ':', '@', '[', 96, '{', '~' >.
range< C, D >
  • Succeeds when the input is not empty, and:
  • The next input byte is in the closed range C ... D.
  • Consumes one byte on success.
  • Meta data and implementation mapping:
    • ascii::range< C, C >::rule_t is internal::one< internal::peek_char, C >.
    • ascii::range< C, D >::rule_t is internal::range< internal::peek_char, C, D > for C < D.
ranges< C1, D1, C2, D2, ... >
ranges< C1, D1, C2, D2, ..., E >
  • Equivalent to sor< (ascii::)range< C1, D1 >, (ascii::)range< C2, D2 >, ... >.
  • Equivalent to sor< (ascii::)range< C1, D1 >, (ascii::)range< C2, D2 >, ..., (ascii::)one< E > >.
  • The character pack must be non-empty.
  • Meta data and implementation mapping:
    • ascii::ranges< E >::rule_t is internal::one< internal::peek_char, E >.
    • ascii::ranges< C, C >::rule_t is internal::one< internal::peek_char, C >.
    • ascii::ranges< C, D >::rule_t is internal::range< internal::peek_char, C, D > for C < D.
    • ascii::ranges< C... >::rule_t is internal::ranges< internal::peek_char, C... > for packs with more than two characters.
shebang
  • Equivalent to seq< (ascii::)string< '#', '!' >, until< eolf > >.
  • Meta data and implementation mapping:
    • ascii::shebang::rule_t is internal::seq< internal::ascii_string< '#', '!' >, internal::until< internal::eolf > >
    • ascii::shebang::subs_t is type_list< internal::ascii_string< '#', '!' >, internal::until< internal::eolf > >
sp
  • Matches and consumes a single ASCII space character of value 32 or 0x20.
  • Equivalent to (ascii::)one< ' ' >.
space
  • Matches and consumes a single space, line feed, carriage return, horizontal tab, vertical tab or form feed.
  • Equivalent to (ascii::)one< ' ', '\n', '\r', '\t', '\v', '\f' >.
string< C... >
  • Matches and consumes a string, a sequence of bytes or ASCII characters.
  • Equivalent to seq< (ascii::)one< C >... >.
  • Meta data and implementation mapping:
    • ascii::string<>::rule_t is internal::success
    • ascii::string< C >::rule_t is internal::one< internal::peek_char, C >
    • ascii::string< C... >::rule_t is internal::ascii_string< C... >
TAO_PEGTL_ISTRING( "..." )
  • Macro where TAO_PEGTL_ISTRING( "foo" ) yields (ascii::)istring< 'f', 'o', 'o' >.
  • The argument must be a string literal.
  • Works for strings up to 512 bytes of length (excluding trailing '\0').
  • Strings may contain embedded '\0'.
TAO_PEGTL_KEYWORD( "..." )
  • Macro where TAO_PEGTL_KEYWORD( "foo" ) yields (ascii::)keyword< 'f', 'o', 'o' >.
  • The argument must be a string literal.
  • Works for keywords up to 512 bytes of length (excluding trailing '\0').
  • Strings may contain embedded '\0'.
TAO_PEGTL_STRING( "..." )
  • Macro where TAO_PEGTL_STRING( "foo" ) yields (ascii::)string< 'f', 'o', 'o' >.
  • The argument must be a string literal.
  • Works for strings up to 512 bytes of length (excluding trailing '\0').
  • Strings may contain embedded '\0'.
three< C >
  • Succeeds when the input contains at least three bytes, and:
  • These three input bytes are all C.
  • Consumes three bytes on success.
  • Meta data and implementation mapping:
    • ascii::three< C >::rule_t is internal::ascii_string< C, C, C >
two< C >
  • Succeeds when the input contains at least two bytes, and:
  • These two input bytes are both C.
  • Consumes two bytes on success.
  • Meta data and implementation mapping:
    • ascii::two< C >::rule_t is internal::ascii_string< C, C >
upper
  • Matches and consumes a single ASCII upper-case alphabetic character.
  • Equivalent to (ascii::)range< 'A', 'Z' >.
vt
  • Matches and consumes a single ASCII vertical tab of value 11 or 0x0b.
  • Equivalent to (ascii::)one< '\v' >.
xdigit
  • Matches and consumes a single ASCII hexadecimal digit character.
  • Equivalent to (ascii::)ranges< '0', '9', 'a', 'f', 'A', 'F' >.

Unicode

These rules are available in multiple versions,

  • in namespace tao::pegtl::utf8 for UTF-8 inputs,
  • in namespace alias tao::pegtl::utf16 for native-endian UTF-16 inputs,
  • in namespace alias tao::pegtl::utf32 for native-endian UTF-32 inputs,
  • in namespace tao::pegtl::utf16_be for big-endian UTF-16 inputs,
  • in namespace tao::pegtl::utf16_le for little-endian UTF-16 inputs,
  • in namespace tao::pegtl::utf32_be for big-endian UTF-32 inputs,
  • in namespace tao::pegtl::utf32_le for little-endian UTF-32 inputs.

Except for UTF-8 the Unicode rules are not automatically included with <tao/pegtl.hpp>. To make them available the following header files need to be included as required.

  • tao/pegtl/unicode/utf16.hpp
  • tao/pegtl/unicode/utf32.hpp

Remember that the column field of the input positions counts the number of input objects since the last line ending, not the actual column!

A Unicode code point is considered valid when it is in the range 0 to 0x10ffff.

  • The UTF-8 rules work on the same inputs as the ASCII rules whose data_t is an 8-bit integer or enum type.
  • The UTF-16 rules work with inputs whose data_t is either an 8-bit or a 16-bit integer or enum type.
  • The UTF-32 rules work with inputs whose data_t is either an 8-bit or a 32-bit integer or enum type.

In the following descriptions the parameter N stands for the size of the encoding of the next Unicode code point in the input.

  • For UTF-8 the rules are multi-byte-sequence-aware and N is either 1, 2, 3 or 4.
  • For UTF-16 the rules are surrogate-pair-aware and N is either 2 or 4 for 8-bit inputs, and either 1 or 2 for 16-bit inputs.
  • For UTF-32 N is always 4 for 8-bit inputs, and always 1 for 32-bit inputs.

Note that the Unicode rules only match UTF-16 surrogates as part of a valid UTF-16 surrogate pair.

For all Unicode rules the template parameters representing code points are of type char32_t.

any
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point.
  • Consumes the N input objects on success.
bom
  • Matches and consumes a byte-order mark of value U+FEFF.
cr
cr_crlf
  • Matches and consumes a carriage return optionally followed by a line feed.
  • Also available in the lazy sub-namespace.
cr_lf
cr_lf_crlf
crlf
eol1
  • Match any single-code-point Unicode end-of-line character:
  • Carriage return, line feed, form feed, vertical tab, next line, or line or paragraph separator.
eolu
lf
lf_crlf
ls
many< Num >
  • Succeeds when the input contains at least Num further code points.
  • Consumes these Num code points from the input.
  • Equivalent to rep< Num, utf_::any >.
not_one< C... >
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • C is a non-empty character pack and the input code point is not one of the given code points C....
  • Consumes the N input objects on success.
not_range< C, D >
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • The input code point B satisfies B < C || D < B.
  • Consumes the N input objects on success.
not_ranges< C1, D1, C2, D2, ... >
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • The input code point is not in any of the closed ranges C1 ... D1, C2 ... D2, ...
  • Consumes the N input objects on success.
  • The character pack must be non-empty.
not_ranges< C1, D1, C2, D2, ..., E >
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • The input code point is not in any of the closed ranges C1 ... D1, C2 ... D2, ...
  • The input code point is also not E.
  • Consumes the N input objects on success.
  • The character pack must be non-empty.
one< C... >
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • C is a non-empty character pack and the input code point is one of the given code points C....
  • Consumes the N input objects on success.
nel
ps
range< C, D >
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • The input code point B satisfies C <= B && B <= D.
  • Consumes the N input objects on success.
ranges< C1, D1, C2, D2, ... >
  • Equivalent to sor< utf_::range< C1, D1 >, utf_::range< C2, D2 >, ... >.
  • The character pack must be non-empty.
ranges< C1, D1, C2, D2, ..., E >
  • Equivalent to sor< utf_::range< C1, D1 >, utf_::range< C2, D2 >, ..., utf_::one< E > >.
  • The character pack must be non-empty.
string< C... >
  • Equivalent to seq< utf_::one< C >... >.
  • Meta data and implementation mapping:
    • utf_::string<>::rule_t is internal::success.
    • utf_::string< C... >::rule_t is internal::seq< internal::one< internal::peek_, C >... >.
    • utf8::string< C >::rule_t is internal::one< internal::peek_char, U > when U is the one-byte UTF-8 encoding of C.
    • utf8::string< C >::rule_t is internal::ascii_string< U... > when U... is the multi-byte UTF-8 encoding of C.
    • utf8::string< C... >::rule_t is internal::ascii_string< U... > where U... is the UTF-8 encoding of C....

Binary

These rules are available in multiple versions,

  • in namespace tao::pegtl::int8 for std::int8_t values,
  • in namespace tao::pegtl::uint8 for std::uint8_t values,
  • in namespace tao::pegtl::int16_be for big-endian std::int16_t values,
  • in namespace tao::pegtl::int16_le for little-endian std::int16_t values,
  • in namespace tao::pegtl::int32_be for big-endian std::int32_t values,
  • in namespace tao::pegtl::int32_le for little-endian std::int32_t values,
  • in namespace tao::pegtl::int64_be for big-endian std::int64_t values,
  • in namespace tao::pegtl::int64_le for little-endian std::int64_t values,
  • in namespace tao::pegtl::uint16_be for big-endian std::uint16_t values,
  • in namespace tao::pegtl::uint16_le for little-endian std::uint16_t values,
  • in namespace tao::pegtl::uint32_be for big-endian std::uint32_t values,
  • in namespace tao::pegtl::uint32_le for little-endian std::uint32_t values,
  • in namespace tao::pegtl::uint64_be for big-endian std::uint64_t values,
  • in namespace tao::pegtl::uint64_le for little-endian std::uint64_t values,
  • in namespace tao::pegtl::enums_be for big-endian enumeration type values,
  • in namespace tao::pegtl::enums_le for little-endian enumeration type values,
  • in namespace alias tao::pegtl::int16 for native-endian std::int16_t values,
  • in namespace alias tao::pegtl::int32 for native-endian std::int32_t values,
  • in namespace alias tao::pegtl::int64 for native-endian std::int64_t values,
  • in namespace alias tao::pegtl::uint16 for native-endian std::uint16_t values,
  • in namespace alias tao::pegtl::uint32 for native-endian std::uint32_t values,
  • in namespace alias tao::pegtl::uint64 for native-endian std::uint64_t values,
  • in namespace alias tao::pegtl::enums for native-endian enumeration type values.

The binary rules are not automatically included with <tao/pegtl.hpp>. To make them available the following header files need to be included as required.

  • tao/pegtl/binary/int8.hpp
  • tao/pegtl/binary/uint8.hpp
  • tao/pegtl/binary/int16.hpp
  • tao/pegtl/binary/uint16.hpp
  • tao/pegtl/binary/int32.hpp
  • tao/pegtl/binary/uint32.hpp
  • tao/pegtl/binary/int64.hpp
  • tao/pegtl/binary/uint64.hpp
  • tao/pegtl/binary/enums.hpp

These rules operate both on byte-sized inputs and on inputs whose data size corresponds to the size of the matched integers or enums.

  • The 8-bit rules work on the same inputs as the ASCII rules whose data_t is an 8-bit integer or enum type.
  • The 16-bit rules work with inputs whose data_t is either an 8-bit or a 16-bit integer or enum type.
  • The 32-bit rules work with inputs whose data_t is either an 8-bit or a 32-bit integer or enum type.
  • The 64-bit rules work with inputs whose data_t is either an 8-bit or a 64-bit integer or enum type.

The enum rules behave like integers of the same size.

In the following descriptions the parameter N stands for the size of the encoding of the next integer value according to the size of integer matched by the rule in question.

  • For 8-bit rules N is always 1.
  • For 16-bit rules N is 2 for 8-bit inputs and 1 for 16-bit inputs.
  • For 32-bit rules N is 4 for 8-bit inputs and 1 for 32-bit inputs.
  • For 64-bit rules N is 8 for 8-bit inputs and 1 for 64-bit inputs.

The enum rules again behave like integers of the same size.

The template parameters of an enum rule must all be of the same enum type.

Only the not_one, not_range, one, range, ranges and string rules are available for enums.

The term input value indicates an integer or enum value of the appropriate size read from the input.

any
  • Succeeds when the input contains at least N objects.
  • Consumes N objects on success.
many< Num >
  • Succeeds when the input contains at least Num times N objects.
  • Consumes these Num * N objects from the input.
  • Equivalent to rep< Num, any >.
mask_not_one< M, C... >
  • Succeeds when the input contains at least N objects, and:
  • C is a non-empty pack and the (endian adjusted) input value masked with M is not one of the values C....
  • Consumes N objects on success.
mask_not_range< M, C, D >
  • Succeeds when the input contains at least N objects, and:
  • The (endian adjusted) input value b satisfies ( b & M ) < C || D < ( b & M ).
  • Consumes N objects on success.
mask_one< M, C... >
  • Succeeds when the input contains at least N objects, and:
  • C is a non-empty pack and the (endian adjusted) input value masked with M is one of the given values C....
  • Consumes N objects on success.
mask_range< M, C, D >
  • Succeeds when the input contains at least N objects, and:
  • The (endian adjusted) input value b satisfies C <= ( b & M ) && ( b & M ) <= D.
  • Consumes N objects on success.
mask_ranges< M, C1, D1, C2, D2, ... >
  • Equivalent to sor< mask_range< M, C1, D1 >, mask_range< M, C2, D2 >, ... >.
  • The value pack must be non-empty.
mask_ranges< M, C1, D1, C2, D2, ..., E >
  • Equivalent to sor< mask_range< M, C1, D1 >, mask_range< M, C2, D2 >, ..., mask_one< M, E > >.
  • The value pack must be non-empty.
mask_string< M, C... >
not_one< C... >
  • Succeeds when the input contains at least N objects, and:
  • C is a non-empty pack and the (endian adjusted) input value is not one of the given values C....
  • Consumes N objects on success.
not_range< C, D >
  • Succeeds when the input contains at least N objects, and:
  • The (endian adjusted) input value b satisfies b < C || D < b.
  • Consumes N objects on success.
not_ranges< C1, D1, C2, D2, ... >
  • Succeeds when the input contains at least N objects, and:
  • The (endian adjusted) input value is not in any of the closed ranges C1 ... D1, C2 ... D2, ...
  • Consumes N objects on success.
  • The value pack must be non-empty.
not_ranges< C1, D1, C2, D2, ..., E >
  • Succeeds when the input contains at least N objects, and:
  • The (endian adjusted) input value is not in any of the closed ranges C1 ... D1, C2 ... D2, ...
  • The (endian adjusted) input value is also not E.
  • Consumes N objects on success.
  • The value pack must be non-empty.
one< C... >
  • Succeeds when the input contains at least N objects, and:
  • C is a non-empty pack and the (endian adjusted) input value is one of the given values C....
  • Consumes N objects on success.
range< C, D >
  • Succeeds when the input contains at least N objects, and:
  • The (endian adjusted) input value b satisfies C <= b && b <= D.
  • Consumes N objects on success.
ranges< C1, D1, C2, D2, ... >
  • Equivalent to sor< range< C1, D1 >, range< C2, D2 >, ... >.
  • The value pack must be non-empty.
ranges< C1, D1, C2, D2, ..., E >
  • Equivalent to sor< range< C1, D1 >, range< C2, D2 >, ..., one< E > >.
  • The value pack must be non-empty.
string< C... >

Member

The member rules apply their matching condition to a value derived from the next object in the input.

The first template parameter to the member rules must be a member pointer, a member function pointer to a "getter" function, or a function pointer to a global "getter".

More precisely, for inputs representing sequences of objects of type T, the permissible types of the first template parameter M are as follows; the functions can be noexcept( true ) or noexcept( false ).

  • U T::* -- pointer to data member of type U.
  • const U T::* -- pointer to data member of type const U.
  • U* T::* -- pointer to data member of type U*.
  • const U* T::* -- pointer to data member of type const U*.
  • U* const T::* -- pointer to data member of type U* const.
  • const U* const T::* -- pointer to data member of type const U* const.
  • U (T::*)() const -- pointer to const member function that returns a U.
  • const U& (T::*)() const -- pointer to const member function that returns a const U&.
  • const U* (T::*)() const -- pointer to const member function that returns a const U*.
  • U (*)( const T& ) -- pointer to function that takes a const T& and returns a U.
  • const U& (*)( const T& ) -- pointer to function that takes a const T& and returns a const U&.
  • const U* (*)( const T& ) -- pointer to function that takes a const T& and returns a const U*.

Here U is assumed to be neither a pointer nor a reference type. Subsequent non-type template parameters, if any, must be of type U as that is the type of the object extracted from the next input object of type T on which the match condition is tested.

The member rules are not automatically included with <tao/pegtl.hpp>. To make them available it is necessary to include tao/pegtl/member.hpp.

These rules are in namespace tao::pegtl::member.

function< M, F >
  • Apply the function F to the extracted object of type U.
  • The function F must take a U or const U& as first argument, and
  • if possible the function F is called with all State objects as additional arguments.
  • The function F must return a bool with the result of the match attempt.
  • The function F can be noexcept( true ) or noexcept( false ).
nested< M, R >
  • Performs a nested parsing run with rule R on the extracted object.
  • The extracted object must be suited to construct a view_input.
  • Consumes 1 object from the outer input when the nested parsing run succeeds.
not_one< M, U... >
  • Succeeds when the input contains at least 1 object, and:
  • The object extracted from the next input object is not one of the values U....
  • Consumes 1 object on success.
  • U must be a non-empty pack.
not_range< M, U, V >
  • Succeeds when the input contains at least 1 object, and:
  • The object u extracted from the next input object satisfies u < U || V < u.
  • Consumes 1 object on success.
not_ranges< M, U1, V1, U2, V2, ... >
  • Succeeds when the input contains at least 1 object, and:
  • The object extracted from the next input object is not in any of the closed ranges U1 ... V1, U2 ... V2, ...
  • Consumes 1 object on success.
  • The value pack must be non-empty.
not_ranges< M, U1, V1, U2, V2, ..., W >
  • Succeeds when the input contains at least 1 object, and:
  • The object extracted from the next input object is not in any of the closed ranges U1 ... V1, U2 ... V2, ...
  • The object extracted from the next input object is also not W.
  • Consumes 1 object on success.
  • The value pack must be non-empty.
one< M, U... >
  • Succeeds when the input contains at least 1 object, and:
  • The object extracted from the next input object is one of the values U....
  • Consumes 1 object on success.
  • U must be a non-empty pack.
range< M, U, V >
  • Succeeds when the input contains at least 1 object, and:
  • The object u extracted from the next input object satisfies U <= u && u <= V.
  • Consumes 1 object on success.
ranges< M, U1, V1, U2, V2, ... >
  • Equivalent to sor< range< M, U1, V1 >, range< M, U2, V2 >, ... >.
  • The value pack must be non-empty.
ranges< M, U1, V1, U2, V2, ..., W >
  • Equivalent to sor< range< M, U1, V1 >, range< M, U2, V2 >, ..., one< M, W > >.
  • The value pack must be non-empty.
string< M, U... >

Combinators

These rules correspond to the classical PEG combinators or operators.

These rules are in namespace tao::pegtl.

at< R... >
  • PEG and-predicate &e
  • Succeeds if and only if seq< R... > would succeed.
  • Consumes nothing independent of result.
  • Disables all actions while matching R....
  • Meta data and implementation mapping:
    • at<>::rule_t is internal::success
    • at< R >::rule_t is internal::at< R >
    • at< R >::subs_t is type_list< R >
    • at< R... >::rule_t is internal::at< internal::seq< R... > >
    • at< R... >::subs_t is type_list< internal::seq< R... > >
not_at< R... >
  • PEG not-predicate !e
  • Succeeds if and only if seq< R... > would not succeed.
  • Consumes nothing independent of result.
  • Disables all actions while matching R....
  • Meta data and implementation mapping:
    • not_at<>::rule_t is internal::failure
    • not_at< R >::rule_t is internal::not_at< R >
    • not_at< R >::subs_t is type_list< R >
    • not_at< R... >::rule_t is internal::not_at< internal::seq< R... > >
    • not_at< R... >::subs_t is type_list< internal::seq< R... > >
opt< R... >
  • PEG optional e?
  • Optional seq< R... >, i.e. attempt to match seq< R... > and always return success:
  • The return value of opt< R... > does not depend on whether R... matched.
  • Equivalent to sor< seq< R... >, success >.
  • Meta data and implementation mapping:
    • opt<>::rule_t is internal::success
    • opt< R >::rule_t is internal::opt< R >
    • opt< R >::subs_t is type_list< R >
    • opt< R... >::rule_t is internal::opt< internal::seq< R... > >
    • opt< R... >::subs_t is type_list< internal::seq< R... > >
plus< R... >
  • PEG one-or-more e+
  • Matches seq< R... > as often as possible and succeeds if it matches at least once.
  • Equivalent to seq< R..., star< R... > >.
  • R must be a non-empty rule pack.
  • Meta data and implementation mapping:
    • plus< R >::rule_t is internal::plus< R >
    • plus< R >::subs_t is type_list< R >
    • plus< R... >::rule_t is internal::plus< internal::seq< R... > >
    • plus< R... >::subs_t is type_list< internal::seq< R... > >
seq< R... >
  • PEG sequence e1 e2
  • Sequence or conjunction of rules.
  • Matches the given rules R... in the given order.
  • Fails and stops matching when one of the given rules fails.
  • Consumes everything that the rules R... consumed.
  • Succeeds if R is an empty rule pack.
  • Meta data and implementation mapping:
    • seq<>::rule_t is internal::success
    • seq< R >::rule_t is internal::seq< R >
    • seq< R >::subs_t is type_list< R >
    • seq< R... >::rule_t is internal::seq< R... >
    • seq< R... >::subs_t is type_list< R... >
sor< R... >
  • PEG ordered choice e1 / e2
  • Choice or disjunction of rules.
  • Matches the given rules R... in the given order.
  • Succeeds and stops matching when one of the given rules succeeds.
  • Consumes whatever the first rule that succeeded consumed.
  • Fails if R is an empty rule pack.
  • Meta data and implementation mapping:
    • sor<>::rule_t is internal::failure
    • sor< R >::rule_t is internal::sor< R >
    • sor< R >::subs_t is type_list< R >
    • sor< R... >::rule_t is internal::sor< R... >
    • sor< R... >::subs_t is type_list< R... >
star< R... >
  • PEG zero-or-more e*
  • Matches seq< R... > as often as possible and always succeeds.
  • Equivalent to opt< plus< R... > >.
  • R must be a non-empty rule pack.
  • Meta data and implementation mapping:
    • star< R >::rule_t is internal::star< R >
    • star< R >::subs_t is type_list< R >
    • star< R... >::rule_t is internal::star< internal::seq< R... > >
    • star< R... >::subs_t is type_list< internal::seq< R... > >

Convenience

These rules implement common rule combinations for more concise and/or efficient grammars.

These rules are in namespace tao::pegtl.

if_then_else< R, S, T >
  • Attempts to match either S or T depending on whether R matched.
  • Equivalent to sor< seq< R, S >, seq< not_at< R >, T > >.
  • Meta data and implementation mapping:
    • if_then_else< R, S, T >::rule_t is internal::if_then_else< R, S, T>
    • if_then_else< R, S, T >::subs_t is type_list< R, S, T >
list< R, S >
  • Matches a non-empty list of R separated by S.
  • Equivalent to seq< R, star< S, R > >.
  • Meta data and implementation mapping:
    • list< R, S >::rule_t is internal::seq< R, internal::star< S, R > >
    • list< R, S >::subs_t is type_list< R, internal::star< S, R > >
list< R, S, P >
  • Matches a non-empty list of R separated by S where each S can be padded by P.
  • Equivalent to seq< R, star< pad< S, P >, R > >.
  • Meta data and implementation mapping:
    • list< R, S, P >::rule_t is internal::seq< R, internal::star< internal::pad< S, P >, R > >
    • list< R, S, P >::subs_t is type_list< R, internal::star< internal::pad< S, P >, R > >
list_opt< R, S >
  • Matches an optional list of R separated by S.
  • Equivalent to opt< list< R, S > >.
  • Equivalent to opt< R, star< S, R > >.
  • Meta data and implementation mapping:
    • list_opt< R, S >::rule_t is internal::opt< internal::seq< R, internal::star< S, R > > >
    • list_opt< R, S >::subs_t is type_list< internal::seq< R, internal::star< S, R > > >
list_opt< R, S, P >
  • Matches an optional list of R separated by S where each S can be padded by P.
  • Equivalent to opt< list< R, S, P > >.
  • Equivalent to opt< R, star< pad< S, P >, R > >.
  • Meta data and implementation mapping:
    • list_opt< R, S, P >::rule_t is internal::opt< internal::seq< R, internal::star< internal::pad< S, P >, R > > >
    • list_opt< R, S, P >::subs_t is type_list< internal::seq< R, internal::star< internal::pad< S, P >, R > > >
list_tail< R, S >
  • Matches a non-empty list of R separated by S with optional trailing S.
  • Equivalent to seq< list< R, S >, opt< S > >.
  • Equivalent to seq< R, star_partial< S, R > >.
  • Meta data and implementation mapping:
    • list_tail< R, S >::rule_t is internal::seq< R, internal::star_partial< S, R > >
    • list_tail< R, S >::subs_t is type_list< R, internal::star_partial< S, R > >
list_tail< R, S, P >
  • Matches a non-empty list of R separated by S with optional trailing S and padding P inside the list.
  • Equivalent to seq< list< R, S, P >, opt< star< P >, S > >.
  • Equivalent to seq< R, star_partial< seq< star< P >, S >, seq< star< P >, R > > >.
  • Meta data and implementation mapping:
    • list_tail< R, S, P >::rule_t is internal::seq< R, internal::star_partial< internal::lpad< S, P >, internal::lpad< R, P > > >
    • list_tail< R, S, P >::subs_t is type_list< R, internal::star_partial< internal::lpad< S, P >, internal::lpad< R, P > > >
minus< M, S >
  • Succeeds if M matches, and S does not match all of the input that M matched.
  • Equivalent to rematch< M, not_at< S, eof > >.
  • Meta data and implementation mapping:
    • minus< M, S >::rule_t is internal::rematch< M, internal::not_at< S, internal::eof > >
    • minus< M, S >::subs_t is type_list< M, internal::not_at< S, internal::eof > >

Note that S is ignored by the grammar analysis.

pad< R, S, T = S >
  • Matches an R that can be padded by arbitrary many S on the left and T on the right.
  • Equivalent to seq< star< S >, R, star< T > >.
  • Meta data and implementation mapping:
    • pad< R, S, T >::rule_t is internal::seq< internal::star< S >, R, internal::star< T > >
    • pad< R, S, T >::subs_t is type_list< internal::star< S >, R, internal::star< T > >

A common mistake is to forget about the implicit star and use e.g. star< blank > for S (and T). This attempts to match star< star< S > > which is an infinite loop without progress. The PEGTL grammar analysis catches this mistake.

pad_opt< R, P >
  • Matches an optional R that can be padded by arbitrary many P, or just arbitrary many P.
  • Equivalent to seq< star< P >, opt< R, star< P > > >.
  • Meta data and implementation mapping:
    • pad_opt< R, P >::rule_t is internal::seq< internal::star< P >, internal::opt< R, internal::star< P > > >
    • pad_opt< R, P >::subs_t is type_list< internal::star< P >, internal::opt< R, internal::star< P > > >
partial< R... >
  • Similar to opt< R... > with one important difference:
  • Does not rewind the input after a partial match of R....
  • Attempts to match the given rules R... in the given order.
  • Succeeds and stops matching when one of the given rules fails;
  • also succeeds when all of the given rules succeed.
  • Consumes everything that the successful rules of R... consumed.
  • R must be a non-empty rule pack.
  • Equivalent to opt< R > when R... is a single rule.
  • Equivalent to opt< R1, opt< R2, opt< ... when R is R1, R2, ...
  • Meta data and implementation mapping:
    • partial< R... >::rule_t is internal::partial< R... >
    • partial< R... >::subs_t is type_list< R... >
rematch< R, S... >
  • Succeeds if R matches, and each S matches the input that R matched.
  • Meta data and implementation mapping:
    • rematch< R, S... >::rule_t is internal::rematch< R, S... >
    • rematch< R, S... >::subs_t is type_list< R, S... >

Note that the rules in S... do not need to match all of the input matched by R. (Which is why minus uses eof in its implementation to match to the end of what R matched).

Note that the S... are ignored in the grammar analysis.

rep< Num, R... >
  • Matches seq< R... > for Num times without checking for further matches.
  • Equivalent to seq< seq< R... >, ..., seq< R... > > where seq< R... > is repeated Num times.
  • Meta data and implementation mapping:
    • rep< 0, R... >::rule_t is internal::success
    • rep< N >::rule_t is internal::success
    • rep< N, R >::rule_t is internal::rep< N, R > for N > 0
    • rep< N, R >::subs_t is type_list< R >
    • rep< N, R... >::rule_t is internal::rep< N, internal::seq< R... > > for N > 0
    • rep< N, R... >::subs_t is type_list< internal::seq< R... > >
rep_max< Max, R... >
  • Matches seq< R... > for at most Max times and verifies that it doesn't match more often.
  • Equivalent to rep_min_max< 0, Max, R... >.
  • Meta data and implementation mapping:
    • rep_max< 0, R >::rule_t is internal::not_at< R >
    • rep_max< 0, R >::subs_t is type_list< R >
    • rep_max< 0, R... >::rule_t is internal::not_at< internal::seq< R... > >
    • rep_max< 0, R... >::subs_t is type_list< internal::seq< R... > >
    • rep_max< Max >::rule_t is internal::failure
    • rep_max< Max, R >::rule_t is internal::rep_min_max< 0, Max, R >
    • rep_max< Max, R >::subs_t is type_list< R >
    • rep_max< Max, R... >::rule_t is internal::rep_min_max< 0, Max, internal::seq< R... > >
    • rep_max< Max, R... >::subs_t is type_list< internal::seq< R... > >
rep_min< Min, R... >
  • Matches seq< R... > as often as possible and succeeds if it matches at least Min times.
  • Equivalent to seq< rep< Min, R... >, star< R... > >.
  • R must be a non-empty rule pack.
  • Meta data and implementation mapping:
    • rep_min< Min, R... >::rule_t is internal::seq< internal::rep< Min, R... >, internal::star< R... > >
    • rep_min< Min, R... >::subs_t is type_list< internal::rep< Min, R... >, internal::star< R... > >
rep_min_max< Min, Max, R... >
  • Matches seq< R... > for Min to Max times and verifies that it doesn't match more often.
  • Equivalent to seq< rep< Min, R... >, rep_opt< Max - Min, R... >, not_at< R... > >.
  • Meta data and implementation mapping:
    • rep_min_max< 0, 0, R >::rule_t is internal::not_at< R >
    • rep_min_max< 0, 0, R >::subs_t is type_list< R >
    • rep_min_max< 0, 0, R... >::rule_t is internal::not_at< internal::seq< R... > >
    • rep_min_max< 0, 0, R... >::subs_t is type_list< internal::seq< R... > >
    • rep_min_max< Min, Max >::rule_t is internal::failure
    • rep_min_max< Min, Max, R >::rule_t is internal::rep_min_max< Min, Max, R >
    • rep_min_max< Min, Max, R >::subs_t is type_list< R >
    • rep_min_max< Min, Max, R... >::rule_t is internal::rep_min_max< Min, Max, internal::seq< R... > >
    • rep_min_max< Min, Max, R... >::subs_t is type_list< internal::seq< R... > >
rep_opt< Num, R... >
  • Matches seq< R... > for zero to Num times without check for further matches.
  • Equivalent to rep< Num, opt< R... > >.
  • Meta data and implementation mapping:
    • rep_opt< Num >::rule_t is internal::success
    • rep_opt< Num, R >::rule_t is internal::rep_opt< Num, R > for Num > 0
    • rep_opt< Num, R >::subs_t is type_list< R >
    • rep_opt< Num, R... >::rule_t is internal::rep_opt< Num, internal::seq< R... > > for Num > 0
    • rep_opt< Num, R... >::subs_t is type_list< internal::seq< R... > >
separated< S, R... >
  • Like seq< R... > but with S as separator.
  • Equivalent to success for empty R....
  • Equivalent to seq< R > for single rule R.
  • Equivalent to seq< R1, S, R2, S, R3, ... > if R... is R1, R2, R3, ....
  • Meta data and implementation mapping:
    • separated< S >::rule_t is internal::success
    • separated< S, R >::rule_t is internal::seq< R >
    • separated< S, R >::subs_t is type_list< R >
    • separated< S, R1, R2, ... >::rule_t is internal::seq< R1, S, R2, ... >
    • separated< S, R1, R2, ... >::subs_t is type_list< R1, S, R2, ... >
separated_pad< S, P, R... >
  • Like seq< R... > but with pad< S, P > as separator.
  • Equivalent to separated< pad< S, P >, R... >.
  • Meta data and implementation mapping:
    • separated_pad< S, P >::rule_t is internal::success
    • separated_pad< S, P, R >::rule_t is internal::seq< R >
    • separated_pad< S, P, R >::subs_t is type_list< R >
    • separated_pad< S, P, R1, R2, ... >::rule_t is internal::seq< R1, internal::star< P >, S, internal::star< P >, R2, ... >
    • separated_pad< S, P, R1, R2, ... >::subs_t is type_list< R1, internal::star< P >, S, internal::star< P >, R2, ... >
star_partial< R... >
  • Similar to star< R... > with one important difference:
  • The final iteration does not rewind the input after a partial match of R....
  • R must be a non-empty rule pack.
  • Meta data and implementation mapping:
    • star_partial< R... >::rule_t is internal::star_partial< R... >
    • star_partial< R... >::subs_t is type_list< R... >
star_strict< R... >
  • Similar to star< R... > with one important difference:
  • A partial match of R... lets star_strict fail locally.
  • R must be a non-empty rule pack.
  • Meta data and implementation mapping:
    • star_strict< R... >::rule_t is internal::star_strict< R... >
    • star_strict< R... >::subs_t is type_list< R... >
strict< R... >
  • Similar to opt< R... > with one important difference:
  • A partial match of R... lets strict fail locally.
  • Equivalent to sor< not_at< R1 >, seq< R... > > if R1 is the first rule of R....
  • R must be a non-empty rule pack.
  • Meta data and implementation mapping:
    • strict< R... >::rule_t is internal::strict< R... >
    • strict< R... >::subs_t is type_list< R... >
unordered< R... >
  • Matches the rules R... in arbitrary order, more precisely:
  • Like rep< sizeof...( R ), sor< R'... > > where R' is updated each repetition to consist of those rules that have not matched in a previous repetition.
  • Meta data and implementation mapping:
    • unordered<>::rule_t is internal::success
    • unordered< R... >::rule_t is internal::unordered< false, R... >
    • unordered< R... >::subs_t is type_list< R... >

Note that the grammar analysis does not correctly handle recursions in the grammar that pass through an unordered rule.

unordered_partial< R... >
  • Combines the behavior of partial and unordered.
  • Meta data and implementation mapping:
    • unordered_partial<>::rule_t is internal::success
    • unordered_partial< R... >::rule_t is internal::unordered< true, R... >
    • unordered_partial< R... >::subs_t is type_list< R... >

Note that the grammar analysis does not correctly handle recursions in the grammar that pass through an unordered_partial rule.

until< R >
  • Consumes all input until R matches.
  • Equivalent to until< R, consume< 1 > >.
  • Meta data and implementation mapping:
    • until< R >::rule_t is internal::until< R >
    • until< R >::subs_t is type_list< R >
until< R, S... >
  • Matches seq< S... > as long as at< R > does not match and succeeds when R matches.
  • Equivalent to seq< star< not_at< R >, S... >, R >.
  • See the previous entry for until< R >, i.e. when S... is empty.
  • Meta data and implementation mapping:
    • until< R, S >::rule_t is internal::until< R, S >
    • until< R, S >::subs_t is type_list< R, S >
    • until< R, S... >::rule_t is internal::until< R, internal::seq< S... > >
    • until< R, S... >::subs_t is type_list< R, internal::seq< S... > >

Controlling

These rules manage and change the control, action and states during a parsing run.

These rules are in namespace tao::pegtl.

action< A, R... >
  • Equivalent to seq< R... >, but:
  • Uses the given class template A as action.
  • Does not change whether actions are enabled or disabled!
  • Meta data and implementation mapping:
    • action< A >::rule_t is internal::success
    • action< A, R >::rule_t is internal::action< A, R >
    • action< A, R >::subs_t is type_list< R >
    • action< A, R... >::rule_t is internal::action< A, internal::seq< R... > >
    • action< A, R... >::subs_t is type_list< internal::seq< R... > >
control< C, R... >
  • Equivalent to seq< R... >, but:
  • Uses the given class template C as control.
  • Meta data and implementation mapping:
    • control< C >::rule_t is internal::success
    • control< C, R >::rule_t is internal::control< C, R >
    • control< C, R >::subs_t is type_list< R >
    • control< C, R... >::rule_t is internal::control< C, internal::seq< R... > >
    • control< C, R... >::subs_t is type_list< internal::seq< R... > >
disable< R... >
  • Equivalent to seq< R... >, but:
  • Disables actions while parsing R..., i.e.
  • calls R... with apply_mode::disabled.
  • Meta data and implementation mapping:
    • disable<>::rule_t is internal::success
    • disable< R >::rule_t is internal::disable< R >
    • disable< R >::subs_t is type_list< R >
    • disable< R... >::rule_t is internal::disable< internal::seq< R... > >
    • disable< R... >::subs_t is type_list< internal::seq< R... > >
enable< R... >
  • Equivalent to seq< R... >, but:
  • Enables actions while parsing R..., i.e.
  • calls R... with apply_mode::enabled.
  • Meta data and implementation mapping:
    • enable<>::rule_t is internal::success
    • enable< R >::rule_t is internal::enable< R >
    • enable< R >::subs_t is type_list< R >
    • enable< R... >::rule_t is internal::enable< internal::seq< R... > >
    • enable< R... >::subs_t is type_list< internal::seq< R... > >
state< S, R... >
  • Equivalent to seq< R... >, but:
  • Replaces all state arguments with a new instance s of type S.
  • s is constructed with the input and all previous states as arguments, or
  • s is default constructed if S has no constructor for the above clause.
  • If R... succeeds then s.success() is called with the input (after the match) and all previous states as arguments.
  • Meta data and implementation mapping:
    • state< S >::rule_t is internal::success
    • state< S, R >::rule_t is internal::state< S, R >
    • state< S, R >::subs_t is type_list< R >
    • state< S, R... >::rule_t is internal::state< S, internal::seq< R... > >
    • state< S, R... >::subs_t is type_list< internal::seq< R... > >

Exceptional

These rules throw and/or catch exceptions and are only available when compiling with exception support.

These rules are in namespace tao::pegtl.

if_must< R, S... >
  • Attempts to match R and depending on the result proceeds with either must< S... > or failure.
  • Equivalent to seq< R, must< S... > >.
  • Equivalent to if_then_else< R, must< S... >, failure >.
  • Meta data and implementation mapping:
    • if_must< R >::rule_t is internal::if_must< false, R >
    • if_must< R >::subs_t is type_list< R >
    • if_must< R, S... >::rule_t is internal::if_must< false, R, S... >
    • if_must< R, S... >::subs_t is type_list< R, internal::must< S... > >

Note that the false template parameter to internal::if_must corresponds to the failure in the equivalent description using if_then_else.

if_must_else< R, S, T >
  • Attempts to match R and depending on the result proceeds with either must< S > or must< T >.
  • Equivalent to if_then_else< R, must< S >, must< T > >.
  • Meta data and implementation mapping:
    • if_must_else< R, S, T >::rule_t is internal::if_then_else< R, internal::must< S >, internal::must< T > >
    • if_must_else< R, S, T >::subs_t is type_list< R, internal::must< S >, internal::must< T > >
list_must< R, S >
  • Matches a non-empty list of R separated by S.
  • Similar to list< R, S >, but if there is an S it must be followed by an R.
  • Equivalent to seq< R, star< if_must< S, R > > >.
  • Meta data and implementation mapping:
    • list_must< R, S >::rule_t is internal::seq< R, internal::star< S, internal::must< R > > >
    • list_must< R, S >::subs_t is type_list< R, internal::star< S, internal::must< R > > >
list_must< R, S, P >
  • Matches a non-empty list of R separated by S where each S can be padded by P.
  • Similar to list< R, S, P >, but if there is an S it must be followed by an R.
  • Equivalent to seq< R, star< if_must< pad< S, P >, R > > >.
  • Meta data and implementation mapping:
    • list_must< R, S, P >::rule_t is internal::seq< R, internal::star< internal::pad< S, P >, internal::must< R > > >
    • list_must< R, S, P >::subs_t is type_list< R, internal::star< internal::pad< S, P >, internal::must< R > > >
must< R... >
  • Equivalent to seq< R... >, but:
  • Converts local failure of R... into global failure.
  • Calls raise< R > for the R that failed.
  • Equivalent to seq< sor< R, raise< R > >... >.
  • Meta data and implementation mapping:
    • must<>::rule_t is internal::success
    • must< R >::rule_t is internal::must< R >
    • must< R >::subs_t is type_list< R >
    • must< R... >::rule_t is internal::seq< internal::must< R >... >::rule_t
    • must< R... >::subs_t is type_list< internal::must< R >... >

Note that must uses a different pattern to handle multiple sub-rules compared to the other seq-equivalent rules (which use rule< seq< R... > > rather than seq< rule< R >... >).

opt_must< R, S... >
  • Equivalent to opt< if_must< R, S... > >.
  • Equivalent to if_then_else< R, must< S... >, success >.
  • Meta data and implementation mapping:
    • opt_must< R >::rule_t is internal::if_must< true, R >
    • opt_must< R >::subs_t is type_list< R >
    • opt_must< R, S... >::rule_t is internal::if_must< true, R, S... >
    • opt_must< R, S... >::subs_t is type_list< R, internal::must< S... > >

Note that the true template parameter to internal::if_must corresponds to the success in the equivalent description using if_then_else.

raise< T >
  • Generates a global failure.
  • Calls the control-class' Control< T >::raise() static member function.
  • T can be a rule, but it does not have to be a rule.
  • Does not consume input.
  • Meta data and implementation mapping:
    • raise< T >::rule_t is internal::raise< T >
raise_message< C... >
  • Generates a global failure with the message given by C....
  • Calls the control-class' Control< raise_message< C... > >::raise() static member function.
  • Does not consume input.
  • Meta data and implementation mapping:
    • raise_message< C... >::rule_t is internal::raise< raise_message< C... > >
star_must< R, S... >
  • Equivalent to star< if_must< R, S... > >.
  • Meta data and implementation mapping:
    • star_must< R >::rule_t is internal::star< internal::if_must< false, R > >
    • star_must< R >::subs_t is type_list< internal::if_must< false, R > >
    • star_must< R, S... >::rule_t is internal::star< internal::if_must< false, R, S... > >
    • star_must< R, S... >::subs_t is type_list< internal::if_must< false, R, S... > >
try_catch_any_raise_nested< R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of any type via catch( ... ) and:
  • Throws a new exception with the caught one as nested exception.
  • Throws via Control< R >::raise_nested() when R... is a single rule.
  • Throws via Control< internal::seq< R... > >::raise_nested() when R... is more than one rule.
  • Meta data and implementation mapping:
    • try_catch_any_raise_nested<>::rule_t is internal::success
    • try_catch_any_raise_nested< R >::rule_t is internal::try_catch_raise_nested< void, R >
    • try_catch_any_raise_nested< R >::subs_t is type_list< R >
    • try_catch_any_raise_nested< R... >::rule_t is internal::try_catch_raise_nested< void, internal::seq< R... > >
    • try_catch_any_raise_nested< R... >::subs_t is type_list< internal::seq< R... > >
try_catch_any_return_false< R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of any type via catch( ... ), and:
  • Converts the global failure (exception) into a local failure (return value false).
  • Meta data and implementation mapping:
    • try_catch_any_return_false<>::rule_t is internal::success
    • try_catch_any_return_false< R >::rule_t is internal::try_catch_return_false< void, R >
    • try_catch_any_return_false< R >::subs_t is type_list< R >
    • try_catch_any_return_false< R... >::rule_t is internal::try_catch_return_false< void, internal::seq< R... > >
    • try_catch_any_return_false< R... >::subs_t is type_list< internal::seq< R... > >
try_catch_raise_nested< R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of type tao::pegtl::parse_error_base (or derived), and:
  • Throws a new exception with the caught one as nested exception.
  • Throws via Control< R >::raise_nested() when R... is a single rule.
  • Throws via Control< internal::seq< R... > >::raise_nested() when R... is more than one rule.
  • Meta data and implementation mapping:
    • try_catch_raise_nested<>::rule_t is internal::success
    • try_catch_raise_nested< R >::rule_t is internal::try_catch_raise_nested< parse_error_base, R >
    • try_catch_raise_nested< R >::subs_t is type_list< R >
    • try_catch_raise_nested< R... >::rule_t is internal::try_catch_raise_nested< parse_error_base, internal::seq< R... > >
    • try_catch_raise_nested< R... >::subs_t is type_list< internal::seq< R... > >
try_catch_return_false< R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of type tao::pegtl::parse_error_base (or derived), and:
  • Converts the global failure (exception) into a local failure (return value false).
  • Meta data and implementation mapping:
    • try_catch_return_false<>::rule_t is internal::success
    • try_catch_return_false< R >::rule_t is internal::try_catch_return_false< parse_error_base, R >
    • try_catch_return_false< R >::subs_t is type_list< R >
    • try_catch_return_false< R... >::rule_t is internal::try_catch_return_false< parse_error_base, internal::seq< R... > >
    • try_catch_return_false< R... >::subs_t is type_list< internal::seq< R... > >
try_catch_std_raise_nested< R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of type std::exception (or derived), and:
  • Throws a new exception with the caught one as nested exception.
  • Throws via Control< R >::raise_nested() when R... is a single rule.
  • Throws via Control< internal::seq< R... > >::raise_nested() when R... is more than one rule.
  • Meta data and implementation mapping:
    • try_catch_std_raise_nested<>::rule_t is internal::success
    • try_catch_std_raise_nested< R >::rule_t is internal::try_catch_raise_nested< std::exception, R >
    • try_catch_std_raise_nested< R >::subs_t is type_list< R >
    • try_catch_std_raise_nested< R... >::rule_t is internal::try_catch_raise_nested< std::exception, internal::seq< R... > >
    • try_catch_std_raise_nested< R... >::subs_t is type_list< internal::seq< R... > >
try_catch_std_return_false< R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of type std::exception (or derived), and:
  • Converts the global failure (exception) into a local failure (return value false).
  • Meta data and implementation mapping:
    • try_catch_std_return_false<>::rule_t is internal::success
    • try_catch_std_return_false< R >::rule_t is internal::try_catch_return_false< std::exception, R >
    • try_catch_std_return_false< R >::subs_t is type_list< R >
    • try_catch_std_return_false< R... >::rule_t is internal::try_catch_return_false< std::exception, internal::seq< R... > >
    • try_catch_std_return_false< R... >::subs_t is type_list< internal::seq< R... > >
try_catch_type_raise_nested< E, R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of type E (or derived), and:
  • Throws a new exception with the caught one as nested exception.
  • Throws via Control< R >::raise_nested() when R... is a single rule.
  • Throws via Control< internal::seq< R... > >::raise_nested() when R... is more than one rule.
  • Meta data and implementation mapping:
    • try_catch_type_raise_nested< E >::rule_t is internal::success
    • try_catch_type_raise_nested< E, R >::rule_t is internal::try_catch_raise_nested< E, R >
    • try_catch_type_raise_nested< E, R >::subs_t is type_list< R >
    • try_catch_type_raise_nested< E, R... >::rule_t is internal::try_catch_raise_nested< E, internal::seq< R... > >
    • try_catch_type_raise_nested< E, R... >::subs_t is type_list< internal::seq< R... > >
try_catch_type_return_false< E, R... >
  • Equivalent to seq< R... >, but:
  • Catches exceptions of type E (or derived), and:
  • Converts the global failure (exception) into a local failure (return value false).
  • Meta data and implementation mapping:
    • try_catch_type_return_false< E >::rule_t is internal::success
    • try_catch_type_return_false< E, R >::rule_t is internal::try_catch_return_false< E, R >
    • try_catch_type_return_false< E, R >::subs_t is type_list< R >
    • try_catch_type_return_false< E, R... >::rule_t is internal::try_catch_return_false< E, internal::seq< R... > >
    • try_catch_type_return_false< E, R... >::subs_t is type_list< internal::seq< R... > >
TAO_PEGTL_RAISE_MESSAGE( "..." )
  • Macro where TAO_PEGTL_RAISE_MESSAGE( "foo" ) yields raise_message< 'f', 'o', 'o' >.
  • The argument must be a string literal.
  • Works for strings up to 512 bytes of length (excluding trailing '\0').

Compatibility

These rules replicate the intrusive way action invocations were part of the grammar in the PEGTL 0.x.

The actions for these rules are classes, rather than the class templates required by parse() and action<>. These rules respect the current apply_mode, but do not use the Control class to invoke the actions.

These rules are in namespace tao::pegtl.

apply< A... >
  • Calls A::apply() for all A, in order, with an empty input and all states as arguments.
  • If any A::apply() has a boolean return type and returns false, no further A::apply() calls are made and the apply< A... > rule returns false, otherwise:
  • Equivalent to success with respect to parsing.
  • Meta data and implementation mapping:
    • apply< A... >::rule_t is internal::apply< A... >
apply0< A... >
  • Calls A::apply0() for all A, in order, with all states as arguments.
  • If any A::apply0() has a boolean return type and returns false, no further A::apply0() calls are made and the apply0< A... > rule returns false, otherwise:
  • Equivalent to success with respect to parsing.
  • Meta data and implementation mapping:
    • apply0< A... >::rule_t is internal::apply0< A... >
if_apply< R, A... >
  • Equivalent to seq< R, apply< A... > > with respect to parsing, but also:
  • If R matches, calls A::apply(), for all A, in order, with the input matched by R and all states as arguments.
  • If any A::apply() has a boolean return type and returns false, no further A::apply() calls are made, the if_apply< R, A... > returns false, and if the rewind_mode is required the input is rewound.
  • Meta data and implementation mapping:
    • if_apply< R, A... >::rule_t is internal::if_apply< R, A... >
    • if_apply< R, A... >::subs_t is type_list< R >

ICU Support

These rules depend on the International Components for Unicode (ICU) that provide the means to match specific Unicode character properties.

Because of this external library dependency the ICU rules are not automatically included with tao/pegtl.hpp.

The convenience ICU rules are supplied for all properties found in ICU version 3.4. Users of later versions can use the basic rules manually or create their own convenience rules derived from the basic rules for additional enumeration values found in those later versions of the ICU library.

Just as the other Unicode rules, the ICU-based rules are available in multiple versions,

  • in namespace tao::pegtl::utf8::icu for UTF-8 encoded inputs,
  • in namespace alias tao::pegtl::utf16::icu for native-endian UTF-16 inputs,
  • in namespace alias tao::pegtl::utf32::icu for native-endian UTF-32 inputs.
  • in namespace tao::pegtl::utf16_be::icu for big-endian UTF-16 encoded inputs,
  • in namespace tao::pegtl::utf16_le::icu for little-endian UTF-16 encoded inputs,
  • in namespace tao::pegtl::utf32_be::icu for big-endian UTF-32 encoded inputs,
  • in namespace tao::pegtl::utf32_le::icu for little-endian UTF-32 encoded inputs.

To use these rules it is necessary to provide an include path to the ICU library, to link the application against libicu, and to manually include the following header files as required.

  • tao/pegtl/unicode/icu8.hpp
  • tao/pegtl/unicode/icu16.hpp
  • tao/pegtl/unicode/icu32.hpp

Basic ICU Rules

Each of the above namespaces provides two basic rules for matching binary properties and property value matching for enum properties.

binary_property< P, V >
  • P is a binary property defined by ICU, see UProperty.
  • V is a boolean value.
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • The code point's property P, i.e. u_hasBinaryProperty( cp, P ), equals V.
  • Consumes the N input objects on success.
binary_property< P >
  • Identical to binary_property< P, true >.
property_value< P, V >
  • P is an enumerated property defined by ICU, see UProperty.
  • V is an integer value.
  • Succeeds when the input is not empty, and:
  • The next N input objects encode a valid Unicode code point, and:
  • The code point's property P, i.e. u_getIntPropertyValue( cp, P ), equals V.
  • Consumes the N input objects on success.

ICU Rules for Binary Properties

Convenience wrappers for binary properties.

alphabetic
  • Equivalent to binary_property< UCHAR_ALPHABETIC >.
ascii_hex_digit
  • Equivalent to binary_property< UCHAR_ASCII_HEX_DIGIT >.
bidi_control
  • Equivalent to binary_property< UCHAR_BIDI_CONTROL >.
bidi_mirrored
  • Equivalent to binary_property< UCHAR_BIDI_MIRRORED >.
case_sensitive
  • Equivalent to binary_property< UCHAR_CASE_SENSITIVE >.
dash
default_ignorable_code_point
  • Equivalent to binary_property< UCHAR_DEFAULT_IGNORABLE_CODE_POINT >.
deprecated
  • Equivalent to binary_property< UCHAR_DEPRECATED >.
diacritic
  • Equivalent to binary_property< UCHAR_DIACRITIC >.
extender
  • Equivalent to binary_property< UCHAR_EXTENDER >.
full_composition_exclusion
  • Equivalent to binary_property< UCHAR_FULL_COMPOSITION_EXCLUSION >.
grapheme_base
  • Equivalent to binary_property< UCHAR_GRAPHEME_BASE >.
grapheme_extend
  • Equivalent to binary_property< UCHAR_GRAPHEME_EXTEND >.
  • Equivalent to binary_property< UCHAR_GRAPHEME_LINK >.
hex_digit
  • Equivalent to binary_property< UCHAR_HEX_DIGIT >.
hyphen
id_continue
  • Equivalent to binary_property< UCHAR_ID_CONTINUE >.
id_start
  • Equivalent to binary_property< UCHAR_ID_START >.
ideographic
  • Equivalent to binary_property< UCHAR_IDEOGRAPHIC >.
ids_binary_operator
  • Equivalent to binary_property< UCHAR_IDS_BINARY_OPERATOR >.
ids_trinary_operator
  • Equivalent to binary_property< UCHAR_IDS_TRINARY_OPERATOR >.
join_control
  • Equivalent to binary_property< UCHAR_JOIN_CONTROL >.
logical_order_exception
  • Equivalent to binary_property< UCHAR_LOGICAL_ORDER_EXCEPTION >.
lowercase
  • Equivalent to binary_property< UCHAR_LOWERCASE >.
math
nfc_inert
  • Equivalent to binary_property< UCHAR_NFC_INERT >.
nfd_inert
  • Equivalent to binary_property< UCHAR_NFD_INERT >.
nfkc_inert
  • Equivalent to binary_property< UCHAR_NFKC_INERT >.
nfkd_inert
  • Equivalent to binary_property< UCHAR_NFKD_INERT >.
noncharacter_code_point
  • Equivalent to binary_property< UCHAR_NONCHARACTER_CODE_POINT >.
pattern_syntax
  • Equivalent to binary_property< UCHAR_PATTERN_SYNTAX >.
pattern_white_space
  • Equivalent to binary_property< UCHAR_PATTERN_WHITE_SPACE >.
posix_alnum
  • Equivalent to binary_property< UCHAR_POSIX_ALNUM >.
posix_blank
  • Equivalent to binary_property< UCHAR_POSIX_BLANK >.
posix_graph
  • Equivalent to binary_property< UCHAR_POSIX_GRAPH >.
posix_print
  • Equivalent to binary_property< UCHAR_POSIX_PRINT >.
posix_xdigit
  • Equivalent to binary_property< UCHAR_POSIX_XDIGIT >.
quotation_mark
  • Equivalent to binary_property< UCHAR_QUOTATION_MARK >.
radical
s_term
segment_starter
  • Equivalent to binary_property< UCHAR_SEGMENT_STARTER >.
soft_dotted
  • Equivalent to binary_property< UCHAR_SOFT_DOTTED >.
terminal_punctuation
  • Equivalent to binary_property< UCHAR_TERMINAL_PUNCTUATION >.
unified_ideograph
  • Equivalent to binary_property< UCHAR_UNIFIED_IDEOGRAPH >.
uppercase
  • Equivalent to binary_property< UCHAR_UPPERCASE >.
variation_selector
  • Equivalent to binary_property< UCHAR_VARIATION_SELECTOR >.
white_space
  • Equivalent to binary_property< UCHAR_WHITE_SPACE >.
xid_continue
  • Equivalent to binary_property< UCHAR_XID_CONTINUE >.
xid_start
  • Equivalent to binary_property< UCHAR_XID_START >.

ICU Rules for Enumerated Properties

Convenience wrappers for enumerated properties.

bidi_class< V >
  • V is of type UCharDirection.
  • Equivalent to property_value< UCHAR_BIDI_CLASS, V >.
block< V >
  • V is of type UBlockCode.
  • Equivalent to property_value< UCHAR_BLOCK, V >.
decomposition_type< V >
  • V is of type UDecompositionType.
  • Equivalent to property_value< UCHAR_DECOMPOSITION_TYPE, V >.
east_asian_width< V >
  • V is of type UEastAsianWidth.
  • Equivalent to property_value< UCHAR_EAST_ASIAN_WIDTH, V >.
general_category< V >
  • V is of type UCharCategory.
  • Equivalent to property_value< UCHAR_GENERAL_CATEGORY, V >.
grapheme_cluster_break< V >
  • V is of type UGraphemeClusterBreak.
  • Equivalent to property_value< UCHAR_GRAPHEME_CLUSTER_BREAK, V >.
hangul_syllable_type< V >
  • V is of type UHangulSyllableType.
  • Equivalent to property_value< UCHAR_HANGUL_SYLLABLE_TYPE, V >.
joining_group< V >
  • V is of type UJoiningGroup.
  • Equivalent to property_value< UCHAR_JOINING_GROUP, V >.
joining_type< V >
  • V is of type UJoiningType.
  • Equivalent to property_value< UCHAR_JOINING_TYPE, V >.
line_break< V >
  • V is of type ULineBreak.
  • Equivalent to property_value< UCHAR_LINE_BREAK, V >.
numeric_type< V >
  • V is of type UNumericType.
  • Equivalent to property_value< UCHAR_NUMERIC_TYPE, V >.
sentence_break< V >
  • V is of type USentenceBreak.
  • Equivalent to property_value< UCHAR_SENTENCE_BREAK, V >.
word_break< V >
  • V is of type UWordBreakValues.
  • Equivalent to property_value< UCHAR_WORD_BREAK, V >.

ICU Rules for Value Properties

Convenience wrappers for enumerated properties that return a value instead of an actual enum.

canonical_combining_class< V >
  • V is of type std::uint8_t.
  • Equivalent to property_value< UCHAR_CANONICAL_COMBINING_CLASS, V >.
lead_canonical_combining_class< V >
  • V is of type std::uint8_t.
  • Equivalent to property_value< UCHAR_LEAD_CANONICAL_COMBINING_CLASS, V >.
trail_canonical_combining_class< V >
  • V is of type std::uint8_t.
  • Equivalent to property_value< UCHAR_TRAIL_CANONICAL_COMBINING_CLASS, V >.

Index

This page is part of the PEGTL and its documentation.

Copyright (c) 2014-2026 Dr. Colin Hirsch and Daniel Frey
Distributed under the Boost Software License, Version 1.0
See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt