cde8c4c · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

C++: runtime cleanup

commitcde8c4c4c41b95aab1d7d04062f0c3b13000993e authorAndy Arvanitis <andyarvanitis@gmail.com> dateMon 4 Jan 2016, 19:55 (11 years ago) parent55df68c

2 files changed+75−85

compare with golang

unifiedsplit

pcc/include/purescript.cc+47−47 pcc/include/purescript.hh+28−38

pcc/include/purescript.cc+47−47

@@ -22,32 +22,32 @@ any::any(const any& val) : type(val.type) {

2222 case Type::Double: d = val.d; break;

2323 case Type::Character: c = val.c; break;

2424 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;

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> (val.p); break;

3232

3333 default: assert(false && "Unsupported type in copy ctor");

3434 }

3535}

3636

37−void any::swap(any&& val) {

37+void any::swap(any&& val) const {

3838 type = val.type;

3939 switch (type) {

4040 case Type::Integer: i = val.i; break;

4141 case Type::Double: d = val.d; break;

4242 case Type::Character: c = val.c; break;

4343 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;

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> (std::move(val.p)); break;

5151

5252 default: assert(false && "Unsupported type in move ctor");

5353 }

@@ -60,13 +60,13 @@ any::~any() {

6060 case Type::Double: ; break;

6161 case Type::Character: ; break;

6262 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;

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>(); break;

7070

7171 default: assert(false && "Unsupported type in destructor");

7272 }

@@ -229,21 +229,21 @@ any::~any() {

229229

230230#define DEFINE_OPERATOR_LHS(K, T, OP, V, R, P) \

231231auto operator OP(const T lhs, const any& rhs_) -> R { \

232− auto& rhs = any::extract_value(rhs_); \

232+ const any& rhs = any::extract_value(rhs_); \

233233 assert(rhs.type == any::Type::K); \

234234 return lhs OP P(rhs.V); \

235235}

236236

237237#define DEFINE_OPERATOR_RHS(K, T, OP, V, R, P) \

238238auto any::operator OP(const T rhs) const -> R { \

239− auto& lhs = any::extract_value(*this); \

239+ const any& lhs = any::extract_value(*this); \

240240 assert(lhs.type == Type::K); \

241241 return P(lhs.V) OP rhs; \

242242}

243243

244244auto any::operator==(const any& rhs_) const -> bool {

245− auto& lhs = extract_value(*this);

246− auto& rhs = extract_value(rhs_);

245+ const any& lhs = extract_value(*this);

246+ const any& rhs = extract_value(rhs_);

247247 assert(lhs.type == rhs.type);

248248 switch (lhs.type) {

249249 case Type::Integer: return lhs.i == rhs.i;

@@ -265,8 +265,8 @@ DEFINE_OPERATOR_RHS(String, string&, ==, s, bool, *)

265265DEFINE_OPERATOR_RHS(String, char* const, ==, s, bool, *)

266266

267267auto any::operator!=(const any& rhs_) const -> bool {

268− auto& lhs = extract_value(*this);

269− auto& rhs = extract_value(rhs_);

268+ const any& lhs = extract_value(*this);

269+ const any& rhs = extract_value(rhs_);

270270 assert(lhs.type == rhs.type);

271271 switch (lhs.type) {

272272 case Type::Integer: return lhs.i != rhs.i;

@@ -288,8 +288,8 @@ DEFINE_OPERATOR_RHS(String, string&, !=, s, bool, *)

288288DEFINE_OPERATOR_RHS(String, char* const, !=, s, bool, *)

289289

290290auto any::operator<(const any& rhs_) const -> bool {

291− auto& lhs = extract_value(*this);

292− auto& rhs = extract_value(rhs_);

291+ const any& lhs = extract_value(*this);

292+ const any& rhs = extract_value(rhs_);

293293 assert(lhs.type == rhs.type);

294294 switch (lhs.type) {

295295 case Type::Integer: return lhs.i < rhs.i;

@@ -310,8 +310,8 @@ DEFINE_OPERATOR_RHS(String, string&, <, s, bool, *)

310310DEFINE_OPERATOR_RHS(String, char* const, <, s, bool, *)

311311

312312auto any::operator<=(const any& rhs_) const -> bool {

313− auto& lhs = extract_value(*this);

314− auto& rhs = extract_value(rhs_);

313+ const any& lhs = extract_value(*this);

314+ const any& rhs = extract_value(rhs_);

315315 assert(lhs.type == rhs.type);

316316 switch (lhs.type) {

317317 case Type::Integer: return lhs.i <= rhs.i;

@@ -332,8 +332,8 @@ DEFINE_OPERATOR_RHS(String, string&, <=, s, bool, *)

332332DEFINE_OPERATOR_RHS(String, char* const, <=, s, bool, *)

333333

334334auto any::operator>(const any& rhs_) const -> bool {

335− auto& lhs = extract_value(*this);

336− auto& rhs = extract_value(rhs_);

335+ const any& lhs = extract_value(*this);

336+ const any& rhs = extract_value(rhs_);

337337 assert(lhs.type == rhs.type);

338338 switch (lhs.type) {

339339 case Type::Integer: return lhs.i > rhs.i;

@@ -354,8 +354,8 @@ DEFINE_OPERATOR_RHS(String, string&, >, s, bool, *)

354354DEFINE_OPERATOR_RHS(String, char* const, >, s, bool, *)

355355

356356auto any::operator>=(const any& rhs_) const -> bool {

357− auto& lhs = extract_value(*this);

358− auto& rhs = extract_value(rhs_);

357+ const any& lhs = extract_value(*this);

358+ const any& rhs = extract_value(rhs_);

359359 assert(lhs.type == rhs.type);

360360 switch (lhs.type) {

361361 case Type::Integer: return lhs.i >= rhs.i;

@@ -376,8 +376,8 @@ DEFINE_OPERATOR_RHS(String, string&, >=, s, bool, *)

376376DEFINE_OPERATOR_RHS(String, char* const, >=, s, bool, *)

377377

378378auto any::operator+(const any& rhs_) const -> any {

379− auto& lhs = extract_value(*this);

380− auto& rhs = extract_value(rhs_);

379+ const any& lhs = extract_value(*this);

380+ const any& rhs = extract_value(rhs_);

381381 assert(lhs.type == rhs.type);

382382 switch (lhs.type) {

383383 case Type::Integer: return lhs.i + rhs.i;

@@ -396,8 +396,8 @@ DEFINE_OPERATOR_RHS(String, string&, +, s, string, *)

396396DEFINE_OPERATOR_RHS(String, char* const, +, s, string, *)

397397

398398auto any::operator-(const any& rhs_) const -> any {

399− auto& lhs = extract_value(*this);

400− auto& rhs = extract_value(rhs_);

399+ const any& lhs = extract_value(*this);

400+ const any& rhs = extract_value(rhs_);

401401 assert(lhs.type == rhs.type);

402402 switch (lhs.type) {

403403 case Type::Integer: return lhs.i - rhs.i;

@@ -413,8 +413,8 @@ DEFINE_OPERATOR_RHS(Double, double, -, d, double,)

413413DEFINE_OPERATOR_RHS(Character, char, -, c, char,)

414414

415415auto any::operator*(const any& rhs_) const -> any {

416− auto& lhs = extract_value(*this);

417− auto& rhs = extract_value(rhs_);

416+ const any& lhs = extract_value(*this);

417+ const any& rhs = extract_value(rhs_);

418418 assert(lhs.type == rhs.type);

419419 switch (lhs.type) {

420420 case Type::Integer: return lhs.i * rhs.i;

@@ -428,8 +428,8 @@ DEFINE_OPERATOR_RHS(Integer, long, *, i, long,)

428428DEFINE_OPERATOR_RHS(Double, double, *, d, double,)

429429

430430auto any::operator/(const any& rhs_) const -> any {

431− auto& lhs = extract_value(*this);

432− auto& rhs = extract_value(rhs_);

431+ const any& lhs = extract_value(*this);

432+ const any& rhs = extract_value(rhs_);

433433 assert(lhs.type == rhs.type);

434434 switch (lhs.type) {

435435 case Type::Integer: return lhs.i / rhs.i;

@@ -443,8 +443,8 @@ DEFINE_OPERATOR_RHS(Integer, long, /, i, long,)

443443DEFINE_OPERATOR_RHS(Double, double, /, d, double,)

444444

445445auto any::operator%(const any& rhs_) const -> any {

446− auto& lhs = extract_value(*this);

447− auto& rhs = extract_value(rhs_);

446+ const any& lhs = extract_value(*this);

447+ const any& rhs = extract_value(rhs_);

448448 assert(lhs.type == rhs.type);

449449 switch (lhs.type) {

450450 case Type::Integer: return lhs.i % rhs.i;

@@ -456,7 +456,7 @@ auto any::operator%(const any& rhs_) const -> any {

456456DEFINE_OPERATOR_RHS(Integer, long, %, i, long,)

457457

458458auto any::operator-() const -> any {

459− auto& lhs = any::extract_value(*this);

459+ const any& lhs = any::extract_value(*this);

460460 switch (lhs.type) {

461461 case Type::Integer: return (- lhs.i);

462462 case Type::Double: return (- lhs.d);

pcc/include/purescript.hh+28−38

@@ -63,7 +63,7 @@ class any {

6363 Pointer

6464 };

6565

66− Type type = Type::Unknown;

66+ mutable Type type = Type::Unknown;

6767

6868 struct as_thunk {

6969 };

@@ -75,19 +75,9 @@ class any {

7575 using eff_fn = std::function<any()>;

7676 using thunk = std::function<const any& (const as_thunk)>;

7777

78− using shared_string = std::shared_ptr<string>;

79− using shared_map = std::shared_ptr<map>;

80− using shared_vector = std::shared_ptr<vector>;

81−

82− using shared_fn = std::shared_ptr<fn>;

83− using shared_eff_fn = std::shared_ptr<eff_fn>;

84− using shared_thunk = std::shared_ptr<thunk>;

85−

8678 template <typename T>

8779 using shared = std::shared_ptr<T>;

8880

89− using shared_void_ptr = std::shared_ptr<void>;

90−

9181 template <typename T>

9282 static constexpr auto make_shared(const T& arg) -> shared<T> {

9383 return std::make_shared<T>(arg);

@@ -105,17 +95,17 @@ class any {

10595

10696 private:

10797 union {

108− long i;

109− double d;

110− char c;

111− bool b;

112− shared_string s;

113− shared_map m;

114− shared_vector v;

115− shared_fn f;

116− shared_eff_fn e;

117− shared_thunk t;

118− shared_void_ptr p;

98+ mutable long i;

99+ mutable double d;

100+ mutable char c;

101+ mutable bool b;

102+ mutable shared<string> s;

103+ mutable shared<map> m;

104+ mutable shared<vector> v;

105+ mutable shared<fn> f;

106+ mutable shared<eff_fn> e;

107+ mutable shared<thunk> t;

108+ mutable shared<void> p;

119109 };

120110

121111 public:

@@ -135,23 +125,23 @@ class any {

135125

136126 any(const char val[]) : type(Type::String), s(make_shared<string>(val)) {}

137127

138− any(const shared_string& val) : type(Type::String), s(val) {}

139− any(shared_string&& val) : type(Type::String), s(std::move(val)) {}

128+ any(const shared<string>& val) : type(Type::String), s(val) {}

129+ any(shared<string>&& val) : type(Type::String), s(std::move(val)) {}

140130

141131 any(const map& val) : type(Type::Map), m(make_shared<map>(val)) {}

142132 any(map&& val) : type(Type::Map), m(make_shared<map>(std::move(val))) {}

143133

144− any(const shared_map& val) : type(Type::Map), m(val) {}

145− any(shared_map&& val) : type(Type::Map), m(std::move(val)) {}

134+ any(const shared<map>& val) : type(Type::Map), m(val) {}

135+ any(shared<map>&& val) : type(Type::Map), m(std::move(val)) {}

146136

147137 any(const vector& val) : type(Type::Vector), v(make_shared<vector>(val)) {}

148138 any(vector&& val) : type(Type::Vector), v(make_shared<vector>(std::move(val))) {}

149139

150− any(const shared_vector& val) : type(Type::Vector), v(val) {}

151− any(shared_vector&& val) : type(Type::Vector), v(std::move(val)) {}

140+ any(const shared<vector>& val) : type(Type::Vector), v(val) {}

141+ any(shared<vector>&& val) : type(Type::Vector), v(std::move(val)) {}

152142

153− any(const shared_fn& val) : type(Type::Function), f(val) {}

154− any(shared_fn&& val) : type(Type::Function), f(std::move(val)) {}

143+ any(const shared<fn>& val) : type(Type::Function), f(val) {}

144+ any(shared<fn>&& val) : type(Type::Function), f(std::move(val)) {}

155145

156146 template <typename T>

157147 any(const T& val, typename std::enable_if<std::is_assignable<fn,T>::value>::type* = 0)

@@ -161,33 +151,33 @@ class any {

161151 // any(T&& val, typename std::enable_if<std::is_assignable<fn,T>::value>::type* = 0)

162152 // : type(Type::Function), f(std::move(val)) {}

163153

164− any(const shared_eff_fn& val) : type(Type::EffFunction), e(val) {}

165− any(shared_eff_fn&& val) : type(Type::EffFunction), e(std::move(val)) {}

154+ any(const shared<eff_fn>& val) : type(Type::EffFunction), e(val) {}

155+ any(shared<eff_fn>&& val) : type(Type::EffFunction), e(std::move(val)) {}

166156

167157 template <typename T>

168158 any(const T& val, typename std::enable_if<std::is_assignable<eff_fn,T>::value>::type* = 0)

169159 : type(Type::EffFunction), e(make_shared<eff_fn>(val)) {}

170160

171− any(const shared_thunk& val) : type(Type::Thunk), t(val) {}

172− any(shared_thunk&& val) : type(Type::Thunk), t(std::move(val)) {}

161+ any(const shared<thunk>& val) : type(Type::Thunk), t(val) {}

162+ any(shared<thunk>&& val) : type(Type::Thunk), t(std::move(val)) {}

173163

174164 template <typename T>

175165 any(const T& val, typename std::enable_if<std::is_assignable<thunk,T>::value>::type* = 0)

176166 : type(Type::Thunk), t(make_shared<thunk>(val)) {}

177167

178168 template <typename T>

179− any(const T& val, typename std::enable_if<std::is_assignable<shared_void_ptr,T>::value>::type* = 0)

169+ any(const T& val, typename std::enable_if<std::is_assignable<shared<void>,T>::value>::type* = 0)

180170 : type(Type::Pointer), p(val) {}

181171

182172 any(std::nullptr_t) : type(Type::Pointer), p(nullptr) {}

183173

184174 template <typename T>

185− any(T&& val, typename std::enable_if<std::is_assignable<shared_void_ptr,T>::value>::type* = 0)

175+ any(T&& val, typename std::enable_if<std::is_assignable<shared<void>,T>::value>::type* = 0)

186176 : type(Type::Pointer), p(std::move(val)) {}

187177

188178 any(const any&);

189179

190− void swap(any&&);

180+ void swap(any&&) const;

191181

192182 any(any&& val) {

193183 swap(std::move(val));

@@ -226,7 +216,7 @@ class any {

226216 auto cast() const -> typename std::enable_if<std::is_same<T, vector>::value, const T&>::type;

227217

228218 template <typename T>

229− auto cast() const -> typename std::enable_if<std::is_assignable<shared_void_ptr,T>::value, typename T::element_type*>::type {

219+ auto cast() const -> typename std::enable_if<std::is_assignable<shared<void>,T>::value, typename T::element_type*>::type {

230220 if (type == Type::Pointer) {

231221 return static_cast_shared<typename T::element_type>(p);

232222 }