@@ -12,517 +12,439 @@
1212//
1313///////////////////////////////////////////////////////////////////////////////
1414//
15+#include <cstring>
1516#include "PureScript.hh"
1617
1718namespace PureScript {
1819
19−any::any(const any& val) : type(val.type) {
20− switch (type) {
21− case Type::Integer: i = val.i; break;
22− case Type::Double: d = val.d; break;
23− case Type::Character: c = val.c; break;
24− case Type::Boolean: b = val.b; break;
25− case Type::String: new (&s) shared_string (val.s); break;
26− case Type::Map: new (&m) shared_map (val.m); break;
27− case Type::Vector: new (&v) shared_vector (val.v); break;
28− case Type::Function: new (&f) shared_fn (val.f); break;
29− case Type::EffFunction: new (&e) shared_eff_fn (val.e); break;
30− case Type::Thunk: new (&t) shared_thunk (val.t); break;
31− case Type::Pointer: new (&p) shared_void_ptr (val.p); break;
32−
33− default: assert(false && "Unsupported type in copy ctor");
34− }
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+ }
38+
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+ }
57+
58+any::any(const any& other) : type(other.type) {
59+ COPY_DATA(other);
3560}
3661
37−void any::swap(any&& val) {
38− type = val.type;
39− switch (type) {
40− case Type::Integer: i = val.i; break;
41− case Type::Double: d = val.d; break;
42− case Type::Character: c = val.c; break;
43− case Type::Boolean: b = val.b; break;
44− case Type::String: new (&s) shared_string (std::move(val.s)); break;
45− case Type::Map: new (&m) shared_map (std::move(val.m)); break;
46− case Type::Vector: new (&v) shared_vector (std::move(val.v)); break;
47− case Type::Function: new (&f) shared_fn (std::move(val.f)); break;
48− case Type::EffFunction: new (&e) shared_eff_fn (std::move(val.e)); break;
49− case Type::Thunk: new (&t) shared_thunk (std::move(val.t)); break;
50− case Type::Pointer: new (&p) shared_void_ptr (std::move(val.p)); break;
51−
52− default: assert(false && "Unsupported type in move ctor");
53− }
62+any::any(any&& other) noexcept : type(other.type) {
63+ MOVE_DATA(other);
64+}
65+
66+auto any::operator=(const any& rhs) -> any& {
67+ type = rhs.type;
68+ COPY_DATA(rhs);
69+ return *this;
70+}
71+
72+// Takes ownership -- might need to reconsider this
73+auto any::operator=(any& rhs) noexcept -> any& {
74+ type = rhs.type;
75+ MOVE_DATA(rhs);
76+ return *this;
77+}
78+
79+auto any::operator=(any&& rhs) noexcept -> any& {
80+ type = rhs.type;
81+ MOVE_DATA(rhs);
82+ return *this;
5483}
5584
5685any::~any() {
57− // std::cout << "destroy" << std::endl;
5886 switch (type) {
59− case Type::Integer: ; break;
60− case Type::Double: ; break;
61− case Type::Character: ; break;
62− case Type::Boolean: ; break;
63− case Type::String: s.~shared_string(); break;
64− case Type::Map: m.~shared_map(); break;
65− case Type::Vector: v.~shared_vector(); break;
66− case Type::Function: f.~shared_fn(); break;
67− case Type::EffFunction: e.~shared_eff_fn(); break;
68− case Type::Thunk: t.~shared_thunk(); break;
69− case Type::Pointer: p.~shared_void_ptr(); break;
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;
70100
71101 default: assert(false && "Unsupported type in destructor");
72102 }
73103};
74104
75− #define RETURN_VALUE(TYPE, VAL, FN) \
76− if (type == TYPE) { \
77− return FN(VAL); \
78− } \
79− const any* valuePtr = this; \
80− do { \
81− assert(valuePtr->type == Type::Thunk); \
82− const any& value = (*valuePtr->t)(unthunk); \
83− if (value.type == TYPE) { \
84− return FN(value.VAL); \
85− } \
86− valuePtr = &value; \
87− } while (valuePtr->type != Type::Unknown); \
88− return FN(VAL);
89−
90− template <typename T>
91− auto any::cast() const -> typename std::enable_if<std::is_same<T, long>::value, T>::type {
92− RETURN_VALUE(Type::Integer, i,)
93− }
94− template auto any::cast<long>() const -> long;
95−
96− template <typename T>
97− auto any::cast() const -> typename std::enable_if<std::is_same<T, double>::value, T>::type {
98− RETURN_VALUE(Type::Double, d,)
99− }
100− template auto any::cast<double>() const -> double;
101−
102− template <typename T>
103− auto any::cast() const -> typename std::enable_if<std::is_same<T, char>::value, T>::type {
104− RETURN_VALUE(Type::Character, c,)
105− }
106− template auto any::cast<char>() const -> char;
107−
108− template <typename T>
109− auto any::cast() const -> typename std::enable_if<std::is_same<T, bool>::value, T>::type {
110− RETURN_VALUE(Type::Boolean, b,)
111− }
112− template auto any::cast<bool>() const -> bool;
113−
114− template <typename T>
115− auto any::cast() const -> typename std::enable_if<std::is_same<T, string>::value, const T&>::type {
116− RETURN_VALUE(Type::String, s, *)
117− }
118− template auto any::cast<string>() const -> const string&;
119−
120− template <typename T>
121− auto any::cast() const -> typename std::enable_if<std::is_same<T, const char*>::value, const T>::type {
122− RETURN_VALUE(Type::String, s->c_str(),)
123− }
124− template auto any::cast<const char*>() const -> const char* const;
125−
126− template <typename T>
127− auto any::cast() const -> typename std::enable_if<std::is_same<T, map>::value, const T&>::type {
128− RETURN_VALUE(Type::Map, m, *)
129− }
130− template auto any::cast<any::map>() const -> const map&;
131−
132− template <typename T>
133− auto any::cast() const -> typename std::enable_if<std::is_same<T, vector>::value, const T&>::type {
134− RETURN_VALUE(Type::Vector, v, *)
135− }
136− template auto any::cast<any::vector>() const -> const vector&;
137−
138−
139− auto any::operator()(const any arg) const -> any {
140− if (type == Type::Function) {
141− return (*f)(arg);
142− }
143− const any* valuePtr = this;
144− do {
145− assert(valuePtr->type == Type::Thunk);
146− const any& value = (*valuePtr->t)(unthunk);
147− if (value.type == Type::Function) {
148− return (*value.f)(arg);
149− }
150− valuePtr = &value;
151− } while (valuePtr->type != Type::Unknown);
152− return nullptr;
153− }
105+#define RETURN_VALUE(TYPE, ACCESSOR, INDIRECTION) \
106+ const any& variant = unthunkVariant(*this); \
107+ assert(variant.type == TYPE); \
108+ return INDIRECTION(variant.ACCESSOR); \
154109
155− auto any::operator()(const as_thunk) const -> const any& {
156− assert(type == Type::Thunk);
157− return (*t)(unthunk);
158− }
110+template <typename T>
111+auto any::cast() const -> typename std::enable_if<std::is_same<T, long>::value, T>::type {
112+ RETURN_VALUE(Type::Integer, i,)
113+}
114+template auto any::cast<long>() const -> long;
159115
160− auto any::operator()() const -> any {
161− if (type == Type::EffFunction) {
162− return (*e)();
163− }
164− const any* valuePtr = this;
165− do {
166− assert(valuePtr->type == Type::Thunk);
167− const any& value = (*valuePtr->t)(unthunk);
168− if (value.type == Type::EffFunction) {
169− return (*value.e)();
170− }
171− valuePtr = &value;
172− } while (valuePtr->type != Type::Unknown);
173− return nullptr;
174− }
116+template <typename T>
117+auto any::cast() const -> typename std::enable_if<std::is_same<T, double>::value, T>::type {
118+ RETURN_VALUE(Type::Double, d,)
119+}
120+template auto any::cast<double>() const -> double;
175121
176− any::operator long() const {
177− RETURN_VALUE(Type::Integer, i,)
178− }
122+template <typename T>
123+auto any::cast() const -> typename std::enable_if<std::is_same<T, char>::value, T>::type {
124+ RETURN_VALUE(Type::Character, c,)
125+}
126+template auto any::cast<char>() const -> char;
179127
180− any::operator double() const {
181− RETURN_VALUE(Type::Double, d,)
182− }
128+template <typename T>
129+auto any::cast() const -> typename std::enable_if<std::is_same<T, bool>::value, T>::type {
130+ RETURN_VALUE(Type::Boolean, b,)
131+}
132+template auto any::cast<bool>() const -> bool;
183133
184− any::operator bool() const {
185− RETURN_VALUE(Type::Boolean, b,)
134+template <typename T>
135+auto any::cast() const -> typename std::enable_if<std::is_same<T, string>::value, T>::type {
136+ const any& variant = unthunkVariant(*this);
137+ if (variant.type == Type::StringLiteral) {
138+ return variant.r;
186139 }
140+ assert(variant.type == Type::String);
141+ return variant.s->c_str();
142+}
143+template auto any::cast<string>() const -> string;
187144
188− any::operator const string&() const {
189− RETURN_VALUE(Type::String, s, *)
190− }
145+template <typename T>
146+auto any::cast() const -> typename std::enable_if<std::is_same<T, map>::value, const T&>::type {
147+ RETURN_VALUE(Type::Map, m, *)
148+}
149+template auto any::cast<any::map>() const -> const map&;
191150
192− any::operator const map&() const {
193− RETURN_VALUE(Type::Map, m, *)
194− }
151+template <typename T>
152+auto any::cast() const -> typename std::enable_if<std::is_same<T, vector>::value, const T&>::type {
153+ RETURN_VALUE(Type::Vector, v, *)
154+}
155+template auto any::cast<any::vector>() const -> const vector&;
195156
196− any::operator const vector&() const {
197− RETURN_VALUE(Type::Vector, v, *)
157+auto any::operator()(const any& arg) const -> any {
158+ const any& variant = unthunkVariant(*this);
159+ if (variant.type == Type::Closure) {
160+ return (*variant.l)(arg);
198161 }
162+ assert(variant.type == Type::Function);
163+ return (*variant.f)(arg);
164+}
199165
200− auto any::extractPointer() const -> const void* {
201− RETURN_VALUE(Type::Pointer, p.get(),)
202− }
166+auto any::operator()(const as_thunk) const -> const any& {
167+ assert(type == Type::Thunk);
168+ return (*t)(unthunk);
169+}
203170
204− auto any::extract_value(const any& a) -> const any& {
205− if (a.type != Type::Thunk) {
206− return a;
207− }
208− const any* valuePtr = &a;
209− do {
210− const any& value = (*valuePtr->t)(unthunk);
211− if (value.type != Type::Thunk) {
212− return value;
213− }
214− valuePtr = &value;
215− } while (true);
216− }
171+auto any::operator()() const -> any {
172+ const any& variant = unthunkVariant(*this);
173+ assert(variant.type == Type::EffFunction);
174+ return (*variant.e)();
175+}
217176
218− auto any::operator[](const char rhs[]) const -> const any& {
219− RETURN_VALUE(Type::Map, m->at(rhs),)
220− }
177+any::operator long() const {
178+ return cast<long>();
179+}
221180
222− auto any::operator[](const vector::size_type rhs) const -> const any& {
223− RETURN_VALUE(Type::Vector, v->at(rhs),)
224− }
181+any::operator double() const {
182+ return cast<double>();
183+}
225184
226− auto any::operator[](const any& rhs) const -> const any& {
227− RETURN_VALUE(Type::Vector, v->at(rhs.cast<long>()),)
228− }
185+any::operator bool() const {
186+ return cast<bool>();
187+}
229188
230−#define DEFINE_OPERATOR_LHS(K, T, OP, V, R, P) \
231−auto operator OP(const T lhs, const any& rhs_) -> R { \
232− auto& rhs = any::extract_value(rhs_); \
233− assert(rhs.type == any::Type::K); \
234− return lhs OP P(rhs.V); \
189+any::operator string() const {
190+ return cast<string>();
235191}
236192
237−#define DEFINE_OPERATOR_RHS(K, T, OP, V, R, P) \
238−auto any::operator OP(const T rhs) const -> R { \
239− auto& lhs = any::extract_value(*this); \
240− assert(lhs.type == Type::K); \
241− return P(lhs.V) OP rhs; \
193+any::operator const map&() const {
194+ return cast<map>();
242195}
243196
244−auto any::operator==(const any& rhs_) const -> bool {
245− auto& lhs = extract_value(*this);
246− auto& rhs = extract_value(rhs_);
247− assert(lhs.type == rhs.type);
248− switch (lhs.type) {
249− case Type::Integer: return lhs.i == rhs.i;
250− case Type::Double: return lhs.d == rhs.d;
251− case Type::Character: return lhs.c == rhs.c;
252− case Type::Boolean: return lhs.b == rhs.b;
253− case Type::String: return (*lhs.s) == (*rhs.s);
254− case Type::Pointer: return lhs.p == rhs.p;
255− default: assert(false && "Unsupported type for '==' operator");
256− }
257− return false;
197+any::operator const vector&() const {
198+ return cast<vector>();
258199}
259200
260−DEFINE_OPERATOR_RHS(Integer, long, ==, i, bool,)
261−DEFINE_OPERATOR_RHS(Double, double, ==, d, bool,)
262−DEFINE_OPERATOR_RHS(Character, char, ==, c, bool,)
263−DEFINE_OPERATOR_RHS(Boolean, bool, ==, b, bool,)
264−DEFINE_OPERATOR_RHS(String, string&, ==, s, bool, *)
265−DEFINE_OPERATOR_RHS(String, char* const, ==, s, bool, *)
201+auto any::extractPointer() const -> void* {
202+ RETURN_VALUE(Type::Pointer, p.get(),)
203+}
266204
267−auto any::operator!=(const any& rhs_) const -> bool {
268− auto& lhs = extract_value(*this);
269− auto& rhs = extract_value(rhs_);
270− assert(lhs.type == rhs.type);
271− switch (lhs.type) {
272− case Type::Integer: return lhs.i != rhs.i;
273− case Type::Double: return lhs.d != rhs.d;
274− case Type::Character: return lhs.c != rhs.c;
275− case Type::Boolean: return lhs.b != rhs.b;
276− case Type::String: return (*lhs.s) != (*rhs.s);
277− case Type::Pointer: return lhs.p != rhs.p;
278− default: assert(false && "Unsupported type for '!=' operator");
205+auto any::unthunkVariant(const any& a) -> const any& {
206+ const any * variant = &a;
207+ while (variant->type == Type::Thunk) {
208+ variant = &((*variant->t)(unthunk));
279209 }
280− return false;
210+ return *variant;
281211}
282212
283−DEFINE_OPERATOR_RHS(Integer, long, !=, i, bool,)
284−DEFINE_OPERATOR_RHS(Double, double, !=, d, bool,)
285−DEFINE_OPERATOR_RHS(Character, char, !=, c, bool,)
286−DEFINE_OPERATOR_RHS(Boolean, bool, !=, b, bool,)
287−DEFINE_OPERATOR_RHS(String, string&, !=, s, bool, *)
288−DEFINE_OPERATOR_RHS(String, char* const, !=, s, bool, *)
289−
290−auto any::operator<(const any& rhs_) const -> bool {
291− auto& lhs = extract_value(*this);
292− auto& rhs = extract_value(rhs_);
293− assert(lhs.type == rhs.type);
294− switch (lhs.type) {
295− case Type::Integer: return lhs.i < rhs.i;
296− case Type::Double: return lhs.d < rhs.d;
297− case Type::Character: return lhs.c < rhs.c;
298− case Type::Boolean: return lhs.b < rhs.b;
299− case Type::String: return (*lhs.s) < (*rhs.s);
300− default: assert(false && "Unsupported type for '<' operator");
213+auto any::operator[](const char rhs[]) const -> const any& {
214+ const any& variant = unthunkVariant(*this);
215+ assert(variant.type == Type::Map);
216+ const any::map::const_iterator begin = variant.m->begin();
217+ const any::map::const_iterator end = variant.m->end();
218+ for (any::map::const_iterator it = begin; it != end; ++it) {
219+ if (it->first == rhs) {
220+ return it->second;
221+ }
301222 }
302− return false;
223+ for (any::map::const_iterator it = begin; it != end; ++it) {
224+ if (strcmp(it->first, rhs) == 0) {
225+ return it->second;
226+ }
227+ }
228+ throw runtime_error("map key not found");
303229}
304230
305−DEFINE_OPERATOR_RHS(Integer, long, <, i, bool,)
306−DEFINE_OPERATOR_RHS(Double, double, <, d, bool,)
307−DEFINE_OPERATOR_RHS(Character, char, <, c, bool,)
308−DEFINE_OPERATOR_RHS(Boolean, bool, <, b, bool,)
309−DEFINE_OPERATOR_RHS(String, string&, <, s, bool, *)
310−DEFINE_OPERATOR_RHS(String, char* const, <, s, bool, *)
311−
312−auto any::operator<=(const any& rhs_) const -> bool {
313− auto& lhs = extract_value(*this);
314− auto& rhs = extract_value(rhs_);
315− assert(lhs.type == rhs.type);
316− switch (lhs.type) {
317− case Type::Integer: return lhs.i <= rhs.i;
318− case Type::Double: return lhs.d <= rhs.d;
319− case Type::Character: return lhs.c <= rhs.c;
320− case Type::Boolean: return lhs.b <= rhs.b;
321− case Type::String: return (*lhs.s) <= (*rhs.s);
322− default: assert(false && "Unsupported type for '<' operator");
323− }
324− return false;
231+auto any::operator[](const vector::size_type rhs) const -> const any& {
232+ const any& variant = unthunkVariant(*this);
233+ assert(variant.type == Type::Vector);
234+ return (*variant.v)[rhs];
325235}
326236
327−DEFINE_OPERATOR_RHS(Integer, long, <=, i, bool,)
328−DEFINE_OPERATOR_RHS(Double, double, <=, d, bool,)
329−DEFINE_OPERATOR_RHS(Character, char, <=, c, bool,)
330−DEFINE_OPERATOR_RHS(Boolean, bool, <=, b, bool,)
331−DEFINE_OPERATOR_RHS(String, string&, <=, s, bool, *)
332−DEFINE_OPERATOR_RHS(String, char* const, <=, s, bool, *)
237+auto any::operator[](const any& rhs) const -> const any& {
238+ const any& variant = unthunkVariant(*this);
239+ assert(variant.type == Type::Vector);
240+ return (*variant.v)[rhs.cast<long>()];
241+}
333242
334−auto any::operator>(const any& rhs_) const -> bool {
335− auto& lhs = extract_value(*this);
336− auto& rhs = extract_value(rhs_);
337− assert(lhs.type == rhs.type);
338− switch (lhs.type) {
339− case Type::Integer: return lhs.i > rhs.i;
340− case Type::Double: return lhs.d > rhs.d;
341− case Type::Character: return lhs.c > rhs.c;
342− case Type::Boolean: return lhs.b > rhs.b;
343− case Type::String: return (*lhs.s) > (*rhs.s);
344− default: assert(false && "Unsupported type for '>' operator");
243+auto any::contains(const char key[]) const -> bool {
244+ const any& variant = unthunkVariant(*this);
245+ assert(variant.type == Type::Map);
246+ for (any::map::const_iterator it = variant.m->begin(), end = variant.m->end(); it != end; ++it) {
247+ if (it->first == key || strcmp(it->first, key) == 0) {
248+ return true;
249+ }
345250 }
346251 return false;
347252}
348253
349−DEFINE_OPERATOR_RHS(Integer, long, >, i, bool,)
350−DEFINE_OPERATOR_RHS(Double, double, >, d, bool,)
351−DEFINE_OPERATOR_RHS(Character, char, >, c, bool,)
352−DEFINE_OPERATOR_RHS(Boolean, bool, >, b, bool,)
353−DEFINE_OPERATOR_RHS(String, string&, >, s, bool, *)
354−DEFINE_OPERATOR_RHS(String, char* const, >, s, bool, *)
254+//-----------------------------------------------------------------------------
255+// Operator helper macros
256+//-----------------------------------------------------------------------------
355257
356−auto any::operator>=(const any& rhs_) const -> bool {
357− auto& lhs = extract_value(*this);
358− auto& rhs = extract_value(rhs_);
359− assert(lhs.type == rhs.type);
360− switch (lhs.type) {
361− case Type::Integer: return lhs.i >= rhs.i;
362− case Type::Double: return lhs.d >= rhs.d;
363− case Type::Character: return lhs.c >= rhs.c;
364− case Type::Boolean: return lhs.b >= rhs.b;
365− case Type::String: return (*lhs.s) >= (*rhs.s);
366− default: assert(false && "Unsupported type for '>' operator");
367− }
368− return false;
258+#define DEFINE_OPERATOR(op, ty, rty) \
259+auto operator op (const any& lhs, ty rhs) -> rty { \
260+ return lhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>() op rhs; \
261+} \
262+auto operator op (ty lhs, const any& rhs) -> rty { \
263+ return lhs op rhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>(); \
369264}
370265
371−DEFINE_OPERATOR_RHS(Integer, long, >=, i, bool,)
372−DEFINE_OPERATOR_RHS(Double, double, >=, d, bool,)
373−DEFINE_OPERATOR_RHS(Character, char, >=, c, bool,)
374−DEFINE_OPERATOR_RHS(Boolean, bool, >=, b, bool,)
375−DEFINE_OPERATOR_RHS(String, string&, >=, s, bool, *)
376−DEFINE_OPERATOR_RHS(String, char* const, >=, s, bool, *)
377−
378−auto any::operator+(const any& rhs_) const -> any {
379− auto& lhs = extract_value(*this);
380− auto& rhs = extract_value(rhs_);
381− assert(lhs.type == rhs.type);
266+#define DEFINE_CSTR_EQUALS_OPERATOR() \
267+ auto operator==(const any& lhs_, const char * rhs) -> bool { \
268+ const any& lhs = any::unthunkVariant(lhs_); \
269+ assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
270+ if (lhs.type == any::Type::StringLiteral) { \
271+ return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \
272+ } \
273+ return strcmp(lhs.s->c_str(), rhs) == 0; \
274+ } \
275+ auto operator==(const char * lhs, const any& rhs_) -> bool { \
276+ const any& rhs = any::unthunkVariant(rhs_); \
277+ assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
278+ if (rhs.type == any::Type::StringLiteral) { \
279+ return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \
280+ } \
281+ return strcmp(lhs, rhs.s->c_str()) == 0; \
282+ }
283+
284+#define DEFINE_CSTR_COMPARISON_OPERATOR(op) \
285+ auto operator op (const any& lhs, const char * rhs) -> bool { \
286+ return strcmp(lhs.cast<string>(), rhs) op 0; \
287+ } \
288+ auto operator op (const char * lhs, const any& rhs) -> bool { \
289+ return strcmp(lhs, rhs.cast<string>()) op 0; \
290+ }
291+
292+#define DEFINE_COMPARISON_OPERATOR(op) \
293+ auto operator op (const any& lhs_, const any& rhs_) -> bool { \
294+ const any& lhs = any::unthunkVariant(lhs_); \
295+ const any& rhs = any::unthunkVariant(rhs_); \
296+ switch (lhs.type) { \
297+ case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i op rhs.i; \
298+ case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d op rhs.d; \
299+ case any::Type::Character: assert(lhs.type == any::Type::Character); return lhs.c op rhs.c; \
300+ case any::Type::Boolean: assert(lhs.type == any::Type::Boolean); return lhs.b op rhs.b; \
301+ case any::Type::StringLiteral: \
302+ assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
303+ assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
304+ return strcmp(lhs.r, rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
305+ case any::Type::String: \
306+ assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
307+ assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
308+ return strcmp(lhs.s->c_str(), rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
309+ case any::Type::Pointer: return lhs.p op rhs.p; \
310+ default: assert(false && "Unsupported type for operator " #op); \
311+ } \
312+ return false; \
313+ } \
314+ DEFINE_OPERATOR(op, long, bool) \
315+ DEFINE_OPERATOR(op, double, bool) \
316+ DEFINE_OPERATOR(op, char, bool) \
317+ DEFINE_OPERATOR(op, bool, bool) \
318+
319+//-----------------------------------------------------------------------------
320+// Operator definitions
321+//-----------------------------------------------------------------------------
322+
323+DEFINE_COMPARISON_OPERATOR(==)
324+DEFINE_COMPARISON_OPERATOR(!=)
325+DEFINE_COMPARISON_OPERATOR(<)
326+DEFINE_COMPARISON_OPERATOR(<=)
327+DEFINE_COMPARISON_OPERATOR(>)
328+DEFINE_COMPARISON_OPERATOR(>=)
329+
330+DEFINE_CSTR_EQUALS_OPERATOR()
331+DEFINE_CSTR_COMPARISON_OPERATOR(!=)
332+DEFINE_CSTR_COMPARISON_OPERATOR(<)
333+DEFINE_CSTR_COMPARISON_OPERATOR(<=)
334+DEFINE_CSTR_COMPARISON_OPERATOR(>)
335+DEFINE_CSTR_COMPARISON_OPERATOR(>=)
336+
337+auto operator+(const any& lhs_, const any& rhs_) -> any {
338+ const any& lhs = any::unthunkVariant(lhs_);
339+ const any& rhs = any::unthunkVariant(rhs_);
382340 switch (lhs.type) {
383− case Type::Integer: return lhs.i + rhs.i;
384− case Type::Double: return lhs.d + rhs.d;
385− case Type::Character: return any(char(lhs.c + rhs.c));
386− case Type::String: return (*lhs.s) + (*rhs.s);
341+ case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i + rhs.i;
342+ case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d + rhs.d;
343+ case any::Type::Character: assert(lhs.type == any::Type::Character); return any(char(lhs.c + rhs.c));
344+ case any::Type::StringLiteral:
345+ assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
346+ assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
347+ return rhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
348+ case any::Type::String:
349+ assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
350+ assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
351+ return rhs.type == any::Type::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
387352 default: assert(false && "Unsupported type for '+' operator");
388353 }
389354 return nullptr;
390355}
391356
392−DEFINE_OPERATOR_RHS(Integer, long, +, i, long,)
393−DEFINE_OPERATOR_RHS(Double, double, +, d, double,)
394−DEFINE_OPERATOR_RHS(Character, char, +, c, char,)
395−DEFINE_OPERATOR_RHS(String, string&, +, s, string, *)
396−DEFINE_OPERATOR_RHS(String, char* const, +, s, string, *)
357+DEFINE_OPERATOR(+, long, long)
358+DEFINE_OPERATOR(+, double, double)
359+DEFINE_OPERATOR(+, char, char)
360+
361+auto operator+(const any& lhs_, const char * rhs) -> std::string {
362+ const any& lhs = any::unthunkVariant(lhs_);
363+ assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
364+ return lhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
365+}
366+
367+auto operator+(const char * lhs, const any& rhs_) -> std::string {
368+ const any& rhs = any::unthunkVariant(rhs_);
369+ assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
370+ return rhs.type == any::Type::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
371+}
397372
398−auto any::operator-(const any& rhs_) const -> any {
399− auto& lhs = extract_value(*this);
400− auto& rhs = extract_value(rhs_);
373+auto operator-(const any& lhs_, const any& rhs_) -> any {
374+ const any& lhs = any::unthunkVariant(lhs_);
375+ const any& rhs = any::unthunkVariant(rhs_);
401376 assert(lhs.type == rhs.type);
402377 switch (lhs.type) {
403− case Type::Integer: return lhs.i - rhs.i;
404− case Type::Double: return lhs.d - rhs.d;
405− case Type::Character: return any(char(lhs.c - rhs.c));
406− default: assert(false && "Unsupported type for '-' binary operator");
378+ case any::Type::Integer: return lhs.i - rhs.i;
379+ case any::Type::Double: return lhs.d - rhs.d;
380+ case any::Type::Character: return any(char(lhs.c - rhs.c));
381+ default: assert(false && "Unsupported type for '-' operator");
407382 }
408383 return nullptr;
409384}
410385
411−DEFINE_OPERATOR_RHS(Integer, long, -, i, long,)
412−DEFINE_OPERATOR_RHS(Double, double, -, d, double,)
413−DEFINE_OPERATOR_RHS(Character, char, -, c, char,)
386+DEFINE_OPERATOR(-, long, long)
387+DEFINE_OPERATOR(-, double, double)
388+DEFINE_OPERATOR(-, char, char)
414389
415−auto any::operator*(const any& rhs_) const -> any {
416− auto& lhs = extract_value(*this);
417− auto& rhs = extract_value(rhs_);
390+auto operator*(const any& lhs_, const any& rhs_) -> any {
391+ const any& lhs = any::unthunkVariant(lhs_);
392+ const any& rhs = any::unthunkVariant(rhs_);
418393 assert(lhs.type == rhs.type);
419394 switch (lhs.type) {
420− case Type::Integer: return lhs.i * rhs.i;
421− case Type::Double: return lhs.d * rhs.d;
395+ case any::Type::Integer: return lhs.i * rhs.i;
396+ case any::Type::Double: return lhs.d * rhs.d;
397+ case any::Type::Character: return any(char(lhs.c * rhs.c));
422398 default: assert(false && "Unsupported type for '*' operator");
423399 }
424400 return nullptr;
425401}
426402
427−DEFINE_OPERATOR_RHS(Integer, long, *, i, long,)
428−DEFINE_OPERATOR_RHS(Double, double, *, d, double,)
403+DEFINE_OPERATOR(*, long, long)
404+DEFINE_OPERATOR(*, double, double)
405+DEFINE_OPERATOR(*, char, char)
429406
430−auto any::operator/(const any& rhs_) const -> any {
431− auto& lhs = extract_value(*this);
432− auto& rhs = extract_value(rhs_);
407+auto operator/(const any& lhs_, const any& rhs_) -> any {
408+ const any& lhs = any::unthunkVariant(lhs_);
409+ const any& rhs = any::unthunkVariant(rhs_);
433410 assert(lhs.type == rhs.type);
434411 switch (lhs.type) {
435− case Type::Integer: return lhs.i / rhs.i;
436− case Type::Double: return lhs.d / rhs.d;
412+ case any::Type::Integer: return lhs.i / rhs.i;
413+ case any::Type::Double: return lhs.d / rhs.d;
414+ case any::Type::Character: return any(char(lhs.c / rhs.c));
437415 default: assert(false && "Unsupported type for '/' operator");
438416 }
439417 return nullptr;
440418}
441419
442−DEFINE_OPERATOR_RHS(Integer, long, /, i, long,)
443−DEFINE_OPERATOR_RHS(Double, double, /, d, double,)
420+DEFINE_OPERATOR(/, long, long)
421+DEFINE_OPERATOR(/, double, double)
422+DEFINE_OPERATOR(/, char, char)
444423
445−auto any::operator%(const any& rhs_) const -> any {
446− auto& lhs = extract_value(*this);
447− auto& rhs = extract_value(rhs_);
424+auto operator%(const any& lhs_, const any& rhs_) -> any {
425+ const any& lhs = any::unthunkVariant(lhs_);
426+ const any& rhs = any::unthunkVariant(rhs_);
448427 assert(lhs.type == rhs.type);
449428 switch (lhs.type) {
450− case Type::Integer: return lhs.i % rhs.i;
429+ case any::Type::Integer: return lhs.i % rhs.i;
430+ case any::Type::Character: return any(char(lhs.c % rhs.c));
451431 default: assert(false && "Unsupported type for '%' operator");
452432 }
453433 return nullptr;
454434}
455435
456−DEFINE_OPERATOR_RHS(Integer, long, %, i, long,)
436+DEFINE_OPERATOR(%, long, long)
437+DEFINE_OPERATOR(%, char, char)
457438
458−auto any::operator-() const -> any {
459− auto& lhs = any::extract_value(*this);
460− switch (lhs.type) {
461− case Type::Integer: return (- lhs.i);
462− case Type::Double: return (- lhs.d);
439+// unary negate
440+auto operator-(const any& rhs_) -> any {
441+ const any& rhs = any::unthunkVariant(rhs_);
442+ switch (rhs.type) {
443+ case any::Type::Integer: return (- rhs.i);
444+ case any::Type::Double: return (- rhs.d);
463445 default: assert(false && "Unsupported type for unary '-' operator");
464446 }
465447 return nullptr;
466448}
467449
468−DEFINE_OPERATOR_LHS(Integer, long, ==, i, bool,)
469−DEFINE_OPERATOR_LHS(Integer, long, !=, i, bool,)
470−DEFINE_OPERATOR_LHS(Integer, long, <, i, bool,)
471−DEFINE_OPERATOR_LHS(Integer, long, <=, i, bool,)
472−DEFINE_OPERATOR_LHS(Integer, long, >, i, bool,)
473−DEFINE_OPERATOR_LHS(Integer, long, >=, i, bool,)
474−
475−DEFINE_OPERATOR_LHS(Double, double, ==, d, bool,)
476−DEFINE_OPERATOR_LHS(Double, double, !=, d, bool,)
477−DEFINE_OPERATOR_LHS(Double, double, <, d, bool,)
478−DEFINE_OPERATOR_LHS(Double, double, <=, d, bool,)
479−DEFINE_OPERATOR_LHS(Double, double, >, d, bool,)
480−DEFINE_OPERATOR_LHS(Double, double, >=, d, bool,)
481−
482−DEFINE_OPERATOR_LHS(Character, char, ==, c, bool,)
483−DEFINE_OPERATOR_LHS(Character, char, !=, c, bool,)
484−DEFINE_OPERATOR_LHS(Character, char, <, c, bool,)
485−DEFINE_OPERATOR_LHS(Character, char, <=, c, bool,)
486−DEFINE_OPERATOR_LHS(Character, char, >, c, bool,)
487−DEFINE_OPERATOR_LHS(Character, char, >=, c, bool,)
488−
489−DEFINE_OPERATOR_LHS(Boolean, bool, ==, b, bool,)
490−DEFINE_OPERATOR_LHS(Boolean, bool, !=, b, bool,)
491−DEFINE_OPERATOR_LHS(Boolean, bool, <, b, bool,)
492−DEFINE_OPERATOR_LHS(Boolean, bool, <=, b, bool,)
493−DEFINE_OPERATOR_LHS(Boolean, bool, >, b, bool,)
494−DEFINE_OPERATOR_LHS(Boolean, bool, >=, b, bool,)
495−
496−DEFINE_OPERATOR_LHS(String, string&, ==, s, bool, *)
497−DEFINE_OPERATOR_LHS(String, string&, !=, s, bool, *)
498−DEFINE_OPERATOR_LHS(String, string&, <, s, bool, *)
499−DEFINE_OPERATOR_LHS(String, string&, <=, s, bool, *)
500−DEFINE_OPERATOR_LHS(String, string&, >, s, bool, *)
501−DEFINE_OPERATOR_LHS(String, string&, >=, s, bool, *)
502−
503−DEFINE_OPERATOR_LHS(String, char* const, ==, s, bool, *)
504−DEFINE_OPERATOR_LHS(String, char* const, !=, s, bool, *)
505−DEFINE_OPERATOR_LHS(String, char* const, <, s, bool, *)
506−DEFINE_OPERATOR_LHS(String, char* const, <=, s, bool, *)
507−DEFINE_OPERATOR_LHS(String, char* const, >, s, bool, *)
508−DEFINE_OPERATOR_LHS(String, char* const, >=, s, bool, *)
509−
510−DEFINE_OPERATOR_LHS(Integer, long, +, i, long,)
511−DEFINE_OPERATOR_LHS(Integer, long, -, i, long,)
512−DEFINE_OPERATOR_LHS(Integer, long, *, i, long,)
513−DEFINE_OPERATOR_LHS(Integer, long, /, i, long,)
514−DEFINE_OPERATOR_LHS(Integer, long, %, i, long,)
515−
516−DEFINE_OPERATOR_LHS(Double, double, +, d, double,)
517−DEFINE_OPERATOR_LHS(Double, double, -, d, double,)
518−DEFINE_OPERATOR_LHS(Double, double, *, d, double,)
519−DEFINE_OPERATOR_LHS(Double, double, /, d, double,)
520−
521−DEFINE_OPERATOR_LHS(Character, char, +, i, char,)
522−DEFINE_OPERATOR_LHS(Character, char, -, i, char,)
523−
524−DEFINE_OPERATOR_LHS(String, string&, +, s, string, *)
525−DEFINE_OPERATOR_LHS(String, char* const, +, s, string, *)
526−
527−
528450} // namespace PureScript