Changeset f53acdf8 for src/ResolvExpr/PtrsCastable.cc

Timestamp:

Jul 19, 2019, 2:16:01 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

4eb43fa

Parents:

1f1c102 (diff), 8ac3b0e (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' into new-ast

File:

• src/ResolvExpr/PtrsCastable.cc (modified) (9 diffs)

src/ResolvExpr/PtrsCastable.cc

@@ -29 +29 @@
         struct PtrsCastable_old : public WithShortCircuiting  {
           public:
-                PtrsCastable_old( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
+                PtrsCastable_old( const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
 
                 int get_result() const { return result; }
 
-                void previsit( Type * ) { visit_children = false; }
-
-                void postvisit( VoidType * voidType );
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
-                void postvisit( ArrayType * arrayType );
-                void postvisit( FunctionType * functionType );
-                void postvisit( StructInstType * inst );
-                void postvisit( UnionInstType * inst );
-                void postvisit( EnumInstType * inst );
-                void postvisit( TraitInstType * inst );
-                void postvisit( TypeInstType * inst );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
+                void previsit( const Type * ) { visit_children = false; }
+
+                void postvisit( const VoidType * voidType );
+                void postvisit( const BasicType * basicType );
+                void postvisit( const PointerType * pointerType );
+                void postvisit( const ArrayType * arrayType );
+                void postvisit( const FunctionType * functionType );
+                void postvisit( const StructInstType * inst );
+                void postvisit( const UnionInstType * inst );
+                void postvisit( const EnumInstType * inst );
+                void postvisit( const TraitInstType * inst );
+                void postvisit( const TypeInstType * inst );
+                void postvisit( const TupleType * tupleType );
+                void postvisit( const VarArgsType * varArgsType );
+                void postvisit( const ZeroType * zeroType );
+                void postvisit( const OneType * oneType );
           private:
-                Type *dest;
+                const Type * dest;
                 int result;
                 const TypeEnvironment &env;
@@ -57 +57 @@
 
         namespace {
-                int objectCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-                        if ( dynamic_cast< FunctionType* >( src ) ) {
+                int objectCast( const Type * src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                        if ( dynamic_cast< const FunctionType* >( src ) ) {
                                 return -1;
-                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) {
-                                if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
-                                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
-                                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
+                        } else if ( const TypeInstType * typeInst = dynamic_cast< const TypeInstType* >( src ) ) {
+                                if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->name ) ) {
+                                        if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl* >( ntDecl ) ) {
+                                                if ( tyDecl->kind == TypeDecl::Ftype ) {
                                                         return -1;
                                                 } // if
                                         } //if
-                                } else if ( const EqvClass *eqvClass = env.lookup( typeInst->get_name() ) ) {
+                                } else if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) {
                                         if ( eqvClass->data.kind == TypeDecl::Ftype ) {
                                                 return -1;
@@ -75 +75 @@
                         return 1;
                 }
-                int functionCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                int functionCast( const Type * src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
                         return -1 * objectCast( src, env, indexer );  // reverse the sense of objectCast
                 }
         }
 
-        int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
+        int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
+                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
                                 // xxx - should this be ptrsCastable?
                                 return ptrsAssignable( src, eqvClass->type, env );
                         } // if
                 } // if
-                if ( dynamic_cast< VoidType* >( dest ) ) {
+                if ( dynamic_cast< const VoidType* >( dest ) ) {
                         return objectCast( src, env, indexer );
                 } else {
@@ -96 +96 @@
         }
 
-        PtrsCastable_old::PtrsCastable_old( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer )
+        PtrsCastable_old::PtrsCastable_old( const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer )
                 : dest( dest ), result( 0 ), env( env ), indexer( indexer )     {
         }
 
-        void PtrsCastable_old::postvisit( VoidType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( BasicType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( PointerType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( ArrayType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( FunctionType * ) {
+        void PtrsCastable_old::postvisit( const VoidType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const BasicType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const PointerType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const ArrayType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const FunctionType * ) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( StructInstType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( UnionInstType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( EnumInstType * ) {
-                if ( dynamic_cast< EnumInstType* >( dest ) ) {
+        void PtrsCastable_old::postvisit( const StructInstType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const UnionInstType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const EnumInstType * ) {
+                if ( dynamic_cast< const EnumInstType * >( dest ) ) {
                         result = 1;
-                } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) {
-                        if ( bt->get_kind() == BasicType::SignedInt ) {
+                } else if ( const BasicType * bt = dynamic_cast< const BasicType * >( dest ) ) {
+                        if ( bt->kind == BasicType::SignedInt ) {
                                 result = 0;
                         } else {
@@ -143 +143 @@
         }
 
-        void PtrsCastable_old::postvisit( TraitInstType * ) {}
-
-        void PtrsCastable_old::postvisit(TypeInstType *inst ) {
+        void PtrsCastable_old::postvisit( const TraitInstType * ) {}
+
+        void PtrsCastable_old::postvisit( const TypeInstType *inst ) {
                 //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
                 result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1;
         }
 
-        void PtrsCastable_old::postvisit( TupleType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( VarArgsType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( ZeroType * ) {
-                result = objectCast( dest, env, indexer );
-        }
-
-        void PtrsCastable_old::postvisit( OneType * ) {
+        void PtrsCastable_old::postvisit( const TupleType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const VarArgsType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const ZeroType * ) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable_old::postvisit( const OneType * ) {
                 result = objectCast( dest, env, indexer );
         }
@@ -168 +168 @@
 namespace {
         // can this type be cast to an object (1 for yes, -1 for no)
-        int objectCast( 
-                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab 
+        int objectCast(
+                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
         ) {
                 if ( dynamic_cast< const ast::FunctionType * >( src ) ) {
@@ -191 +191 @@
 
         // can this type be cast to a function (inverse of objectCast)
-        int functionCast( 
-                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab 
+        int functionCast(
+                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
         ) {
                 return -1 * objectCast( src, env, symtab );
@@ -204 +204 @@
                 int result;
 
-                PtrsCastable_new( 
+                PtrsCastable_new(
                         const ast::Type * d, const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
                 : dst( d ), env( e ), symtab( syms ), result( 0 ) {}
@@ -278 +278 @@
 } // anonymous namespace
 
-int ptrsCastable( 
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
-        const ast::TypeEnvironment & env 
+int ptrsCastable(
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
 ) {
         if ( auto inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {