diff options
author | David Robillard <d@drobilla.net> | 2010-12-02 06:16:29 +0000 |
---|---|---|
committer | David Robillard <d@drobilla.net> | 2010-12-02 06:16:29 +0000 |
commit | 563a807be78bfe12e5bfbb9ff0d6da44242696c4 (patch) | |
tree | 13cf7ce3b90d072d6e7106c7d2eb4da33209acb0 /src/lift.cpp | |
parent | 32ac40a9ef62d2109563e36fb7cd478426c3489f (diff) | |
download | resp-563a807be78bfe12e5bfbb9ff0d6da44242696c4.tar.gz resp-563a807be78bfe12e5bfbb9ff0d6da44242696c4.tar.bz2 resp-563a807be78bfe12e5bfbb9ff0d6da44242696c4.zip |
Represent code as list structure (i.e. traditional LISP lists built from pairs), rather than tuple structure.
Remove unused/crufty depoly stage.
Remove cps from AST interface (but keep cps.cpp code around for later).
Improved command line interface for compilation stages (options -T -L -S).
git-svn-id: http://svn.drobilla.net/resp/resp@277 ad02d1e2-f140-0410-9f75-f8b11f17cedd
Diffstat (limited to 'src/lift.cpp')
-rw-r--r-- | src/lift.cpp | 90 |
1 files changed, 48 insertions, 42 deletions
diff --git a/src/lift.cpp b/src/lift.cpp index 563fd5d..81b157d 100644 --- a/src/lift.cpp +++ b/src/lift.cpp @@ -57,12 +57,8 @@ AQuote::lift(CEnv& cenv, Code& code) throw() AST* ATuple::lift(CEnv& cenv, Code& code) throw() { - ATuple* ret = new ATuple(*this); - iterator ri = ret->begin(); - FOREACHP(const_iterator, t, this) - *ri++ = (*t)->lift(cenv, code); - cenv.setTypeSameAs(ret, this); - return ret; + assert(false); + return NULL; } AST* @@ -84,24 +80,24 @@ AFn::lift(CEnv& cenv, Code& code) throw() const AType* paramType = (*tp++)->as<const AType*>(); if (paramType->kind == AType::EXPR && *paramType->head() == *cenv.tenv.Fn) { AType* fnType = new AType(*paramType); - fnType->prot()->push_front(const_cast<AType*>(cenv.tenv.var())); + fnType->prot(new AType(const_cast<AType*>(cenv.tenv.var()), fnType->prot()->as<AType*>(), Cursor())); paramType = tup<const AType>((*p)->loc, cenv.tenv.Tup, fnType, NULL); } - cenv.def((*p)->as<ASymbol*>(), *p, paramType, NULL); + cenv.def((*p)->as<const ASymbol*>(), *p, paramType, NULL); *ip++ = new AType(*paramType); } - /* Add closure parameter with dummy name (undefined symbol). + /* Prepend closure parameter with dummy name (undefined symbol). * The name of this parameter will be changed to the name of this * function after lifting the body (so recursive references correctly * refer to this function by the closure parameter). */ - impl->prot()->push_front(cenv.penv.sym("_")); + impl->prot(new ATuple(cenv.penv.sym("_"), impl->prot())); // Lift body const AType* implRetT = NULL; - iterator ci = impl->begin() + 2; - for (const_iterator i = begin() + 2; i != end(); ++i, ++ci) { + iterator ci = impl->iter_at(2); + for (iterator i = iter_at(2); i != end(); ++i, ++ci) { *ci = (*i)->lift(cenv, code); implRetT = cenv.type(*ci); } @@ -117,22 +113,22 @@ AFn::lift(CEnv& cenv, Code& code) throw() code.push_back(def); AType* implT = new AType(*type); // Type of the implementation function - AType* tupT = tup<AType>(loc, cenv.tenv.Tup, cenv.tenv.var(), NULL); - AType* consT = tup<AType>(loc, cenv.tenv.Tup, implT, NULL); - ACons* cons = tup<ACons>(loc, cenv.penv.sym("Closure"), implName, NULL); + TList tupT(loc, cenv.tenv.Tup, cenv.tenv.var(), NULL); + TList consT(loc, cenv.tenv.Tup, implT, NULL); + List<ACons, AST> cons(loc, cenv.penv.sym("Closure"), implName, NULL); - *(implT->begin() + 1) = implProtT; + implT->list_ref(1) = implProtT; const CEnv::FreeVars& freeVars = cenv.liftStack.top(); for (CEnv::FreeVars::const_iterator i = freeVars.begin(); i != freeVars.end(); ++i) { - cons->push_back(*i); - tupT->push_back(const_cast<AType*>(cenv.type(*i))); - consT->push_back(const_cast<AType*>(cenv.type(*i))); + cons.push_back(*i); + tupT.push_back(const_cast<AType*>(cenv.type(*i))); + consT.push_back(const_cast<AType*>(cenv.type(*i))); } cenv.liftStack.pop(); - implT->prot()->push_front(tupT); - *(implT->begin() + 2) = const_cast<AType*>(implRetT); + implT->prot(new AType(tupT, implT->prot(), Cursor())); + implT->list_ref(2) = const_cast<AType*>(implRetT); cenv.setType(impl, implT); cenv.setType(cons, consT); @@ -147,19 +143,22 @@ AFn::lift(CEnv& cenv, Code& code) throw() AST* ACall::lift(CEnv& cenv, Code& code) throw() { - ACall* copy = new ACall(this); - ATuple::iterator ri = copy->begin(); + List<ACall, AST> copy; // Lift all children (callee and arguments, recursively) - for (const_iterator i = begin(); i != end(); ++i) - *ri++ = (*i)->lift(cenv, code); + for (iterator i = begin(); i != end(); ++i) + copy.push_back((*i)->lift(cenv, code)); + + copy.head->loc = loc; + const AType* copyT = NULL; + ASymbol* sym = head()->to<ASymbol*>(); if (sym && !cenv.liftStack.empty() && sym->cppstr == cenv.liftStack.top().fn->name) { /* Recursive call to innermost function, call implementation directly, * reusing the current "_me" closure parameter (no cons or .). */ - copy->push_front(cenv.penv.sym(cenv.liftStack.top().implName)); + copy.push_front(cenv.penv.sym(cenv.liftStack.top().implName)); } else if (head()->to<AFn*>()) { /* Special case: ((fn ...) ...) * Lifting (fn ...) yields: (Fn _impl ...). @@ -168,24 +167,25 @@ ACall::lift(CEnv& cenv, Code& code) throw() * closure as the first parameter: * (_impl (Fn _impl ...) ...) */ - ACons* closure = (*copy->begin())->as<ACons*>(); - ASymbol* implSym = (*(closure->begin() + 1))->as<ASymbol*>(); + ACons* closure = copy.head->list_ref(0)->as<ACons*>(); + ASymbol* implSym = closure->list_ref(1)->as<ASymbol*>(); const AType* implT = cenv.type(cenv.resolve(implSym)); - copy->push_front(implSym); - cenv.setType(copy, (*(implT->begin() + 2))->as<const AType*>()); + copy.push_front(implSym); + copyT = implT->list_ref(2)->as<const AType*>(); } else { // Call to a closure, prepend code to access implementation function ADot* getFn = tup<ADot>(loc, cenv.penv.sym("."), - copy->head(), - new ALiteral<int32_t>(0, Cursor()), NULL); - const AType* calleeT = cenv.type(copy->head()); + copy.head->head(), + new ALiteral<int32_t>(0, Cursor()), NULL); + const AType* calleeT = cenv.type(copy.head->head()); assert(**calleeT->begin() == *cenv.tenv.Tup); - const AType* implT = (*(calleeT->begin() + 1))->as<const AType*>(); - copy->push_front(getFn); + const AType* implT = calleeT->list_ref(1)->as<const AType*>(); + copy.push_front(getFn); cenv.setType(getFn, implT); - cenv.setType(copy, (*(implT->begin() + 2))->as<const AType*>()); + copyT = implT->list_ref(2)->as<const AType*>(); } + cenv.setType(copy, copyT); return copy; } @@ -198,13 +198,19 @@ ADef::lift(CEnv& cenv, Code& code) throw() if (c) c->name = sym()->str(); - ADef* copy = new ADef(ATuple::lift(cenv, code)->as<ATuple*>()); + assert(list_ref(1)->to<const ASymbol*>()); + List<ADef, AST> copy; + copy.push_back(head()); + copy.push_back(list_ref(1)->lift(cenv, code)); + for (iterator t = iter_at(2); t != end(); ++t) + copy.push_back((*t)->lift(cenv, code)); + + cenv.setTypeSameAs(copy, this); - if (copy->sym() == copy->body()) + if (copy.head->sym() == copy.head->body()) return NULL; // Definition created by AFn::lift when body was lifted - cenv.def(copy->sym(), copy->body(), cenv.type(copy->body()), NULL); - cenv.setTypeSameAs(copy, this); + cenv.def(copy.head->sym(), copy.head->body(), cenv.type(copy.head->body()), NULL); return copy; } @@ -213,10 +219,10 @@ AST* lift_builtin_call(CEnv& cenv, T* call, Code& code) throw() { ATuple* copy = new T(call); - ATuple::iterator ri = copy->begin() + 1; + ATuple::iterator ri = copy->iter_at(1); // Lift all arguments - for (typename T::const_iterator i = call->begin() + 1; i != call->end(); ++i) + for (typename T::iterator i = call->iter_at(1); i != call->end(); ++i) *ri++ = (*i)->lift(cenv, code); cenv.setTypeSameAs(copy, call); |