Namespaces
	ascii

	bit

	unicode

Classes
struct	_any

struct	_argvsep

struct	_b

struct	_bint

struct	_bits

struct	_bom

struct	_bom< lexy::utf16_encoding, lexy::encoding_endianness::big >

struct	_bom< lexy::utf16_encoding, lexy::encoding_endianness::little >

struct	_bom< lexy::utf32_encoding, lexy::encoding_endianness::big >

struct	_bom< lexy::utf32_encoding, lexy::encoding_endianness::little >

struct	_bom< lexy::utf8_char_encoding, DontCare >

struct	_bom< lexy::utf8_encoding, DontCare >

struct	_bounded_integer_parser

struct	_br

struct	_brackets

struct	_break

struct	_calt

struct	_cand

struct	_cap

struct	_capr

struct	_capt

struct	_cb

struct	_ccomp

struct	_ccp

struct	_cfl

struct	_cfl_folding

struct	_char_class_base

struct	_chc

struct	_cminus

struct	_comb

struct	_comb_control

struct	_comb_it

struct	_cp

struct	_ctx_cadd

struct	_ctx_ccreate

struct	_ctx_ceq

struct	_ctx_ceq< H, T... >

struct	_ctx_cis

struct	_ctx_counter_dsl

struct	_ctx_cpush

struct	_ctx_cvalue

struct	_ctx_fcreate

struct	_ctx_fis

struct	_ctx_flag_dsl

struct	_ctx_fset

struct	_ctx_ftoggle

struct	_ctx_fvalue

struct	_ctx_icap

struct	_ctx_icreate

struct	_ctx_id_dsl

struct	_ctx_irem

struct	_d

struct	_d< 10 >

struct	_d< 16 >

struct	_d< 2 >

struct	_d< 8 >

struct	_debug

struct	_del

struct	_del_chars

struct	_del_limit

struct	_del_limit< void, Error >

struct	_delim_dsl

struct	_digits

struct	_digits_s

struct	_digits_st

struct	_digits_t

struct	_eff

struct	_else

struct	_else_dsl

struct	_eof

struct	_eol

struct	_err

struct	_escape

struct	_escape_base

struct	_expr

struct	_find

struct	_flag

struct	_flags

struct	_id

struct	_idcp

struct	_idp

struct	_idpp

struct	_idrp

struct	_idsp

struct	_if

struct	_int

struct	_int_dsl

struct	_integer_parser_digits

struct	_integer_parser_digits< T, _digits< Base > >

struct	_integer_parser_digits< T, _digits_s< Base, Sep > >

struct	_integer_parser_digits< T, _digits_st< Base, Sep > >

struct	_integer_parser_digits< T, _digits_t< Base > >

struct	_integer_parser_digits< T, _ndigits< N, Base > >

struct	_integer_parser_digits< T, _ndigits_s< N, Base, Sep > >

struct	_isep

struct	_keyword

struct	_keyword< _id< L, T, R... > >

struct	_kw

struct	_lcp

struct	_lit

struct	_lit_base

struct	_look

struct	_loop

struct	_lset

struct	_lset_base

struct	_lst

struct	_lstt

struct	_mem

struct	_mem_dsl

struct	_minus

struct	_must

struct	_must_dsl

struct	_ndigits

struct	_ndigits_s

struct	_nf

struct	_nl

struct	_nsep

struct	_nullopt

struct	_olstt

struct	_op

struct	_opc

struct	_operation_base

struct	_opt

struct	_optt

struct	_pas

struct	_pas_handler

struct	_pb

struct	_peek

struct	_peekn

struct	_plus

struct	_pos

struct	_pos_dsl

struct	_posr

struct	_prd

struct	_rec

struct	_recb

struct	_reco

struct	_recovery_base

struct	_recovery_wrapper

struct	_rep

struct	_rep_dsl

struct	_rep_impl

struct	_rep_impl< Item, void >

struct	_repc

struct	_repd

struct	_repl

struct	_ret

struct	_scan

struct	_sep

struct	_sep_base

struct	_seq

struct	_seq_impl

struct	_seq_impl< R1 >

struct	_seq_impl< R1, R2 >

struct	_seq_impl< R1, R2, R3 >

struct	_seq_impl< R1, R2, R3, R4 >

struct	_seq_impl< R1, R2, R3, R4, R5 >

struct	_seq_impl< R1, R2, R3, R4, R5, R6 >

struct	_seq_impl< R1, R2, R3, R4, R5, R6, R7 >

struct	_seq_impl< R1, R2, R3, R4, R5, R6, R7, T... >

struct	_seq_impl<>

struct	_subg

struct	_sym

struct	_sym< Table, _idp< L, T >, Tag >

struct	_sym< Table, void, Tag >

struct	_sym_dsl

struct	_term

struct	_times

struct	_toke

struct	_token

struct	_token_base

struct	_token_inherit

struct	_token_inherit< Impl, true >

struct	_token_inherit< Tag, false >

struct	_tokk

struct	_tryr

struct	_tryt

struct	_tsep

struct	_unbounded_integer_parser

struct	_until

struct	_until_eof

struct	_whl

struct	_wsn

struct	_wsr

struct	_zero

struct	atom
	Operation that just parses the atomic rule. More...

struct	branch_base

struct	char_class_base

struct	groups
	Operation that selects between multiple ones. More...

struct	hex_lower

struct	hex_upper

struct	infix_op_left

struct	infix_op_list

struct	infix_op_right

struct	infix_op_single

struct	postfix_op

struct	prefix_op

struct	rule_base

struct	token_base

struct	unconditional_branch_base

Typedefs
template<typename Rule >
using	_copy_base = decltype(_copy_base_impl< Rule >())

template<typename Id >
using	_ctx_counter = lexy::_detail::parse_context_var< Id, int >

template<typename Id >
using	_ctx_flag = lexy::_detail::parse_context_var< Id, bool >

template<typename Id , typename Reader >
using	_ctx_id = lexy::_detail::parse_context_var< Id, lexy::lexeme< Reader > >

template<typename EffRule , typename State >
using	_detect_eff_fn = decltype(EffRule::_fn()(LEXY_DECLVAL(State &)))

template<typename Tag , typename Reader >
using	_detect_op_tag_ctor = decltype(Tag(LEXY_DECLVAL(Reader).position()))

template<typename Context , typename Scanner , typename StatePtr >
using	_detect_scan_state = decltype(Context::production::scan(LEXY_DECLVAL(Scanner &), *StatePtr()))

template<typename T , typename Base , bool AssumeOnlyDigits>
using	_integer_parser = std::conditional_t< _is_bounded< T >, _bounded_integer_parser< T, Base, AssumeOnlyDigits >, _unbounded_integer_parser< T, Base > >

