From ced439fb6918e8848882d0e3a65f11b72da92425 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 20 Jun 2009 18:16:00 +0000 Subject: Move eval and repl to tuplr.cpp (non-backend dependent code). git-svn-id: http://svn.drobilla.net/resp/tuplr@133 ad02d1e2-f140-0410-9f75-f8b11f17cedd --- llvm.cpp | 119 +----------------------------------------------------------- tuplr.cpp | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- tuplr.hpp | 8 +++++ 3 files changed, 129 insertions(+), 119 deletions(-) diff --git a/llvm.cpp b/llvm.cpp index f472893..dbe647b 100644 --- a/llvm.cpp +++ b/llvm.cpp @@ -139,7 +139,7 @@ LITERAL(bool, "Bool", ConstantInt::get(Type::Int1Ty, val, false)) CFunction startFunction(CEnv& cenv, const std::string& name, const AType* retT, const ATuple& argsT, - const vector argNames=vector()) + const vector argNames) { Function::LinkageTypes linkage = Function::ExternalLinkage; @@ -522,123 +522,6 @@ call(CEnv& cenv, CFunction f, AType* retT) return ss.str(); } -int -eval(CEnv& cenv, const string& name, istream& is) -{ - AST* result = NULL; - AType* resultType = NULL; - list< pair > exprs; - Cursor cursor(name); - try { - while (true) { - SExp exp = readExpression(cursor, is); - if (exp.type == SExp::LIST && exp.empty()) - break; - - result = cenv.penv.parse(exp); // Parse input - Constraints c; - result->constrain(cenv.tenv, c); // Constrain types - cenv.tsubst = Subst::compose(cenv.tsubst, TEnv::unify(c)); // Solve type constraints - resultType = cenv.type(result); - result->lift(cenv); // Lift functions - exprs.push_back(make_pair(exp, result)); - - // Add definitions as GC roots - if (result->to()) - cenv.lock(result); - - // Add types in type substition as GC roots - for (Subst::iterator i = cenv.tsubst.begin(); i != cenv.tsubst.end(); ++i) { - Object::pool.addRoot(i->first); - Object::pool.addRoot(i->second); - } - } - - THROW_IF(!llType(resultType), cursor, "body has non-compilable type") - - // Create function for top-level of program - CFunction f = startFunction(cenv, "main", resultType, ATuple(cursor)); - - // Compile all expressions into it - CValue val = NULL; - for (list< pair >::const_iterator i = exprs.begin(); i != exprs.end(); ++i) - val = cenv.compile(i->second); - - finishFunction(cenv, f, val); - - cenv.out << call(cenv, f, resultType) << " : " << resultType << endl; - - Object::pool.collect(Object::pool.roots()); - - if (cenv.args.find("-d") != cenv.args.end()) - cenv.write(cenv.out); - - } catch (Error& e) { - cenv.err << e.what() << endl; - return 1; - } - return 0; -} - -int -repl(CEnv& cenv) -{ - while (1) { - cenv.out << "() "; - cenv.out.flush(); - Cursor cursor("(stdin)"); - - try { - SExp exp = readExpression(cursor, std::cin); - if (exp.type == SExp::LIST && exp.empty()) - break; - - AST* body = cenv.penv.parse(exp); // Parse input - Constraints c; - body->constrain(cenv.tenv, c); // Constrain types - - Subst oldSubst = cenv.tsubst; - cenv.tsubst = Subst::compose(cenv.tsubst, TEnv::unify(c)); // Solve type constraints - - AType* bodyT = cenv.type(body); - THROW_IF(!bodyT, cursor, "call to untyped body") - - body->lift(cenv); - - CFunction f = NULL; - try { - // Create anonymous function to insert code into - f = startFunction(cenv, cenv.gensym("_repl"), bodyT, ATuple(cursor)); - CValue retVal = cenv.compile(body); - finishFunction(cenv, f, retVal); - cenv.out << call(cenv, f, bodyT); - } catch (Error& e) { - ADefinition* def = body->to(); - if (def) - cenv.out << def->sym(); - else - cenv.out << "?"; - eraseFunction(cenv, f); - } - cenv.out << " : " << cenv.type(body) << endl; - - // Add definitions as GC roots - if (body->to()) - cenv.lock(body); - - Object::pool.collect(Object::pool.roots()); - - cenv.tsubst = oldSubst; - if (cenv.args.find("-d") != cenv.args.end()) - cenv.write(cenv.out); - - } catch (Error& e) { - cenv.err << e.what() << endl; - } - } - return 0; -} - CEnv* newCenv(PEnv& penv, TEnv& tenv) { diff --git a/tuplr.cpp b/tuplr.cpp index ae9caf7..de7d8a1 100644 --- a/tuplr.cpp +++ b/tuplr.cpp @@ -226,9 +226,128 @@ initLang(PEnv& penv, TEnv& tenv) } +/*************************************************************************** + * EVAL/REPL * + ***************************************************************************/ + +int +eval(CEnv& cenv, const string& name, istream& is) +{ + AST* result = NULL; + AType* resultType = NULL; + list< pair > exprs; + Cursor cursor(name); + try { + while (true) { + SExp exp = readExpression(cursor, is); + if (exp.type == SExp::LIST && exp.empty()) + break; + + result = cenv.penv.parse(exp); // Parse input + Constraints c; + result->constrain(cenv.tenv, c); // Constrain types + cenv.tsubst = Subst::compose(cenv.tsubst, TEnv::unify(c)); // Solve type constraints + resultType = cenv.type(result); + result->lift(cenv); // Lift functions + exprs.push_back(make_pair(exp, result)); + + // Add definitions as GC roots + if (result->to()) + cenv.lock(result); + + // Add types in type substition as GC roots + for (Subst::iterator i = cenv.tsubst.begin(); i != cenv.tsubst.end(); ++i) { + Object::pool.addRoot(i->first); + Object::pool.addRoot(i->second); + } + } + + // Create function for top-level of program + CFunction f = startFunction(cenv, "main", resultType, ATuple(cursor)); + + // Compile all expressions into it + CValue val = NULL; + for (list< pair >::const_iterator i = exprs.begin(); i != exprs.end(); ++i) + val = cenv.compile(i->second); + + finishFunction(cenv, f, val); + + cenv.out << call(cenv, f, resultType) << " : " << resultType << endl; + + Object::pool.collect(Object::pool.roots()); + + if (cenv.args.find("-d") != cenv.args.end()) + cenv.write(cenv.out); + + } catch (Error& e) { + cenv.err << e.what() << endl; + return 1; + } + return 0; +} + +int +repl(CEnv& cenv) +{ + while (1) { + cenv.out << "() "; + cenv.out.flush(); + Cursor cursor("(stdin)"); + + try { + SExp exp = readExpression(cursor, std::cin); + if (exp.type == SExp::LIST && exp.empty()) + break; + + AST* body = cenv.penv.parse(exp); // Parse input + Constraints c; + body->constrain(cenv.tenv, c); // Constrain types + + Subst oldSubst = cenv.tsubst; + cenv.tsubst = Subst::compose(cenv.tsubst, TEnv::unify(c)); // Solve type constraints + + AType* bodyT = cenv.type(body); + THROW_IF(!bodyT, cursor, "call to untyped body") + + body->lift(cenv); + + CFunction f = NULL; + try { + // Create anonymous function to insert code into + f = startFunction(cenv, cenv.gensym("_repl"), bodyT, ATuple(cursor)); + CValue retVal = cenv.compile(body); + finishFunction(cenv, f, retVal); + cenv.out << call(cenv, f, bodyT); + } catch (Error& e) { + ADefinition* def = body->to(); + if (def) + cenv.out << def->sym(); + else + cenv.out << "?"; + eraseFunction(cenv, f); + } + cenv.out << " : " << cenv.type(body) << endl; + + // Add definitions as GC roots + if (body->to()) + cenv.lock(body); + + Object::pool.collect(Object::pool.roots()); + + cenv.tsubst = oldSubst; + if (cenv.args.find("-d") != cenv.args.end()) + cenv.write(cenv.out); + + } catch (Error& e) { + cenv.err << e.what() << endl; + } + } + return 0; +} + /*************************************************************************** - * EVAL/REPL/MAIN * + * MAIN * ***************************************************************************/ int diff --git a/tuplr.hpp b/tuplr.hpp index f70fc9c..c548110 100644 --- a/tuplr.hpp +++ b/tuplr.hpp @@ -556,6 +556,14 @@ struct TEnv : public Env< const ASymbol*, pair > { * Code Generation * ***************************************************************************/ +CFunction startFunction(CEnv& cenv, const std::string& name, + const AType* retT, const ATuple& argsT, + const vector argNames=vector()); + +void finishFunction(CEnv& cenv, CFunction f, CValue ret); +void eraseFunction(CEnv& cenv, CFunction f); +const string call(CEnv& cenv, CFunction f, AType* retT); + /// Compile-Time Environment struct CEnv { CEnv(PEnv& p, TEnv& t, CEngine e, ostream& os=std::cout, ostream& es=std::cerr); -- cgit v1.2.1