Changes in / [e229c22:b8387fc]


Ignore:
Location:
src
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • src/ArgTweak/FunctionFixer.cc

    re229c22 rb8387fc  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FunctionFixer.cc -- 
     7// FunctionFixer.cc --
    88//
    99// Author           : Rodolfo G. Esteves
     
    4242        Expression *FunctionFixer::mutate( UntypedExpr *untypedExpr ) throw ( SemanticError ) {
    4343                assert( untypedExpr != 0 );
    44                 NameExpr *function;
    4544
    46                 if ( ( function = dynamic_cast< NameExpr *>(untypedExpr->get_function()) ) != 0 ) {
     45                if ( NameExpr * function = dynamic_cast< NameExpr *>(untypedExpr->get_function() ) ) {
    4746                        std::list < DeclarationWithType * > options;
    4847                        index->lookupId ( function->get_name(), options );
    4948                        for ( std::list < DeclarationWithType * >::iterator i = options.begin(); i != options.end(); i++ ) {
    50                                 FunctionType *f;
    51                                 if ( ( f = dynamic_cast< FunctionType * > ( (*i)->get_type() ) ) != 0 ) {
     49                                if ( FunctionType * f = dynamic_cast< FunctionType * > ( (*i)->get_type() ) )   {
    5250                                        std::list < DeclarationWithType * > &pars = f->get_parameters();
    53 
    5451                                        bool candidateExists ;
    55                                         for ( std::list < DeclarationWithType * >::iterator p = pars.begin(); p != pars.end(); p++ )
     52                                        for ( std::list < DeclarationWithType * >::iterator p = pars.begin(); p != pars.end(); p++ ) {
    5653                                                if ( ( candidateExists = align( f->get_parameters(), untypedExpr->get_args(), Matcher() ) ) ) break;
    57 
     54                                        }
    5855                                        if ( ! candidateExists ) throw SemanticError("Error in function call");
    5956                                } // if
  • src/CodeGen/CodeGenerator.cc

    re229c22 rb8387fc  
    3333#include "OperatorTable.h"
    3434#include "GenType.h"
     35
     36#include "InitTweak/InitTweak.h"
    3537
    3638using namespace std;
     
    255257                                std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
    256258                                switch ( opInfo.type ) {
     259                                  case OT_CTOR:
     260                                  case OT_DTOR:
     261                                        {
     262                                                // if the first argument's type is const then GCC complains. In this
     263                                                // case, output an explicit ctor/dtor call and exit, rather than following
     264                                                // the normal path
     265                                                assert( arg != applicationExpr->get_args().end() );
     266                                                assert( (*arg)->get_results().size() >= 1 );
     267                                                Type * baseType = InitTweak::getPointerBase( (*arg)->get_results().front() );
     268                                                if ( baseType->get_isConst() ) {
     269                                                        // cast away the qualifiers, to eliminate warnings
     270                                                        Type * newType = baseType->clone();
     271                                                        newType->get_qualifiers() = Type::Qualifiers();
     272                                                        *arg = new CastExpr( *arg, new PointerType( Type::Qualifiers(), newType ) );
     273                                                        varExpr->accept( *this );
     274                                                        output << "(";
     275                                                        genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
     276                                                        output << ")";
     277                                                        return;
     278                                                }
     279                                        }
     280                                        // intentional fallthrough - instrinsic ctor/dtor for non-const objects should
     281                                        // be handled the same way as assignment
    257282                                  case OT_PREFIXASSIGN:
    258283                                  case OT_POSTFIXASSIGN:
    259284                                  case OT_INFIXASSIGN:
    260                                   case OT_CTOR:
    261                                   case OT_DTOR:
    262285                                        {
    263286                                                assert( arg != applicationExpr->get_args().end() );
     
    269292                                                        UntypedExpr *newExpr = new UntypedExpr( new NameExpr( "*?" ) );
    270293                                                        newExpr->get_args().push_back( *arg );
     294                                                        assert( (*arg)->get_results().size() == 1 );
     295                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
     296                                                        assert( type );
     297                                                        newExpr->get_results().push_back( type );
    271298                                                        *arg = newExpr;
    272299                                                } // if
  • src/GenPoly/Box.cc

    re229c22 rb8387fc  
    19471947                                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
    19481948                                derefExpr->get_args().push_back( derefdVar );
     1949                                // xxx - should set results on derefExpr
    19491950                                derefdVar = derefExpr;
    19501951                        }
  • src/InitTweak/FixGlobalInit.cc

    re229c22 rb8387fc  
    125125                std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids();
    126126
    127                 // if ( objDecl->get_init() == NULL ) return;
    128127                if ( ! tryConstruct( objDecl ) ) return; // don't construct @= or designated objects
    129                 if ( objDecl->get_type()->get_isConst() ) return; // temporary: can't assign to a const variable
    130128                if ( objDecl->get_storageClass() == DeclarationNode::Extern ) return;
    131129                // C allows you to initialize objects with constant expressions
     
    146144                        init->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
    147145                        init->get_args().push_back( new VariableExpr( newObj ) );
    148                         initStatements.push_back( new ExprStmt( noLabels, init ) );
     146                        initStatements.push_back( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, init ) ) );
    149147
    150148                        // add destructor calls to global destroy function
    151149                        UntypedExpr * destroy = new UntypedExpr( new NameExpr( "^?{}" ) );
    152150                        destroy->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
    153                         destroyStatements.push_front( new ExprStmt( noLabels, destroy ) );
     151                        destroyStatements.push_front( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, destroy ) ) );
    154152                }
    155153        }
  • src/InitTweak/FixInit.cc

    re229c22 rb8387fc  
    132132                                return appExpr;
    133133                        } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
    134                                 // FunctionType * ftype = funcDecl->get_functionType();
    135134                                FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
    136135                                assert( ftype );
  • src/InitTweak/GenInit.cc

    re229c22 rb8387fc  
    164164                                                assert( ctor.size() == 1 );
    165165                                                assert( dtor.size() == 1 );
    166 
    167                                                 objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
     166                                                objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctor.front() ), new ImplicitCtorDtorStmt( dtor.front() ), objDecl->get_init() ) );
    168167                                        } else {
    169168                                                // array came with an initializer list: initialize each element
     
    185184                                        ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
    186185                                        ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
    187                                         objDecl->set_init( new ConstructorInit( ctorStmt, dtorStmt, objDecl->get_init() ) );
     186                                        objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctorStmt ), new ImplicitCtorDtorStmt( dtorStmt ), objDecl->get_init() ) );
    188187                                }
    189188                        }
  • src/InitTweak/InitTweak.cc

    re229c22 rb8387fc  
    6060  }
    6161
    62   bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
    63     if ( stmt == NULL ) return false;
     62  Expression * getCtorDtorCall( Statement * stmt ) {
     63    if ( stmt == NULL ) return NULL;
    6464    if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
    65       ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( exprStmt->get_expr() );
    66       assert( appExpr );
    67       VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
    68       assert( function );
    69       // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
    70       // will call all member dtors, and some members may have a user defined dtor.
    71       FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
    72       assert( funcType );
    73       return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
     65      return exprStmt->get_expr();
    7466    } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
    7567      // could also be a compound statement with a loop, in the case of an array
     
    7769      ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
    7870      assert( forStmt && forStmt->get_body() );
    79       return isInstrinsicSingleArgCallStmt( forStmt->get_body() );
     71      return getCtorDtorCall( forStmt->get_body() );
     72    } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
     73      return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
    8074    } else {
    8175      // should never get here
     
    8377    }
    8478  }
     79
     80  bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
     81    Expression * callExpr = getCtorDtorCall( stmt );
     82    if ( ! callExpr ) return false;
     83    ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
     84    assert( appExpr );
     85    VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
     86    assert( function );
     87    // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
     88    // will call all member dtors, and some members may have a user defined dtor.
     89    FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
     90    assert( funcType );
     91    return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
     92  }
     93
     94  namespace {
     95    template<typename CallExpr>
     96    Expression * callArg( CallExpr * callExpr, unsigned int pos ) {
     97      if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
     98      for ( Expression * arg : callExpr->get_args() ) {
     99        if ( pos == 0 ) return arg;
     100        pos--;
     101      }
     102      assert( false );
     103    }
     104  }
     105
     106  Expression * getCallArg( Expression * callExpr, unsigned int pos ) {
     107    if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
     108      return callArg( appExpr, pos );
     109    } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
     110      return callArg( untypedExpr, pos );
     111    } else {
     112      assert( false && "Unexpected expression type passed to getCallArg" );
     113    }
     114  }
     115
     116  namespace {
     117    template<typename CallExpr>
     118    std::string funcName( CallExpr * expr ) {
     119      Expression * func = expr->get_function();
     120      if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
     121        return nameExpr->get_name();
     122      } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
     123        return varExpr->get_var()->get_name();
     124      } else {
     125        assert( false && "Unexpected expression type being called as a function in call expression" );
     126      }
     127    }
     128  }
     129
     130  std::string getFunctionName( Expression * expr ) {
     131    if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
     132      return funcName( appExpr );
     133    } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
     134      return funcName( untypedExpr );
     135    } else {
     136      assert( false && "Unexpected expression type passed to getFunctionName" );
     137    }
     138  }
     139
     140  Type * getPointerBase( Type * type ) {
     141    if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
     142      return ptrType->get_base();
     143    } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
     144      return arrayType->get_base();
     145    } else {
     146      return NULL;
     147    }
     148  }
     149
    85150}
  • src/InitTweak/InitTweak.h

    re229c22 rb8387fc  
    3939  /// Currently has assertions that make it less than fully general.
    4040  bool isInstrinsicSingleArgCallStmt( Statement * expr );
     41
     42  /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
     43  Expression * getCtorDtorCall( Statement * stmt );
     44
     45  /// returns the name of the function being called
     46  std::string getFunctionName( Expression * expr );
     47
     48  /// returns the argument to a call expression in position N indexed from 0
     49  Expression * getCallArg( Expression * callExpr, unsigned int pos );
     50
     51  /// returns the base type of a PointerType or ArrayType
     52  Type * getPointerBase( Type * );
    4153} // namespace
    4254
  • src/ResolvExpr/AlternativeFinder.cc

    re229c22 rb8387fc  
    3939#include "Tuples/NameMatcher.h"
    4040#include "Common/utility.h"
     41#include "InitTweak/InitTweak.h"
    4142
    4243extern bool resolvep;
     
    546547
    547548                {
    548                         NameExpr *fname = 0;;
    549                         if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
    550                                  && ( fname->get_name() == std::string("&&")) ) {
     549                        std::string fname = InitTweak::getFunctionName( untypedExpr );
     550                        if ( fname == "&&" ) {
    551551                                VoidType v = Type::Qualifiers();                // resolve to type void *
    552552                                PointerType pt( Type::Qualifiers(), v.clone() );
  • src/ResolvExpr/Resolver.cc

    re229c22 rb8387fc  
    5252                virtual void visit( BranchStmt *branchStmt );
    5353                virtual void visit( ReturnStmt *returnStmt );
     54                virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
    5455
    5556                virtual void visit( SingleInit *singleInit );
     
    492493                } catch ( SemanticError ) {
    493494                        // no alternatives for the constructor initializer - fallback on C-style initializer
    494                         // xxx- not sure if this makes a ton of sense - should maybe never be able to have this situation?
     495                        // xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation?
    495496                        fallbackInit( ctorInit );
    496497                        return;
     
    513514                }
    514515        }
     516
     517        void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
     518                // this code is fairly gross. If VariableExpr didn't have its own results list then this could be cleaned up a bit
     519                // by remembering the ObjectDecl in the ImplicitCtorDtorStmt and changing the ObjectDecl's type temporarily, but currently
     520                // VariableExprs have their own type list which is manipulated in AlternativeFinder (e.g. in inferRecursive).
     521
     522                // before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed)
     523                Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
     524                assert( callExpr );
     525                Expression * constructee = InitTweak::getCallArg( callExpr, 0 );
     526                Type * type = 0;
     527                if ( UntypedExpr * plusExpr = dynamic_cast< UntypedExpr * >( constructee ) ) {
     528                        // constructee is <array>+<index>
     529                        // get Variable <array>, then get the base type of the VariableExpr - this is the type that needs to be fixed
     530                        Expression * arr = InitTweak::getCallArg( plusExpr, 0 );
     531                        assert( dynamic_cast< VariableExpr * >( arr ) );
     532                        assert( arr && arr->get_results().size() == 1 );
     533                        type = InitTweak::getPointerBase( arr->get_results().front() );
     534                        assert( type );
     535                } else {
     536                        // otherwise, constructing a plain object, which means the object's address is being taken.
     537                        // Need to get the type of the VariableExpr object, because the AddressExpr is rebuilt and uses the
     538                        // type of the VariableExpr to do so.
     539                        assert( constructee->get_results().size() == 1 );
     540                        AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
     541                        assert( addrExpr );
     542                        VariableExpr * varExpr = dynamic_cast< VariableExpr * >( addrExpr->get_arg() );
     543                        assert( varExpr && varExpr->get_results().size() == 1 );
     544                        type = varExpr->get_results().front();
     545                }
     546                // remember qualifiers so they can be replaced
     547                Type::Qualifiers qualifiers = type->get_qualifiers();
     548
     549                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
     550                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
     551                // remove lvalue as a qualifier, this can change to
     552                //   type->get_qualifiers() = Type::Qualifiers();
     553                type->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
     554
     555                // finally, resolve the ctor/dtor
     556                impCtorDtorStmt->get_callStmt()->accept( *this );
     557
     558                // reset type qualifiers, but first need to figure out where everything is again
     559                // because the expressions are often changed by the resolver.
     560                callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
     561                assert( callExpr );
     562                constructee = InitTweak::getCallArg( callExpr, 0 );
     563                if ( ApplicationExpr * plusExpr = dynamic_cast< ApplicationExpr * >( constructee ) ) {
     564                        // constructee is <array>+<index>
     565                        // get Variable <array>, then get the base type of the VariableExpr - this is the type that needs to be fixed
     566                        Expression * arr = InitTweak::getCallArg( plusExpr, 0 );
     567                        assert( dynamic_cast< VariableExpr * >( arr ) );
     568                        assert( arr && arr->get_results().size() == 1 );
     569                        type = InitTweak::getPointerBase( arr->get_results().front() );
     570                        assert( type );
     571                        type->get_qualifiers() = qualifiers;
     572                } else {
     573                        // otherwise constructing a plain object
     574                        // replace qualifiers on AddressExpr and on inner VariableExpr
     575                        assert( constructee->get_results().size() == 1 );
     576                        AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
     577                        assert( addrExpr );
     578                        type = InitTweak::getPointerBase( addrExpr->get_results().front() );
     579                        assert( type );
     580                        type->get_qualifiers() = qualifiers;
     581
     582                        VariableExpr * varExpr = dynamic_cast< VariableExpr * >( addrExpr->get_arg() );
     583                        assert( varExpr && varExpr->get_results().size() == 1 );
     584                        type = varExpr->get_results().front();
     585                        type->get_qualifiers() = qualifiers;
     586                }
     587        }
    515588} // namespace ResolvExpr
    516589
  • src/SynTree/Initializer.cc

    re229c22 rb8387fc  
    2020
    2121Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
     22Initializer::Initializer( const Initializer & other ) : maybeConstructed( other.maybeConstructed ) {
     23}
     24
    2225
    2326Initializer::~Initializer() {}
     
    3942}
    4043
    41 SingleInit::~SingleInit() {}
    42 
    43 SingleInit *SingleInit::clone() const { return new SingleInit( *this); }
     44SingleInit::~SingleInit() {
     45        deleteAll(designators);
     46}
    4447
    4548void SingleInit::print( std::ostream &os, int indent ) {
     
    5861
    5962ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
    60         : Initializer( maybeConstructed), initializers( _initializers ), designators( _designators ) {
     63        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
    6164}
    6265
    63 ListInit::~ListInit() {}
    64 
    65 ListInit *ListInit::clone() const {
    66         return new ListInit( *this );
     66ListInit::~ListInit() {
     67        deleteAll( initializers );
     68        deleteAll( designators );
    6769}
    6870
     
    8587
    8688ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ) {}
     89ConstructorInit::ConstructorInit( const ConstructorInit &other ) : Initializer( other ), ctor( maybeClone( other.ctor ) ), dtor( maybeClone( other.dtor ) ), init( maybeClone( other.init ) ) {
     90}
     91
    8792ConstructorInit::~ConstructorInit() {
    8893        delete ctor;
     94        delete dtor;
    8995        delete init;
    90 }
    91 
    92 ConstructorInit *ConstructorInit::clone() const {
    93         return new ConstructorInit( *this );
    9496}
    9597
  • src/SynTree/Initializer.h

    re229c22 rb8387fc  
    2020#include "Visitor.h"
    2121#include "Mutator.h"
     22#include "Type.h"
    2223
    2324#include <cassert>
     
    2829        //      Initializer( std::string _name = std::string(""), int _pos = 0 );
    2930        Initializer( bool maybeConstructed );
     31        Initializer( const Initializer & other );
    3032        virtual ~Initializer();
    3133
     
    6870        std::list<Expression *> &get_designators() { return designators; }
    6971
    70         virtual SingleInit *clone() const;
     72        virtual SingleInit *clone() const { return new SingleInit( *this); }
    7173        virtual void accept( Visitor &v ) { v.visit( this ); }
    7274        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     
    9496        std::list<Initializer*>::iterator end_initializers() { return initializers.end(); }
    9597
    96         virtual ListInit *clone() const;
     98        virtual ListInit *clone() const { return new ListInit( *this ); }
    9799        virtual void accept( Visitor &v ) { v.visit( this ); }
    98100        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     
    108110  public:
    109111        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
     112        ConstructorInit( const ConstructorInit &other );
    110113        virtual ~ConstructorInit();
    111114
     
    117120        Initializer * get_init() const { return init; }
    118121
    119         virtual ConstructorInit *clone() const;
     122        ConstructorInit *clone() const { return new ConstructorInit( *this ); }
    120123        virtual void accept( Visitor &v ) { v.visit( this ); }
    121124        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
  • src/SynTree/Mutator.cc

    re229c22 rb8387fc  
    182182}
    183183
     184Statement *Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
     185        impCtorDtorStmt->set_callStmt( maybeMutate( impCtorDtorStmt->get_callStmt(), *this ) );
     186        return impCtorDtorStmt;
     187}
     188
    184189Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
    185190        mutateAll( applicationExpr->get_results(), *this );
  • src/SynTree/Mutator.h

    re229c22 rb8387fc  
    5252        virtual NullStmt* mutate( NullStmt *nullStmt );
    5353        virtual Statement* mutate( DeclStmt *declStmt );
     54        virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt );
    5455
    5556        virtual Expression* mutate( ApplicationExpr *applicationExpr );
  • src/SynTree/Statement.cc

    re229c22 rb8387fc  
    358358
    359359void CatchStmt::print( std::ostream &os, int indent ) const {
    360         os << string( indent, ' ' ) << "Catch Statement" << endl;
     360        os << "Catch Statement" << endl;
    361361
    362362        os << string( indent, ' ' ) << "... catching" << endl;
     
    383383
    384384void FinallyStmt::print( std::ostream &os, int indent ) const {
    385         os << string( indent, ' ' ) << "Finally Statement" << endl;
     385        os << "Finally Statement" << endl;
    386386        os << string( indent + 2, ' ' ) << "with block: " << endl;
    387387        block->print( os, indent + 4 );
     
    393393void NullStmt::print( std::ostream &os, int indent ) const {
    394394        os << "Null Statement" << endl ;
     395}
     396
     397ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement( std::list<Label>() ), callStmt( callStmt ) {
     398        assert( callStmt );
     399}
     400
     401ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other ) : Statement( other ), callStmt( other.callStmt ) {
     402}
     403
     404ImplicitCtorDtorStmt::~ImplicitCtorDtorStmt() {
     405}
     406
     407void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
     408        os << "Implicit Ctor Dtor Statement" << endl;
     409        os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
     410        callStmt->print( os, indent + 2);
     411        os << endl;
    395412}
    396413
  • src/SynTree/Statement.h

    re229c22 rb8387fc  
    2121#include "Mutator.h"
    2222#include "Common/SemanticError.h"
     23#include "Type.h"
    2324
    2425class Statement {
     
    394395        virtual ~DeclStmt();
    395396
    396         Declaration *get_decl() { return decl; }
     397        Declaration *get_decl() const { return decl; }
    397398        void set_decl( Declaration *newValue ) { decl = newValue; }
    398399
     
    404405        Declaration *decl;
    405406};
     407
     408
     409/// represents an implicit application of a constructor or destructor. Qualifiers are replaced
     410/// immediately before and after the call so that qualified objects can be constructed
     411/// with the same functions as unqualified objects.
     412class ImplicitCtorDtorStmt : public Statement {
     413  public:
     414        ImplicitCtorDtorStmt( Statement * callStmt );
     415        ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
     416        virtual ~ImplicitCtorDtorStmt();
     417
     418        Statement *get_callStmt() const { return callStmt; }
     419        void set_callStmt( Statement * newValue ) { callStmt = newValue; }
     420
     421        virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
     422        virtual void accept( Visitor &v ) { v.visit( this ); }
     423        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     424        virtual void print( std::ostream &os, int indent = 0 ) const;
     425
     426  private:
     427        // Non-owned pointer to the constructor/destructor statement
     428        Statement * callStmt;
     429};
     430
    406431
    407432std::ostream & operator<<( std::ostream & out, Statement * statement );
  • src/SynTree/SynTree.h

    re229c22 rb8387fc  
    5656class DeclStmt;
    5757class NullStmt;
     58class ImplicitCtorDtorStmt;
    5859
    5960class Expression;
  • src/SynTree/Type.cc

    re229c22 rb8387fc  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Type.cc -- 
     7// Type.cc --
    88//
    99// Author           : Richard C. Bilson
     
    5454}
    5555
     56void Type::Qualifiers::print( std::ostream &os, int indent ) const {
     57        if ( isConst ) {
     58                os << "const ";
     59        } // if
     60        if ( isVolatile ) {
     61                os << "volatile ";
     62        } // if
     63        if ( isRestrict ) {
     64                os << "restrict ";
     65        } // if
     66        if ( isLvalue ) {
     67                os << "lvalue ";
     68        } // if
     69        if ( isAtomic ) {
     70                os << "_Atomic ";
     71        } // if
     72        if ( isAttribute ) {
     73                os << "__attribute(( )) ";
     74        } // if
     75}
     76
    5677void Type::print( std::ostream &os, int indent ) const {
    5778        if ( ! forall.empty() ) {
     
    6081                os << std::string( indent+2, ' ' );
    6182        } // if
    62         if ( tq.isConst ) {
    63                 os << "const ";
    64         } // if
    65         if ( tq.isVolatile ) {
    66                 os << "volatile ";
    67         } // if
    68         if ( tq.isRestrict ) {
    69                 os << "restrict ";
    70         } // if
    71         if ( tq.isLvalue ) {
    72                 os << "lvalue ";
    73         } // if
    74         if ( tq.isAtomic ) {
    75                 os << "_Atomic ";
    76         } // if
    77         if ( tq.isAttribute ) {
    78                 os << "__attribute(( )) ";
    79         } // if
     83        tq.print( os, indent );
    8084}
    8185
  • src/SynTree/Type.h

    re229c22 rb8387fc  
    3636                bool operator<( const Qualifiers &other );
    3737                bool operator>( const Qualifiers &other );
     38                void print( std::ostream &os, int indent = 0 ) const;
    3839
    3940                bool isConst;
  • src/SynTree/Visitor.cc

    re229c22 rb8387fc  
    152152}
    153153
     154void Visitor::visit( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
     155        maybeAccept( impCtorDtorStmt->get_callStmt(), *this );
     156}
     157
    154158void Visitor::visit( ApplicationExpr *applicationExpr ) {
    155159        acceptAll( applicationExpr->get_results(), *this );
  • src/SynTree/Visitor.h

    re229c22 rb8387fc  
    5252        virtual void visit( NullStmt *nullStmt );
    5353        virtual void visit( DeclStmt *declStmt );
     54        virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt );
    5455
    5556        virtual void visit( ApplicationExpr *applicationExpr );
  • src/examples/avltree/avl-private.h

    re229c22 rb8387fc  
     1#ifndef AVL_PRIVATE_H
    12#include "avl.h"
    23
     
    1314forall(otype K | Comparable(K), otype V)
    1415int height(tree(K, V) * t);
     16
     17#endif
Note: See TracChangeset for help on using the changeset viewer.