template<typename T , typename Digits >
using	_integer_parser_for = typename _integer_parser_digits< T, Digits >::type

using	binary = _d< 2 >

using	decimal = _d< 10 >

using	hex = _d< 16 >

using	octal = _d< 8 >

Functions
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 T , typename CurProduction , typename U , typename P , typename Handler >
constexpr auto	_make_pas_handler (_pas_handler< U, P, Handler > &handler)

template<typename T , typename CurProduction , 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<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)

Variables
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>{}
	Matches an arbitrary byte. More...

template<std::size_t N>
constexpr auto	bytes = _b<N>{}
	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...

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...

constexpr auto	triple_backticked = delimited(LEXY_LIT("```"))

constexpr auto	triple_quoted = delimited(LEXY_LIT("\"\"\""))

constexpr auto	zero = _zero{}
	Matches the zero digit. More...

Typedef Documentation

◆ _copy_base

template<typename Rule >

using lexyd::_copy_base = typedef decltype(_copy_base_impl<Rule>())

Definition at line 91 of file dsl/base.hpp.

◆ _ctx_counter

template<typename Id >

using lexyd::_ctx_counter = typedef lexy::_detail::parse_context_var<Id, int>

Definition at line 26 of file context_counter.hpp.

◆ _ctx_flag

template<typename Id >

using lexyd::_ctx_flag = typedef lexy::_detail::parse_context_var<Id, bool>

Definition at line 13 of file context_flag.hpp.

◆ _ctx_id

template<typename Id , typename Reader >

using lexyd::_ctx_id = typedef lexy::_detail::parse_context_var<Id, lexy::lexeme<Reader> >

Definition at line 25 of file context_identifier.hpp.

◆ _detect_eff_fn

template<typename EffRule , typename State >

using lexyd::_detect_eff_fn = typedef decltype(EffRule::_fn()(LEXY_DECLVAL(State&)))

Definition at line 13 of file effect.hpp.

◆ _detect_op_tag_ctor

template<typename Tag , typename Reader >

using lexyd::_detect_op_tag_ctor = typedef decltype(Tag(LEXY_DECLVAL(Reader).position()))

Definition at line 97 of file operator.hpp.

◆ _detect_scan_state

template<typename Context , typename Scanner , typename StatePtr >

using lexyd::_detect_scan_state = typedef decltype(Context::production::scan(LEXY_DECLVAL(Scanner&), *StatePtr()))

Definition at line 450 of file dsl/scan.hpp.

◆ _integer_parser

template<typename T , typename Base , bool AssumeOnlyDigits>

using lexyd::_integer_parser = typedef std::conditional_t<_is_bounded<T>, _bounded_integer_parser<T, Base, AssumeOnlyDigits>, _unbounded_integer_parser<T, Base> >

Definition at line 347 of file dsl/integer.hpp.

◆ _integer_parser_for

template<typename T , typename Digits >

using lexyd::_integer_parser_for = typedef typename _integer_parser_digits<T, Digits>::type

Definition at line 387 of file dsl/integer.hpp.

◆ binary

using lexyd::binary = typedef _d<2>

Definition at line 54 of file digit.hpp.

◆ decimal

using lexyd::decimal = typedef _d<10>

Definition at line 124 of file digit.hpp.

◆ hex

using lexyd::hex = typedef _d<16>

Definition at line 237 of file digit.hpp.

◆ octal

using lexyd::octal = typedef _d<8>

Definition at line 89 of file digit.hpp.

Function Documentation

◆ _build_look_trie()

template<typename Encoding , typename... Needle, typename... End>

LEXY_CONSTEVAL auto lexyd::_build_look_trie	(	_lset< Needle... >	,
		_lset< End... >
	)

Definition at line 26 of file lookahead.hpp.

◆ _copy_base_impl()

template<typename Rule >

auto lexyd::_copy_base_impl ( )

Definition at line 81 of file dsl/base.hpp.

◆ _finish_production()

template<typename ProductionParser , typename Context , typename Reader >

constexpr bool lexyd::_finish_production	(	ProductionParser &	parser,
		Context &	context,
		Reader &	reader
	)

constexpr

Definition at line 28 of file production.hpp.

◆ _make_char_class()

template<typename C , typename = std::enable_if_t<lexy::is_char_class_rule<C>>>

constexpr auto lexyd::_make_char_class ( C c )

constexpr

Definition at line 359 of file char_class.hpp.

◆ _make_lit_rule()

template<template< typename > typename CaseFolding, typename CharT , CharT... C>

constexpr auto lexyd::_make_lit_rule ( lexy::_detail::type_string< CharT, C... > )

constexpr

Definition at line 507 of file literal.hpp.

◆ _make_pas_handler() [1/2]

template<typename T , typename CurProduction , typename U , typename P , typename Handler >

constexpr auto lexyd::_make_pas_handler ( _pas_handler< U, P, Handler > & handler )

constexpr

Definition at line 51 of file parse_as.hpp.

◆ _make_pas_handler() [2/2]

template<typename T , typename CurProduction , typename Handler >

constexpr auto lexyd::_make_pas_handler ( Handler & handler )

constexpr

Definition at line 45 of file parse_as.hpp.

◆ _match_digits()

template<typename Base , typename Reader >

constexpr bool lexyd::_match_digits ( Reader & reader )

constexpr

Definition at line 294 of file digit.hpp.

◆ _match_digits_sep()

template<typename Base , typename Sep , typename Reader >

constexpr bool lexyd::_match_digits_sep ( Reader & reader )

constexpr

Definition at line 318 of file digit.hpp.

◆ _maybe_branch()

template<typename Condition , typename Then >

constexpr auto lexyd::_maybe_branch	(	Condition	condition,
		Then	then
	)

constexpr

Definition at line 104 of file branch.hpp.

◆ _ndigits_can_overflow()

template<typename T , std::size_t N, int Radix>

constexpr bool lexyd::_ndigits_can_overflow ( )

constexpr

Definition at line 228 of file dsl/integer.hpp.

◆ _parse_production()

template<typename Production , typename Context , typename Reader >

constexpr bool lexyd::_parse_production	(	Context &	context,
		Reader &	reader
	)

constexpr

Definition at line 22 of file production.hpp.

◆ _until_swar()

template<typename Condition , typename Reader >

constexpr void lexyd::_until_swar ( [[maybe_unused] ] Reader & reader )

constexpr

Definition at line 16 of file until.hpp.

◆ bits()

template<typename... Bits>

constexpr auto lexyd::bits ( Bits... )

constexpr

Matches the specific bit pattern.

Definition at line 136 of file bits.hpp.

◆ brackets()

template<typename Open , typename Close >

constexpr auto lexyd::brackets	(	Open	,
		Close
	)

