mirror of
https://github.com/ChaiScript/ChaiScript.git
synced 2026-05-01 03:19:28 +08:00
9d4ec82475
AppleClang's libc++ does not support std::from_chars for floating-point types. Add a compile-time detection macro (CHAISCRIPT_HAS_FLOAT_FROM_CHARS) and fall back to strtod/strtof/strtold on libc++ platforms. Centralize the fallback in parse_num and route bootstrap.hpp and json.hpp through it to keep the workaround in one place. Requested by @lefticus in PR #669 review. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
222 lines
6.7 KiB
C++
222 lines
6.7 KiB
C++
// This file is distributed under the BSD License.
|
|
// See "license.txt" for details.
|
|
// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
|
|
// Copyright 2009-2018, Jason Turner (jason@emptycrate.com)
|
|
// http://www.chaiscript.com
|
|
|
|
#ifndef CHAISCRIPT_DEFINES_HPP_
|
|
#define CHAISCRIPT_DEFINES_HPP_
|
|
|
|
#ifdef _MSC_VER
|
|
#define CHAISCRIPT_STRINGIZE(x) "" #x
|
|
#define CHAISCRIPT_STRINGIZE_EXPANDED(x) CHAISCRIPT_STRINGIZE(x)
|
|
#define CHAISCRIPT_COMPILER_VERSION CHAISCRIPT_STRINGIZE_EXPANDED(_MSC_FULL_VER)
|
|
#define CHAISCRIPT_MSVC _MSC_VER
|
|
#define CHAISCRIPT_HAS_DECLSPEC
|
|
|
|
static_assert(_MSC_FULL_VER >= 190024210, "Visual C++ 2015 Update 3 or later required");
|
|
|
|
#else
|
|
#define CHAISCRIPT_COMPILER_VERSION __VERSION__
|
|
#endif
|
|
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#if defined(_LIBCPP_VERSION)
|
|
#define CHAISCRIPT_LIBCPP
|
|
#endif
|
|
|
|
#if defined(_WIN32) || defined(__CYGWIN__)
|
|
#define CHAISCRIPT_WINDOWS
|
|
#endif
|
|
|
|
#if defined(_WIN32)
|
|
#if defined(__llvm__)
|
|
#define CHAISCRIPT_COMPILER_NAME "clang(windows)"
|
|
#elif defined(__GNUC__)
|
|
#define CHAISCRIPT_COMPILER_NAME "gcc(mingw)"
|
|
#else
|
|
#define CHAISCRIPT_COMPILER_NAME "msvc"
|
|
#endif
|
|
#else
|
|
#if defined(__llvm__)
|
|
#define CHAISCRIPT_COMPILER_NAME "clang"
|
|
#elif defined(__GNUC__)
|
|
#define CHAISCRIPT_COMPILER_NAME "gcc"
|
|
#else
|
|
#define CHAISCRIPT_COMPILER_NAME "unknown"
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(__llvm__)
|
|
#define CHAISCRIPT_CLANG
|
|
#endif
|
|
|
|
#ifdef CHAISCRIPT_HAS_DECLSPEC
|
|
#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
|
|
#else
|
|
#define CHAISCRIPT_MODULE_EXPORT extern "C"
|
|
#endif
|
|
|
|
#if defined(CHAISCRIPT_MSVC) || (defined(__GNUC__) && __GNUC__ >= 5) || defined(CHAISCRIPT_CLANG)
|
|
#define CHAISCRIPT_UTF16_UTF32
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
#define CHAISCRIPT_DEBUG true
|
|
#else
|
|
#define CHAISCRIPT_DEBUG false
|
|
#endif
|
|
|
|
#include <charconv>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
// libc++ (AppleClang, Emscripten) may not support floating-point std::from_chars
|
|
#if !defined(CHAISCRIPT_LIBCPP)
|
|
#define CHAISCRIPT_HAS_FLOAT_FROM_CHARS 1
|
|
#endif
|
|
|
|
#ifndef CHAISCRIPT_HAS_FLOAT_FROM_CHARS
|
|
#include <cstdlib>
|
|
#endif
|
|
|
|
namespace chaiscript {
|
|
constexpr static const int version_major = 7;
|
|
constexpr static const int version_minor = 0;
|
|
constexpr static const int version_patch = 0;
|
|
|
|
constexpr static const char *compiler_version = CHAISCRIPT_COMPILER_VERSION;
|
|
constexpr static const char *compiler_name = CHAISCRIPT_COMPILER_NAME;
|
|
constexpr static const bool debug_build = CHAISCRIPT_DEBUG;
|
|
|
|
template<typename B, typename D, typename... Arg>
|
|
inline std::shared_ptr<B> make_shared(Arg &&...arg) {
|
|
#ifdef CHAISCRIPT_USE_STD_MAKE_SHARED
|
|
return std::make_shared<D>(std::forward<Arg>(arg)...);
|
|
#else
|
|
return std::shared_ptr<B>(static_cast<B *>(new D(std::forward<Arg>(arg)...)));
|
|
#endif
|
|
}
|
|
|
|
template<typename B, typename D, typename... Arg>
|
|
inline std::unique_ptr<B> make_unique(Arg &&...arg) {
|
|
#ifdef CHAISCRIPT_USE_STD_MAKE_SHARED
|
|
return std::make_unique<D>(std::forward<Arg>(arg)...);
|
|
#else
|
|
return std::unique_ptr<B>(static_cast<B *>(new D(std::forward<Arg>(arg)...)));
|
|
#endif
|
|
}
|
|
|
|
struct Build_Info {
|
|
[[nodiscard]] constexpr static int version_major() noexcept { return chaiscript::version_major; }
|
|
|
|
[[nodiscard]] constexpr static int version_minor() noexcept { return chaiscript::version_minor; }
|
|
|
|
[[nodiscard]] constexpr static int version_patch() noexcept { return chaiscript::version_patch; }
|
|
|
|
[[nodiscard]] static std::string version() {
|
|
return std::to_string(version_major()) + '.' + std::to_string(version_minor()) + '.' + std::to_string(version_patch());
|
|
}
|
|
|
|
[[nodiscard]] static std::string compiler_id() { return compiler_name() + '-' + compiler_version(); }
|
|
|
|
[[nodiscard]] static std::string build_id() { return compiler_id() + (debug_build() ? "-Debug" : "-Release"); }
|
|
|
|
[[nodiscard]] static std::string compiler_version() { return chaiscript::compiler_version; }
|
|
|
|
[[nodiscard]] static std::string compiler_name() { return chaiscript::compiler_name; }
|
|
|
|
[[nodiscard]] constexpr static bool debug_build() noexcept { return chaiscript::debug_build; }
|
|
};
|
|
|
|
template<typename T>
|
|
[[nodiscard]] auto parse_num(const std::string_view t_str) {
|
|
T t{};
|
|
if constexpr (std::is_floating_point_v<T>) {
|
|
#ifdef CHAISCRIPT_HAS_FLOAT_FROM_CHARS
|
|
std::from_chars(t_str.data(), t_str.data() + t_str.size(), t);
|
|
#else
|
|
const std::string tmp(t_str);
|
|
if constexpr (std::is_same_v<T, float>) {
|
|
t = std::strtof(tmp.c_str(), nullptr);
|
|
} else if constexpr (std::is_same_v<T, long double>) {
|
|
t = std::strtold(tmp.c_str(), nullptr);
|
|
} else {
|
|
t = std::strtod(tmp.c_str(), nullptr);
|
|
}
|
|
#endif
|
|
} else {
|
|
std::from_chars(t_str.data(), t_str.data() + t_str.size(), t);
|
|
}
|
|
return t;
|
|
}
|
|
|
|
struct str_equal {
|
|
[[nodiscard]] bool operator()(const std::string &t_lhs, const std::string &t_rhs) const noexcept { return t_lhs == t_rhs; }
|
|
template<typename LHS, typename RHS>
|
|
[[nodiscard]] constexpr bool operator()(const LHS &t_lhs, const RHS &t_rhs) const noexcept {
|
|
return std::equal(t_lhs.begin(), t_lhs.end(), t_rhs.begin(), t_rhs.end());
|
|
}
|
|
struct is_transparent {
|
|
};
|
|
};
|
|
|
|
struct str_less {
|
|
[[nodiscard]] bool operator()(const std::string &t_lhs, const std::string &t_rhs) const noexcept { return t_lhs < t_rhs; }
|
|
template<typename LHS, typename RHS>
|
|
[[nodiscard]] constexpr bool operator()(const LHS &t_lhs, const RHS &t_rhs) const noexcept {
|
|
return std::lexicographical_compare(t_lhs.begin(), t_lhs.end(), t_rhs.begin(), t_rhs.end());
|
|
}
|
|
struct is_transparent {
|
|
};
|
|
};
|
|
|
|
enum class Options {
|
|
No_Load_Modules,
|
|
Load_Modules,
|
|
No_External_Scripts,
|
|
External_Scripts
|
|
};
|
|
|
|
enum class Library_Options {
|
|
No_Stdlib,
|
|
No_IO,
|
|
No_Prelude,
|
|
No_JSON
|
|
};
|
|
|
|
template<typename From, typename To>
|
|
struct is_nothrow_forward_constructible : std::bool_constant<noexcept(To{std::declval<From>()})> {
|
|
};
|
|
|
|
template<class From, class To>
|
|
static inline constexpr bool is_nothrow_forward_constructible_v = is_nothrow_forward_constructible<From, To>::value;
|
|
|
|
template<typename Container, typename... T>
|
|
[[nodiscard]] constexpr auto make_container(T &&...t) {
|
|
Container c;
|
|
c.reserve(sizeof...(t));
|
|
(c.push_back(std::forward<T>(t)), ...);
|
|
return c;
|
|
}
|
|
|
|
template<typename... T>
|
|
[[nodiscard]] auto make_vector(T &&...t) -> std::vector<std::common_type_t<std::decay_t<T>...>> {
|
|
using container_type = std::vector<std::common_type_t<std::decay_t<T>...>>;
|
|
|
|
return make_container<container_type>(std::forward<T>(t)...);
|
|
}
|
|
|
|
[[nodiscard]] inline std::vector<Options> default_options() {
|
|
#ifdef CHAISCRIPT_NO_DYNLOAD
|
|
return {Options::No_Load_Modules, Options::External_Scripts};
|
|
#else
|
|
return {Options::Load_Modules, Options::External_Scripts};
|
|
#endif
|
|
}
|
|
} // namespace chaiscript
|
|
#endif
|