Changeset b8524ca for src/InitTweak

Timestamp:

Jun 20, 2019, 6:50:42 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

9af00d23

Parents:

234b1cb

Message:

new AST porting

• mostly InitTweak? autogeneration
• added some convenience methods
  • nullptr assignment for ast::ptr
  • convenience wrapper ctors for AddressExpr?, CastExpr? that draw location from first arg

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (1 diff)
• GenInit.cc (modified) (4 diffs)
• GenInit.h (modified) (2 diffs)
• InitTweak.cc (modified) (9 diffs)
• InitTweak.h (modified) (3 diffs)

src/InitTweak/FixInit.cc ¶

@@ -1111 +1111 @@
                                                 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() );

src/InitTweak/GenInit.cc ¶

@@ -18 +18 @@
 #include <algorithm>                   // for any_of
 #include <cassert>                     // for assert, strict_dynamic_cast, assertf
+#include <deque>
 #include <iterator>                    // for back_inserter, inserter, back_inse...
 #include <list>                        // 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 +279 @@
                 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 +291 @@
                 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 +359 @@
         }
 
-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;
 }

src/InitTweak/GenInit.h ¶

@@ -20 +20 @@
 
 #include "AST/Fwd.hpp"
+#include "Common/CodeLocation.h"
 #include "GenPoly/ScopedSet.h" // for ScopedSet
 #include "SynTree/SynTree.h"   // for Visitor Nodes
@@ -35 +36 @@
         /// 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 {

src/InitTweak/InitTweak.cc ¶

@@ -22 +22 @@
 
 #include "AST/Expr.hpp"
+#include "AST/Node.hpp"
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
@@ -112 +113 @@
         }
 
-        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 +127 @@
         };
 
-        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 +144 @@
         };
 
-        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 +171 @@
         };
 
-        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 +185 @@
 
         // 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 +226 @@
 
                 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 +283 @@
         // 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 +296 @@
         }
 
-        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 ) {

src/InitTweak/InitTweak.h ¶

@@ -44 +44 @@
         /// 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 +102 @@
         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 +131 @@
                 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