constexpr

Defines open and close brackets.

Definition at line 101 of file brackets.hpp.

◆ capture() [1/2]

template<typename Production >

constexpr auto lexyd::capture ( _prd< Production > )

constexpr

Captures whatever the token production matches as lexeme; does not include trailing whitespace.

Definition at line 135 of file capture.hpp.

◆ capture() [2/2]

template<typename Token >

constexpr auto lexyd::capture ( Token )

constexpr

Captures whatever the token matches as a lexeme; does not include trailing whitespace.

Definition at line 127 of file capture.hpp.

◆ combination()

template<typename... R>

constexpr auto lexyd::combination ( R... )

constexpr

Matches each of the rules in an arbitrary order. Only matches each rule exactly once.

Definition at line 131 of file combination.hpp.

◆ context_identifier()

template<typename Id , typename Leading , typename Trailing , typename... Reserved>

constexpr auto lexyd::context_identifier ( _id< Leading, Trailing, Reserved... > )

constexpr

Declares a context variable that stores one instance of the given identifier.

Definition at line 170 of file context_identifier.hpp.

◆ delimited() [1/2]

template<typename Delim >

constexpr auto lexyd::delimited ( Delim )

constexpr

Parses everything between a paired delimiter.

Definition at line 334 of file delimited.hpp.

◆ delimited() [2/2]

template<typename Open , typename Close >

constexpr auto lexyd::delimited	(	Open	,
		Close
	)

constexpr

Parses everything between the two delimiters and captures it.

Definition at line 326 of file delimited.hpp.

◆ do_while()

template<typename Then , typename Condition >

constexpr auto lexyd::do_while	(	Then	then,
		Condition	condition
	)

constexpr

Matches then once, then while_(condition >> then).

Definition at line 117 of file loop.hpp.

◆ equal_counts()

template<typename... Ids>

constexpr auto lexyd::equal_counts ( _ctx_counter_dsl< Ids > ... )

constexpr

Takes a branch only if all counters are equal.

Definition at line 260 of file context_counter.hpp.

◆ escape()

template<typename EscapeToken >

constexpr auto lexyd::escape ( EscapeToken )

constexpr

Creates an escape rule. The token is the initial rule to begin, and then you can add rules that match after it.

Definition at line 456 of file delimited.hpp.

◆ find()

template<typename... Literals>

constexpr auto lexyd::find ( Literals... literals )

constexpr

Recovers once it finds one of the given literal tokens (without consuming them).

Definition at line 124 of file recover.hpp.

◆ flag()

template<auto If, auto Else = LEXY_DECAY_DECLTYPE(If){}, typename Rule >

constexpr auto lexyd::flag ( Rule )

constexpr

Definition at line 127 of file flags.hpp.

◆ flags() [1/2]

template<auto Default, const auto & Table, typename Token , typename Tag >

constexpr auto lexyd::flags ( _sym< Table, Token, Tag > flag_rule )

constexpr

Definition at line 83 of file flags.hpp.

◆ flags() [2/2]

template<const auto & Table, typename Token , typename Tag >

constexpr auto lexyd::flags ( _sym< Table, Token, Tag > flag_rule )

constexpr

Definition at line 93 of file flags.hpp.

◆ followed_by()

template<typename Literal , typename CharClass >

constexpr auto lexyd::followed_by	(	Literal	lit,
		CharClass	cc
	)

constexpr

Match a literal but only if followed by the given char class.

Definition at line 108 of file follow.hpp.

◆ identifier() [1/2]

template<typename CharClass >

constexpr auto lexyd::identifier ( CharClass )

constexpr

Creates an identifier that consists of one or more of the given characters.

Definition at line 287 of file identifier.hpp.

◆ identifier() [2/2]

template<typename LeadingClass , typename TrailingClass >

constexpr auto lexyd::identifier	(	LeadingClass	,
		TrailingClass
	)

constexpr

Creates an identifier that consists of one leading token followed by zero or more trailing tokens.

Definition at line 296 of file identifier.hpp.

◆ if_()

template<typename Branch >

constexpr auto lexyd::if_ ( Branch )

constexpr

If the branch condition matches, matches the branch then.

Definition at line 37 of file if.hpp.

◆ ignore_trailing_sep()

template<typename Branch >

constexpr auto lexyd::ignore_trailing_sep ( Branch )

constexpr

Defines a separator for a list that ignores the existence of trailing separators.

Definition at line 131 of file separator.hpp.

◆ keyword()

template<auto C, typename L , typename T , typename... R>

constexpr auto lexyd::keyword ( _id< L, T, R... > )

constexpr

Definition at line 394 of file identifier.hpp.

◆ LEXY_PUNCT() [1/21]

lexyd::LEXY_PUNCT	(	ampersand	,
		"&"
	)

◆ LEXY_PUNCT() [2/21]

lexyd::LEXY_PUNCT	(	apostrophe	,
		"'"
	)

◆ LEXY_PUNCT() [3/21]

lexyd::LEXY_PUNCT	(	asterisk	,
		"*"
	)

◆ LEXY_PUNCT() [4/21]

lexyd::LEXY_PUNCT	(	at_sign	,
		"@"
	)

◆ LEXY_PUNCT() [5/21]

lexyd::LEXY_PUNCT	(	backslash	,
		"\\"
	)

◆ LEXY_PUNCT() [6/21]

lexyd::LEXY_PUNCT	(	caret	,
		"^"
	)

◆ LEXY_PUNCT() [7/21]

lexyd::LEXY_PUNCT	(	colon	,
		":"
	)

◆ LEXY_PUNCT() [8/21]

lexyd::LEXY_PUNCT	(	comma	,
		"	,
		"
	)

◆ LEXY_PUNCT() [9/21]

lexyd::LEXY_PUNCT	(	dollar_sign	,
		"$"
	)

◆ LEXY_PUNCT() [10/21]

lexyd::LEXY_PUNCT	(	double_colon	,
		"::"
	)

◆ LEXY_PUNCT() [11/21]

lexyd::LEXY_PUNCT ( equal_sign )

◆ LEXY_PUNCT() [12/21]

lexyd::LEXY_PUNCT	(	exclamation_mark	,
		"!"
	)

◆ LEXY_PUNCT() [13/21]

lexyd::LEXY_PUNCT	(	hash_sign	,
		"#"
	)

◆ LEXY_PUNCT() [14/21]

lexyd::LEXY_PUNCT	(	hyphen	,
		"-"
	)

◆ LEXY_PUNCT() [15/21]

lexyd::LEXY_PUNCT	(	percent_sign	,
		"%"
	)

◆ LEXY_PUNCT() [16/21]

lexyd::LEXY_PUNCT	(	period	,
		"."
	)

