Changeset 5ccb10d for src/ResolvExpr


Ignore:
Timestamp:
Aug 22, 2017, 6:41:28 PM (7 years ago)
Author:
Rob Schluntz <rschlunt@…>
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, with_gc
Children:
0b5d871
Parents:
d104b02
Message:

Set reference size to base size, clean up debug code, remove more old-style NULLs from prelude

Location:
src/ResolvExpr
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/AlternativeFinder.cc

    rd104b02 r5ccb10d  
    845845                        // then excess components do not come out in the result expression (but UniqueExprs ensure that
    846846                        // side effects will still be done).
    847                         if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
     847                        if ( Tuples::maybeImpureIgnoreUnique( argExpr ) ) {
    848848                                // expressions which may contain side effects require a single unique instance of the expression.
    849849                                argExpr = new UniqueExpr( argExpr );

  • src/ResolvExpr/CommonType.cc

    rd104b02 r5ccb10d  
    1818#include "Unify.h"
    1919
    20 /// #define DEBUG
     20// #define DEBUG
    2121
    2222namespace ResolvExpr {

  • src/ResolvExpr/ConversionCost.cc

    rd104b02 r5ccb10d  
    2828        const Cost Cost::reference = Cost( 0, 0, 0, 1 );
    2929
     30#if 0
     31#define PRINT(x) x
     32#else
     33#define PRINT(x)
     34#endif
    3035
    3136        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    … …  
    3338                        EqvClass eqvClass;
    3439                        NamedTypeDecl *namedType;
    35 ///     std::cout << "type inst " << destAsTypeInst->get_name();
     40                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
    3641                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
    3742                                if ( eqvClass.type ) {
    … …  
    4146                                }
    4247                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
    43 ///       std::cout << " found" << std::endl;
     48                                PRINT( std::cerr << " found" << std::endl; )
    4449                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    4550                                // all typedefs should be gone by this point
    … …  
    4954                                } // if
    5055                        } // if
    51 ///     std::cout << " not found" << std::endl;
    52                 } // if
    53 ///   std::cout << "src is ";
    54 ///   src->print( std::cout );
    55 ///   std::cout << std::endl << "dest is ";
    56 ///   dest->print( std::cout );
    57 ///   std::cout << std::endl << "env is" << std::endl;
    58 ///   env.print( std::cout, 8 );
     56                        PRINT( std::cerr << " not found" << std::endl; )
     57                } // if
     58                PRINT(
     59                        std::cerr << "src is ";
     60                        src->print( std::cerr );
     61                        std::cerr << std::endl << "dest is ";
     62                        dest->print( std::cerr );
     63                        std::cerr << std::endl << "env is" << std::endl;
     64                        env.print( std::cerr, 8 );
     65                )
    5966                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
    60 ///     std::cout << "compatible!" << std::endl;
     67                        PRINT( std::cerr << "compatible!" << std::endl; )
    6168                        return Cost::zero;
    6269                } else if ( dynamic_cast< VoidType* >( dest ) ) {
    6370                        return Cost::safe;
    6471                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    65                         // std::cerr << "conversionCost: dest is reference" << std::endl;
     72                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    6673                        return convertToReferenceCost( src, refType, indexer, env );
    6774                } else {
    … …  
    7784
    7885        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
    79                 // std::cerr << "convert to reference cost..." << std::endl;
     86                PRINT( std::cerr << "convert to reference cost..." << std::endl; )
    8087                if ( diff > 0 ) {
    8188                        // TODO: document this
    … …  
    9299                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
    93100                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
    94                                 // std::cerr << "converting between references" << std::endl;
     101                                PRINT( std::cerr << "converting between references" << std::endl; )
    95102                                if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
    96103                                        return Cost::safe;
    97104                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
    98105                                        int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env );
     106                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
    99107                                        if ( assignResult < 0 ) {
    100108                                                return Cost::safe;
    … …  
    104112                                } // if
    105113                        } else {
    106                                 // std::cerr << "reference to rvalue conversion" << std::endl;
     114                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
    107115                                ConversionCost converter( dest, indexer, env );
    108116                                src->accept( converter );
    … …  
    113121                        assert( diff == -1 && destAsRef );
    114122                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
    115                                 // std::cerr << "converting compatible base type" << std::endl;
     123                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
    116124                                if ( src->get_lvalue() ) {
    117                                         // std::cerr << "lvalue to reference conversion" << std::endl;
     125                                        PRINT(
     126                                                std::cerr << "lvalue to reference conversion" << std::endl;
     127                                                std::cerr << src << " => " << destAsRef << std::endl;
     128                                        )
    118129                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
    119130                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
    … …  
    125136                                        } // if
    126137                                } else if ( destAsRef->get_base()->get_const() ) {
    127                                         // std::cerr << "rvalue to const ref conversion" << std::endl;
     138                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
    128139                                        // rvalue-to-const-reference conversion: T => const T &
    129140                                        return Cost::safe;
    130141                                } else {
    131                                         // std::cerr << "rvalue to non-const reference conversion" << std::endl;
     142                                        PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; )
    132143                                        // rvalue-to-reference conversion: T => T &
    133144                                        return Cost::unsafe;
    134145                                } // if
    135146                        } // if
    136                         // std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl;
     147                        PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; )
    137148                }
    138149                return Cost::infinity;
    … …  
    248259        void ConversionCost::visit(PointerType *pointerType) {
    249260                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
    250                         // std::cerr << pointerType << " ===> " << destAsPtr;
     261                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
    251262                        Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
    252263                        Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
    … …  
    257268                                } else {
    258269                                        // types are the same, except otherPointer has more qualifiers
    259                                         // std::cerr << " :: compatible and good qualifiers" << std::endl;
     270                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    260271                                        cost = Cost::safe;
    261272                                }
    262273                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
    263274                                int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
    264                                 // std::cerr << " :: " << assignResult << std::endl;
     275                                PRINT( std::cerr << " :: " << assignResult << std::endl; )
    265276                                if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
    266277                                        cost = Cost::safe;
    … …  
    291302                        cost.incUnsafe(); // lose qualifiers as last resort
    292303                }
    293                 // std::cerr << refType << " ==> " << dest << " " << cost << std::endl;
     304                PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; )
    294305        }
    295306

  • src/ResolvExpr/PtrsAssignable.cc

    rd104b02 r5ccb10d  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // PtrsAssignable.cc -- 
     7// PtrsAssignable.cc --
    88//
    99// Author           : Richard C. Bilson
    … …  
    8383        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
    8484
    85         void PtrsAssignable::visit( EnumInstType *inst ) {
    86                 if ( dynamic_cast< EnumInstType* >( inst ) ) {
     85        void PtrsAssignable::visit( EnumInstType * ) {
     86                if ( dynamic_cast< EnumInstType* >( dest ) ) {
    8787                        result = 1;
    88                 } else if ( BasicType *bt = dynamic_cast< BasicType* >( inst ) ) {
     88                } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) {
    8989                        result = bt->get_kind() == BasicType::SignedInt;
    9090                }
    … …  
    105105        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
    106106        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
    107        
     107
    108108} // namespace ResolvExpr
    109109
Note: See TracChangeset for help on using the changeset viewer.