Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SymTab/Validate.cc

    re82ef13 r25fcb84  
    7777class SwitchStmt;
    7878
    79 #define debugPrint( x ) if ( doDebug ) x
     79#define debugPrint( x ) if ( doDebug ) { std::cout << x; }
    8080
    8181namespace SymTab {
    82         /// hoists declarations that are difficult to hoist while parsing
    83         struct HoistTypeDecls final : public WithDeclsToAdd {
    84                 void previsit( SizeofExpr * );
    85                 void previsit( AlignofExpr * );
    86                 void previsit( UntypedOffsetofExpr * );
    87                 void handleType( Type * );
    88         };
    89 
    90         struct FixQualifiedTypes final : public WithIndexer {
    91                 Type * postmutate( QualifiedType * );
    92         };
    93 
    9482        struct HoistStruct final : public WithDeclsToAdd, public WithGuards {
    9583                /// Flattens nested struct types
    9684                static void hoistStruct( std::list< Declaration * > &translationUnit );
    9785
     86                void previsit( EnumInstType * enumInstType );
     87                void previsit( StructInstType * structInstType );
     88                void previsit( UnionInstType * unionInstType );
    9889                void previsit( StructDecl * aggregateDecl );
    9990                void previsit( UnionDecl * aggregateDecl );
    10091                void previsit( StaticAssertDecl * assertDecl );
    101                 void previsit( StructInstType * type );
    102                 void previsit( UnionInstType * type );
    103                 void previsit( EnumInstType * type );
    10492
    10593          private:
    … …  
    124112
    125113        /// Associates forward declarations of aggregates with their definitions
    126         struct LinkReferenceToTypes final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes>, public WithShortCircuiting {
     114        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards {
    127115                LinkReferenceToTypes( const Indexer *indexer );
    128116                void postvisit( TypeInstType *typeInst );
    … …  
    132120                void postvisit( UnionInstType *unionInst );
    133121                void postvisit( TraitInstType *traitInst );
    134                 void previsit( QualifiedType * qualType );
    135                 void postvisit( QualifiedType * qualType );
    136122
    137123                void postvisit( EnumDecl *enumDecl );
    … …  
    179165        };
    180166
    181         struct ReplaceTypedef final : public WithVisitorRef<ReplaceTypedef>, public WithGuards, public WithShortCircuiting, public WithDeclsToAdd {
    182                 ReplaceTypedef() : scopeLevel( 0 ) {}
     167        struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
     168                EliminateTypedef() : scopeLevel( 0 ) {}
    183169                /// Replaces typedefs by forward declarations
    184                 static void replaceTypedef( std::list< Declaration * > &translationUnit );
    185 
    186                 void premutate( QualifiedType * );
    187                 Type * postmutate( QualifiedType * qualType );
     170                static void eliminateTypedef( std::list< Declaration * > &translationUnit );
     171
    188172                Type * postmutate( TypeInstType * aggregateUseType );
    189173                Declaration * postmutate( TypedefDecl * typeDecl );
    … …  
    196180
    197181                void premutate( CompoundStmt * compoundStmt );
     182                CompoundStmt * postmutate( CompoundStmt * compoundStmt );
    198183
    199184                void premutate( StructDecl * structDecl );
     185                Declaration * postmutate( StructDecl * structDecl );
    200186                void premutate( UnionDecl * unionDecl );
     187                Declaration * postmutate( UnionDecl * unionDecl );
    201188                void premutate( EnumDecl * enumDecl );
    202                 void premutate( TraitDecl * );
     189                Declaration * postmutate( EnumDecl * enumDecl );
     190                Declaration * postmutate( TraitDecl * contextDecl );
    203191
    204192                void premutate( FunctionType * ftype );
    … …  
    206194          private:
    207195                template<typename AggDecl>
     196                AggDecl *handleAggregate( AggDecl * aggDecl );
     197
     198                template<typename AggDecl>
    208199                void addImplicitTypedef( AggDecl * aggDecl );
    209                 template< typename AggDecl >
    210                 void handleAggregate( AggDecl * aggr );
    211200
    212201                typedef std::unique_ptr<TypedefDecl> TypedefDeclPtr;
    213202                typedef ScopedMap< std::string, std::pair< TypedefDeclPtr, int > > TypedefMap;
    214                 typedef ScopedMap< std::string, TypeDecl * > TypeDeclMap;
     203                typedef std::map< std::string, TypeDecl * > TypeDeclMap;
    215204                TypedefMap typedefNames;
    216205                TypeDeclMap typedeclNames;
    217206                int scopeLevel;
    218207                bool inFunctionType = false;
    219         };
    220 
    221         struct EliminateTypedef {
    222                 /// removes TypedefDecls from the AST
    223                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
    224 
    225                 template<typename AggDecl>
    226                 void handleAggregate( AggDecl *aggregateDecl );
    227 
    228                 void previsit( StructDecl * aggregateDecl );
    229                 void previsit( UnionDecl * aggregateDecl );
    230                 void previsit( CompoundStmt * compoundStmt );
    231208        };
    232209
    … …  
    286263                PassVisitor<FindSpecialDeclarations> finder;
    287264                PassVisitor<LabelAddressFixer> labelAddrFixer;
    288                 PassVisitor<HoistTypeDecls> hoistDecls;
    289                 PassVisitor<FixQualifiedTypes> fixQual;
    290 
    291                 acceptAll( translationUnit, hoistDecls );
    292                 ReplaceTypedef::replaceTypedef( translationUnit );
     265
     266                EliminateTypedef::eliminateTypedef( translationUnit );
     267                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
    293268                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
    294269                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
    295270                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
    296                 mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
    297                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
    298                 EliminateTypedef::eliminateTypedef( translationUnit ); //
    299271                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
    300272                VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
    … …  
    322294        }
    323295
    324 
    325         void HoistTypeDecls::handleType( Type * type ) {
    326                 // some type declarations are buried in expressions and not easy to hoist during parsing; hoist them here
    327                 AggregateDecl * aggr = nullptr;
    328                 if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
    329                         aggr = inst->baseStruct;
    330                 } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
    331                         aggr = inst->baseUnion;
    332                 } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( type ) ) {
    333                         aggr = inst->baseEnum;
    334                 }
    335                 if ( aggr && aggr->body ) {
    336                         declsToAddBefore.push_front( aggr );
    337                 }
    338         }
    339 
    340         void HoistTypeDecls::previsit( SizeofExpr * expr ) {
    341                 handleType( expr->type );
    342         }
    343 
    344         void HoistTypeDecls::previsit( AlignofExpr * expr ) {
    345                 handleType( expr->type );
    346         }
    347 
    348         void HoistTypeDecls::previsit( UntypedOffsetofExpr * expr ) {
    349                 handleType( expr->type );
    350         }
    351 
    352 
    353         Type * FixQualifiedTypes::postmutate( QualifiedType * qualType ) {
    354                 Type * parent = qualType->parent;
    355                 Type * child = qualType->child;
    356                 if ( dynamic_cast< GlobalScopeType * >( qualType->parent ) ) {
    357                         // .T => lookup T at global scope
    358                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
    359                                 auto td = indexer.globalLookupType( inst->name );
    360                                 if ( ! td ) {
    361                                         SemanticError( qualType->location, toString("Use of undefined global type ", inst->name) );
    362                                 }
    363                                 auto base = td->base;
    364                                 assert( base );
    365                                 return base->clone();
    366                         } else {
    367                                 // .T => T is not a type name
    368                                 assertf( false, "unhandled global qualified child type: %s", toCString(child) );
    369                         }
    370                 } else {
    371                         // S.T => S must be an aggregate type, find the declaration for T in S.
    372                         AggregateDecl * aggr = nullptr;
    373                         if ( StructInstType * inst = dynamic_cast< StructInstType * >( parent ) ) {
    374                                 aggr = inst->baseStruct;
    375                         } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * > ( parent ) ) {
    376                                 aggr = inst->baseUnion;
    377                         } else {
    378                                 SemanticError( qualType->location, toString("Qualified type requires an aggregate on the left, but has: ", parent) );
    379                         }
    380                         assert( aggr ); // TODO: need to handle forward declarations
    381                         for ( Declaration * member : aggr->members ) {
    382                                 if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
    383                                         if ( StructDecl * aggr = dynamic_cast< StructDecl * >( member ) ) {
    384                                                 if ( aggr->name == inst->name ) {
    385                                                         return new StructInstType( qualType->get_qualifiers(), aggr );
    386                                                 }
    387                                         }
    388                                 } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
    389                                         if ( UnionDecl * aggr = dynamic_cast< UnionDecl * > ( member ) ) {
    390                                                 if ( aggr->name == inst->name ) {
    391                                                         return new UnionInstType( qualType->get_qualifiers(), aggr );
    392                                                 }
    393                                         }
    394                                 } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
    395                                         if ( EnumDecl * aggr = dynamic_cast< EnumDecl * > ( member ) ) {
    396                                                 if ( aggr->name == inst->name ) {
    397                                                         return new EnumInstType( qualType->get_qualifiers(), aggr );
    398                                                 }
    399                                         }
    400                                 } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
    401                                         // struct typedefs are being replaced by forward decls too early; move it to hoist struct
    402                                         if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
    403                                                 if ( aggr->name == inst->name ) {
    404                                                         assert( aggr->base );
    405                                                         return aggr->base->clone();
    406                                                 }
    407                                         }
    408                                 } else {
    409                                         // S.T - S is not an aggregate => error
    410                                         assertf( false, "unhandled qualified child type: %s", toCString(qualType) );
    411                                 }
    412                         }
    413                         // failed to find a satisfying definition of type
    414                         SemanticError( qualType->location, toString("Undefined type in qualified type: ", qualType) );
    415                 }
    416 
    417                 // ... may want to link canonical SUE definition to each forward decl so that it becomes easier to lookup?
    418         }
    419 
    420 
    421296        void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
    422297                PassVisitor<HoistStruct> hoister;
    … …  
    428303        }
    429304
    430         namespace {
    431                 void qualifiedName( AggregateDecl * aggr, std::ostringstream & ss ) {
    432                         if ( aggr->parent ) qualifiedName( aggr->parent, ss );
    433                         ss << "__" << aggr->name;
    434                 }
    435 
    436                 // mangle nested type names using entire parent chain
    437                 std::string qualifiedName( AggregateDecl * aggr ) {
    438                         std::ostringstream ss;
    439                         qualifiedName( aggr, ss );
    440                         return ss.str();
    441                 }
    442         }
    443 
    444305        template< typename AggDecl >
    445306        void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
    446307                if ( parentAggr ) {
    447                         aggregateDecl->parent = parentAggr;
    448                         aggregateDecl->name = qualifiedName( aggregateDecl );
    449308                        // Add elements in stack order corresponding to nesting structure.
    450309                        declsToAddBefore.push_front( aggregateDecl );
    … …  
    457316        }
    458317
     318        void HoistStruct::previsit( EnumInstType * inst ) {
     319                if ( inst->baseEnum && inst->baseEnum->body ) {
     320                        declsToAddBefore.push_front( inst->baseEnum );
     321                }
     322        }
     323
     324        void HoistStruct::previsit( StructInstType * inst ) {
     325                if ( inst->baseStruct && inst->baseStruct->body ) {
     326                        declsToAddBefore.push_front( inst->baseStruct );
     327                }
     328        }
     329
     330        void HoistStruct::previsit( UnionInstType * inst ) {
     331                if ( inst->baseUnion && inst->baseUnion->body ) {
     332                        declsToAddBefore.push_front( inst->baseUnion );
     333                }
     334        }
     335
    459336        void HoistStruct::previsit( StaticAssertDecl * assertDecl ) {
    460337                if ( parentAggr ) {
    … …  
    471348        }
    472349
    473         void HoistStruct::previsit( StructInstType * type ) {
    474                 // need to reset type name after expanding to qualified name
    475                 assert( type->baseStruct );
    476                 type->name = type->baseStruct->name;
    477         }
    478 
    479         void HoistStruct::previsit( UnionInstType * type ) {
    480                 assert( type->baseUnion );
    481                 type->name = type->baseUnion->name;
    482         }
    483 
    484         void HoistStruct::previsit( EnumInstType * type ) {
    485                 assert( type->baseEnum );
    486                 type->name = type->baseEnum->name;
    487         }
    488 
    489 
    490         bool isTypedef( Declaration *decl ) {
    491                 return dynamic_cast< TypedefDecl * >( decl );
    492         }
    493 
    494         void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
    495                 PassVisitor<EliminateTypedef> eliminator;
    496                 acceptAll( translationUnit, eliminator );
    497                 filter( translationUnit, isTypedef, true );
    498         }
    499 
    500         template< typename AggDecl >
    501         void EliminateTypedef::handleAggregate( AggDecl *aggregateDecl ) {
    502                 filter( aggregateDecl->members, isTypedef, true );
    503         }
    504 
    505         void EliminateTypedef::previsit( StructDecl * aggregateDecl ) {
    506                 handleAggregate( aggregateDecl );
    507         }
    508 
    509         void EliminateTypedef::previsit( UnionDecl * aggregateDecl ) {
    510                 handleAggregate( aggregateDecl );
    511         }
    512 
    513         void EliminateTypedef::previsit( CompoundStmt * compoundStmt ) {
    514                 // remove and delete decl stmts
    515                 filter( compoundStmt->kids, [](Statement * stmt) {
    516                         if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
    517                                 if ( dynamic_cast< TypedefDecl * >( declStmt->decl ) ) {
    518                                         return true;
    519                                 } // if
    520                         } // if
    521                         return false;
    522                 }, true);
    523         }
    524 
    525350        void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) {
    526351                // Set the type of each member of the enumeration to be EnumConstant
    527                 for ( std::list< Declaration * >::iterator i = enumDecl->members.begin(); i != enumDecl->members.end(); ++i ) {
     352                for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
    528353                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
    529354                        assert( obj );
    530                         obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->name ) );
     355                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
    531356                } // for
    532357        }
    … …  
    570395
    571396        void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
    572                 EnumDecl *st = local_indexer->lookupEnum( enumInst->name );
     397                EnumDecl *st = local_indexer->lookupEnum( enumInst->get_name() );
    573398                // it's not a semantic error if the enum is not found, just an implicit forward declaration
    574399                if ( st ) {
    575                         enumInst->baseEnum = st;
    576                 } // if
    577                 if ( ! st || ! st->body ) {
     400                        //assert( ! enumInst->get_baseEnum() || enumInst->get_baseEnum()->get_members().empty() || ! st->get_members().empty() );
     401                        enumInst->set_baseEnum( st );
     402                } // if
     403                if ( ! st || st->get_members().empty() ) {
    578404                        // use of forward declaration
    579                         forwardEnums[ enumInst->name ].push_back( enumInst );
     405                        forwardEnums[ enumInst->get_name() ].push_back( enumInst );
    580406                } // if
    581407        }
    … …  
    590416
    591417        void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
    592                 StructDecl *st = local_indexer->lookupStruct( structInst->name );
     418                StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
    593419                // it's not a semantic error if the struct is not found, just an implicit forward declaration
    594420                if ( st ) {
    595                         structInst->baseStruct = st;
    596                 } // if
    597                 if ( ! st || ! st->body ) {
     421                        //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
     422                        structInst->set_baseStruct( st );
     423                } // if
     424                if ( ! st || st->get_members().empty() ) {
    598425                        // use of forward declaration
    599                         forwardStructs[ structInst->name ].push_back( structInst );
     426                        forwardStructs[ structInst->get_name() ].push_back( structInst );
    600427                } // if
    601428                checkGenericParameters( structInst );
    … …  
    603430
    604431        void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
    605                 UnionDecl *un = local_indexer->lookupUnion( unionInst->name );
     432                UnionDecl *un = local_indexer->lookupUnion( unionInst->get_name() );
    606433                // it's not a semantic error if the union is not found, just an implicit forward declaration
    607434                if ( un ) {
    608                         unionInst->baseUnion = un;
    609                 } // if
    610                 if ( ! un || ! un->body ) {
     435                        unionInst->set_baseUnion( un );
     436                } // if
     437                if ( ! un || un->get_members().empty() ) {
    611438                        // use of forward declaration
    612                         forwardUnions[ unionInst->name ].push_back( unionInst );
     439                        forwardUnions[ unionInst->get_name() ].push_back( unionInst );
    613440                } // if
    614441                checkGenericParameters( unionInst );
    615         }
    616 
    617         void LinkReferenceToTypes::previsit( QualifiedType * ) {
    618                 visit_children = false;
    619         }
    620 
    621         void LinkReferenceToTypes::postvisit( QualifiedType * qualType ) {
    622                 // linking only makes sense for the 'oldest ancestor' of the qualified type
    623                 qualType->parent->accept( *visitor );
    624442        }
    625443
    … …  
    632450                        DeclarationWithType * dwt2 = dynamic_cast<DeclarationWithType *>( d2 );
    633451                        if ( dwt1 && dwt2 ) {
    634                                 if ( dwt1->name == dwt2->name && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
     452                                if ( dwt1->get_name() == dwt2->get_name() && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
    635453                                        // std::cerr << "=========== equal:" << std::endl;
    636454                                        // std::cerr << "d1: " << d1 << std::endl;
    … …  
    657475        template< typename Iterator >
    658476        void expandAssertions( TraitInstType * inst, Iterator out ) {
    659                 assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toCString( inst ) );
     477                assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toString( inst ).c_str() );
    660478                std::list< DeclarationWithType * > asserts;
    661479                for ( Declaration * decl : inst->baseTrait->members ) {
    … …  
    694512                        SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
    695513                } // if
    696                 if ( traitDecl->parameters.size() != traitInst->parameters.size() ) {
     514                if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
    697515                        SemanticError( traitInst, "incorrect number of trait parameters: " );
    698516                } // if
    … …  
    700518
    701519                // need to carry over the 'sized' status of each decl in the instance
    702                 for ( auto p : group_iterate( traitDecl->parameters, traitInst->parameters ) ) {
     520                for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
    703521                        TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
    704522                        if ( ! expr ) {
    … …  
    707525                        if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
    708526                                TypeDecl * formalDecl = std::get<0>(p);
    709                                 TypeDecl * instDecl = inst->baseType;
     527                                TypeDecl * instDecl = inst->get_baseType();
    710528                                if ( formalDecl->get_sized() ) instDecl->set_sized( true );
    711529                        }
    … …  
    716534        void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
    717535                // visit enum members first so that the types of self-referencing members are updated properly
    718                 if ( enumDecl->body ) {
    719                         ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->name );
     536                if ( ! enumDecl->get_members().empty() ) {
     537                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->get_name() );
    720538                        if ( fwds != forwardEnums.end() ) {
    721539                                for ( std::list< EnumInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    722                                         (*inst)->baseEnum = enumDecl;
     540                                        (*inst )->set_baseEnum( enumDecl );
    723541                                } // for
    724542                                forwardEnums.erase( fwds );
    … …  
    756574                // visit struct members first so that the types of self-referencing members are updated properly
    757575                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
    758                 if ( structDecl->body ) {
    759                         ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->name );
     576                if ( ! structDecl->get_members().empty() ) {
     577                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
    760578                        if ( fwds != forwardStructs.end() ) {
    761579                                for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    762                                         (*inst)->baseStruct = structDecl;
     580                                        (*inst )->set_baseStruct( structDecl );
    763581                                } // for
    764582                                forwardStructs.erase( fwds );
    … …  
    768586
    769587        void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
    770                 if ( unionDecl->body ) {
    771                         ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->name );
     588                if ( ! unionDecl->get_members().empty() ) {
     589                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
    772590                        if ( fwds != forwardUnions.end() ) {
    773591                                for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    774                                         (*inst)->baseUnion = unionDecl;
     592                                        (*inst )->set_baseUnion( unionDecl );
    775593                                } // for
    776594                                forwardUnions.erase( fwds );
    … …  
    782600                // ensure generic parameter instances are renamed like the base type
    783601                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
    784                 if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->name ) ) {
     602                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
    785603                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
    786604                                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
    … …  
    861679
    862680
    863         void ReplaceTypedef::replaceTypedef( std::list< Declaration * > &translationUnit ) {
    864                 PassVisitor<ReplaceTypedef> eliminator;
     681        bool isTypedef( Declaration *decl ) {
     682                return dynamic_cast< TypedefDecl * >( decl );
     683        }
     684
     685        void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
     686                PassVisitor<EliminateTypedef> eliminator;
    865687                mutateAll( translationUnit, eliminator );
    866688                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
    867689                        // grab and remember declaration of size_t
    868                         SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
     690                        SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
    869691                } else {
    870692                        // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
    … …  
    872694                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
    873695                }
    874         }
    875 
    876         void ReplaceTypedef::premutate( QualifiedType * ) {
    877                 visit_children = false;
    878         }
    879 
    880         Type * ReplaceTypedef::postmutate( QualifiedType * qualType ) {
    881                 // replacing typedefs only makes sense for the 'oldest ancestor' of the qualified type
    882                 qualType->parent = qualType->parent->acceptMutator( *visitor );
    883                 return qualType;
    884         }
    885 
    886         Type * ReplaceTypedef::postmutate( TypeInstType * typeInst ) {
     696                filter( translationUnit, isTypedef, true );
     697        }
     698
     699        Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) {
    887700                // instances of typedef types will come here. If it is an instance
    888701                // of a typdef type, link the instance to its actual type.
    889                 TypedefMap::const_iterator def = typedefNames.find( typeInst->name );
     702                TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
    890703                if ( def != typedefNames.end() ) {
    891704                        Type *ret = def->second.first->base->clone();
    892                         ret->location = typeInst->location;
    893705                        ret->get_qualifiers() |= typeInst->get_qualifiers();
    894706                        // attributes are not carried over from typedef to function parameters/return values
    … …  
    905717                                        SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
    906718                                }
    907                                 rtt->parameters.clear();
     719                                rtt->get_parameters().clear();
    908720                                cloneAll( typeInst->parameters, rtt->parameters );
    909721                                mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
    … …  
    912724                        return ret;
    913725                } else {
    914                         TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->name );
    915                         if ( base == typedeclNames.end() ) {
    916                                 SemanticError( typeInst->location, toString("Use of undefined type ", typeInst->name) );
    917                         }
     726                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() );
     727                        assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->name.c_str() );
    918728                        typeInst->set_baseType( base->second );
    919                         return typeInst;
    920                 } // if
    921                 assert( false );
     729                } // if
     730                return typeInst;
    922731        }
    923732
    … …  
    936745        }
    937746
    938         Declaration * ReplaceTypedef::postmutate( TypedefDecl * tyDecl ) {
    939                 if ( typedefNames.count( tyDecl->name ) == 1 && typedefNames[ tyDecl->name ].second == scopeLevel ) {
     747        Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
     748                if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
    940749                        // typedef to the same name from the same scope
    941750                        // must be from the same type
    942751
    943                         Type * t1 = tyDecl->base;
    944                         Type * t2 = typedefNames[ tyDecl->name ].first->base;
     752                        Type * t1 = tyDecl->get_base();
     753                        Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
    945754                        if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
    946755                                SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
    … …  
    954763                        }
    955764                } else {
    956                         typedefNames[ tyDecl->name ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
     765                        typedefNames[ tyDecl->get_name() ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
    957766                } // if
    958767
    … …  
    966775                // Note, qualifiers on the typedef are superfluous for the forward declaration.
    967776
    968                 Type *designatorType = tyDecl->base->stripDeclarator();
     777                Type *designatorType = tyDecl->get_base()->stripDeclarator();
    969778                if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
    970                         declsToAddBefore.push_back( new StructDecl( aggDecl->name, DeclarationNode::Struct, noAttributes, tyDecl->linkage ) );
     779                        return new StructDecl( aggDecl->get_name(), DeclarationNode::Struct, noAttributes, tyDecl->get_linkage() );
    971780                } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
    972                         declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
     781                        return new UnionDecl( aggDecl->get_name(), noAttributes, tyDecl->get_linkage() );
    973782                } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
    974                         declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) );
    975                 } // if
    976                 return tyDecl->clone();
    977         }
    978 
    979         void ReplaceTypedef::premutate( TypeDecl * typeDecl ) {
    980                 TypedefMap::iterator i = typedefNames.find( typeDecl->name );
     783                        return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
     784                } else {
     785                        return tyDecl->clone();
     786                } // if
     787        }
     788
     789        void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
     790                TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
    981791                if ( i != typedefNames.end() ) {
    982792                        typedefNames.erase( i ) ;
    983793                } // if
    984794
    985                 typedeclNames.insert( typeDecl->name, typeDecl );
    986         }
    987 
    988         void ReplaceTypedef::premutate( FunctionDecl * ) {
     795                typedeclNames[ typeDecl->get_name() ] = typeDecl;
     796        }
     797
     798        void EliminateTypedef::premutate( FunctionDecl * ) {
    989799                GuardScope( typedefNames );
    990                 GuardScope( typedeclNames );
    991         }
    992 
    993         void ReplaceTypedef::premutate( ObjectDecl * ) {
     800        }
     801
     802        void EliminateTypedef::premutate( ObjectDecl * ) {
    994803                GuardScope( typedefNames );
    995                 GuardScope( typedeclNames );
    996         }
    997 
    998         DeclarationWithType * ReplaceTypedef::postmutate( ObjectDecl * objDecl ) {
    999                 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->type ) ) { // function type?
     804        }
     805
     806        DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
     807                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
    1000808                        // replace the current object declaration with a function declaration
    1001                         FunctionDecl * newDecl = new FunctionDecl( objDecl->name, objDecl->get_storageClasses(), objDecl->linkage, funtype, 0, objDecl->attributes, objDecl->get_funcSpec() );
    1002                         objDecl->attributes.clear();
     809                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
     810                        objDecl->get_attributes().clear();
    1003811                        objDecl->set_type( nullptr );
    1004812                        delete objDecl;
    … …  
    1008816        }
    1009817
    1010         void ReplaceTypedef::premutate( CastExpr * ) {
     818        void EliminateTypedef::premutate( CastExpr * ) {
    1011819                GuardScope( typedefNames );
    1012                 GuardScope( typedeclNames );
    1013         }
    1014 
    1015         void ReplaceTypedef::premutate( CompoundStmt * ) {
     820        }
     821
     822        void EliminateTypedef::premutate( CompoundStmt * ) {
    1016823                GuardScope( typedefNames );
    1017                 GuardScope( typedeclNames );
    1018824                scopeLevel += 1;
    1019825                GuardAction( [this](){ scopeLevel -= 1; } );
    1020826        }
    1021827
     828        CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
     829                // remove and delete decl stmts
     830                filter( compoundStmt->kids, [](Statement * stmt) {
     831                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
     832                                if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
     833                                        return true;
     834                                } // if
     835                        } // if
     836                        return false;
     837                }, true);
     838                return compoundStmt;
     839        }
     840
     841        // there may be typedefs nested within aggregates. in order for everything to work properly, these should be removed
     842        // as well
    1022843        template<typename AggDecl>
    1023         void ReplaceTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
     844        AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
     845                filter( aggDecl->members, isTypedef, true );
     846                return aggDecl;
     847        }
     848
     849        template<typename AggDecl>
     850        void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
    1024851                if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
    1025852                        Type *type = nullptr;
    … …  
    1033860                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type, aggDecl->get_linkage() ) );
    1034861                        typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
    1035                         // add the implicit typedef to the AST
    1036                         declsToAddBefore.push_back( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type->clone(), aggDecl->get_linkage() ) );
    1037                 } // if
    1038         }
    1039 
    1040         template< typename AggDecl >
    1041         void ReplaceTypedef::handleAggregate( AggDecl * aggr ) {
    1042                 SemanticErrorException errors;
    1043 
    1044                 ValueGuard< std::list<Declaration * > > oldBeforeDecls( declsToAddBefore );
    1045                 ValueGuard< std::list<Declaration * > > oldAfterDecls ( declsToAddAfter  );
    1046                 declsToAddBefore.clear();
    1047                 declsToAddAfter.clear();
    1048 
    1049                 GuardScope( typedefNames );
    1050                 GuardScope( typedeclNames );
    1051                 mutateAll( aggr->parameters, *visitor );
    1052 
    1053                 // unroll mutateAll for aggr->members so that implicit typedefs for nested types are added to the aggregate body.
    1054                 for ( std::list< Declaration * >::iterator i = aggr->members.begin(); i != aggr->members.end(); ++i ) {
    1055                         if ( !declsToAddAfter.empty() ) { aggr->members.splice( i, declsToAddAfter ); }
    1056 
    1057                         try {
    1058                                 *i = maybeMutate( *i, *visitor );
    1059                         } catch ( SemanticErrorException &e ) {
    1060                                 errors.append( e );
    1061                         }
    1062 
    1063                         if ( !declsToAddBefore.empty() ) { aggr->members.splice( i, declsToAddBefore ); }
    1064                 }
    1065 
    1066                 if ( !declsToAddAfter.empty() ) { aggr->members.splice( aggr->members.end(), declsToAddAfter ); }
    1067                 if ( !errors.isEmpty() ) { throw errors; }
    1068         }
    1069 
    1070         void ReplaceTypedef::premutate( StructDecl * structDecl ) {
    1071                 visit_children = false;
     862                } // if
     863        }
     864
     865        void EliminateTypedef::premutate( StructDecl * structDecl ) {
    1072866                addImplicitTypedef( structDecl );
    1073                 handleAggregate( structDecl );
    1074         }
    1075 
    1076         void ReplaceTypedef::premutate( UnionDecl * unionDecl ) {
    1077                 visit_children = false;
     867        }
     868
     869
     870        Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
     871                return handleAggregate( structDecl );
     872        }
     873
     874        void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
    1078875                addImplicitTypedef( unionDecl );
    1079                 handleAggregate( unionDecl );
    1080         }
    1081 
    1082         void ReplaceTypedef::premutate( EnumDecl * enumDecl ) {
     876        }
     877
     878        Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
     879                return handleAggregate( unionDecl );
     880        }
     881
     882        void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
    1083883                addImplicitTypedef( enumDecl );
    1084884        }
    1085885
    1086         void ReplaceTypedef::premutate( FunctionType * ) {
     886        Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
     887                return handleAggregate( enumDecl );
     888        }
     889
     890        Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
     891                return handleAggregate( traitDecl );
     892        }
     893
     894        void EliminateTypedef::premutate( FunctionType * ) {
    1087895                GuardValue( inFunctionType );
    1088896                inFunctionType = true;
    1089         }
    1090 
    1091         void ReplaceTypedef::premutate( TraitDecl * ) {
    1092                 GuardScope( typedefNames );
    1093                 GuardScope( typedeclNames);
    1094897        }
    1095898
    … …  
    12211024
    12221025        void ArrayLength::previsit( ObjectDecl * objDecl ) {
    1223                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
     1026                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
    12241027                        if ( at->get_dimension() ) return;
    1225                         if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->init ) ) {
    1226                                 at->set_dimension( new ConstantExpr( Constant::from_ulong( init->initializers.size() ) ) );
     1028                        if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->get_init() ) ) {
     1029                                at->set_dimension( new ConstantExpr( Constant::from_ulong( init->get_initializers().size() ) ) );
    12271030                        }
    12281031                }
Note: See TracChangeset for help on using the changeset viewer.