aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/lift.cpp83
-rw-r--r--src/resp.hpp50
2 files changed, 47 insertions, 86 deletions
diff --git a/src/lift.cpp b/src/lift.cpp
index 04bf61b..979f3c1 100644
--- a/src/lift.cpp
+++ b/src/lift.cpp
@@ -52,7 +52,9 @@ lift_symbol(CEnv& cenv, Code& code, const ASymbol* sym) throw()
static AST*
lift_fn(CEnv& cenv, Code& code, ATuple* fn) throw()
{
- ATuple* impl = new ATuple(*fn);
+ List<ATuple,AST> impl;
+ impl.push_back(fn->head());
+
const string fnName = cenv.name(fn);
const string nameBase = cenv.penv.gensymstr(((fnName != "") ? fnName : "fn").c_str());
const string implNameStr = string("_") + nameBase;
@@ -64,53 +66,48 @@ lift_fn(CEnv& cenv, Code& code, ATuple* fn) throw()
cenv.push();
const AType* type = cenv.type(fn);
AType::const_iterator tp = type->prot()->begin();
- AType* implProtT = new AType(*type->prot()->as_type());
- ATuple::iterator ip = implProtT->begin();
+ List<AType,AType> implProtT;
+
+ List<ATuple,AST> implProt;
+
+ // Prepend closure parameter
+ implProt.push_back(const_cast<ASymbol*>(cenv.penv.sym("_me")));
+
for (ATuple::const_iterator p = fn->prot()->begin(); p != fn->prot()->end(); ++p) {
const AType* paramType = (*tp++)->as_type();
if (paramType->kind == AType::EXPR && *paramType->head() == *cenv.tenv.Fn) {
- AType* fnType = new AType(*paramType);
- fnType->set_prot(new AType(const_cast<AType*>(cenv.tenv.var()),
- const_cast<AType*>(fnType->prot()->as_type()),
- Cursor()));
+ AType* fnType = new AType(const_cast<AType*>(cenv.tenv.var()),
+ const_cast<AType*>(paramType),
+ fnType->loc);
paramType = tup<const AType>((*p)->loc, cenv.tenv.Tup, fnType, NULL);
}
cenv.def((*p)->as_symbol(), *p, paramType, NULL);
- *ip++ = new AType(*paramType);
+ implProt.push_back(const_cast<AST*>(*p));
+ implProtT.push_back(new AType(*paramType));
}
- /* 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->set_prot(new ATuple(cenv.penv.sym("_"), impl->prot()));
+ impl.push_back(implProt);
// Lift body
const AType* implRetT = NULL;
- ATuple::iterator ci = impl->iter_at(2);
- for (ATuple::iterator i = fn->iter_at(2); i != fn->end(); ++i, ++ci) {
- *ci = resp_lift(cenv, code, *i);
- implRetT = cenv.type(*ci);
+ for (ATuple::const_iterator i = fn->iter_at(2); i != fn->end(); ++i) {
+ AST* lifted = resp_lift(cenv, code, const_cast<AST*>(*i));
+ impl.push_back(lifted);
+ implRetT = cenv.type(lifted);
}
cenv.pop();
- // Set name of closure parameter to "me"
- *impl->prot()->begin() = cenv.penv.sym("_me");
-
// Create definition for implementation fn
ASymbol* implName = cenv.penv.sym(implNameStr);
- ATuple* def = tup<ATuple>(fn->loc, cenv.penv.sym("def"), implName, impl, NULL);
+ ATuple* def = tup<ATuple>(fn->loc, cenv.penv.sym("def"), implName, impl.head, NULL);
code.push_back(def);
- AType* implT = new AType(*type); // Type of the implementation function
- TList tupT(fn->loc, cenv.tenv.Tup, cenv.tenv.var(), NULL);
- TList consT(fn->loc, cenv.tenv.Tup, implT, NULL);
+ TList implT; // Type of the implementation function
+ TList tupT(fn->loc, cenv.tenv.Tup, cenv.tenv.var(), NULL);
+ TList consT;
List<ATuple, AST> cons(fn->loc, cenv.penv.sym("Closure"), implName, NULL);
- 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(const_cast<ASymbol*>(*i));
@@ -119,9 +116,15 @@ lift_fn(CEnv& cenv, Code& code, ATuple* fn) throw()
}
cenv.liftStack.pop();
- implT->set_prot(new AType(tupT, implT->prot(), Cursor()));
- implT->list_ref(2) = const_cast<AType*>(implRetT);
+ implProtT.push_front(tupT);
+
+ implT.push_back(const_cast<AType*>((AType*)type->head()));
+ implT.push_back(const_cast<AType*>(implProtT.head));
+ implT.push_back(const_cast<AType*>(implRetT));
+ consT.push_front(implT.head);
+ consT.push_front(cenv.tenv.Tup);
+
cenv.setType(impl, implT);
cenv.setType(cons, consT);
@@ -138,8 +141,8 @@ lift_call(CEnv& cenv, Code& code, ATuple* call) throw()
List<ATuple, AST> copy;
// Lift all children (callee and arguments, recursively)
- for (ATuple::iterator i = call->begin(); i != call->end(); ++i)
- copy.push_back(resp_lift(cenv, code, *i));
+ for (ATuple::const_iterator i = call->begin(); i != call->end(); ++i)
+ copy.push_back(const_cast<AST*>(resp_lift(cenv, code, const_cast<AST*>(*i))));
copy.head->loc = call->loc;
@@ -159,9 +162,9 @@ lift_call(CEnv& cenv, Code& code, ATuple* call) throw()
* closure as the first parameter:
* (_impl (Fn _impl ...) ...)
*/
- ATuple* closure = copy.head->list_ref(0)->as_tuple();
- ASymbol* implSym = const_cast<ASymbol*>(closure->list_ref(1)->as_symbol());
- const AType* implT = cenv.type(cenv.resolve(implSym));
+ const ATuple* closure = copy.head->list_ref(0)->as_tuple();
+ ASymbol* implSym = const_cast<ASymbol*>(closure->list_ref(1)->as_symbol());
+ const AType* implT = cenv.type(cenv.resolve(implSym));
copy.push_front(implSym);
copyT = implT->list_ref(2)->as_type();
} else {
@@ -186,7 +189,7 @@ lift_def(CEnv& cenv, Code& code, ATuple* def) throw()
{
// Define stub first for recursion
const ASymbol* const sym = def->list_ref(1)->as_symbol();
- AST* const body = def->list_ref(2);
+ const AST* const body = def->list_ref(2);
cenv.def(sym, body, cenv.type(body), NULL);
if (is_form(body, "fn"))
cenv.setName(body->as_tuple(), sym->str());
@@ -194,9 +197,9 @@ lift_def(CEnv& cenv, Code& code, ATuple* def) throw()
assert(def->list_ref(1)->to_symbol());
List<ATuple, AST> copy;
copy.push_back(def->head());
- copy.push_back(resp_lift(cenv, code, def->list_ref(1)));
- for (ATuple::iterator t = def->iter_at(2); t != def->end(); ++t)
- copy.push_back(resp_lift(cenv, code, *t));
+ copy.push_back(resp_lift(cenv, code, const_cast<AST*>(def->list_ref(1))));
+ for (ATuple::const_iterator t = def->iter_at(2); t != def->end(); ++t)
+ copy.push_back(resp_lift(cenv, code, const_cast<AST*>(*t)));
cenv.setTypeSameAs(copy, def);
@@ -217,8 +220,8 @@ lift_builtin_call(CEnv& cenv, Code& code, ATuple* call) throw()
copy.push_back(call->head());
// Lift all arguments
- for (ATuple::iterator i = call->iter_at(1); i != call->end(); ++i)
- copy.push_back(resp_lift(cenv, code, *i));
+ for (ATuple::const_iterator i = call->iter_at(1); i != call->end(); ++i)
+ copy.push_back(resp_lift(cenv, code, const_cast<AST*>(*i)));
cenv.setTypeSameAs(copy, call);
return copy;
diff --git a/src/resp.hpp b/src/resp.hpp
index 12d2ca0..0112a9e 100644
--- a/src/resp.hpp
+++ b/src/resp.hpp
@@ -204,6 +204,9 @@ struct ASymbol;
struct AType;
struct ALexeme;
+class AST;
+extern ostream& operator<<(ostream& out, const AST* ast);
+
/// Base class for all AST nodes
struct AST : public Object {
AST(Tag t, Cursor c=Cursor()) : loc(c) { this->tag(t); }
@@ -263,8 +266,6 @@ struct AST : public Object {
Cursor loc;
};
-extern ostream& operator<<(ostream& out, const AST* ast);
-
template<typename T>
static T* tup(Cursor c, AST* ast, ...)
{
@@ -359,42 +360,12 @@ struct ATuple : public AST {
void last(AST* ast) { _vec[_len - 1] = ast; }
- struct iterator {
- iterator(ATuple* n) : node(n) {
- assert(!n || n->tup_len() == 0 || n->tup_len() == 2);
- if (!n || n->tup_len() == 0)
- node = NULL;
- }
- inline void increment() {
- if (node->last())
- node = node->last()->as_tuple();
- else
- node = NULL;
- }
- inline iterator& operator++() {
- assert(node);
- increment();
- return *this;
- }
- inline iterator operator++(int) {
- assert(node);
- const iterator ret(node);
- increment();
- return ret;
- }
- inline bool operator==(const iterator& i) const { return node == i.node; }
- inline bool operator!=(const iterator& i) const { return node != i.node; }
- AST*& operator*() { return node->head(); }
- ATuple* node;
- };
-
struct const_iterator {
const_iterator(const ATuple* n) : node(n) {
assert(!n || n->tup_len() == 0 || n->tup_len() == 2);
if (!n || n->tup_len() == 0)
node = NULL;
}
- const_iterator(const iterator& i) : node(i.node) {}
inline void increment() {
if (node->last())
node = node->last()->as_tuple();
@@ -423,9 +394,7 @@ struct ATuple : public AST {
};
const_iterator begin() const { assert(_len == 0 || _len == 2); return const_iterator(this); }
- iterator begin() { assert(_len == 0 || _len == 2); return iterator(this); }
const_iterator end() const { return const_iterator(NULL); }
- iterator end() { return iterator(NULL); }
const_iterator iter_at(unsigned index) const {
const_iterator i = begin();
@@ -435,20 +404,9 @@ struct ATuple : public AST {
return i;
}
- iterator iter_at(unsigned index) {
- iterator i = begin();
- for (unsigned idx = 0; idx != index; ++i, ++idx) {
- assert(i != end());
- }
- return i;
- }
-
- AST*& list_ref(unsigned index) { return *iter_at(index); }
const AST* list_ref(unsigned index) const { return *iter_at(index); }
- const ATuple* prot() const { return list_ref(1)->as_tuple(); }
- ATuple* prot() { return list_ref(1)->as_tuple(); }
- void set_prot(ATuple* prot) { *iter_at(1) = prot; }
+ const ATuple* prot() const { return list_ref(1)->as_tuple(); }
private:
friend class GC;
generated by cgit v1.2.1 (git 2.18.0) at 2024-09-28 19:27:09 +0000