git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
C++: clean up some private type names in the runtime
de13186Andy Arvanitis
pcc/runtime/purescript.cc+62−62
compare with golang
unifiedsplit
@@ -17,8 +17,8 @@
17
17
18namespace PureScript {
18namespace PureScript {
19
19
20−any::closure::~closure() {}
20+any::Closure::~Closure() {}
21−any::eff_closure::~eff_closure() {}
21+any::EffClosure::~EffClosure() {}
22
22
23#define RETURN_VALUE(TAG, ACCESSOR, INDIRECTION) \
23#define RETURN_VALUE(TAG, ACCESSOR, INDIRECTION) \
24 const any& variant = unthunkVariant(*this); \
24 const any& variant = unthunkVariant(*this); \
@@ -27,41 +27,41 @@ any::eff_closure::~eff_closure() {}
27
27
28auto any::operator()(const any& arg) const -> any {
28auto any::operator()(const any& arg) const -> any {
29 const any& variant = unthunkVariant(*this);
29 const any& variant = unthunkVariant(*this);
30− if (variant.tag == tag_t::Closure) {
30+ if (variant.tag == Tag::Closure) {
31 return (*variant.l)(arg);
31 return (*variant.l)(arg);
32 }
32 }
33− assert(variant.tag == tag_t::Function);
33+ assert(variant.tag == Tag::Function);
34 return (*variant.f)(arg);
34 return (*variant.f)(arg);
35}
35}
36
36
37auto any::operator()(const as_thunk) const -> const any& {
37auto any::operator()(const as_thunk) const -> const any& {
38− assert(tag == tag_t::Thunk);
38+ assert(tag == Tag::Thunk);
39 return (*t)(unthunk);
39 return (*t)(unthunk);
40}
40}
41
41
42auto any::operator()() const -> any {
42auto any::operator()() const -> any {
43 const any& variant = unthunkVariant(*this);
43 const any& variant = unthunkVariant(*this);
44− if (variant.tag == tag_t::EffClosure) {
44+ if (variant.tag == Tag::EffClosure) {
45 return (*variant.k)();
45 return (*variant.k)();
46 }
46 }
47− assert(variant.tag == tag_t::EffFunction);
47+ assert(variant.tag == Tag::EffFunction);
48 return (*variant.e)();
48 return (*variant.e)();
49}
49}
50
50
51any::operator int() const {
51any::operator int() const {
52− RETURN_VALUE(tag_t::Integer, i,)
52+ RETURN_VALUE(Tag::Integer, i,)
53}
53}
54
54
55any::operator double() const {
55any::operator double() const {
56− RETURN_VALUE(tag_t::Double, d,)
56+ RETURN_VALUE(Tag::Double, d,)
57}
57}
58
58
59any::operator bool() const {
59any::operator bool() const {
60− RETURN_VALUE(tag_t::Boolean, b,)
60+ RETURN_VALUE(Tag::Boolean, b,)
61}
61}
62
62
63any::operator char() const {
63any::operator char() const {
64− RETURN_VALUE(tag_t::Character, c,)
64+ RETURN_VALUE(Tag::Character, c,)
65}
65}
66
66
67any::operator size_t() const {
67any::operator size_t() const {
@@ -72,24 +72,24 @@ any::operator size_t() const {
72
72
73any::operator cstring() const {
73any::operator cstring() const {
74 const any& variant = unthunkVariant(*this);
74 const any& variant = unthunkVariant(*this);
75− if (variant.tag == tag_t::StringLiteral) {
75+ if (variant.tag == Tag::StringLiteral) {
76 return variant.r;
76 return variant.r;
77 }
77 }
78− assert(variant.tag == tag_t::String);
78+ assert(variant.tag == Tag::String);
79 return variant.s->c_str();
79 return variant.s->c_str();
80}
80}
81
81
82any::operator const array&() const {
82any::operator const array&() const {
83− RETURN_VALUE(tag_t::Array, a, *)
83+ RETURN_VALUE(Tag::Array, a, *)
84}
84}
85
85
86−auto any::extractPointer(IF_DEBUG(const any::tag_t t)) const -> void* {
86+auto any::extractPointer(IF_DEBUG(const any::Tag t)) const -> void* {
87 RETURN_VALUE(t, POINTER_FROM_MEMBER(p),)
87 RETURN_VALUE(t, POINTER_FROM_MEMBER(p),)
88}
88}
89
89
90auto any::unthunkVariant(const any& a) -> const any& {
90auto any::unthunkVariant(const any& a) -> const any& {
91 const any * variant = &a;
91 const any * variant = &a;
92− while (variant->tag == tag_t::Thunk) {
92+ while (variant->tag == Tag::Thunk) {
93 variant = &((*variant->t)(unthunk));
93 variant = &((*variant->t)(unthunk));
94 }
94 }
95 return *variant;
95 return *variant;
@@ -108,7 +108,7 @@ auto any::empty() const -> bool {
108 return cast<array>(*this).empty();
108 return cast<array>(*this).empty();
109}
109}
110
110
111−auto any::contains(const symbol_t key) const -> bool {
111+auto any::contains(const Private::Symbol key) const -> bool {
112 // TODO: assumes at least one element -- safe assumption?
112 // TODO: assumes at least one element -- safe assumption?
113 const auto& m = cast<map<unknown_size>>(*this);
113 const auto& m = cast<map<unknown_size>>(*this);
114 std::remove_reference<decltype(m)>::type::size_type i = 0;
114 std::remove_reference<decltype(m)>::type::size_type i = 0;
@@ -127,16 +127,16 @@ auto any::contains(const symbol_t key) const -> bool {
127#define DEFINE_CSTR_EQUALS_OPERATOR() \
127#define DEFINE_CSTR_EQUALS_OPERATOR() \
128 auto operator==(const any& lhs_, const char * rhs) -> bool { \
128 auto operator==(const any& lhs_, const char * rhs) -> bool { \
129 const any& lhs = any::unthunkVariant(lhs_); \
129 const any& lhs = any::unthunkVariant(lhs_); \
130− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
130+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String); \
131− if (lhs.tag == any::tag_t::StringLiteral) { \
131+ if (lhs.tag == any::Tag::StringLiteral) { \
132 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \
132 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \
133 } \
133 } \
134 return strcmp(lhs.s->c_str(), rhs) == 0; \
134 return strcmp(lhs.s->c_str(), rhs) == 0; \
135 } \
135 } \
136 auto operator==(const char * lhs, const any& rhs_) -> bool { \
136 auto operator==(const char * lhs, const any& rhs_) -> bool { \
137 const any& rhs = any::unthunkVariant(rhs_); \
137 const any& rhs = any::unthunkVariant(rhs_); \
138− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
138+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String); \
139− if (rhs.tag == any::tag_t::StringLiteral) { \
139+ if (rhs.tag == any::Tag::StringLiteral) { \
140 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \
140 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \
141 } \
141 } \
142 return strcmp(lhs, rhs.s->c_str()) == 0; \
142 return strcmp(lhs, rhs.s->c_str()) == 0; \
@@ -155,19 +155,19 @@ auto any::contains(const symbol_t key) const -> bool {
155 const any& lhs = any::unthunkVariant(lhs_); \
155 const any& lhs = any::unthunkVariant(lhs_); \
156 const any& rhs = any::unthunkVariant(rhs_); \
156 const any& rhs = any::unthunkVariant(rhs_); \
157 switch (lhs.tag) { \
157 switch (lhs.tag) { \
158− case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i op rhs.i; \
158+ case any::Tag::Integer: assert(lhs.tag == any::Tag::Integer); return lhs.i op rhs.i; \
159− case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d op rhs.d; \
159+ case any::Tag::Double: assert(lhs.tag == any::Tag::Double); return lhs.d op rhs.d; \
160− case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return lhs.c op rhs.c; \
160+ case any::Tag::Character: assert(lhs.tag == any::Tag::Character); return lhs.c op rhs.c; \
161− case any::tag_t::Boolean: assert(lhs.tag == any::tag_t::Boolean); return lhs.b op rhs.b; \
161+ case any::Tag::Boolean: assert(lhs.tag == any::Tag::Boolean); return lhs.b op rhs.b; \
162− case any::tag_t::StringLiteral: \
162+ case any::Tag::StringLiteral: \
163− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
163+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String); \
164− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
164+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String); \
165− return strcmp(lhs.r, rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
165+ return strcmp(lhs.r, rhs.tag == any::Tag::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
166− case any::tag_t::String: \
166+ case any::Tag::String: \
167− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
167+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String); \
168− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
168+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String); \
169− return strcmp(lhs.s->c_str(), rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
169+ return strcmp(lhs.s->c_str(), rhs.tag == any::Tag::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
170− case any::tag_t::Pointer: return lhs.p op rhs.p; \
170+ case any::Tag::Pointer: return lhs.p op rhs.p; \
171 default: assert(false && "Unsupported tag for operator " #op); \
171 default: assert(false && "Unsupported tag for operator " #op); \
172 } \
172 } \
173 return false; \
173 return false; \
@@ -195,17 +195,17 @@ auto operator+(const any& lhs_, const any& rhs_) -> any {
195 const any& lhs = any::unthunkVariant(lhs_);
195 const any& lhs = any::unthunkVariant(lhs_);
196 const any& rhs = any::unthunkVariant(rhs_);
196 const any& rhs = any::unthunkVariant(rhs_);
197 switch (lhs.tag) {
197 switch (lhs.tag) {
198− case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i + rhs.i;
198+ case any::Tag::Integer: assert(lhs.tag == any::Tag::Integer); return lhs.i + rhs.i;
199− case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d + rhs.d;
199+ case any::Tag::Double: assert(lhs.tag == any::Tag::Double); return lhs.d + rhs.d;
200− case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return any(char(lhs.c + rhs.c));
200+ case any::Tag::Character: assert(lhs.tag == any::Tag::Character); return any(char(lhs.c + rhs.c));
201− case any::tag_t::StringLiteral:
201+ case any::Tag::StringLiteral:
202− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
202+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String);
203− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
203+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String);
204− return rhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
204+ return rhs.tag == any::Tag::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
205− case any::tag_t::String:
205+ case any::Tag::String:
206− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
206+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String);
207− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
207+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String);
208− return rhs.tag == any::tag_t::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
208+ return rhs.tag == any::Tag::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
209 default: assert(false && "Unsupported tag for '+' operator");
209 default: assert(false && "Unsupported tag for '+' operator");
210 }
210 }
211 return nullptr;
211 return nullptr;
@@ -213,14 +213,14 @@ auto operator+(const any& lhs_, const any& rhs_) -> any {
213
213
214auto operator+(const any& lhs_, const char * rhs) -> std::string {
214auto operator+(const any& lhs_, const char * rhs) -> std::string {
215 const any& lhs = any::unthunkVariant(lhs_);
215 const any& lhs = any::unthunkVariant(lhs_);
216− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
216+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String);
217− return lhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
217+ return lhs.tag == any::Tag::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
218}
218}
219
219
220auto operator+(const char * lhs, const any& rhs_) -> std::string {
220auto operator+(const char * lhs, const any& rhs_) -> std::string {
221 const any& rhs = any::unthunkVariant(rhs_);
221 const any& rhs = any::unthunkVariant(rhs_);
222− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
222+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String);
223− return rhs.tag == any::tag_t::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
223+ return rhs.tag == any::Tag::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
224}
224}
225
225
226auto operator-(const any& lhs_, const any& rhs_) -> any {
226auto operator-(const any& lhs_, const any& rhs_) -> any {
@@ -228,9 +228,9 @@ auto operator-(const any& lhs_, const any& rhs_) -> any {
228 const any& rhs = any::unthunkVariant(rhs_);
228 const any& rhs = any::unthunkVariant(rhs_);
229 assert(lhs.tag == rhs.tag);
229 assert(lhs.tag == rhs.tag);
230 switch (lhs.tag) {
230 switch (lhs.tag) {
231− case any::tag_t::Integer: return lhs.i - rhs.i;
231+ case any::Tag::Integer: return lhs.i - rhs.i;
232− case any::tag_t::Double: return lhs.d - rhs.d;
232+ case any::Tag::Double: return lhs.d - rhs.d;
233− case any::tag_t::Character: return any(char(lhs.c - rhs.c));
233+ case any::Tag::Character: return any(char(lhs.c - rhs.c));
234 default: assert(false && "Unsupported tag for '-' operator");
234 default: assert(false && "Unsupported tag for '-' operator");
235 }
235 }
236 return nullptr;
236 return nullptr;
@@ -241,9 +241,9 @@ auto operator*(const any& lhs_, const any& rhs_) -> any {
241 const any& rhs = any::unthunkVariant(rhs_);
241 const any& rhs = any::unthunkVariant(rhs_);
242 assert(lhs.tag == rhs.tag);
242 assert(lhs.tag == rhs.tag);
243 switch (lhs.tag) {
243 switch (lhs.tag) {
244− case any::tag_t::Integer: return lhs.i * rhs.i;
244+ case any::Tag::Integer: return lhs.i * rhs.i;
245− case any::tag_t::Double: return lhs.d * rhs.d;
245+ case any::Tag::Double: return lhs.d * rhs.d;
246− case any::tag_t::Character: return any(char(lhs.c * rhs.c));
246+ case any::Tag::Character: return any(char(lhs.c * rhs.c));
247 default: assert(false && "Unsupported tag for '*' operator");
247 default: assert(false && "Unsupported tag for '*' operator");
248 }
248 }
249 return nullptr;
249 return nullptr;
@@ -254,9 +254,9 @@ auto operator/(const any& lhs_, const any& rhs_) -> any {
254 const any& rhs = any::unthunkVariant(rhs_);
254 const any& rhs = any::unthunkVariant(rhs_);
255 assert(lhs.tag == rhs.tag);
255 assert(lhs.tag == rhs.tag);
256 switch (lhs.tag) {
256 switch (lhs.tag) {
257− case any::tag_t::Integer: return lhs.i / rhs.i;
257+ case any::Tag::Integer: return lhs.i / rhs.i;
258− case any::tag_t::Double: return lhs.d / rhs.d;
258+ case any::Tag::Double: return lhs.d / rhs.d;
259− case any::tag_t::Character: return any(char(lhs.c / rhs.c));
259+ case any::Tag::Character: return any(char(lhs.c / rhs.c));
260 default: assert(false && "Unsupported tag for '/' operator");
260 default: assert(false && "Unsupported tag for '/' operator");
261 }
261 }
262 return nullptr;
262 return nullptr;
@@ -267,8 +267,8 @@ auto operator%(const any& lhs_, const any& rhs_) -> any {
267 const any& rhs = any::unthunkVariant(rhs_);
267 const any& rhs = any::unthunkVariant(rhs_);
268 assert(lhs.tag == rhs.tag);
268 assert(lhs.tag == rhs.tag);
269 switch (lhs.tag) {
269 switch (lhs.tag) {
270− case any::tag_t::Integer: return lhs.i % rhs.i;
270+ case any::Tag::Integer: return lhs.i % rhs.i;
271− case any::tag_t::Character: return any(char(lhs.c % rhs.c));
271+ case any::Tag::Character: return any(char(lhs.c % rhs.c));
272 default: assert(false && "Unsupported tag for '%' operator");
272 default: assert(false && "Unsupported tag for '%' operator");
273 }
273 }
274 return nullptr;
274 return nullptr;
@@ -278,8 +278,8 @@ auto operator%(const any& lhs_, const any& rhs_) -> any {
278auto operator-(const any& rhs_) -> any {
278auto operator-(const any& rhs_) -> any {
279 const any& rhs = any::unthunkVariant(rhs_);
279 const any& rhs = any::unthunkVariant(rhs_);
280 switch (rhs.tag) {
280 switch (rhs.tag) {
281− case any::tag_t::Integer: return (- rhs.i);
281+ case any::Tag::Integer: return (- rhs.i);
282− case any::tag_t::Double: return (- rhs.d);
282+ case any::Tag::Double: return (- rhs.d);
283 default: assert(false && "Unsupported tag for unary '-' operator");
283 default: assert(false && "Unsupported tag for unary '-' operator");
284 }
284 }
285 return nullptr;
285 return nullptr;
pcc/runtime/purescript.hh+83−83
@@ -48,30 +48,30 @@ using std::nullptr_t;
48using std::runtime_error;
48using std::runtime_error;
49
49
50namespace Private {
50namespace Private {
51− struct symbol_generator_anchor_t {};
51+ struct SymbolGeneratorAnchor {};
52
52
53 template <typename T>
53 template <typename T>
54− struct symbol_generator {
54+ struct SymbolGenerator {
55− constexpr static symbol_generator_anchor_t anchor = symbol_generator_anchor_t{};
55+ constexpr static SymbolGeneratorAnchor anchor = SymbolGeneratorAnchor{};
56 };
56 };
57 template <typename T>
57 template <typename T>
58− constexpr symbol_generator_anchor_t symbol_generator<T>::anchor;
58+ constexpr SymbolGeneratorAnchor SymbolGenerator<T>::anchor;
59−}
60
59
61−using symbol_t = const Private::symbol_generator_anchor_t *;
60+ using Symbol = const SymbolGeneratorAnchor *;
61+}
62
62
63#define define_symbol(S) namespace PureScript { \
63#define define_symbol(S) namespace PureScript { \
64 namespace Private { \
64 namespace Private { \
65− namespace Symbol { \
65+ namespace Symbols { \
66 struct S_ ## S {}; \
66 struct S_ ## S {}; \
67 } \
67 } \
68 } \
68 } \
69 }
69 }
70−#define symbol(S) (&Private::symbol_generator<::PureScript::Private::Symbol::S_ ## S>::anchor)
70+#define symbol(S) (&Private::SymbolGenerator<::PureScript::Private::Symbols::S_ ## S>::anchor)
71
71
72constexpr bool undefined = false;
72constexpr bool undefined = false;
73
73
74−// Not a real limit, just used for simpler accessors
74+// TODO: Not a real limit, just used for simpler accessors
75static constexpr size_t unknown_size = 64;
75static constexpr size_t unknown_size = 64;
76
76
77// A variant data class designed to provide some features of dynamic typing.
77// A variant data class designed to provide some features of dynamic typing.
@@ -79,7 +79,7 @@ static constexpr size_t unknown_size = 64;
79class any {
79class any {
80
80
81 public:
81 public:
82− enum class tag_t {
82+ enum class Tag {
83 Thunk = 0x10,
83 Thunk = 0x10,
84 Integer,
84 Integer,
85 Double,
85 Double,
@@ -99,14 +99,14 @@ class any {
99 };
99 };
100
100
101 private:
101 private:
102− mutable tag_t tag;
102+ mutable Tag tag;
103
103
104 public:
104 public:
105 struct as_thunk {
105 struct as_thunk {
106 };
106 };
107 static constexpr as_thunk unthunk = as_thunk{};
107 static constexpr as_thunk unthunk = as_thunk{};
108
108
109− using map_pair = std::pair<const symbol_t, const any>;
109+ using map_pair = std::pair<const Private::Symbol, const any>;
110
110
111 template <size_t N>
111 template <size_t N>
112 using map = std::array<const map_pair, N>;
112 using map = std::array<const map_pair, N>;
@@ -120,33 +120,33 @@ class any {
120 using thunk = auto (*)(const as_thunk) -> const any&;
120 using thunk = auto (*)(const as_thunk) -> const any&;
121
121
122 private:
122 private:
123− class closure {
123+ class Closure {
124 public:
124 public:
125 virtual auto operator()(const any&) const -> any = 0;
125 virtual auto operator()(const any&) const -> any = 0;
126− virtual ~closure();
126+ virtual ~Closure();
127 };
127 };
128
128
129 template <typename T>
129 template <typename T>
130− class closure_ : public closure {
130+ class Closure_ : public Closure {
131 const T lambda;
131 const T lambda;
132 public:
132 public:
133− closure_(const T& l) noexcept : lambda(l) {}
133+ Closure_(const T& l) noexcept : lambda(l) {}
134 auto operator()(const any& arg) const -> any override {
134 auto operator()(const any& arg) const -> any override {
135 return lambda(arg);
135 return lambda(arg);
136 }
136 }
137 };
137 };
138
138
139− class eff_closure {
139+ class EffClosure {
140 public:
140 public:
141 virtual auto operator()() const -> any = 0;
141 virtual auto operator()() const -> any = 0;
142− virtual ~eff_closure();
142+ virtual ~EffClosure();
143 };
143 };
144
144
145 template <typename T>
145 template <typename T>
146− class eff_closure_ : public eff_closure {
146+ class EffClosure_ : public EffClosure {
147 const T lambda;
147 const T lambda;
148 public:
148 public:
149− eff_closure_(const T& l) noexcept : lambda(l) {}
149+ EffClosure_(const T& l) noexcept : lambda(l) {}
150 auto operator()() const -> any override {
150 auto operator()() const -> any override {
151 return lambda();
151 return lambda();
152 }
152 }
@@ -165,82 +165,82 @@ class any {
165 mutable void * u;
165 mutable void * u;
166 mutable managed<std::string> s;
166 mutable managed<std::string> s;
167 mutable managed<array> a;
167 mutable managed<array> a;
168− mutable managed<closure> l;
168+ mutable managed<Closure> l;
169− mutable managed<eff_closure> k;
169+ mutable managed<EffClosure> k;
170 mutable managed<void> p;
170 mutable managed<void> p;
171 };
171 };
172
172
173 public:
173 public:
174
174
175− any(const int val) noexcept : tag(tag_t::Integer), i(val) {}
175+ any(const int val) noexcept : tag(Tag::Integer), i(val) {}
176− any(const long val) noexcept : tag(tag_t::Integer), i(static_cast<decltype(i)>(val)) {
176+ any(const long val) noexcept : tag(Tag::Integer), i(static_cast<decltype(i)>(val)) {
177 assert(val >= std::numeric_limits<decltype(i)>::min() &&
177 assert(val >= std::numeric_limits<decltype(i)>::min() &&
178 val <= std::numeric_limits<decltype(i)>::max());
178 val <= std::numeric_limits<decltype(i)>::max());
179 }
179 }
180
180
181− any(const double val) noexcept : tag(tag_t::Double), d(val) {}
181+ any(const double val) noexcept : tag(Tag::Double), d(val) {}
182− any(const char val) noexcept : tag(tag_t::Character), c(val) {}
182+ any(const char val) noexcept : tag(Tag::Character), c(val) {}
183
183
184 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>
184 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>
185− any(const T val) noexcept : tag(tag_t::Boolean), b(val) {}
185+ any(const T val) noexcept : tag(Tag::Boolean), b(val) {}
186
186
187 template <size_t N>
187 template <size_t N>
188− any(const char (&val)[N]) noexcept : tag(tag_t::StringLiteral), r(val) {}
188+ any(const char (&val)[N]) noexcept : tag(Tag::StringLiteral), r(val) {}
189− any(char * val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}
189+ any(char * val) : tag(Tag::String), s(make_managed<std::string>(val)) {}
190
190
191− any(const std::string& val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}
191+ any(const std::string& val) : tag(Tag::String), s(make_managed<std::string>(val)) {}
192− any(std::string&& val) noexcept : tag(tag_t::String), s(make_managed<std::string>(std::move(val))) {}
192+ any(std::string&& val) noexcept : tag(Tag::String), s(make_managed<std::string>(std::move(val))) {}
193
193
194− any(const managed<std::string>& val) noexcept : tag(tag_t::String), s(val) {}
194+ any(const managed<std::string>& val) noexcept : tag(Tag::String), s(val) {}
195− any(managed<std::string>&& val) noexcept : tag(tag_t::String), s(std::move(val)) {}
195+ any(managed<std::string>&& val) noexcept : tag(Tag::String), s(std::move(val)) {}
196
196
197 template <size_t N>
197 template <size_t N>
198− any(map<N>&& val) noexcept : tag(tag_t::Map), p(make_managed<map<N>>(std::move(val))) {}
198+ any(map<N>&& val) noexcept : tag(Tag::Map), p(make_managed<map<N>>(std::move(val))) {}
199
199
200 template <size_t N>
200 template <size_t N>
201− any(data<N>&& val) noexcept : tag(tag_t::Data), p(make_managed<data<N>>(std::move(val))) {}
201+ any(data<N>&& val) noexcept : tag(Tag::Data), p(make_managed<data<N>>(std::move(val))) {}
202
202
203− any(const array& val) : tag(tag_t::Array), a(make_managed<array>(val)) {}
203+ any(const array& val) : tag(Tag::Array), a(make_managed<array>(val)) {}
204− any(array&& val) noexcept : tag(tag_t::Array), a(make_managed<array>(std::move(val))) {}
204+ any(array&& val) noexcept : tag(Tag::Array), a(make_managed<array>(std::move(val))) {}
205
205
206 template <typename T>
206 template <typename T>
207 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0) noexcept
207 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0) noexcept
208− : tag(tag_t::Function), f(val) {}
208+ : tag(Tag::Function), f(val) {}
209
209
210 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&
210 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&
211 !std::is_convertible<T,fn>::value>::type>
211 !std::is_convertible<T,fn>::value>::type>
212 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any(const any&)>,T>::value>::type* = 0)
212 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any(const any&)>,T>::value>::type* = 0)
213− : tag(tag_t::Closure), l(make_managed<closure_<T>>(val)) {}
213+ : tag(Tag::Closure), l(make_managed<Closure_<T>>(val)) {}
214
214
215 template <typename T>
215 template <typename T>
216 any(const T& val, typename std::enable_if<std::is_convertible<T,eff_fn>::value>::type* = 0) noexcept
216 any(const T& val, typename std::enable_if<std::is_convertible<T,eff_fn>::value>::type* = 0) noexcept
217− : tag(tag_t::EffFunction), e(val) {}
217+ : tag(Tag::EffFunction), e(val) {}
218
218
219 template <typename T,
219 template <typename T,
220 typename = typename std::enable_if<!std::is_same<any,T>::value &&
220 typename = typename std::enable_if<!std::is_same<any,T>::value &&
221 !std::is_convertible<T,eff_fn>::value>::type>
221 !std::is_convertible<T,eff_fn>::value>::type>
222 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any()>,T>::value>::type* = 0)
222 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any()>,T>::value>::type* = 0)
223− : tag(tag_t::EffClosure), k(make_managed<eff_closure_<T>>(val)) {}
223+ : tag(Tag::EffClosure), k(make_managed<EffClosure_<T>>(val)) {}
224
224
225 template <typename T>
225 template <typename T>
226 any(const T& val, typename std::enable_if<std::is_convertible<T,thunk>::value>::type* = 0) noexcept
226 any(const T& val, typename std::enable_if<std::is_convertible<T,thunk>::value>::type* = 0) noexcept
227− : tag(tag_t::Thunk), t(val) {}
227+ : tag(Tag::Thunk), t(val) {}
228
228
229 template <typename T,
229 template <typename T,
230 typename = typename std::enable_if<std::is_class<typename std::remove_pointer<T>::type>::value>::type>
230 typename = typename std::enable_if<std::is_class<typename std::remove_pointer<T>::type>::value>::type>
231 any(const T& val, typename std::enable_if<IS_POINTER_TYPE(T)::value>::type* = 0) noexcept
231 any(const T& val, typename std::enable_if<IS_POINTER_TYPE(T)::value>::type* = 0) noexcept
232− : tag(tag_t::Pointer), p(val) {}
232+ : tag(Tag::Pointer), p(val) {}
233
233
234 template <typename T>
234 template <typename T>
235 any(T&& val, typename std::enable_if<std::is_assignable<managed<void>,T>::value>::type* = 0) noexcept
235 any(T&& val, typename std::enable_if<std::is_assignable<managed<void>,T>::value>::type* = 0) noexcept
236− : tag(tag_t::Pointer), p(std::move(val)) {}
236+ : tag(Tag::Pointer), p(std::move(val)) {}
237
237
238 // Explicit void* to raw pointer value
238 // Explicit void* to raw pointer value
239 template <typename T>
239 template <typename T>
240 any(const T& val, typename std::enable_if<std::is_same<T,void*>::value>::type* = 0) noexcept
240 any(const T& val, typename std::enable_if<std::is_same<T,void*>::value>::type* = 0) noexcept
241− : tag(tag_t::RawPointer), u(val) {}
241+ : tag(Tag::RawPointer), u(val) {}
242
242
243− any(nullptr_t) noexcept : tag(tag_t::RawPointer), u(nullptr) {}
243+ any(nullptr_t) noexcept : tag(Tag::RawPointer), u(nullptr) {}
244
244
245
245
246#if !defined(USE_GC)
246#if !defined(USE_GC)
@@ -262,23 +262,23 @@ class any {
262 template <typename T>
262 template <typename T>
263 auto assign(T&& other) const noexcept -> void {
263 auto assign(T&& other) const noexcept -> void {
264 switch (other.tag) {
264 switch (other.tag) {
265− case tag_t::Thunk: t = other.t; break;
265+ case Tag::Thunk: t = other.t; break;
266− case tag_t::Integer: i = other.i; break;
266+ case Tag::Integer: i = other.i; break;
267− case tag_t::Double: d = other.d; break;
267+ case Tag::Double: d = other.d; break;
268− case tag_t::Character: c = other.c; break;
268+ case Tag::Character: c = other.c; break;
269− case tag_t::Boolean: b = other.b; break;
269+ case Tag::Boolean: b = other.b; break;
270− case tag_t::StringLiteral: r = other.r; break;
270+ case Tag::StringLiteral: r = other.r; break;
271− case tag_t::Function: f = other.f; break;
271+ case Tag::Function: f = other.f; break;
272− case tag_t::EffFunction: e = other.e; break;
272+ case Tag::EffFunction: e = other.e; break;
273− case tag_t::RawPointer: u = other.u; break;
273+ case Tag::RawPointer: u = other.u; break;
274−
274+
275− case tag_t::String: new (&s) managed<std::string>(move_if_rvalue<T>(other.s)); break;
275+ case Tag::String: new (&s) managed<std::string>(move_if_rvalue<T>(other.s)); break;
276− case tag_t::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;
276+ case Tag::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;
277− case tag_t::Closure: new (&l) managed<closure>(move_if_rvalue<T>(other.l)); break;
277+ case Tag::Closure: new (&l) managed<Closure>(move_if_rvalue<T>(other.l)); break;
278− case tag_t::EffClosure: new (&k) managed<eff_closure>(move_if_rvalue<T>(other.k)); break;
278+ case Tag::EffClosure: new (&k) managed<EffClosure>(move_if_rvalue<T>(other.k)); break;
279− case tag_t::Map:
279+ case Tag::Map:
280− case tag_t::Data:
280+ case Tag::Data:
281− case tag_t::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;
281+ case Tag::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;
282
282
283 default: assert(false && "Bad 'any' tag"); break;
283 default: assert(false && "Bad 'any' tag"); break;
284 }
284 }
@@ -286,13 +286,13 @@ class any {
286
286
287 auto destruct() -> void {
287 auto destruct() -> void {
288 switch (tag) {
288 switch (tag) {
289− case tag_t::String: s.~managed<std::string>(); break;
289+ case Tag::String: s.~managed<std::string>(); break;
290− case tag_t::Array: a.~managed<array>(); break;
290+ case Tag::Array: a.~managed<array>(); break;
291− case tag_t::Closure: l.~managed<closure>(); break;
291+ case Tag::Closure: l.~managed<Closure>(); break;
292− case tag_t::EffClosure: k.~managed<eff_closure>(); break;
292+ case Tag::EffClosure: k.~managed<EffClosure>(); break;
293− case tag_t::Map:
293+ case Tag::Map:
294− case tag_t::Data:
294+ case Tag::Data:
295− case tag_t::Pointer: p.~managed<void>(); break;
295+ case Tag::Pointer: p.~managed<void>(); break;
296
296
297 default: break;
297 default: break;
298 }
298 }
@@ -345,13 +345,13 @@ class any {
345
345
346 auto size() const -> size_t;
346 auto size() const -> size_t;
347 auto empty() const -> bool;
347 auto empty() const -> bool;
348− auto contains(const symbol_t) const -> bool;
348+ auto contains(const Private::Symbol) const -> bool;
349
349
350− auto extractPointer(IF_DEBUG(const tag_t)) const -> void*;
350+ auto extractPointer(IF_DEBUG(const Tag)) const -> void*;
351
351
352 auto rawPointer() const -> void* {
352 auto rawPointer() const -> void* {
353 const any& variant = unthunkVariant(*this);
353 const any& variant = unthunkVariant(*this);
354− assert(tag == tag_t::RawPointer);
354+ assert(tag == Tag::RawPointer);
355 return variant.u;
355 return variant.u;
356 }
356 }
357
357
@@ -418,21 +418,21 @@ class any {
418
418
419namespace Private {
419namespace Private {
420 template <typename T, typename U=void>
420 template <typename T, typename U=void>
421− struct tag_helper_t {};
421+ struct TagHelper {};
422
422
423 template <size_t N>
423 template <size_t N>
424− struct tag_helper_t<any::map<N>> {
424+ struct TagHelper<any::map<N>> {
425− static constexpr any::tag_t tag = any::tag_t::Map;
425+ static constexpr any::Tag tag = any::Tag::Map;
426 };
426 };
427
427
428 template <size_t N>
428 template <size_t N>
429− struct tag_helper_t<any::data<N>> {
429+ struct TagHelper<any::data<N>> {
430− static constexpr any::tag_t tag = any::tag_t::Data;
430+ static constexpr any::Tag tag = any::Tag::Data;
431 };
431 };
432
432
433 template <typename T>
433 template <typename T>
434− struct tag_helper_t<T> {
434+ struct TagHelper<T> {
435− static constexpr any::tag_t tag = any::tag_t::Pointer;
435+ static constexpr any::Tag tag = any::Tag::Pointer;
436 };
436 };
437}
437}
438
438
@@ -458,7 +458,7 @@ inline auto cast(const any& a) ->
458template <typename T, typename = typename std::enable_if<std::is_class<T>::value>::type>
458template <typename T, typename = typename std::enable_if<std::is_class<T>::value>::type>
459inline auto cast(const any& a) ->
459inline auto cast(const any& a) ->
460 typename std::enable_if<!std::is_same<T, any::array>::value, T&>::type {
460 typename std::enable_if<!std::is_same<T, any::array>::value, T&>::type {
461− return *static_cast<T*>(a.extractPointer(IF_DEBUG(Private::tag_helper_t<T>::tag)));
461+ return *static_cast<T*>(a.extractPointer(IF_DEBUG(Private::TagHelper<T>::tag)));
462}
462}
463
463
464template <typename T>
464template <typename T>
@@ -480,7 +480,7 @@ namespace map {
480 }
480 }
481
481
482 template <size_t N>
482 template <size_t N>
483− inline auto get(const symbol_t key, const any::map<N>& a) -> const any& {
483+ inline auto get(const Private::Symbol key, const any::map<N>& a) -> const any& {
484 static_assert(N > 0, "map size must be greater than zero");
484 static_assert(N > 0, "map size must be greater than zero");
485 typename std::remove_reference<decltype(a)>::type::size_type i = 0;
485 typename std::remove_reference<decltype(a)>::type::size_type i = 0;
486 do {
486 do {
@@ -493,7 +493,7 @@ namespace map {
493 return invalid_key;
493 return invalid_key;
494 }
494 }
495
495
496− inline auto get(const symbol_t key, const any& a) -> const any& {
496+ inline auto get(const Private::Symbol key, const any& a) -> const any& {
497 return get(key, cast<any::map<unknown_size>>(a));
497 return get(key, cast<any::map<unknown_size>>(a));
498 }
498 }
499}
499}
src/Language/PureScript/CodeGen/Cpp/Common.hs−1
@@ -204,7 +204,6 @@ nameIsCppReserved name =
204 , "struct"
204 , "struct"
205 , "switch"
205 , "switch"
206 , "symbol"
206 , "symbol"
207− , "symbol_t"
208 , "synchronized"
207 , "synchronized"
209 , "template"
208 , "template"
210 , "the_value"
209 , "the_value"