pcc/include/purescript.cc · rowtype-yoga/purescript-native

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

on a966e02 help sign in

rowtype-yoga/purescript-native/pcc/include/purescript.cc

488 lines 18 kB history raw

1///////////////////////////////////////////////////////////////////////////////

2//

3// Module : purescript.cc

4// Copyright : (c) Andy Arvanitis 2015

5// License : MIT

6//

7// Maintainer : Andy Arvanitis <andy.arvanitis@gmail.com>

8// Stability : experimental

9// Portability :

10//

11// Basic types and functions to support purescript-to-C++1x rendering

12//

13///////////////////////////////////////////////////////////////////////////////

14//

15#include <cstring>

16#include "PureScript.hh"

18namespace PureScript {

20#define COPY_DATA(src) \

21 switch (type) { \

22 case Type::Integer: i = src.i; break; \

23 case Type::Double: d = src.d; break; \

24 case Type::Character: c = src.c; break; \

25 case Type::Boolean: b = src.b; break; \

26 case Type::StringLiteral: r = src.r; break; \

27 case Type::String: new (&s) shared<std::string>(src.s); break; \

28 case Type::Map: new (&m) shared<map>(src.m); break; \

29 case Type::Data: new (&v) shared<data>(src.v); break; \

30 case Type::Array: new (&a) shared<array>(src.a); break; \

31 case Type::Function: f = src.f; break; \

32 case Type::Closure: new (&l) shared<closure>(src.l); break; \

33 case Type::EffFunction: new (&e) shared<eff_fn>(src.e); break; \

34 case Type::Thunk: t = src.t; break; \

35 case Type::Pointer: new (&p) shared<void>(src.p); break; \

36 \

37 default: assert(false && "Unsupported type in copy"); \

38 }

40#define MOVE_DATA(src) \

41 switch (type) { \

42 case Type::Integer: i = src.i; break; \

43 case Type::Double: d = src.d; break; \

44 case Type::Character: c = src.c; break; \

45 case Type::Boolean: b = src.b; break; \

46 case Type::StringLiteral: r = src.r; break; \

47 case Type::String: new (&s) shared<std::string>(std::move(src.s)); break; \

48 case Type::Map: new (&m) shared<map>(std::move(src.m)); break; \

49 case Type::Data: new (&v) shared<data>(std::move(src.v)); break; \

50 case Type::Array: new (&a) shared<array>(std::move(src.a)); break; \

51 case Type::Function: f = src.f; break; \

52 case Type::Closure: new (&l) shared<closure>(std::move(src.l)); break; \

53 case Type::EffFunction: new (&e) shared<eff_fn>(std::move(src.e)); break; \

54 case Type::Thunk: t = src.t; break; \

55 case Type::Pointer: new (&p) shared<void>(std::move(src.p)); break; \

56 \

57 default: assert(false && "Unsupported type in move"); \

58 }

60any::any(const any& other) : type(other.type) {

61 COPY_DATA(other);

62}

64any::any(any&& other) noexcept : type(other.type) {

65 MOVE_DATA(other);

66}

68auto any::operator=(const any& rhs) -> any& {

69 type = rhs.type;

70 COPY_DATA(rhs);

71 return *this;

72}

74// Takes ownership -- might need to reconsider this

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

76 type = rhs.type;

77 MOVE_DATA(rhs);

78 return *this;

79}

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

82 type = rhs.type;

83 MOVE_DATA(rhs);

84 return *this;

85}

87any::~any() {

88 switch (type) {

89 case Type::Integer: ; break;

90 case Type::Double: ; break;

91 case Type::Character: ; break;

92 case Type::Boolean: ; break;

93 case Type::StringLiteral: ; break;

94 case Type::String: s.~shared<std::string>(); break;

95 case Type::Map: m.~shared<map>(); break;

96 case Type::Data: v.~shared<data>(); break;

97 case Type::Array: a.~shared<array>(); break;

98 case Type::Function: ; break;

99 case Type::Closure: l.~shared<closure>(); break;

100 case Type::EffFunction: e.~shared<eff_fn>(); break;

101 case Type::Thunk: ; break;

102 case Type::Pointer: p.~shared<void>(); break;

103

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

105 }

106};

107

108#define RETURN_VALUE(TYPE, ACCESSOR, INDIRECTION) \

109 const any& variant = unthunkVariant(*this); \

110 assert(variant.type == TYPE); \

111 return INDIRECTION(variant.ACCESSOR); \

112

