Make TEnv an actual lexical environment (not used yet).

Proper parsing of boolean literals "true" and "false".


git-svn-id: http://svn.drobilla.net/resp/tuplr@46 ad02d1e2-f140-0410-9f75-f8b11f17cedd

1 files changed, 17 insertions, 23 deletions

diff --git a/tuplr.cpp b/tuplr.cpp
index f5db2ce..b93918b 100644
--- a/tuplr.cpp
+++ b/tuplr.cpp
@@ -408,6 +408,10 @@ parseExpression(PEnv& penv, const SExp& exp)
 			return new ASTLiteral<int32_t>(strtol(exp.atom.c_str(), NULL, 10));
 		else
 			return new ASTLiteral<float>(strtod(exp.atom.c_str(), NULL));
+	} else if (exp.atom == "true") {
+		return new ASTLiteral<bool>(true);
+	} else if (exp.atom == "false") {
+		return new ASTLiteral<bool>(false);
 	}
 	return penv.sym(exp.atom);
 }
@@ -456,7 +460,8 @@ template<typename K, typename V>
 struct Env : public list< map<K,V> > {
 	typedef map<K,V> Frame;
 	Env() : list<Frame>(1) {}
-	void push_front() { list<Frame>::push_front(Frame()); }
+	void push() { list<Frame>::push_front(Frame()); }
+	void pop()  { list<Frame>::pop_front(); }
 	const V& def(const K& k, const V& v) {
 		typename Frame::iterator existing = this->front().find(k);
 		if (existing != this->front().end() && existing->second != v)
@@ -482,23 +487,16 @@ struct TSubst : public map<AType*, AType*> {
 };
 
 /// Type-Time Environment
-struct TEnv {
+struct TEnv : public Env<const AST*,AType*> {
 	TEnv(PEnv& p) : penv(p), varID(1) {}
-	typedef map<const AST*, AType*>  Types;
 	typedef list< pair<AType*, AType*> > Constraints;
 	AType* var() { return new AType(varID++); }
 	AType* type(const AST* ast) {
-		Types::iterator t = types.find(ast);
-		return (t != types.end()) ? t->second : (types[ast] = var());
+		AType** t = ref(ast);
+		return t ? *t : def(ast, var());
 	}
-	AType* named(const string& name) const {
-		Types::const_iterator i = namedTypes.find(penv.sym(name));
-		if (i == namedTypes.end()) throw Error("Unknown named type");
-		return i->second;
-	}
-	void name(const string& name, const Type* type) {
-		ASTSymbol* sym = penv.sym(name);
-		namedTypes[sym] = new AType(penv.sym(name), type);
+	AType* named(const string& name) {
+		return *ref(penv.sym(name));
 	}
 	void constrain(const AST* o, AType* t) {
 		assert(!dynamic_cast<const AType*>(o));
@@ -508,8 +506,6 @@ struct TEnv {
 	void          apply(const TSubst& substs);
 	static TSubst unify(const Constraints& c);
 	PEnv&       penv;
-	Types       types;
-	Types       namedTypes;
 	Constraints constraints;
 	unsigned    varID;
 };
@@ -711,7 +707,7 @@ void
 TEnv::apply(const TSubst& substs)
 {
 	FOREACH(TSubst::const_iterator, s, substs)
-		FOREACH(Types::iterator, t, types)
+		FOREACH(Frame::iterator, t, front())
 			if (*t->second == *s->first)
 				t->second = s->second;
 			else
@@ -738,8 +734,8 @@ struct CEnv {
 		opt.add(createCFGSimplificationPass()); // Simplify control flow
 	}
 	string gensym(const char* s="_") { return (format("%1%%2%") % s % symID++).str(); }
-	void push() { code.push_front(); vals.push_front(); }
-	void pop()  { code.pop_front();  vals.pop_front(); }
+	void push() { code.push(); vals.push(); }
+	void pop()  { code.pop();  vals.pop(); }
 	Value* compile(AST* obj) {
 		Value** v = vals.ref(obj);
 		return (v) ? *v : vals.def(obj, obj->compile(*this));
@@ -1252,11 +1248,9 @@ main(int argc, char** argv)
 	ExecutionEngine* engine = ExecutionEngine::create(module);
 	CEnv             cenv(penv, module, engine->getTargetData());
 
-	cenv.tenv.name("Bool",  Type::Int1Ty);
-	cenv.tenv.name("Int",   Type::Int32Ty);
-	cenv.tenv.name("Float", Type::FloatTy);
-	cenv.code.def(penv.sym("true"),  new ASTLiteral<bool>(true));
-	cenv.code.def(penv.sym("false"), new ASTLiteral<bool>(false));
+	cenv.tenv.def(penv.sym("Bool"),  new AType(penv.sym("Bool"),  Type::Int1Ty));
+	cenv.tenv.def(penv.sym("Int"),   new AType(penv.sym("Int"),   Type::Int32Ty));
+	cenv.tenv.def(penv.sym("Float"), new AType(penv.sym("Float"), Type::FloatTy));
 	
 	// Host provided allocation primitive prototypes
 	std::vector<const Type*> argsT(1, Type::Int32Ty);