◆ LEXY_PUNCT() [17/21]

lexyd::LEXY_PUNCT	(	question_mark	,
		"?"
	)

◆ LEXY_PUNCT() [18/21]

lexyd::LEXY_PUNCT	(	semicolon	,
		";"
	)

◆ LEXY_PUNCT() [19/21]

lexyd::LEXY_PUNCT	(	slash	,
		"/"
	)

◆ LEXY_PUNCT() [20/21]

lexyd::LEXY_PUNCT	(	tilde	,
		"~"
	)

◆ LEXY_PUNCT() [21/21]

lexyd::LEXY_PUNCT	(	vbar	,
		"\|"
	)

◆ list() [1/4]

template<typename Item >

constexpr auto lexyd::list ( Item )

constexpr

Parses a list of items without a separator.

Definition at line 133 of file list.hpp.

◆ list() [2/4]

template<typename Item , typename Sep >

constexpr auto lexyd::list	(	Item	,
		_isep< Sep >
	)

constexpr

Definition at line 157 of file list.hpp.

◆ list() [3/4]

template<typename Item , typename Sep , typename Tag >

constexpr auto lexyd::list	(	Item	,
		_sep< Sep, Tag >
	)

constexpr

Parses a list of items with the specified separator.

Definition at line 142 of file list.hpp.

◆ list() [4/4]

template<typename Item , typename Sep >

constexpr auto lexyd::list	(	Item	,
		_tsep< Sep >
	)

constexpr

Parses a list of items with the specified separator that can be trailing.

Definition at line 149 of file list.hpp.

◆ literal_set() [1/2]

template<typename T , template< typename > typename CaseFolding, typename... Strings>

constexpr auto lexyd::literal_set ( const lexy::_symbol_table< T, CaseFolding, Strings... > )

constexpr

Matches one of the symbols in the symbol table.

Definition at line 600 of file literal.hpp.

◆ literal_set() [2/2]

template<typename... Literals>

constexpr auto lexyd::literal_set ( Literals... )

constexpr

Matches one of the specified literals.

Definition at line 592 of file literal.hpp.

◆ lookahead()

template<typename Needle , typename End >

constexpr auto lexyd::lookahead	(	Needle	_needle,
		End	_end
	)

constexpr

Looks for the Needle before End. Used as condition to implement arbitrary lookahead.

Definition at line 128 of file lookahead.hpp.

◆ loop()

template<typename Rule >

constexpr auto lexyd::loop ( Rule )

constexpr

Repeatedly matches the rule until a break rule matches.

Definition at line 63 of file loop.hpp.

◆ must()

template<typename Branch >

constexpr auto lexyd::must ( Branch )

constexpr

Tries to parse Branch and raises a specific error on failure. It can still be used as a branch rule; then behaves exactly like Branch.

Definition at line 103 of file dsl/error.hpp.

◆ no_whitespace()

template<typename Rule >

constexpr auto lexyd::no_whitespace ( Rule )

constexpr

Disables automatic skipping of whitespace for all tokens of the given rule.

Definition at line 308 of file whitespace.hpp.

◆ not_followed_by()

template<typename Literal , typename CharClass >

constexpr auto lexyd::not_followed_by	(	Literal	,
		CharClass	cc
	)

constexpr

Match a literal but only if not followed by the given char class.

Definition at line 100 of file follow.hpp.

◆ op() [1/4]

template<typename Literal , typename... R>

constexpr auto lexyd::op ( _br< Literal, R... > )

constexpr

Definition at line 183 of file operator.hpp.

◆ op() [2/4]

template<typename Tag , typename Literal , typename... R>

constexpr auto lexyd::op ( _br< Literal, R... > )

constexpr

Definition at line 197 of file operator.hpp.

◆ op() [3/4]

template<typename Literal >

constexpr auto lexyd::op ( Literal )

constexpr

Definition at line 177 of file operator.hpp.

◆ op() [4/4]

template<typename Tag , typename Literal >

constexpr auto lexyd::op ( Literal )

constexpr

Definition at line 191 of file operator.hpp.

◆ operator&() [1/4]

template<typename... Cs, typename... Ds>

constexpr auto lexyd::operator&	(	_cand< Cs... >	,
		_cand< Ds... >
	)		-> _cand<Cs..., Ds...>

constexpr

Definition at line 602 of file char_class.hpp.

◆ operator&() [2/4]

template<typename... Cs, typename C >

constexpr auto lexyd::operator&	(	_cand< Cs... >	,
		C	c
	)		-> _cand<Cs..., decltype(_make_char_class(c))>

constexpr

Definition at line 591 of file char_class.hpp.

◆ operator&() [3/4]

template<typename C , typename... Cs>

constexpr auto lexyd::operator&	(	C	c,
		_cand< Cs... >
	)		-> _cand<decltype(_make_char_class(c)), Cs...>

constexpr

Definition at line 596 of file char_class.hpp.

◆ operator&() [4/4]

template<typename C1 , typename C2 >

constexpr auto lexyd::operator&	(	C1	c1,
		C2	c2
	)		-> _cand<decltype(_make_char_class(c1)), decltype(_make_char_class(c2))>

constexpr

Definition at line 584 of file char_class.hpp.

◆ operator+() [1/9]

template<typename C1 , typename... R, typename C2 , typename... S>

constexpr auto lexyd::operator+	(	_br< C1, R... >	,
		_br< C2, S... >
	)

constexpr

Definition at line 98 of file branch.hpp.

◆ operator+() [2/9]

template<typename Condition , typename... R, typename... S>

constexpr auto lexyd::operator+	(	_br< Condition, R... >	,
		_seq< S... >
	)

constexpr

Definition at line 91 of file branch.hpp.

◆ operator+() [3/9]

template<typename Condition , typename... R, typename Rule >

constexpr auto lexyd::operator+	(	_br< Condition, R... >	,
		Rule
	)

constexpr

Definition at line 85 of file branch.hpp.

◆ operator+() [4/9]

template<typename... R, typename Condition , typename... S>

constexpr auto lexyd::operator+	(	_seq< R... >	,
		_br< Condition, S... >
	)

constexpr

Definition at line 78 of file branch.hpp.

◆ operator+() [5/9]

template<typename... R, typename... S>

constexpr auto lexyd::operator+	(	_seq< R... >	,
		_seq< S... >
	)

constexpr

Definition at line 118 of file sequence.hpp.

◆ operator+() [6/9]

template<typename... R, typename S >

constexpr auto lexyd::operator+	(	_seq< R... >	,
		S
	)

constexpr

Definition at line 108 of file sequence.hpp.

◆ operator+() [7/9]

template<typename R , typename... S>

constexpr auto lexyd::operator+	(	R	,
		_seq< S... >
	)

constexpr

