894 lines
26 KiB
C++
894 lines
26 KiB
C++
|
#ifndef TOML11_SYNTAX_IMPL_HPP
|
||
|
|
#define TOML11_SYNTAX_IMPL_HPP
|
||
|
|
|
||
|
|
#include "../fwd/syntax_fwd.hpp"
|
||
|
|
#include "../scanner.hpp"
|
||
|
|
#include "../spec.hpp"
|
||
|
|
#include "../version.hpp"
|
||
|
|
|
||
|
|
namespace toml
|
||
|
|
{
|
||
|
|
inline namespace TOML11_INLINE_VERSION_NAMESPACE
|
||
|
|
{
|
||
|
|
namespace detail
|
||
|
|
{
|
||
|
|
namespace syntax
|
||
|
|
{
|
||
|
|
|
||
|
|
using char_type = location::char_type;
|
||
|
|
|
||
|
|
template<typename F>
|
||
|
|
struct syntax_cache
|
||
|
|
{
|
||
|
|
using value_type = cxx::return_type_of_t<F, const spec&>;
|
||
|
|
static_assert(std::is_base_of<scanner_base, value_type>::value, "");
|
||
|
|
|
||
|
|
explicit syntax_cache(F f)
|
||
|
|
: func_(std::move(f)), cache_(cxx::make_nullopt())
|
||
|
|
{}
|
||
|
|
|
||
|
|
value_type const& at(const spec& s)
|
||
|
|
{
|
||
|
|
if( ! this->cache_.has_value() || this->cache_.value().first != s)
|
||
|
|
{
|
||
|
|
this->cache_ = std::make_pair(s, func_(s));
|
||
|
|
}
|
||
|
|
return this->cache_.value().second;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
F func_;
|
||
|
|
cxx::optional<std::pair<spec, value_type>> cache_;
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename F>
|
||
|
|
syntax_cache<cxx::remove_cvref_t<F>> make_cache(F&& f)
|
||
|
|
{
|
||
|
|
return syntax_cache<cxx::remove_cvref_t<F>>(std::forward<F>(f));
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// UTF-8
|
||
|
|
|
||
|
|
// avoid redundant representation and out-of-unicode sequence
|
||
|
|
|
||
|
|
TOML11_INLINE character_in_range const& utf8_1byte(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local character_in_range cache(0x00, 0x7F);
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& utf8_2bytes(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local sequence cache(
|
||
|
|
character_in_range(0xC2, 0xDF),
|
||
|
|
character_in_range(0x80, 0xBF));
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& utf8_3bytes(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local sequence cache(/*1~2 bytes = */either(
|
||
|
|
sequence(character (0xE0), character_in_range(0xA0, 0xBF)),
|
||
|
|
sequence(character_in_range(0xE1, 0xEC), character_in_range(0x80, 0xBF)),
|
||
|
|
sequence(character (0xED), character_in_range(0x80, 0x9F)),
|
||
|
|
sequence(character_in_range(0xEE, 0xEF), character_in_range(0x80, 0xBF))
|
||
|
|
), /*3rd byte = */ character_in_range(0x80, 0xBF));
|
||
|
|
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& utf8_4bytes(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local sequence cache(/*1~2 bytes = */either(
|
||
|
|
sequence(character (0xF0), character_in_range(0x90, 0xBF)),
|
||
|
|
sequence(character_in_range(0xF1, 0xF3), character_in_range(0x80, 0xBF)),
|
||
|
|
sequence(character (0xF4), character_in_range(0x80, 0x8F))
|
||
|
|
), character_in_range(0x80, 0xBF), character_in_range(0x80, 0xBF));
|
||
|
|
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Whitespace
|
||
|
|
|
||
|
|
TOML11_INLINE character_either const& wschar(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local character_either cache(" \t");
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE repeat_at_least const& ws(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s){
|
||
|
|
return repeat_at_least(0, wschar(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Newline
|
||
|
|
|
||
|
|
TOML11_INLINE either const& newline(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local either cache(character(char_type('\n')), literal("\r\n"));
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Comments
|
||
|
|
|
||
|
|
TOML11_INLINE either const& allowed_comment_char(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s){
|
||
|
|
if(s.v1_1_0_allow_control_characters_in_comments)
|
||
|
|
{
|
||
|
|
return either(
|
||
|
|
character_in_range(0x01, 0x09),
|
||
|
|
character_in_range(0x0E, 0x7F),
|
||
|
|
non_ascii(s)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return either(
|
||
|
|
character(0x09),
|
||
|
|
character_in_range(0x20, 0x7E),
|
||
|
|
non_ascii(s)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// XXX Note that it does not take newline
|
||
|
|
TOML11_INLINE sequence const& comment(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s){
|
||
|
|
return sequence(character(char_type('#')),
|
||
|
|
repeat_at_least(0, allowed_comment_char(s)));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Boolean
|
||
|
|
|
||
|
|
TOML11_INLINE either const& boolean(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local either cache(literal("true"), literal("false"));
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Integer
|
||
|
|
|
||
|
|
// non-digit-graph = ([a-zA-Z]|unicode mb char)
|
||
|
|
// graph = ([a-zA-Z0-9]|unicode mb char)
|
||
|
|
// suffix = _ non-digit-graph (graph | _graph)
|
||
|
|
TOML11_INLINE sequence const& num_suffix(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
const auto non_digit_graph = [&s]() {
|
||
|
|
return either(
|
||
|
|
alpha(s),
|
||
|
|
non_ascii(s)
|
||
|
|
);
|
||
|
|
};
|
||
|
|
const auto graph = [&s]() {
|
||
|
|
return either(
|
||
|
|
alpha(s),
|
||
|
|
digit(s),
|
||
|
|
non_ascii(s)
|
||
|
|
);
|
||
|
|
};
|
||
|
|
|
||
|
|
return sequence(
|
||
|
|
character(char_type('_')),
|
||
|
|
non_digit_graph(),
|
||
|
|
repeat_at_least(0,
|
||
|
|
either(
|
||
|
|
sequence(character(char_type('_')), graph()),
|
||
|
|
graph()
|
||
|
|
)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& dec_int(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
const auto digit19 = []() {
|
||
|
|
return character_in_range(char_type('1'), char_type('9'));
|
||
|
|
};
|
||
|
|
return sequence(
|
||
|
|
maybe(character_either("+-")),
|
||
|
|
either(
|
||
|
|
sequence(
|
||
|
|
digit19(),
|
||
|
|
repeat_at_least(1,
|
||
|
|
either(
|
||
|
|
digit(s),
|
||
|
|
sequence(character(char_type('_')), digit(s))
|
||
|
|
)
|
||
|
|
)
|
||
|
|
),
|
||
|
|
digit(s)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& hex_int(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
literal("0x"),
|
||
|
|
hexdig(s),
|
||
|
|
repeat_at_least(0,
|
||
|
|
either(
|
||
|
|
hexdig(s),
|
||
|
|
sequence(character(char_type('_')), hexdig(s))
|
||
|
|
)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& oct_int(const spec& s)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec&) {
|
||
|
|
const auto digit07 = []() {
|
||
|
|
return character_in_range(char_type('0'), char_type('7'));
|
||
|
|
};
|
||
|
|
return sequence(
|
||
|
|
literal("0o"),
|
||
|
|
digit07(),
|
||
|
|
repeat_at_least(0,
|
||
|
|
either(
|
||
|
|
digit07(),
|
||
|
|
sequence(character(char_type('_')), digit07())
|
||
|
|
)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(s);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& bin_int(const spec& s)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec&) {
|
||
|
|
const auto digit01 = []() {
|
||
|
|
return character_either("01");
|
||
|
|
};
|
||
|
|
return sequence(
|
||
|
|
literal("0b"),
|
||
|
|
digit01(),
|
||
|
|
repeat_at_least(0,
|
||
|
|
either(
|
||
|
|
digit01(),
|
||
|
|
sequence(character(char_type('_')), digit01())
|
||
|
|
)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(s);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE either const& integer(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return either(
|
||
|
|
hex_int(s),
|
||
|
|
oct_int(s),
|
||
|
|
bin_int(s),
|
||
|
|
dec_int(s)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Floating
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& zero_prefixable_int(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
digit(s),
|
||
|
|
repeat_at_least(0,
|
||
|
|
either(
|
||
|
|
digit(s),
|
||
|
|
sequence(character('_'), digit(s))
|
||
|
|
)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& fractional_part(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
character('.'),
|
||
|
|
zero_prefixable_int(s)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& exponent_part(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
character_either("eE"),
|
||
|
|
maybe(character_either("+-")),
|
||
|
|
zero_prefixable_int(s)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& hex_floating(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
// C99 hexfloat (%a)
|
||
|
|
// [+-]? 0x ( [0-9a-fA-F]*\.[0-9a-fA-F]+ | [0-9a-fA-F]+\.? ) [pP] [+-]? [0-9]+
|
||
|
|
|
||
|
|
// - 0x(int).(frac)p[+-](int)
|
||
|
|
// - 0x(int).p[+-](int)
|
||
|
|
// - 0x.(frac)p[+-](int)
|
||
|
|
// - 0x(int)p[+-](int)
|
||
|
|
|
||
|
|
return sequence(
|
||
|
|
maybe(character_either("+-")),
|
||
|
|
character('0'),
|
||
|
|
character_either("xX"),
|
||
|
|
either(
|
||
|
|
sequence(
|
||
|
|
repeat_at_least(0, hexdig(s)),
|
||
|
|
character('.'),
|
||
|
|
repeat_at_least(1, hexdig(s))
|
||
|
|
),
|
||
|
|
sequence(
|
||
|
|
repeat_at_least(1, hexdig(s)),
|
||
|
|
maybe(character('.'))
|
||
|
|
)
|
||
|
|
),
|
||
|
|
character_either("pP"),
|
||
|
|
maybe(character_either("+-")),
|
||
|
|
repeat_at_least(1, character_in_range('0', '9'))
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE either const& floating(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return either(
|
||
|
|
sequence(
|
||
|
|
dec_int(s),
|
||
|
|
either(
|
||
|
|
exponent_part(s),
|
||
|
|
sequence(fractional_part(s), maybe(exponent_part(s)))
|
||
|
|
)
|
||
|
|
),
|
||
|
|
sequence(
|
||
|
|
maybe(character_either("+-")),
|
||
|
|
either(literal("inf"), literal("nan"))
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Datetime
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& local_date(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
repeat_exact(4, digit(s)),
|
||
|
|
character('-'),
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
character('-'),
|
||
|
|
repeat_exact(2, digit(s))
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE sequence const& local_time(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
if(s.v1_1_0_make_seconds_optional)
|
||
|
|
{
|
||
|
|
return sequence(
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
character(':'),
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
maybe(sequence(
|
||
|
|
character(':'),
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
maybe(sequence(character('.'), repeat_at_least(1, digit(s))))
|
||
|
|
)));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return sequence(
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
character(':'),
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
character(':'),
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
maybe(sequence(character('.'), repeat_at_least(1, digit(s))))
|
||
|
|
);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE either const& time_offset(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return either(
|
||
|
|
character_either("zZ"),
|
||
|
|
sequence(character_either("+-"),
|
||
|
|
repeat_exact(2, digit(s)),
|
||
|
|
character(':'),
|
||
|
|
repeat_exact(2, digit(s))
|
||
|
|
)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE sequence const& full_time(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(local_time(s), time_offset(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE character_either const& time_delim(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec&) {
|
||
|
|
return character_either("Tt ");
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE sequence const& local_datetime(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(local_date(s), time_delim(s), local_time(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE sequence const& offset_datetime(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(local_date(s), time_delim(s), full_time(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// String
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& escaped_x2(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(character('x'), repeat_exact(2, hexdig(s)));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE sequence const& escaped_u4(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(character('u'), repeat_exact(4, hexdig(s)));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
TOML11_INLINE sequence const& escaped_U8(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(character('U'), repeat_exact(8, hexdig(s)));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& escaped(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
const auto escape_char = [&s] {
|
||
|
|
if(s.v1_1_0_add_escape_sequence_e)
|
||
|
|
{
|
||
|
|
return character_either("\"\\bfnrte");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return character_either("\"\\bfnrt");
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
const auto escape_seq = [&s, &escape_char] {
|
||
|
|
if(s.v1_1_0_add_escape_sequence_x)
|
||
|
|
{
|
||
|
|
return either(
|
||
|
|
escape_char(),
|
||
|
|
escaped_u4(s),
|
||
|
|
escaped_U8(s),
|
||
|
|
escaped_x2(s)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return either(
|
||
|
|
escape_char(),
|
||
|
|
escaped_u4(s),
|
||
|
|
escaped_U8(s)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
return sequence(character('\\'), escape_seq());
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE either const& basic_char(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
const auto basic_unescaped = [&s]() {
|
||
|
|
return either(
|
||
|
|
wschar(s),
|
||
|
|
character(0x21), // 22 is "
|
||
|
|
character_in_range(0x23, 0x5B), // 5C is backslash
|
||
|
|
character_in_range(0x5D, 0x7E), // 7F is DEL
|
||
|
|
non_ascii(s)
|
||
|
|
);
|
||
|
|
};
|
||
|
|
return either(basic_unescaped(), escaped(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& basic_string(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
character('"'),
|
||
|
|
repeat_at_least(0, basic_char(s)),
|
||
|
|
character('"')
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------
|
||
|
|
// multiline string
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& escaped_newline(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
character('\\'), ws(s), newline(s),
|
||
|
|
repeat_at_least(0, either(wschar(s), newline(s)))
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& ml_basic_string(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
const auto mlb_content = [&s]() {
|
||
|
|
return either(basic_char(s), newline(s), escaped_newline(s));
|
||
|
|
};
|
||
|
|
const auto mlb_quotes = []() {
|
||
|
|
return either(literal("\"\""), character('\"'));
|
||
|
|
};
|
||
|
|
|
||
|
|
return sequence(
|
||
|
|
literal("\"\"\""),
|
||
|
|
maybe(newline(s)),
|
||
|
|
repeat_at_least(0, mlb_content()),
|
||
|
|
repeat_at_least(0,
|
||
|
|
sequence(
|
||
|
|
mlb_quotes(),
|
||
|
|
repeat_at_least(1, mlb_content())
|
||
|
|
)
|
||
|
|
),
|
||
|
|
// XXX """ and mlb_quotes are intentionally reordered to avoid
|
||
|
|
// unexpected match of mlb_quotes
|
||
|
|
literal("\"\"\""),
|
||
|
|
maybe(mlb_quotes())
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------
|
||
|
|
// literal string
|
||
|
|
|
||
|
|
TOML11_INLINE either const& literal_char(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return either(
|
||
|
|
character (0x09),
|
||
|
|
character_in_range(0x20, 0x26),
|
||
|
|
character_in_range(0x28, 0x7E),
|
||
|
|
non_ascii(s)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& literal_string(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
character('\''),
|
||
|
|
repeat_at_least(0, literal_char(s)),
|
||
|
|
character('\'')
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& ml_literal_string(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
const auto mll_quotes = []() {
|
||
|
|
return either(literal("''"), character('\''));
|
||
|
|
};
|
||
|
|
const auto mll_content = [&s]() {
|
||
|
|
return either(literal_char(s), newline(s));
|
||
|
|
};
|
||
|
|
|
||
|
|
return sequence(
|
||
|
|
literal("'''"),
|
||
|
|
maybe(newline(s)),
|
||
|
|
repeat_at_least(0, mll_content()),
|
||
|
|
repeat_at_least(0, sequence(
|
||
|
|
mll_quotes(),
|
||
|
|
repeat_at_least(1, mll_content())
|
||
|
|
)
|
||
|
|
),
|
||
|
|
literal("'''"),
|
||
|
|
maybe(mll_quotes())
|
||
|
|
// XXX ''' and mll_quotes are intentionally reordered to avoid
|
||
|
|
// unexpected match of mll_quotes
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE either const& string(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return either(
|
||
|
|
ml_basic_string(s),
|
||
|
|
ml_literal_string(s),
|
||
|
|
basic_string(s),
|
||
|
|
literal_string(s)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Keys
|
||
|
|
|
||
|
|
// to keep `expected_chars` simple
|
||
|
|
TOML11_INLINE non_ascii_key_char::non_ascii_key_char(const spec& s) noexcept
|
||
|
|
{
|
||
|
|
assert(s.v1_1_0_allow_non_english_in_bare_keys);
|
||
|
|
(void)s; // for NDEBUG
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE std::uint32_t non_ascii_key_char::read_utf8(location& loc) const
|
||
|
|
{
|
||
|
|
// U+0000 ... U+0079 ; 0xxx_xxxx
|
||
|
|
// U+0080 ... U+07FF ; 110y_yyyx 10xx_xxxx;
|
||
|
|
// U+0800 ... U+FFFF ; 1110_yyyy 10yx_xxxx 10xx_xxxx
|
||
|
|
// U+010000 ... U+10FFFF; 1111_0yyy 10yy_xxxx 10xx_xxxx 10xx_xxxx
|
||
|
|
|
||
|
|
const unsigned char b1 = loc.current(); loc.advance(1);
|
||
|
|
if(b1 < 0x80)
|
||
|
|
{
|
||
|
|
return static_cast<std::uint32_t>(b1);
|
||
|
|
}
|
||
|
|
else if((b1 >> 5) == 6) // 0b110 == 6
|
||
|
|
{
|
||
|
|
const auto b2 = loc.current(); loc.advance(1);
|
||
|
|
|
||
|
|
const std::uint32_t c1 = b1 & ((1 << 5) - 1);
|
||
|
|
const std::uint32_t c2 = b2 & ((1 << 6) - 1);
|
||
|
|
const std::uint32_t codep = (c1 << 6) + c2;
|
||
|
|
|
||
|
|
if(codep < 0x80)
|
||
|
|
{
|
||
|
|
return 0xFFFFFFFF;
|
||
|
|
}
|
||
|
|
return codep;
|
||
|
|
}
|
||
|
|
else if((b1 >> 4) == 14) // 0b1110 == 14
|
||
|
|
{
|
||
|
|
const auto b2 = loc.current(); loc.advance(1); if(loc.eof()) {return 0xFFFFFFFF;}
|
||
|
|
const auto b3 = loc.current(); loc.advance(1);
|
||
|
|
|
||
|
|
const std::uint32_t c1 = b1 & ((1 << 4) - 1);
|
||
|
|
const std::uint32_t c2 = b2 & ((1 << 6) - 1);
|
||
|
|
const std::uint32_t c3 = b3 & ((1 << 6) - 1);
|
||
|
|
|
||
|
|
const std::uint32_t codep = (c1 << 12) + (c2 << 6) + c3;
|
||
|
|
if(codep < 0x800)
|
||
|
|
{
|
||
|
|
return 0xFFFFFFFF;
|
||
|
|
}
|
||
|
|
return codep;
|
||
|
|
}
|
||
|
|
else if((b1 >> 3) == 30) // 0b11110 == 30
|
||
|
|
{
|
||
|
|
const auto b2 = loc.current(); loc.advance(1); if(loc.eof()) {return 0xFFFFFFFF;}
|
||
|
|
const auto b3 = loc.current(); loc.advance(1); if(loc.eof()) {return 0xFFFFFFFF;}
|
||
|
|
const auto b4 = loc.current(); loc.advance(1);
|
||
|
|
|
||
|
|
const std::uint32_t c1 = b1 & ((1 << 3) - 1);
|
||
|
|
const std::uint32_t c2 = b2 & ((1 << 6) - 1);
|
||
|
|
const std::uint32_t c3 = b3 & ((1 << 6) - 1);
|
||
|
|
const std::uint32_t c4 = b4 & ((1 << 6) - 1);
|
||
|
|
const std::uint32_t codep = (c1 << 18) + (c2 << 12) + (c3 << 6) + c4;
|
||
|
|
|
||
|
|
if(codep < 0x10000)
|
||
|
|
{
|
||
|
|
return 0xFFFFFFFF;
|
||
|
|
}
|
||
|
|
return codep;
|
||
|
|
}
|
||
|
|
else // not a Unicode codepoint in UTF-8
|
||
|
|
{
|
||
|
|
return 0xFFFFFFFF;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE region non_ascii_key_char::scan(location& loc) const
|
||
|
|
{
|
||
|
|
if(loc.eof()) {return region{};}
|
||
|
|
|
||
|
|
const auto first = loc;
|
||
|
|
|
||
|
|
const auto cp = read_utf8(loc);
|
||
|
|
|
||
|
|
if(cp == 0xFFFFFFFF)
|
||
|
|
{
|
||
|
|
return region{};
|
||
|
|
}
|
||
|
|
|
||
|
|
// ALPHA / DIGIT / %x2D / %x5F ; a-z A-Z 0-9 - _
|
||
|
|
// / %xB2 / %xB3 / %xB9 / %xBC-BE ; superscript digits, fractions
|
||
|
|
// / %xC0-D6 / %xD8-F6 / %xF8-37D ; non-symbol chars in Latin block
|
||
|
|
// / %x37F-1FFF ; exclude GREEK QUESTION MARK, which is basically a semi-colon
|
||
|
|
// / %x200C-200D / %x203F-2040 ; from General Punctuation Block, include the two tie symbols and ZWNJ, ZWJ
|
||
|
|
// / %x2070-218F / %x2460-24FF ; include super-/subscripts, letterlike/numberlike forms, enclosed alphanumerics
|
||
|
|
// / %x2C00-2FEF / %x3001-D7FF ; skip arrows, math, box drawing etc, skip 2FF0-3000 ideographic up/down markers and spaces
|
||
|
|
// / %xF900-FDCF / %xFDF0-FFFD ; skip D800-DFFF surrogate block, E000-F8FF Private Use area, FDD0-FDEF intended for process-internal use (unicode)
|
||
|
|
// / %x10000-EFFFF ; all chars outside BMP range, excluding Private Use planes (F0000-10FFFF)
|
||
|
|
|
||
|
|
if(cp == 0xB2 || cp == 0xB3 || cp == 0xB9 || (0xBC <= cp && cp <= 0xBE) ||
|
||
|
|
(0xC0 <= cp && cp <= 0xD6 ) || (0xD8 <= cp && cp <= 0xF6) || (0xF8 <= cp && cp <= 0x37D) ||
|
||
|
|
(0x37F <= cp && cp <= 0x1FFF) ||
|
||
|
|
(0x200C <= cp && cp <= 0x200D) || (0x203F <= cp && cp <= 0x2040) ||
|
||
|
|
(0x2070 <= cp && cp <= 0x218F) || (0x2460 <= cp && cp <= 0x24FF) ||
|
||
|
|
(0x2C00 <= cp && cp <= 0x2FEF) || (0x3001 <= cp && cp <= 0xD7FF) ||
|
||
|
|
(0xF900 <= cp && cp <= 0xFDCF) || (0xFDF0 <= cp && cp <= 0xFFFD) ||
|
||
|
|
(0x10000 <= cp && cp <= 0xEFFFF) )
|
||
|
|
{
|
||
|
|
return region(first, loc);
|
||
|
|
}
|
||
|
|
loc = first;
|
||
|
|
return region{};
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE repeat_at_least const& unquoted_key(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
const auto keychar = [&s] {
|
||
|
|
if(s.v1_1_0_allow_non_english_in_bare_keys)
|
||
|
|
{
|
||
|
|
return either(alpha(s), digit(s), character{0x2D}, character{0x5F},
|
||
|
|
non_ascii_key_char(s));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return either(alpha(s), digit(s), character{0x2D}, character{0x5F});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return repeat_at_least(1, keychar());
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE either const& quoted_key(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return either(basic_string(s), literal_string(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE either const& simple_key(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return either(unquoted_key(s), quoted_key(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& dot_sep(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(ws(s), character('.'), ws(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& dotted_key(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(
|
||
|
|
simple_key(s),
|
||
|
|
repeat_at_least(1, sequence(dot_sep(s), simple_key(s)))
|
||
|
|
);
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& keyval_sep(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(ws(s), character('='), ws(s));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// Table key
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& std_table(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(character('['), ws(s), key(s), ws(s), character(']'));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
TOML11_INLINE sequence const& array_table(const spec& sp)
|
||
|
|
{
|
||
|
|
static thread_local auto cache = make_cache([](const spec& s) {
|
||
|
|
return sequence(literal("[["), ws(s), key(s), ws(s), literal("]]"));
|
||
|
|
});
|
||
|
|
return cache.at(sp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================================================================
|
||
|
|
// extension: null
|
||
|
|
|
||
|
|
TOML11_INLINE literal const& null_value(const spec&)
|
||
|
|
{
|
||
|
|
static thread_local literal cache("null");
|
||
|
|
return cache;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace syntax
|
||
|
|
} // namespace detail
|
||
|
|
} // TOML11_INLINE_VERSION_NAMESPACE
|
||
|
|
} // namespace toml
|
||
|
|
#endif // TOML11_SYNTAX_IMPL_HPP
|