|
| template<typename Encoding , typename... Needle, typename... End> |
| LEXY_CONSTEVAL auto | _build_look_trie (_lset< Needle... >, _lset< End... >) |
| |
| template<typename Rule > |
| auto | _copy_base_impl () |
| |
| template<typename ProductionParser , typename Context , typename Reader > |
| constexpr bool | _finish_production (ProductionParser &parser, Context &context, Reader &reader) |
| |
| template<typename C , typename = std::enable_if_t<lexy::is_char_class_rule<C>>> |
| constexpr auto | _make_char_class (C c) |
| |
| template<template< typename > typename CaseFolding, typename CharT , CharT... C> |
| constexpr auto | _make_lit_rule (lexy::_detail::type_string< CharT, C... >) |
| |
| template<typename Handler > |
| constexpr auto | _make_pas_handler (_pas_handler< Handler > &handler) |
| |
| template<typename Handler > |
| constexpr auto | _make_pas_handler (Handler &handler) |
| |
| template<typename Base , typename Reader > |
| constexpr bool | _match_digits (Reader &reader) |
| |
| template<typename Base , typename Sep , typename Reader > |
| constexpr bool | _match_digits_sep (Reader &reader) |
| |
| template<typename Condition , typename Then > |
| constexpr auto | _maybe_branch (Condition condition, Then then) |
| |
| template<typename T , std::size_t N, int Radix> |
| constexpr bool | _ndigits_can_overflow () |
| |
| template<typename Production , typename Context , typename Reader > |
| constexpr bool | _parse_production (Context &context, Reader &reader) |
| |
| template<typename Condition , typename Reader > |
| constexpr void | _until_swar ([[maybe_unused]] Reader &reader) |
| |
| template<typename... Bits> |
| constexpr auto | bits (Bits...) |
| | Matches the specific bit pattern. More...
|
| |
| template<typename Open , typename Close > |
| constexpr auto | brackets (Open, Close) |
| | Defines open and close brackets. More...
|
| |
| template<typename Production > |
| constexpr auto | capture (_prd< Production >) |
| | Captures whatever the token production matches as lexeme; does not include trailing whitespace. More...
|
| |
| template<typename Token > |
| constexpr auto | capture (Token) |
| | Captures whatever the token matches as a lexeme; does not include trailing whitespace. More...
|
| |
| template<typename... R> |
| constexpr auto | combination (R...) |
| |
| template<typename Id , typename Leading , typename Trailing , typename... Reserved> |
| constexpr auto | context_identifier (_id< Leading, Trailing, Reserved... >) |
| | Declares a context variable that stores one instance of the given identifier. More...
|
| |
| template<typename Delim > |
| constexpr auto | delimited (Delim) |
| | Parses everything between a paired delimiter. More...
|
| |
| template<typename Open , typename Close > |
| constexpr auto | delimited (Open, Close) |
| | Parses everything between the two delimiters and captures it. More...
|
| |
| template<typename Then , typename Condition > |
| constexpr auto | do_while (Then then, Condition condition) |
| | Matches then once, then while_(condition >> then). More...
|
| |
| template<typename... Ids> |
| constexpr auto | equal_counts (_ctx_counter_dsl< Ids >...) |
| | Takes a branch only if all counters are equal. More...
|
| |
| template<typename EscapeToken > |
| constexpr auto | escape (EscapeToken) |
| |
| template<typename... Literals> |
| constexpr auto | find (Literals... literals) |
| | Recovers once it finds one of the given literal tokens (without consuming them). More...
|
| |
| template<typename Rule > |
| constexpr auto | flag (Rule rule) |
| |
| template<auto If, auto Else = LEXY_DECAY_DECLTYPE(If){}, typename Rule > |
| constexpr auto | flag (Rule) |
| |
| template<auto Default, const auto & Table, typename Token , typename Tag > |
| constexpr auto | flags (_sym< Table, Token, Tag > flag_rule) |
| |
| template<const auto & Table, typename Token , typename Tag > |
| constexpr auto | flags (_sym< Table, Token, Tag > flag_rule) |
| |
| template<typename Literal , typename CharClass > |
| constexpr auto | followed_by (Literal lit, CharClass cc) |
| | Match a literal but only if followed by the given char class. More...
|
| |
| template<typename CharClass > |
| constexpr auto | identifier (CharClass) |
| | Creates an identifier that consists of one or more of the given characters. More...
|
| |
| template<typename LeadingClass , typename TrailingClass > |
| constexpr auto | identifier (LeadingClass, TrailingClass) |
| |
| template<typename Branch > |
| constexpr auto | if_ (Branch) |
| | If the branch condition matches, matches the branch then. More...
|
| |
| template<typename Branch > |
| constexpr auto | ignore_trailing_sep (Branch) |
| | Defines a separator for a list that ignores the existence of trailing separators. More...
|
| |
| template<auto C, typename L , typename T , typename... R> |
| constexpr auto | keyword (_id< L, T, R... >) |
| |
| | LEXY_PUNCT (ampersand, "&") |
| |
| | LEXY_PUNCT (apostrophe, "'") |
| |
| | LEXY_PUNCT (asterisk, "*") |
| |
| | LEXY_PUNCT (at_sign, "@") |
| |
| | LEXY_PUNCT (backslash, "\\") |
| |
| | LEXY_PUNCT (caret, "^") |
| |
| | LEXY_PUNCT (colon, ":") |
| |
| | LEXY_PUNCT (comma, ",") |
| |
| | LEXY_PUNCT (dollar_sign, "$") |
| |
| | LEXY_PUNCT (double_colon, "::") |
| |
| | LEXY_PUNCT (equal_sign, "=") |
| |
| | LEXY_PUNCT (exclamation_mark, "!") |
| |
| | LEXY_PUNCT (hash_sign, "#") |
| |
| | LEXY_PUNCT (hyphen, "-") |
| |
| | LEXY_PUNCT (percent_sign, "%") |
| |
| | LEXY_PUNCT (period, ".") |
| |
| | LEXY_PUNCT (question_mark, "?") |
| |
| | LEXY_PUNCT (semicolon, ";") |
| |
| | LEXY_PUNCT (slash, "/") |
| |
| | LEXY_PUNCT (tilde, "~") |
| |
| | LEXY_PUNCT (vbar, "|") |
| |
| template<typename Item > |
| constexpr auto | list (Item) |
| | Parses a list of items without a separator. More...
|
| |
| template<typename Item , typename Sep > |
| constexpr auto | list (Item, _isep< Sep >) |
| |
| template<typename Item , typename Sep , typename Tag > |
| constexpr auto | list (Item, _sep< Sep, Tag >) |
| | Parses a list of items with the specified separator. More...
|
| |
| template<typename Item , typename Sep > |
| constexpr auto | list (Item, _tsep< Sep >) |
| | Parses a list of items with the specified separator that can be trailing. More...
|
| |
| template<typename T , template< typename > typename CaseFolding, typename... Strings> |
| constexpr auto | literal_set (const lexy::_symbol_table< T, CaseFolding, Strings... >) |
| | Matches one of the symbols in the symbol table. More...
|
| |
| template<typename... Literals> |
| constexpr auto | literal_set (Literals...) |
| | Matches one of the specified literals. More...
|
| |
| template<typename Needle , typename End > |
| constexpr auto | lookahead (Needle _needle, End _end) |
| |
| template<typename Rule > |
| constexpr auto | loop (Rule) |
| | Repeatedly matches the rule until a break rule matches. More...
|
| |
| template<typename Branch > |
| constexpr auto | must (Branch) |
| |
| template<typename Rule > |
| constexpr auto | no_whitespace (Rule) |
| | Disables automatic skipping of whitespace for all tokens of the given rule. More...
|
| |
| template<typename Literal , typename CharClass > |
| constexpr auto | not_followed_by (Literal, CharClass cc) |
| | Match a literal but only if not followed by the given char class. More...
|
| |
| template<typename Literal , typename... R> |
| constexpr auto | op (_br< Literal, R... >) |
| |
| template<typename Tag , typename Literal , typename... R> |
| constexpr auto | op (_br< Literal, R... >) |
| |
| template<typename Literal > |
| constexpr auto | op (Literal) |
| |
| template<typename Tag , typename Literal > |
| constexpr auto | op (Literal) |
| |
| template<typename... Cs, typename... Ds> |
| constexpr auto | operator& (_cand< Cs... >, _cand< Ds... >) -> _cand< Cs..., Ds... > |
| |
| template<typename... Cs, typename C > |
| constexpr auto | operator& (_cand< Cs... >, C c) -> _cand< Cs..., decltype(_make_char_class(c))> |
| |
| template<typename C , typename... Cs> |
| constexpr auto | operator& (C c, _cand< Cs... >) -> _cand< decltype(_make_char_class(c)), Cs... > |
| |
| template<typename C1 , typename C2 > |
| constexpr auto | operator& (C1 c1, C2 c2) -> _cand< decltype(_make_char_class(c1)), decltype(_make_char_class(c2))> |
| |
| template<typename C1 , typename... R, typename C2 , typename... S> |
| constexpr auto | operator+ (_br< C1, R... >, _br< C2, S... >) |
| |
| template<typename Condition , typename... R, typename... S> |
| constexpr auto | operator+ (_br< Condition, R... >, _seq< S... >) |
| |
| template<typename Condition , typename... R, typename Rule > |
| constexpr auto | operator+ (_br< Condition, R... >, Rule) |
| |
| template<typename... R, typename Condition , typename... S> |
| constexpr auto | operator+ (_seq< R... >, _br< Condition, S... >) |
| |
| template<typename... R, typename... S> |
| constexpr auto | operator+ (_seq< R... >, _seq< S... >) |
| |
| template<typename... R, typename S > |
| constexpr auto | operator+ (_seq< R... >, S) |
| |
| template<typename R , typename... S> |
| constexpr auto | operator+ (R, _seq< S... >) |
| |
| template<typename R , typename S , typename = std::enable_if_t<lexy::is_rule<R> && lexy::is_rule<S>>> |
| constexpr auto | operator+ (R, S) |
| |
| template<typename Rule , typename Condition , typename... R> |
| constexpr auto | operator+ (Rule rule, _br< Condition, R... >) |
| |
| template<typename C > |
| constexpr auto | operator- (_ccomp< C >) -> C |
| |
| template<typename Set , typename Minus , typename OtherMinus > |
| constexpr auto | operator- (_cminus< Set, Minus >, OtherMinus other) |
| |
| template<typename C > |
| constexpr auto | operator- (C c) -> _ccomp< decltype(_make_char_class(c))> |
| |
| template<typename Set , typename Minus > |
| constexpr auto | operator- (Set, Minus minus) |
| |
| template<typename... Cs, typename... Ds> |
| constexpr auto | operator/ (_calt< Cs... >, _calt< Ds... >) -> _calt< Cs..., Ds... > |
| |
| template<typename... Cs, typename C > |
| constexpr auto | operator/ (_calt< Cs... >, C c) -> _calt< Cs..., decltype(_make_char_class(c))> |
| |
| template<typename T1 , typename L1 , typename... R1, typename T2 , typename L2 , typename... R2> |
| constexpr auto | operator/ (_op< T1, L1, R1... > lhs, _op< T2, L2, R2... > rhs) |
| |
| template<typename T1 , typename L1 , typename... R1, typename... Ops> |
| constexpr auto | operator/ (_op< T1, L1, R1... > lhs, _opc< Ops... >) |
| |
| template<typename... O1, typename... O2> |
| constexpr auto | operator/ (_opc< O1... >, _opc< O2... >) |
| |
| template<typename... Ops, typename T2 , typename L2 , typename... R2> |
| constexpr auto | operator/ (_opc< Ops... >, _op< T2, L2, R2... > rhs) |
| |
| template<typename C , typename... Cs> |
| constexpr auto | operator/ (C c, _calt< Cs... >) -> _calt< decltype(_make_char_class(c)), Cs... > |
| |
| template<typename R1 , typename R2 > |
| constexpr auto | operator/ (R1 r1, R2 r2) -> _calt< decltype(_make_char_class(r1)), decltype(_make_char_class(r2))> |
| |
| template<typename C , typename... R, typename... S> |
| constexpr auto | operator>> (_br< C, R... >, _seq< S... >) |
| |
| template<typename C , typename... R, typename Then > |
| constexpr auto | operator>> (_br< C, R... >, Then) |
| |
| template<typename C1 , typename... R, typename C2 , typename... S> |
| constexpr auto | operator>> (_br< C1, R... >, _br< C2, S... >) |
| |
| template<typename Condition , typename C , typename... R> |
| constexpr auto | operator>> (Condition, _br< C, R... >) |
| |
| template<typename Condition , typename... R> |
| constexpr auto | operator>> (Condition, _seq< R... >) |
| |
| template<typename Condition , typename Then > |
| constexpr auto | operator>> (Condition, Then) |
| | Parses Then only after Condition has matched. More...
|
| |
| template<typename... R, typename... S> |
| constexpr auto | operator| (_chc< R... >, _chc< S... >) |
| |
| template<typename... R, typename S > |
| constexpr auto | operator| (_chc< R... >, S) |
| |
| template<typename R , typename... S> |
| constexpr auto | operator| (R, _chc< S... >) |
| |
| template<typename R , typename S > |
| constexpr auto | operator| (R, S) |
| |
| template<typename Rule > |
| constexpr auto | opt (Rule) |
| |
| template<typename T , typename Rule > |
| constexpr auto | parse_as (Rule) |
| |
| template<typename... R> |
| constexpr auto | partial_combination (R...) |
| |
| template<typename Rule > |
| constexpr auto | peek (Rule) |
| |
| template<typename Rule > |
| constexpr auto | peek_not (Rule) |
| | Checks if at this reader position, the rule would not match. More...
|
| |
| template<typename... Branches> |
| constexpr auto | recover (Branches...) |
| | Discards input until one of the branches matches to recover from an error. More...
|
| |
| template<typename Count > |
| constexpr auto | repeat (Count) |
| | Parses a rule n times, where n is the value produced by Count. More...
|
| |
| template<typename Branch > |
| constexpr auto | sep (Branch) |
| | Defines a separator for a list. More...
|
| |
| template<typename Branch > |
| constexpr auto | terminator (Branch) |
| | Creates a terminator using the given branch. More...
|
| |
| template<std::size_t N, typename Rule > |
| constexpr auto | times (Rule) |
| | Repeats the rule N times in sequence. More...
|
| |
| template<std::size_t N, typename Rule , typename Sep > |
| constexpr auto | times (Rule, Sep) |
| | Repeates the rule N times in sequence separated by a separator. More...
|
| |
| template<typename Rule > |
| constexpr auto | token (Rule) |
| | Turns the arbitrary rule into a token by matching it without producing any values. More...
|
| |
| template<typename Branch > |
| constexpr auto | trailing_sep (Branch) |
| | Defines a separator for a list that can be trailing. More...
|
| |
| template<typename Rule > |
| constexpr auto | try_ (Rule) |
| | Parses Rule, if that fails, continues immediately. More...
|
| |
| template<typename Rule , typename Recover > |
| constexpr auto | try_ (Rule, Recover) |
| | Parses Rule, if that fails, parses recovery rule. More...
|
| |
| template<typename Rule > |
| constexpr auto | twice (Rule rule) |
| |
| template<typename Rule , typename Sep > |
| constexpr auto | twice (Rule rule, Sep sep) |
| |
| template<typename Condition > |
| constexpr auto | until (Condition) |
| |
| template<typename Rule > |
| constexpr auto | while_ (Rule) |
| | Matches the branch rule as often as possible. More...
|
| |
| template<typename Rule > |
| constexpr auto | while_one (Rule rule) |
| | Matches the rule at least once, then as often as possible. More...
|
| |
| template<typename Rule > |
| constexpr auto | whitespace (Rule) |
| |
|
| template<typename CharSet > |
| constexpr auto | _cas = lexy::_detail::compress_ascii_set<CharSet>() |
| |
| template<typename T > |
| constexpr bool | _is_bounded = lexy::integer_traits<T>::is_bounded |
| |
| template<typename Encoding , typename Needle , typename End > |
| static constexpr auto | _look_trie = _build_look_trie<Encoding>(typename Needle::as_lset{}, typename End::as_lset{}) |
| |
| constexpr auto | angle_bracketed = brackets(lit_c<'<'>, lit_c<'>'>) |
| |
| constexpr auto | any = _any{} |
| | Matches anything and consumes all remaining characters. More...
|
| |
| constexpr auto | argv_separator = _argvsep{} |
| | Matches the separator between arguments of an argv_input. More...
|
| |
| constexpr auto | backslash_escape = escape(lit_c<'\\'>) |
| |
| constexpr auto | backticked = delimited(LEXY_LIT("`")) |
| |
| constexpr auto | big_bint16 = _bint<2, lexy::_detail::bint_big>{} |
| |
| constexpr auto | big_bint32 = _bint<4, lexy::_detail::bint_big>{} |
| |
| constexpr auto | big_bint64 = _bint<8, lexy::_detail::bint_big>{} |
| |
| constexpr auto | bint16 = _bint<2, lexy::_detail::bint_native>{} |
| | Matches two bytes and converts it into an 16-bit integer. More...
|
| |
| constexpr auto | bint32 = _bint<4, lexy::_detail::bint_native>{} |
| | Matches four bytes and converts it into an 32-bit integer. More...
|
| |
| constexpr auto | bint64 = _bint<8, lexy::_detail::bint_native>{} |
| | Matches eight bytes and converts it into an 64-bit integer. More...
|
| |
| constexpr auto | bint8 = _bint<1, lexy::_detail::bint_native>{} |
| | Matches one byte and converts it into an 8-bit integer. More...
|
| |
| template<typename Encoding , lexy::encoding_endianness Endianness> |
| constexpr auto | bom = _bom<Encoding, Endianness>{} |
| | The BOM for that particular encoding. More...
|
| |
| constexpr auto | break_ = _break{} |
| | Exits a loop(). More...
|
| |
| constexpr auto | byte = _b<1, void>{} |
| | Matches an arbitrary byte. More...
|
| |
| template<std::size_t N> |
| constexpr auto | bytes = _b<N, void>{} |
| | Matches N arbitrary bytes. More...
|
| |
| constexpr auto | code_point = _cp<void>{} |
| | Matches a single unicode code point in the current unicode encoding. More...
|
| |
| template<std::size_t N, typename Base = hex> |
| constexpr auto | code_point_id |
| | Matches the integer value of a code point. More...
|
| |
| template<typename Encoding , std::size_t N, typename Base = hex> |
| constexpr auto | code_unit_id |
| | Matches the integer value of a code unit. More...
|
| |
| template<typename Id > |
| constexpr auto | context_counter = _ctx_counter_dsl<Id>{} |
| | Declares an integer counter that is added to the parsing context. More...
|
| |
| template<typename Id > |
| constexpr auto | context_flag = _ctx_flag_dsl<Id>{} |
| | Declares a flag. More...
|
| |
| constexpr auto | curly_bracketed = brackets(lit_c<'{'>, lit_c<'}'>) |
| |
| template<typename Base = decimal, int = Base::digit_radix> |
| constexpr auto | digit = Base{} |
| | Matches a single digit. More...
|
| |
| constexpr auto | digit_sep_tick = LEXY_LIT("'") |
| |
| constexpr auto | digit_sep_underscore = LEXY_LIT("_") |
| |
| template<typename Base = decimal> |
| constexpr auto | digits = _digits<Base>{} |
| | Matches a non-empty list of digits. More...
|
| |
| constexpr auto | dollar_escape = escape(lit_c<'$'>) |
| |
| constexpr auto | double_backticked = delimited(LEXY_LIT("``")) |
| |
| template<LEXY_NTTP_PARAM Fn> |
| constexpr auto | effect = _eff<Fn>{} |
| | Invokes Fn and produces its value as result. More...
|
| |
| constexpr auto | else_ = _else_dsl{} |
| | Takes the branch unconditionally. More...
|
| |
| constexpr auto | eof = _eof{} |
| | Matches EOF. More...
|
| |
| constexpr auto | eol = _eol{} |
| | Matches the end of line (EOF or newline). More...
|
| |
| template<typename Tag > |
| constexpr auto | error = _err<Tag, void>{} |
| | Matches nothing, produces an error with the given tag. More...
|
| |
| template<typename Production > |
| constexpr auto | inline_ = lexy::production_rule<Production>{} |
| | Parses the rule of the production as if it were part of the current production. More...
|
| |
| template<typename T , typename Base = void> |
| constexpr auto | integer = _int_dsl<T, Base>{} |
| | Parses the digits matched by the rule into an integer type. More...
|
| |
| template<unsigned char... C> |
| constexpr auto | lit_b = _lit<unsigned char, C...>{} |
| |
| template<auto C> |
| constexpr auto | lit_c = _lit<LEXY_DECAY_DECLTYPE(C), C>{} |
| |
| template<char32_t... CodePoint> |
| constexpr auto | lit_cp = _lcp<CodePoint...>{} |
| |
| constexpr auto | little_bint16 = _bint<2, lexy::_detail::bint_little>{} |
| |
| constexpr auto | little_bint32 = _bint<4, lexy::_detail::bint_little>{} |
| |
| constexpr auto | little_bint64 = _bint<8, lexy::_detail::bint_little>{} |
| |
| lexyd::_rep | Loop |
| |
| template<auto MemPtr> |
| constexpr auto | member = _mem_dsl<lexy::_mem_ptr_fn<MemPtr>>{} |
| |
| constexpr auto | minus_sign = if_(_minus{}) |
| | Matches a minus sign or nothing, producing +1 or -1. More...
|
| |
| template<std::size_t N, typename Base = decimal> |
| constexpr auto | n_digits = _ndigits<N, Base>{} |
| | Matches exactly N digits. More...
|
| |
| constexpr auto | newline = _nl{} |
| | Matches a newline character. More...
|
| |
| constexpr auto | nullopt = _nullopt{} |
| |
| template<typename Production > |
| constexpr auto | p = _prd<Production>{} |
| | Parses the production. More...
|
| |
| template<std::size_t N, unsigned char Padding = 0> |
| constexpr auto | padding_bytes = _pb<N, Padding>{} |
| |
| constexpr auto | parenthesized = round_bracketed |
| |
| constexpr auto | plus_sign = if_(_plus{}) |
| | Matches a plus sign or nothing, producing +1. More...
|
| |
| template<typename Production > |
| constexpr auto | pnode = _pn<Production>{} |
| |
| constexpr auto | position = _pos_dsl{} |
| | Produces an iterator to the current reader position without parsing anything. More...
|
| |
| constexpr auto | quoted = delimited(LEXY_LIT("\"")) |
| |
| template<typename Production > |
| constexpr auto | recurse = _rec<Production>{} |
| |
| template<typename Production > |
| constexpr auto | recurse_branch = _recb<Production>{} |
| |
| constexpr auto | return_ = _ret{} |
| | Finishes parsing a production without considering subsequent rules. More...
|
| |
| constexpr auto | round_bracketed = brackets(lit_c<'('>, lit_c<')'>) |
| |
| constexpr auto | scan = _scan{} |
| |
| constexpr auto | sign = if_(_plus{} | _minus{}) |
| | Matches a plus or minus sign or nothing, producing +1 or -1. More...
|
| |
| constexpr auto | single_quoted = delimited(LEXY_LIT("'")) |
| |
| constexpr auto | square_bracketed = brackets(lit_c<'['>, lit_c<']'>) |
| |
| template<typename Production , typename T > |
| constexpr auto | subgrammar = _subg<Production, T>{} |
| |
| template<const auto & Table> |
| constexpr auto | symbol = _sym_dsl<Table>{} |
| | Parses optional rule, then matches the resulting lexeme against the symbol table. More...
|
| |
| template<auto Kind> |
| constexpr auto | tnode = _tn<Kind>{} |
| |
| constexpr auto | triple_backticked = delimited(LEXY_LIT("```")) |
| |
| constexpr auto | triple_quoted = delimited(LEXY_LIT("\"\"\"")) |
| |
| constexpr auto | zero = _zero{} |
| | Matches the zero digit. More...
|
| |