Changeset c14cff1 for src/ResolvExpr

Timestamp:

Feb 25, 2016, 5:16:15 PM (10 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

071a31a

Parents:

a9a259c (diff), ac1ed49 (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 ctor

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (2 diffs)
• AlternativeFinder.cc (modified) (1 diff)
• CommonType.cc (modified) (2 diffs)
• ConversionCost.cc (modified) (1 diff)
• 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)
• TypeMap.h (added)
• Unify.cc (modified) (12 diffs)

src/ResolvExpr/AdjustExprType.cc

@@ -36 +36 @@
                 virtual Type* mutate( TypeInstType *aggregateUseType );
                 virtual Type* mutate( TupleType *tupleType );
+                virtual Type* mutate( VarArgsType *varArgsType );
 
                 const TypeEnvironment &env;
@@ -111 +112 @@
                 return tupleType;
         }
+
+        Type *AdjustExprType::mutate( VarArgsType *varArgsType ) {
+                return varArgsType;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.cc

@@ -572 +572 @@
 
                 AltList candidates;
+                SemanticError errors;
 
                 for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
-                        PRINT(
-                                std::cerr << "working on alternative: " << std::endl;
-                                func->print( std::cerr, 8 );
-                        )
-                        // check if the type is pointer to function
-                        PointerType *pointer;
-                        if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
-                                if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
-                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                // XXX
-                                                //Designators::check_alternative( function, *actualAlt );
-                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
-                                        }
-                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
-                                        EqvClass eqvClass;
-                                        if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
-                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
-                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
-                                                        } // for
+                        try {
+                                PRINT(
+                                        std::cerr << "working on alternative: " << std::endl;
+                                        func->print( std::cerr, 8 );
+                                )
+                                // check if the type is pointer to function
+                                PointerType *pointer;
+                                if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
+                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                        // XXX
+                                                        //Designators::check_alternative( function, *actualAlt );
+                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                }
+                                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
+                                                EqvClass eqvClass;
+                                                if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                                } // for
+                                                        } // if
                                                 } // if
                                         } // if
+                                } else {
+                                        // seek a function operator that's compatible
+                                        if ( ! doneInit ) {
+                                                doneInit = true;
+                                                NameExpr *opExpr = new NameExpr( "?()" );
+                                                try {
+                                                        funcOpFinder.findWithAdjustment( opExpr );
+                                                } catch( SemanticError &e ) {
+                                                        // it's ok if there aren't any defined function ops
+                                                }
+                                                PRINT(
+                                                        std::cerr << "known function ops:" << std::endl;
+                                                        printAlts( funcOpFinder.alternatives, std::cerr, 8 );
+                                                )
+                                        }
+
+                                        for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                                // check if the type is pointer to function
+                                                PointerType *pointer;
+                                                if ( funcOp->expr->get_results().size() == 1
+                                                        && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
+                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                        AltList currentAlt;
+                                                                        currentAlt.push_back( *func );
+                                                                        currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
+                                                                        makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
+                                                                } // for
+                                                        } // if
+                                                } // if
+                                        } // for
                                 } // if
-                        } else {
-                                // seek a function operator that's compatible
-                                if ( ! doneInit ) {
-                                        doneInit = true;
-                                        NameExpr *opExpr = new NameExpr( "?()" );
-                                        try {
-                                                funcOpFinder.findWithAdjustment( opExpr );
-                                        } catch( SemanticError &e ) {
-                                                // it's ok if there aren't any defined function ops
-                                        }
-                                        PRINT(
-                                                std::cerr << "known function ops:" << std::endl;
-                                                printAlts( funcOpFinder.alternatives, std::cerr, 8 );
-                                        )
-                                }
-
-                                for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
-                                        // check if the type is pointer to function
-                                        PointerType *pointer;
-                                        if ( funcOp->expr->get_results().size() == 1
-                                                 && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
-                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
-                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                                AltList currentAlt;
-                                                                currentAlt.push_back( *func );
-                                                                currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
-                                                                makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
-                                                        } // for
-                                                } // if
-                                        } // if
-                                } // for
-                        } // if
-                } // for
+                        } catch ( SemanticError &e ) {
+                                errors.append( e );
+                        }
+                } // for
+
+                // Implement SFINAE; resolution errors are only errors if there aren't any non-erroneous resolutions
+                if ( candidates.empty() && ! errors.isEmpty() ) { throw errors; }
 
                 for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {

src/ResolvExpr/CommonType.cc

@@ -38 +38 @@
                 virtual void visit( TypeInstType *aggregateUseType );
                 virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -213 +214 @@
         void CommonType::visit( TupleType *tupleType ) {
         }
+
+        void CommonType::visit( VarArgsType *varArgsType ) {
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.cc

@@ -247 +247 @@
                 } // if
         }
