tao::TAO_PEGTL_NAMESPACE::internal namespace

Contents

Classes

template<template<typename...> class Action, typename... Rules>
struct action
template<typename Input>
class action_input
template<typename Peek>
struct any
template<>
struct any<peek_char>
template<typename... Actions>
struct apply
template<typename... Actions>
struct apply0
template<apply_mode A, typename... Actions>
struct apply0_impl
template<>
struct apply0_impl<apply_mode::ACTION>
template<typename... Actions>
struct apply0_impl<apply_mode::ACTION, Actions...>
template<typename... Actions>
struct apply0_impl<apply_mode::NOTHING, Actions...>
template<typename Action>
struct apply0_single
template<apply_mode A, typename... Actions>
struct apply_impl
template<>
struct apply_impl<apply_mode::ACTION>
template<typename... Actions>
struct apply_impl<apply_mode::ACTION, Actions...>
template<typename... Actions>
struct apply_impl<apply_mode::NOTHING, Actions...>
template<typename Action>
struct apply_single
template<typename... Rules>
struct at
template<>
struct at<>
template<char Marker, char Close>
struct at_raw_string_close
struct bof
struct bol
template<bool...>
struct bool_list
template<bool>
struct bump_impl
template<>
struct bump_impl<false>
template<>
struct bump_impl<true>
template<unsigned Num>
struct bytes
template<template<typename...> class Control, typename... Rules>
struct control
struct cr_crlf_eol
struct cr_eol
struct crlf_eol
struct cstream_reader
struct cstring_reader
template<typename... Rules>
struct disable
struct discard
struct dummy_disabled_state
template<typename Rule, apply_mode A, rewind_mode M, template<typename...> class Action, template<typename...> class Control, dusel_mode = dusel_mode::NOTHING>
struct duseltronik
template<typename Rule, apply_mode A, rewind_mode M, template<typename...> class Action, template<typename...> class Control>
struct duseltronik<Rule, A, M, Action, Control, dusel_mode::CONTROL>
template<typename Rule, apply_mode A, rewind_mode M, template<typename...> class Action, template<typename...> class Control>
struct duseltronik<Rule, A, M, Action, Control, dusel_mode::CONTROL_AND_APPLY0_BOOL>
template<typename Rule, apply_mode A, rewind_mode M, template<typename...> class Action, template<typename...> class Control>
struct duseltronik<Rule, A, M, Action, Control, dusel_mode::CONTROL_AND_APPLY0_VOID>
template<typename Rule, apply_mode A, rewind_mode M, template<typename...> class Action, template<typename...> class Control>
struct duseltronik<Rule, A, M, Action, Control, dusel_mode::CONTROL_AND_APPLY_BOOL>
template<typename Rule, apply_mode A, rewind_mode M, template<typename...> class Action, template<typename...> class Control>
struct duseltronik<Rule, A, M, Action, Control, dusel_mode::CONTROL_AND_APPLY_VOID>
template<typename Rule, apply_mode A, rewind_mode M, template<typename...> class Action, template<typename...> class Control>
struct duseltronik<Rule, A, M, Action, Control, dusel_mode::NOTHING>
template<typename... Rules>
struct enable
struct eof
struct eol
struct eolf
struct file_close
class file_mapper
struct file_opener
class file_reader
struct filename_holder
template<bool V, bool E>
struct generate_sequence
template<>
struct generate_sequence<false, false>
template<>
struct generate_sequence<false, true>
template<>
struct generate_sequence<true, false>
template<>
struct generate_sequence<true, true>
template<typename, typename, typename...>
struct has_apply
template<typename, typename, typename...>
struct has_apply0
template<typename A, typename... S>
struct has_apply0<A, decltype(A::apply0(std::declval<S>()...)), S...>
template<typename A, typename... S>
struct has_apply<A, decltype(A::apply(std::declval<S>()...)), S...>
template<char C, bool A = is_alpha<C>::value>
struct ichar_equal
template<char C>
struct ichar_equal<C, false>
template<char C>
struct ichar_equal<C, true>
template<typename Rule, typename... Actions>
struct if_apply
template<apply_mode A, typename Rule, typename... Actions>
struct if_apply_impl
template<typename Rule>
struct if_apply_impl<apply_mode::ACTION, Rule>
template<typename Rule, typename... Actions>
struct if_apply_impl<apply_mode::ACTION, Rule, Actions...>
template<typename Rule, typename... Actions>
struct if_apply_impl<apply_mode::NOTHING, Rule, Actions...>
template<typename Cond, typename Then, typename Else>
struct if_then_else
template<typename Data>
struct input_pair
template<typename T, T... Ns>
struct integer_sequence
struct istream_reader
template<char... Cs>
struct istring
template<>
struct istring<>
template<char... Cs>
struct istring_equal
template<char C, char... Cs>
struct istring_equal<C, Cs...>
template<>
struct istring_equal<>
struct iterator
struct lf_crlf_eol
struct lf_eol
template<typename Iterator, rewind_mode M>
class marker
template<typename Iterator>
class marker<Iterator, rewind_mode::REQUIRED>
template<typename T, T N>
struct memoize_sequence
template<tracking_mode, typename Eol, typename Source>
class memory_input_base
template<typename Eol, typename Source>
class memory_input_base<tracking_mode::IMMEDIATE, Eol, Source>
template<typename Eol, typename Source>
class memory_input_base<tracking_mode::LAZY, Eol, Source>
template<typename R, typename S>
struct minus
struct mmap_holder
template<typename... Rules>
struct must
template<typename Rule>
struct must<Rule>
template<typename... Rules>
struct not_at
template<>
struct not_at<>
template<result_on_found R, typename Peek, typename Peek::data_t... Cs>
struct one
template<result_on_found R, typename Peek, typename Peek::data_t C>
struct one<R, Peek, C>
template<typename... Rules>
struct opt
template<>
struct opt<>
struct peek_char
template<typename R>
struct peek_utf16_impl
template<typename R>
struct peek_utf32_impl
struct peek_utf8
template<typename Rule, typename... Rules>
struct plus
template<typename T>
struct raise
template<result_on_found R, typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi>
struct range
template<typename Peek, typename Peek::data_t... Cs>
struct ranges
template<typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi>
struct ranges<Peek, Lo, Hi>
template<int Eol, typename Char, Char... Cs>
struct ranges_impl
template<int Eol, typename Char>
struct ranges_impl<Eol, Char>
template<int Eol, typename Char, Char Eq>
struct ranges_impl<Eol, Char, Eq>
template<int Eol, typename Char, Char Lo, Char Hi, Char... Cs>
struct ranges_impl<Eol, Char, Lo, Hi, Cs...>
template<char Open, char Marker>
struct raw_string_open
template<typename Cond, typename... Rules>
struct raw_string_until
template<typename Cond>
struct raw_string_until<Cond>
struct read_utf16_be
struct read_utf16_le
struct read_utf32_be
struct read_utf32_le
template<unsigned Num, typename... Rules>
struct rep
template<typename Rule, typename... Rules>
struct rep<0, Rule, Rules...>
template<unsigned Num>
struct rep<Num>
template<unsigned Min, unsigned Max, typename... Rules>
struct rep_min_max
template<typename Rule, typename... Rules>
struct rep_min_max<0, 0, Rule, Rules...>
template<unsigned Min, unsigned Max>
struct rep_min_max<Min, Max>
template<unsigned Min, unsigned Max, char C>
struct rep_one_min_max
template<unsigned Max, typename... Rules>
struct rep_opt
template<unsigned Amount>
struct require
template<>
struct require<0>
template<typename... Rules>
struct rule_conjunction
template<>
struct rule_conjunction<>
template<typename... Rules>
struct seq
template<typename Rule>
struct seq<Rule>
template<>
struct seq<>
template<typename Rule>
struct skip_control
template<template<typename...> class Action, typename... Rules>
struct skip_control<action<Action, Rules...>>
template<typename Peek>
struct skip_control<any<Peek>>
template<typename... Actions>
struct skip_control<apply0<Actions...>>
template<typename... Actions>
struct skip_control<apply<Actions...>>
template<typename... Rules>
struct skip_control<at<Rules...>>
template<char Marker, char Close>
struct skip_control<at_raw_string_close<Marker, Close>>
template<>
struct skip_control<bof>
template<>
struct skip_control<bol>
template<unsigned Num>
struct skip_control<bytes<Num>>
template<template<typename...> class Control, typename... Rules>
struct skip_control<control<Control, Rules...>>
template<typename... Rules>
struct skip_control<disable<Rules...>>
template<>
struct skip_control<discard>
template<typename... Rules>
struct skip_control<enable<Rules...>>
template<>
struct skip_control<eof>
template<>
struct skip_control<eol>
template<>
struct skip_control<eolf>
template<typename Rule, typename... Actions>
struct skip_control<if_apply<Rule, Actions...>>
template<typename Cond, typename Then, typename Else>
struct skip_control<if_then_else<Cond, Then, Else>>
template<char... Cs>
struct skip_control<istring<Cs...>>
template<typename R, typename S>
struct skip_control<minus<R, S>>
template<typename... Rules>
struct skip_control<must<Rules...>>
template<typename... Rules>
struct skip_control<not_at<Rules...>>
template<result_on_found R, typename Peek, typename Peek::data_t... Cs>
struct skip_control<one<R, Peek, Cs...>>
template<typename... Rules>
struct skip_control<opt<Rules...>>
template<typename Rule, typename... Rules>
struct skip_control<plus<Rule, Rules...>>
template<typename T>
struct skip_control<raise<T>>
template<result_on_found R, typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi>
struct skip_control<range<R, Peek, Lo, Hi>>
template<typename Peek, typename Peek::data_t... Cs>
struct skip_control<ranges<Peek, Cs...>>
template<char Open, char Marker>
struct skip_control<raw_string_open<Open, Marker>>
template<typename Cond, typename... Rules>
struct skip_control<raw_string_until<Cond, Rules...>>
template<unsigned Num, typename... Rules>
struct skip_control<rep<Num, Rules...>>
template<unsigned Min, unsigned Max, typename... Rules>
struct skip_control<rep_min_max<Min, Max, Rules...>>
template<unsigned Min, unsigned Max, char C>
struct skip_control<rep_one_min_max<Min, Max, C>>
template<unsigned Max, typename... Rules>
struct skip_control<rep_opt<Max, Rules...>>
template<unsigned Amount>
struct skip_control<require<Amount>>
template<typename... Rules>
struct skip_control<seq<Rules...>>
template<typename... Rules>
struct skip_control<sor<Rules...>>
template<typename Rule, typename... Rules>
struct skip_control<star<Rule, Rules...>>
template<typename State, typename... Rules>
struct skip_control<state<State, Rules...>>
template<char... Cs>
struct skip_control<string<Cs...>>
template<bool Result>
struct skip_control<trivial<Result>>
template<typename Exception, typename... Rules>
struct skip_control<try_catch_type<Exception, Rules...>>
template<typename Cond, typename... Rules>
struct skip_control<until<Cond, Rules...>>
template<typename... Rules>
struct sor
template<std::size_t... Indices, typename... Rules>
struct sor<index_sequence<Indices...>, Rules...>
template<>
struct sor<>
template<typename Rule, typename... Rules>
struct star
template<typename State, typename... Rules>
struct state
template<char... Cs>
struct string
template<>
struct string<>
template<template<char...> class S, char, bool>
struct string_at
template<template<char...> class S, char C>
struct string_at<S, C, true>
struct string_holder
template<typename, typename, typename, typename, typename, typename, typename, typename>
struct string_join
template<template<char...> class S, char... C0s, char... C1s, char... C2s, char... C3s, char... C4s, char... C5s, char... C6s, char... C7s>
struct string_join<S<C0s...>, S<C1s...>, S<C2s...>, S<C3s...>, S<C4s...>, S<C5s...>, S<C6s...>, S<C7s...>>
template<typename T, std::size_t S>
struct string_max_length
template<unsigned S>
struct to_and_from_be
template<>
struct to_and_from_be<1>
template<>
struct to_and_from_be<2>
template<>
struct to_and_from_be<4>
template<>
struct to_and_from_be<8>
template<unsigned S>
struct to_and_from_le
template<>
struct to_and_from_le<1>
template<>
struct to_and_from_le<2>
template<>
struct to_and_from_le<4>
template<>
struct to_and_from_le<8>
template<typename>
struct to_string
template<template<char...> class X, char... Cs>
struct to_string<X<Cs...>>
template<bool Result>
struct trivial
template<typename Exception, typename... Rules>
struct try_catch_type
template<typename Exception>
struct try_catch_type<Exception>
template<typename Cond, typename... Rules>
struct until
template<typename Cond>
struct until<Cond>