113template <typename T>

114auto any::cast() const -> typename std::enable_if<std::is_same<T, long>::value, T>::type {

115 RETURN_VALUE(Type::Integer, i,)

116}

117template auto any::cast<long>() const -> long;

118

119template <typename T>

120auto any::cast() const -> typename std::enable_if<std::is_same<T, double>::value, T>::type {

121 RETURN_VALUE(Type::Double, d,)

122}

123template auto any::cast<double>() const -> double;

124

125template <typename T>

126auto any::cast() const -> typename std::enable_if<std::is_same<T, char>::value, T>::type {

127 RETURN_VALUE(Type::Character, c,)

128}

129template auto any::cast<char>() const -> char;

130

131template <typename T>

132auto any::cast() const -> typename std::enable_if<std::is_same<T, bool>::value, T>::type {

133 RETURN_VALUE(Type::Boolean, b,)

134}

135template auto any::cast<bool>() const -> bool;

136

137template <typename T>

138auto any::cast() const -> typename std::enable_if<std::is_same<T, string>::value, T>::type {

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

140 if (variant.type == Type::StringLiteral) {

141 return variant.r;

142 }

143 assert(variant.type == Type::String);

144 return variant.s->c_str();

145}

146template auto any::cast<string>() const -> string;

147

148template <typename T>

149auto any::cast() const -> typename std::enable_if<std::is_same<T, map>::value, const T&>::type {

150 RETURN_VALUE(Type::Map, m, *)

151}

152template auto any::cast<any::map>() const -> const map&;

153

154template <typename T>

155auto any::cast() const -> typename std::enable_if<std::is_same<T, data>::value, const T&>::type {

156 RETURN_VALUE(Type::Data, v, *)

157}

158template auto any::cast<any::data>() const -> const data&;

159

160template <typename T>

161auto any::cast() const -> typename std::enable_if<std::is_same<T, array>::value, const T&>::type {

162 RETURN_VALUE(Type::Array, a, *)

163}

164template auto any::cast<any::array>() const -> const array&;

165

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

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

168 if (variant.type == Type::Closure) {

169 return (*variant.l)(arg);

170 }

171 assert(variant.type == Type::Function);

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

173}

174

175auto any::operator()(const any& arg1, const any& arg2) const -> any {

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

177 if (variant.type == Type::Closure) {

178 return (*variant.l)(arg1, arg2);

179 }

180 assert(variant.type == Type::Function);

181 return (*variant.f)(arg1)(arg2);

182}

183

184auto any::operator()(const any& arg1, const any& arg2, const any& arg3) const -> any {

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

186 if (variant.type == Type::Closure) {

187 return (*variant.l)(arg1, arg2, arg3);

188 }

189 assert(variant.type == Type::Function);

190 return (*variant.f)(arg1)(arg2)(arg3);

191}

192

193auto any::operator()(const as_thunk) const -> const any& {

194 assert(type == Type::Thunk);

195 return (*t)(unthunk);

196}

197

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

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

200 assert(variant.type == Type::EffFunction);

201 return (*variant.e)();

202}

203

204any::operator long() const {

205 return cast<long>();

206}

207

208any::operator double() const {

209 return cast<double>();

210}

211

212any::operator bool() const {

213 return cast<bool>();

214}

215

216any::operator string() const {

217 return cast<string>();

218}

219

220any::operator const map&() const {

221 return cast<map>();

222}

223

224any::operator const data&() const {

225 return cast<data>();

226}

227

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

229 return cast<array>();

230}

231

232auto any::extractPointer() const -> void* {

233 RETURN_VALUE(Type::Pointer, p.get(),)

234}

235

236auto any::unthunkVariant(const any& a) -> const any& {

237 const any * variant = &a;

238 while (variant->type == Type::Thunk) {

239 variant = &((*variant->t)(unthunk));

240 }

241 return *variant;

242}

243

244auto any::operator[](const char rhs[]) const -> const any& {

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

246 assert(variant.type == Type::Map);

247 const auto begin = variant.m->cbegin();

248 const auto end = variant.m->cend();

249 for (auto it = begin; it != end; ++it) {

250 if (it->first == rhs) {

251 return it->second;

252 }

253 }

254 for (auto it = begin; it != end; ++it) {

255 if (strcmp(it->first, rhs) == 0) {

256 return it->second;

257 }

258 }

259 throw runtime_error("map key not found");

260}

261

