Changes in src/ResolvExpr/PtrsCastable.cc [c6b4432:5bf3976]

File:

• src/ResolvExpr/PtrsCastable.cc (modified) (1 diff)

src/ResolvExpr/PtrsCastable.cc

@@ -20 +20 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
+#include "Common/PassVisitor.h"
 #include "ResolvExpr/PtrsAssignable.hpp" // for ptrsAssignable
+#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
+#include "SymTab/Indexer.h"              // for Indexer
+#include "SynTree/Declaration.h"         // for TypeDecl, TypeDecl::Kind::Ftype
+#include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
+#include "SynTree/Visitor.h"             // for Visitor
 
 namespace ResolvExpr {
+        struct PtrsCastable_old : public WithShortCircuiting  {
+          public:
+                PtrsCastable_old( const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
+
+                int get_result() const { return result; }
+
+                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:
+                const Type * dest;
+                int result;
+                const TypeEnvironment &env;
+                const SymTab::Indexer &indexer;
+        };
+
+        namespace {
+                int objectCast( const Type * src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                        if ( dynamic_cast< const FunctionType* >( src ) ) {
+                                return -1;
+                        } 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() ) ) {
+                                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
+                                                return -1;
+                                        } // if
+                                } // if
+                        } //if
+                        return 1;
+                }
+                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( 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< const VoidType* >( dest ) ) {
+                        return objectCast( src, env, indexer );
+                } else {
+                        PassVisitor<PtrsCastable_old> ptrs( dest, env, indexer );
+                        src->accept( ptrs );
+                        return ptrs.pass.get_result();
+                } // if
+        }
+
+        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( 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( 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 ( const BasicType * bt = dynamic_cast< const BasicType * >( dest ) ) {
+                        if ( bt->kind == BasicType::SignedInt ) {
+                                result = 0;
+                        } else {
+                                result = 1;
+                        }
+                } else {
+                        result = objectCast( dest, env, indexer );
+                }
+        }
+
+        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( 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 );
+        }
 
 namespace {