Enums

enum class result_on_found: bool { SUCCESS = true, FAILURE = false }

Typedefs

template<apply_mode A, typename State>
using state_disable_helper = typename std::conditional<A==apply_mode::ACTION, State, dummy_disabled_state>::type
using alnum = ranges<peek_char, 'a', 'z', 'A', 'Z', '0', '9'>
using alpha = ranges<peek_char, 'a', 'z', 'A', 'Z'>
template<bool... Bs>
using bool_and = std::is_same<bool_list<Bs..., true>, bool_list<true, Bs...>>
using identifier_first = ranges<peek_char, 'a', 'z', 'A', 'Z', '_'>
using identifier_other = ranges<peek_char, 'a', 'z', 'A', 'Z', '0', '9', '_'>
using identifier = seq<identifier_first, star<identifier_other>>
template<typename Cond, typename... Thens>
using if_must = seq<Cond, must<Thens...>>
template<typename Cond, typename Then, typename Else>
using if_must_else = if_then_else<Cond, must<Then>, must<Else>>
template<std::size_t... Ns>
using index_sequence = integer_sequence<std::size_t, Ns...>
template<typename T, T N>
using make_integer_sequence = typename memoize_sequence<T, N>::type
template<std::size_t N>
using make_index_sequence = make_integer_sequence<std::size_t, N>
template<typename... Ts>
using index_sequence_for = make_index_sequence<sizeof...(Ts)>
template<char C>
using is_alpha = std::integral_constant<bool,(('a'<=C) && (C<='z'))||(('A'<=C) && (C<='Z'))>
template<typename Rule, typename Sep>
using list = seq<Rule, star<Sep, Rule>>
template<typename Rule, typename Sep>
using list_must = seq<Rule, star<Sep, must<Rule>>>
template<typename Rule, typename Sep>
using list_tail = seq<list<Rule, Sep>, opt<Sep>>
template<typename Rule, typename Sep, typename Pad>
using list_tail_pad = seq<list<Rule, pad<Sep, Pad>>, opt<star<Pad>, Sep>>
template<typename Rule, typename Pad1, typename Pad2 = Pad1>
using pad = seq<star<Pad1>, Rule, star<Pad2>>
template<typename Rule, typename Pad>
using pad_opt = seq<star<Pad>, opt<Rule, star<Pad>>>
using peek_utf16_be = peek_utf16_impl<read_utf16_be>
using peek_utf16_le = peek_utf16_impl<read_utf16_le>
using peek_utf16 = peek_utf16_le
using peek_utf32_be = peek_utf32_impl<read_utf32_be>
using peek_utf32_le = peek_utf32_impl<read_utf32_le>
using peek_utf32 = peek_utf32_le
template<unsigned Min, typename Rule, typename... Rules>
using rep_min = seq<rep<Min, Rule, Rules...>, star<Rule, Rules...>>
template<typename Cond, typename... Rules>
using star_must = star<if_must<Cond, Rules...>>

