git.iko.soy/rowtype-yoga/purescript-native
on 2f17513 help sign in
rowtype-yoga/purescript-native/pcc/runtime/purescript.hh
555 lines 17 kB history raw
1///////////////////////////////////////////////////////////////////////////////
2//
3// Module : purescript.hh
4// Copyright : (c) Andy Arvanitis 2015
5// License : MIT
6//
7// Maintainer : Andy Arvanitis <andy.arvanitis@gmail.com>
8// Stability : experimental
9// Portability :
10//
11// Basic types and functions to support purescript-to-C++1x rendering
12//
13///////////////////////////////////////////////////////////////////////////////
14//
15#ifndef PureScript_HH
16#define PureScript_HH
18#if !defined(__cplusplus)
19#error This is a C++ file!
20#endif
22// Standard includes
24#if defined(DEBUG)
25 #include <cassert>
26 #include <limits>
27 #define IF_DEBUG(x) x
28#else
29 #define NDEBUG
30 #undef assert
31 #define assert(x)
32 #define IF_DEBUG(_)
33#endif
35#include <functional>
36#include <string>
37#include <array>
38#include <deque>
39#include <unordered_map>
40#include <utility>
41#include <stdexcept>
42#include <iso646.h> // mostly for MS Visual Studio compiler
43#include "purescript_memory.hh"
45namespace PureScript {
47using cstring = const char *;
48using std::string;
49using std::nullptr_t;
50using std::runtime_error;
52namespace Private {
53 struct SymbolGeneratorAnchor {};
55 template <typename T>
56 struct SymbolGenerator {
57 constexpr static SymbolGeneratorAnchor anchor = SymbolGeneratorAnchor{};
58 };
59 template <typename T>
60 constexpr SymbolGeneratorAnchor SymbolGenerator<T>::anchor;
62 using Symbol = const SymbolGeneratorAnchor *;
65#define DEFINE_SYMBOL(S) namespace PureScript { \
66 namespace Private { \
67 namespace Symbols { \
68 struct S_ ## S {}; \
69 } \
70 } \
71 }
72#define SYM(S) (&Private::SymbolGenerator<::PureScript::Private::Symbols::S_ ## S>::anchor)
74constexpr bool undefined = false;
76// TODO: Not a real limit, just used for simpler accessors
77static constexpr size_t unknown_size = 64;
79// A variant data class designed to provide some features of dynamic typing.
80//
81class any {
83 private:
84 static constexpr auto _managed_ = 0x10;
86 public:
87 enum class Tag {
88 Unknown,
89 Thunk,
90 Integer,
91 Double,
92 Character,
93 Boolean,
94 Function,
95 EffFunction,
96 RawPointer,
97 String = _managed_,
98 Dictionary,
99 Data,
100 Array,
101 Record,
102 Closure,
103 EffClosure,
104 Pointer,
105 Invalid
106 };
108 private:
109 mutable Tag tag;
111 inline static auto isManaged(const Tag tag) -> decltype(_managed_) {
112 return static_cast<decltype(_managed_)>(tag) & _managed_;
113 }
114 static_assert(static_cast<decltype(_managed_)>(Tag::Invalid) & _managed_, "outside of range");
116 public:
117 struct as_thunk {
118 };
119 static constexpr as_thunk unthunk = as_thunk{};
121 using dict_pair = std::pair<const Private::Symbol, const any>;
123 template <size_t N>
124 using dict = std::array<const dict_pair, N>;
126 template <size_t N>
127 using data = std::array<const any, N>;
129 using array = std::deque<any WITH_ALLOCATOR(any)>;
130 using record = std::unordered_map<std::string, any WITH_ALLOCATOR_PAIR(std::string, any)>;
132 using fn = auto (*)(const any&) -> any;
133 using eff_fn = auto (*)() -> any;
134 using thunk = auto (*)(const as_thunk) -> const any&;
136 private:
137 class Closure {
138 public:
139 virtual auto operator()(const any&) const -> any = 0;
140 virtual ~Closure();
141 };
143 template <typename T>
144 class Closure_ : public Closure {
145 const T lambda;
146 public:
147 Closure_(const T& l) noexcept : lambda(l) {}
148 auto operator()(const any& arg) const -> any override {
149 return lambda(arg);
150 }
151 };
153 class EffClosure {
154 public:
155 virtual auto operator()() const -> any = 0;
156 virtual ~EffClosure();
157 };
159 template <typename T>
160 class EffClosure_ : public EffClosure {
161 const T lambda;
162 public:
163 EffClosure_(const T& l) noexcept : lambda(l) {}
164 auto operator()() const -> any override {
165 return lambda();
166 }
167 };
169 private:
170 union {
171 mutable thunk t;
172 mutable int i;
173 mutable double d;
174 mutable char32_t c;
175 mutable bool b;
176 mutable fn f;
177 mutable eff_fn e;
178 mutable void * v;
179 mutable uint64_t u;
180 mutable managed<void> p;
181 };
183 public:
185 any(const int val) noexcept : tag(Tag::Integer), i(val) {}
186 any(const long val) noexcept : tag(Tag::Integer), i(static_cast<decltype(i)>(val)) {
187 assert(val >= std::numeric_limits<decltype(i)>::min() &&
188 val <= std::numeric_limits<decltype(i)>::max());
189 }
190 any(const double val) noexcept : tag(Tag::Double), d(val) {}
191 any(const char32_t val) noexcept : tag(Tag::Character), c(val) {}
192 any(const char val) noexcept : tag(Tag::Character), c(val) {}
194 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>
195 any(const T val) noexcept : tag(Tag::Boolean), b(val) {}
197 any(const char * val) : tag(Tag::String), p(make_managed_and_finalized<string>(val)) {}
198 any(const string& val) : tag(Tag::String), p(make_managed_and_finalized<string>(val)) {}
199 any(string&& val) noexcept : tag(Tag::String), p(make_managed_and_finalized<string>(std::move(val))) {}
201 any(const managed<string>& val) noexcept : tag(Tag::String), p(val) {}
202 any(managed<string>&& val) noexcept : tag(Tag::String), p(std::move(val)) {}
204 template <size_t N>
205 any(dict<N>&& val) noexcept : tag(Tag::Dictionary), p(make_managed<dict<N>>(std::move(val))) {}
207 template <size_t N>
208 any(data<N>&& val) noexcept : tag(Tag::Data), p(make_managed<data<N>>(std::move(val))) {}
210 any(const array& val) : tag(Tag::Array), p(make_managed<array>(val)) {}
211 any(array&& val) noexcept : tag(Tag::Array), p(make_managed<array>(std::move(val))) {}
213 any(const record& val) : tag(Tag::Record), p(make_managed<record>(val)) {}
214 any(record&& val) noexcept : tag(Tag::Record), p(make_managed<record>(std::move(val))) {}
216 template <typename T>
217 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0) noexcept
218 : tag(Tag::Function), f(val) {}
220 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&
221 !std::is_convertible<T,fn>::value>::type>
222 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any(const any&)>,T>::value>::type* = 0)
223 : tag(Tag::Closure), p(make_managed<Closure_<T>>(val)) {}
225 template <typename T>
226 any(const T& val, typename std::enable_if<std::is_convertible<T,eff_fn>::value>::type* = 0) noexcept
227 : tag(Tag::EffFunction), e(val) {}
229 template <typename T,
230 typename = typename std::enable_if<!std::is_same<any,T>::value &&
231 !std::is_convertible<T,eff_fn>::value>::type>
232 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any()>,T>::value>::type* = 0)
233 : tag(Tag::EffClosure), p(make_managed<EffClosure_<T>>(val)) {}
235 template <typename T>
236 any(const T& val, typename std::enable_if<std::is_convertible<T,thunk>::value>::type* = 0) noexcept
237 : tag(Tag::Thunk), t(val) {}
239 template <typename T,
240 typename = typename std::enable_if<std::is_class<typename std::remove_pointer<T>::type>::value>::type>
241 any(const T& val, typename std::enable_if<IS_POINTER_TYPE(T)::value>::type* = 0) noexcept
242 : tag(Tag::Pointer), p(val) {}
244 template <typename T>
245 any(T&& val, typename std::enable_if<std::is_assignable<managed<void>,T>::value>::type* = 0) noexcept
246 : tag(Tag::Pointer), p(std::move(val)) {}
248 // Explicit void* to raw pointer value
249 template <typename T>
250 any(const T& val, typename std::enable_if<std::is_same<T,void*>::value>::type* = 0) noexcept
251 : tag(Tag::RawPointer), v(val) {}
253 any(nullptr_t) noexcept : tag(Tag::RawPointer), v(nullptr) {}
256#if !defined(USE_GC)
257 private:
258 auto destruct() const noexcept -> void {
259 if (isManaged(tag)) {
260 p.~managed<void>();
261 }
262 }
264 static_assert(sizeof(u) >= sizeof(t), "size assumption");
265 static_assert(sizeof(u) >= sizeof(i), "size assumption");
266 static_assert(sizeof(u) >= sizeof(d), "size assumption");
267 static_assert(sizeof(u) >= sizeof(c), "size assumption");
268 static_assert(sizeof(u) >= sizeof(b), "size assumption");
269 static_assert(sizeof(u) >= sizeof(f), "size assumption");
270 static_assert(sizeof(u) >= sizeof(e), "size assumption");
271 static_assert(sizeof(u) >= sizeof(v), "size assumption");
273 auto copyAssign(const any& other) const noexcept -> void {
274 if (isManaged(other.tag)) {
275 new (&p) managed<void>(other.p);
276 } else {
277 u = other.u;
278 }
279 }
280 auto moveAssign(any& other) const noexcept -> void {
281 if (isManaged(other.tag)) {
282 new (&p) managed<void>(std::move(other.p));
283 } else {
284 u = other.u;
285 }
286 }
288 public:
289 any(const any& other) noexcept : tag(other.tag) {
290 copyAssign(other);
291 }
293 any(any&& other) noexcept : tag(other.tag) {
294 moveAssign(other);
295 }
297 auto operator=(const any& rhs) noexcept -> any& {
298 destruct();
299 tag = rhs.tag;
300 copyAssign(rhs);
301 return *this;
302 }
304 auto operator=(any&& rhs) noexcept -> any& {
305 destruct();
306 tag = rhs.tag;
307 moveAssign(rhs);
308 return *this;
309 }
311 ~any() {
312 destruct();
313 }
314#endif // !defined(USE_GC)
316 public:
317 any() = delete;
319 auto operator()(const any&) const -> any;
320 auto operator()(const as_thunk) const -> const any&;
321 auto operator()() const -> any;
323 operator int() const;
324 operator double() const;
325 operator bool() const;
326 operator char32_t() const;
327 operator char() const;
328 operator size_t() const;
329 operator const string&() const;
330 operator const char *() const;
331 operator const array&() const;
332 operator const record&() const;
334 auto operator[](const size_t) const -> const any&;
335 auto at(const std::string&) const -> const any&;
336 auto size() const -> size_t;
337 auto empty() const -> bool;
338 auto contains(const Private::Symbol) const -> bool;
340 auto extractPointer(IF_DEBUG(const Tag)) const -> void*;
342 auto rawPointer() const -> void* {
343 const any& variant = unthunkVariant(*this);
344 assert(tag == Tag::RawPointer);
345 return variant.v;
346 }
348 static auto unthunkVariant(const any&) -> const any&;
350 #define DEFINE_OPERATOR(op) \
351 template <typename T, \
352 typename = typename std::enable_if<!std::is_same<T,any>::value && \
353 !std::is_same<T,const char *>::value>::type> \
354 inline friend auto operator op (const any& lhs, T rhs) -> T { \
355 return static_cast<typename std::add_lvalue_reference<typename std::add_const<T>::type >::type>(lhs) op rhs; \
356 } \
357 template <typename T, \
358 typename = typename std::enable_if<!std::is_same<T,any>::value && \
359 !std::is_same<T,const char *>::value>::type> \
360 inline friend auto operator op (T lhs, const any& rhs) -> T { \
361 return lhs op static_cast<typename std::add_lvalue_reference<typename std::add_const<T>::type >::type>(rhs); \
362 } \
363 friend auto operator op (const any&, const any&) -> any; \
365 #define DEFINE_COMPARISON_OPERATOR(op) \
366 template <typename T, \
367 typename = typename std::enable_if<!std::is_same<T,any>::value && \
368 !std::is_same<T,const char *>::value>::type> \
369 inline friend auto operator op (const any& lhs, T rhs) -> bool { \
370 return static_cast<typename std::add_lvalue_reference<typename std::add_const<T>::type >::type>(lhs) op rhs; \
371 } \
372 template <typename T, \
373 typename = typename std::enable_if<!std::is_same<T,any>::value && \
374 !std::is_same<T,const char *>::value>::type> \
375 inline friend auto operator op (T lhs, const any& rhs) -> bool { \
376 return lhs op static_cast<typename std::add_lvalue_reference<typename std::add_const<T>::type >::type>(rhs); \
377 } \
378 inline friend auto operator op (const any& lhs, const char * rhs) -> bool { \
379 return static_cast<const string&>(lhs) op rhs; \
380 } \
381 inline friend auto operator op (const char * lhs, const any& rhs) -> bool { \
382 return lhs op static_cast<const string&>(rhs); \
383 } \
384 friend auto operator op (const any&, const any&) -> bool; \
386 DEFINE_COMPARISON_OPERATOR(==)
387 DEFINE_COMPARISON_OPERATOR(!=)
388 DEFINE_COMPARISON_OPERATOR(<)
389 DEFINE_COMPARISON_OPERATOR(<=)
390 DEFINE_COMPARISON_OPERATOR(>)
391 DEFINE_COMPARISON_OPERATOR(>=)
393 DEFINE_OPERATOR(+)
394 DEFINE_OPERATOR(-)
395 DEFINE_OPERATOR(*)
396 DEFINE_OPERATOR(/)
397 DEFINE_OPERATOR(%)
399 inline friend auto operator+(const any& lhs, const char * rhs) -> string {
400 return static_cast<const string&>(lhs) + rhs;
401 }
402 inline friend auto operator+(const char * lhs, const any& rhs) -> string {
403 return lhs + static_cast<const string&>(rhs);
404 }
406 friend auto operator-(const any&) -> any; // unary negate
408}; // class any
410namespace Private {
411 template <typename T, typename U=void>
412 struct TagHelper {};
414 template <size_t N>
415 struct TagHelper<any::dict<N>> {
416 static constexpr any::Tag tag = any::Tag::Dictionary;
417 };
419 template <size_t N>
420 struct TagHelper<any::data<N>> {
421 static constexpr any::Tag tag = any::Tag::Data;
422 };
424 template <typename T>
425 struct TagHelper<T> {
426 static constexpr any::Tag tag = any::Tag::Pointer;
427 };
430// Pass-through
431template <typename T>
432constexpr auto cast(const T& a) -> const T& {
433 return a;
436template <typename T>
437inline auto cast(const any& a) ->
438 typename std::enable_if<std::is_arithmetic<T>::value ||
439 std::is_same<T,const char *>::value, T>::type {
440 return a;
443template <typename T,
444 typename = typename std::enable_if<std::is_class<T>::value>::type>
445inline auto cast(const any& a) -> T& {
446 return *static_cast<T*>(a.extractPointer(IF_DEBUG(Private::TagHelper<T>::tag)));
449template <typename T,
450 typename = typename std::enable_if<std::is_pointer<T>::value &&
451 !std::is_same<T,void*>::value &&
452 !std::is_same<T,const char *>::value>::type>
453inline auto cast(const any& a) -> T {
454 return static_cast<T>(a.extractPointer(IF_DEBUG(Private::TagHelper<T>::tag)));
457template <typename T>
458inline auto cast(const any& a) ->
459 typename std::enable_if<std::is_same<void*, T>::value, T>::type {
460 return a.rawPointer();
463namespace dict {
464 template <size_t N, typename T>
465 inline auto get(const T& a) ->
466 typename std::enable_if<!std::is_same<any, T>::value, const any&>::type {
467 return a[N].second;
468 }
470 template <size_t N>
471 inline auto get(const any& a) -> const any& {
472 return cast<any::dict<N+1>>(a)[N].second;
473 }
475 template <size_t N>
476 inline auto get(const Private::Symbol key, const any::dict<N>& a) -> const any& {
477 static_assert(N > 0, "dict size must be greater than zero");
478 typename std::remove_reference<decltype(a)>::type::size_type i = 0;
479 do {
480 if (a[i].first == key) {
481 return a[i].second;
482 }
483 } while (a[++i].first != nullptr);
484 assert(false && "dict key not found");
485 static const any invalid_key(nullptr);
486 return invalid_key;
487 }
489 inline auto get(const Private::Symbol key, const any& a) -> const any& {
490 return get(key, cast<any::dict<unknown_size>>(a));
491 }
493 #define P(N) any::dict_pair&& arg ## N
494 #define T(N) any::dict<N+1>
495 #define E(N) std::forward<decltype(arg ## N)>(arg ## N)
496 #define M(...) {{ __VA_ARGS__, { nullptr, nullptr } }}
498 inline auto make(P(1)) -> T(1) {
499 return T(1) M(E(1));
500 }
501 inline auto make(P(1), P(2)) -> T(2) {
502 return T(2) M(E(1), E(2));
503 }
504 inline auto make(P(1), P(2), P(3)) -> T(3) {
505 return T(3) M(E(1), E(2), E(3));
506 }
507 inline auto make(P(1), P(2), P(3), P(4)) -> T(4) {
508 return T(4) M(E(1), E(2), E(3), E(4));
509 }
510 inline auto make(P(1), P(2), P(3), P(4), P(5)) -> T(5) {
511 return T(5) M(E(1), E(2), E(3), E(4), E(5));
512 }
513 inline auto make(P(1), P(2), P(3), P(4), P(5), P(6)) -> T(6) {
514 return T(6) M(E(1), E(2), E(3), E(4), E(5), E(6));
515 }
516 inline auto make(P(1), P(2), P(3), P(4), P(5), P(6), P(7)) -> T(7) {
517 return T(7) M(E(1), E(2), E(3), E(4), E(5), E(6), E(7));
518 }
519 inline auto make(P(1), P(2), P(3), P(4), P(5), P(6), P(7), P(8)) -> T(8) {
520 return T(8) M(E(1), E(2), E(3), E(4), E(5), E(6), E(7), E(8));
521 }
523 #undef P
524 #undef T
525 #undef E
526 #undef M
529namespace data {
530 template <size_t N, typename T>
531 inline auto get(const T& a) ->
532 typename std::enable_if<!std::is_same<any, T>::value, const any&>::type {
533 return a[N];
534 }
536 template <size_t N>
537 inline auto get(const any& a) -> const any& {
538 return cast<any::data<N+1>>(a)[N];
539 }
541 template <typename T>
542 inline auto ctor(const T& a) -> int {
543 return get<0>(a);
544 }
547} // namespace PureScript
549#undef WITH_ALLOCATOR
550#undef WITH_ALLOCATOR_PAIR
551#undef IS_POINTER_TYPE
552#undef DEFINE_OPERATOR
553#undef DEFINE_COMPARISON_OPERATOR
555#endif // PureScript_HH