void IpeModuleRoot::init()
{
mState = kResolved;
initialize();
for (int i = 1; i <= sHighWater; i++)
{
DefExpr* expr = toDefExpr(rootModule->block->body.get(i));
INT_ASSERT(expr);
if (mEnv->findLocal(expr->sym->name) != NULL)
{
printf(" Attempt to redefine identifier %s\n", expr->sym->name);
INT_ASSERT(false);
}
else if (TypeSymbol* sym = toTypeSymbol(expr->sym))
{
int offset = mEnv->allocateValue(sym->type);
VarSymbol* var = new VarSymbol(sym->name, gIpeTypeType);
INT_ASSERT(expr->exprType == NULL);
INT_ASSERT(expr->init == NULL);
var->addFlag(FLAG_CONST);
var->locationSet(0, offset);
mEnv->varAdd(var);
}
else if (expr->sym->isImmediate() == true)
{
VarSymbol* var = toVarSymbol(expr->sym);
int offset = mEnv->allocateValue(var->type);
var->addFlag(FLAG_CONST);
var->locationSet(0, offset);
mEnv->varAdd(var);
}
else
{
AstDumpToNode logger(stdout, 3);
printf("Unexpected expression while initializing RootModule\n");
printf(" ");
expr->accept(&logger);
printf("\n");
INT_ASSERT(false);
}
}
moduleAdd(this);
}
gc<String> SignatureBuilder::build(const DefExpr& method)
{
SignatureBuilder builder;
if (!method.leftParam().isNull())
{
builder.writeParam(method.leftParam());
}
builder.add(method.name()->cString());
if (!method.value().isNull()) builder.add("=");
if (!method.rightParam().isNull())
{
builder.add(" ");
builder.writeParam(method.rightParam());
}
if (!method.value().isNull())
{
builder.add("=");
builder.writeParam(method.value());
}
return String::create(builder.signature_, builder.length_);
}
forv_Vec(CallExpr, call, gCallExprs) {
if (call->isPrimitive(PRIM_CHECK_ERROR)) {
SET_LINENO(call);
SymExpr* errSe = toSymExpr(call->get(1));
Symbol* errorVar= errSe->symbol();
VarSymbol* errorExistsVar = newTemp("errorExists", dtBool);
DefExpr* def = new DefExpr(errorExistsVar);
CallExpr* errorExists = new CallExpr(PRIM_NOTEQUAL, errorVar, gNil);
CallExpr* move = new CallExpr(PRIM_MOVE, errorExistsVar, errorExists);
Expr* stmt = call->getStmtExpr();
stmt->insertBefore(def);
def->insertAfter(move);
call->replace(new SymExpr(errorExistsVar));
}
}
void flattenClasses(void) {
//
// collect nested classes
//
Vec<AggregateType*> nestedClasses;
forv_Vec(TypeSymbol, ts, gTypeSymbols) {
if (AggregateType* ct = toAggregateType(ts->type))
if (toAggregateType(ct->symbol->defPoint->parentSymbol->type))
nestedClasses.add(ct);
}
//
// move nested classes to module level
//
forv_Vec(AggregateType, ct, nestedClasses) {
ModuleSymbol* mod = ct->getModule();
DefExpr *def = ct->symbol->defPoint;
def->remove();
mod->block->insertAtTail(def);
}
void Resolver::resolve(Compiler& compiler, Module& module, DefExpr& method)
{
resolve(compiler, module, NULL, &method.resolved(), false,
method.leftParam(), method.rightParam(), method.value(),
method.body());
}