Functions

auto make_argv_source(const std::size_t argn) -> std::string
auto begin_c_ptr(const char* p) -> const char* noexcept
auto begin_c_ptr(const iterator& it) -> const char* noexcept
template<result_on_found R, typename Input, typename Char, Char... Cs>
void bump_help(Input& in, const std::size_t count) noexcept
void bump(iterator& iter, const std::size_t count, const int ch) noexcept
void bump_in_this_line(iterator& iter, const std::size_t count) noexcept
void bump_to_next_line(iterator& iter, const std::size_t count) noexcept
template<typename T>
auto demangle() -> std::string
auto demangle(const char* symbol) -> std::string
void demangle_sanitise_chars(std::string& s)
template<typename N>
auto h_to_be(const N n) -> N noexcept
template<typename N>
auto be_to_h(const N n) -> N noexcept
template<typename N>
auto be_to_h(const void* p) -> N noexcept
template<typename N>
auto h_to_le(const N n) -> N noexcept
template<typename N>
auto le_to_h(const N n) -> N noexcept
template<typename N>
auto le_to_h(const void* p) -> N noexcept
auto file_open(const char* filename) -> std::FILE*
auto source_pointer(const char* source) -> const char* noexcept
auto source_pointer(const std::string& source) -> const char* noexcept
template<typename Char>
auto contains(const Char c, const std::initializer_list<Char>& l) -> bool noexcept
auto unsafe_equals(const char* s, const std::initializer_list<char>& l) -> bool noexcept