d3bc249 · rowtype-yoga/purescript-native

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

on golang help sign in

Merge remote-tracking branch 'pure11/pure11' into native

d3bc249Andy Arvanitis10 years ago

pcc/runtime/purescript.cc+3−2

compare with golang

unifiedsplit

@@ -119,7 +119,8 @@ auto any::empty() const -> bool {

119

120auto any::contains(const Private::Symbol key) const -> bool {

121 // TODO: assumes at least one element -- safe assumption?

122− const auto& m = cast<dict<unknown_size>>(*this);

122+ const auto& m =

123+ *static_cast<const any::dict<unknown_size>*>(this->extractPointer(IF_DEBUG(any::Tag::Dictionary)));

123 std::remove_reference<decltype(m)>::type::size_type i = 0;

124 std::remove_reference<decltype(m)>::type::size_type i = 0;

124 do {

125 do {

125 if (m[i].first == key) {

126 if (m[i].first == key) {

@@ -151,7 +152,7 @@ auto any::at(const char * key) const -> const any& {

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

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

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

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

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

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

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

155+ case any::Tag::RawPointer: return lhs.v op static_cast<decltype(any::v)>(rhs); \

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

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

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

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

157 } \

158 } \

pcc/runtime/purescript.hh+19−69

@@ -44,7 +44,7 @@

45namespace PureScript {

47−using cstring = const char *;

47+using cstring = const char *; // TODO: deprecated

48using std::string;

49using std::nullptr_t;

50using std::runtime_error;

@@ -193,6 +193,9 @@ class any {

193 assert(val >= std::numeric_limits<decltype(i)>::min() &&

194 val <= std::numeric_limits<decltype(i)>::max());

195 }

196+ any(const size_t val) noexcept : tag(Tag::Integer), i(static_cast<decltype(i)>(val)) {

197+ assert(val <= std::numeric_limits<decltype(i)>::max());

198+ }

196 any(const double val) noexcept : tag(Tag::Double), d(val) {}

199 any(const double val) noexcept : tag(Tag::Double), d(val) {}

197 any(const char32_t val) noexcept : tag(Tag::Character), c(val) {}

200 any(const char32_t val) noexcept : tag(Tag::Character), c(val) {}

198 any(const char val) noexcept : tag(Tag::Character), c(val) {}

201 any(const char val) noexcept : tag(Tag::Character), c(val) {}

@@ -333,14 +336,14 @@ class any {

333 operator const record&() const;

336 operator const record&() const;

334

337

335 operator void *() const {

338 operator void *() const {

336− return extractPointer(IF_DEBUG(Tag::RawPointer));

339+ return rawPointer();

337 }

340 }

338

341

339 template <typename T,

342 template <typename T,

340 typename = typename std::enable_if<std::is_pointer<T>::value &&

343 typename = typename std::enable_if<std::is_pointer<T>::value &&

341 std::is_class<typename std::remove_pointer<T>::type>::value>::type>

344 std::is_class<typename std::remove_pointer<T>::type>::value>::type>

342 operator T() const {

345 operator T() const {

343− return static_cast<T>(extractPointer(IF_DEBUG(Tag::RawPointer)));

346+ return static_cast<T>(rawPointer());

344 }

347 }

345

348

346 auto operator[](const size_t) const -> const any&;

349 auto operator[](const size_t) const -> const any&;

@@ -419,77 +422,24 @@ class any {

419

422

420}; // class any

423}; // class any

421

424

422−namespace Private {

423− template <typename T, typename U=void>

424− struct TagHelper {};

425−

426− template <>

427− struct TagHelper<string> {

428− static constexpr any::Tag tag = any::Tag::String;

429− };

430−

431− template <>

432− struct TagHelper<const char *> {

433− static constexpr any::Tag tag = any::Tag::String;

434− };

435−

436− template <size_t N>

437− struct TagHelper<any::dict<N>> {

438− static constexpr any::Tag tag = any::Tag::Dictionary;

439− };

440−

441− template <size_t N>

442− struct TagHelper<any::data<N>> {

443− static constexpr any::Tag tag = any::Tag::Data;

444− };

445−

446− template <>

447− struct TagHelper<any::array> {

448− static constexpr any::Tag tag = any::Tag::Array;

449− };

450−

451− template <>

452− struct TagHelper<any::record> {

453− static constexpr any::Tag tag = any::Tag::Record;

454− };

455−

456− template <typename T>

457− struct TagHelper<T> {

458− static constexpr any::Tag tag = any::Tag::Pointer;

459− };

460−}

461−

462−// Pass-through

463−template <typename T>

464−constexpr auto cast(const T& a) -> const T& {

465− return a;

466−}

467−

468−template <typename T>

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

470− typename std::enable_if<std::is_arithmetic<T>::value ||

471− std::is_same<T,const char *>::value, T>::type {

472− return a;

473−}

474−

475template <typename T,

425template <typename T,

476 typename = typename std::enable_if<std::is_class<T>::value>::type>

426 typename = typename std::enable_if<std::is_class<T>::value>::type>

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

427+inline auto cast_managed(const any& a) -> T& {

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

428+ return *static_cast<T*>(a.extractPointer(IF_DEBUG(any::Tag::Pointer)));

479}

429}

480

430

431+// TODO: Deprecated - use static_cast

481template <typename T,

432template <typename T,

482− typename = typename std::enable_if<std::is_pointer<T>::value &&

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

483− !std::is_same<T,void*>::value &&

484− !std::is_same<T,const char *>::value>::type>

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

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

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

435+ return static_cast<T>(a);

487}

436}

488

437

438+// TODO: Deprecated - use cast_managed

489−template <typename T>

439+template <typename T,

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

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

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

491− typename std::enable_if<std::is_same<void*, T>::value, T>::type {

442+ return cast_managed<T>(a);

492− return a.rawPointer();

493}

443}

494

444

495namespace dict {

445namespace dict {

@@ -501,7 +451,7 @@ namespace dict {

501

451

502 template <size_t N>

452 template <size_t N>

503 inline auto get(const any& a) -> const any& {

453 inline auto get(const any& a) -> const any& {

504− return cast<any::dict<N+1>>(a)[N].second;

454+ return (*static_cast<const any::dict<N+1>*>(a.extractPointer(IF_DEBUG(any::Tag::Dictionary))))[N].second;

505 }

455 }

506

456

507 template <size_t N>

457 template <size_t N>

@@ -519,7 +469,7 @@ namespace dict {

519 }

469 }

520

470

521 inline auto get(const Private::Symbol key, const any& a) -> const any& {

471 inline auto get(const Private::Symbol key, const any& a) -> const any& {

522− return get(key, cast<any::dict<unknown_size>>(a));

472+ return get(key, *static_cast<const any::dict<unknown_size>*>(a.extractPointer(IF_DEBUG(any::Tag::Dictionary))));

523 }

473 }

524

474

525 #define P(N) any::dict_pair&& arg ## N

475 #define P(N) any::dict_pair&& arg ## N

@@ -567,7 +517,7 @@ namespace data {

567

517

568 template <size_t N>

518 template <size_t N>

569 inline auto get(const any& a) -> const any& {

519 inline auto get(const any& a) -> const any& {

570− return cast<any::data<N+1>>(a)[N];

520+ return (*static_cast<const any::data<N+1>*>(a.extractPointer(IF_DEBUG(any::Tag::Data))))[N];

571 }

521 }

572

522

573 template <typename T>

523 template <typename T>

src/Language/PureScript/Pretty/Cpp.hs+1−1

@@ -268,7 +268,7 @@ literals = mkPattern' match

268 CppNumericLiteral {} -> vstr

269 CppStringLiteral {} -> vstr

270 CppBooleanLiteral {} -> vstr

271− _ -> "cast" <> angles (runType typ) <> parensT val'

271+ _ -> "static_cast" <> angles (runType typ) <> parensT val'

272 where

273 vstr = prettyPrintCpp1 val

274 val' | "(" `T.isInfixOf` vstr || "[" `T.isInfixOf` vstr = parensT vstr