mirror of
https://github.com/ChaiScript/ChaiScript.git
synced 2025-12-06 16:57:04 +08:00
295 lines
7.4 KiB
C++
295 lines
7.4 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 <vector>
|
|
#include <string_view>
|
|
|
|
#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 <memory>
|
|
#include <string>
|
|
#include <cmath>
|
|
|
|
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]] constexpr auto parse_num(const std::string_view t_str) noexcept -> typename std::enable_if<std::is_integral<T>::value, T>::type
|
|
{
|
|
T t = 0;
|
|
for (const auto c : t_str) {
|
|
if (c < '0' || c > '9') {
|
|
return t;
|
|
}
|
|
t *= 10;
|
|
t += c - '0';
|
|
}
|
|
return t;
|
|
}
|
|
|
|
|
|
template<typename T>
|
|
[[nodiscard]] auto parse_num(const std::string_view t_str) -> typename std::enable_if<!std::is_integral<T>::value, T>::type
|
|
{
|
|
T t = 0;
|
|
T base{};
|
|
T decimal_place = 0;
|
|
int exponent = 0;
|
|
|
|
for (const auto c : t_str) {
|
|
switch (c)
|
|
{
|
|
case '.':
|
|
decimal_place = 10;
|
|
break;
|
|
case 'e':
|
|
case 'E':
|
|
exponent = 1;
|
|
decimal_place = 0;
|
|
base = t;
|
|
t = 0;
|
|
break;
|
|
case '-':
|
|
exponent = -1;
|
|
break;
|
|
case '+':
|
|
break;
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
if (decimal_place < 10) {
|
|
t *= 10;
|
|
t += static_cast<T>(c - '0');
|
|
}
|
|
else {
|
|
t += static_cast<T>(c - '0') / decimal_place;
|
|
decimal_place *= 10;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return exponent ? base * std::pow(T(10), t * static_cast<T>(exponent)) : 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
|
|
};
|
|
|
|
template<typename From, typename To>
|
|
struct is_nothrow_forward_constructible
|
|
: std::bool_constant<noexcept(To{std::declval<From>()})>
|
|
{
|
|
};
|
|
|
|
template< class From, class To >
|
|
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)
|
|
{
|
|
using container_type =
|
|
std::vector<std::common_type_t<std::decay_t<T>...>>;
|
|
|
|
return make_container<container_type>(std::forward<T>(t)...);
|
|
}
|
|
|
|
|
|
|
|
static 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
|
|
}
|
|
}
|
|
#endif
|
|
|