diff options
-rw-r--r-- | src/exports.cc | 12 | ||||
-rw-r--r-- | src/lookup.cc | 4 | ||||
-rw-r--r-- | src/parsetree.h | 22 | ||||
-rw-r--r-- | src/resolve.cc | 98 |
4 files changed, 68 insertions, 68 deletions
diff --git a/src/exports.cc b/src/exports.cc index 92813f5e..62e0d2a3 100644 --- a/src/exports.cc +++ b/src/exports.cc @@ -123,7 +123,7 @@ void Compiler::generateExports() for ( ObjFieldList::Iter ofi = *objFieldList; ofi.lte(); ofi++ ) { ObjectField *field = ofi->value; if ( field->useOffset && field->typeRef != 0 ) { - UniqueType *ut = field->typeRef->lookupType( this ); + UniqueType *ut = field->typeRef->resolveType( this ); if ( ut != 0 && ut->typeId == TYPE_TREE ) { out << " " << ut->langEl->refName << " " << field->name << "();\n"; @@ -131,7 +131,7 @@ void Compiler::generateExports() } if ( field->isRhsGet ) { - UniqueType *ut = field->typeRef->lookupType( this ); + UniqueType *ut = field->typeRef->resolveType( this ); if ( ut != 0 && ut->typeId == TYPE_TREE ) { out << " " << ut->langEl->refName << " " << field->name << "();\n"; @@ -179,7 +179,7 @@ void Compiler::generateExports() for ( ObjFieldList::Iter of = *globalObjectDef->objFieldList; of.lte(); of++ ) { ObjectField *field = of->value; if ( field->isExport ) { - UniqueType *ut = field->typeRef->lookupType(this); + UniqueType *ut = field->typeRef->resolveType(this); if ( ut != 0 && ut->typeId == TYPE_TREE ) { out << ut->langEl->refName << " " << field->name << "( colm_program *prg );\n"; } @@ -220,7 +220,7 @@ void Compiler::generateExportsImpl() for ( ObjFieldList::Iter ofi = *objFieldList; ofi.lte(); ofi++ ) { ObjectField *field = ofi->value; if ( field->useOffset && field->typeRef != 0 ) { - UniqueType *ut = field->typeRef->lookupType( this ); + UniqueType *ut = field->typeRef->resolveType( this ); if ( ut != 0 && ut->typeId == TYPE_TREE ) { out << ut->langEl->refName << " " << lel->declName << "::" << field->name << @@ -230,7 +230,7 @@ void Compiler::generateExportsImpl() } if ( field->isRhsGet ) { - UniqueType *ut = field->typeRef->lookupType( this ); + UniqueType *ut = field->typeRef->resolveType( this ); if ( ut != 0 && ut->typeId == TYPE_TREE ) { out << ut->langEl->refName << " " << lel->declName << "::" << field->name << @@ -277,7 +277,7 @@ void Compiler::generateExportsImpl() for ( ObjFieldList::Iter of = *globalObjectDef->objFieldList; of.lte(); of++ ) { ObjectField *field = of->value; if ( field->isExport ) { - UniqueType *ut = field->typeRef->lookupType(this); + UniqueType *ut = field->typeRef->resolveType(this); if ( ut != 0 && ut->typeId == TYPE_TREE ) { out << ut->langEl->refName << " " << field->name << "( colm_program *prg )\n" diff --git a/src/lookup.cc b/src/lookup.cc index 357937c9..3809de33 100644 --- a/src/lookup.cc +++ b/src/lookup.cc @@ -76,7 +76,7 @@ VarRefLookup LangVarRef::lookupQualification( Compiler *pd, ObjNameScope *rootSc error(qi->loc) << "cannot resolve qualification " << qi->data << endp; /* Lookup the type of the field. */ - el->typeRef->lookupType( pd ); + el->typeRef->resolveType( pd ); UniqueType *qualUT = el->typeRef->uniqueType; /* If we are dealing with an iterator then dereference it. */ @@ -203,7 +203,7 @@ UniqueType *LangVarRef::lookup( Compiler *pd ) const VarRefLookup lookup = lookupField( pd ); ObjectField *el = lookup.objField; - UniqueType *elUT = el->typeRef->lookupType( pd ); + UniqueType *elUT = el->typeRef->resolveType( pd ); /* Deref iterators. */ if ( elUT->typeId == TYPE_ITER ) diff --git a/src/parsetree.h b/src/parsetree.h index 4a80e8d4..f03ab3f0 100644 --- a/src/parsetree.h +++ b/src/parsetree.h @@ -2133,17 +2133,17 @@ struct TypeRef void resolveRepeat( Compiler *pd ); - Namespace *lookupNspace( Compiler *pd ); - UniqueType *lookupIterator( Compiler *pd ); - UniqueType *lookupTypeName( Compiler *pd ); - UniqueType *lookupTypeLiteral( Compiler *pd ); - UniqueType *lookupTypeMap( Compiler *pd ); - UniqueType *lookupTypeList( Compiler *pd ); - UniqueType *lookupTypeVector( Compiler *pd ); - UniqueType *lookupTypeParser( Compiler *pd ); - UniqueType *lookupType( Compiler *pd ); - UniqueType *lookupTypePtr( Compiler *pd ); - UniqueType *lookupTypeRef( Compiler *pd ); + Namespace *resolveNspace( Compiler *pd ); + UniqueType *resolveIterator( Compiler *pd ); + UniqueType *resolveTypeName( Compiler *pd ); + UniqueType *resolveTypeLiteral( Compiler *pd ); + UniqueType *resolveTypeMap( Compiler *pd ); + UniqueType *resolveTypeList( Compiler *pd ); + UniqueType *resolveTypeVector( Compiler *pd ); + UniqueType *resolveTypeParser( Compiler *pd ); + UniqueType *resolveType( Compiler *pd ); + UniqueType *resolveTypePtr( Compiler *pd ); + UniqueType *resolveTypeRef( Compiler *pd ); Type type; InputLoc loc; diff --git a/src/resolve.cc b/src/resolve.cc index b4c0f51d..6b5dc757 100644 --- a/src/resolve.cc +++ b/src/resolve.cc @@ -28,14 +28,14 @@ using std::cout; using std::cerr; using std::endl; -Namespace *TypeRef::lookupNspace( Compiler *pd ) +Namespace *TypeRef::resolveNspace( Compiler *pd ) { if ( parsedVarRef != 0 && !nspaceQual->thisOnly() ) { UniqueType *ut = parsedVarRef->lookup( pd ); return ut->langEl->nspace; } else if ( parsedTypeRef != 0 && !nspaceQual->thisOnly() ) { - UniqueType *ut = parsedTypeRef->lookupType( pd ); + UniqueType *ut = parsedTypeRef->resolveType( pd ); return ut->langEl->nspace; } else { @@ -44,9 +44,9 @@ Namespace *TypeRef::lookupNspace( Compiler *pd ) } } -UniqueType *TypeRef::lookupTypeName( Compiler *pd ) +UniqueType *TypeRef::resolveTypeName( Compiler *pd ) { - nspace = lookupNspace( pd ); + nspace = resolveNspace( pd ); if ( nspace == 0 ) error(loc) << "do not have region for resolving reference" << endp; @@ -59,7 +59,7 @@ UniqueType *TypeRef::lookupTypeName( Compiler *pd ) switch ( inDict->type ) { /* Defer to the typeRef we are an alias of. We need to guard against loops here. */ case TypeMapEl::TypeAliasType: - return inDict->typeRef->lookupType( pd ); + return inDict->typeRef->resolveType( pd ); case TypeMapEl::LangElType: return pd->findUniqueType( TYPE_TREE, inDict->value ); @@ -76,10 +76,10 @@ UniqueType *TypeRef::lookupTypeName( Compiler *pd ) return 0; } -UniqueType *TypeRef::lookupTypeLiteral( Compiler *pd ) +UniqueType *TypeRef::resolveTypeLiteral( Compiler *pd ) { /* Lookup up the qualifiction and then the name. */ - nspace = lookupNspace( pd ); + nspace = resolveNspace( pd ); if ( nspace == 0 ) error(loc) << "do not have region for resolving reference" << endp; @@ -106,12 +106,12 @@ UniqueType *TypeRef::lookupTypeLiteral( Compiler *pd ) return 0; } -UniqueType *TypeRef::lookupTypeMap( Compiler *pd ) +UniqueType *TypeRef::resolveTypeMap( Compiler *pd ) { nspace = pd->rootNamespace; - UniqueType *utKey = typeRef1->lookupType( pd ); - UniqueType *utValue = typeRef2->lookupType( pd ); + UniqueType *utKey = typeRef1->resolveType( pd ); + UniqueType *utValue = typeRef2->resolveType( pd ); UniqueMap searchKey( utKey, utValue ); UniqueMap *inMap = pd->uniqueMapMap.find( &searchKey ); @@ -138,11 +138,11 @@ UniqueType *TypeRef::lookupTypeMap( Compiler *pd ) return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl ); } -UniqueType *TypeRef::lookupTypeList( Compiler *pd ) +UniqueType *TypeRef::resolveTypeList( Compiler *pd ) { nspace = pd->rootNamespace; - UniqueType *utValue = typeRef1->lookupType( pd ); + UniqueType *utValue = typeRef1->resolveType( pd ); UniqueList searchKey( utValue ); UniqueList *inMap = pd->uniqueListMap.find( &searchKey ); @@ -168,11 +168,11 @@ UniqueType *TypeRef::lookupTypeList( Compiler *pd ) return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl ); } -UniqueType *TypeRef::lookupTypeVector( Compiler *pd ) +UniqueType *TypeRef::resolveTypeVector( Compiler *pd ) { nspace = pd->rootNamespace; - UniqueType *utValue = typeRef1->lookupType( pd ); + UniqueType *utValue = typeRef1->resolveType( pd ); UniqueVector searchKey( utValue ); UniqueVector *inMap = pd->uniqueVectorMap.find( &searchKey ); @@ -198,11 +198,11 @@ UniqueType *TypeRef::lookupTypeVector( Compiler *pd ) return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl ); } -UniqueType *TypeRef::lookupTypeParser( Compiler *pd ) +UniqueType *TypeRef::resolveTypeParser( Compiler *pd ) { nspace = pd->rootNamespace; - UniqueType *utParse = typeRef1->lookupType( pd ); + UniqueType *utParse = typeRef1->resolveType( pd ); UniqueParser searchKey( utParse ); UniqueParser *inMap = pd->uniqueParserMap.find( &searchKey ); @@ -228,15 +228,15 @@ UniqueType *TypeRef::lookupTypeParser( Compiler *pd ) return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl ); } -UniqueType *TypeRef::lookupTypePtr( Compiler *pd ) +UniqueType *TypeRef::resolveTypePtr( Compiler *pd ) { - typeRef1->lookupType( pd ); + typeRef1->resolveType( pd ); return pd->findUniqueType( TYPE_PTR, typeRef1->uniqueType->langEl ); } -UniqueType *TypeRef::lookupTypeRef( Compiler *pd ) +UniqueType *TypeRef::resolveTypeRef( Compiler *pd ) { - typeRef1->lookupType( pd ); + typeRef1->resolveType( pd ); return pd->findUniqueType( TYPE_REF, typeRef1->uniqueType->langEl ); } @@ -287,9 +287,9 @@ void TypeRef::resolveRepeat( Compiler *pd ) uniqueType = pd->findUniqueType( TYPE_TREE, uniqueRepeat->declLangEl ); } -UniqueType *TypeRef::lookupIterator( Compiler *pd ) +UniqueType *TypeRef::resolveIterator( Compiler *pd ) { - UniqueType *searchUT = searchTypeRef->lookupType( pd ); + UniqueType *searchUT = searchTypeRef->resolveType( pd ); /* Lookup the iterator call. Make sure it is an iterator. */ VarRefLookup lookup = iterCall->langTerm->varRef->lookupMethod( pd ); @@ -309,7 +309,7 @@ UniqueType *TypeRef::lookupIterator( Compiler *pd ) } -UniqueType *TypeRef::lookupType( Compiler *pd ) +UniqueType *TypeRef::resolveType( Compiler *pd ) { if ( uniqueType != 0 ) return uniqueType; @@ -317,31 +317,31 @@ UniqueType *TypeRef::lookupType( Compiler *pd ) /* Not an iterator. May be a reference. */ switch ( type ) { case Name: - uniqueType = lookupTypeName( pd ); + uniqueType = resolveTypeName( pd ); break; case Literal: - uniqueType = lookupTypeLiteral( pd ); + uniqueType = resolveTypeLiteral( pd ); break; case Map: - uniqueType = lookupTypeMap( pd ); + uniqueType = resolveTypeMap( pd ); break; case List: - uniqueType = lookupTypeList( pd ); + uniqueType = resolveTypeList( pd ); break; case Vector: - uniqueType = lookupTypeVector( pd ); + uniqueType = resolveTypeVector( pd ); break; case Parser: - uniqueType = lookupTypeParser( pd ); + uniqueType = resolveTypeParser( pd ); break; case Ptr: - uniqueType = lookupTypePtr( pd ); + uniqueType = resolveTypePtr( pd ); break; case Ref: - uniqueType = lookupTypeRef( pd ); + uniqueType = resolveTypeRef( pd ); break; case Iterator: - uniqueType = lookupIterator( pd ); + uniqueType = resolveIterator( pd ); break; case Unspecified: /* No lookup needed, unique type(s) set when constructed. */ @@ -356,7 +356,7 @@ UniqueType *TypeRef::lookupType( Compiler *pd ) void Compiler::resolveProdEl( ProdEl *prodEl ) { - prodEl->typeRef->lookupType( this ); + prodEl->typeRef->resolveType( this ); prodEl->langEl = prodEl->typeRef->uniqueType->langEl; } @@ -364,7 +364,7 @@ void LangTerm::resolve( Compiler *pd ) { switch ( type ) { case ConstructType: - typeRef->lookupType( pd ); + typeRef->resolveType( pd ); /* Initialization expressions. */ if ( fieldInitArgs != 0 ) { @@ -419,10 +419,10 @@ void LangTerm::resolve( Compiler *pd ) expr->resolve( pd ); break; case TypeIdType: - typeRef->lookupType( pd ); + typeRef->resolveType( pd ); break; case SearchType: - typeRef->lookupType( pd ); + typeRef->resolveType( pd ); break; case NilType: case TrueType: @@ -431,7 +431,7 @@ void LangTerm::resolve( Compiler *pd ) case ParseStopType: case ParseType: - typeRef->lookupType( pd ); + typeRef->resolveType( pd ); /* Evaluate the initialization expressions. */ if ( fieldInitArgs != 0 ) { for ( FieldInitVect::Iter pi = *fieldInitArgs; pi.lte(); pi++ ) @@ -455,7 +455,7 @@ void LangTerm::resolve( Compiler *pd ) case EmbedStringType: break; case CastType: - typeRef->lookupType( pd ); + typeRef->resolveType( pd ); expr->resolve( pd ); break; } @@ -502,10 +502,10 @@ void LangStmt::resolveForIter( Compiler *pd ) const iterCall->resolve( pd ); /* Search type ref. */ - typeRef->lookupType( pd ); + typeRef->resolveType( pd ); /* Iterator type ref. */ - objField->typeRef->lookupType( pd ); + objField->typeRef->resolveType( pd ); /* Resolve the statements. */ for ( StmtList::Iter stmt = *stmtList; stmt.lte(); stmt++ ) @@ -588,7 +588,7 @@ void ObjectDef::resolve( Compiler *pd ) ObjectField *field = fli->value; if ( field->typeRef != 0 ) - field->typeRef->lookupType( pd ); + field->typeRef->resolveType( pd ); } } @@ -605,10 +605,10 @@ void CodeBlock::resolve( Compiler *pd ) const void Compiler::resolveFunction( Function *func ) { if ( func->typeRef != 0 ) - func->typeRef->lookupType( this ); + func->typeRef->resolveType( this ); for ( ParameterList::Iter param = *func->paramList; param.lte(); param++ ) - param->typeRef->lookupType( this ); + param->typeRef->resolveType( this ); CodeBlock *block = func->codeBlock; block->resolve( this ); @@ -673,14 +673,14 @@ void Compiler::resolveParseTree() if ( objDef != 0 ) { /* Init all fields of the object. */ for ( ObjFieldList::Iter f = *objDef->objFieldList; f.lte(); f++ ) { - f->value->typeRef->lookupType( this ); + f->value->typeRef->resolveType( this ); } } } /* Init all fields of the global object. */ for ( ObjFieldList::Iter f = *globalObjectDef->objFieldList; f.lte(); f++ ) { - f->value->typeRef->lookupType( this ); + f->value->typeRef->resolveType( this ); } } @@ -713,10 +713,10 @@ void Compiler::resolveGenericTypes() { for ( NamespaceList::Iter ns = namespaceList; ns.lte(); ns++ ) { for ( GenericList::Iter gen = ns->genericList; gen.lte(); gen++ ) { - gen->utArg = gen->typeArg->lookupType( this ); + gen->utArg = gen->typeArg->resolveType( this ); if ( gen->typeId == GEN_MAP ) - gen->keyUT = gen->keyTypeArg->lookupType( this ); + gen->keyUT = gen->keyTypeArg->resolveType( this ); } } } @@ -768,7 +768,7 @@ void Compiler::makeEofElements() void Compiler::resolvePrecedence() { for ( PredDeclList::Iter predDecl = predDeclList; predDecl != 0; predDecl++ ) { - predDecl->typeRef->lookupType( this ); + predDecl->typeRef->resolveType( this ); LangEl *langEl = predDecl->typeRef->uniqueType->langEl; langEl->predType = predDecl->predType; @@ -789,7 +789,7 @@ void Compiler::resolvePass() resolveGenericTypes(); - argvTypeRef->lookupType( this ); + argvTypeRef->resolveType( this ); /* We must do this as the last step in the type resolution process because * all type resolves can cause new language elments with associated |