Definition at line 113 of file sequence.hpp.

◆ operator+() [8/9]

template<typename R , typename S , typename = std::enable_if_t<lexy::is_rule<R> && lexy::is_rule<S>>>

constexpr auto lexyd::operator+	(	R	,
		S
	)

constexpr

Definition at line 103 of file sequence.hpp.

◆ operator+() [9/9]

template<typename Rule , typename Condition , typename... R>

constexpr auto lexyd::operator+	(	Rule	rule,
		_br< Condition, R... >
	)

constexpr

Definition at line 72 of file branch.hpp.

◆ operator-() [1/4]

template<typename C >

constexpr auto lexyd::operator- ( _ccomp< C > ) -> C

constexpr

Definition at line 489 of file char_class.hpp.

◆ operator-() [2/4]

template<typename Set , typename Minus , typename OtherMinus >

constexpr auto lexyd::operator-	(	_cminus< Set, Minus >	,
		OtherMinus	other
	)

constexpr

Definition at line 540 of file char_class.hpp.

◆ operator-() [3/4]

template<typename C >

constexpr auto lexyd::operator- ( C c ) -> _ccomp<decltype(_make_char_class(c))>

constexpr

Definition at line 484 of file char_class.hpp.

◆ operator-() [4/4]

template<typename Set , typename Minus >

constexpr auto lexyd::operator-	(	Set	,
		Minus	minus
	)

constexpr

Definition at line 534 of file char_class.hpp.

◆ operator/() [1/8]

template<typename... Cs, typename... Ds>

constexpr auto lexyd::operator/	(	_calt< Cs... >	,
		_calt< Ds... >
	)		-> _calt<Cs..., Ds...>

constexpr

Definition at line 441 of file char_class.hpp.

◆ operator/() [2/8]

template<typename... Cs, typename C >

constexpr auto lexyd::operator/	(	_calt< Cs... >	,
		C	c
	)		-> _calt<Cs..., decltype(_make_char_class(c))>

constexpr

Definition at line 430 of file char_class.hpp.

◆ operator/() [3/8]

template<typename T1 , typename L1 , typename... R1, typename T2 , typename L2 , typename... R2>

constexpr auto lexyd::operator/	(	_op< T1, L1, R1... >	lhs,
		_op< T2, L2, R2... >	rhs
	)

constexpr

Definition at line 292 of file operator.hpp.

◆ operator/() [4/8]

template<typename T1 , typename L1 , typename... R1, typename... Ops>

constexpr auto lexyd::operator/	(	_op< T1, L1, R1... >	lhs,
		_opc< Ops... >
	)

constexpr

Definition at line 302 of file operator.hpp.

◆ operator/() [5/8]

template<typename... O1, typename... O2>

constexpr auto lexyd::operator/	(	_opc< O1... >	,
		_opc< O2... >
	)

constexpr

Definition at line 307 of file operator.hpp.

◆ operator/() [6/8]

template<typename... Ops, typename T2 , typename L2 , typename... R2>

constexpr auto lexyd::operator/	(	_opc< Ops... >	,
		_op< T2, L2, R2... >	rhs
	)

constexpr

Definition at line 297 of file operator.hpp.

◆ operator/() [7/8]

template<typename C , typename... Cs>

constexpr auto lexyd::operator/	(	C	c,
		_calt< Cs... >
	)		-> _calt<decltype(_make_char_class(c)), Cs...>

constexpr

Definition at line 435 of file char_class.hpp.

◆ operator/() [8/8]

template<typename R1 , typename R2 >

constexpr auto lexyd::operator/	(	R1	r1,
		R2	r2
	)		-> _calt<decltype(_make_char_class(r1)), decltype(_make_char_class(r2))>

constexpr

Definition at line 423 of file char_class.hpp.

◆ operator>>() [1/6]

template<typename C , typename... R, typename... S>

constexpr auto lexyd::operator>>	(	_br< C, R... >	,
		_seq< S... >
	)

constexpr

Definition at line 57 of file branch.hpp.

◆ operator>>() [2/6]

template<typename C , typename... R, typename Then >

constexpr auto lexyd::operator>>	(	_br< C, R... >	,
		Then
	)

constexpr

Definition at line 52 of file branch.hpp.

◆ operator>>() [3/6]

template<typename C1 , typename... R, typename C2 , typename... S>

constexpr auto lexyd::operator>>	(	_br< C1, R... >	,
		_br< C2, S... >
	)

constexpr

Definition at line 64 of file branch.hpp.

◆ operator>>() [4/6]

template<typename Condition , typename C , typename... R>

constexpr auto lexyd::operator>>	(	Condition	,
		_br< C, R... >
	)

constexpr

Definition at line 44 of file branch.hpp.

◆ operator>>() [5/6]

template<typename Condition , typename... R>

constexpr auto lexyd::operator>>	(	Condition	,
		_seq< R... >
	)

constexpr

Definition at line 38 of file branch.hpp.

◆ operator>>() [6/6]

template<typename Condition , typename Then >

constexpr auto lexyd::operator>>	(	Condition	,
		Then
	)

constexpr

Parses Then only after Condition has matched.

Definition at line 32 of file branch.hpp.

◆ operator|() [1/4]

template<typename... R, typename... S>

constexpr auto lexyd::operator\|	(	_chc< R... >	,
		_chc< S... >
	)

constexpr

Definition at line 154 of file choice.hpp.

◆ operator|() [2/4]

template<typename... R, typename S >

constexpr auto lexyd::operator\|	(	_chc< R... >	,
		S
	)

constexpr

Definition at line 142 of file choice.hpp.

◆ operator|() [3/4]

template<typename R , typename... S>

constexpr auto lexyd::operator\|	(	R	,
		_chc< S... >
	)

constexpr

Definition at line 148 of file choice.hpp.

◆ operator|() [4/4]

template<typename R , typename S >

constexpr auto lexyd::operator\|	(	R	,
		S
	)

constexpr

Definition at line 135 of file choice.hpp.

◆ opt()

template<typename Rule >

constexpr auto lexyd::opt ( Rule )

constexpr

Matches the rule or nothing. In the latter case, produces a nullopt value.

Definition at line 81 of file option.hpp.

◆ parse_as()

template<typename T , typename Rule >

constexpr auto lexyd::parse_as ( Rule )

constexpr

Definition at line 142 of file parse_as.hpp.

◆ partial_combination()

template<typename... R>

constexpr auto lexyd::partial_combination ( R... )

constexpr

Matches some of the rules in an arbitrary order. Only matches a rule at most once.

Definition at line 142 of file combination.hpp.

◆ peek()

template<typename Rule >

constexpr auto lexyd::peek ( Rule )

constexpr

Check if at this reader position, the rule would match, but don't actually consume any characters if it does.

