e35596a · rowtype-yoga/purescript-native

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

on golang help sign in

Revert "C++: revamp arrays"

e35596aAndy Arvanitis11 years ago

pcc/include/purescript.cc+8−15

compare with golang

unifiedsplit

@@ -27,7 +27,6 @@ namespace PureScript {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -94,7 +92,6 @@ any::~any() {

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

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

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

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

96 case Type::Vector: v.~shared<vector>(); break;

94 case Type::Vector: v.~shared<vector>(); break;

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

98 case Type::Function: ; break;

95 case Type::Function: ; break;

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

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

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

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

@@ -152,10 +149,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&;

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

153

150

154template <typename T>

151template <typename T>

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

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

156− RETURN_VALUE(Type::Array, a, *)

153+ RETURN_VALUE(Type::Vector, v, *)

157}

154}

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

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

159

156

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

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

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

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

@@ -201,10 +198,6 @@ any::operator const vector&() const {

201 return cast<vector>();

198 return cast<vector>();

202}

199}

203

200

204−any::operator const array&() const {

205− return cast<array>();

206−}

207−

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

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

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

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

210}

203}

@@ -235,16 +228,16 @@ auto any::operator[](const char rhs[]) const -> const any& {

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

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

236}

229}

237

230

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

231+auto any::operator[](const vector::size_type rhs) const -> const any& {

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

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

240− assert(variant.type == Type::Array);

233+ assert(variant.type == Type::Vector);

241− return (*variant.a)[rhs];

234+ return (*variant.v)[rhs];

242}

235}

243

236

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

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

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

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

246− assert(variant.type == Type::Array);

239+ assert(variant.type == Type::Vector);

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

240+ return (*variant.v)[rhs.cast<long>()];

248}

241}

249

242

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

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

pcc/include/purescript.hh+4−23

@@ -29,7 +29,6 @@

29#include <functional>

30#include <string>

31#include <vector>

32−#include <deque>

33#include <utility>

32#include <utility>

34#include <stdexcept>

33#include <stdexcept>

@@ -57,7 +56,7 @@ public:

57};

56};

59const bool undefined = false;

58const bool undefined = false;

60−const size_t kDataCtor = 0;

59+const std::vector<int>::size_type kDataCtor = 0;

62// A variant data class designed to provide some features of dynamic typing.

61// A variant data class designed to provide some features of dynamic typing.

63//

62//

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

74 String,

73 String,

75 Map,

74 Map,

76 Vector,

75 Vector,

77− Array,

78 Function,

76 Function,

79 Closure,

77 Closure,

80 EffFunction,

78 EffFunction,

@@ -82,22 +80,17 @@ class any {

82 Pointer

80 Pointer

83 };

81 };

85− private:

86 mutable Type type = Type::Unknown;

83 mutable Type type = Type::Unknown;

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

89− public:

90 struct as_thunk {

85 struct as_thunk {

91 };

86 };

92 static constexpr as_thunk unthunk = as_thunk{};

87 static constexpr as_thunk unthunk = as_thunk{};

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

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

95− using data = vector;

90+ using vector = std::vector<any>;

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

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

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

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

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

100− private:

101 class closure {

94 class closure {

102 public:

95 public:

103 virtual auto operator()(const any&) const -> any = 0;

96 virtual auto operator()(const any&) const -> any = 0;

@@ -128,7 +121,6 @@ class any {

128 }

121 }

129 };

122 };

130

123

131− public:

132 template <typename T>

124 template <typename T>

133 using shared = std::shared_ptr<T>;

125 using shared = std::shared_ptr<T>;

134

126

@@ -147,7 +139,6 @@ class any {

147 mutable shared<std::string> s;

139 mutable shared<std::string> s;

148 mutable shared<map> m;

140 mutable shared<map> m;

149 mutable shared<vector> v;

141 mutable shared<vector> v;

150− mutable shared<array> a;

151 mutable fn f;

142 mutable fn f;

152 mutable shared<closure> l;

143 mutable shared<closure> l;

153 mutable shared<eff_fn> e;

144 mutable shared<eff_fn> e;

@@ -182,9 +173,6 @@ class any {

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

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

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

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

184

175

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

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

187−

188 template <typename T>

176 template <typename T>

189 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0)

177 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0)

190 : type(Type::Function), f(val) {}

178 : type(Type::Function), f(val) {}

@@ -240,14 +228,8 @@ class any {

240 template <typename T>

228 template <typename T>

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

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

242

230

243− // These cannot be thunked

244− template <typename T>

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

246− return *v;

247− }

248−

249 template <typename T>

231 template <typename T>

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

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

251

233

252 template <typename T>

234 template <typename T>