262auto any::operator[](const size_t rhs) const -> const any& {

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

264 assert(variant.type == Type::Array);

265 return (*variant.a)[rhs];

266}

267

268auto any::operator[](const any& rhs) const -> const any& {

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

270 assert(variant.type == Type::Array);

271 return (*variant.a)[rhs.cast<long>()];

272}

273

274auto any::contains(const char key[]) const -> bool {

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

276 assert(variant.type == Type::Map);

277 const auto begin = variant.m->cbegin();

278 const auto end = variant.m->cend();

279 for (auto it = begin; it != end; ++it) {

280 if (it->first == key) {

281 return true;

282 }

283 }

284 for (auto it = begin; it != end; ++it) {

285 if (strcmp(it->first, key) == 0) {

286 return true;

287 }

288 }

289 return false;

290}

291

292//-----------------------------------------------------------------------------

293// Operator helper macros

294//-----------------------------------------------------------------------------

295

296#define DEFINE_OPERATOR(op, ty, rty) \

297auto operator op (const any& lhs, ty rhs) -> rty { \

298 return lhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>() op rhs; \

299} \

300auto operator op (ty lhs, const any& rhs) -> rty { \

301 return lhs op rhs.cast<typename std::remove_const<std::remove_reference<ty>::type>::type>(); \

302}

303

304#define DEFINE_CSTR_EQUALS_OPERATOR() \

305 auto operator==(const any& lhs_, const char * rhs) -> bool { \

306 const any& lhs = any::unthunkVariant(lhs_); \

307 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \

308 if (lhs.type == any::Type::StringLiteral) { \

309 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \

310 } \

311 return strcmp(lhs.s->c_str(), rhs) == 0; \

312 } \

313 auto operator==(const char * lhs, const any& rhs_) -> bool { \

314 const any& rhs = any::unthunkVariant(rhs_); \

315 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \

316 if (rhs.type == any::Type::StringLiteral) { \

317 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \

318 } \

319 return strcmp(lhs, rhs.s->c_str()) == 0; \

320 }

321

322#define DEFINE_CSTR_COMPARISON_OPERATOR(op) \

323 auto operator op (const any& lhs, const char * rhs) -> bool { \

324 return strcmp(lhs.cast<string>(), rhs) op 0; \

325 } \

326 auto operator op (const char * lhs, const any& rhs) -> bool { \

327 return strcmp(lhs, rhs.cast<string>()) op 0; \

328 }

329

330#define DEFINE_COMPARISON_OPERATOR(op) \

331 auto operator op (const any& lhs_, const any& rhs_) -> bool { \

332 const any& lhs = any::unthunkVariant(lhs_); \

333 const any& rhs = any::unthunkVariant(rhs_); \

334 switch (lhs.type) { \

335 case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i op rhs.i; \

336 case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d op rhs.d; \

337 case any::Type::Character: assert(lhs.type == any::Type::Character); return lhs.c op rhs.c; \

338 case any::Type::Boolean: assert(lhs.type == any::Type::Boolean); return lhs.b op rhs.b; \

339 case any::Type::StringLiteral: \

340 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \

341 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \

342 return strcmp(lhs.r, rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \

343 case any::Type::String: \

344 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \

345 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \

346 return strcmp(lhs.s->c_str(), rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \

347 case any::Type::Pointer: return lhs.p op rhs.p; \

348 default: assert(false && "Unsupported type for operator " #op); \

349 } \

350 return false; \

351 } \

352 DEFINE_OPERATOR(op, long, bool) \

353 DEFINE_OPERATOR(op, double, bool) \

354 DEFINE_OPERATOR(op, char, bool) \

355 DEFINE_OPERATOR(op, bool, bool) \

356

357//-----------------------------------------------------------------------------

358// Operator definitions

359//-----------------------------------------------------------------------------

360

361DEFINE_COMPARISON_OPERATOR(==)

362DEFINE_COMPARISON_OPERATOR(!=)

363DEFINE_COMPARISON_OPERATOR(<)

364DEFINE_COMPARISON_OPERATOR(<=)

365DEFINE_COMPARISON_OPERATOR(>)

366DEFINE_COMPARISON_OPERATOR(>=)

367

368DEFINE_CSTR_EQUALS_OPERATOR()

369DEFINE_CSTR_COMPARISON_OPERATOR(!=)

370DEFINE_CSTR_COMPARISON_OPERATOR(<)

371DEFINE_CSTR_COMPARISON_OPERATOR(<=)

372DEFINE_CSTR_COMPARISON_OPERATOR(>)

373DEFINE_CSTR_COMPARISON_OPERATOR(>=)

374

375auto operator+(const any& lhs_, const any& rhs_) -> any {

376 const any& lhs = any::unthunkVariant(lhs_);

377 const any& rhs = any::unthunkVariant(rhs_);

378 switch (lhs.type) {

379 case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i + rhs.i;

380 case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d + rhs.d;

381 case any::Type::Character: assert(lhs.type == any::Type::Character); return any(char(lhs.c + rhs.c));

382 case any::Type::StringLiteral:

383 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

384 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);

385 return rhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;

386 case any::Type::String:

387 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

388 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);

389 return rhs.type == any::Type::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;

390 default: assert(false && "Unsupported type for '+' operator");

391 }

392 return nullptr;

393}

394

395DEFINE_OPERATOR(+, long, long)

396DEFINE_OPERATOR(+, double, double)

397DEFINE_OPERATOR(+, char, char)

398

399auto operator+(const any& lhs_, const char * rhs) -> std::string {

400 const any& lhs = any::unthunkVariant(lhs_);

401 assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

402 return lhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;

403}

404

405auto operator+(const char * lhs, const any& rhs_) -> std::string {

406 const any& rhs = any::unthunkVariant(rhs_);

407 assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);

408 return rhs.type == any::Type::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;

409}

