be026ab · rowtype-yoga/purescript-native

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

on golang help sign in

C++: use 'data' type alias in more places (in runtime)

be026abAndy Arvanitis11 years ago

pcc/include/purescript.cc+8−8

compare with golang

unifiedsplit

@@ -26,7 +26,7 @@ namespace PureScript {

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; \

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; \

@@ -46,7 +46,7 @@ namespace PureScript {

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; \

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; \

@@ -93,7 +93,7 @@ any::~any() {

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;

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;

@@ -152,10 +152,10 @@ auto any::cast() const -> typename std::enable_if<std::is_same<T, map>::value, c

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

153

154template <typename T>

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

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

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

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

157}

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

158+template 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 {

@@ -221,8 +221,8 @@ any::operator const map&() const {

221 return cast<map>();

222}

223

224−any::operator const vector&() const {

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

225− return cast<vector>();

225+ return cast<data>();

226}

227

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

pcc/include/purescript.hh+7−8

@@ -73,7 +73,7 @@ class any {

73 StringLiteral,

74 String,

75 Map,

76− Vector,

76+ Data,

77 Array,

78 Function,

79 Closure,

@@ -84,7 +84,6 @@ class any {

85 private:

86 mutable Type type = Type::Unknown;

87− using vector = std::vector<any>;

89 public:

88 public:

90 struct as_thunk {

89 struct as_thunk {

@@ -92,7 +91,7 @@ class any {

92 static constexpr as_thunk unthunk = as_thunk{};

91 static constexpr as_thunk unthunk = as_thunk{};

94 using map = std::vector<std::pair<const char * const, const any>>;

93 using map = std::vector<std::pair<const char * const, const any>>;

95− using data = vector;

94+ using data = std::vector<any>;

96 using array = std::deque<any>;

95 using array = std::deque<any>;

97 using fn = auto (*)(const any&) -> any;

96 using fn = auto (*)(const any&) -> any;

98 using thunk = auto (*)(const as_thunk) -> const any&;

97 using thunk = auto (*)(const as_thunk) -> const any&;

@@ -194,7 +193,7 @@ class any {

194 mutable string r;

193 mutable string r;

195 mutable shared<std::string> s;

194 mutable shared<std::string> s;

196 mutable shared<map> m;

195 mutable shared<map> m;

197− mutable shared<vector> v;

196+ mutable shared<data> v;

198 mutable shared<array> a;

197 mutable shared<array> a;

199 mutable fn f;

198 mutable fn f;

200 mutable shared<closure> l;

199 mutable shared<closure> l;

@@ -227,8 +226,8 @@ class any {

227 any(const map& val) : type(Type::Map), m(make_shared<map>(val)) {}

226 any(const map& val) : type(Type::Map), m(make_shared<map>(val)) {}

228 any(map&& val) noexcept : type(Type::Map), m(make_shared<map>(std::move(val))) {}

227 any(map&& val) noexcept : type(Type::Map), m(make_shared<map>(std::move(val))) {}

229

228

230− any(const vector& val) : type(Type::Vector), v(make_shared<vector>(val)) {}

229+ any(const data& val) : type(Type::Data), v(make_shared<data>(val)) {}

231− any(vector&& val) noexcept : type(Type::Vector), v(make_shared<vector>(std::move(val))) {}

230+ any(data&& val) noexcept : type(Type::Data), v(make_shared<data>(std::move(val))) {}

232

231

233 any(const array& val) : type(Type::Array), a(make_shared<array>(val)) {}

232 any(const array& val) : type(Type::Array), a(make_shared<array>(val)) {}

234 any(array&& val) noexcept : type(Type::Array), a(make_shared<array>(std::move(val))) {}

233 any(array&& val) noexcept : type(Type::Array), a(make_shared<array>(std::move(val))) {}

@@ -302,7 +301,7 @@ class any {

302 auto cast() const -> typename std::enable_if<std::is_same<T, map>::value, const T&>::type;

301 auto cast() const -> typename std::enable_if<std::is_same<T, map>::value, const T&>::type;

303

302

304 template <typename T>

303 template <typename T>

305− auto cast() const -> typename std::enable_if<std::is_same<T, vector>::value, const T&>::type;

304+ auto cast() const -> typename std::enable_if<std::is_same<T, data>::value, const T&>::type;

306

305

307 template <typename T>

306 template <typename T>

308 auto cast() const -> typename std::enable_if<std::is_same<T, array>::value, const T&>::type;

307 auto cast() const -> typename std::enable_if<std::is_same<T, array>::value, const T&>::type;

@@ -326,7 +325,7 @@ class any {

326

325

327 operator string() const;

326 operator string() const;

328 operator const map&() const;

327 operator const map&() const;

329− operator const vector&() const;

328+ operator const data&() const;

330 operator const array&() const;

329 operator const array&() const;

331

330

332 auto operator[](const char[]) const -> const any&;

331 auto operator[](const char[]) const -> const any&;