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

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

on e655652 help sign in

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

400 lines 14 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 RETURN_VALUE(TYPE, ACCESSOR, INDIRECTION) \

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

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

23 return INDIRECTION(variant.ACCESSOR); \

25template <typename T>

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

27 RETURN_VALUE(Type::Integer, i,)

28}

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

31template <typename T>

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

33 RETURN_VALUE(Type::Double, d,)

34}

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

37template <typename T>

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

39 RETURN_VALUE(Type::Character, c,)

40}

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

43template <typename T>

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

45 RETURN_VALUE(Type::Boolean, b,)

46}

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

49template <typename T>

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

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

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

53 return variant.r;

54 }

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

56 return variant.s->c_str();

57}

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

60template <typename T>

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

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

63}

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

66template <typename T>

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

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

69}

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

72template <typename T>

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

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

75}

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

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

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

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

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

82 }

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

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

85}

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

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

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

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

91 }

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

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

94}

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

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

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

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

100 }

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

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

103}

104

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

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

107 return (*t)(unthunk);

108}

109

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

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

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

113 return (*variant.e)();

114}

115

116any::operator long() const {

117 return cast<long>();

118}

119

120any::operator double() const {

121 return cast<double>();

122}

123

124any::operator bool() const {

125 return cast<bool>();

126}

127

128any::operator string() const {

129 return cast<string>();

130}

131

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

133 return cast<map>();

134}

135

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

137 return cast<data>();

138}

139

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

141 return cast<array>();

142}

143

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

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

146}

147

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

149 const any * variant = &a;

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

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

152 }

153 return *variant;

154}

155

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

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

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

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

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

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

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

163 return it->second;

164 }

165 }

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

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

168 return it->second;

169 }

170 }

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

172}

173

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

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

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

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

178}

179

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

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

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

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

184}

185

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

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

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

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

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

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

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

193 return true;

194 }

195 }

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

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

198 return true;

199 }

200 }

201 return false;

202}

203

204//-----------------------------------------------------------------------------

205// Operator helper macros

206//-----------------------------------------------------------------------------

207

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

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

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

211} \

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

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

214}

215

216#define DEFINE_CSTR_EQUALS_OPERATOR() \

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

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

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

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

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

222 } \

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

224 } \

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

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

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

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

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

230 } \

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

232 }

233

234#define DEFINE_CSTR_COMPARISON_OPERATOR(op) \

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

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

237 } \

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

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

240 }

241

242#define DEFINE_COMPARISON_OPERATOR(op) \

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

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

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

246 switch (lhs.type) { \

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

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

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

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

251 case any::Type::StringLiteral: \

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

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

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

255 case any::Type::String: \

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

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

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

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

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

261 } \

262 return false; \

263 } \

264 DEFINE_OPERATOR(op, long, bool) \

265 DEFINE_OPERATOR(op, double, bool) \

266 DEFINE_OPERATOR(op, char, bool) \

267 DEFINE_OPERATOR(op, bool, bool) \

268

269//-----------------------------------------------------------------------------

270// Operator definitions

271//-----------------------------------------------------------------------------

272

273DEFINE_COMPARISON_OPERATOR(==)

274DEFINE_COMPARISON_OPERATOR(!=)

275DEFINE_COMPARISON_OPERATOR(<)

276DEFINE_COMPARISON_OPERATOR(<=)

277DEFINE_COMPARISON_OPERATOR(>)

278DEFINE_COMPARISON_OPERATOR(>=)

279

280DEFINE_CSTR_EQUALS_OPERATOR()

281DEFINE_CSTR_COMPARISON_OPERATOR(!=)

282DEFINE_CSTR_COMPARISON_OPERATOR(<)

283DEFINE_CSTR_COMPARISON_OPERATOR(<=)

284DEFINE_CSTR_COMPARISON_OPERATOR(>)

285DEFINE_CSTR_COMPARISON_OPERATOR(>=)

286

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

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

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

290 switch (lhs.type) {

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

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

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

294 case any::Type::StringLiteral:

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

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

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

298 case any::Type::String:

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

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

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

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

303 }

304 return nullptr;

305}

306

307DEFINE_OPERATOR(+, long, long)

308DEFINE_OPERATOR(+, double, double)

309DEFINE_OPERATOR(+, char, char)

310

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

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

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

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

315}

316

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

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

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

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

321}

322

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

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

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

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

327 switch (lhs.type) {

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

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

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

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

332 }

333 return nullptr;

334}

335

336DEFINE_OPERATOR(-, long, long)

337DEFINE_OPERATOR(-, double, double)

338DEFINE_OPERATOR(-, char, char)

339

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

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

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

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

344 switch (lhs.type) {

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

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

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

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

349 }

350 return nullptr;

351}

352

353DEFINE_OPERATOR(*, long, long)

354DEFINE_OPERATOR(*, double, double)

355DEFINE_OPERATOR(*, char, char)

356

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

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

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

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

361 switch (lhs.type) {

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

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

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

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

366 }

367 return nullptr;

368}

369

370DEFINE_OPERATOR(/, long, long)

371DEFINE_OPERATOR(/, double, double)

372DEFINE_OPERATOR(/, char, char)

373

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

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

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

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

378 switch (lhs.type) {

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

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

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

382 }

383 return nullptr;

384}

385

386DEFINE_OPERATOR(%, long, long)

387DEFINE_OPERATOR(%, char, char)

388

389// unary negate

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

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

392 switch (rhs.type) {

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

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

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

396 }

397 return nullptr;

398}

399

400} // namespace PureScript