Changeset 9c23f31 for src/ResolvExpr

Timestamp:

Sep 24, 2016, 12:19:33 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, stuck-waitfor-destruct, with_gc

Children:

3b5e3aa

Parents:

2298f728 (diff), 7ae930a (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:

fix conflicts

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (2 diffs)
• AlternativeFinder.cc (modified) (6 diffs)
• AlternativeFinder.h (modified) (3 diffs)
• CommonType.cc (modified) (5 diffs)
• ConversionCost.cc (modified) (3 diffs)
• ConversionCost.h (modified) (1 diff)
• PtrsAssignable.cc (modified) (2 diffs)
• PtrsCastable.cc (modified) (2 diffs)
• RenameVars.cc (modified) (1 diff)
• RenameVars.h (modified) (1 diff)
• Resolver.cc (modified) (2 diffs)
• Unify.cc (modified) (2 diffs)

src/ResolvExpr/AdjustExprType.cc

@@ -37 +37 @@
                 virtual Type* mutate( TupleType *tupleType );
                 virtual Type* mutate( VarArgsType *varArgsType );
+                virtual Type* mutate( ZeroType *zeroType );
+                virtual Type* mutate( OneType *oneType );
 
                 const TypeEnvironment &env;
@@ -117 +119 @@
                 return varArgsType;
         }
+
+        Type *AdjustExprType::mutate( ZeroType *zeroType ) {
+                return zeroType;
+        }
+
+        Type *AdjustExprType::mutate( OneType *oneType ) {
+                return oneType;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.cc

@@ -197 +197 @@
         }
 
-        void AlternativeFinder::find( Expression *expr, bool adjust ) {
+        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) {
                 expr->accept( *this );
                 if ( alternatives.empty() ) {
@@ -207 +207 @@
                         }
                 }
-                PRINT(
-                        std::cerr << "alternatives before prune:" << std::endl;
-                        printAlts( alternatives, std::cerr );
-                )
-                AltList::iterator oldBegin = alternatives.begin();
-                pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
-                if ( alternatives.begin() == oldBegin ) {
-                        std::ostringstream stream;
-                        stream << "Can't choose between alternatives for expression ";
-                        expr->print( stream );
-                        stream << "Alternatives are:";
-                        AltList winners;
-                        findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
-                        printAlts( winners, stream, 8 );
-                        throw SemanticError( stream.str() );
-                }
-                alternatives.erase( oldBegin, alternatives.end() );
-                PRINT(
-                        std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
-                )
+                if ( prune ) {
+                        PRINT(
+                                std::cerr << "alternatives before prune:" << std::endl;
+                                printAlts( alternatives, std::cerr );
+                        )
+                        AltList::iterator oldBegin = alternatives.begin();
+                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
+                        if ( alternatives.begin() == oldBegin ) {
+                                std::ostringstream stream;
+                                stream << "Can't choose between alternatives for expression ";
+                                expr->print( stream );
+                                stream << "Alternatives are:";
+                                AltList winners;
+                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
+                                printAlts( winners, stream, 8 );
+                                throw SemanticError( stream.str() );
+                        }
+                        alternatives.erase( oldBegin, alternatives.end() );
+                        PRINT(
+                                std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
+                        )
+                }
 
                 // Central location to handle gcc extension keyword for all expression types.
@@ -234 +236 @@
         }
 
-        void AlternativeFinder::findWithAdjustment( Expression *expr ) {
-                find( expr, true );
+        void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) {
+                find( expr, true, prune );
         }
 
         template< typename StructOrUnionType >
-        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name ) {
+        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ) {
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
@@ -760 +762 @@
                         if ( agg->expr->get_results().size() == 1 ) {
                                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
-                                        addAggMembers( structInst, agg->expr, agg->cost, memberExpr->get_member() );
+                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
                                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
-                                        addAggMembers( unionInst, agg->expr, agg->cost, memberExpr->get_member() );
+                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
                                 } // if
                         } // if
@@ -789 +791 @@
                         renameTypes( alternatives.back().expr );
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
-                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), "" );
+                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
-                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), "" );
+                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
                         } // if
                 } // for
@@ -1012 +1014 @@
                 alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
         }
+
+        void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) {
+                AlternativeFinder finder( indexer, env );
+                // don't prune here, since it's guaranteed all alternatives will have the same type
+                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
+                finder.findWithAdjustment( ctorExpr->get_callExpr(), false );
+                for ( Alternative & alt : finder.alternatives ) {
+                        alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -29 +29 @@
           public:
                 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
-                void find( Expression *expr, bool adjust = false );
+                void find( Expression *expr, bool adjust = false, bool prune = true );
                 /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
-                void findWithAdjustment( Expression *expr );
+                void findWithAdjustment( Expression *expr, bool prune = true );
                 AltList &get_alternatives() { return alternatives; }
 
@@ -66 +66 @@
                 virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
+                virtual void visit( ConstructorExpr * ctorExpr );
           public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
                 template< typename InputIterator, typename OutputIterator >
@@ -72 +73 @@
           private:
                 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
-                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name );
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name );
                 /// Adds alternatives for offsetof expressions, given the base type and name of the member
                 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );

src/ResolvExpr/CommonType.cc

@@ -39 +39 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -134 +136 @@
                                 result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
                         } // if
-                } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
-                        // use signed int in lieu of the enum type
+                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
+                        // use signed int in lieu of the enum/zero/one type
                         BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
-                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
-                                result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
+                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
+                                result = new BasicType( basicType->get_qualifiers() + type2->get_qualifiers(), newType );
                         } // if
                 } // if
@@ -171 +173 @@
                                 otherPointer->get_base()->get_qualifiers() = tq2;
                         } // if
+                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
+                        result = pointerType->clone();
+                        result->get_qualifiers() += type2->get_qualifiers();
                 } // if
         }
@@ -190 +195 @@
 
         void CommonType::visit( EnumInstType *enumInstType ) {
-                if ( dynamic_cast< BasicType * >( type2 ) ) {
+                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
                         Type * temp = type2;
@@ -230 +235 @@
         void CommonType::visit( VarArgsType *varArgsType ) {
         }
+
+        void CommonType::visit( ZeroType *zeroType ) {
+                if ( widenFirst ) {
+                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+                                if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) {
+                                        result = type2->clone();
+                                        result->get_qualifiers() += zeroType->get_qualifiers();
+                                }
+                        }
+                }
+        }
+
+        void CommonType::visit( OneType *oneType ) {
+                if ( widenFirst ) {
+                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+                                if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) {
+                                        result = type2->clone();
+                                        result->get_qualifiers() += oneType->get_qualifiers();
+                                }
+                        }
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.cc

@@ -160 +160 @@
                         // xxx - not positive this is correct, but appears to allow casting int => enum
                         cost = Cost( 1, 0, 0 );
-    } // if
+                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                        cost = Cost( 1, 0, 0 );
+                } // if
         }
 
@@ -175 +177 @@
                                 } // if
                         } // if
+                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                        cost = Cost( 1, 0, 0 );
                 } // if
         }
@@ -256 +260 @@
                 }
         }
+
+        void ConversionCost::visit(ZeroType *zeroType) {
+                if ( dynamic_cast< ZeroType* >( dest ) ) {
+                        cost = Cost::zero;
+                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
+                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+                        if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                        }
+                } else if ( dynamic_cast< PointerType* >( dest ) ) {
+                        cost = Cost( 0, 0, 1 );
+                }
+        }
+
+        void ConversionCost::visit(OneType *oneType) {
+                if ( dynamic_cast< OneType* >( dest ) ) {
+                        cost = Cost::zero;
+                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
+                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+                        if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                        }
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.h

@@ -41 +41 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
           protected:
                 Type *dest;

src/ResolvExpr/PtrsAssignable.cc

@@ -39 +39 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
           private:
                 Type *dest;
@@ -141 +143 @@
         void PtrsAssignable::visit( VarArgsType *varArgsType ) {
         }
+
+        void PtrsAssignable::visit( ZeroType *zeroType ) {
+        }
+        
+        void PtrsAssignable::visit( OneType *oneType ) {
+        }
+        
 } // namespace ResolvExpr
 

src/ResolvExpr/PtrsCastable.cc

@@ -40 +40 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
           private:
                 Type *dest;
@@ -144 +146 @@
                 result = objectCast( dest, env, indexer );
         }
+
+        void PtrsCastable::visit(ZeroType *zeroType) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable::visit(OneType *oneType) {
+                result = objectCast( dest, env, indexer );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.cc

@@ -110 +110 @@
         }
 
+        void RenameVars::visit( ZeroType *zeroType ) {
+                typeBefore( zeroType );
+                typeAfter( zeroType );
+        }
+
+        void RenameVars::visit( OneType *oneType ) {
+                typeBefore( oneType );
+                typeAfter( oneType );
+        }
+
         void RenameVars::typeBefore( Type *type ) {
                 if ( ! type->get_forall().empty() ) {

src/ResolvExpr/RenameVars.h

@@ -44 +44 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 void typeBefore( Type *type );

src/ResolvExpr/Resolver.cc

@@ -133 +133 @@
                         } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
                                 return bt->isInteger();
+                        } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
+                                return true;
                         } else {
                                 return false;
@@ -459 +461 @@
                         }
                 } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext ) );
+                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
                         // basic types are handled here
                         Visitor::visit( listInit );

src/ResolvExpr/Unify.cc

@@ -60 +60 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -588 +590 @@
         }
 
+        void Unify::visit(ZeroType *zeroType) {
+                result = dynamic_cast< ZeroType* >( type2 );
+        }
+
+        void Unify::visit(OneType *oneType) {
+                result = dynamic_cast< OneType* >( type2 );
+        }
+
 } // namespace ResolvExpr