+
+        void ConversionCost::visit(VarArgsType *varArgsType) {
+                if ( VarArgsType *destAsVarArgs = dynamic_cast< VarArgsType* >( dest ) ) {
+                        cost = Cost::zero;
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.h

@@ -40 +40 @@
                 virtual void visit(TypeInstType *aggregateUseType);
                 virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
           protected:
                 Type *dest;

src/ResolvExpr/PtrsAssignable.cc

@@ -38 +38 @@
                 virtual void visit( TypeInstType *inst );
                 virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
           private:
                 Type *dest;
@@ -137 +138 @@
 ///   }
         }
+
+        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/PtrsCastable.cc

@@ -39 +39 @@
                 virtual void visit(TypeInstType *inst);
                 virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
           private:
                 Type *dest;
@@ -139 +140 @@
                 result = objectCast( dest, env, indexer );
         }
+
+        void PtrsCastable::visit(VarArgsType *varArgsType) {
+                result = objectCast( dest, env, indexer );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.cc

@@ -113 +113 @@
         }
 
+        void RenameVars::visit( VarArgsType *varArgsType ) {
+                typeBefore( varArgsType );
+                typeAfter( varArgsType );
+        }
+
         void RenameVars::typeBefore( Type *type ) {
                 if ( ! type->get_forall().empty() ) {

src/ResolvExpr/RenameVars.h

@@ -43 +43 @@
                 virtual void visit( TypeInstType *aggregateUseType );
                 virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
 
                 void typeBefore( Type *type );

src/ResolvExpr/Unify.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Unify.cc -- 
+// Unify.cc --
 //
 // Author           : Richard C. Bilson
@@ -38 +38 @@
                 WidenMode operator&( const WidenMode &other ) { WidenMode newWM( *this ); newWM &= other; return newWM; }
                 operator bool() { return widenFirst && widenSecond; }
-  
+
                 bool widenFirst : 1, widenSecond : 1;
         };
@@ -45 +45 @@
           public:
                 Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
-  
+
                 bool get_result() const { return result; }
           private:
@@ -59 +59 @@
                 virtual void visit(TypeInstType *aggregateUseType);
                 virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -78 +79 @@
         bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common );
         bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
-  
+
         bool typesCompatible( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
                 TypeEnvironment newEnv;
@@ -136 +137 @@
                   case TypeDecl::Dtype:
                         return ! isFtype( type, indexer );
-  
+
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
@@ -195 +196 @@
                 bool widen1 = false, widen2 = false;
                 Type *type1 = 0, *type2 = 0;
-  
+
                 if ( env.lookup( var1->get_name(), class1 ) ) {
                         hasClass1 = true;
@@ -216 +217 @@
                         widen2 = widenMode.widenSecond && class2.allowWidening;
                 } // if
-  
+
                 if ( type1 && type2 ) {
 //    std::cout << "has type1 && type2" << std::endl;
@@ -435 +436 @@
                 // to unify, array types must both be VLA or both not VLA
                 // and must both have a dimension expression or not have a dimension
-                if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() 
-                                && ((arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0)
-                                        || (arrayType->get_dimension() == 0 && otherArray->get_dimension() == 0))) {
+                if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) {
 
                         // not positive this is correct in all cases, but it's needed for typedefs
@@ -448 +447 @@
                                 ConstantExpr * ce1 = dynamic_cast< ConstantExpr * >( arrayType->get_dimension() );
                                 ConstantExpr * ce2 = dynamic_cast< ConstantExpr * >( otherArray->get_dimension() );
-                                assert(ce1 && ce2);
-
-                                Constant * c1 = ce1->get_constant();
-                                Constant * c2 = ce2->get_constant();
-
-                                if ( c1->get_value() != c2->get_value() ) {
-                                        // does not unify if the dimension is different
-                                        return;
+                                // see C11 Reference Manual 6.7.6.2.6
+                                // two array types with size specifiers that are integer constant expressions are
+                                // compatible if both size specifiers have the same constant value
+                                if ( ce1 && ce2 ) {
+                                        Constant * c1 = ce1->get_constant();
+                                        Constant * c2 = ce2->get_constant();
+
+                                        if ( c1->get_value() != c2->get_value() ) {
+                                                // does not unify if the dimension is different
+                                                return;
+                                        }
                                 }
                         }
@@ -484 +486 @@
 
                         if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-        
+
                                 if ( unifyDeclList( functionType->get_returnVals().begin(), functionType->get_returnVals().end(), otherFunction->get_returnVals().begin(), otherFunction->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
 
@@ -582 +584 @@
         }
 
+        void Unify::visit(VarArgsType *varArgsType) {
+                result = dynamic_cast< VarArgsType* >( type2 );
+        }
+
 } // namespace ResolvExpr