Definition at line 166 of file peek.hpp.

◆ peek_not()

template<typename Rule >

constexpr auto lexyd::peek_not ( Rule )

constexpr

Checks if at this reader position, the rule would not match.

Definition at line 173 of file peek.hpp.

◆ recover()

template<typename... Branches>

constexpr auto lexyd::recover ( Branches... )

constexpr

Discards input until one of the branches matches to recover from an error.

Definition at line 200 of file recover.hpp.

◆ repeat()

template<typename Count >

constexpr auto lexyd::repeat ( Count )

constexpr

Parses a rule n times, where n is the value produced by Count.

Definition at line 176 of file repeat.hpp.

◆ sep()

template<typename Branch >

constexpr auto lexyd::sep ( Branch )

constexpr

Defines a separator for a list.

Definition at line 91 of file separator.hpp.

◆ terminator()

template<typename Branch >

constexpr auto lexyd::terminator ( Branch )

constexpr

Creates a terminator using the given branch.

Definition at line 106 of file terminator.hpp.

◆ times() [1/2]

template<std::size_t N, typename Rule >

constexpr auto lexyd::times ( Rule )

constexpr

Repeats the rule N times in sequence.

Definition at line 40 of file times.hpp.

◆ times() [2/2]

template<std::size_t N, typename Rule , typename Sep >

constexpr auto lexyd::times	(	Rule	,
		Sep
	)

constexpr

Repeates the rule N times in sequence separated by a separator.

Definition at line 48 of file times.hpp.

◆ token()

template<typename Rule >

constexpr auto lexyd::token ( Rule )

constexpr

Turns the arbitrary rule into a token by matching it without producing any values.

Definition at line 214 of file dsl/token.hpp.

◆ trailing_sep()

template<typename Branch >

constexpr auto lexyd::trailing_sep ( Branch )

constexpr

Defines a separator for a list that can be trailing.

Definition at line 111 of file separator.hpp.

◆ try_() [1/2]

template<typename Rule >

constexpr auto lexyd::try_ ( Rule )

constexpr

Parses Rule, if that fails, continues immediately.

Definition at line 313 of file recover.hpp.

◆ try_() [2/2]

template<typename Rule , typename Recover >

constexpr auto lexyd::try_	(	Rule	,
		Recover
	)

constexpr

Parses Rule, if that fails, parses recovery rule.

Definition at line 320 of file recover.hpp.

◆ twice() [1/2]

template<typename Rule >

constexpr auto lexyd::twice ( Rule rule )

constexpr

Definition at line 56 of file times.hpp.

◆ twice() [2/2]

template<typename Rule , typename Sep >

constexpr auto lexyd::twice	(	Rule	rule,
		Sep	sep
	)

constexpr

Definition at line 61 of file times.hpp.

◆ until()

template<typename Condition >

constexpr auto lexyd::until ( Condition )

constexpr

Matches anything until Condition matches. Then matches Condition.

Definition at line 141 of file until.hpp.

◆ while_()

template<typename Rule >

constexpr auto lexyd::while_ ( Rule )

constexpr

Matches the branch rule as often as possible.

Definition at line 95 of file loop.hpp.

◆ while_one()

template<typename Rule >

constexpr auto lexyd::while_one ( Rule rule )

constexpr

Matches the rule at least once, then as often as possible.

Definition at line 106 of file loop.hpp.

◆ whitespace()

template<typename Rule >

constexpr auto lexyd::whitespace ( Rule )

constexpr

Definition at line 227 of file whitespace.hpp.

Variable Documentation

◆ _cas

template<typename CharSet >

constexpr auto lexyd::_cas = lexy::_detail::compress_ascii_set<CharSet>()

constexpr

Definition at line 167 of file char_class.hpp.

◆ _is_bounded

template<typename T >

constexpr bool lexyd::_is_bounded = lexy::integer_traits<T>::is_bounded

constexpr

Definition at line 225 of file dsl/integer.hpp.

◆ _look_trie

template<typename Encoding , typename Needle , typename End >

constexpr auto lexyd::_look_trie = _build_look_trie<Encoding>(typename Needle::as_lset{}, typename End::as_lset{})

staticconstexpr

Definition at line 45 of file lookahead.hpp.

◆ angle_bracketed

constexpr auto lexyd::angle_bracketed = brackets(lit_c<'<'>, lit_c<'>'>)

constexpr

Definition at line 110 of file brackets.hpp.

◆ any

constexpr auto lexyd::any = _any{}

constexpr

Matches anything and consumes all remaining characters.

Definition at line 42 of file 3rdparty/lexy/include/lexy/dsl/any.hpp.

◆ argv_separator

constexpr auto lexyd::argv_separator = _argvsep{}

constexpr

Matches the separator between arguments of an argv_input.

Definition at line 205 of file argv_input.hpp.

◆ backslash_escape

constexpr auto lexyd::backslash_escape = escape(lit_c<'\\'>)

constexpr

Definition at line 462 of file delimited.hpp.

◆ backticked

constexpr auto lexyd::backticked = delimited(LEXY_LIT("`"))

constexpr

Definition at line 345 of file delimited.hpp.

◆ big_bint16

constexpr auto lexyd::big_bint16 = _bint<2, lexy::_detail::bint_big>{}

inlineconstexpr

Definition at line 297 of file byte.hpp.

◆ big_bint32

constexpr auto lexyd::big_bint32 = _bint<4, lexy::_detail::bint_big>{}

inlineconstexpr

Definition at line 302 of file byte.hpp.

◆ big_bint64

constexpr auto lexyd::big_bint64 = _bint<8, lexy::_detail::bint_big>{}

inlineconstexpr

Definition at line 307 of file byte.hpp.

◆ bint16

constexpr auto lexyd::bint16 = _bint<2, lexy::_detail::bint_native>{}

inlineconstexpr

Matches two bytes and converts it into an 16-bit integer.

Definition at line 295 of file byte.hpp.

◆ bint32

constexpr auto lexyd::bint32 = _bint<4, lexy::_detail::bint_native>{}

inlineconstexpr

Matches four bytes and converts it into an 32-bit integer.

Definition at line 300 of file byte.hpp.

◆ bint64

constexpr auto lexyd::bint64 = _bint<8, lexy::_detail::bint_native>{}

inlineconstexpr

Matches eight bytes and converts it into an 64-bit integer.

Definition at line 305 of file byte.hpp.

◆ bint8

constexpr auto lexyd::bint8 = _bint<1, lexy::_detail::bint_native>{}

inlineconstexpr

Matches one byte and converts it into an 8-bit integer.

Definition at line 292 of file byte.hpp.

◆ bom

template<typename Encoding , lexy::encoding_endianness Endianness>

