diff options
Diffstat (limited to 'third_party/immer/extra/guile/scm/detail')
8 files changed, 428 insertions, 0 deletions
diff --git a/third_party/immer/extra/guile/scm/detail/convert.hpp b/third_party/immer/extra/guile/scm/detail/convert.hpp new file mode 100644 index 000000000000..4c87ff185669 --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/convert.hpp @@ -0,0 +1,58 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +#include <scm/detail/util.hpp> + +#include <cstdint> +#include <type_traits> +#include <utility> + +#include <libguile.h> + +namespace scm { +namespace detail { + +template <typename T, typename Enable=void> +struct convert; + +template <typename T> +auto to_scm(T&& v) + -> SCM_DECLTYPE_RETURN( + convert<std::decay_t<T>>::to_scm(std::forward<T>(v))); + +template <typename T> +auto to_cpp(SCM v) + -> SCM_DECLTYPE_RETURN( + convert<std::decay_t<T>>::to_cpp(v)); + +} // namespace detail +} // namespace scm + +#define SCM_DECLARE_NUMERIC_TYPE(cpp_name__, scm_name__) \ + namespace scm { \ + namespace detail { \ + template <> \ + struct convert<cpp_name__> { \ + static cpp_name__ to_cpp(SCM v) { return scm_to_ ## scm_name__(v); } \ + static SCM to_scm(cpp_name__ v) { return scm_from_ ## scm_name__(v); } \ + }; \ + }} /* namespace scm::detail */ \ + /**/ + +SCM_DECLARE_NUMERIC_TYPE(float, double); +SCM_DECLARE_NUMERIC_TYPE(double, double); +SCM_DECLARE_NUMERIC_TYPE(std::int8_t, int8); +SCM_DECLARE_NUMERIC_TYPE(std::int16_t, int16); +SCM_DECLARE_NUMERIC_TYPE(std::int32_t, int32); +SCM_DECLARE_NUMERIC_TYPE(std::int64_t, int64); +SCM_DECLARE_NUMERIC_TYPE(std::uint8_t, uint8); +SCM_DECLARE_NUMERIC_TYPE(std::uint16_t, uint16); +SCM_DECLARE_NUMERIC_TYPE(std::uint32_t, uint32); +SCM_DECLARE_NUMERIC_TYPE(std::uint64_t, uint64); diff --git a/third_party/immer/extra/guile/scm/detail/define.hpp b/third_party/immer/extra/guile/scm/detail/define.hpp new file mode 100644 index 000000000000..08b6e763381f --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/define.hpp @@ -0,0 +1,36 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +#ifndef SCM_AUTO_EXPORT +#define SCM_AUTO_EXPORT 1 +#endif + +#include <scm/detail/subr_wrapper.hpp> +#include <scm/list.hpp> + +namespace scm { +namespace detail { + +template <typename Tag, typename Fn> +static void define_impl(const std::string& name, Fn fn) +{ + using args_t = function_args_t<Fn>; + constexpr auto args_size = pack_size_v<args_t>; + constexpr auto has_rest = std::is_same<pack_last_t<args_t>, scm::args>{}; + constexpr auto arg_count = args_size - has_rest; + auto subr = (scm_t_subr) +subr_wrapper_aux<Tag>(fn, args_t{}); + scm_c_define_gsubr(name.c_str(), arg_count, 0, has_rest, subr); +#if SCM_AUTO_EXPORT + scm_c_export(name.c_str()); +#endif +} + +} // namespace detail +} // namespace scm diff --git a/third_party/immer/extra/guile/scm/detail/finalizer_wrapper.hpp b/third_party/immer/extra/guile/scm/detail/finalizer_wrapper.hpp new file mode 100644 index 000000000000..258249eb2c73 --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/finalizer_wrapper.hpp @@ -0,0 +1,62 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +#include <scm/detail/invoke.hpp> +#include <scm/detail/function_args.hpp> +#include <scm/detail/convert.hpp> + +namespace scm { +namespace detail { +// this anonymous namespace should help avoiding registration clashes +// among translation units. +namespace { + +template <typename Tag, typename Fn> +auto finalizer_wrapper_impl(Fn fn, pack<>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] { invoke(fn_); }; +} +template <typename Tag, typename Fn, typename T1> +auto finalizer_wrapper_impl(Fn fn, pack<T1>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1) { invoke(fn_, to_cpp<T1>(a1)); }; +} +template <typename Tag, typename Fn, typename T1, typename T2> +auto finalizer_wrapper_impl(Fn fn, pack<T1, T2>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1, SCM a2) { + invoke(fn_, to_cpp<T1>(a1), to_cpp<T2>(a2)); + }; +} +template <typename Tag, typename Fn, typename T1, typename T2, typename T3> +auto finalizer_wrapper_impl(Fn fn, pack<T1, T2, T3>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1, SCM a2, SCM a3) { + invoke(fn_, to_cpp<T1>(a1), to_cpp<T2>(a2), to_cpp<T3>(a3)); + }; +} + +template <typename Tag, typename Fn> +auto finalizer_wrapper(Fn fn) +{ + return finalizer_wrapper_impl<Tag>(fn, function_args_t<Fn>{}); +} + +} // anonymous namespace +} // namespace detail +} // namespace scm diff --git a/third_party/immer/extra/guile/scm/detail/function_args.hpp b/third_party/immer/extra/guile/scm/detail/function_args.hpp new file mode 100644 index 000000000000..809e3eb1979b --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/function_args.hpp @@ -0,0 +1,21 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +#include <scm/detail/pack.hpp> +#include <boost/callable_traits/args.hpp> + +namespace scm { +namespace detail { + +template <typename Fn> +using function_args_t = boost::callable_traits::args_t<Fn, pack>; + +} // namespace detail +} // namespace scm diff --git a/third_party/immer/extra/guile/scm/detail/invoke.hpp b/third_party/immer/extra/guile/scm/detail/invoke.hpp new file mode 100644 index 000000000000..d9f2b37ccece --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/invoke.hpp @@ -0,0 +1,39 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +// Adapted from the official std::invoke proposal: +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4169.html + +#include <type_traits> +#include <functional> + +namespace scm { +namespace detail { + +template <typename Functor, typename... Args> +std::enable_if_t< + std::is_member_pointer<std::decay_t<Functor>>::value, + std::result_of_t<Functor&&(Args&&...)>> +invoke(Functor&& f, Args&&... args) +{ + return std::mem_fn(f)(std::forward<Args>(args)...); +} + +template <typename Functor, typename... Args> +std::enable_if_t< + !std::is_member_pointer<std::decay_t<Functor>>::value, + std::result_of_t<Functor&&(Args&&...)>> +invoke(Functor&& f, Args&&... args) +{ + return std::forward<Functor>(f)(std::forward<Args>(args)...); +} + +} // namespace detail +} // namespace scm diff --git a/third_party/immer/extra/guile/scm/detail/pack.hpp b/third_party/immer/extra/guile/scm/detail/pack.hpp new file mode 100644 index 000000000000..9a1813570bcd --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/pack.hpp @@ -0,0 +1,52 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +namespace scm { +namespace detail { + +struct none_t; + +template <typename... Ts> +struct pack {}; + +template <typename Pack> +struct pack_size; + +template <typename... Ts> +struct pack_size<pack<Ts...>> +{ + static constexpr auto value = sizeof...(Ts); +}; + +template <typename Pack> +constexpr auto pack_size_v = pack_size<Pack>::value; + +template <typename Pack> +struct pack_last +{ + using type = none_t; +}; + +template <typename T, typename ...Ts> +struct pack_last<pack<T, Ts...>> + : pack_last<pack<Ts...>> +{}; + +template <typename T> +struct pack_last<pack<T>> +{ + using type = T; +}; + +template <typename Pack> +using pack_last_t = typename pack_last<Pack>::type; + +} // namespace detail +} // namespace scm diff --git a/third_party/immer/extra/guile/scm/detail/subr_wrapper.hpp b/third_party/immer/extra/guile/scm/detail/subr_wrapper.hpp new file mode 100644 index 000000000000..fc11ff1c51ec --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/subr_wrapper.hpp @@ -0,0 +1,111 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +#include <scm/detail/invoke.hpp> +#include <scm/detail/function_args.hpp> +#include <scm/detail/convert.hpp> + +namespace scm { +namespace detail { + +// this anonymous namespace should help avoiding registration clashes +// among translation units. +namespace { + +template <typename Tag, typename R, typename Fn> +auto subr_wrapper_impl(Fn fn, pack<R>, pack<>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] () -> SCM { return to_scm(invoke(fn_)); }; +} +template <typename Tag, typename Fn, typename R, typename T1> +auto subr_wrapper_impl(Fn fn, pack<R>, pack<T1>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1) -> SCM { + return to_scm(invoke(fn_, to_cpp<T1>(a1))); + }; +} +template <typename Tag, typename Fn, typename R, typename T1, typename T2> +auto subr_wrapper_impl(Fn fn, pack<R>, pack<T1, T2>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1, SCM a2) -> SCM { + return to_scm(invoke(fn_, to_cpp<T1>(a1), to_cpp<T2>(a2))); + }; +} +template <typename Tag, typename Fn, typename R, typename T1, typename T2, + typename T3> +auto subr_wrapper_impl(Fn fn, pack<R>, pack<T1, T2, T3>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1, SCM a2, SCM a3) -> SCM { + return to_scm(invoke(fn_, to_cpp<T1>(a1), to_cpp<T2>(a2), + to_cpp<T3>(a3))); + }; +} + +template <typename Tag, typename Fn> +auto subr_wrapper_impl(Fn fn, pack<void>, pack<>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] () -> SCM { invoke(fn_); return SCM_UNSPECIFIED; }; +} +template <typename Tag, typename Fn, typename T1> +auto subr_wrapper_impl(Fn fn, pack<void>, pack<T1>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1) -> SCM { + invoke(fn_, to_cpp<T1>(a1)); return SCM_UNSPECIFIED; + }; +} +template <typename Tag, typename Fn, typename T1, typename T2> +auto subr_wrapper_impl(Fn fn, pack<void>, pack<T1, T2>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1, SCM a2) -> SCM { + invoke(fn_, to_cpp<T1>(a1), to_cpp<T2>(a2)); + return SCM_UNSPECIFIED; + }; +} +template <typename Tag, typename Fn, typename T1, typename T2, typename T3> +auto subr_wrapper_impl(Fn fn, pack<void>, pack<T1, T2, T3>) +{ + check_call_once<Tag, Fn>(); + static const Fn fn_ = fn; + return [] (SCM a1, SCM a2, SCM a3) -> SCM { + invoke(fn_, to_cpp<T1>(a1), to_cpp<T2>(a2), to_cpp<T3>(a3)); + return SCM_UNSPECIFIED; + }; +} + +template <typename Tag, typename Fn, typename... Args> +auto subr_wrapper_aux(Fn fn, pack<Args...>) +{ + return subr_wrapper_impl<Tag>( + fn, pack<std::result_of_t<Fn(Args...)>>{}, pack<Args...>{}); +} + +template <typename Tag, typename Fn> +auto subr_wrapper(Fn fn) +{ + return subr_wrapper_aux<Tag>(fn, function_args_t<Fn>{}); +} + +} // anonymous namespace +} // namespace detail +} // namespace scm diff --git a/third_party/immer/extra/guile/scm/detail/util.hpp b/third_party/immer/extra/guile/scm/detail/util.hpp new file mode 100644 index 000000000000..fdc323722e99 --- /dev/null +++ b/third_party/immer/extra/guile/scm/detail/util.hpp @@ -0,0 +1,49 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +#include <libguile.h> + +namespace scm { +namespace detail { + +#define SCM_DECLTYPE_RETURN(...) \ + decltype(__VA_ARGS__) \ + { return __VA_ARGS__; } \ + /**/ + +template <typename... Ts> +constexpr bool is_valid_v = true; + +template <typename... Ts> +using is_valid_t = void; + +template <typename... Ts> +void check_call_once() +{ + static bool called = false; + if (called) scm_misc_error (nullptr, "Double defined binding. \ +This may be caused because there are multiple C++ binding groups in the same \ +translation unit. You may solve this by using different type tags for each \ +binding group.", SCM_EOL); + called = true; +} + +struct move_sequence +{ + move_sequence() = default; + move_sequence(const move_sequence&) = delete; + move_sequence(move_sequence&& other) + { other.moved_from_ = true; }; + + bool moved_from_ = false; +}; + +} // namespace detail +} // namespace scm |