Changeset e5d9274 for src/ResolvExpr/ConversionCost.cc

Timestamp:

Jun 2, 2022, 3:11:21 PM (3 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

ced5e2a

Parents:

015925a (diff), fc134a48 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -321 +321 @@
         }
 
+        // refactor for code resue
+        void ConversionCost::conversionCostFromBasicToBasic(const BasicType * src, const BasicType * dest) {
+                int tableResult = costMatrix[ src->kind ][ dest->kind ];
+                if ( tableResult == -1 ) {
+                        cost = Cost::unsafe;
+                } else {
+                        cost = Cost::zero;
+                        cost.incSafe( tableResult );
+                        cost.incSign( signMatrix[ src->kind ][ dest->kind ] );
+                } // if
+        } // ConversionCost::conversionCostFromBasicToBasic
+
         void ConversionCost::postvisit(const BasicType * basicType) {
                 if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
-                        int tableResult = costMatrix[ basicType->kind ][ destAsBasic->kind ];
-                        if ( tableResult == -1 ) {
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = Cost::zero;
-                                cost.incSafe( tableResult );
-                                cost.incSign( signMatrix[ basicType->kind ][ destAsBasic->kind ] );
-                        } // if
-                } else if ( dynamic_cast< const EnumInstType * >( dest ) ) {
-                        // xxx - not positive this is correct, but appears to allow casting int => enum
-                        // TODO
-                        EnumDecl * decl = dynamic_cast< const EnumInstType * >( dest )->baseEnum;
-                        if ( decl->base ) {
-                                cost = Cost::infinity;
+                        conversionCostFromBasicToBasic(basicType, destAsBasic);
+                } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * >( dest ) ) {
+                        const EnumDecl * base_enum = enumInst->baseEnum;
+                        if ( const Type * base = base_enum->base ) { // if the base enum has a base (if it is typed)
+                                if ( const BasicType * enumBaseAstBasic = dynamic_cast< const BasicType *> (base) ) {
+                                        conversionCostFromBasicToBasic(basicType, enumBaseAstBasic);
+                                } else {
+                                        cost = Cost::infinity;
+                                } // if
                         } else {
                                 cost = Cost::unsafe;
@@ -398 +405 @@
         void ConversionCost::postvisit( const FunctionType * ) {}
 
-        void ConversionCost::postvisit( const EnumInstType * ) {
-                static Type::Qualifiers q;
-                static BasicType integer( q, BasicType::SignedInt );
-                cost = costFunc( &integer, dest, srcIsLvalue, indexer, env );  // safe if dest >= int
+        void ConversionCost::postvisit( const EnumInstType * enumInst) {
+                const EnumDecl * enumDecl = enumInst -> baseEnum;
+                if ( const Type * enumType = enumDecl -> base ) { // if it is a typed enum
+                        cost = costFunc( enumType, dest, srcIsLvalue, indexer, env );
+                } else {
+                        static Type::Qualifiers q;
+                        static BasicType integer( q, BasicType::SignedInt );
+                        cost = costFunc( &integer, dest, srcIsLvalue, indexer, env );  // safe if dest >= int
+                } // if
                 if ( cost < Cost::unsafe ) {
-                        cost.incSafe();
+                                cost.incSafe();
                 } // if
         }
@@ -604 +616 @@
 }
 
+void ConversionCost_new::conversionCostFromBasicToBasic( const ast::BasicType * src, const ast::BasicType* dest ) {
+        int tableResult = costMatrix[ src->kind ][ dest->kind ];
+        if ( tableResult == -1 ) {
+                cost = Cost::unsafe;
+        } else {
+                cost = Cost::zero;
+                cost.incSafe( tableResult );
+                cost.incSign( signMatrix[ src->kind ][ dest->kind ] );
+        }
+}
+
 void ConversionCost_new::postvisit( const ast::BasicType * basicType ) {
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
-                int tableResult = costMatrix[ basicType->kind ][ dstAsBasic->kind ];
-                if ( tableResult == -1 ) {
-                        cost = Cost::unsafe;
-                } else {
-                        cost = Cost::zero;
-                        cost.incSafe( tableResult );
-                        cost.incSign( signMatrix[ basicType->kind ][ dstAsBasic->kind ] );
-                }
-        } else if ( dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                // xxx - not positive this is correct, but appears to allow casting int => enum
-                const ast::EnumDecl * decl = (dynamic_cast< const ast::EnumInstType * >( dst ))->base.get();
-                if ( decl->base ) {
-                        cost = Cost::infinity;
-                } else {
-                        cost = Cost::unsafe;
-                } // if
+                conversionCostFromBasicToBasic( basicType, dstAsBasic );
+        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+                const ast::EnumDecl * enumDecl = enumInst->base.get();
+                if ( const ast::Type * enumType = enumDecl->base.get() ) {
+                        if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast<const ast::BasicType *>(enumType) ) {
+                                conversionCostFromBasicToBasic( basicType, enumTypeAsBasic );
+                        } else {
+                                cost = Cost::infinity;
+                        }
+                } else {
+            cost = Cost::unsafe;
+                }
         }
 }
@@ -673 +692 @@
 
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
-        (void)enumInstType;
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        const ast::EnumDecl * baseEnum = enumInstType->base;
+        if ( const ast::Type * baseType = baseEnum->base ) {
+                cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
+        } else {
+                (void)enumInstType;
+                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+                cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        }
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();