mirror/tomlplusplus
1
0
Fork 0
mirror of https://github.com/marzer/tomlplusplus.git synced 2024-10-06 06:49:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

added TOML_CALLCONV config option

Browse Source
This commit is contained in:
Mark Gillard 2022-06-06 12:21:46 +03:00
parent 3f4acc7c32
commit 0f5d986df1
38 changed files with 970 additions and 747 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.clang-format
View File

@ -25,6 +25,7 @@ AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
AttributeMacros:
- TOML_ABSTRACT_BASE
- TOML_CALLCONV
- TOML_CLOSED_ENUM
- TOML_CLOSED_FLAGS_ENUM
- TOML_EMPTY_BASES

1
CHANGELOG.md
View File

@ -21,6 +21,7 @@ template:
#### Additions:
- Added value type deduction to `emplace()` methods
- Added `toml::path` utility type (#153, #156) (@jonestristand)
- Added config option `TOML_CALLCONV`
#### Changes:
- Relaxed cvref requirements of `is_homogeneous()`, `emplace()`, `emplace_back()`, `emplace_hint()`

1
README.md
View File

@ -186,6 +186,7 @@ won't need to mess with these at all, but if you do, set them before including t
| Option | Type | Description | Default |
|-----------------------------------|:--------------:|----------------------------------------------------------------------------------------------------------|------------------------|
| `TOML_ASSERT(expr)` | function macro | Sets the assert function used by the library. | `assert()` |
| `TOML_CALLCONV` | define | Calling convention to apply to all free/static functions in the library. | undefined |
| `TOML_CONFIG_HEADER` | string literal | Includes the given header file before the rest of the library. | undefined |
| `TOML_ENABLE_FORMATTERS` | boolean | Enables the formatters. Set to `0` if you don't need them to improve compile times and binary size. | `1` |
| `TOML_ENABLE_PARSER` | boolean | Enables the parser. Set to `0` if you don't need it to improve compile times and binary size. | `1` |

37
include/toml++/impl/array.h
View File

@ -123,61 +123,61 @@ TOML_IMPL_NAMESPACE_START
}
TOML_NODISCARD
friend array_iterator operator+(const array_iterator& lhs, ptrdiff_t rhs) noexcept
friend array_iterator TOML_CALLCONV operator+(const array_iterator& lhs, ptrdiff_t rhs) noexcept
{
return array_iterator{ lhs.iter_ + rhs };
}
TOML_NODISCARD
friend array_iterator operator+(ptrdiff_t lhs, const array_iterator& rhs) noexcept
friend array_iterator TOML_CALLCONV operator+(ptrdiff_t lhs, const array_iterator& rhs) noexcept
{
return array_iterator{ rhs.iter_ + lhs };
}
TOML_NODISCARD
friend array_iterator operator-(const array_iterator& lhs, ptrdiff_t rhs) noexcept
friend array_iterator TOML_CALLCONV operator-(const array_iterator& lhs, ptrdiff_t rhs) noexcept
{
return array_iterator{ lhs.iter_ - rhs };
}
TOML_PURE_INLINE_GETTER
friend ptrdiff_t operator-(const array_iterator& lhs, const array_iterator& rhs) noexcept
friend ptrdiff_t TOML_CALLCONV operator-(const array_iterator& lhs, const array_iterator& rhs) noexcept
{
return lhs.iter_ - rhs.iter_;
}
TOML_PURE_INLINE_GETTER
friend bool operator==(const array_iterator& lhs, const array_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator==(const array_iterator& lhs, const array_iterator& rhs) noexcept
{
return lhs.iter_ == rhs.iter_;
}
TOML_PURE_INLINE_GETTER
friend bool operator!=(const array_iterator& lhs, const array_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const array_iterator& lhs, const array_iterator& rhs) noexcept
{
return lhs.iter_ != rhs.iter_;
}
TOML_PURE_INLINE_GETTER
friend bool operator<(const array_iterator& lhs, const array_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator<(const array_iterator& lhs, const array_iterator& rhs) noexcept
{
return lhs.iter_ < rhs.iter_;
}
TOML_PURE_INLINE_GETTER
friend bool operator<=(const array_iterator& lhs, const array_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator<=(const array_iterator& lhs, const array_iterator& rhs) noexcept
{
return lhs.iter_ <= rhs.iter_;
}
TOML_PURE_INLINE_GETTER
friend bool operator>(const array_iterator& lhs, const array_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator>(const array_iterator& lhs, const array_iterator& rhs) noexcept
{
return lhs.iter_ > rhs.iter_;
}
TOML_PURE_INLINE_GETTER
friend bool operator>=(const array_iterator& lhs, const array_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator>=(const array_iterator& lhs, const array_iterator& rhs) noexcept
{
return lhs.iter_ >= rhs.iter_;
}
@ -872,7 +872,8 @@ TOML_NAMESPACE_START
// clang-format on
template <typename Func, typename Array>
static void do_for_each(Func&& visitor, Array&& arr) noexcept(for_each_is_nothrow<Func&&, Array&&>)
static void TOML_CALLCONV do_for_each(Func&& visitor,
Array&& arr) noexcept(for_each_is_nothrow<Func&&, Array&&>)
{
static_assert(can_for_each_any<Func&&, Array&&>,
"TOML array for_each visitors must be invocable for at least one of the toml::node "
@ -1628,11 +1629,11 @@ TOML_NAMESPACE_START
TOML_NODISCARD
TOML_EXPORTED_STATIC_FUNCTION
static bool equal(const array&, const array&) noexcept;
static bool TOML_CALLCONV equal(const array&, const array&) noexcept;
template <typename T>
TOML_NODISCARD
static bool equal_to_container(const array& lhs, const T& rhs) noexcept
static bool TOML_CALLCONV equal_to_container(const array& lhs, const T& rhs) noexcept
{
using element_type = std::remove_const_t<typename T::value_type>;
static_assert(impl::is_losslessly_convertible_to_native<element_type>,
@ -1667,7 +1668,7 @@ TOML_NAMESPACE_START
///
/// \returns True if the arrays contained the same elements.
TOML_NODISCARD
friend bool operator==(const array& lhs, const array& rhs) noexcept
friend bool TOML_CALLCONV operator==(const array& lhs, const array& rhs) noexcept
{
return equal(lhs, rhs);
}
@ -1679,7 +1680,7 @@ TOML_NAMESPACE_START
///
/// \returns True if the arrays did not contain the same elements.
TOML_NODISCARD
friend bool operator!=(const array& lhs, const array& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const array& lhs, const array& rhs) noexcept
{
return !equal(lhs, rhs);
}
@ -1687,7 +1688,7 @@ TOML_NAMESPACE_START
/// \brief Initializer list equality operator.
template <typename T>
TOML_NODISCARD
friend bool operator==(const array& lhs, const std::initializer_list<T>& rhs) noexcept
friend bool TOML_CALLCONV operator==(const array& lhs, const std::initializer_list<T>& rhs) noexcept
{
return equal_to_container(lhs, rhs);
}
@ -1696,7 +1697,7 @@ TOML_NAMESPACE_START
/// \brief Vector equality operator.
template <typename T>
TOML_NODISCARD
friend bool operator==(const array& lhs, const std::vector<T>& rhs) noexcept
friend bool TOML_CALLCONV operator==(const array& lhs, const std::vector<T>& rhs) noexcept
{
return equal_to_container(lhs, rhs);
}
@ -1709,7 +1710,7 @@ TOML_NAMESPACE_START
/// \brief Prints the array out to a stream as formatted TOML.
///
/// \availability This operator is only available when #TOML_ENABLE_FORMATTERS is enabled.
friend std::ostream& operator<<(std::ostream& lhs, const array& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const array& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;

2
include/toml++/impl/array.inl
View File

@ -350,7 +350,7 @@ TOML_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
bool array::equal(const array& lhs, const array& rhs) noexcept
bool TOML_CALLCONV array::equal(const array& lhs, const array& rhs) noexcept
{
if (&lhs == &rhs)
return true;

12
include/toml++/impl/at_path.h
View File

@ -48,14 +48,14 @@ TOML_NAMESPACE_START
/// \param path The "TOML path" to traverse.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
node_view<node> at_path(node & root, std::string_view path) noexcept;
node_view<node> TOML_CALLCONV at_path(node & root, std::string_view path) noexcept;
/// \brief Returns a const view of the node matching a fully-qualified "TOML path".
///
/// \see #toml::at_path(node&, std::string_view)
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
node_view<const node> at_path(const node& root, std::string_view path) noexcept;
node_view<const node> TOML_CALLCONV at_path(const node& root, std::string_view path) noexcept;
/// \brief Returns a view of the node matching a fully-qualified "TOML path".
///
@ -98,14 +98,14 @@ TOML_NAMESPACE_START
/// \param path The "TOML path" to traverse.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
node_view<node> at_path(node & root, const toml::path& path) noexcept;
node_view<node> TOML_CALLCONV at_path(node & root, const toml::path& path) noexcept;
/// \brief Returns a const view of the node matching a fully-qualified "TOML path".
///
/// \see #toml::at_path(node&, const toml::path& path)
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
node_view<const node> at_path(const node& root, const toml::path& path) noexcept;
node_view<const node> TOML_CALLCONV at_path(const node& root, const toml::path& path) noexcept;
#if TOML_ENABLE_WINDOWS_COMPAT
@ -116,7 +116,7 @@ TOML_NAMESPACE_START
/// \see #toml::at_path(node&, std::string_view)
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
node_view<node> at_path(node & root, std::wstring_view path);
node_view<node> TOML_CALLCONV at_path(node & root, std::wstring_view path);
/// \brief Returns a const view of the node matching a fully-qualified "TOML path".
///
@ -125,7 +125,7 @@ TOML_NAMESPACE_START
/// \see #toml::at_path(node&, std::string_view)
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
node_view<const node> at_path(const node& root, std::wstring_view path);
node_view<const node> TOML_CALLCONV at_path(const node& root, std::wstring_view path);
#endif
}

138
include/toml++/impl/at_path.inl
View File

@ -26,7 +26,7 @@ TOML_ENABLE_WARNINGS;
TOML_ANON_NAMESPACE_START
{
TOML_INTERNAL_LINKAGE
node* get_at_path(node & root, std::string_view path) noexcept
node* TOML_CALLCONV get_at_path(node & root, std::string_view path) noexcept
{
if (root.is_value()) // values don't have child nodes
return nullptr;
@ -46,33 +46,77 @@ TOML_ANON_NAMESPACE_START
if (!current_array)
return nullptr;
// get array index substring
const auto index_start = pos + 1u; // first position after '['
const auto index_end = path.find(']', index_start); // position of ']'
if (index_end == std::string_view::npos || index_end == index_start)
return nullptr;
auto index_str = path.substr(index_start, index_end - index_start);
// find first digit in index
size_t index_start = pos + 1u;
while (true)
{
if TOML_UNLIKELY(index_start >= path.length())
return nullptr;
// trim whitespace from either side of the index
const auto first_non_ws = index_str.find_first_not_of(" \t"sv);
const auto last_non_ws = index_str.find_last_not_of(" \t"sv);
if (first_non_ws == std::string_view::npos)
return nullptr;
TOML_ASSERT_ASSUME(last_non_ws != std::string_view::npos);
index_str = index_str.substr(first_non_ws, (last_non_ws - first_non_ws) + 1u);
const auto c = path[index_start];
if TOML_LIKELY(c >= '0' && c <= '9')
break;
else if (c == ' ' || c == '\t')
index_start++;
else
return nullptr;
}
TOML_ASSERT(path[index_start] >= '0');
TOML_ASSERT(path[index_start] <= '9');
// find end of index (first non-digit character)
size_t index_end = index_start + 1u;
while (true)
{
// if an array indexer is missing the trailing ']' at the end of the string, permissively accept it
if TOML_UNLIKELY(index_end >= path.length())
break;
const auto c = path[index_end];
if (c >= '0' && c <= '9')
index_end++;
else if (c == ']' || c == ' ' || c == '\t' || c == '.' || c == '[')
break;
else
return nullptr;
}
TOML_ASSERT(path[index_end - 1u] >= '0');
TOML_ASSERT(path[index_end - 1u] <= '9');
// move pos to after indexer (char after closing ']' or permissively EOL/subkey '.'/next opening '[')
pos = index_end;
while (true)
{
if TOML_UNLIKELY(pos >= path.length())
break;
const auto c = path[pos];
if (c == ']')
{
pos++;
break;
}
else if TOML_UNLIKELY(c == '.' || c == '[')
break;
else if (c == '\t' || c == '.')
pos++;
else
return nullptr;
}
// get array index substring
auto index_str = path.substr(index_start, index_end - index_start);
// parse the actual array index
size_t index;
if (index_str.length() == 1u && index_str[0] >= '0' && index_str[0] <= '9')
if (index_str.length() == 1u)
index = static_cast<size_t>(index_str[0] - '0');
else
{
#if TOML_INT_CHARCONV
auto fc_result = std::from_chars(index_str.data(), index_str.data() + index_str.length(), index);
// fail if unable to parse or entire index not parseable (otherwise would allow a[1bc] == a[1])
if (fc_result.ec != std::errc{} || fc_result.ptr != index_str.data() + index_str.length())
if (fc_result.ec != std::errc{})
return nullptr;
#else
@ -87,7 +131,6 @@ TOML_ANON_NAMESPACE_START
}
current = current_array->get(index);
pos = index_end + 1u;
prev_was_dot = false;
prev_was_array_indexer = true;
}
@ -116,13 +159,17 @@ TOML_ANON_NAMESPACE_START
prev_was_array_indexer = false;
}
// an errant closing ']'
else if TOML_UNLIKELY(path[pos] == ']')
return nullptr;
// some regular subkey
else
{
// get subkey text
const auto subkey_start = pos;
const auto subkey_len =
impl::min(path.find_first_of(".["sv, subkey_start + 1u), path.length()) - subkey_start;
impl::min(path.find_first_of(".[]"sv, subkey_start + 1u), path.length()) - subkey_start;
const auto subkey = path.substr(subkey_start, subkey_len);
// a regular subkey segment immediately after an array indexer is OK if it was all whitespace, e.g.:
@ -176,17 +223,29 @@ TOML_ANON_NAMESPACE_START
return current;
}
#if TOML_ENABLE_WINDOWS_COMPAT
TOML_INTERNAL_LINKAGE
node* get_at_path(node & root, const toml::path& path)
node* TOML_CALLCONV get_at_path(node & root, std::wstring_view path) noexcept
{
if (root.is_value())
return {};
if (auto tbl = root.as_table(); tbl && tbl->empty())
return {};
if (auto arr = root.as_array(); arr && arr->empty())
return {};
return get_at_path(root, impl::narrow(path));
}
#endif // TOML_ENABLE_WINDOWS_COMPAT
TOML_INTERNAL_LINKAGE
node* TOML_CALLCONV get_at_path(node & root, const toml::path& path)
{
if (root.is_value()) // values don't have child nodes
return nullptr;
// special check if table has a key that is an empty string, and the path is empty,
// return the node at that empty key.
if (path.size() == 0 && root.is_table() && root.as_table()->contains(""))
return root.as_table()->get("");
node* current = &root;
for (const auto& component : path)
@ -217,21 +276,6 @@ TOML_ANON_NAMESPACE_START
return current;
}
#if TOML_ENABLE_WINDOWS_COMPAT
TOML_INTERNAL_LINKAGE
node* get_at_path(node & root, std::wstring_view path) noexcept
{
if (auto tbl = root.as_table(); tbl && tbl->empty())
return {};
if (auto arr = root.as_array(); arr && arr->empty())
return {};
return get_at_path(root, impl::narrow(path));
}
#endif // TOML_ENABLE_WINDOWS_COMPAT
}
TOML_ANON_NAMESPACE_END;
@ -239,25 +283,25 @@ TOML_ANON_NAMESPACE_END;
TOML_NAMESPACE_START
{
TOML_EXTERNAL_LINKAGE
node_view<node> at_path(node & root, std::string_view path) noexcept
node_view<node> TOML_CALLCONV at_path(node & root, std::string_view path) noexcept
{
return node_view<node>{ TOML_ANON_NAMESPACE::get_at_path(root, path) };
}
TOML_EXTERNAL_LINKAGE
node_view<const node> at_path(const node& root, std::string_view path) noexcept
node_view<const node> TOML_CALLCONV at_path(const node& root, std::string_view path) noexcept
{
return node_view<const node>{ TOML_ANON_NAMESPACE::get_at_path(const_cast<node&>(root), path) };
}
TOML_EXTERNAL_LINKAGE
node_view<node> at_path(node & root, const toml::path& path) noexcept
node_view<node> TOML_CALLCONV at_path(node & root, const toml::path& path) noexcept
{
return node_view<node>{ TOML_ANON_NAMESPACE::get_at_path(root, path) };
}
TOML_EXTERNAL_LINKAGE
node_view<const node> at_path(const node& root, const toml::path& path) noexcept
node_view<const node> TOML_CALLCONV at_path(const node& root, const toml::path& path) noexcept
{
return node_view<const node>{ TOML_ANON_NAMESPACE::get_at_path(const_cast<node&>(root), path) };
}
@ -265,13 +309,13 @@ TOML_NAMESPACE_START
#if TOML_ENABLE_WINDOWS_COMPAT
TOML_EXTERNAL_LINKAGE
node_view<node> at_path(node & root, std::wstring_view path)
node_view<node> TOML_CALLCONV at_path(node & root, std::wstring_view path)
{
return node_view<node>{ TOML_ANON_NAMESPACE::get_at_path(root, path) };
}
TOML_EXTERNAL_LINKAGE
node_view<const node> at_path(const node& root, std::wstring_view path)
node_view<const node> TOML_CALLCONV at_path(const node& root, std::wstring_view path)
{
return node_view<const node>{ TOML_ANON_NAMESPACE::get_at_path(const_cast<node&>(root), path) };
}

60
include/toml++/impl/date_time.h
View File

@ -37,14 +37,14 @@ TOML_NAMESPACE_START
/// \brief Equality operator.
TOML_PURE_GETTER
friend constexpr bool operator==(const date& lhs, const date& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator==(const date& lhs, const date& rhs) noexcept
{
return lhs.year == rhs.year && lhs.month == rhs.month && lhs.day == rhs.day;
}
/// \brief Inequality operator.
TOML_PURE_GETTER
friend constexpr bool operator!=(const date& lhs, const date& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator!=(const date& lhs, const date& rhs) noexcept
{
return lhs.year != rhs.year || lhs.month != rhs.month || lhs.day != rhs.day;
}
@ -53,7 +53,7 @@ TOML_NAMESPACE_START
/// \cond
TOML_PURE_GETTER
static constexpr uint32_t pack(const date& d) noexcept
static constexpr uint32_t TOML_CALLCONV pack(const date& d) noexcept
{
return (static_cast<uint32_t>(d.year) << 16) | (static_cast<uint32_t>(d.month) << 8)
| static_cast<uint32_t>(d.day);
@ -64,28 +64,28 @@ TOML_NAMESPACE_START
public:
/// \brief Less-than operator.
TOML_PURE_GETTER
friend constexpr bool operator<(const date& lhs, const date& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<(const date& lhs, const date& rhs) noexcept
{
return pack(lhs) < pack(rhs);
}
/// \brief Less-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator<=(const date& lhs, const date& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<=(const date& lhs, const date& rhs) noexcept
{
return pack(lhs) <= pack(rhs);
}
/// \brief Greater-than operator.
TOML_PURE_GETTER
friend constexpr bool operator>(const date& lhs, const date& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>(const date& lhs, const date& rhs) noexcept
{
return pack(lhs) > pack(rhs);
}
/// \brief Greater-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator>=(const date& lhs, const date& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>=(const date& lhs, const date& rhs) noexcept
{
return pack(lhs) >= pack(rhs);
}
@ -99,7 +99,7 @@ TOML_NAMESPACE_START
/// \out
/// 1987-03-16
/// \eout
friend std::ostream& operator<<(std::ostream& lhs, const date& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const date& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;
@ -141,7 +141,7 @@ TOML_NAMESPACE_START
/// \brief Equality operator.
TOML_PURE_GETTER
friend constexpr bool operator==(const time& lhs, const time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator==(const time& lhs, const time& rhs) noexcept
{
return lhs.hour == rhs.hour && lhs.minute == rhs.minute && lhs.second == rhs.second
&& lhs.nanosecond == rhs.nanosecond;
@ -149,7 +149,7 @@ TOML_NAMESPACE_START
/// \brief Inequality operator.
TOML_PURE_GETTER
friend constexpr bool operator!=(const time& lhs, const time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator!=(const time& lhs, const time& rhs) noexcept
{
return !(lhs == rhs);
}
@ -158,7 +158,7 @@ TOML_NAMESPACE_START
/// \cond
TOML_PURE_GETTER
static constexpr uint64_t pack(const time& t) noexcept
static constexpr uint64_t TOML_CALLCONV pack(const time& t) noexcept
{
return static_cast<uint64_t>(t.hour) << 48 | static_cast<uint64_t>(t.minute) << 40
| static_cast<uint64_t>(t.second) << 32 | static_cast<uint64_t>(t.nanosecond);
@ -169,28 +169,28 @@ TOML_NAMESPACE_START
public:
/// \brief Less-than operator.
TOML_PURE_GETTER
friend constexpr bool operator<(const time& lhs, const time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<(const time& lhs, const time& rhs) noexcept
{
return pack(lhs) < pack(rhs);
}
/// \brief Less-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator<=(const time& lhs, const time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<=(const time& lhs, const time& rhs) noexcept
{
return pack(lhs) <= pack(rhs);
}
/// \brief Greater-than operator.
TOML_PURE_GETTER
friend constexpr bool operator>(const time& lhs, const time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>(const time& lhs, const time& rhs) noexcept
{
return pack(lhs) > pack(rhs);
}
/// \brief Greater-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator>=(const time& lhs, const time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>=(const time& lhs, const time& rhs) noexcept
{
return pack(lhs) >= pack(rhs);
}
@ -205,7 +205,7 @@ TOML_NAMESPACE_START
/// 10:20:34
/// 10:20:34.5
/// \eout
friend std::ostream& operator<<(std::ostream& lhs, const time& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const time& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;
@ -253,42 +253,42 @@ TOML_NAMESPACE_START
/// \brief Equality operator.
TOML_PURE_GETTER
friend constexpr bool operator==(time_offset lhs, time_offset rhs) noexcept
friend constexpr bool TOML_CALLCONV operator==(time_offset lhs, time_offset rhs) noexcept
{
return lhs.minutes == rhs.minutes;
}
/// \brief Inequality operator.
TOML_PURE_GETTER
friend constexpr bool operator!=(time_offset lhs, time_offset rhs) noexcept
friend constexpr bool TOML_CALLCONV operator!=(time_offset lhs, time_offset rhs) noexcept
{
return lhs.minutes != rhs.minutes;
}
/// \brief Less-than operator.
TOML_PURE_GETTER
friend constexpr bool operator<(time_offset lhs, time_offset rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<(time_offset lhs, time_offset rhs) noexcept
{
return lhs.minutes < rhs.minutes;
}
/// \brief Less-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator<=(time_offset lhs, time_offset rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<=(time_offset lhs, time_offset rhs) noexcept
{
return lhs.minutes <= rhs.minutes;
}
/// \brief Greater-than operator.
TOML_PURE_GETTER
friend constexpr bool operator>(time_offset lhs, time_offset rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>(time_offset lhs, time_offset rhs) noexcept
{
return lhs.minutes > rhs.minutes;
}
/// \brief Greater-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator>=(time_offset lhs, time_offset rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>=(time_offset lhs, time_offset rhs) noexcept
{
return lhs.minutes >= rhs.minutes;
}
@ -309,7 +309,7 @@ TOML_NAMESPACE_START
/// -01:30
/// -02:30
/// \eout
friend std::ostream& operator<<(std::ostream& lhs, const time_offset& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const time_offset& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;
@ -388,21 +388,21 @@ TOML_NAMESPACE_START
/// \brief Equality operator.
TOML_PURE_GETTER
friend constexpr bool operator==(const date_time& lhs, const date_time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator==(const date_time& lhs, const date_time& rhs) noexcept
{
return lhs.date == rhs.date && lhs.time == rhs.time && lhs.offset == rhs.offset;
}
/// \brief Inequality operator.
TOML_PURE_GETTER
friend constexpr bool operator!=(const date_time& lhs, const date_time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator!=(const date_time& lhs, const date_time& rhs) noexcept
{
return !(lhs == rhs);
}
/// \brief Less-than operator.
TOML_PURE_GETTER
friend constexpr bool operator<(const date_time& lhs, const date_time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<(const date_time& lhs, const date_time& rhs) noexcept
{
if (lhs.date != rhs.date)
return lhs.date < rhs.date;
@ -413,7 +413,7 @@ TOML_NAMESPACE_START
/// \brief Less-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator<=(const date_time& lhs, const date_time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<=(const date_time& lhs, const date_time& rhs) noexcept
{
if (lhs.date != rhs.date)
return lhs.date < rhs.date;
@ -424,14 +424,14 @@ TOML_NAMESPACE_START
/// \brief Greater-than operator.
TOML_PURE_GETTER
friend constexpr bool operator>(const date_time& lhs, const date_time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>(const date_time& lhs, const date_time& rhs) noexcept
{
return !(lhs <= rhs);
}
/// \brief Greater-than-or-equal-to operator.
TOML_PURE_GETTER
friend constexpr bool operator>=(const date_time& lhs, const date_time& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator>=(const date_time& lhs, const date_time& rhs) noexcept
{
return !(lhs < rhs);
}
@ -448,7 +448,7 @@ TOML_NAMESPACE_START
/// 1987-03-16T10:20:34-02:30
/// 1987-03-16T10:20:34Z
/// \eout
friend std::ostream& operator<<(std::ostream& lhs, const date_time& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const date_time& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;

18
include/toml++/impl/forward_declarations.h
View File

@ -250,15 +250,15 @@ TOML_NAMESPACE_START // abi namespace
/// Element [3] is: boolean
/// \eout
template <typename Char>
inline std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& lhs, node_type rhs)
inline std::basic_ostream<Char>& TOML_CALLCONV operator<<(std::basic_ostream<Char>& lhs, node_type rhs)
{
using underlying_t = std::underlying_type_t<node_type>;
const auto str = impl::node_type_friendly_names[static_cast<underlying_t>(rhs)];
if constexpr (std::is_same_v<Char, char>)
const auto str = impl::node_type_friendly_names[static_cast<std::underlying_type_t<node_type>>(rhs)];
using str_char_t = decltype(str)::value_type;
if constexpr (std::is_same_v<Char, str_char_t>)
return lhs << str;
else
{
if constexpr (sizeof(Char) == 1)
if constexpr (sizeof(Char) == sizeof(str_char_t))
return lhs << std::basic_string_view<Char>{ reinterpret_cast<const Char*>(str.data()), str.length() };
else
return lhs << str.data();
@ -1013,7 +1013,7 @@ TOML_IMPL_NAMESPACE_START
{
template <typename T>
TOML_CONST_INLINE_GETTER
constexpr std::underlying_type_t<T> unwrap_enum(T val) noexcept
constexpr std::underlying_type_t<T> TOML_CALLCONV unwrap_enum(T val) noexcept
{
return static_cast<std::underlying_type_t<T>>(val);
}
@ -1029,7 +1029,7 @@ TOML_IMPL_NAMESPACE_START
};
TOML_PURE_GETTER
inline fp_class fpclassify(const double& val) noexcept
inline fp_class TOML_CALLCONV fpclassify(const double& val) noexcept
{
static_assert(sizeof(uint64_t) == sizeof(double));
@ -1052,7 +1052,7 @@ TOML_IMPL_NAMESPACE_START
template <typename Iterator, typename T>
TOML_PURE_GETTER
inline auto find(Iterator start, Iterator end, const T& needle) noexcept //
inline auto TOML_CALLCONV find(Iterator start, Iterator end, const T& needle) noexcept //
->decltype(&(*start))
{
for (; start != end; start++)
@ -1063,7 +1063,7 @@ TOML_IMPL_NAMESPACE_START
template <typename T>
TOML_PURE_GETTER
constexpr const T& min(const T& a, const T& b) noexcept //
constexpr const T& TOML_CALLCONV min(const T& a, const T& b) noexcept //
{
return a < b ? a : b;
}

4
include/toml++/impl/json_formatter.h
View File

@ -121,7 +121,7 @@ TOML_NAMESPACE_START
#endif
/// \brief Prints the bound TOML object out to the stream as JSON.
friend std::ostream& operator<<(std::ostream& lhs, json_formatter& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, json_formatter& rhs)
{
rhs.attach(lhs);
rhs.print();
@ -130,7 +130,7 @@ TOML_NAMESPACE_START
}
/// \brief Prints the bound TOML object out to the stream as JSON (rvalue overload).
friend std::ostream& operator<<(std::ostream& lhs, json_formatter&& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, json_formatter&& rhs)
{
return lhs << rhs; // as lvalue
}

38
include/toml++/impl/key.h
View File

@ -161,126 +161,126 @@ TOML_NAMESPACE_START
/// \brief Returns true if `lhs.str() == rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator==(const key& lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator==(const key& lhs, const key& rhs) noexcept
{
return lhs.key_ == rhs.key_;
}
/// \brief Returns true if `lhs.str() != rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator!=(const key& lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const key& lhs, const key& rhs) noexcept
{
return lhs.key_ != rhs.key_;
}
/// \brief Returns true if `lhs.str() < rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator<(const key& lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator<(const key& lhs, const key& rhs) noexcept
{
return lhs.key_ < rhs.key_;
}
/// \brief Returns true if `lhs.str() <= rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator<=(const key& lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator<=(const key& lhs, const key& rhs) noexcept
{
return lhs.key_ <= rhs.key_;
}
/// \brief Returns true if `lhs.str() > rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator>(const key& lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator>(const key& lhs, const key& rhs) noexcept
{
return lhs.key_ > rhs.key_;
}
/// \brief Returns true if `lhs.str() >= rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator>=(const key& lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator>=(const key& lhs, const key& rhs) noexcept
{
return lhs.key_ >= rhs.key_;
}
/// \brief Returns true if `lhs.str() == rhs`.
TOML_PURE_INLINE_GETTER
friend bool operator==(const key& lhs, std::string_view rhs) noexcept
friend bool TOML_CALLCONV operator==(const key& lhs, std::string_view rhs) noexcept
{
return lhs.key_ == rhs;
}
/// \brief Returns true if `lhs.str() != rhs`.
TOML_PURE_INLINE_GETTER
friend bool operator!=(const key& lhs, std::string_view rhs) noexcept
friend bool TOML_CALLCONV operator!=(const key& lhs, std::string_view rhs) noexcept
{
return lhs.key_ != rhs;
}
/// \brief Returns true if `lhs.str() < rhs`.
TOML_PURE_INLINE_GETTER
friend bool operator<(const key& lhs, std::string_view rhs) noexcept
friend bool TOML_CALLCONV operator<(const key& lhs, std::string_view rhs) noexcept
{
return lhs.key_ < rhs;
}
/// \brief Returns true if `lhs.str() <= rhs`.
TOML_PURE_INLINE_GETTER
friend bool operator<=(const key& lhs, std::string_view rhs) noexcept
friend bool TOML_CALLCONV operator<=(const key& lhs, std::string_view rhs) noexcept
{
return lhs.key_ <= rhs;
}
/// \brief Returns true if `lhs.str() > rhs`.
TOML_PURE_INLINE_GETTER
friend bool operator>(const key& lhs, std::string_view rhs) noexcept
friend bool TOML_CALLCONV operator>(const key& lhs, std::string_view rhs) noexcept
{
return lhs.key_ > rhs;
}
/// \brief Returns true if `lhs.str() >= rhs`.
TOML_PURE_INLINE_GETTER
friend bool operator>=(const key& lhs, std::string_view rhs) noexcept
friend bool TOML_CALLCONV operator>=(const key& lhs, std::string_view rhs) noexcept
{
return lhs.key_ >= rhs;
}
/// \brief Returns true if `lhs == rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator==(std::string_view lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator==(std::string_view lhs, const key& rhs) noexcept
{
return lhs == rhs.key_;
}
/// \brief Returns true if `lhs != rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator!=(std::string_view lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator!=(std::string_view lhs, const key& rhs) noexcept
{
return lhs != rhs.key_;
}
/// \brief Returns true if `lhs < rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator<(std::string_view lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator<(std::string_view lhs, const key& rhs) noexcept
{
return lhs < rhs.key_;
}
/// \brief Returns true if `lhs <= rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator<=(std::string_view lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator<=(std::string_view lhs, const key& rhs) noexcept
{
return lhs <= rhs.key_;
}
/// \brief Returns true if `lhs > rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator>(std::string_view lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator>(std::string_view lhs, const key& rhs) noexcept
{
return lhs > rhs.key_;
}
/// \brief Returns true if `lhs >= rhs.str()`.
TOML_PURE_INLINE_GETTER
friend bool operator>=(std::string_view lhs, const key& rhs) noexcept
friend bool TOML_CALLCONV operator>=(std::string_view lhs, const key& rhs) noexcept
{
return lhs >= rhs.key_;
}
@ -313,7 +313,7 @@ TOML_NAMESPACE_START
/// @}
/// \brief Prints the key's underlying string out to the stream.
friend std::ostream& operator<<(std::ostream& lhs, const key& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const key& rhs)
{
impl::print_to_stream(lhs, rhs.key_);
return lhs;

8
include/toml++/impl/make_node.h
View File

@ -13,7 +13,7 @@ TOML_IMPL_NAMESPACE_START
template <typename T>
TOML_NODISCARD
TOML_ATTR(returns_nonnull)
auto* make_node_impl_specialized(T && val, [[maybe_unused]] value_flags flags)
auto* TOML_CALLCONV make_node_impl_specialized(T && val, [[maybe_unused]] value_flags flags)
{
using unwrapped_type = unwrap_node<remove_cvref<T>>;
static_assert(!std::is_same_v<unwrapped_type, node>);
@ -81,7 +81,7 @@ TOML_IMPL_NAMESPACE_START
template <typename T>
TOML_NODISCARD
auto* make_node_impl(T && val, value_flags flags = preserve_source_value_flags)
auto* TOML_CALLCONV make_node_impl(T && val, value_flags flags = preserve_source_value_flags)
{
using unwrapped_type = unwrap_node<remove_cvref<T>>;
if constexpr (std::is_same_v<unwrapped_type, node> || is_node_view<unwrapped_type>)
@ -104,7 +104,7 @@ TOML_IMPL_NAMESPACE_START
template <typename T>
TOML_NODISCARD
auto* make_node_impl(inserter<T> && val, value_flags flags = preserve_source_value_flags)
auto* TOML_CALLCONV make_node_impl(inserter<T> && val, value_flags flags = preserve_source_value_flags)
{
return make_node_impl(static_cast<T&&>(val.value), flags);
}
@ -129,7 +129,7 @@ TOML_IMPL_NAMESPACE_START
template <typename T>
TOML_NODISCARD
node_ptr make_node(T && val, value_flags flags = preserve_source_value_flags)
node_ptr TOML_CALLCONV make_node(T && val, value_flags flags = preserve_source_value_flags)
{
return node_ptr{ make_node_impl(static_cast<T&&>(val), flags) };
}

5
include/toml++/impl/node.h
View File

@ -43,7 +43,7 @@ TOML_NAMESPACE_START
template <typename T, typename N>
TOML_PURE_GETTER
static ref_type<T, N&&> do_ref(N&& n) noexcept
static ref_type<T, N&&> TOML_CALLCONV do_ref(N&& n) noexcept
{
using unwrapped_type = impl::unwrap_node<T>;
static_assert(toml::is_value<unwrapped_type> || toml::is_container<unwrapped_type>,
@ -795,7 +795,8 @@ TOML_NAMESPACE_START
using nonvoid = std::conditional_t<std::is_void_v<A>, B, A>;
template <typename Func, typename Node>
static decltype(auto) do_visit(Func&& visitor, Node&& n) noexcept(visit_is_nothrow<Func&&, Node&&>)
static decltype(auto) TOML_CALLCONV do_visit(Func&& visitor,
Node&& n) noexcept(visit_is_nothrow<Func&&, Node&&>)
{
static_assert(can_visit_any<Func&&, Node&&>,
"TOML node visitors must be invocable for at least one of the toml::node "

2
include/toml++/impl/node.inl
View File

@ -104,7 +104,7 @@ TOML_NAMESPACE_END;
TOML_IMPL_NAMESPACE_START
{
TOML_EXTERNAL_LINKAGE
bool node_deep_equality(const node* lhs, const node* rhs) noexcept
bool TOML_CALLCONV node_deep_equality(const node* lhs, const node* rhs) noexcept
{
// both same or both null
if (lhs == rhs)

21
include/toml++/impl/node_view.h
View File

@ -595,7 +595,7 @@ TOML_NAMESPACE_START
/// \brief Returns true if the two views refer to nodes of the same type and value.
template <typename T>
TOML_PURE_GETTER
friend bool operator==(const node_view& lhs, const node_view<T>& rhs) noexcept
friend bool TOML_CALLCONV operator==(const node_view& lhs, const node_view<T>& rhs) noexcept
{
return impl::node_deep_equality(lhs.node_, rhs.node_);
}
@ -603,14 +603,14 @@ TOML_NAMESPACE_START
/// \brief Returns true if the two views do not refer to nodes of the same type and value.
template <typename T>
TOML_PURE_GETTER
friend bool operator!=(const node_view& lhs, const node_view<T>& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const node_view& lhs, const node_view<T>& rhs) noexcept
{
return !impl::node_deep_equality(lhs.node_, rhs.node_);
}
/// \brief Returns true if the viewed node is a table with the same contents as RHS.
TOML_NODISCARD
friend bool operator==(const node_view& lhs, const table& rhs) noexcept
friend bool TOML_CALLCONV operator==(const node_view& lhs, const table& rhs) noexcept
{
if (lhs.node_ == &rhs)
return true;
@ -621,7 +621,7 @@ TOML_NAMESPACE_START
/// \brief Returns true if the viewed node is an array with the same contents as RHS.
TOML_NODISCARD
friend bool operator==(const node_view& lhs, const array& rhs) noexcept
friend bool TOML_CALLCONV operator==(const node_view& lhs, const array& rhs) noexcept
{
if (lhs.node_ == &rhs)
return true;
@ -633,7 +633,7 @@ TOML_NAMESPACE_START
/// \brief Returns true if the viewed node is a value with the same value as RHS.
template <typename T>
TOML_NODISCARD
friend bool operator==(const node_view& lhs, const toml::value<T>& rhs) noexcept
friend bool TOML_CALLCONV operator==(const node_view& lhs, const toml::value<T>& rhs) noexcept
{
if (lhs.node_ == &rhs)
return true;
@ -645,7 +645,7 @@ TOML_NAMESPACE_START
/// \brief Returns true if the viewed node is a value with the same value as RHS.
TOML_CONSTRAINED_TEMPLATE(impl::is_losslessly_convertible_to_native<T>, typename T)
TOML_NODISCARD
friend bool operator==(const node_view& lhs, const T& rhs) noexcept(!impl::is_wide_string<T>)
friend bool TOML_CALLCONV operator==(const node_view& lhs, const T& rhs) noexcept(!impl::is_wide_string<T>)
{
static_assert(!impl::is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
"Comparison with wide-character strings is only "
@ -673,8 +673,8 @@ TOML_NAMESPACE_START
/// \brief Returns true if the viewed node is an array with the same contents as the RHS initializer list.
template <typename T>
TOML_NODISCARD
friend bool operator==(const node_view& lhs,
const std::initializer_list<T>& rhs) noexcept(!impl::is_wide_string<T>)
friend bool TOML_CALLCONV operator==(const node_view& lhs,
const std::initializer_list<T>& rhs) noexcept(!impl::is_wide_string<T>)
{
const auto arr = lhs.as<array>();
return arr && *arr == rhs;
@ -684,7 +684,8 @@ TOML_NAMESPACE_START
/// \brief Returns true if the viewed node is an array with the same contents as the RHS vector.
template <typename T>
TOML_NODISCARD
friend bool operator==(const node_view& lhs, const std::vector<T>& rhs) noexcept(!impl::is_wide_string<T>)
friend bool TOML_CALLCONV operator==(const node_view& lhs,
const std::vector<T>& rhs) noexcept(!impl::is_wide_string<T>)
{
const auto arr = lhs.as<array>();
return arr && *arr == rhs;
@ -792,7 +793,7 @@ TOML_NAMESPACE_START
/// \brief Prints the viewed node out to a stream.
///
/// \availability This operator is only available when #TOML_ENABLE_FORMATTERS is enabled.
friend std::ostream& operator<<(std::ostream& os, const node_view& nv)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& os, const node_view& nv)
{
if (nv.node_)
nv.node_->visit([&os](const auto& n) { os << n; });

2
include/toml++/impl/parse_error.h
View File

@ -119,7 +119,7 @@ TOML_NAMESPACE_START
/// \param rhs The parse_error.
///
/// \returns The input stream.
friend std::ostream& operator<<(std::ostream& lhs, const parse_error& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const parse_error& rhs)
{
impl::print_to_stream(lhs, rhs.description());
impl::print_to_stream(lhs, "\n\t(error occurred at "sv);

12
include/toml++/impl/parse_result.h
View File

@ -54,21 +54,21 @@ TOML_NAMESPACE_START
private:
struct storage_t
{
static constexpr size_t size_ =
static constexpr size_t size =
(sizeof(toml::table) < sizeof(parse_error) ? sizeof(parse_error) : sizeof(toml::table));
static constexpr size_t align_ =
static constexpr size_t align =
(alignof(toml::table) < alignof(parse_error) ? alignof(parse_error) : alignof(toml::table));
alignas(align_) unsigned char bytes[size_];
alignas(align) unsigned char bytes[size];
};
mutable storage_t storage_;
alignas(storage_t::align) mutable storage_t storage_;
bool err_;
template <typename Type>
TOML_NODISCARD
TOML_ALWAYS_INLINE
static Type* get_as(storage_t& s) noexcept
static Type* TOML_CALLCONV get_as(storage_t& s) noexcept
{
return TOML_LAUNDER(reinterpret_cast<Type*>(s.bytes));
}
@ -439,7 +439,7 @@ TOML_NAMESPACE_START
/// \brief Prints the held error or table object out to a text stream.
///
/// \availability This operator is only available when #TOML_ENABLE_FORMATTERS is enabled.
friend std::ostream& operator<<(std::ostream& os, const parse_result& result)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& os, const parse_result& result)
{
return result.err_ ? (os << result.error()) : (os << result.table());
}

30
include/toml++/impl/parser.h
View File

@ -37,7 +37,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::string_view doc, std::string_view source_path = {});
parse_result TOML_CALLCONV parse(std::string_view doc, std::string_view source_path = {});
/// \brief Parses a TOML document from a string view.
///
@ -61,7 +61,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::string_view doc, std::string && source_path);
parse_result TOML_CALLCONV parse(std::string_view doc, std::string && source_path);
/// \brief Parses a TOML document from a file.
///
@ -80,7 +80,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse_file(std::string_view file_path);
parse_result TOML_CALLCONV parse_file(std::string_view file_path);
#if TOML_HAS_CHAR8
@ -106,7 +106,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::u8string_view doc, std::string_view source_path = {});
parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string_view source_path = {});
/// \brief Parses a TOML document from a char8_t string view.
///
@ -130,7 +130,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::u8string_view doc, std::string && source_path);
parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string && source_path);
/// \brief Parses a TOML document from a file.
///
@ -149,7 +149,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse_file(std::u8string_view file_path);
parse_result TOML_CALLCONV parse_file(std::u8string_view file_path);
#endif // TOML_HAS_CHAR8
@ -179,7 +179,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::string_view doc, std::wstring_view source_path);
parse_result TOML_CALLCONV parse(std::string_view doc, std::wstring_view source_path);
/// \brief Parses a TOML document from a stream.
///
@ -208,7 +208,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::istream & doc, std::wstring_view source_path);
parse_result TOML_CALLCONV parse(std::istream & doc, std::wstring_view source_path);
/// \brief Parses a TOML document from a file.
///
@ -229,7 +229,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse_file(std::wstring_view file_path);
parse_result TOML_CALLCONV parse_file(std::wstring_view file_path);
#endif // TOML_ENABLE_WINDOWS_COMPAT
@ -259,7 +259,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::u8string_view doc, std::wstring_view source_path);
parse_result TOML_CALLCONV parse(std::u8string_view doc, std::wstring_view source_path);
#endif // TOML_HAS_CHAR8 && TOML_ENABLE_WINDOWS_COMPAT
@ -288,7 +288,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::istream & doc, std::string_view source_path = {});
parse_result TOML_CALLCONV parse(std::istream & doc, std::string_view source_path = {});
/// \brief Parses a TOML document from a stream.
///
@ -315,7 +315,7 @@ TOML_NAMESPACE_START
/// A toml::parse_result.
TOML_NODISCARD
TOML_EXPORTED_FREE_FUNCTION
parse_result parse(std::istream & doc, std::string && source_path);
parse_result TOML_CALLCONV parse(std::istream & doc, std::string && source_path);
TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
@ -344,7 +344,8 @@ TOML_NAMESPACE_START
/// \conditional_return{Without exceptions}
/// A toml::parse_result.
TOML_NODISCARD
inline parse_result operator"" _toml(const char* str, size_t len)
TOML_ALWAYS_INLINE
parse_result TOML_CALLCONV operator"" _toml(const char* str, size_t len)
{
return parse(std::string_view{ str, len });
}
@ -372,7 +373,8 @@ TOML_NAMESPACE_START
/// \conditional_return{Without exceptions}
/// A toml::parse_result.
TOML_NODISCARD
inline parse_result operator"" _toml(const char8_t* str, size_t len)
TOML_ALWAYS_INLINE
parse_result TOML_CALLCONV operator"" _toml(const char8_t* str, size_t len)
{
return parse(std::u8string_view{ str, len });
}

32
include/toml++/impl/parser.inl
View File

@ -608,7 +608,7 @@ TOML_ANON_NAMESPACE_START
template <typename... T>
TOML_CONST_GETTER
TOML_INTERNAL_LINKAGE
constexpr bool is_match(char32_t codepoint, T... vals) noexcept
constexpr bool TOML_CALLCONV is_match(char32_t codepoint, T... vals) noexcept
{
static_assert((std::is_same_v<char32_t, T> && ...));
return ((codepoint == vals) || ...);
@ -3464,7 +3464,7 @@ TOML_IMPL_NAMESPACE_START
current_table->source_.end = eof_pos;
}
static void update_region_ends(node& nde) noexcept
static void TOML_CALLCONV update_region_ends(node& nde) noexcept
{
const auto type = nde.type();
if (type > node_type::array)
@ -3729,14 +3729,14 @@ TOML_ANON_NAMESPACE_START
{
TOML_NODISCARD
TOML_INTERNAL_LINKAGE
parse_result do_parse(utf8_reader_interface && reader)
parse_result TOML_CALLCONV do_parse(utf8_reader_interface && reader)
{
return impl::parser{ std::move(reader) };
}
TOML_NODISCARD
TOML_INTERNAL_LINKAGE
parse_result do_parse_file(std::string_view file_path)
parse_result TOML_CALLCONV do_parse_file(std::string_view file_path)
{
#if TOML_EXCEPTIONS
#define TOML_PARSE_FILE_ERROR(msg, path) \
@ -3792,31 +3792,31 @@ TOML_NAMESPACE_START
TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, ex, noex);
TOML_EXTERNAL_LINKAGE
parse_result parse(std::string_view doc, std::string_view source_path)
parse_result TOML_CALLCONV parse(std::string_view doc, std::string_view source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, source_path });
}
TOML_EXTERNAL_LINKAGE
parse_result parse(std::string_view doc, std::string && source_path)
parse_result TOML_CALLCONV parse(std::string_view doc, std::string && source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, std::move(source_path) });
}
TOML_EXTERNAL_LINKAGE
parse_result parse(std::istream & doc, std::string_view source_path)
parse_result TOML_CALLCONV parse(std::istream & doc, std::string_view source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, source_path });
}
TOML_EXTERNAL_LINKAGE
parse_result parse(std::istream & doc, std::string && source_path)
parse_result TOML_CALLCONV parse(std::istream & doc, std::string && source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, std::move(source_path) });
}
TOML_EXTERNAL_LINKAGE
parse_result parse_file(std::string_view file_path)
parse_result TOML_CALLCONV parse_file(std::string_view file_path)
{
return TOML_ANON_NAMESPACE::do_parse_file(file_path);
}
@ -3824,19 +3824,19 @@ TOML_NAMESPACE_START
#if TOML_HAS_CHAR8
TOML_EXTERNAL_LINKAGE
parse_result parse(std::u8string_view doc, std::string_view source_path)
parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string_view source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, source_path });
}
TOML_EXTERNAL_LINKAGE
parse_result parse(std::u8string_view doc, std::string && source_path)
parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string && source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, std::move(source_path) });
}
TOML_EXTERNAL_LINKAGE
parse_result parse_file(std::u8string_view file_path)
parse_result TOML_CALLCONV parse_file(std::u8string_view file_path)
{
std::string file_path_str;
file_path_str.resize(file_path.length());
@ -3849,19 +3849,19 @@ TOML_NAMESPACE_START
#if TOML_ENABLE_WINDOWS_COMPAT
TOML_EXTERNAL_LINKAGE
parse_result parse(std::string_view doc, std::wstring_view source_path)
parse_result TOML_CALLCONV parse(std::string_view doc, std::wstring_view source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, impl::narrow(source_path) });
}
TOML_EXTERNAL_LINKAGE
parse_result parse(std::istream & doc, std::wstring_view source_path)
parse_result TOML_CALLCONV parse(std::istream & doc, std::wstring_view source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, impl::narrow(source_path) });
}
TOML_EXTERNAL_LINKAGE
parse_result parse_file(std::wstring_view file_path)
parse_result TOML_CALLCONV parse_file(std::wstring_view file_path)
{
return TOML_ANON_NAMESPACE::do_parse_file(impl::narrow(file_path));
}
@ -3871,7 +3871,7 @@ TOML_NAMESPACE_START
#if TOML_HAS_CHAR8 && TOML_ENABLE_WINDOWS_COMPAT
TOML_EXTERNAL_LINKAGE
parse_result parse(std::u8string_view doc, std::wstring_view source_path)
parse_result TOML_CALLCONV parse(std::u8string_view doc, std::wstring_view source_path)
{
return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, impl::narrow(source_path) });
}

51
include/toml++/impl/path.h
View File

@ -33,20 +33,20 @@ TOML_NAMESPACE_START
TOML_PURE_GETTER
TOML_EXPORTED_STATIC_FUNCTION
static bool equal(const path_component&, const path_component&) noexcept;
static bool TOML_CALLCONV equal(const path_component&, const path_component&) noexcept;
/// \endcond
public:
/// \brief Returns true if two path components represent the same key or array index.
TOML_PURE_INLINE_GETTER
friend bool operator==(const path_component& lhs, const path_component& rhs) noexcept
friend bool TOML_CALLCONV operator==(const path_component& lhs, const path_component& rhs) noexcept
{
return equal(lhs, rhs);
}
/// \brief Returns true if two path components do not represent the same key or array index.
TOML_PURE_INLINE_GETTER
friend bool operator!=(const path_component& lhs, const path_component& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const path_component& lhs, const path_component& rhs) noexcept
{
return !equal(lhs, rhs);
}
@ -78,14 +78,14 @@ TOML_NAMESPACE_START
std::vector<path_component> components_;
static bool parse_into(std::string_view, std::vector<path_component>&);
static bool TOML_CALLCONV parse_into(std::string_view, std::vector<path_component>&);
TOML_EXPORTED_MEMBER_FUNCTION
void print_to(std::ostream&) const;
TOML_PURE_GETTER
TOML_EXPORTED_STATIC_FUNCTION
static bool equal(const path&, const path&) noexcept;
static bool TOML_CALLCONV equal(const path&, const path&) noexcept;
/// \endcond
@ -224,7 +224,7 @@ TOML_NAMESPACE_START
/// \brief Appends another path onto the end of this one.
TOML_EXPORTED_MEMBER_FUNCTION
path& operator+=(path&&) noexcept;
path& operator+=(path&&);
/// \brief Parses a path and appends it onto the end of this one.
TOML_EXPORTED_MEMBER_FUNCTION
@ -249,7 +249,7 @@ TOML_NAMESPACE_START
/// \brief Appends another path onto the end of this one.
TOML_ALWAYS_INLINE
path& append(path&& p) noexcept
path& append(path&& p)
{
return *this += std::move(p);
}
@ -308,7 +308,7 @@ TOML_NAMESPACE_START
/// \brief Concatenates two paths.
TOML_NODISCARD
friend path operator+(const path& lhs, const path& rhs)
friend path TOML_CALLCONV operator+(const path& lhs, const path& rhs)
{
path result = lhs;
result += rhs;
@ -317,7 +317,7 @@ TOML_NAMESPACE_START
/// \brief Concatenates two paths.
TOML_NODISCARD
friend path operator+(const path& lhs, std::string_view rhs)
friend path TOML_CALLCONV operator+(const path& lhs, std::string_view rhs)
{
path result = lhs;
result += rhs;
@ -326,7 +326,7 @@ TOML_NAMESPACE_START
/// \brief Concatenates two paths.
TOML_NODISCARD
friend path operator+(std::string_view lhs, const path& rhs)
friend path TOML_CALLCONV operator+(std::string_view lhs, const path& rhs)
{
path result = rhs;
result.prepend(lhs);
@ -339,7 +339,7 @@ TOML_NAMESPACE_START
///
/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
TOML_NODISCARD
friend path operator+(const path& lhs, std::wstring_view rhs)
friend path TOML_CALLCONV operator+(const path& lhs, std::wstring_view rhs)
{
path result = lhs;
result += rhs;
@ -350,7 +350,7 @@ TOML_NAMESPACE_START
///
/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
TOML_NODISCARD
friend path operator+(std::wstring_view lhs, const path& rhs)
friend path TOML_CALLCONV operator+(std::wstring_view lhs, const path& rhs)
{
path result = rhs;
result.prepend(lhs);
@ -366,7 +366,7 @@ TOML_NAMESPACE_START
/// \brief Prints the string representation of a #toml::path out to a stream.
TOML_ALWAYS_INLINE
friend std::ostream& operator<<(std::ostream& os, const path& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& os, const path& rhs)
{
rhs.print_to(os);
return os;
@ -414,7 +414,7 @@ TOML_NAMESPACE_START
/// \brief Returns whether two paths are the same.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator==(const path& lhs, const path& rhs) noexcept
friend bool TOML_CALLCONV operator==(const path& lhs, const path& rhs) noexcept
{
return equal(lhs, rhs);
}
@ -422,7 +422,7 @@ TOML_NAMESPACE_START
/// \brief Returns whether two paths are not the same.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator!=(const path& lhs, const path& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const path& lhs, const path& rhs) noexcept
{
return !equal(lhs, rhs);
}
@ -430,7 +430,7 @@ TOML_NAMESPACE_START
/// \brief Returns whether two paths are the same.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator==(const path& lhs, std::string_view rhs)
friend bool TOML_CALLCONV operator==(const path& lhs, std::string_view rhs)
{
return lhs == path{ rhs };
}
@ -438,7 +438,7 @@ TOML_NAMESPACE_START
/// \brief Returns whether two paths are the same.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator==(std::string_view lhs, const path& rhs)
friend bool TOML_CALLCONV operator==(std::string_view lhs, const path& rhs)
{
return rhs == lhs;
}
@ -446,7 +446,7 @@ TOML_NAMESPACE_START
/// \brief Returns whether two paths are not the same.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator!=(const path& lhs, std::string_view rhs)
friend bool TOML_CALLCONV operator!=(const path& lhs, std::string_view rhs)
{
return lhs != path{ rhs };
}
@ -454,7 +454,7 @@ TOML_NAMESPACE_START
/// \brief Returns whether two paths are not the same.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator!=(std::string_view lhs, const path& rhs)
friend bool TOML_CALLCONV operator!=(std::string_view lhs, const path& rhs)
{
return rhs != lhs;
}
@ -466,7 +466,7 @@ TOML_NAMESPACE_START
/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator==(const path& lhs, std::wstring_view rhs)
friend bool TOML_CALLCONV operator==(const path& lhs, std::wstring_view rhs)
{
return lhs == path{ rhs };
}
@ -476,7 +476,7 @@ TOML_NAMESPACE_START
/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator==(std::wstring_view lhs, const path& rhs)
friend bool TOML_CALLCONV operator==(std::wstring_view lhs, const path& rhs)
{
return rhs == lhs;
}
@ -486,7 +486,7 @@ TOML_NAMESPACE_START
/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator!=(const path& lhs, std::wstring_view rhs)
friend bool TOML_CALLCONV operator!=(const path& lhs, std::wstring_view rhs)
{
return lhs != path{ rhs };
}
@ -496,7 +496,7 @@ TOML_NAMESPACE_START
/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
TOML_NODISCARD
TOML_ALWAYS_INLINE
friend bool operator!=(std::wstring_view lhs, const path& rhs)
friend bool TOML_CALLCONV operator!=(std::wstring_view lhs, const path& rhs)
{
return rhs != lhs;
}
@ -576,9 +576,10 @@ TOML_NAMESPACE_START
///
/// \returns A #toml::path generated from the string literal.
TOML_NODISCARD
inline toml::path operator"" _tpath(const char* str, size_t len)
TOML_ALWAYS_INLINE
path TOML_CALLCONV operator"" _tpath(const char* str, size_t len)
{
return toml::path(std::string_view{ str, len });
return path(std::string_view{ str, len });
}
}
}

93
include/toml++/impl/path.inl
View File

@ -29,7 +29,7 @@ TOML_ENABLE_WARNINGS;
TOML_NAMESPACE_START
{
TOML_EXTERNAL_LINKAGE
bool path_component::equal(const path_component& lhs, const path_component& rhs) noexcept
bool TOML_CALLCONV path_component::equal(const path_component& lhs, const path_component& rhs) noexcept
{
return lhs.type == rhs.type && lhs.value == rhs.value;
}
@ -43,7 +43,7 @@ TOML_NAMESPACE_END;
TOML_NAMESPACE_START
{
TOML_EXTERNAL_LINKAGE
bool path::parse_into(std::string_view path_str, std::vector<path_component> & components)
bool TOML_CALLCONV path::parse_into(std::string_view path_str, std::vector<path_component> & components)
{
// a blank string is a valid path; it's just one component representing the "" key
if (path_str.empty())
@ -70,37 +70,77 @@ TOML_NAMESPACE_START
// start of an array indexer
if (path_str[pos] == '[')
{
// get array index substring
const auto index_start = pos + 1u; // first position after '['
const auto index_end = path_str.find(']', index_start); // position of ']'
if (index_end == std::string_view::npos || index_end == index_start) // nothing in brackets, error
// find first digit in index
size_t index_start = pos + 1u;
while (true)
{
return parse_failed();
}
auto index_str = std::string_view(&path_str[index_start], index_end - index_start);
if TOML_UNLIKELY(index_start >= path_str.length())
return parse_failed();
// trim whitespace from either side of the index
const auto first_non_ws = index_str.find_first_not_of(" \t"sv);
const auto last_non_ws = index_str.find_last_not_of(" \t"sv);
if (first_non_ws == std::string_view::npos)
{
return parse_failed();
const auto c = path_str[index_start];
if TOML_LIKELY(c >= '0' && c <= '9')
break;
else if (c == ' ' || c == '\t')
index_start++;
else
return parse_failed();
}
TOML_ASSERT_ASSUME(last_non_ws != std::string_view::npos);
index_str = index_str.substr(first_non_ws, (last_non_ws - first_non_ws) + 1u);
TOML_ASSERT(path_str[index_start] >= '0');
TOML_ASSERT(path_str[index_start] <= '9');
// find end of index (first non-digit character)
size_t index_end = index_start + 1u;
while (true)
{
// if an array indexer is missing the trailing ']' at the end of the string, permissively accept it
if TOML_UNLIKELY(index_end >= path_str.length())
break;
const auto c = path_str[index_end];
if (c >= '0' && c <= '9')
index_end++;
else if (c == ']' || c == ' ' || c == '\t' || c == '.' || c == '[')
break;
else
return parse_failed();
}
TOML_ASSERT(path_str[index_end - 1u] >= '0');
TOML_ASSERT(path_str[index_end - 1u] <= '9');
// move pos to after indexer (char after closing ']' or permissively EOL/subkey '.'/next opening '[')
pos = index_end;
while (true)
{
if TOML_UNLIKELY(pos >= path_str.length())
break;
const auto c = path_str[pos];
if (c == ']')
{
pos++;
break;
}
else if TOML_UNLIKELY(c == '.' || c == '[')
break;
else if (c == '\t' || c == '.')
pos++;
else
return parse_failed();
}
// get array index substring
auto index_str = path_str.substr(index_start, index_end - index_start);
// parse the actual array index to an integer type
size_t index;
if (index_str.length() == 1u && index_str[0] >= '0' && index_str[0] <= '9')
if (index_str.length() == 1u)
index = static_cast<size_t>(index_str[0] - '0');
else
{
#if TOML_INT_CHARCONV
auto fc_result = std::from_chars(index_str.data(), index_str.data() + index_str.length(), index);
// fail if unable to parse or entire index not parseable (otherwise would allow a[1bc] == a[1])
if (fc_result.ec != std::errc{} || fc_result.ptr != index_str.data() + index_str.length())
if (fc_result.ec != std::errc{})
{
return parse_failed();
}
@ -118,7 +158,6 @@ TOML_NAMESPACE_START
#endif
}
pos = index_end + 1u;
prev_was_dot = false;
prev_was_array_indexer = true;
@ -145,12 +184,16 @@ TOML_NAMESPACE_START
prev_was_array_indexer = false;
}
// an errant closing ']'
else if TOML_UNLIKELY(path_str[pos] == ']')
return parse_failed();
// some regular subkey
else
{
const auto subkey_start = pos;
const auto subkey_len =
impl::min(path_str.find_first_of(".["sv, subkey_start + 1u), path_str.length()) - subkey_start;
impl::min(path_str.find_first_of(".[]"sv, subkey_start + 1u), path_str.length()) - subkey_start;
const auto subkey = path_str.substr(subkey_start, subkey_len);
// a regular subkey segment immediately after an array indexer is OK if it was all whitespace, e.g.:
@ -215,7 +258,7 @@ TOML_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
bool path::equal(const path& lhs, const path& rhs) noexcept
bool TOML_CALLCONV path::equal(const path& lhs, const path& rhs) noexcept
{
return lhs.components_ == rhs.components_;
}
@ -267,7 +310,7 @@ TOML_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
path& path::operator+=(path&& rhs) noexcept
path& path::operator+=(path&& rhs)
{
components_.insert(components_.end(),
std::make_move_iterator(rhs.components_.begin()),

17
include/toml++/impl/preprocessor.h
View File

@ -536,11 +536,15 @@
#define TOML_EXCEPTIONS 0
#endif
// calling convention for static/free/friend functions
#ifndef TOML_CALLCONV
#define TOML_CALLCONV
#endif
#ifndef TOML_UNDEF_MACROS
#define TOML_UNDEF_MACROS 1
#endif
#ifndef TOML_MAX_NESTED_VALUES
#define TOML_MAX_NESTED_VALUES 256
// this refers to the depth of nested values, e.g. inline tables and arrays.
@ -714,9 +718,9 @@
#endif
#define TOML_ASYMMETRICAL_EQUALITY_OPS(LHS, RHS, ...) \
__VA_ARGS__ TOML_NODISCARD friend bool operator == (RHS rhs, LHS lhs) noexcept { return lhs == rhs; } \
__VA_ARGS__ TOML_NODISCARD friend bool operator != (LHS lhs, RHS rhs) noexcept { return !(lhs == rhs); } \
__VA_ARGS__ TOML_NODISCARD friend bool operator != (RHS rhs, LHS lhs) noexcept { return !(lhs == rhs); } \
__VA_ARGS__ TOML_NODISCARD friend bool TOML_CALLCONV operator == (RHS rhs, LHS lhs) noexcept { return lhs == rhs; } \
__VA_ARGS__ TOML_NODISCARD friend bool TOML_CALLCONV operator != (LHS lhs, RHS rhs) noexcept { return !(lhs == rhs); } \
__VA_ARGS__ TOML_NODISCARD friend bool TOML_CALLCONV operator != (RHS rhs, LHS lhs) noexcept { return !(lhs == rhs); } \
static_assert(true)
#ifndef TOML_SIMPLE_STATIC_ASSERT_MESSAGES
@ -1030,6 +1034,11 @@
/// \ecpp
/// \def TOML_CALLCONV
/// \brief Calling convention to apply to all free/static functions in the library.
/// \detail Not defined by default (let the compiler decide).
/// \def TOML_EXPORTED_CLASS
/// \brief An 'export' annotation to add to classes.
/// \detail Not defined by default.

62
include/toml++/impl/print_to_stream.h
View File

@ -18,101 +18,101 @@ TOML_IMPL_NAMESPACE_START
TOML_EXPORTED_FREE_FUNCTION
TOML_ATTR(nonnull)
void print_to_stream(std::ostream&, const char*, size_t);
void TOML_CALLCONV print_to_stream(std::ostream&, const char*, size_t);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, std::string_view);
void TOML_CALLCONV print_to_stream(std::ostream&, std::string_view);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const std::string&);
void TOML_CALLCONV print_to_stream(std::ostream&, const std::string&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, char);
void TOML_CALLCONV print_to_stream(std::ostream&, char);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, int8_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, int8_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, int16_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, int16_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, int32_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, int32_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, int64_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, int64_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, uint8_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, uint8_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, uint16_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, uint16_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, uint32_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, uint32_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, uint64_t, value_flags = {}, size_t min_digits = 0);
void TOML_CALLCONV print_to_stream(std::ostream&, uint64_t, value_flags = {}, size_t min_digits = 0);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, float, value_flags = {}, bool relaxed_precision = false);
void TOML_CALLCONV print_to_stream(std::ostream&, float, value_flags = {}, bool relaxed_precision = false);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, double, value_flags = {}, bool relaxed_precision = false);
void TOML_CALLCONV print_to_stream(std::ostream&, double, value_flags = {}, bool relaxed_precision = false);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, bool);
void TOML_CALLCONV print_to_stream(std::ostream&, bool);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const toml::date&);
void TOML_CALLCONV print_to_stream(std::ostream&, const toml::date&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const toml::time&);
void TOML_CALLCONV print_to_stream(std::ostream&, const toml::time&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const toml::time_offset&);
void TOML_CALLCONV print_to_stream(std::ostream&, const toml::time_offset&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const toml::date_time&);
void TOML_CALLCONV print_to_stream(std::ostream&, const toml::date_time&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const source_position&);
void TOML_CALLCONV print_to_stream(std::ostream&, const source_position&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const source_region&);
void TOML_CALLCONV print_to_stream(std::ostream&, const source_region&);
#if TOML_ENABLE_FORMATTERS
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const array&);
void TOML_CALLCONV print_to_stream(std::ostream&, const array&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const table&);
void TOML_CALLCONV print_to_stream(std::ostream&, const table&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const value<std::string>&);
void TOML_CALLCONV print_to_stream(std::ostream&, const value<std::string>&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const value<int64_t>&);
void TOML_CALLCONV print_to_stream(std::ostream&, const value<int64_t>&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const value<double>&);
void TOML_CALLCONV print_to_stream(std::ostream&, const value<double>&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const value<bool>&);
void TOML_CALLCONV print_to_stream(std::ostream&, const value<bool>&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const value<date>&);
void TOML_CALLCONV print_to_stream(std::ostream&, const value<date>&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const value<time>&);
void TOML_CALLCONV print_to_stream(std::ostream&, const value<time>&);
TOML_EXPORTED_FREE_FUNCTION
void print_to_stream(std::ostream&, const value<date_time>&);
void TOML_CALLCONV print_to_stream(std::ostream&, const value<date_time>&);
#endif
template <typename T, typename U>
inline void print_to_stream_bookended(std::ostream & stream, const T& val, const U& bookend)
inline void TOML_CALLCONV print_to_stream_bookended(std::ostream & stream, const T& val, const U& bookend)
{
print_to_stream(stream, bookend);
print_to_stream(stream, val);

73
include/toml++/impl/print_to_stream.inl
View File

@ -69,7 +69,10 @@ TOML_ANON_NAMESPACE_START
template <typename T>
TOML_INTERNAL_LINKAGE
void print_integer_to_stream(std::ostream & stream, T val, value_flags format = {}, size_t min_digits = 0)
void TOML_CALLCONV print_integer_to_stream(std::ostream & stream,
T val,
value_flags format = {},
size_t min_digits = 0)
{
if (!val)
{
@ -156,10 +159,10 @@ TOML_ANON_NAMESPACE_START
template <typename T>
TOML_INTERNAL_LINKAGE
void print_floating_point_to_stream(std::ostream & stream,
T val,
value_flags format,
[[maybe_unused]] bool relaxed_precision)
void TOML_CALLCONV print_floating_point_to_stream(std::ostream & stream,
T val,
value_flags format,
[[maybe_unused]] bool relaxed_precision)
{
switch (impl::fpclassify(val))
{
@ -228,97 +231,97 @@ TOML_IMPL_NAMESPACE_START
{
TOML_EXTERNAL_LINKAGE
TOML_ATTR(nonnull)
void print_to_stream(std::ostream & stream, const char* val, size_t len)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const char* val, size_t len)
{
stream.write(val, static_cast<std::streamsize>(len));
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, std::string_view val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, std::string_view val)
{
stream.write(val.data(), static_cast<std::streamsize>(val.length()));
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const std::string& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const std::string& val)
{
stream.write(val.data(), static_cast<std::streamsize>(val.length()));
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, char val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, char val)
{
stream.put(val);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, int8_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, int8_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, int16_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, int16_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, int32_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, int32_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, int64_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, int64_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, uint8_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, uint8_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, uint16_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, uint16_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, uint32_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, uint32_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, uint64_t val, value_flags format, size_t min_digits)
void TOML_CALLCONV print_to_stream(std::ostream & stream, uint64_t val, value_flags format, size_t min_digits)
{
TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, float val, value_flags format, bool relaxed_precision)
void TOML_CALLCONV print_to_stream(std::ostream & stream, float val, value_flags format, bool relaxed_precision)
{
TOML_ANON_NAMESPACE::print_floating_point_to_stream(stream, val, format, relaxed_precision);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, double val, value_flags format, bool relaxed_precision)
void TOML_CALLCONV print_to_stream(std::ostream & stream, double val, value_flags format, bool relaxed_precision)
{
TOML_ANON_NAMESPACE::print_floating_point_to_stream(stream, val, format, relaxed_precision);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, bool val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, bool val)
{
print_to_stream(stream, val ? "true"sv : "false"sv);
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const toml::date& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::date& val)
{
print_to_stream(stream, val.year, {}, 4);
stream.put('-');
@ -328,7 +331,7 @@ TOML_IMPL_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const toml::time& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::time& val)
{
print_to_stream(stream, val.hour, {}, 2);
stream.put(':');
@ -350,7 +353,7 @@ TOML_IMPL_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const toml::time_offset& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::time_offset& val)
{
if (!val.minutes)
{
@ -379,7 +382,7 @@ TOML_IMPL_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const toml::date_time& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::date_time& val)
{
print_to_stream(stream, val.date);
stream.put('T');
@ -389,7 +392,7 @@ TOML_IMPL_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const source_position& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const source_position& val)
{
print_to_stream(stream, "line "sv);
print_to_stream(stream, val.line);
@ -398,7 +401,7 @@ TOML_IMPL_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const source_region& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const source_region& val)
{
print_to_stream(stream, val.begin);
if (val.path)
@ -412,55 +415,55 @@ TOML_IMPL_NAMESPACE_START
#if TOML_ENABLE_FORMATTERS
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const array& arr)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const array& arr)
{
stream << toml_formatter{ arr };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const table& tbl)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const table& tbl)
{
stream << toml_formatter{ tbl };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const value<std::string>& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<std::string>& val)
{
stream << toml_formatter{ val };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const value<int64_t>& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<int64_t>& val)
{
stream << toml_formatter{ val };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const value<double>& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<double>& val)
{
stream << toml_formatter{ val };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const value<bool>& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<bool>& val)
{
stream << toml_formatter{ val };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const value<date>& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<date>& val)
{
stream << toml_formatter{ val };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const value<time>& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<time>& val)
{
stream << toml_formatter{ val };
}
TOML_EXTERNAL_LINKAGE
void print_to_stream(std::ostream & stream, const value<date_time>& val)
void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<date_time>& val)
{
stream << toml_formatter{ val };
}

12
include/toml++/impl/source_region.h
View File

@ -58,28 +58,28 @@ TOML_NAMESPACE_START
/// \brief Returns true if two source_positions represent the same line and column.
TOML_NODISCARD
friend constexpr bool operator==(const source_position& lhs, const source_position& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator==(const source_position& lhs, const source_position& rhs) noexcept
{
return lhs.line == rhs.line && lhs.column == rhs.column;
}
/// \brief Returns true if two source_positions do not represent the same line and column.
TOML_NODISCARD
friend constexpr bool operator!=(const source_position& lhs, const source_position& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator!=(const source_position& lhs, const source_position& rhs) noexcept
{
return lhs.line != rhs.line || lhs.column != rhs.column;
}
/// \brief Returns true if the LHS position is before the RHS position.
TOML_NODISCARD
friend constexpr bool operator<(const source_position& lhs, const source_position& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<(const source_position& lhs, const source_position& rhs) noexcept
{
return lhs.line < rhs.line || (lhs.line == rhs.line && lhs.column < rhs.column);
}
/// \brief Returns true if the LHS position is before the RHS position or equal to it.
TOML_NODISCARD
friend constexpr bool operator<=(const source_position& lhs, const source_position& rhs) noexcept
friend constexpr bool TOML_CALLCONV operator<=(const source_position& lhs, const source_position& rhs) noexcept
{
return lhs.line < rhs.line || (lhs.line == rhs.line && lhs.column <= rhs.column);
}
@ -102,7 +102,7 @@ TOML_NAMESPACE_START
/// \param rhs The source_position.
///
/// \returns The input stream.
friend std::ostream& operator<<(std::ostream& lhs, const source_position& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const source_position& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;
@ -183,7 +183,7 @@ TOML_NAMESPACE_START
/// \param rhs The source_position.
///
/// \returns The input stream.
friend std::ostream& operator<<(std::ostream& lhs, const source_region& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const source_region& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;

15
include/toml++/impl/table.h
View File

@ -149,13 +149,13 @@ TOML_IMPL_NAMESPACE_START
}
TOML_PURE_INLINE_GETTER
friend bool operator==(const table_iterator& lhs, const table_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator==(const table_iterator& lhs, const table_iterator& rhs) noexcept
{
return lhs.iter_ == rhs.iter_;
}
TOML_PURE_INLINE_GETTER
friend bool operator!=(const table_iterator& lhs, const table_iterator& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const table_iterator& lhs, const table_iterator& rhs) noexcept
{
return lhs.iter_ != rhs.iter_;
}
@ -881,7 +881,8 @@ TOML_NAMESPACE_START
// clang-format on
template <typename Func, typename Table>
static void do_for_each(Func&& visitor, Table&& tbl) noexcept(for_each_is_nothrow<Func&&, Table&&>)
static void TOML_CALLCONV do_for_each(Func&& visitor,
Table&& tbl) noexcept(for_each_is_nothrow<Func&&, Table&&>)
{
static_assert(can_for_each_any<Func&&, Table&&>,
"TOML table for_each visitors must be invocable for at least one of the toml::node "
@ -1942,7 +1943,7 @@ TOML_NAMESPACE_START
TOML_PURE_GETTER
TOML_EXPORTED_STATIC_FUNCTION
static bool equal(const table&, const table&) noexcept;
static bool TOML_CALLCONV equal(const table&, const table&) noexcept;
/// \endcond
public:
@ -1953,7 +1954,7 @@ TOML_NAMESPACE_START
///
/// \returns True if the tables contained the same keys and map.
TOML_NODISCARD
friend bool operator==(const table& lhs, const table& rhs) noexcept
friend bool TOML_CALLCONV operator==(const table& lhs, const table& rhs) noexcept
{
return equal(lhs, rhs);
}
@ -1965,7 +1966,7 @@ TOML_NAMESPACE_START
///
/// \returns True if the tables did not contain the same keys and map.
TOML_NODISCARD
friend bool operator!=(const table& lhs, const table& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const table& lhs, const table& rhs) noexcept
{
return !equal(lhs, rhs);
}
@ -1977,7 +1978,7 @@ TOML_NAMESPACE_START
/// \brief Prints the table out to a stream as formatted TOML.
///
/// \availability This operator is only available when #TOML_ENABLE_FORMATTERS is enabled.
friend std::ostream& operator<<(std::ostream& lhs, const table& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const table& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;

2
include/toml++/impl/table.inl
View File

@ -278,7 +278,7 @@ TOML_NAMESPACE_START
}
TOML_EXTERNAL_LINKAGE
bool table::equal(const table& lhs, const table& rhs) noexcept
bool TOML_CALLCONV table::equal(const table& lhs, const table& rhs) noexcept
{
if (&lhs == &rhs)
return true;

4
include/toml++/impl/toml_formatter.h
View File

@ -131,7 +131,7 @@ TOML_NAMESPACE_START
#endif
/// \brief Prints the bound TOML object out to the stream as formatted TOML.
friend std::ostream& operator<<(std::ostream& lhs, toml_formatter& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, toml_formatter& rhs)
{
rhs.attach(lhs);
rhs.key_path_.clear();
@ -141,7 +141,7 @@ TOML_NAMESPACE_START
}
/// \brief Prints the bound TOML object out to the stream as formatted TOML (rvalue overload).
friend std::ostream& operator<<(std::ostream& lhs, toml_formatter&& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, toml_formatter&& rhs)
{
return lhs << rhs; // as lvalue
}

6
include/toml++/impl/toml_formatter.inl
View File

@ -24,7 +24,7 @@ TOML_DISABLE_ARITHMETIC_WARNINGS;
TOML_ANON_NAMESPACE_START
{
TOML_INTERNAL_LINKAGE
size_t toml_formatter_count_inline_columns(const node& node, size_t line_wrap_cols) noexcept
size_t TOML_CALLCONV toml_formatter_count_inline_columns(const node& node, size_t line_wrap_cols) noexcept
{
switch (node.type())
{
@ -107,7 +107,9 @@ TOML_ANON_NAMESPACE_START
}
TOML_INTERNAL_LINKAGE
bool toml_formatter_forces_multiline(const node& node, size_t line_wrap_cols, size_t starting_column_bias) noexcept
bool TOML_CALLCONV toml_formatter_forces_multiline(const node& node,
size_t line_wrap_cols,
size_t starting_column_bias) noexcept
{
return (toml_formatter_count_inline_columns(node, line_wrap_cols) + starting_column_bias) >= line_wrap_cols;
}

34
include/toml++/impl/unicode.h
View File

@ -11,44 +11,44 @@
TOML_IMPL_NAMESPACE_START
{
TOML_CONST_GETTER
constexpr bool is_string_delimiter(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_string_delimiter(char32_t c) noexcept
{
return c == U'"' || c == U'\'';
}
TOML_CONST_GETTER
constexpr bool is_ascii_letter(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_ascii_letter(char32_t c) noexcept
{
return (c >= U'a' && c <= U'z') || (c >= U'A' && c <= U'Z');
}
TOML_CONST_GETTER
constexpr bool is_binary_digit(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_binary_digit(char32_t c) noexcept
{
return c == U'0' || c == U'1';
}
TOML_CONST_GETTER
constexpr bool is_octal_digit(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_octal_digit(char32_t c) noexcept
{
return (c >= U'0' && c <= U'7');
}
TOML_CONST_GETTER
constexpr bool is_decimal_digit(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_decimal_digit(char32_t c) noexcept
{
return (c >= U'0' && c <= U'9');
}
TOML_CONST_GETTER
constexpr bool is_hexadecimal_digit(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_hexadecimal_digit(char32_t c) noexcept
{
return U'0' <= c && c <= U'f' && (1ull << (static_cast<uint_least64_t>(c) - 0x30u)) & 0x7E0000007E03FFull;
}
template <typename T>
TOML_CONST_GETTER
constexpr uint_least32_t hex_to_dec(const T c) noexcept
constexpr uint_least32_t TOML_CALLCONV hex_to_dec(const T c) noexcept
{
if constexpr (std::is_same_v<remove_cvref<T>, uint_least32_t>)
return c >= 0x41u // >= 'A'
@ -60,25 +60,25 @@ TOML_IMPL_NAMESPACE_START
}
TOML_CONST_GETTER
constexpr bool is_horizontal_whitespace(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_horizontal_whitespace(char32_t c) noexcept
{
return is_ascii_horizontal_whitespace(c) || is_non_ascii_horizontal_whitespace(c);
}
TOML_CONST_GETTER
constexpr bool is_vertical_whitespace(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_vertical_whitespace(char32_t c) noexcept
{
return is_ascii_vertical_whitespace(c) || is_non_ascii_vertical_whitespace(c);
}
TOML_CONST_GETTER
constexpr bool is_whitespace(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_whitespace(char32_t c) noexcept
{
return is_horizontal_whitespace(c) || is_vertical_whitespace(c);
}
TOML_CONST_GETTER
constexpr bool is_bare_key_character(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_bare_key_character(char32_t c) noexcept
{
return is_ascii_bare_key_character(c)
#if TOML_LANG_UNRELEASED // toml/pull/891 (unicode bare keys)
@ -88,31 +88,31 @@ TOML_IMPL_NAMESPACE_START
}
TOML_CONST_GETTER
constexpr bool is_value_terminator(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_value_terminator(char32_t c) noexcept
{
return is_whitespace(c) || c == U']' || c == U'}' || c == U',' || c == U'#';
}
TOML_CONST_GETTER
constexpr bool is_control_character(char c) noexcept
constexpr bool TOML_CALLCONV is_control_character(char c) noexcept
{
return c <= '\u001F' || c == '\u007F';
}
TOML_CONST_GETTER
constexpr bool is_control_character(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_control_character(char32_t c) noexcept
{
return c <= U'\u001F' || c == U'\u007F';
}
TOML_CONST_GETTER
constexpr bool is_nontab_control_character(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_nontab_control_character(char32_t c) noexcept
{
return c <= U'\u0008' || (c >= U'\u000A' && c <= U'\u001F') || c == U'\u007F';
}
TOML_CONST_GETTER
constexpr bool is_unicode_surrogate(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_unicode_surrogate(char32_t c) noexcept
{
return c >= 0xD800u && c <= 0xDFFF;
}
@ -189,7 +189,7 @@ TOML_IMPL_NAMESPACE_START
TOML_PURE_GETTER
TOML_ATTR(nonnull)
bool is_ascii(const char* str, size_t len) noexcept;
bool TOML_CALLCONV is_ascii(const char* str, size_t len) noexcept;
}
TOML_IMPL_NAMESPACE_END;

2
include/toml++/impl/unicode.inl
View File

@ -18,7 +18,7 @@
TOML_IMPL_NAMESPACE_START
{
TOML_EXTERNAL_LINKAGE
bool is_ascii(const char* str, size_t len) noexcept
bool TOML_CALLCONV is_ascii(const char* str, size_t len) noexcept
{
const char* const end = str + len;

12
include/toml++/impl/unicode_autogenerated.h
View File

@ -18,13 +18,13 @@
TOML_IMPL_NAMESPACE_START
{
TOML_CONST_GETTER
constexpr bool is_ascii_horizontal_whitespace(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_ascii_horizontal_whitespace(char32_t c) noexcept
{
return c == U'\t' || c == U' ';
}
TOML_CONST_GETTER
constexpr bool is_non_ascii_horizontal_whitespace(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_non_ascii_horizontal_whitespace(char32_t c) noexcept
{
// 20 code units from 8 ranges (spanning a search area of 65120)
@ -48,19 +48,19 @@ TOML_IMPL_NAMESPACE_START
}
TOML_CONST_GETTER
constexpr bool is_ascii_vertical_whitespace(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_ascii_vertical_whitespace(char32_t c) noexcept
{
return c >= U'\n' && c <= U'\r';
}
TOML_CONST_GETTER
constexpr bool is_non_ascii_vertical_whitespace(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_non_ascii_vertical_whitespace(char32_t c) noexcept
{
return (U'\u2028' <= c && c <= U'\u2029') || c == U'\x85';
}
TOML_CONST_GETTER
constexpr bool is_ascii_bare_key_character(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_ascii_bare_key_character(char32_t c) noexcept
{
#if TOML_LANG_UNRELEASED // toml/issues/644 ('+' in bare keys)
if TOML_UNLIKELY(c == U'+')
@ -78,7 +78,7 @@ TOML_IMPL_NAMESPACE_START
#if TOML_LANG_UNRELEASED // toml/pull/891 (unicode bare keys)
TOML_CONST_GETTER
constexpr bool is_non_ascii_bare_key_character(char32_t c) noexcept
constexpr bool TOML_CALLCONV is_non_ascii_bare_key_character(char32_t c) noexcept
{
// 971732 code units from 16 ranges (spanning a search area of 982862)

40
include/toml++/impl/value.h
View File

@ -80,7 +80,7 @@ TOML_IMPL_NAMESPACE_START
{
template <typename... Args>
TOML_NODISCARD
static T make(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args&&...>)
static T TOML_CALLCONV make(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args&&...>)
{
if constexpr (std::is_aggregate_v<T>)
return T{ static_cast<Args&&>(args)... };
@ -95,7 +95,7 @@ TOML_IMPL_NAMESPACE_START
template <typename U>
TOML_NODISCARD
TOML_ALWAYS_INLINE
static U&& make(U&& val) noexcept
static U&& TOML_CALLCONV make(U&& val) noexcept
{
return static_cast<U&&>(val);
}
@ -107,7 +107,7 @@ TOML_IMPL_NAMESPACE_START
{
template <typename T>
TOML_NODISCARD
static std::string make(T&& arg) noexcept
static std::string TOML_CALLCONV make(T&& arg) noexcept
{
using arg_type = std::decay_t<T>;
#if TOML_HAS_CHAR8
@ -221,7 +221,7 @@ TOML_NAMESPACE_START
template <typename T, typename U>
TOML_CONST_INLINE_GETTER
static auto as_value([[maybe_unused]] U* ptr) noexcept
static auto TOML_CALLCONV as_value([[maybe_unused]] U* ptr) noexcept
{
if constexpr (std::is_same_v<value_type, T>)
return ptr;
@ -772,7 +772,7 @@ TOML_NAMESPACE_START
/// \brief Value equality operator.
TOML_NODISCARD
friend bool operator==(const value& lhs, value_arg rhs) noexcept
friend bool TOML_CALLCONV operator==(const value& lhs, value_arg rhs) noexcept
{
if constexpr (std::is_same_v<value_type, double>)
{
@ -789,56 +789,56 @@ TOML_NAMESPACE_START
/// \brief Value less-than operator.
TOML_NODISCARD
friend bool operator<(const value& lhs, value_arg rhs) noexcept
friend bool TOML_CALLCONV operator<(const value& lhs, value_arg rhs) noexcept
{
return lhs.val_ < rhs;
}
/// \brief Value less-than operator.
TOML_NODISCARD
friend bool operator<(value_arg lhs, const value& rhs) noexcept
friend bool TOML_CALLCONV operator<(value_arg lhs, const value& rhs) noexcept
{
return lhs < rhs.val_;
}
/// \brief Value less-than-or-equal-to operator.
TOML_NODISCARD
friend bool operator<=(const value& lhs, value_arg rhs) noexcept
friend bool TOML_CALLCONV operator<=(const value& lhs, value_arg rhs) noexcept
{
return lhs.val_ <= rhs;
}
/// \brief Value less-than-or-equal-to operator.
TOML_NODISCARD
friend bool operator<=(value_arg lhs, const value& rhs) noexcept
friend bool TOML_CALLCONV operator<=(value_arg lhs, const value& rhs) noexcept
{
return lhs <= rhs.val_;
}
/// \brief Value greater-than operator.
TOML_NODISCARD
friend bool operator>(const value& lhs, value_arg rhs) noexcept
friend bool TOML_CALLCONV operator>(const value& lhs, value_arg rhs) noexcept
{
return lhs.val_ > rhs;
}
/// \brief Value greater-than operator.
TOML_NODISCARD
friend bool operator>(value_arg lhs, const value& rhs) noexcept
friend bool TOML_CALLCONV operator>(value_arg lhs, const value& rhs) noexcept
{
return lhs > rhs.val_;
}
/// \brief Value greater-than-or-equal-to operator.
TOML_NODISCARD
friend bool operator>=(const value& lhs, value_arg rhs) noexcept
friend bool TOML_CALLCONV operator>=(const value& lhs, value_arg rhs) noexcept
{
return lhs.val_ >= rhs;
}
/// \brief Value greater-than-or-equal-to operator.
TOML_NODISCARD
friend bool operator>=(value_arg lhs, const value& rhs) noexcept
friend bool TOML_CALLCONV operator>=(value_arg lhs, const value& rhs) noexcept
{
return lhs >= rhs.val_;
}
@ -851,7 +851,7 @@ TOML_NAMESPACE_START
/// \returns True if the values were of the same type and contained the same value.
template <typename T>
TOML_NODISCARD
friend bool operator==(const value& lhs, const value<T>& rhs) noexcept
friend bool TOML_CALLCONV operator==(const value& lhs, const value<T>& rhs) noexcept
{
if constexpr (std::is_same_v<value_type, T>)
return lhs == rhs.val_; // calls asymmetrical value-equality operator defined above
@ -867,7 +867,7 @@ TOML_NAMESPACE_START
/// \returns True if the values were not of the same type, or did not contain the same value.
template <typename T>
TOML_NODISCARD
friend bool operator!=(const value& lhs, const value<T>& rhs) noexcept
friend bool TOML_CALLCONV operator!=(const value& lhs, const value<T>& rhs) noexcept
{
return !(lhs == rhs);
}
@ -883,7 +883,7 @@ TOML_NAMESPACE_START
/// `lhs.type() < rhs.type()`
template <typename T>
TOML_NODISCARD
friend bool operator<(const value& lhs, const value<T>& rhs) noexcept
friend bool TOML_CALLCONV operator<(const value& lhs, const value<T>& rhs) noexcept
{
if constexpr (std::is_same_v<value_type, T>)
return lhs.val_ < rhs.val_;
@ -902,7 +902,7 @@ TOML_NAMESPACE_START
/// `lhs.type() <= rhs.type()`
template <typename T>
TOML_NODISCARD
friend bool operator<=(const value& lhs, const value<T>& rhs) noexcept
friend bool TOML_CALLCONV operator<=(const value& lhs, const value<T>& rhs) noexcept
{
if constexpr (std::is_same_v<value_type, T>)
return lhs.val_ <= rhs.val_;
@ -921,7 +921,7 @@ TOML_NAMESPACE_START
/// `lhs.type() > rhs.type()`
template <typename T>
TOML_NODISCARD
friend bool operator>(const value& lhs, const value<T>& rhs) noexcept
friend bool TOML_CALLCONV operator>(const value& lhs, const value<T>& rhs) noexcept
{
if constexpr (std::is_same_v<value_type, T>)
return lhs.val_ > rhs.val_;
@ -940,7 +940,7 @@ TOML_NAMESPACE_START
/// `lhs.type() >= rhs.type()`
template <typename T>
TOML_NODISCARD
friend bool operator>=(const value& lhs, const value<T>& rhs) noexcept
friend bool TOML_CALLCONV operator>=(const value& lhs, const value<T>& rhs) noexcept
{
if constexpr (std::is_same_v<value_type, T>)
return lhs.val_ >= rhs.val_;
@ -955,7 +955,7 @@ TOML_NAMESPACE_START
/// \brief Prints the value out to a stream as formatted TOML.
///
/// \availability This operator is only available when #TOML_ENABLE_FORMATTERS is enabled.
friend std::ostream& operator<<(std::ostream& lhs, const value& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, const value& rhs)
{
impl::print_to_stream(lhs, rhs);
return lhs;

4
include/toml++/impl/yaml_formatter.h
View File

@ -118,7 +118,7 @@ TOML_NAMESPACE_START
#endif
/// \brief Prints the bound TOML object out to the stream as YAML.
friend std::ostream& operator<<(std::ostream& lhs, yaml_formatter& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, yaml_formatter& rhs)
{
rhs.attach(lhs);
rhs.print();
@ -127,7 +127,7 @@ TOML_NAMESPACE_START
}
/// \brief Prints the bound TOML object out to the stream as YAML (rvalue overload).
friend std::ostream& operator<<(std::ostream& lhs, yaml_formatter&& rhs)
friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, yaml_formatter&& rhs)
{
return lhs << rhs; // as lvalue
}

20
tests/at_path.cpp
View File

@ -61,7 +61,7 @@ TEST_CASE("at_path")
CHECK(tbl["b"][0]);
CHECK(tbl["b"][0] == at_path(tbl, "b[0]"));
CHECK(tbl["b"][0] == at_path(tbl, "b[0] "));
CHECK(tbl["b"][0] == at_path(tbl, "b[ 0\t]")); // whitespace is allowed inside array indexer
CHECK(tbl["b"][0] == at_path(tbl, "b[ 0\t]")); // whitespace is allowed inside indexer
CHECK(tbl["b"][1]);
CHECK(tbl["b"][1] != tbl["b"][0]);
@ -69,12 +69,17 @@ TEST_CASE("at_path")
CHECK(tbl["b"][1][0]);
CHECK(tbl["b"][1][0] == at_path(tbl, "b[1][0]"));
CHECK(tbl["b"][1][0] == at_path(tbl, "b[1] \t [0]")); // whitespace is allowed after array
// indexers
CHECK(tbl["b"][1][0] == at_path(tbl, "b[1] \t [0]")); // whitespace is allowed after indexers
CHECK(tbl["b"][2]["c"]);
CHECK(tbl["b"][2]["c"] == at_path(tbl, "b[2].c"));
CHECK(tbl["b"][2]["c"] == at_path(tbl, "b[2] \t.c")); // whitespace is allowed after array indexers
CHECK(tbl["b"][2]["c"] == at_path(tbl, "b[2] \t.c")); // whitespace is allowed after indexers
// permissivity checks for missing trailing ']'
// (this permissivity is undocumented but serves to reduce error paths in user code)
CHECK(tbl["b"][1][0] == at_path(tbl, "b[1[0]"));
CHECK(tbl["b"][1][0] == at_path(tbl, "b[1[0"));
CHECK(tbl["b"][2]["c"] == at_path(tbl, "b[2.c"));
CHECK(tbl["d"]);
CHECK(tbl["d"] == at_path(tbl, "d"));
@ -97,7 +102,7 @@ TEST_CASE("at_path")
CHECK(tbl["b"][0]);
CHECK(tbl["b"][0] == arr.at_path("[0]"));
CHECK(tbl["b"][0] == arr.at_path("[0] "));
CHECK(tbl["b"][0] == arr.at_path("[ 0\t]")); // whitespace is allowed inside array indexer
CHECK(tbl["b"][0] == arr.at_path("[ 0\t]")); // whitespace is allowed inside indexer
CHECK(tbl["b"][1]);
CHECK(tbl["b"][1].node() != arr[0].node());
@ -105,11 +110,10 @@ TEST_CASE("at_path")
CHECK(tbl["b"][1][0]);
CHECK(tbl["b"][1][0] == arr.at_path("[1][0]"));
CHECK(tbl["b"][1][0] == arr.at_path("[1] \t [0]")); // whitespace is allowed after array
// indexers
CHECK(tbl["b"][1][0] == arr.at_path("[1] \t [0]")); // whitespace is allowed after indexers
CHECK(tbl["b"][2]["c"]);
CHECK(tbl["b"][2]["c"] == arr.at_path("[2].c"));
CHECK(tbl["b"][2]["c"] == arr.at_path("[2] \t.c")); // whitespace is allowed after array indexers
CHECK(tbl["b"][2]["c"] == arr.at_path("[2] \t.c")); // whitespace is allowed after indexers
}
}

3
tests/settings.h
View File

@ -21,6 +21,9 @@
#undef LEAK_TESTS
#define LEAK_TESTS 0
#endif
#ifdef _MSC_VER
#define TOML_CALLCONV __stdcall // just to test that TOML_CALLCONV doesn't cause linker failures
#endif
// catch2 config
#define CATCH_CONFIG_CPP11_TO_STRING

842
toml.hpp
View File

File diff suppressed because it is too large Load Diff

1
tools/generate_single_header.py
View File

@ -206,6 +206,7 @@ def main():
r'POXY_IMPLEMENTATION_DETAIL',
r'TOML_ALL_INLINE',
r'TOML_API',
r'TOML_CALLCONV',
r'TOML_CONCAT',
r'TOML_CONCAT_1',
r'TOML_CONFIG_HEADER',