410

411auto operator-(const any& lhs_, const any& rhs_) -> any {

412 const any& lhs = any::unthunkVariant(lhs_);

413 const any& rhs = any::unthunkVariant(rhs_);

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

415 switch (lhs.type) {

416 case any::Type::Integer: return lhs.i - rhs.i;

417 case any::Type::Double: return lhs.d - rhs.d;

418 case any::Type::Character: return any(char(lhs.c - rhs.c));

419 default: assert(false && "Unsupported type for '-' operator");

420 }

421 return nullptr;

422}

423

424DEFINE_OPERATOR(-, long, long)

425DEFINE_OPERATOR(-, double, double)

426DEFINE_OPERATOR(-, char, char)

427

428auto operator*(const any& lhs_, const any& rhs_) -> any {

429 const any& lhs = any::unthunkVariant(lhs_);

430 const any& rhs = any::unthunkVariant(rhs_);

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

432 switch (lhs.type) {

433 case any::Type::Integer: return lhs.i * rhs.i;

434 case any::Type::Double: return lhs.d * rhs.d;

435 case any::Type::Character: return any(char(lhs.c * rhs.c));

436 default: assert(false && "Unsupported type for '*' operator");

437 }

438 return nullptr;

439}

440

441DEFINE_OPERATOR(*, long, long)

442DEFINE_OPERATOR(*, double, double)

443DEFINE_OPERATOR(*, char, char)

444

445auto operator/(const any& lhs_, const any& rhs_) -> any {

446 const any& lhs = any::unthunkVariant(lhs_);

447 const any& rhs = any::unthunkVariant(rhs_);

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

449 switch (lhs.type) {

450 case any::Type::Integer: return lhs.i / rhs.i;

451 case any::Type::Double: return lhs.d / rhs.d;

452 case any::Type::Character: return any(char(lhs.c / rhs.c));

453 default: assert(false && "Unsupported type for '/' operator");

454 }

455 return nullptr;

456}

457

458DEFINE_OPERATOR(/, long, long)

459DEFINE_OPERATOR(/, double, double)

460DEFINE_OPERATOR(/, char, char)

461

462auto operator%(const any& lhs_, const any& rhs_) -> any {

463 const any& lhs = any::unthunkVariant(lhs_);

464 const any& rhs = any::unthunkVariant(rhs_);

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

466 switch (lhs.type) {

467 case any::Type::Integer: return lhs.i % rhs.i;

468 case any::Type::Character: return any(char(lhs.c % rhs.c));

469 default: assert(false && "Unsupported type for '%' operator");

470 }

471 return nullptr;

472}

473

474DEFINE_OPERATOR(%, long, long)

475DEFINE_OPERATOR(%, char, char)

476

477// unary negate

478auto operator-(const any& rhs_) -> any {

479 const any& rhs = any::unthunkVariant(rhs_);

480 switch (rhs.type) {

481 case any::Type::Integer: return (- rhs.i);

482 case any::Type::Double: return (- rhs.d);

483 default: assert(false && "Unsupported type for unary '-' operator");

484 }

485 return nullptr;

486}

487

488} // namespace PureScript