Changes in / [f5e81d1:cd14861]


Ignore:
Location:
src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/Common/utility.h

    rf5e81d1 rcd14861  
    1818
    1919#include <cctype>
    20 #include <algorithm>
    2120#include <iostream>
    2221#include <iterator>
     
    114113}
    115114
     115template< class T, typename ResultType, ResultType( T::* memfunc )() >
     116ResultType dispatch( T *pT ) {
     117        return (pT->*memfunc)();
     118}
     119
    116120template < typename T >
    117121std::list<T> tail( std::list<T> l ) {
     
    158162}
    159163
     164template< class Constructed, typename Arg >
     165Constructed *ctor( Arg arg ) {
     166        Constructed *c = new Constructed( arg );
     167        return c;
     168}
     169
     170template< class Constructed, typename Arg >
     171Constructed ctor_noptr( Arg arg ) {
     172        return Constructed( arg );
     173}
     174
    160175template< typename T >
    161176void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
     
    170185}
    171186
    172 template< typename... Args >
    173 auto filter(Args&&... args) -> decltype(std::copy_if(std::forward<Args>(args)...)) {
    174   return std::copy_if(std::forward<Args>(args)...);
    175 }
    176 
    177 template< typename... Args >
    178 auto zip(Args&&... args) -> decltype(zipWith(std::forward<Args>(args)..., std::make_pair)) {
    179   return zipWith(std::forward<Args>(args)..., std::make_pair);
     187template< typename T1, typename T2 >
     188T2 *cast_ptr( T1 *from ) {
     189        return dynamic_cast< T2 * >( from );
     190}
     191
     192template< class Exception, typename Arg >
     193void inline assert_throw( bool pred, Arg arg ) {
     194        if (pred) throw Exception( arg );
     195}
     196
     197template< typename T >
     198struct is_null_pointer {
     199        bool operator()( const T *ptr ) { return ( ptr == 0 ); }
     200};
     201
     202template< class InputIterator, class OutputIterator, class Predicate >
     203void filter(InputIterator begin, InputIterator end, OutputIterator out, Predicate pred) {
     204        while ( begin++ != end )
     205                if ( pred(*begin) ) *out++ = *begin;
     206
     207        return;
     208}
     209
     210template< class InputIterator1, class InputIterator2, class OutputIterator >
     211void zip( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out ) {
     212        while ( b1 != e1 && b2 != e2 )
     213                *out++ = std::pair<typename InputIterator1::value_type, typename InputIterator2::value_type>(*b1++, *b2++);
    180214}
    181215
     
    187221
    188222// it's nice to actually be able to increment iterators by an arbitrary amount
    189 template< class InputIt, class Distance >
    190 InputIt operator+( InputIt it, Distance n ) {
    191         advance(it, n);
    192         return it;
     223template< typename Iterator >
     224Iterator operator+(Iterator i, int inc) {
     225        while ( inc > 0 ) {
     226                ++i;
     227                --inc;
     228        }
     229        return i;
    193230}
    194231
     
    209246        warn_single( params... );
    210247}
    211 
    212 // -----------------------------------------------------------------------------
    213 // Ref Counted Singleton class
    214 // Objects that inherit from this class will have at most one reference to it
    215 // but if all references die, the object will be deleted.
    216248
    217249template< typename ThisType >
     
    233265std::weak_ptr<ThisType> RefCountSingleton<ThisType>::global_instance;
    234266
    235 // -----------------------------------------------------------------------------
    236267// RAII object to regulate "save and restore" behaviour, e.g.
    237268// void Foo::bar() {
     
    248279};
    249280
    250 // -----------------------------------------------------------------------------
    251 // Helper struct and function to support
    252 // for ( val : reverseIterate( container ) ) {}
    253 // syntax to have a for each that iterates backwards
    254 
    255281template< typename T >
    256282struct reverseIterate_t {
  • src/InitTweak/InitTweak.cc

    rf5e81d1 rcd14861  
    304304
    305305        namespace {
    306                 DeclarationWithType * getCalledFunction( Expression * expr ) {
    307                         assert( expr );
    308                         if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
    309                                 return varExpr->get_var();
    310                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
    311                                 return memberExpr->get_member();
    312                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
    313                                 return getCalledFunction( castExpr->get_arg() );
    314                         }
    315                         return nullptr;
     306                VariableExpr * getCalledFunction( ApplicationExpr * appExpr ) {
     307                        assert( appExpr );
     308                        // xxx - it's possible this can be other things, e.g. MemberExpr, so this is insufficient
     309                        return dynamic_cast< VariableExpr * >( appExpr->get_function() );
    316310                }
    317311        }
     
    320314                ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
    321315                if ( ! appExpr ) return NULL;
    322                 DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
     316                VariableExpr * function = getCalledFunction( appExpr );
    323317                assert( function );
    324318                // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
    325319                // will call all member dtors, and some members may have a user defined dtor.
    326                 return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
     320                return function->get_var()->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
    327321        }
    328322
     
    385379                        }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
    386380                                return funcName( castExpr->get_arg() );
    387                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
    388                                 return memberExpr->get_member()->get_name();
    389381                        } else {
    390382                                assert( false && "Unexpected expression type being called as a function in call expression" );
     
    480472        bool isConstructor( const std::string & str ) { return str == "?{}"; }
    481473        bool isDestructor( const std::string & str ) { return str == "^?{}"; }
    482         bool isAssignment( const std::string & str ) { return str == "?=?"; }
    483474        bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
    484         bool isCtorDtorAssign( const std::string & str ) { return isCtorDtor( str ) || isAssignment( str ); }
    485 
    486         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) {
     475
     476        FunctionDecl * isCopyConstructor( Declaration * decl ) {
    487477                FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
    488478                if ( ! function ) return 0;
    489                 if ( function->get_name() != fname ) return 0;
     479                if ( ! isConstructor( function->get_name() ) ) return 0;
    490480                FunctionType * ftype = function->get_functionType();
    491481                if ( ftype->get_parameters().size() != 2 ) return 0;
     
    496486                assert( ptrType );
    497487
    498                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
     488                if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
    499489                        return function;
    500490                } else {
    501                         return nullptr;
    502                 }
    503         }
    504 
    505         FunctionDecl * isCopyConstructor( Declaration * decl ) {
    506                 return isCopyFunction( decl, "?{}" );
     491                        return 0;
     492                }
    507493        }
    508494}
  • src/InitTweak/InitTweak.h

    rf5e81d1 rcd14861  
    2828        bool isConstructor( const std::string & );
    2929        bool isDestructor( const std::string & );
    30         bool isAssignment( const std::string & );
    3130        bool isCtorDtor( const std::string & );
    32         bool isCtorDtorAssign( const std::string & );
    3331
    3432        FunctionDecl * isCopyConstructor( Declaration * decl );
    35         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname );
    3633
    3734        /// transform Initializer into an argument list that can be passed to a call expression
  • src/SymTab/Indexer.cc

    rf5e81d1 rcd14861  
    105105
    106106        void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
    107                 // only need to perform this step for constructors, destructors, and assignment functions
    108                 if ( ! InitTweak::isCtorDtorAssign( id ) ) return;
     107                // only need to perform this step for constructors and destructors
     108                if ( ! InitTweak::isCtorDtor( id ) ) return;
    109109
    110110                // helpful data structure
     
    127127                                bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->get_linkage() );
    128128                                bool isDefaultFunc = function->get_functionType()->get_parameters().size() == 1;
    129                                 bool isCopyFunc = InitTweak::isCopyFunction( function, function->get_name() );
     129                                bool isCopyFunc = InitTweak::isCopyConstructor( function );
    130130                                decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultFunc, isCopyFunc } );
    131131                                userDefinedFunc = userDefinedFunc || isUserDefinedFunc;
Note: See TracChangeset for help on using the changeset viewer.