Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision c93bc28fc58cf97703952c9f870947a14d155972) +++ src/ResolvExpr/AlternativeFinder.cc (revision 5ccb10d750e81ef921035bdd254327997acd80ae) @@ -845,5 +845,5 @@ // then excess components do not come out in the result expression (but UniqueExprs ensure that // side effects will still be done). - if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) { + if ( Tuples::maybeImpureIgnoreUnique( argExpr ) ) { // expressions which may contain side effects require a single unique instance of the expression. argExpr = new UniqueExpr( argExpr ); Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision c93bc28fc58cf97703952c9f870947a14d155972) +++ src/ResolvExpr/CommonType.cc (revision 5ccb10d750e81ef921035bdd254327997acd80ae) @@ -18,5 +18,5 @@ #include "Unify.h" -/// #define DEBUG +// #define DEBUG namespace ResolvExpr { Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision c93bc28fc58cf97703952c9f870947a14d155972) +++ src/ResolvExpr/ConversionCost.cc (revision 5ccb10d750e81ef921035bdd254327997acd80ae) @@ -28,4 +28,9 @@ const Cost Cost::reference = Cost( 0, 0, 0, 1 ); +#if 0 +#define PRINT(x) x +#else +#define PRINT(x) +#endif Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { @@ -33,5 +38,5 @@ EqvClass eqvClass; NamedTypeDecl *namedType; -/// std::cout << "type inst " << destAsTypeInst->get_name(); + PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); ) if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { if ( eqvClass.type ) { @@ -41,5 +46,5 @@ } } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) { -/// std::cout << " found" << std::endl; + PRINT( std::cerr << " found" << std::endl; ) TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); // all typedefs should be gone by this point @@ -49,19 +54,21 @@ } // if } // if -/// std::cout << " not found" << std::endl; - } // if -/// std::cout << "src is "; -/// src->print( std::cout ); -/// std::cout << std::endl << "dest is "; -/// dest->print( std::cout ); -/// std::cout << std::endl << "env is" << std::endl; -/// env.print( std::cout, 8 ); + PRINT( std::cerr << " not found" << std::endl; ) + } // if + PRINT( + std::cerr << "src is "; + src->print( std::cerr ); + std::cerr << std::endl << "dest is "; + dest->print( std::cerr ); + std::cerr << std::endl << "env is" << std::endl; + env.print( std::cerr, 8 ); + ) if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) { -/// std::cout << "compatible!" << std::endl; + PRINT( std::cerr << "compatible!" << std::endl; ) return Cost::zero; } else if ( dynamic_cast< VoidType* >( dest ) ) { return Cost::safe; } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { - // std::cerr << "conversionCost: dest is reference" << std::endl; + PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) return convertToReferenceCost( src, refType, indexer, env ); } else { @@ -77,5 +84,5 @@ Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) { - // std::cerr << "convert to reference cost..." << std::endl; + PRINT( std::cerr << "convert to reference cost..." << std::endl; ) if ( diff > 0 ) { // TODO: document this @@ -92,9 +99,10 @@ ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest ); if ( srcAsRef && destAsRef ) { // pointer-like conversions between references - // std::cerr << "converting between references" << std::endl; + PRINT( std::cerr << "converting between references" << std::endl; ) if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) { return Cost::safe; } else { // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env ); + PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; ) if ( assignResult < 0 ) { return Cost::safe; @@ -104,5 +112,5 @@ } // if } else { - // std::cerr << "reference to rvalue conversion" << std::endl; + PRINT( std::cerr << "reference to rvalue conversion" << std::endl; ) ConversionCost converter( dest, indexer, env ); src->accept( converter ); @@ -113,7 +121,10 @@ assert( diff == -1 && destAsRef ); if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) { - // std::cerr << "converting compatible base type" << std::endl; + PRINT( std::cerr << "converting compatible base type" << std::endl; ) if ( src->get_lvalue() ) { - // std::cerr << "lvalue to reference conversion" << std::endl; + PRINT( + std::cerr << "lvalue to reference conversion" << std::endl; + std::cerr << src << " => " << destAsRef << std::endl; + ) // lvalue-to-reference conversion: cv lvalue T => cv T & if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) { @@ -125,14 +136,14 @@ } // if } else if ( destAsRef->get_base()->get_const() ) { - // std::cerr << "rvalue to const ref conversion" << std::endl; + PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; ) // rvalue-to-const-reference conversion: T => const T & return Cost::safe; } else { - // std::cerr << "rvalue to non-const reference conversion" << std::endl; + PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; ) // rvalue-to-reference conversion: T => T & return Cost::unsafe; } // if } // if - // std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; + PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; ) } return Cost::infinity; @@ -248,5 +259,5 @@ void ConversionCost::visit(PointerType *pointerType) { if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { - // std::cerr << pointerType << " ===> " << destAsPtr; + PRINT( std::cerr << pointerType << " ===> " << destAsPtr; ) Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(); Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers(); @@ -257,10 +268,10 @@ } else { // types are the same, except otherPointer has more qualifiers - // std::cerr << " :: compatible and good qualifiers" << std::endl; + PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) cost = Cost::safe; } } else { // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env ); - // std::cerr << " :: " << assignResult << std::endl; + PRINT( std::cerr << " :: " << assignResult << std::endl; ) if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) { cost = Cost::safe; @@ -291,5 +302,5 @@ cost.incUnsafe(); // lose qualifiers as last resort } - // std::cerr << refType << " ==> " << dest << " " << cost << std::endl; + PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; ) } Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision c93bc28fc58cf97703952c9f870947a14d155972) +++ src/ResolvExpr/PtrsAssignable.cc (revision 5ccb10d750e81ef921035bdd254327997acd80ae) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// PtrsAssignable.cc -- +// PtrsAssignable.cc -- // // Author : Richard C. Bilson @@ -83,8 +83,8 @@ void PtrsAssignable::visit( __attribute__((unused)) UnionInstType *inst ) {} - void PtrsAssignable::visit( EnumInstType *inst ) { - if ( dynamic_cast< EnumInstType* >( inst ) ) { + void PtrsAssignable::visit( EnumInstType * ) { + if ( dynamic_cast< EnumInstType* >( dest ) ) { result = 1; - } else if ( BasicType *bt = dynamic_cast< BasicType* >( inst ) ) { + } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) { result = bt->get_kind() == BasicType::SignedInt; } @@ -105,5 +105,5 @@ void PtrsAssignable::visit( __attribute__((unused)) ZeroType *zeroType ) {} void PtrsAssignable::visit( __attribute__((unused)) OneType *oneType ) {} - + } // namespace ResolvExpr