constexpr auto lexyd::bom = _bom<Encoding, Endianness>{}

inlineconstexpr

The BOM for that particular encoding.

Definition at line 43 of file bom.hpp.

◆ break_

constexpr auto lexyd::break_ = _break{}

constexpr

Exits a loop().

Definition at line 30 of file loop.hpp.

◆ byte

constexpr auto lexyd::byte = _b<1>{}

constexpr

Matches an arbitrary byte.

Definition at line 51 of file byte.hpp.

◆ bytes

template<std::size_t N>

constexpr auto lexyd::bytes = _b<N>{}

constexpr

Matches N arbitrary bytes.

Definition at line 55 of file byte.hpp.

◆ code_point

constexpr auto lexyd::code_point = _cp<void>{}

constexpr

Matches a single unicode code point in the current unicode encoding.

Definition at line 200 of file dsl/code_point.hpp.

◆ code_point_id

template<std::size_t N, typename Base = hex>

constexpr auto lexyd::code_point_id

constexpr

Initial value:

= [] {
    using type = std::conditional_t<_ndigits_can_overflow<lexy::code_point, N, Base::digit_radix>(),
                                    lexy::code_point, lexy::unbounded<lexy::code_point>>;
    using parser = _integer_parser<type, Base, true>;
    return _int<_ndigits<N, Base>, parser, lexy::invalid_code_point>{};
}()

Matches the integer value of a code point.

Definition at line 529 of file dsl/integer.hpp.

◆ code_unit_id

template<typename Encoding , std::size_t N, typename Base = hex>

constexpr auto lexyd::code_unit_id

constexpr

Initial value:

= [] {
    using char_type = typename Encoding::char_type;
    using type      = std::conditional_t<_ndigits_can_overflow<char_type, N, Base::digit_radix>(),
                                    char_type, lexy::unbounded<char_type>>;
    using parser    = _integer_parser<type, Base, true>;
    return _int<_ndigits<N, Base>, parser, lexy::invalid_code_unit>{};
}()

Matches the integer value of a code unit.

Definition at line 553 of file dsl/integer.hpp.

◆ context_counter

template<typename Id >

constexpr auto lexyd::context_counter = _ctx_counter_dsl<Id>{}

constexpr

Declares an integer counter that is added to the parsing context.

Definition at line 256 of file context_counter.hpp.

◆ context_flag

template<typename Id >

constexpr auto lexyd::context_flag = _ctx_flag_dsl<Id>{}

constexpr

Declares a flag.

Definition at line 149 of file context_flag.hpp.

◆ curly_bracketed

constexpr auto lexyd::curly_bracketed = brackets(lit_c<'{'>, lit_c<'}'>)

constexpr

Definition at line 109 of file brackets.hpp.

◆ digit

template<typename Base = decimal, int = Base::digit_radix>

constexpr auto lexyd::digit = Base{}

constexpr

Matches a single digit.

Definition at line 263 of file digit.hpp.

◆ digit_sep_tick

constexpr auto lexyd::digit_sep_tick = LEXY_LIT("'")

constexpr

Definition at line 534 of file digit.hpp.

◆ digit_sep_underscore

constexpr auto lexyd::digit_sep_underscore = LEXY_LIT("_")

constexpr

Definition at line 533 of file digit.hpp.

◆ digits

template<typename Base = decimal>

constexpr auto lexyd::digits = _digits<Base>{}

constexpr

Matches a non-empty list of digits.

Definition at line 531 of file digit.hpp.

◆ dollar_escape

constexpr auto lexyd::dollar_escape = escape(lit_c<'$'>)

constexpr

Definition at line 463 of file delimited.hpp.

◆ double_backticked

constexpr auto lexyd::double_backticked = delimited(LEXY_LIT("``"))

constexpr

Definition at line 346 of file delimited.hpp.

◆ effect

template<LEXY_NTTP_PARAM Fn>

constexpr auto lexyd::effect = _eff<Fn>{}

constexpr

Invokes Fn and produces its value as result.

Definition at line 65 of file effect.hpp.

◆ else_

constexpr auto lexyd::else_ = _else_dsl{}

inlineconstexpr

Takes the branch unconditionally.

Definition at line 143 of file branch.hpp.

◆ eof

constexpr auto lexyd::eof = _eof{}

constexpr

Matches EOF.

Definition at line 72 of file eof.hpp.

◆ eol

constexpr auto lexyd::eol = _eol{}

constexpr

Matches the end of line (EOF or newline).

Definition at line 79 of file newline.hpp.

◆ error

template<typename Tag >

constexpr auto lexyd::error = _err<Tag, void>{}

constexpr

Matches nothing, produces an error with the given tag.

Definition at line 49 of file dsl/error.hpp.

◆ inline_

template<typename Production >

constexpr auto lexyd::inline_ = lexy::production_rule<Production>{}

constexpr

Parses the rule of the production as if it were part of the current production.

Definition at line 16 of file production.hpp.

◆ integer

template<typename T , typename Base = void>

constexpr auto lexyd::integer = _int_dsl<T, Base>{}

constexpr

Parses the digits matched by the rule into an integer type.

Definition at line 510 of file dsl/integer.hpp.

◆ lit_b

template<unsigned char... C>

constexpr auto lexyd::lit_b = _lit<unsigned char, C...>{}

constexpr

Definition at line 382 of file literal.hpp.

◆ lit_c

template<auto C>

constexpr auto lexyd::lit_c = _lit<LEXY_DECAY_DECLTYPE(C), C>{}

constexpr

Definition at line 379 of file literal.hpp.

◆ lit_cp

template<char32_t... CodePoint>

constexpr auto lexyd::lit_cp = _lcp<CodePoint...>{}

constexpr

Definition at line 477 of file literal.hpp.

◆ little_bint16

constexpr auto lexyd::little_bint16 = _bint<2, lexy::_detail::bint_little>{}

inlineconstexpr

Definition at line 296 of file byte.hpp.

◆ little_bint32

constexpr auto lexyd::little_bint32 = _bint<4, lexy::_detail::bint_little>{}

inlineconstexpr

Definition at line 301 of file byte.hpp.

◆ little_bint64

constexpr auto lexyd::little_bint64 = _bint<8, lexy::_detail::bint_little>{}

inlineconstexpr

Definition at line 306 of file byte.hpp.

◆ Loop

lexyd::_rep lexyd::Loop

◆ member

template<auto MemPtr>

constexpr auto lexyd::member = _mem_dsl<lexy::_mem_ptr_fn<MemPtr>>{}

constexpr

Specifies that the output of the associated rule should be stored in the member pointer. Used with lexy::as_aggregate.

Definition at line 92 of file member.hpp.

◆ minus_sign

constexpr auto lexyd::minus_sign = if_(_minus{})

