40a3fe2 · rowtype-yoga/purescript-native

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

on golang help sign in

C++: consolidate logic for managed types

40a3fe2Andy Arvanitis10 years ago

pcc/runtime/purescript.cc+10−8

compare with golang

unifiedsplit

@@ -28,7 +28,7 @@ any::EffClosure::~EffClosure() {}

28auto any::operator()(const any& arg) const -> any {

29 const any& variant = unthunkVariant(*this);

30 if (variant.tag == Tag::Closure) {

31− return (*variant.l)(arg);

31+ return (*static_cast<const Closure*>(POINTER_FROM_MEMBER(variant.p)))(arg);

32 }

33 assert(variant.tag == Tag::Function);

34 return (*variant.f)(arg);

@@ -42,7 +42,7 @@ auto any::operator()(const as_thunk) const -> const any& {

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

43 const any& variant = unthunkVariant(*this);

44 if (variant.tag == Tag::EffClosure) {

45− return (*variant.k)();

45+ return (*static_cast<const EffClosure*>(POINTER_FROM_MEMBER(variant.p)))();

46 }

47 assert(variant.tag == Tag::EffFunction);

48 return (*variant.e)();

@@ -77,19 +77,19 @@ any::operator size_t() const {

77}

79any::operator const string&() const {

80− RETURN_VALUE(Tag::String, s, *)

80+ return *static_cast<const string*>(extractPointer(IF_DEBUG(Tag::String)));

81}

83any::operator const char *() const {

84− RETURN_VALUE(Tag::String, s->c_str(),)

84+ return static_cast<const string*>(extractPointer(IF_DEBUG(Tag::String)))->c_str();

85}

87any::operator const array&() const {

88− RETURN_VALUE(Tag::Array, a, *)

88+ return *static_cast<const array*>(extractPointer(IF_DEBUG(Tag::Array)));

89}

91any::operator const record&() const {

92− RETURN_VALUE(Tag::Record, r, *)

92+ return *static_cast<const record*>(extractPointer(IF_DEBUG(Tag::Record)));

93}

95auto any::extractPointer(IF_DEBUG(const any::Tag t)) const -> void* {

@@ -145,7 +145,8 @@ auto any::at(const std::string& key) const -> const any& {

145 case any::Tag::Double: return lhs.d op static_cast<decltype(any::d)>(rhs); \

146 case any::Tag::Character: return lhs.c op static_cast<decltype(any::c)>(rhs); \

147 case any::Tag::Boolean: return lhs.b op static_cast<decltype(any::b)>(rhs); \

148+ case any::Tag::String: return *static_cast<const string*>(POINTER_FROM_MEMBER(lhs.p)) \

148− case any::Tag::String: return *lhs.s op static_cast<const string&>(rhs); \

149+ op static_cast<const string&>(rhs); \

149 case any::Tag::RawPointer: return lhs.v op cast<decltype(any::v)>(rhs); \

150 case any::Tag::RawPointer: return lhs.v op cast<decltype(any::v)>(rhs); \

150 case any::Tag::Pointer: return lhs.p op any::unthunkVariant(rhs).p; \

151 case any::Tag::Pointer: return lhs.p op any::unthunkVariant(rhs).p; \

151 default: assert(false && "Unsupported tag for operator " #op); \

152 default: assert(false && "Unsupported tag for operator " #op); \

@@ -170,7 +171,8 @@ auto operator+(const any& lhs_, const any& rhs) -> any {

170 case any::Tag::Integer: return lhs.i + static_cast<decltype(any::i)>(rhs);

171 case any::Tag::Integer: return lhs.i + static_cast<decltype(any::i)>(rhs);

171 case any::Tag::Double: return lhs.d + static_cast<decltype(any::d)>(rhs);

172 case any::Tag::Double: return lhs.d + static_cast<decltype(any::d)>(rhs);

172 case any::Tag::Character: return decltype(any::c){lhs.c + static_cast<decltype(any::c)>(rhs)};

173 case any::Tag::Character: return decltype(any::c){lhs.c + static_cast<decltype(any::c)>(rhs)};

174+ case any::Tag::String: return *static_cast<const string*>(POINTER_FROM_MEMBER(lhs.p))

173− case any::Tag::String: return *lhs.s + static_cast<const string&>(rhs);

175+ + static_cast<const string&>(rhs);

174 default: assert(false && "Unsupported tag for '+' operator");

176 default: assert(false && "Unsupported tag for '+' operator");

175 }

177 }

176 return nullptr;

178 return nullptr;

pcc/runtime/purescript.hh+65−94

@@ -80,9 +80,13 @@ static constexpr size_t unknown_size = 64;

80//

81class any {

83+ private:

84+ static constexpr auto _managed_ = 0x10;

85+

83 public:

86 public:

84 enum class Tag {

87 enum class Tag {

88+ Unknown,

85− Thunk = 0x10,

89+ Thunk,

86 Integer,

90 Integer,

87 Double,

91 Double,

88 Character,

92 Character,

@@ -90,19 +94,25 @@ class any {

90 Function,

94 Function,

91 EffFunction,

95 EffFunction,

92 RawPointer,

96 RawPointer,

93− String,

97+ String = _managed_,

94− Map,

98+ Dictionary,

95 Data,

99 Data,

96 Array,

100 Array,

97 Record,

101 Record,

98 Closure,

102 Closure,

99 EffClosure,

103 EffClosure,

100− Pointer

104+ Pointer,

105+ Invalid

101 };

106 };

102

107

103 private:

108 private:

104 mutable Tag tag;

109 mutable Tag tag;

105

110

111+ inline static auto isManaged(const Tag tag) -> decltype(_managed_) {

112+ return static_cast<decltype(_managed_)>(tag) & _managed_;

113+ }

114+ static_assert(static_cast<decltype(_managed_)>(Tag::Invalid) & _managed_, "outside of range");

115+

106 public:

116 public:

107 struct as_thunk {

117 struct as_thunk {

108 };

118 };

@@ -158,20 +168,16 @@ class any {

158

168

159 private:

169 private:

160 union {

170 union {

161− mutable thunk t;

171+ mutable thunk t;

162− mutable int i;

172+ mutable int i;

163− mutable double d;

173+ mutable double d;

164− mutable char32_t c;

174+ mutable char32_t c;

165− mutable bool b;

175+ mutable bool b;

166− mutable fn f;

176+ mutable fn f;

167− mutable eff_fn e;

177+ mutable eff_fn e;

168− mutable void * v;

178+ mutable void * v;

169− mutable managed<string> s;

179+ mutable uint64_t u;

170− mutable managed<array> a;

171− mutable managed<record> r;

172− mutable managed<Closure> l;

173− mutable managed<EffClosure> k;

180+ mutable managed<void> p;

174− mutable managed<void> p;

175 };

181 };

176

182

177 public:

183 public:

@@ -188,24 +194,24 @@ class any {

188 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>

194 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>

189 any(const T val) noexcept : tag(Tag::Boolean), b(val) {}

195 any(const T val) noexcept : tag(Tag::Boolean), b(val) {}

190

196

191− any(const char * val) : tag(Tag::String), s(make_managed_and_finalized<string>(val)) {}

197+ any(const char * val) : tag(Tag::String), p(make_managed_and_finalized<string>(val)) {}

192− any(const string& val) : tag(Tag::String), s(make_managed_and_finalized<string>(val)) {}

198+ any(const string& val) : tag(Tag::String), p(make_managed_and_finalized<string>(val)) {}

193− any(string&& val) noexcept : tag(Tag::String), s(make_managed_and_finalized<string>(std::move(val))) {}

199+ any(string&& val) noexcept : tag(Tag::String), p(make_managed_and_finalized<string>(std::move(val))) {}

194

200

195− any(const managed<string>& val) noexcept : tag(Tag::String), s(val) {}

201+ any(const managed<string>& val) noexcept : tag(Tag::String), p(val) {}

196− any(managed<string>&& val) noexcept : tag(Tag::String), s(std::move(val)) {}

202+ any(managed<string>&& val) noexcept : tag(Tag::String), p(std::move(val)) {}

197

203

198 template <size_t N>

204 template <size_t N>

199− any(dict<N>&& val) noexcept : tag(Tag::Map), p(make_managed<dict<N>>(std::move(val))) {}

205+ any(dict<N>&& val) noexcept : tag(Tag::Dictionary), p(make_managed<dict<N>>(std::move(val))) {}

200

206

201 template <size_t N>

207 template <size_t N>

202 any(data<N>&& val) noexcept : tag(Tag::Data), p(make_managed<data<N>>(std::move(val))) {}

208 any(data<N>&& val) noexcept : tag(Tag::Data), p(make_managed<data<N>>(std::move(val))) {}

203

209

204− any(const array& val) : tag(Tag::Array), a(make_managed<array>(val)) {}

210+ any(const array& val) : tag(Tag::Array), p(make_managed<array>(val)) {}

205− any(array&& val) noexcept : tag(Tag::Array), a(make_managed<array>(std::move(val))) {}

211+ any(array&& val) noexcept : tag(Tag::Array), p(make_managed<array>(std::move(val))) {}

206

212

207− any(const record& val) : tag(Tag::Record), r(make_managed<record>(val)) {}

213+ any(const record& val) : tag(Tag::Record), p(make_managed<record>(val)) {}

208− any(record&& val) noexcept : tag(Tag::Record), r(make_managed<record>(std::move(val))) {}

214+ any(record&& val) noexcept : tag(Tag::Record), p(make_managed<record>(std::move(val))) {}

209

215

210 template <typename T>

216 template <typename T>

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

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

@@ -214,7 +220,7 @@ class any {

214 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&

220 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&

215 !std::is_convertible<T,fn>::value>::type>

221 !std::is_convertible<T,fn>::value>::type>

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

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

217− : tag(Tag::Closure), l(make_managed<Closure_<T>>(val)) {}

223+ : tag(Tag::Closure), p(make_managed<Closure_<T>>(val)) {}

218

224

219 template <typename T>

225 template <typename T>

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

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

@@ -224,7 +230,7 @@ class any {

224 typename = typename std::enable_if<!std::is_same<any,T>::value &&

230 typename = typename std::enable_if<!std::is_same<any,T>::value &&

225 !std::is_convertible<T,eff_fn>::value>::type>

231 !std::is_convertible<T,eff_fn>::value>::type>

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

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

227− : tag(Tag::EffClosure), k(make_managed<EffClosure_<T>>(val)) {}

233+ : tag(Tag::EffClosure), p(make_managed<EffClosure_<T>>(val)) {}

228

234

229 template <typename T>

235 template <typename T>

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

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

@@ -249,80 +255,56 @@ class any {

249

255

250#if !defined(USE_GC)

256#if !defined(USE_GC)

251 private:

257 private:

252− template <typename T,

258+ auto destruct() const noexcept -> void {

253− typename U,

259+ if (isManaged(tag)) {

254− typename = typename std::enable_if<!std::is_reference<T>::value>::type>

260+ p.~managed<void>();

255− static constexpr auto move_if_rvalue(U&& u) noexcept -> U&& {

256− return static_cast<U&&>(u);

257− }

261+ }

258−

259− template <typename T,

260− typename U,

261− typename = typename std::enable_if<std::is_reference<T>::value>::type>

262− static constexpr auto move_if_rvalue(U& u) noexcept -> U& {

263− return static_cast<U&>(u);

264 }

262 }

265

263

266− template <typename T>

264+ static_assert(sizeof(u) >= sizeof(t), "size assumption");

265+ static_assert(sizeof(u) >= sizeof(i), "size assumption");

266+ static_assert(sizeof(u) >= sizeof(d), "size assumption");

267+ static_assert(sizeof(u) >= sizeof(c), "size assumption");

268+ static_assert(sizeof(u) >= sizeof(b), "size assumption");

269+ static_assert(sizeof(u) >= sizeof(f), "size assumption");

270+ static_assert(sizeof(u) >= sizeof(e), "size assumption");

271+ static_assert(sizeof(u) >= sizeof(v), "size assumption");

272+

267− auto assign(T&& other) const noexcept -> void {

273+ auto copyAssign(const any& other) const noexcept -> void {

268− switch (other.tag) {

274+ if (isManaged(other.tag)) {

269− case Tag::Thunk: t = other.t; break;

275+ new (&p) managed<void>(other.p);

270− case Tag::Integer: i = other.i; break;

276+ } else {

271− case Tag::Double: d = other.d; break;

277+ u = other.u;

272− case Tag::Character: c = other.c; break;

273− case Tag::Boolean: b = other.b; break;

274− case Tag::Function: f = other.f; break;

275− case Tag::EffFunction: e = other.e; break;

276− case Tag::RawPointer: v = other.v; break;

277−

278− case Tag::String: new (&s) managed<string>(move_if_rvalue<T>(other.s)); break;

279− case Tag::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;

280− case Tag::Record: new (&r) managed<record>(move_if_rvalue<T>(other.r)); break;

281− case Tag::Closure: new (&l) managed<Closure>(move_if_rvalue<T>(other.l)); break;

282− case Tag::EffClosure: new (&k) managed<EffClosure>(move_if_rvalue<T>(other.k)); break;

283− case Tag::Map:

284− case Tag::Data:

285− case Tag::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;

286−

287− default: assert(false && "Bad 'any' tag"); break;

288 }

278 }

289 }

279 }

290−

280+ auto moveAssign(any& other) const noexcept -> void {

291− auto destruct() -> void {

281+ if (isManaged(other.tag)) {

292− switch (tag) {

282+ new (&p) managed<void>(std::move(other.p));

293− case Tag::String: s.~managed<string>(); break;

283+ } else {

294− case Tag::Array: a.~managed<array>(); break;

284+ u = other.u;

295− case Tag::Record: r.~managed<record>(); break;

296− case Tag::Closure: l.~managed<Closure>(); break;

297− case Tag::EffClosure: k.~managed<EffClosure>(); break;

298− case Tag::Map:

299− case Tag::Data:

300− case Tag::Pointer: p.~managed<void>(); break;

301−

302− default: break;

303 }

285 }

304 }

286 }

305

287

306 public:

288 public:

307 any(const any& other) noexcept : tag(other.tag) {

289 any(const any& other) noexcept : tag(other.tag) {

308− assign(other);

290+ copyAssign(other);

309 }

291 }

310

292

311 any(any&& other) noexcept : tag(other.tag) {

293 any(any&& other) noexcept : tag(other.tag) {

312− assign(std::move(other));

294+ moveAssign(other);

313 }

295 }

314

296

315 auto operator=(const any& rhs) noexcept -> any& {

297 auto operator=(const any& rhs) noexcept -> any& {

316 destruct();

298 destruct();

317 tag = rhs.tag;

299 tag = rhs.tag;

318− assign(rhs);

300+ copyAssign(rhs);

319 return *this;

301 return *this;

320 }

302 }

321

303

322 auto operator=(any&& rhs) noexcept -> any& {

304 auto operator=(any&& rhs) noexcept -> any& {

323 destruct();

305 destruct();

324 tag = rhs.tag;

306 tag = rhs.tag;

325− assign(std::move(rhs));

307+ moveAssign(rhs);

326 return *this;

308 return *this;

327 }

309 }

328

310

@@ -431,7 +413,7 @@ namespace Private {

431

413

432 template <size_t N>

414 template <size_t N>

433 struct TagHelper<any::dict<N>> {

415 struct TagHelper<any::dict<N>> {

434− static constexpr any::Tag tag = any::Tag::Map;

416+ static constexpr any::Tag tag = any::Tag::Dictionary;

435 };

417 };

436

418

437 template <size_t N>

419 template <size_t N>

@@ -458,19 +440,8 @@ inline auto cast(const any& a) ->

458 return a;

440 return a;

459}

441}

460

442

461−template <typename T>

462−inline auto cast(const any& a) ->

463− typename std::enable_if<std::is_same<T, string>::value ||

464− std::is_same<T, any::array>::value ||

465− std::is_same<T, any::record>::value, const T&>::type {

466− return a;

467−}

468−

469template <typename T,

443template <typename T,

470− typename = typename std::enable_if<std::is_class<T>::value &&

444+ typename = typename std::enable_if<std::is_class<T>::value>::type>

471− !std::is_same<T,string>::value &&

472− !std::is_same<T,any::array>::value &&

473− !std::is_same<T,any::record>::value>::type>

474inline auto cast(const any& a) -> T& {

445inline auto cast(const any& a) -> T& {

475 return *static_cast<T*>(a.extractPointer(IF_DEBUG(Private::TagHelper<T>::tag)));

446 return *static_cast<T*>(a.extractPointer(IF_DEBUG(Private::TagHelper<T>::tag)));

476}

447}