253 auto cast() const -> typename std::enable_if<std::is_assignable<shared<void>,T>::value, typename T::element_type*>::type {

235 auto cast() const -> typename std::enable_if<std::is_assignable<shared<void>,T>::value, typename T::element_type*>::type {

@@ -267,10 +249,9 @@ class any {

267 operator string() const;

249 operator string() const;

268 operator const map&() const;

250 operator const map&() const;

269 operator const vector&() const;

251 operator const vector&() const;

270− operator const array&() const;

271

252

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

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

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

254+ auto operator[](const vector::size_type) const -> const any&;

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

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

275

256

276 auto contains(const char[]) const -> bool;

257 auto contains(const char[]) const -> bool;

src/Language/PureScript/CodeGen/Cpp.hs+4−4

@@ -135,7 +135,7 @@ moduleToCpp env (Module _ mn imps _ foreigns decls) = do

135 CppFunction (identToCpp ident)

136 [] (Just $ CppAny [])

137 [CppInline]

138− (CppBlock [CppReturn (CppDataLiteral [CppStringLiteral (identToCpp ident)])])

138+ (CppBlock [CppReturn (CppArrayLiteral [CppStringLiteral (identToCpp ident)])])

139

140 declToCpp _ ident (Constructor _ _ (ProperName _) fields) = return . CppNamespace [] $

141 [ CppFunction ('$' : identToCpp ident) (farg <$> fields')

@@ -159,7 +159,7 @@ moduleToCpp env (Module _ mn imps _ foreigns decls) = do

159 (Just $ CppAny [])

160 (CppBlock $ fieldLambdas fs')]

161 | otherwise = fullyConstructed

162− fullyConstructed = [CppReturn (CppDataLiteral (CppStringLiteral name : (CppVar <$> fields')))]

162+ fullyConstructed = [CppReturn (CppArrayLiteral (CppStringLiteral name : (CppVar <$> fields')))]

163

164 declToCpp _ ident val = do

165 val' <- valueToCpp val

@@ -421,7 +421,7 @@ moduleToCpp env (Module _ mn imps _ foreigns decls) = do

421 return $ case ctorType of

422 ProductType -> cpps

423 SumType ->

424− [ CppIfElse (CppBinary Equal (CppIndexer (CppVar ctorKey) (CppCast dataType $ CppVar varName))

424+ [ CppIfElse (CppBinary Equal (CppIndexer (CppVar ctorKey) (CppVar varName))

425 (CppStringLiteral ctor))

426 (CppBlock cpps)

427 Nothing ]

@@ -434,7 +434,7 @@ moduleToCpp env (Module _ mn imps _ foreigns decls) = do

434 cpps <- binderToCpp argVar done'' binder

435 return (CppVariableIntroduction (argVar, Nothing)

436 []

437− (Just (CppIndexer (fieldToIndex field) (CppCast dataType $ CppVar varName)))

437+ (Just (CppIndexer (fieldToIndex field) (CppVar varName)))

438 : cpps)

439 fieldToIndex :: Ident -> Cpp

440 fieldToIndex = CppNumericLiteral . Left . (+1) . read . dropWhile isLetter . runIdent

src/Language/PureScript/CodeGen/Cpp/AST.hs−7

@@ -170,10 +170,6 @@ data Cpp

170 --

171 | CppArrayLiteral [Cpp]

172 -- |

173− -- A data literal

174− --

175− | CppDataLiteral [Cpp]

176− -- |

177 -- An array indexer expression

173 -- An array indexer expression

178 --

174 --

179 | CppIndexer Cpp Cpp

175 | CppIndexer Cpp Cpp

@@ -286,7 +282,6 @@ everywhereOnCpp f = go

286 go (CppUnary op j) = f (CppUnary op (go j))

282 go (CppUnary op j) = f (CppUnary op (go j))

287 go (CppBinary op j1 j2) = f (CppBinary op (go j1) (go j2))

283 go (CppBinary op j1 j2) = f (CppBinary op (go j1) (go j2))

288 go (CppArrayLiteral cpp) = f (CppArrayLiteral (map go cpp))

284 go (CppArrayLiteral cpp) = f (CppArrayLiteral (map go cpp))

289− go (CppDataLiteral cpp) = f (CppDataLiteral (map go cpp))

290 go (CppIndexer j1 j2) = f (CppIndexer (go j1) (go j2))

285 go (CppIndexer j1 j2) = f (CppIndexer (go j1) (go j2))

291 go (CppObjectLiteral cpp) = f (CppObjectLiteral (map (fmap go) cpp))

286 go (CppObjectLiteral cpp) = f (CppObjectLiteral (map (fmap go) cpp))

292 go (CppAccessor prop j) = f (CppAccessor (go prop) (go j))

287 go (CppAccessor prop j) = f (CppAccessor (go prop) (go j))

@@ -316,7 +311,6 @@ everywhereOnCppTopDownM f = f >=> go

316 go (CppUnary op j) = CppUnary op <$> f' j

311 go (CppUnary op j) = CppUnary op <$> f' j

317 go (CppBinary op j1 j2) = CppBinary op <$> f' j1 <*> f' j2

312 go (CppBinary op j1 j2) = CppBinary op <$> f' j1 <*> f' j2

318 go (CppArrayLiteral cpp) = CppArrayLiteral <$> traverse f' cpp

313 go (CppArrayLiteral cpp) = CppArrayLiteral <$> traverse f' cpp

319− go (CppDataLiteral cpp) = CppDataLiteral <$> traverse f' cpp

320 go (CppIndexer j1 j2) = CppIndexer <$> f' j1 <*> f' j2

314 go (CppIndexer j1 j2) = CppIndexer <$> f' j1 <*> f' j2

321 go (CppObjectLiteral cpp) = CppObjectLiteral <$> traverse (sndM f') cpp

315 go (CppObjectLiteral cpp) = CppObjectLiteral <$> traverse (sndM f') cpp

322 go (CppAccessor prop j) = CppAccessor prop <$> f' j

316 go (CppAccessor prop j) = CppAccessor prop <$> f' j

@@ -342,7 +336,6 @@ everythingOnCpp (<>) f = go

342 go j@(CppUnary _ j1) = f j <> go j1

336 go j@(CppUnary _ j1) = f j <> go j1

343 go j@(CppBinary _ j1 j2) = f j <> go j1 <> go j2

337 go j@(CppBinary _ j1 j2) = f j <> go j1 <> go j2

344 go j@(CppArrayLiteral cpp) = foldl (<>) (f j) (map go cpp)

338 go j@(CppArrayLiteral cpp) = foldl (<>) (f j) (map go cpp)

345− go j@(CppDataLiteral cpp) = foldl (<>) (f j) (map go cpp)

346 go j@(CppIndexer j1 j2) = f j <> go j1 <> go j2

339 go j@(CppIndexer j1 j2) = f j <> go j1 <> go j2

347 go j@(CppObjectLiteral cpp) = foldl (<>) (f j) (map (go . snd) cpp)

340 go j@(CppObjectLiteral cpp) = foldl (<>) (f j) (map (go . snd) cpp)

348 go j@(CppAccessor j1 j2) = f j <> go j1 <> go j2

341 go j@(CppAccessor j1 j2) = f j <> go j1 <> go j2

src/Language/PureScript/CodeGen/Cpp/Optimizer/Inliner.hs−1

@@ -48,7 +48,6 @@ shouldInline (CppStringLiteral _) = True

48shouldInline (CppBooleanLiteral _) = True

49shouldInline (CppAccessor _ val) = shouldInline val

50shouldInline (CppIndexer index val) = shouldInline index && shouldInline val

51−shouldInline (CppCast _ val) = shouldInline val

52shouldInline _ = False

51shouldInline _ = False

54etaConvert :: Cpp -> Cpp

53etaConvert :: Cpp -> Cpp

src/Language/PureScript/CodeGen/Cpp/Types.hs+1−4

@@ -108,11 +108,8 @@ charType = CppPrimitive "char"

108mapType :: CppType

109mapType = CppPrimitive "any::map"

110

111−dataType :: CppType

112−dataType = CppPrimitive "any::data"

113−

114arrayType :: CppType

111arrayType :: CppType

115−arrayType = CppPrimitive "any::array"

112+arrayType = CppPrimitive "any::vector"

116

113

117thunkMarkerType :: CppType

114thunkMarkerType :: CppType

118thunkMarkerType = CppPrimitive "any::as_thunk"

115thunkMarkerType = CppPrimitive "any::as_thunk"

src/Language/PureScript/Pretty/Cpp.hs−6

@@ -71,12 +71,6 @@ literals = mkPattern' match

71 , fmap (intercalate ", ") $ forM xs prettyPrintCpp'

72 , return " }"

73 ]

74− match (CppDataLiteral xs) = fmap concat $ sequence

75− [ return $ runType dataType

76− , return "{ "

77− , fmap (intercalate ", ") $ forM xs prettyPrintCpp'

78− , return " }"

79− ]

80 match (CppObjectLiteral ps) = fmap concat $ sequence

74 match (CppObjectLiteral ps) = fmap concat $ sequence

81 [ return $ runType mapType ++ "{\n"

75 [ return $ runType mapType ++ "{\n"

82 , withIndent $ do

76 , withIndent $ do