constexpr

Matches a minus sign or nothing, producing +1 or -1.

Definition at line 40 of file sign.hpp.

◆ n_digits

template<std::size_t N, typename Base = decimal>

constexpr auto lexyd::n_digits = _ndigits<N, Base>{}

constexpr

Matches exactly N digits.

Definition at line 630 of file digit.hpp.

◆ newline

constexpr auto lexyd::newline = _nl{}

constexpr

Matches a newline character.

Definition at line 29 of file newline.hpp.

◆ nullopt

constexpr auto lexyd::nullopt = _nullopt{}

constexpr

Definition at line 50 of file option.hpp.

◆ p

template<typename Production >

constexpr auto lexyd::p = _prd<Production>{}

constexpr

Parses the production.

Definition at line 127 of file production.hpp.

◆ padding_bytes

template<std::size_t N, unsigned char Padding = 0>

constexpr auto lexyd::padding_bytes = _pb<N, Padding>{}

constexpr

Matches N bytes set to the padding value. It is a recoverable error if the byte doesn't have that value.

Definition at line 135 of file byte.hpp.

◆ parenthesized

constexpr auto lexyd::parenthesized = round_bracketed

constexpr

Definition at line 112 of file brackets.hpp.

◆ plus_sign

constexpr auto lexyd::plus_sign = if_(_plus{})

constexpr

Matches a plus sign or nothing, producing +1.

Definition at line 38 of file sign.hpp.

◆ position

constexpr auto lexyd::position = _pos_dsl{}

constexpr

Produces an iterator to the current reader position without parsing anything.

Definition at line 79 of file position.hpp.

◆ quoted

constexpr auto lexyd::quoted = delimited(LEXY_LIT("\""))

constexpr

Definition at line 340 of file delimited.hpp.

◆ recurse

template<typename Production >

constexpr auto lexyd::recurse = _rec<Production>{}

constexpr

Parses the production, recursively. dsl::p requires that the production is already defined in order to propagate a branch condition outwards.

Definition at line 242 of file production.hpp.

◆ recurse_branch

template<typename Production >

constexpr auto lexyd::recurse_branch = _recb<Production>{}

constexpr

Definition at line 245 of file production.hpp.

◆ return_

constexpr auto lexyd::return_ = _ret{}

constexpr

Finishes parsing a production without considering subsequent rules.

Definition at line 20 of file return.hpp.

◆ round_bracketed

constexpr auto lexyd::round_bracketed = brackets(lit_c<'('>, lit_c<')'>)

constexpr

Definition at line 107 of file brackets.hpp.

◆ scan

constexpr auto lexyd::scan = _scan{}

inlineconstexpr

Definition at line 489 of file dsl/scan.hpp.

◆ sign

constexpr auto lexyd::sign = if_(_plus{} | _minus{})

constexpr

Matches a plus or minus sign or nothing, producing +1 or -1.

Definition at line 43 of file sign.hpp.

◆ single_quoted

constexpr auto lexyd::single_quoted = delimited(LEXY_LIT("'"))

constexpr

Definition at line 343 of file delimited.hpp.

◆ square_bracketed

constexpr auto lexyd::square_bracketed = brackets(lit_c<'['>, lit_c<']'>)

constexpr

Definition at line 108 of file brackets.hpp.

◆ subgrammar

template<typename Production , typename T >

constexpr auto lexyd::subgrammar = _subg<Production, T>{}

constexpr

Parses the entry production of a subgrammar, which may be defined in a different file.

Definition at line 103 of file subgrammar.hpp.

◆ symbol

template<const auto & Table>

constexpr auto lexyd::symbol = _sym_dsl<Table>{}

constexpr

Parses optional rule, then matches the resulting lexeme against the symbol table.

Definition at line 532 of file symbol.hpp.

◆ triple_backticked

constexpr auto lexyd::triple_backticked = delimited(LEXY_LIT("```"))

constexpr

Definition at line 347 of file delimited.hpp.

◆ triple_quoted

constexpr auto lexyd::triple_quoted = delimited(LEXY_LIT("\"\"\""))

constexpr

Definition at line 341 of file delimited.hpp.

◆ zero

constexpr auto lexyd::zero = _zero{}

constexpr

Matches the zero digit.

Definition at line 259 of file digit.hpp.

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ _copy_base

◆ _ctx_counter

◆ _ctx_flag

◆ _ctx_id

◆ _detect_eff_fn

◆ _detect_op_tag_ctor

◆ _detect_scan_state

◆ _integer_parser

◆ _integer_parser_for

◆ binary

◆ decimal

◆ hex

◆ octal

Function Documentation

◆ _build_look_trie()

◆ _copy_base_impl()

◆ _finish_production()

◆ _make_char_class()

◆ _make_lit_rule()

◆ _make_pas_handler() [1/2]

◆ _make_pas_handler() [2/2]

◆ _match_digits()

◆ _match_digits_sep()

◆ _maybe_branch()

◆ _ndigits_can_overflow()

◆ _parse_production()

◆ _until_swar()

◆ bits()

◆ brackets()

◆ capture() [1/2]

◆ capture() [2/2]

◆ combination()

◆ context_identifier()

◆ delimited() [1/2]

◆ delimited() [2/2]

◆ do_while()

◆ equal_counts()

◆ escape()

◆ find()

◆ flag()

◆ flags() [1/2]

◆ flags() [2/2]

◆ followed_by()

◆ identifier() [1/2]

◆ identifier() [2/2]

◆ if_()

◆ ignore_trailing_sep()

◆ keyword()

◆ LEXY_PUNCT() [1/21]

◆ LEXY_PUNCT() [2/21]

◆ LEXY_PUNCT() [3/21]

◆ LEXY_PUNCT() [4/21]

◆ LEXY_PUNCT() [5/21]

◆ LEXY_PUNCT() [6/21]

◆ LEXY_PUNCT() [7/21]

◆ LEXY_PUNCT() [8/21]

◆ LEXY_PUNCT() [9/21]

◆ LEXY_PUNCT() [10/21]

◆ LEXY_PUNCT() [11/21]

◆ LEXY_PUNCT() [12/21]

◆ LEXY_PUNCT() [13/21]

◆ LEXY_PUNCT() [14/21]

◆ LEXY_PUNCT() [15/21]

◆ LEXY_PUNCT() [16/21]

◆ LEXY_PUNCT() [17/21]

◆ LEXY_PUNCT() [18/21]

◆ LEXY_PUNCT() [19/21]

◆ LEXY_PUNCT() [20/21]

◆ LEXY_PUNCT() [21/21]

◆ list() [1/4]

◆ list() [2/4]

◆ list() [3/4]

◆ list() [4/4]

◆ literal_set() [1/2]