Changes in src/ResolvExpr/CastCost.cc [ef5b828:3c89751]

File:

• src/ResolvExpr/CastCost.cc (modified) (10 diffs)

src/ResolvExpr/CastCost.cc

@@ -37 +37 @@
         struct CastCost_old : public ConversionCost {
           public:
-                CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
+                CastCost_old( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
 
                 using ConversionCost::previsit;
                 using ConversionCost::postvisit;
-                void postvisit( const BasicType * basicType );
-                void postvisit( const PointerType * pointerType );
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
         };
 
-        Cost castCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
-                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
+        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
+                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
+                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
                                 if ( eqvClass->type ) {
                                         return castCost( src, eqvClass->type, indexer, env );
@@ -53 +53 @@
                                         return Cost::infinity;
                                 }
-                        } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
+                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) {
                                 // all typedefs should be gone by this point
-                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
+                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
                                 if ( type->base ) {
                                         return castCost( src, type->base, indexer, env ) + Cost::safe;
@@ -74 +74 @@
                         PRINT( std::cerr << "compatible!" << std::endl; )
                         return Cost::zero;
-                } else if ( dynamic_cast< const VoidType * >( dest ) ) {
+                } else if ( dynamic_cast< VoidType* >( dest ) ) {
                         return Cost::safe;
-                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
                                 return ptrsCastable( t1, t2, env, indexer );
                         });
                 } else {
-                        PassVisitor<CastCost_old> converter(
-                                dest, indexer, env,
-                                (Cost (*)( const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment & ))
+                        PassVisitor<CastCost_old> converter( 
+                                dest, indexer, env, 
+                                (Cost (*)( Type *, Type *, const SymTab::Indexer &, const TypeEnvironment & ))
                                         castCost );
                         src->accept( converter );
@@ -96 +96 @@
         }
 
-        CastCost_old::CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+        CastCost_old::CastCost_old( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
                 : ConversionCost( dest, indexer, env, costFunc ) {
         }
 
-        void CastCost_old::postvisit( const BasicType * basicType ) {
-                const PointerType * destAsPointer = dynamic_cast< const PointerType * >( dest );
+        void CastCost_old::postvisit( BasicType *basicType ) {
+                PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
-                        // necessary for, e.g. unsigned long => void *
+                        // necessary for, e.g. unsigned long => void*
                         cost = Cost::unsafe;
                 } else {
@@ -110 +110 @@
         }
 
-        void CastCost_old::postvisit( const PointerType * pointerType ) {
-                if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
-                        if ( pointerType->tq <= destAsPtr->tq && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
+        void CastCost_old::postvisit( PointerType *pointerType ) {
+                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
+                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 cost = Cost::safe;
                         } else {
@@ -125 +125 @@
                                 } // if
                         } // if
-                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
+                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
                         if ( destAsBasic->isInteger() ) {
-                                // necessary for, e.g. void * => unsigned long
+                                // necessary for, e.g. void* => unsigned long
                                 cost = Cost::unsafe;
                         } // if
@@ -138 +138 @@
                 using ConversionCost_new::postvisit;
 
-                CastCost_new(
-                        const ast::Type * dst, const ast::SymbolTable & symtab,
+                CastCost_new( 
+                        const ast::Type * dst, const ast::SymbolTable & symtab, 
                         const ast::TypeEnvironment & env, CostCalculation costFunc )
                 : ConversionCost_new( dst, symtab, env, costFunc ) {}
@@ -182 +182 @@
 } // anonymous namespace
 
-Cost castCost(
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-        const ast::TypeEnvironment & env
+Cost castCost( 
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
+        const ast::TypeEnvironment & env 
 ) {
         if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -220 +220 @@
                 PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
                 #warning cast on ptrsCastable artifact of having two functions, remove when port done
-                return convertToReferenceCost(
-                        src, refType, symtab, env,
-                        ( int (*)(
-                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
+                return convertToReferenceCost( 
+                        src, refType, symtab, env, 
+                        ( int (*)( 
+                                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
                                 const ast::TypeEnvironment & )
                         ) ptrsCastable );
@@ -229 +229 @@
                 #warning cast on castCost artifact of having two functions, remove when port done
                 ast::Pass< CastCost_new > converter{
-                        dst, symtab, env,
-                        ( Cost (*)(
-                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
+                        dst, symtab, env, 
+                        ( Cost (*)( 
+                                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
                                 const ast::TypeEnvironment & )
                         ) castCost };