Changes in src/ResolvExpr/CastCost.cc [c6b4432:251ce80]

File:

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

src/ResolvExpr/CastCost.cc

@@ -26 +26 @@
 #include "ResolvExpr/ConversionCost.h"   // for conversionCost
 #include "ResolvExpr/PtrsCastable.hpp"   // for ptrsCastable
+#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment, EqvClass
 #include "ResolvExpr/typeops.h"          // for ptrsCastable
 #include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
+#include "SymTab/Indexer.h"              // for Indexer
+#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
+#include "SynTree/Type.h"                // for PointerType, Type, TypeInstType
 
 #if 0
@@ -36 +40 @@
 
 namespace ResolvExpr {
+        struct CastCost_old : public ConversionCost {
+          public:
+                CastCost_old( const Type * dest, bool srcIsLvalue,
+                        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 );
+        };
+
+        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
+                        const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
+                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
+                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
+                                if ( eqvClass->type ) {
+                                        return castCost( src, eqvClass->type, srcIsLvalue, indexer, env );
+                                } else {
+                                        return Cost::infinity;
+                                }
+                        } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
+                                // all typedefs should be gone by this point
+                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
+                                if ( type->base ) {
+                                        return castCost( src, type->base, srcIsLvalue, indexer, env ) + Cost::safe;
+                                } // if
+                        } // if
+                } // if
+
+                PRINT(
+                        std::cerr << "castCost ::: src is ";
+                        src->print( std::cerr );
+                        std::cerr << std::endl << "dest is ";
+                        dest->print( std::cerr );
+                        std::cerr << std::endl << "env is" << std::endl;
+                        env.print( std::cerr, 8 );
+                )
+
+                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
+                        PRINT( std::cerr << "compatible!" << std::endl; )
+                        return Cost::zero;
+                } else if ( dynamic_cast< const VoidType * >( dest ) ) {
+                        return Cost::safe;
+                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
+                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
+                        return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                                return ptrsCastable( t1, t2, env, indexer );
+                        });
+                } else {
+                        PassVisitor<CastCost_old> converter(
+                                dest, srcIsLvalue, indexer, env,
+                                (Cost (*)( const Type *, const Type *, bool, const SymTab::Indexer &, const TypeEnvironment & ))
+                                        castCost );
+                        src->accept( converter );
+                        if ( converter.pass.get_cost() == Cost::infinity ) {
+                                return Cost::infinity;
+                        } else {
+                                // xxx - why are we adding cost 0 here?
+                                return converter.pass.get_cost() + Cost::zero;
+                        } // if
+                } // if
+        }
+
+        CastCost_old::CastCost_old( const Type * dest, bool srcIsLvalue,
+                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : ConversionCost( dest, srcIsLvalue, indexer, env, costFunc ) {
+        }
+
+        void CastCost_old::postvisit( const BasicType * basicType ) {
+                const PointerType * destAsPointer = dynamic_cast< const PointerType * >( dest );
+                if ( destAsPointer && basicType->isInteger() ) {
+                        // necessary for, e.g. unsigned long => void *
+                        cost = Cost::unsafe;
+                } else {
+                        cost = conversionCost( basicType, dest, srcIsLvalue, indexer, env );
+                } // if
+        }
+
+        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 ) ) {
+                                cost = Cost::safe;
+                        } else {
+                                TypeEnvironment newEnv( env );
+                                newEnv.add( pointerType->forall );
+                                newEnv.add( pointerType->base->forall );
+                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
+                                if ( castResult > 0 ) {
+                                        cost = Cost::safe;
+                                } else if ( castResult < 0 ) {
+                                        cost = Cost::infinity;
+                                } // if
+                        } // if
+                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
+                        if ( destAsBasic->isInteger() ) {
+                                // necessary for, e.g. void * => unsigned long
+                                cost = Cost::unsafe;
+                        } // if
+                }
+        }
 
 namespace {
@@ -96 +200 @@
 } // anonymous namespace
 
+
+
 Cost castCost(
         const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
@@ -128 +234 @@
         if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 PRINT( std::cerr << "compatible!" << std::endl; )
-                if (dynamic_cast<const ast::ZeroType *>(dst) || dynamic_cast<const ast::OneType *>(dst)) {
-                        return Cost::spec;
-                }
                 return Cost::zero;
         } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {