This page contains brief descriptions of all PEGTL rule and combinator classes.
The information about how much input is consumed by the rules only applies to when the rules succeed; the PEGTL is implemented in a way that assumes that rules never consume input when they do not succeed.
Remember that there are two failure modes, only the first of which usually leads to back-tracking:
false
, in which case the rule must rewind the input to the position at which the rule match was attempted.tao::parse_error
) that is usually generated by a control-class' raise()
-method.Some rule classes are said to be equivalent to a combination of other rules. These rules are not completely equivalent to the shown definition because that is not how they are implemented, therefore:
However, rule equivalence does show exactly where the raise<>
rule is inserted
and therefore which rule will be used to call the control class' raise()
-method.
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 describe R
as "empty".
When at least one parameter is given, i.e. seq< A >
or seq< A, B, C >
, R
is "non-empty".
These rules are in namespace tao::pegtl
.
action< A, R... >
seq< R... >
, but:A
for actions.disable
) or implicitly (via at
or not_at
).control< C, R... >
seq< R... >
, but:C
as control class.disable< R... >
seq< R... >
, but:discard
success
, but:discard()
-method.discard
might occur and/or nested within a rule for which an action with input can be called.enable< R... >
seq< R... >
, but:require< Num >
Num
further input bytes are available.state< S, R... >
seq< R... >
, but:s
of type S
.s
is constructed with the input and all previous states as arguments.seq< R... >
succeeds then s.success()
is called with the input after the match and all previous states as arguments, and, if expected, with A, M, Action, Control
as template parameters.Combinators (or combinator rules) are rules that combine (other) rules into new ones.
These are the classical PEG combinator rules defined in namespace tao::pegtl
.
at< R... >
seq< R... >
would succeed.R...
even within must<>
etc.not_at< R... >
seq< R... >
would not succeed.R...
even within must<>
etc.opt< R... >
seq< R... >
, i.e. attempt to match seq< R... >
and signal success regardless of the result.sor< seq< R... >, success >
.R...
even within must<>
etc.plus< R... >
seq< R... >
as often as possible and succeeds if it matches at least once.rep_min< 1, R... >
.R
must be a non-empty rule pack.seq< R... >
R...
in the given order.R...
consumed.R
is an empty rule pack.sor< R... >
R...
in the given order.R...
even within must<>
etc.R
is an empty rule pack.star< R... >
seq< R... >
as often as possible and always succeeds.R...
even within must<>
etc.R
must be a non-empty rule pack.The PEGTL offers a variety of convenience rules which help writing concise grammars as well as offering performance benefits over the equivalent implementation with classical PEG combinators.
These rules are in namespace tao::pegtl
.
if_must< R, S... >
R
and depending on the result proceeds with either must< S... >
or failure
.seq< R, must< S... > >
.if_then_else< R, must< S... >, failure >
.if_must_else< R, S, T >
R
and depending on the result proceeds with either must< S >
or must< T >
.if_then_else< R, must< S >, must< T > >
.if_then_else< R, S, T >
sor< seq< R, S >, seq< not_at< R >, T > >
.list< R, S >
R
separated by S
.seq< R, star< S, R > >
.list< R, S, P >
R
separated by S
where each S
can be padded by P
.seq< R, star< pad< S, P >, R > >
.list_must< R, S >
R
separated by S
.list< R, S >
, but if there is an S
it must be followed by an R
.seq< R, star< if_must< S, R > > >
.list_must< R, S, P >
R
separated by S
where each S
can be padded by P
.list< R, S, P >
, but if there is an S
it must be followed by an R
.seq< R, star< if_must< pad< S, P >, R > > >
.list_tail< R, S >
R
separated by S
with optional trailing S
.seq< list< R, S >, opt< S > >
.list_tail< R, S, P >
R
separated by S
with optional trailing S
and padding P
inside the list.seq< list< R, S, P >, opt< star< P >, S > >
.minus< M, S >
M
matches, and then S
does not match all of the input that M
matched.S
(unless S
contains enable<>
).S
for the grammar analysis.must< R... >
seq< R... >
, but:R...
into global failure.raise< R >
for the R
that failed.seq< sor< R, raise< R > >... >
.opt_must< R, S... >
opt< if_must< R, S... > >
.pad< R, S, T = S >
R
that can be padded by arbitrary many S
on the left and T
on the right.seq< star< S >, R, star< T > >
.pad_opt< R, P >
R
that can be padded by arbitrary many P
or just arbitrary many P
.seq< star< P >, opt< R, star< P > > >
.rep< Num, R... >
seq< R... >
for Num
times without checking for further matches.seq< seq< R... >, ..., seq< R... > >
where seq< R... >
is repeated Num
times.rep_max< Max, R... >
seq< R... >
for at most Max
times and verifies that it doesn't match more often.rep_min_max< 0, Max, R... >
.rep_min< Min, R... >
seq< R... >
as often as possible and succeeds if it matches at least Min
times.seq< rep< Min, R... >, star< R... > >
.R
must be a non-empty rule pack.rep_min_max< Min, Max, R... >
seq< R... >
for Min
to Max
times and verifies that it doesn't match more often.seq< rep< Min, R... >, rep_opt< Max - Min, R... >, not_at< R... > >
.rep_opt< Num, R... >
seq< R... >
for zero to Num
times without check for further matches.rep< Num, opt< R... > >
.star_must< R, S... >
star< if_must< R, S... > >
.try_catch< R... >
seq< R... >
, but:false
).tao::pegtl::parse_error
.try_catch_type< E, R... >
seq< R... >
, but:false
).E
.until< R >
R
matches.until< R, any >
.until< R, S... >
seq< S... >
as long as at< R >
does not match and succeeds when R
matches.seq< star< not_at< R >, not_at< eof >, S... >, R >
.S
is an empty rule pack, see the previous entry for the semantics of until< R >
.These rules are in namespace tao::pegtl
.
These rules replicate the intrusive way actions were called from within the grammar in the PEGTL 0.x with the apply<>
and if_apply<>
rules.
The actions for these rules are classes (rather than class templates as required for the parse()
-functions and action<>
-rule).
These rules respect the current apply_mode
, but don't use the control-class to invoke the actions.
apply< A... >
A::apply()
for all A
, in order, with an empty input and all states as arguments.A::apply()
has a boolean return type and returns false
, no further A::apply()
calls are made and the result is equivalent to failure
, otherwise:success
wrt. parsing.apply0< A... >
A::apply0()
for all A
, in order, with all states as arguments.A::apply0()
has a boolean return type and returns false
, no further A::apply0()
calls are made and the result is equivalent to failure
, otherwise:success
wrt. parsing.if_apply< R, A... >
seq< R, apply< A... > >
wrt. parsing, but also:R
matches, calls A::apply()
, for all A
, in order, with the input matched by R
and all states as arguments.A::apply()
has a boolean return type and returns false
, no further A::apply()
calls are made.These rules are in namespace tao::pegtl
.
Atomic rules do not rely on other rules.
bof
byte()
method returns zero.byte()
method.bol
byte_in_line()
method returns zero.byte_in_line()
method.bytes< Num >
Num
further bytes.Num
bytes from the input.eof
failure
raise< T >
Control< T >::raise()
-method.T
can be a rule, but it does not have to be a rule.success
These rules are in the inline namespace tao::pegtl::ascii
.
The ASCII rules operate on single bytes, without restricting the range of values to 7 bits.
They are compatible with input with the 8th bit set in the sense that nothing breaks in their presence.
Rules like ascii::any
or ascii::not_one< 'a' >
will match all possible byte values,
and all possible byte values excluding 'a'
, respectively. However the character class rules like
ascii::alpha
only match the corresponding ASCII characters.
(It is possible to match UTF-8 multi-byte characters with the ASCII rules,
for example the Euro sign code point U+20AC
, which is encoded by the UTF-8 sequence E2 82 AC
,
can be matched by either tao::pegtl::ascii::string< 0xe2, 0x82, 0xac >
or tao::pegtl::utf8::one< 0x20ac >
.)
alnum
ranges< 'a', 'z', 'A', 'Z', '0', '9' >
.alpha
ranges< 'a', 'z', 'A', 'Z' >
.any
bytes< 1 >
.blank
one< ' ', '\t' >
.digit
range< '0', '9' >
.eol
Eol
template parameter of the input, by default:sor< one< '\n' >, string< '\r', '\n' > >
.eolf
sor< eof, eol >
.identifier_first
ranges< 'a', 'z', 'A', 'Z', '_' >
.identifier_other
ranges< 'a', 'z', 'A', 'Z', '0', '9', '_' >
.identifier
seq< identifier_first, star< identifier_other > >
.istring< C... >
C...
with case insensitive matching.string< C... >
, but:keyword< C... >
seq< string< C... >, not_at< identifier_other > >
.lower
range< 'a', 'z' >
.not_one< C... >
C
is an empty character pack or the next input byte is not one of C...
.not_range< C, D >
C ... D
.nul
one< 0 >
.one< C... >
C...
.C
is an empty character pack.print
range< 32, 126 >
.range< C, D >
C ... D
.ranges< C1, D1, C2, D2, ... >
sor< range< C1, D1 >, range< C2, D2 >, ... >
.ranges< C1, D1, C2, D2, ..., E >
sor< range< C1, D1 >, range< C2, D2 >, ..., one< E > >
.seven
range< 0, 127 >
.shebang
seq< string< '#', '!' >, until< eolf > >
.space
one< ' ', '\n', '\r', 't', '\v', '\f' >
.string< C... >
seq< one< C >... >
.TAO_PEGTL_ISTRING( "..." )
TAO_PEGTL_ISTRING( "foo" )
yields istring< 'f', 'o', 'o' >
.'\0'
).'\0'
.TAO_PEGTL_KEYWORD( "..." )
TAO_PEGTL_KEYWORD( "foo" )
yields keyword< 'f', 'o', 'o' >
.'\0'
).'\0'
.TAO_PEGTL_STRING( "..." )
TAO_PEGTL_STRING( "foo" )
yields string< 'f', 'o', 'o' >
.'\0'
).'\0'
.three< C >
C
.two< C >
C
.upper
range< 'A', 'Z' >
.xdigit
ranges< '0', '9', 'a', 'f', 'A', 'F' >
.These rules are available in multiple versions,
tao::pegtl::utf8
for UTF-8 encoded inputs,tao::pegtl::utf16_be
for big-endian UTF-16 encoded inputs,tao::pegtl::utf16_le
for little-endian UTF-16 encoded inputs,tao::pegtl::utf32_be
for big-endian UTF-32 encoded inputs,tao::pegtl::utf32_le
for little-endian UTF-32 encoded inputs.For convenience, they also appear in multiple namespace aliases,
tao::pegtl::utf16
for native-endian UTF-16 encoded inputs,tao::pegtl::utf32
for native-endian UTF-32 encoded inputs.The following limitations apply to the UTF-16 and UTF-32 rules:
Unaligned memory is no problem on x86 compatible processors; on some other architectures like ARM an unaligned access will crash the application.
In the following descriptions a Unicode code point is considered valid when it is in the range 0
to 0x10ffff
.
The parameter N stands for the size of the encoding of the next Unicode code point in the input, i.e.
Following what appears to be "best" practice for UTF-16, it is not an error when a code unit in the range 0xd800
to 0xdfff
is encountered outside of a valid surrogate pair!
any
bom
one< 0xfeff >
.not_one< C... >
C
is an empty character pack or the input code point is not one of the given code points C...
.not_range< C, D >
B
satisfies B < C || D < B
.one< C... >
C
is a non-empty character pack and the input code point is one of the given code points C...
.range< C, D >
B
satisfies C <= B && B <= D
.ranges< C1, D1, C2, D2, ... >
sor< range< C1, D1 >, range< C2, D2 >, ... >
.ranges< C1, D1, C2, D2, ..., E >
sor< range< C1, D1 >, range< C2, D2 >, ..., one< E > >
.string< C... >
seq< one< C >... >
.The following rules depend on the International Components for Unicode (ICU) that provide the means to match characters with specific Unicode character properties.
Because of the external dependency, the rules are in the contrib-section, and the required header files are not automatically included in tao/pegtl.hpp
.
The ICU-based rules are again available in multiple versions,
tao::pegtl::icu::utf8
for UTF-8 encoded inputs,tao::pegtl::icu::utf16_be
for big-endian UTF-16 encoded inputs,tao::pegtl::icu::utf16_le
for little-endian UTF-16 encoded inputs,tao::pegtl::icu::utf32_be
for big-endian UTF-32 encoded inputs, andtao::pegtl::icu::utf32_le
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 one or more of the following header files:
tao/pegtl/contrib/icu/utf8.hpp
tao/pegtl/contrib/icu/utf16.hpp
tao/pegtl/contrib/icu/utf32.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.
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.P
, i.e. u_hasBinaryProperty( cp, P )
, equals V
.binary_property< P >
binary_property< P, true >
.property_value< P, V >
P
is an enumerated property defined by ICU, see UProperty
.V
is an integer value.P
, i.e. u_getIntPropertyValue( cp, P )
, equals V
.Convenience wrappers for binary properties.
alphabetic
binary_property< UCHAR_ALPHABETIC >
.ascii_hex_digit
binary_property< UCHAR_ASCII_HEX_DIGIT >
.bidi_control
binary_property< UCHAR_BIDI_CONTROL >
.bidi_mirrored
binary_property< UCHAR_BIDI_MIRRORED >
.case_sensitive
binary_property< UCHAR_CASE_SENSITIVE >
.dash
binary_property< UCHAR_DASH >
.default_ignorable_code_point
binary_property< UCHAR_DEFAULT_IGNORABLE_CODE_POINT >
.deprecated
binary_property< UCHAR_DEPRECATED >
.diacritic
binary_property< UCHAR_DIACRITIC >
.extender
binary_property< UCHAR_EXTENDER >
.full_composition_exclusion
binary_property< UCHAR_FULL_COMPOSITION_EXCLUSION >
.grapheme_base
binary_property< UCHAR_GRAPHEME_BASE >
.grapheme_extend
binary_property< UCHAR_GRAPHEME_EXTEND >
.grapheme_link
binary_property< UCHAR_GRAPHEME_LINK >
.hex_digit
binary_property< UCHAR_HEX_DIGIT >
.hyphen
binary_property< UCHAR_HYPHEN >
.id_continue
binary_property< UCHAR_ID_CONTINUE >
.id_start
binary_property< UCHAR_ID_START >
.ideographic
binary_property< UCHAR_IDEOGRAPHIC >
.ids_binary_operator
binary_property< UCHAR_IDS_BINARY_OPERATOR >
.ids_trinary_operator
binary_property< UCHAR_IDS_TRINARY_OPERATOR >
.join_control
binary_property< UCHAR_JOIN_CONTROL >
.logical_order_exception
binary_property< UCHAR_LOGICAL_ORDER_EXCEPTION >
.lowercase
binary_property< UCHAR_LOWERCASE >
.math
binary_property< UCHAR_MATH >
.nfc_inert
binary_property< UCHAR_NFC_INERT >
.nfd_inert
binary_property< UCHAR_NFD_INERT >
.nfkc_inert
binary_property< UCHAR_NFKC_INERT >
.nfkd_inert
binary_property< UCHAR_NFKD_INERT >
.noncharacter_code_point
binary_property< UCHAR_NONCHARACTER_CODE_POINT >
.pattern_syntax
binary_property< UCHAR_PATTERN_SYNTAX >
.pattern_white_space
binary_property< UCHAR_PATTERN_WHITE_SPACE >
.posix_alnum
binary_property< UCHAR_POSIX_ALNUM >
.posix_blank
binary_property< UCHAR_POSIX_BLANK >
.posix_graph
binary_property< UCHAR_POSIX_GRAPH >
.posix_print
binary_property< UCHAR_POSIX_PRINT >
.posix_xdigit
binary_property< UCHAR_POSIX_XDIGIT >
.quotation_mark
binary_property< UCHAR_QUOTATION_MARK >
.radical
binary_property< UCHAR_RADICAL >
.s_term
binary_property< UCHAR_S_TERM >
.segment_starter
binary_property< UCHAR_SEGMENT_STARTER >
.soft_dotted
binary_property< UCHAR_SOFT_DOTTED >
.terminal_punctuation
binary_property< UCHAR_TERMINAL_PUNCTUATION >
.unified_ideograph
binary_property< UCHAR_UNIFIED_IDEOGRAPH >
.uppercase
binary_property< UCHAR_UPPERCASE >
.variation_selector
binary_property< UCHAR_VARIATION_SELECTOR >
.white_space
binary_property< UCHAR_WHITE_SPACE >
.xid_continue
binary_property< UCHAR_XID_CONTINUE >
.xid_start
binary_property< UCHAR_XID_START >
.Convenience wrappers for enumerated properties.
bidi_class< V >
V
is of type UCharDirection
.property_value< UCHAR_BIDI_CLASS, V >
.block< V >
V
is of type UBlockCode
.property_value< UCHAR_BLOCK, V >
.decomposition_type< V >
V
is of type UDecompositionType
.property_value< UCHAR_DECOMPOSITION_TYPE, V >
.east_asian_width< V >
V
is of type UEastAsianWidth
.property_value< UCHAR_EAST_ASIAN_WIDTH, V >
.general_category< V >
V
is of type UCharCategory
.property_value< UCHAR_GENERAL_CATEGORY, V >
.grapheme_cluster_break< V >
V
is of type UGraphemeClusterBreak
.property_value< UCHAR_GRAPHEME_CLUSTER_BREAK, V >
.hangul_syllable_type< V >
V
is of type UHangulSyllableType
.property_value< UCHAR_HANGUL_SYLLABLE_TYPE, V >
.joining_group< V >
V
is of type UJoiningGroup
.property_value< UCHAR_JOINING_GROUP, V >
.joining_type< V >
V
is of type UJoiningType
.property_value< UCHAR_JOINING_TYPE, V >
.line_break< V >
V
is of type ULineBreak
.property_value< UCHAR_LINE_BREAK, V >
.numeric_type< V >
V
is of type UNumericType
.property_value< UCHAR_NUMERIC_TYPE, V >
.sentence_break< V >
V
is of type USentenceBreak
.property_value< UCHAR_SENTENCE_BREAK, V >
.word_break< V >
V
is of type UWordBreakValues
.property_value< UCHAR_WORD_BREAK, V >
.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
.property_value< UCHAR_CANONICAL_COMBINING_CLASS, V >
.lead_canonical_combining_class< V >
V
is of type std::uint8_t
.property_value< UCHAR_LEAD_CANONICAL_COMBINING_CLASS, V >
.trail_canonical_combining_class< V >
V
is of type std::uint8_t
.property_value< UCHAR_TRAIL_CANONICAL_COMBINING_CLASS, V >
.These rules are available in multiple versions,
tao::pegtl::uint8
for 8-bit integer values,tao::pegtl::uint16_be
for big-endian 16-bit integer values,tao::pegtl::uint16_le
for little-endian 16-bit integer values,tao::pegtl::uint32_be
for big-endian 32-bit integer values,tao::pegtl::uint32_le
for little-endian 32-bit integer values,tao::pegtl::uint64_be
for big-endian 64-bit integer values, andtao::pegtl::uint64_le
for little-endian 64-bit integer values.These rules read one or more bytes from the input to form (and match) an 8, 16, 32 or 64-bit value, respectively, and template parameters are given as matching std::uint8_t
, std::uint16_t
, std::uint32_t
or std::uin64_t
.
In the following descriptions the parameter N is the size of a single value in bytes, i.e. either 1, 2, 4 or 8. The term input value indicates a correspondingly sized integer value read from successive bytes of the input.
any
mask_not_one< M, C... >
C
is an empty character pack or the (endian adjusted) input value masked with M
is not one of the given values C...
.mask_not_range< M, C, D >
B
satisfies ( B & M ) < C || D < ( B & M )
.mask_one< M, C... >
C
is a non-empty character pack and the (endian adjusted) input value masked with M
is one of the given values C...
.mask_range< M, C, D >
B
satisfies C <= ( B & M ) && ( B & M ) <= D
.mask_ranges< M, C1, D1, C2, D2, ... >
sor< mask_range< M, C1, D1 >, mask_range< M, C2, D2 >, ... >
.mask_ranges< M, C1, D1, C2, D2, ..., E >
sor< mask_range< M, C1, D1 >, mask_range< M, C2, D2 >, ..., mask_one< M, E > >
.mask_string< M, C... >
seq< mask_one< M, C >... >
.not_one< C... >
C
is an empty character pack or the (endian adjusted) input value is not one of the given values C...
.not_range< C, D >
B
satisfies B < C || D < B
.one< C... >
C
is a non-empty character pack and the (endian adjusted) input value is one of the given values C...
.range< C, D >
B
satisfies C <= B && B <= D
.ranges< C1, D1, C2, D2, ... >
sor< range< C1, D1 >, range< C2, D2 >, ... >
.ranges< C1, D1, C2, D2, ..., E >
sor< range< C1, D1 >, range< C2, D2 >, ..., one< E > >
.string< C... >
seq< one< C >... >
.action< A, R... >
<sup>(meta rules)</sup>alnum
<sup>(ascii rules)</sup>alpha
<sup>(ascii rules)</sup>alphabetic
<sup>(icu rules)</sup>any
<sup>(ascii rules)</sup>any
<sup>(unicode rules)</sup>any
<sup>(binary rules)</sup>apply< A... >
<sup>(action rules)</sup>apply0< A... >
<sup>(action rules)</sup>ascii_hex_digit
<sup>(icu rules)</sup>at< R... >
<sup>(combinators)</sup>bidi_class< V >
<sup>(icu rules)</sup>bidi_control
<sup>(icu rules)</sup>bidi_mirrored
<sup>(icu rules)</sup>binary_property< P >
<sup>(icu rules)</sup>binary_property< P, V >
<sup>(icu rules)</sup>blank
<sup>(ascii rules)</sup>block< V >
<sup>(icu rules)</sup>bof
<sup>(atomic rules)</sup>bol
<sup>(atomic rules)</sup>bom
<sup>(unicode rules)</sup>bytes< Num >
<sup>(atomic rules)</sup>canonical_combining_class< V >
<sup>(icu rules)</sup>case_sensitive
<sup>(icu rules)</sup>control< C, R... >
<sup>(meta rules)</sup>dash
<sup>(icu rules)</sup>decomposition_type< V >
<sup>(icu rules)</sup>default_ignorable_code_point
<sup>(icu rules)</sup>deprecated
<sup>(icu rules)</sup>diacritic
<sup>(icu rules)</sup>digit
<sup>(ascii rules)</sup>disable< R... >
<sup>(meta rules)</sup>discard
<sup>(meta rules)</sup>east_asian_width< V >
<sup>(icu rules)</sup>enable< R... >
<sup>(meta-rules)</sup>eof
<sup>(atomic rules)</sup>eol
<sup>(ascii rules)</sup>eolf
<sup>(ascii rules)</sup>extender
<sup>(icu rules)</sup>failure
<sup>(atomic rules)</sup>full_composition_exclusion
<sup>(icu rules)</sup>general_category< V >
<sup>(icu rules)</sup>grapheme_base
<sup>(icu rules)</sup>grapheme_cluster_break< V >
<sup>(icu rules)</sup>grapheme_extend
<sup>(icu rules)</sup>grapheme_link
<sup>(icu rules)</sup>hangul_syllable_type< V >
<sup>(icu rules)</sup>hex_digit
<sup>(icu rules)</sup>hyphen
<sup>(icu rules)</sup>id_continue
<sup>(icu rules)</sup>id_start
<sup>(icu rules)</sup>identifier_first
<sup>(ascii rules)</sup>identifier_other
<sup>(ascii rules)</sup>identifier
<sup>(ascii rules)</sup>ideographic
<sup>(icu rules)</sup>ids_binary_operator
<sup>(icu rules)</sup>ids_trinary_operator
<sup>(icu rules)</sup>if_apply< R, A... >
<sup>(action rules)</sup>if_must< R, S... >
<sup>(convenience)</sup>if_must_else< R, S, T >
<sup>(convenience)</sup>if_then_else< R, S, T >
<sup>(convenience)</sup>istring< C... >
<sup>(ascii rules)</sup>join_control
<sup>(icu rules)</sup>joining_group< V >
<sup>(icu rules)</sup>joining_type< V >
<sup>(icu rules)</sup>keyword< C... >
<sup>(ascii rules)</sup>lead_canonical_combining_class< V >
<sup>(icu rules)</sup>line_break< V >
<sup>(icu rules)</sup>list< R, S >
<sup>(convenience)</sup>list< R, S, P >
<sup>(convenience)</sup>list_must< R, S >
<sup>(convenience)</sup>list_must< R, S, P >
<sup>(convenience)</sup>list_tail< R, S >
<sup>(convenience)</sup>list_tail< R, S, P >
<sup>(convenience)</sup>logical_order_exception
<sup>(icu rules)</sup>lower
<sup>(ascii rules)</sup>lowercase
<sup>(icu rules)</sup>mask_not_one< M, C... >
<sup>(binary rules)</sup>mask_not_range< M, C, D >
<sup>(binary rules)</sup>mask_one< M, C... >
<sup>(binary rules)</sup>mask_range< M, C, D >
<sup>(binary rules)</sup>mask_ranges< M, C1, D1, C2, D2, ... >
<sup>(binary rules)</sup>mask_ranges< M, C1, D1, C2, D2, ..., E >
<sup>(binary rules)</sup>mask_string< M, C... >
<sup>(binary rules)</sup>math
<sup>(icu rules)</sup>minus< M, S >
<sup>(convenience)</sup>must< R... >
<sup>(convenience)</sup>nfc_inert
<sup>(icu rules)</sup>nfd_inert
<sup>(icu rules)</sup>nfkc_inert
<sup>(icu rules)</sup>nfkd_inert
<sup>(icu rules)</sup>noncharacter_code_point
<sup>(icu rules)</sup>not_at< R... >
<sup>(combinators)</sup>not_one< C... >
<sup>(ascii rules)</sup>not_one< C... >
<sup>(unicode rules)</sup>not_one< C... >
<sup>(binary rules)</sup>not_range< C, D >
<sup>(ascii rules)</sup>not_range< C, D >
<sup>(unicode rules)</sup>not_range< C, D >
<sup>(binary rules)</sup>nul
<sup>(ascii rules)</sup>numeric_type< V >
<sup>(icu rules)</sup>one< C... >
<sup>(ascii rules)</sup>one< C... >
<sup>(unicode rules)</sup>one< C... >
<sup>(binary rules)</sup>opt< R... >
<sup>(combinators)</sup>opt_must< R, S...>
<sup>(convenience)</sup>pad< R, S, T = S >
<sup>(convenience)</sup>pad_opt< R, P >
<sup>(convenience)</sup>pattern_syntax
<sup>(icu rules)</sup>pattern_white_space
<sup>(icu rules)</sup>plus< R... >
<sup>(combinators)</sup>posix_alnum
<sup>(icu rules)</sup>posix_blank
<sup>(icu rules)</sup>posix_graph
<sup>(icu rules)</sup>posix_print
<sup>(icu rules)</sup>posix_xdigit
<sup>(icu rules)</sup>print
<sup>(ascii rules)</sup>property_value< P, V >
<sup>(icu rules)</sup>quotation_mark
<sup>(icu rules)</sup>radical
<sup>(icu rules)</sup>raise< T >
<sup>(atomic rules)</sup>range< C, D >
<sup>(ascii rules)</sup>range< C, D >
<sup>(unicode rules)</sup>range< C, D >
<sup>(binary rules)</sup>ranges< C1, D1, C2, D2, ... >
<sup>(ascii rules)</sup>ranges< C1, D1, C2, D2, ... >
<sup>(unicode rules)</sup>ranges< C1, D1, C2, D2, ... >
<sup>(binary rules)</sup>ranges< C1, D1, C2, D2, ..., E >
<sup>(ascii rules)</sup>ranges< C1, D1, C2, D2, ..., E >
<sup>(unicode rules)</sup>ranges< C1, D1, C2, D2, ..., E >
<sup>(binary rules)</sup>rep< Num, R... >
<sup>(convenience)</sup>rep_max< Max, R... >
<sup>(convenience)</sup>rep_min< Min, R... >
<sup>(convenience)</sup>rep_min_max< Min, Max, R... >
<sup>(convenience)</sup>rep_opt< Num, R... >
<sup>(convenience)</sup>require< Num >
<sup>(meta-rules)</sup>s_term
<sup>(icu rules)</sup>segment_starter
<sup>(icu rules)</sup>sentence_break< V >
<sup>(icu rules)</sup>seq< R... >
<sup>(combinators)</sup>seven
<sup>(ascii rules)</sup>shebang
<sup>(ascii rules)</sup>soft_dotted
<sup>(icu rules)</sup>sor< R... >
<sup>(combinators)</sup>space
<sup>(ascii rules)</sup>star< R... >
<sup>(combinators)</sup>star_must< R, S... >
<sup>(convenience)</sup>state< S, R... >
<sup>(meta rules)</sup>string< C... >
<sup>(ascii rules)</sup>string< C... >
<sup>(unicode rules)</sup>string< C... >
<sup>(binary rules)</sup>success
<sup>(atomic rules)</sup>TAO_PEGTL_ISTRING( "..." )
<sup>(ascii rules)</sup>TAO_PEGTL_KEYWORD( "..." )
<sup>(ascii rules)</sup>TAO_PEGTL_STRING( "..." )
<sup>(ascii rules)</sup>terminal_punctuation
<sup>(icu rules)</sup>three< C >
<sup>(ascii rules)</sup>trail_canonical_combining_class< V >
<sup>(icu rules)</sup>try_catch< R... >
<sup>(convenience)</sup>try_catch_type< E, R... >
<sup>(convenience)</sup>two< C >
<sup>(ascii rules)</sup>unified_ideograph
<sup>(icu rules)</sup>until< R >
<sup>(convenience)</sup>until< R, S... >
<sup>(convenience)</sup>upper
<sup>(ascii rules)</sup>uppercase
<sup>(icu rules)</sup>variation_selector
<sup>(icu rules)</sup>white_space
<sup>(icu rules)</sup>word_break< V >
<sup>(icu rules)</sup>xdigit
<sup>(ascii rules)</sup>xid_continue
<sup>(icu rules)</sup>xid_start
<sup>(icu rules)</sup>Copyright (c) 2014-2018 Dr. Colin Hirsch and Daniel Frey