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

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

on 45bc08b help sign in

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

481 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::Vector: new (&v) shared<vector>(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::Vector: new (&v) shared<vector>(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::Vector: v.~shared<vector>(); 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, vector>::value, const T&>::type {

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

157}

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

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 vector&() const {

225 return cast<vector>();

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 any::map::const_iterator begin = variant.m->begin();

248 const any::map::const_iterator end = variant.m->end();

249 for (any::map::const_iterator it = begin; it != end; ++it) {

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

251 return it->second;

252 }

253 }

254 for (any::map::const_iterator 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 for (any::map::const_iterator it = variant.m->begin(), end = variant.m->end(); it != end; ++it) {

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

279 return true;

280 }

281 }

282 return false;

283}

284

285//-----------------------------------------------------------------------------

286// Operator helper macros

287//-----------------------------------------------------------------------------

288

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

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

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

292} \

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

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

295}

296

297#define DEFINE_CSTR_EQUALS_OPERATOR() \

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

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

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

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

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

303 } \

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

305 } \

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

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

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

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

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

311 } \

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

313 }

314

315#define DEFINE_CSTR_COMPARISON_OPERATOR(op) \

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

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

318 } \

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

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

321 }

322

323#define DEFINE_COMPARISON_OPERATOR(op) \

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

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

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

327 switch (lhs.type) { \

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

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

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

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

332 case any::Type::StringLiteral: \

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

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

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

336 case any::Type::String: \

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

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

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

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

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

342 } \

343 return false; \

344 } \

345 DEFINE_OPERATOR(op, long, bool) \

346 DEFINE_OPERATOR(op, double, bool) \

347 DEFINE_OPERATOR(op, char, bool) \

348 DEFINE_OPERATOR(op, bool, bool) \

349

350//-----------------------------------------------------------------------------

351// Operator definitions

352//-----------------------------------------------------------------------------

353

354DEFINE_COMPARISON_OPERATOR(==)

355DEFINE_COMPARISON_OPERATOR(!=)

356DEFINE_COMPARISON_OPERATOR(<)

357DEFINE_COMPARISON_OPERATOR(<=)

358DEFINE_COMPARISON_OPERATOR(>)

359DEFINE_COMPARISON_OPERATOR(>=)

360

361DEFINE_CSTR_EQUALS_OPERATOR()

362DEFINE_CSTR_COMPARISON_OPERATOR(!=)

363DEFINE_CSTR_COMPARISON_OPERATOR(<)

364DEFINE_CSTR_COMPARISON_OPERATOR(<=)

365DEFINE_CSTR_COMPARISON_OPERATOR(>)

366DEFINE_CSTR_COMPARISON_OPERATOR(>=)

367

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

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

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

371 switch (lhs.type) {

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

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

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

375 case any::Type::StringLiteral:

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

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

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

379 case any::Type::String:

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

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

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

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

384 }

385 return nullptr;

386}

387

388DEFINE_OPERATOR(+, long, long)

389DEFINE_OPERATOR(+, double, double)

390DEFINE_OPERATOR(+, char, char)

391

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

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

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

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

396}

397

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

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

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

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

402}

403

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

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

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

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

408 switch (lhs.type) {

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

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

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

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

413 }

414 return nullptr;

415}

416

417DEFINE_OPERATOR(-, long, long)

418DEFINE_OPERATOR(-, double, double)

419DEFINE_OPERATOR(-, char, char)

420

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

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

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

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

425 switch (lhs.type) {

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

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

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

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

430 }

431 return nullptr;

432}

433

434DEFINE_OPERATOR(*, long, long)

435DEFINE_OPERATOR(*, double, double)

436DEFINE_OPERATOR(*, char, char)

437

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

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

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

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

442 switch (lhs.type) {

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

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

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

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

447 }

448 return nullptr;

449}

450

451DEFINE_OPERATOR(/, long, long)

452DEFINE_OPERATOR(/, double, double)

453DEFINE_OPERATOR(/, char, char)

454

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

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

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

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

459 switch (lhs.type) {

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

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

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

463 }

464 return nullptr;

465}

466

467DEFINE_OPERATOR(%, long, long)

468DEFINE_OPERATOR(%, char, char)

469

470// unary negate

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

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

473 switch (rhs.type) {

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

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

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

477 }

478 return nullptr;

479}

480

481} // namespace PureScript