Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 234b1cb4afd88ccf2b1f3e001a2eae5dc12ca39b) +++ src/InitTweak/FixInit.cc (revision b8524ca1420ff28d69347f46888a20baa805f797) @@ -1111,5 +1111,5 @@ arg2 = new MemberExpr( field, new VariableExpr( params.back() ) ); } - InitExpander srcParam( arg2 ); + InitExpander_old srcParam( arg2 ); // cast away reference type and construct field. Expression * thisExpr = new CastExpr( new VariableExpr( thisParam ), thisParam->get_type()->stripReferences()->clone() ); Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 234b1cb4afd88ccf2b1f3e001a2eae5dc12ca39b) +++ src/InitTweak/GenInit.cc (revision b8524ca1420ff28d69347f46888a20baa805f797) @@ -18,7 +18,12 @@ #include // for any_of #include // for assert, strict_dynamic_cast, assertf +#include #include // for back_inserter, inserter, back_inse... #include // for _List_iterator, list +#include "AST/Decl.hpp" +#include "AST/Init.hpp" +#include "AST/Node.hpp" +#include "AST/Stmt.hpp" #include "CodeGen/OperatorTable.h" #include "Common/PassVisitor.h" // for PassVisitor, WithGuards, WithShort... @@ -274,5 +279,5 @@ assertf( objDecl, "genCtorDtor passed null objDecl" ); std::list< Statement * > stmts; - InitExpander srcParam( maybeClone( arg ) ); + InitExpander_old srcParam( maybeClone( arg ) ); SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), fname, back_inserter( stmts ), objDecl ); assert( stmts.size() <= 1 ); @@ -286,6 +291,6 @@ std::list< Statement * > dtor; - InitExpander srcParam( objDecl->get_init() ); - InitExpander nullParam( (Initializer *)NULL ); + InitExpander_old srcParam( objDecl->get_init() ); + InitExpander_old nullParam( (Initializer *)NULL ); SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl ); SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false ); @@ -354,8 +359,27 @@ } -ast::ConstructorInit * genCtorInit( const ast::ObjectDecl * objDecl ) { - #warning unimplemented - (void)objDecl; - assert( false ); +ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl ) { + // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor for each + // constructable object + InitExpander_new srcParam{ objDecl->init }, nullParam{ (const ast::Init *)nullptr }; + + ast::ptr< ast::Stmt > ctor = SymTab::genImplicitCall( + srcParam, new ast::VariableExpr{ loc, objDecl }, loc, "?{}", objDecl ); + ast::ptr< ast::Stmt > dtor = SymTab::genImplicitCall( + nullParam, new ast::VariableExpr{ loc, objDecl }, loc, "^?{}", objDecl, + SymTab::LoopBackward ); + + // check that either both ctor and dtor are present, or neither + assert( (bool)ctor == (bool)dtor ); + + if ( ctor ) { + // need to remember init expression, in case no ctors exist. If ctor does exist, want to + // use ctor expression instead of init. + ctor.strict_as< ast::ImplicitCtorDtorStmt >(); + dtor.strict_as< ast::ImplicitCtorDtorStmt >(); + + return new ast::ConstructorInit{ loc, ctor, dtor, objDecl->init }; + } + return nullptr; } Index: src/InitTweak/GenInit.h =================================================================== --- src/InitTweak/GenInit.h (revision 234b1cb4afd88ccf2b1f3e001a2eae5dc12ca39b) +++ src/InitTweak/GenInit.h (revision b8524ca1420ff28d69347f46888a20baa805f797) @@ -20,4 +20,5 @@ #include "AST/Fwd.hpp" +#include "Common/CodeLocation.h" #include "GenPoly/ScopedSet.h" // for ScopedSet #include "SynTree/SynTree.h" // for Visitor Nodes @@ -35,5 +36,5 @@ /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer ConstructorInit * genCtorInit( ObjectDecl * objDecl ); - ast::ConstructorInit * genCtorInit( const ast::ObjectDecl * objDecl ); + ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl ); class ManagedTypes { Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 234b1cb4afd88ccf2b1f3e001a2eae5dc12ca39b) +++ src/InitTweak/InitTweak.cc (revision b8524ca1420ff28d69347f46888a20baa805f797) @@ -22,4 +22,5 @@ #include "AST/Expr.hpp" +#include "AST/Node.hpp" #include "AST/Stmt.hpp" #include "AST/Type.hpp" @@ -112,5 +113,12 @@ } - class InitExpander::ExpanderImpl { +std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) { + #warning unimplmented + (void)init; + assert(false); + return {}; +} + + class InitExpander_old::ExpanderImpl { public: virtual ~ExpanderImpl() = default; @@ -119,8 +127,8 @@ }; - class InitImpl : public InitExpander::ExpanderImpl { + class InitImpl_old : public InitExpander_old::ExpanderImpl { public: - InitImpl( Initializer * init ) : init( init ) {} - virtual ~InitImpl() = default; + InitImpl_old( Initializer * init ) : init( init ) {} + virtual ~InitImpl_old() = default; virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) { @@ -136,8 +144,8 @@ }; - class ExprImpl : public InitExpander::ExpanderImpl { + class ExprImpl_old : public InitExpander_old::ExpanderImpl { public: - ExprImpl( Expression * expr ) : arg( expr ) {} - virtual ~ExprImpl() { delete arg; } + ExprImpl_old( Expression * expr ) : arg( expr ) {} + virtual ~ExprImpl_old() { delete arg; } virtual std::list< Expression * > next( std::list< Expression * > & indices ) { @@ -163,13 +171,13 @@ }; - InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {} - - InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {} - - std::list< Expression * > InitExpander::operator*() { + InitExpander_old::InitExpander_old( Initializer * init ) : expander( new InitImpl_old( init ) ) {} + + InitExpander_old::InitExpander_old( Expression * expr ) : expander( new ExprImpl_old( expr ) ) {} + + std::list< Expression * > InitExpander_old::operator*() { return cur; } - InitExpander & InitExpander::operator++() { + InitExpander_old & InitExpander_old::operator++() { cur = expander->next( indices ); return *this; @@ -177,15 +185,15 @@ // use array indices list to build switch statement - void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) { + void InitExpander_old::addArrayIndex( Expression * index, Expression * dimension ) { indices.push_back( index ); indices.push_back( dimension ); } - void InitExpander::clearArrayIndices() { + void InitExpander_old::clearArrayIndices() { deleteAll( indices ); indices.clear(); } - bool InitExpander::addReference() { + bool InitExpander_old::addReference() { bool added = false; for ( Expression *& expr : cur ) { @@ -218,5 +226,5 @@ template< typename OutIterator > - void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) { + void build( UntypedExpr * callExpr, InitExpander_old::IndexList::iterator idx, InitExpander_old::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) { if ( idx == idxEnd ) return; Expression * index = *idx++; @@ -275,5 +283,5 @@ // remaining elements. // To accomplish this, generate switch statement, consuming all of expander's elements - Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) { + Statement * InitImpl_old::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) { if ( ! init ) return nullptr; CompoundStmt * block = new CompoundStmt(); @@ -288,11 +296,94 @@ } - Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) { + Statement * ExprImpl_old::buildListInit( UntypedExpr *, std::list< Expression * > & ) { return nullptr; } - Statement * InitExpander::buildListInit( UntypedExpr * dst ) { + Statement * InitExpander_old::buildListInit( UntypedExpr * dst ) { return expander->buildListInit( dst, indices ); } + +class InitExpander_new::ExpanderImpl { +public: + virtual ~ExpanderImpl() = default; + virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0; + virtual ast::ptr< ast::Stmt > buildListInit( + const ast::UntypedExpr * callExpr, IndexList & indices ) = 0; +}; + +namespace { + class InitImpl_new final : public InitExpander_new::ExpanderImpl { + ast::ptr< ast::Init > init; + public: + InitImpl_new( const ast::Init * i ) : init( i ) {} + + std::vector< ast::ptr< ast::Expr > > next( InitExpander_new::IndexList & ) override { + return makeInitList( init ); + } + + ast::ptr< ast::Stmt > buildListInit( + const ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices + ) override { + #warning unimplemented + (void)callExpr; (void)indices; + assert(false); + return {}; + } + }; + + class ExprImpl_new final : public InitExpander_new::ExpanderImpl { + ast::ptr< ast::Expr > arg; + public: + ExprImpl_new( const ast::Expr * a ) : arg( a ) {} + + std::vector< ast::ptr< ast::Expr > > next( + InitExpander_new::IndexList & indices + ) override { + #warning unimplemented + (void)indices; + assert(false); + return {}; + } + + ast::ptr< ast::Stmt > buildListInit( + const ast::UntypedExpr *, InitExpander_new::IndexList & + ) override { + return {}; + } + }; +} // anonymous namespace + +InitExpander_new::InitExpander_new( const ast::Init * init ) +: expander( new InitImpl_new{ init } ), crnt(), indices() {} + +InitExpander_new::InitExpander_new( const ast::Expr * expr ) +: expander( new ExprImpl_new{ expr } ), crnt(), indices() {} + +std::vector< ast::ptr< ast::Expr > > InitExpander_new::operator* () { return crnt; } + +InitExpander_new & InitExpander_new::operator++ () { + crnt = expander->next( indices ); + return *this; +} + +/// builds statement which has the same semantics as a C-style list initializer (for array +/// initializers) using callExpr as the base expression to perform initialization +ast::ptr< ast::Stmt > InitExpander_new::buildListInit( const ast::UntypedExpr * callExpr ) { + return expander->buildListInit( callExpr, indices ); +} + +void InitExpander_new::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) { + indices.emplace_back( index ); + indices.emplace_back( dimension ); +} + +void InitExpander_new::clearArrayIndices() { indices.clear(); } + +bool InitExpander_new::addReference() { + for ( ast::ptr< ast::Expr > & expr : crnt ) { + expr = new ast::AddressExpr{ expr }; + } + return ! crnt.empty(); +} Type * getTypeofThis( FunctionType * ftype ) { Index: src/InitTweak/InitTweak.h =================================================================== --- src/InitTweak/InitTweak.h (revision 234b1cb4afd88ccf2b1f3e001a2eae5dc12ca39b) +++ src/InitTweak/InitTweak.h (revision b8524ca1420ff28d69347f46888a20baa805f797) @@ -44,4 +44,5 @@ /// transform Initializer into an argument list that can be passed to a call expression std::list< Expression * > makeInitList( Initializer * init ); + std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ); /// True if the resolver should try to construct dwt @@ -101,15 +102,15 @@ bool isConstExpr( Initializer * init ); - class InitExpander { + class InitExpander_old { public: // expand by stepping through init to get each list of arguments - InitExpander( Initializer * init ); + InitExpander_old( Initializer * init ); // always expand to expr - InitExpander( Expression * expr ); + InitExpander_old( Expression * expr ); // iterator-like interface std::list< Expression * > operator*(); - InitExpander & operator++(); + InitExpander_old & operator++(); // builds statement which has the same semantics as a C-style list initializer @@ -130,4 +131,36 @@ IndexList indices; }; + + class InitExpander_new { + public: + using IndexList = std::vector< ast::ptr< ast::Expr > >; + class ExpanderImpl; + + private: + std::shared_ptr< ExpanderImpl > expander; + std::vector< ast::ptr< ast::Expr > > crnt; + // invariant: list of size 2N (elements come in pairs [index, dimension]) + IndexList indices; + + public: + /// Expand by stepping through init to get each list of arguments + InitExpander_new( const ast::Init * init ); + + /// Always expand to expression + InitExpander_new( const ast::Expr * expr ); + + std::vector< ast::ptr< ast::Expr > > operator* (); + InitExpander_new & operator++ (); + + /// builds statement which has the same semantics as a C-style list initializer (for array + /// initializers) using callExpr as the base expression to perform initialization + ast::ptr< ast::Stmt > buildListInit( const ast::UntypedExpr * callExpr ); + + void addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ); + + void clearArrayIndices(); + + bool addReference(); + }; } // namespace