git.iko.soy/rowtype-yoga/purescript-native
on c7392d6 help sign in
rowtype-yoga/purescript-native/pcc/include/purescript.cc
487 lines 17 kB history raw
1///////////////////////////////////////////////////////////////////////////////
2//
3// Module : purescript.cc
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#include <cstring>
16#include "PureScript.hh"
18namespace PureScript {
20#define COPY_DATA(src) \
21 switch (type) { \
22 case Type::Integer: i = src.i; break; \
23 case Type::Double: d = src.d; break; \
24 case Type::Character: c = src.c; break; \
25 case Type::Boolean: b = src.b; break; \
26 case Type::StringLiteral: r = src.r; break; \
27 case Type::String: new (&s) shared<std::string>(src.s); break; \
28 case Type::Map: new (&m) shared<map>(src.m); break; \
29 case Type::Vector: new (&v) shared<vector>(src.v); break; \
30 case Type::Function: f = src.f; break; \
31 case Type::Closure: new (&l) shared<closure>(src.l); break; \
32 case Type::EffFunction: new (&e) shared<eff_fn>(src.e); break; \
33 case Type::Thunk: t = src.t; break; \
34 case Type::Pointer: new (&p) shared<void>(src.p); break; \
35 \
36 default: assert(false && "Unsupported type in copy"); \
37 }
39#define MOVE_DATA(src) \
40 switch (type) { \
41 case Type::Integer: i = src.i; break; \
42 case Type::Double: d = src.d; break; \
43 case Type::Character: c = src.c; break; \
44 case Type::Boolean: b = src.b; break; \
45 case Type::StringLiteral: r = src.r; break; \
46 case Type::String: new (&s) shared<std::string>(std::move(src.s)); break; \
47 case Type::Map: new (&m) shared<map>(std::move(src.m)); break; \
48 case Type::Vector: new (&v) shared<vector>(std::move(src.v)); break; \
49 case Type::Function: f = src.f; break; \
50 case Type::Closure: new (&l) shared<closure>(std::move(src.l)); break; \
51 case Type::EffFunction: new (&e) shared<eff_fn>(std::move(src.e)); break; \
52 case Type::Thunk: t = src.t; break; \
53 case Type::Pointer: new (&p) shared<void>(std::move(src.p)); break; \
54 \
55 default: assert(false && "Unsupported type in move"); \
56 }
58any::any(const any& other) : type(other.type) {
59 COPY_DATA(other);
62any::any(any&& other) noexcept : type(other.type) {
63 MOVE_DATA(other);
66auto any::operator=(const any& rhs) -> any& {
67 type = rhs.type;
68 COPY_DATA(rhs);
69 return *this;
72// Takes ownership -- might need to reconsider this
73auto any::operator=(any& rhs) noexcept -> any& {
74 type = rhs.type;
75 MOVE_DATA(rhs);
76 return *this;
79auto any::operator=(any&& rhs) noexcept -> any& {
80 type = rhs.type;
81 MOVE_DATA(rhs);
82 return *this;
85any::~any() {
86 switch (type) {
87 case Type::Integer: ; break;
88 case Type::Double: ; break;
89 case Type::Character: ; break;
90 case Type::Boolean: ; break;
91 case Type::StringLiteral: ; break;
92 case Type::String: s.~shared<std::string>(); break;
93 case Type::Map: m.~shared<map>(); break;
94 case Type::Vector: v.~shared<vector>(); break;
95 case Type::Function: ; break;
96 case Type::Closure: l.~shared<closure>(); break;
97 case Type::EffFunction: e.~shared<eff_fn>(); break;
98 case Type::Thunk: ; break;
99 case Type::Pointer: p.~shared<void>(); break;
101 default: assert(false && "Unsupported type in destructor");
102 }
103};
105#define RETURN_VALUE(TYPE, VAL, FN) \
106 if (type == TYPE) { \
107 return FN(VAL); \
108 } \
109 const any* valuePtr = this; \
110 do { \
111 assert(valuePtr->type == Type::Thunk); \
112 const any& value = (*valuePtr->t)(unthunk); \
113 if (value.type == TYPE) { \
114 return FN(value.VAL); \
115 } \
116 valuePtr = &value; \
117 } while (valuePtr->type != Type::Unknown); \
118 assert(false && "Unknown value type"); \
119 return FN(VAL);
121template <typename T>
122auto any::cast() const -> typename std::enable_if<std::is_same<T, long>::value, T>::type {
123 RETURN_VALUE(Type::Integer, i,)
125template auto any::cast<long>() const -> long;
127template <typename T>
128auto any::cast() const -> typename std::enable_if<std::is_same<T, double>::value, T>::type {
129 RETURN_VALUE(Type::Double, d,)
131template auto any::cast<double>() const -> double;
133template <typename T>
134auto any::cast() const -> typename std::enable_if<std::is_same<T, char>::value, T>::type {
135 RETURN_VALUE(Type::Character, c,)
137template auto any::cast<char>() const -> char;
139template <typename T>
140auto any::cast() const -> typename std::enable_if<std::is_same<T, bool>::value, T>::type {
141 RETURN_VALUE(Type::Boolean, b,)
143template auto any::cast<bool>() const -> bool;
145template <typename T>
146auto any::cast() const -> typename std::enable_if<std::is_same<T, string>::value, T>::type {
147 const any& val = extractValue(*this);
148 if (val.type == Type::StringLiteral) {
149 return val.r;
150 }
151 assert(val.type == Type::String);
152 return val.s->c_str();
154template auto any::cast<string>() const -> string;
156template <typename T>
157auto any::cast() const -> typename std::enable_if<std::is_same<T, map>::value, const T&>::type {
158 RETURN_VALUE(Type::Map, m, *)
160template auto any::cast<any::map>() const -> const map&;
162template <typename T>
163auto any::cast() const -> typename std::enable_if<std::is_same<T, vector>::value, const T&>::type {
164 RETURN_VALUE(Type::Vector, v, *)
166template auto any::cast<any::vector>() const -> const vector&;
168auto any::operator()(const any& arg) const -> any {
169 if (type == Type::Function) {
170 return (*f)(arg);
171 }
172 if (type == Type::Closure) {
173 return (*l)(arg);
174 }
175 const any* valuePtr = this;
176 do {
177 assert(valuePtr->type == Type::Thunk);
178 const any& value = (*valuePtr->t)(unthunk);
179 if (value.type == Type::Function) {
180 return (*value.f)(arg);
181 }
182 if (value.type == Type::Closure) {
183 return (*value.l)(arg);
184 }
185 valuePtr = &value;
186 } while (valuePtr->type != Type::Unknown);
187 assert(false && "Unknown value type");
188 return nullptr;
191auto any::operator()(const as_thunk) const -> const any& {
192 assert(type == Type::Thunk);
193 return (*t)(unthunk);
196auto any::operator()() const -> any {
197 if (type == Type::EffFunction) {
198 return (*e)();
199 }
200 const any* valuePtr = this;
201 do {
202 assert(valuePtr->type == Type::Thunk);
203 const any& value = (*valuePtr->t)(unthunk);
204 if (value.type == Type::EffFunction) {
205 return (*value.e)();
206 }
207 valuePtr = &value;
208 } while (valuePtr->type != Type::Unknown);
209 assert(false && "Unknown value type");
210 return nullptr;
213any::operator long() const {
214 RETURN_VALUE(Type::Integer, i,)
217any::operator double() const {
218 RETURN_VALUE(Type::Double, d,)
221any::operator bool() const {
222 RETURN_VALUE(Type::Boolean, b,)
225any::operator string() const {
226 return cast<string>();
229any::operator const map&() const {
230 RETURN_VALUE(Type::Map, m, *)
233any::operator const vector&() const {
234 RETURN_VALUE(Type::Vector, v, *)
237auto any::extractPointer() const -> void* {
238 RETURN_VALUE(Type::Pointer, p.get(),)
241auto any::extractValue(const any& a) -> const any& {
242 if (a.type != Type::Thunk) {
243 return a;
244 }
245 const any* valuePtr = &a;
246 do {
247 const any& value = (*valuePtr->t)(unthunk);
248 if (value.type != Type::Thunk) {
249 return value;
250 }
251 valuePtr = &value;
252 } while (valuePtr->type != Type::Unknown);
253 assert(false && "Unknown value type");
254 return a;
257auto any::operator[](const char rhs[]) const -> const any& {
258 const any& val = extractValue(*this);
259 assert(val.type == Type::Map);
260 for (any::map::const_iterator it = val.m->begin(), end = val.m->end(); it != end; ++it) {
261 if (it->first == rhs || strcmp(it->first, rhs) == 0) {
262 return it->second;
263 }
264 }
265 throw runtime_error("map key not found");
268auto any::operator[](const vector::size_type rhs) const -> const any& {
269 const any& val = extractValue(*this);
270 assert(val.type == Type::Vector);
271 return (*val.v)[rhs];
274auto any::operator[](const any& rhs) const -> const any& {
275 const any& val = extractValue(*this);
276 assert(val.type == Type::Vector);
277 return (*val.v)[rhs.cast<long>()];
280auto any::contains(const char key[]) const -> bool {
281 const any& val = extractValue(*this);
282 assert(val.type == Type::Map);
283 for (any::map::const_iterator it = val.m->begin(), end = val.m->end(); it != end; ++it) {
284 if (it->first == key || strcmp(it->first, key) == 0) {
285 return true;
286 }
287 }
288 return false;
291//-----------------------------------------------------------------------------
292// Operator helper macros
293//-----------------------------------------------------------------------------
295#define DEFINE_OPERATOR(op, ty, rty) \
296auto operator op (const any& lhs, ty rhs) -> rty { \
297 return lhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>() op rhs; \
298} \
299auto operator op (ty lhs, const any& rhs) -> rty { \
300 return lhs op rhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>(); \
303#define DEFINE_CSTR_EQUALS_OPERATOR() \
304 auto operator==(const any& lhs_, const char * rhs) -> bool { \
305 const any& lhs = any::extractValue(lhs_); \
306 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
307 if (lhs.type == any::Type::StringLiteral) { \
308 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \
309 } \
310 return strcmp(lhs.s->c_str(), rhs) == 0; \
311 } \
312 auto operator==(const char * lhs, const any& rhs_) -> bool { \
313 const any& rhs = any::extractValue(rhs_); \
314 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
315 if (rhs.type == any::Type::StringLiteral) { \
316 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \
317 } \
318 return strcmp(lhs, rhs.s->c_str()) == 0; \
319 }
321#define DEFINE_CSTR_COMPARISON_OPERATOR(op) \
322 auto operator op (const any& lhs, const char * rhs) -> bool { \
323 return strcmp(lhs.cast<string>(), rhs) op 0; \
324 } \
325 auto operator op (const char * lhs, const any& rhs) -> bool { \
326 return strcmp(lhs, rhs.cast<string>()) op 0; \
327 }
329#define DEFINE_COMPARISON_OPERATOR(op) \
330 auto operator op (const any& lhs_, const any& rhs_) -> bool { \
331 const any& lhs = any::extractValue(lhs_); \
332 const any& rhs = any::extractValue(rhs_); \
333 switch (lhs.type) { \
334 case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i op rhs.i; \
335 case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d op rhs.d; \
336 case any::Type::Character: assert(lhs.type == any::Type::Character); return lhs.c op rhs.c; \
337 case any::Type::Boolean: assert(lhs.type == any::Type::Boolean); return lhs.b op rhs.b; \
338 case any::Type::StringLiteral: \
339 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
340 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
341 return strcmp(lhs.r, rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
342 case any::Type::String: \
343 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
344 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
345 return strcmp(lhs.s->c_str(), rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
346 case any::Type::Pointer: return lhs.p op rhs.p; \
347 default: assert(false && "Unsupported type for operator " #op); \
348 } \
349 return false; \
350 } \
351 DEFINE_OPERATOR(op, long, bool) \
352 DEFINE_OPERATOR(op, double, bool) \
353 DEFINE_OPERATOR(op, char, bool) \
354 DEFINE_OPERATOR(op, bool, bool) \
356//-----------------------------------------------------------------------------
357// Operator definitions
358//-----------------------------------------------------------------------------
360DEFINE_COMPARISON_OPERATOR(==)
361DEFINE_COMPARISON_OPERATOR(!=)
362DEFINE_COMPARISON_OPERATOR(<)
363DEFINE_COMPARISON_OPERATOR(<=)
364DEFINE_COMPARISON_OPERATOR(>)
365DEFINE_COMPARISON_OPERATOR(>=)
367DEFINE_CSTR_EQUALS_OPERATOR()
368DEFINE_CSTR_COMPARISON_OPERATOR(!=)
369DEFINE_CSTR_COMPARISON_OPERATOR(<)
370DEFINE_CSTR_COMPARISON_OPERATOR(<=)
371DEFINE_CSTR_COMPARISON_OPERATOR(>)
372DEFINE_CSTR_COMPARISON_OPERATOR(>=)
374auto operator+(const any& lhs_, const any& rhs_) -> any {
375 const any& lhs = any::extractValue(lhs_);
376 const any& rhs = any::extractValue(rhs_);
377 switch (lhs.type) {
378 case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i + rhs.i;
379 case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d + rhs.d;
380 case any::Type::Character: assert(lhs.type == any::Type::Character); return any(char(lhs.c + rhs.c));
381 case any::Type::StringLiteral:
382 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
383 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
384 return rhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
385 case any::Type::String:
386 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
387 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
388 return rhs.type == any::Type::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
389 default: assert(false && "Unsupported type for '+' operator");
390 }
391 return nullptr;
394DEFINE_OPERATOR(+, long, long)
395DEFINE_OPERATOR(+, double, double)
396DEFINE_OPERATOR(+, char, char)
398auto operator+(const any& lhs_, const char * rhs) -> std::string {
399 const any& lhs = any::extractValue(lhs_);
400 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
401 return lhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
404auto operator+(const char * lhs, const any& rhs_) -> std::string {
405 const any& rhs = any::extractValue(rhs_);
406 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
407 return rhs.type == any::Type::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
410auto operator-(const any& lhs_, const any& rhs_) -> any {
411 const any& lhs = any::extractValue(lhs_);
412 const any& rhs = any::extractValue(rhs_);
413 assert(lhs.type == rhs.type);
414 switch (lhs.type) {
415 case any::Type::Integer: return lhs.i - rhs.i;
416 case any::Type::Double: return lhs.d - rhs.d;
417 case any::Type::Character: return any(char(lhs.c - rhs.c));
418 default: assert(false && "Unsupported type for '-' operator");
419 }
420 return nullptr;
423DEFINE_OPERATOR(-, long, long)
424DEFINE_OPERATOR(-, double, double)
425DEFINE_OPERATOR(-, char, char)
427auto operator*(const any& lhs_, const any& rhs_) -> any {
428 const any& lhs = any::extractValue(lhs_);
429 const any& rhs = any::extractValue(rhs_);
430 assert(lhs.type == rhs.type);
431 switch (lhs.type) {
432 case any::Type::Integer: return lhs.i * rhs.i;
433 case any::Type::Double: return lhs.d * rhs.d;
434 case any::Type::Character: return any(char(lhs.c * rhs.c));
435 default: assert(false && "Unsupported type for '*' operator");
436 }
437 return nullptr;
440DEFINE_OPERATOR(*, long, long)
441DEFINE_OPERATOR(*, double, double)
442DEFINE_OPERATOR(*, char, char)
444auto operator/(const any& lhs_, const any& rhs_) -> any {
445 const any& lhs = any::extractValue(lhs_);
446 const any& rhs = any::extractValue(rhs_);
447 assert(lhs.type == rhs.type);
448 switch (lhs.type) {
449 case any::Type::Integer: return lhs.i / rhs.i;
450 case any::Type::Double: return lhs.d / rhs.d;
451 case any::Type::Character: return any(char(lhs.c / rhs.c));
452 default: assert(false && "Unsupported type for '/' operator");
453 }
454 return nullptr;
457DEFINE_OPERATOR(/, long, long)
458DEFINE_OPERATOR(/, double, double)
459DEFINE_OPERATOR(/, char, char)
461auto operator%(const any& lhs_, const any& rhs_) -> any {
462 const any& lhs = any::extractValue(lhs_);
463 const any& rhs = any::extractValue(rhs_);
464 assert(lhs.type == rhs.type);
465 switch (lhs.type) {
466 case any::Type::Integer: return lhs.i % rhs.i;
467 case any::Type::Character: return any(char(lhs.c % rhs.c));
468 default: assert(false && "Unsupported type for '%' operator");
469 }
470 return nullptr;
473DEFINE_OPERATOR(%, long, long)
474DEFINE_OPERATOR(%, char, char)
476// unary negate
477auto operator-(const any& rhs_) -> any {
478 const any& rhs = any::extractValue(rhs_);
479 switch (rhs.type) {
480 case any::Type::Integer: return (- rhs.i);
481 case any::Type::Double: return (- rhs.d);
482 default: assert(false && "Unsupported type for unary '-' operator");
483 }
484 return nullptr;
487} // namespace PureScript