Changeset 39f84a4

Timestamp:

Jul 29, 2016, 11:40:28 AM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

4d2434a

Parents:

29e8bf5

Message:

part-way through reorganizing ctor call generation so that it is more general

Location:

src

Files:

• InitTweak/GenInit.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (4 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• SymTab/Autogen.cc (modified) (2 diffs)
• SymTab/Autogen.h (modified) (7 diffs)
• SynTree/Expression.cc (modified) (1 diff)

src/InitTweak/GenInit.cc

@@ -225 +225 @@
                                         std::list< Statement * > dtor;
 
-                                        SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
-                                        SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
+                                        InitExpander srcParam( (Expression *)NULL );
+                                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
+                                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
 
                                         // Currently genImplicitCall produces a single Statement - a CompoundStmt

src/InitTweak/InitTweak.cc

@@ -20 +20 @@
                 };
 
-                class InitExpander : public Visitor {
+                class InitExpander_OLD : public Visitor {
                         public:
-                        InitExpander() {}
                         virtual void visit( SingleInit * singleInit );
                         virtual void visit( ListInit * listInit );
@@ -28 +27 @@
                 };
 
-                void InitExpander::visit( SingleInit * singleInit ) {
+                void InitExpander_OLD::visit( SingleInit * singleInit ) {
                         argList.push_back( singleInit->get_value()->clone() );
                 }
 
-                void InitExpander::visit( ListInit * listInit ) {
+                void InitExpander_OLD::visit( ListInit * listInit ) {
                         // xxx - for now, assume no nested list inits
                         std::list<Initializer*>::iterator it = listInit->begin_initializers();
@@ -42 +41 @@
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                InitExpander expander;
+                InitExpander_OLD expander;
                 maybeAccept( init, expander );
                 return expander.argList;
@@ -51 +50 @@
                 maybeAccept( init, finder );
                 return finder.hasDesignations;
+        }
+
+        class InitExpander::ExpanderImpl {
+        public:
+                virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
+        };
+
+        class InitImpl : public InitExpander::ExpanderImpl {
+        public:
+                InitImpl( Initializer * init ) {
+                        if ( init ) inits.push_back( init );
+                }
+
+                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+                        // this is wrong, but just a placeholder for now
+                        return ! inits.empty() ? makeInitList( inits.front() ) : std::list< Expression * >();
+                }
+        private:
+                std::list< Initializer * > inits;
+        };
+
+        class ExprImpl : public InitExpander::ExpanderImpl {
+        public:
+                ExprImpl( Expression * expr ) : arg( expr ) {}
+
+                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+                        std::list< Expression * > ret;
+                        Expression * expr = maybeClone( arg );
+                        if ( expr ) {
+                                for ( std::list< Expression * >::reverse_iterator it = indices.rbegin(); it != indices.rend(); ++it ) {
+                                        // go through indices and layer on subscript exprs ?[?]
+                                        ++it;
+                                        UntypedExpr * subscriptExpr = new UntypedExpr( new NameExpr( "?[?]") );
+                                        subscriptExpr->get_args().push_back( expr );
+                                        subscriptExpr->get_args().push_back( (*it)->clone() );
+                                        expr = subscriptExpr;
+                                }
+                                ret.push_back( expr );
+                        }
+                        return ret;
+                }
+        private:
+                Expression * arg;
+        };
+
+        InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
+
+        InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
+
+        std::list< Expression * > InitExpander::operator*() {
+                return cur;
+        }
+
+        InitExpander & InitExpander::operator++() {
+                cur = expander->next( indices );
+                return *this;
+        }
+
+        // use array indices list to build switch statement
+        void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
+                indices.push_back( index );
+                indices.push_back( dimension );
+        }
+
+        template< typename OutIterator >
+        void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator end, OutIterator out ) {
+                if ( idx == end ) return;
+                Expression * index = *idx++;
+                assert( idx != end );
+                Expression * dimension = *idx++;
+
+                // if ( idx == end ) {
+                //      // loop through list of expressions belonging to the current initializer
+                //      UntypedExpr * cond = new UntypedExpr( new NameExpr( "?<?") );
+                //      cond->get_args().push_back( index->clone() );
+                //      cond->get_args().push_back( dimension->clone() );
+
+                //      UntypedExpr * call = callExpr->clone();
+                //      std::list< Expression * > args = *++expander; // xxx - need a way to indentify the end of an init list
+                //      call->get_args().splice( args );
+
+                //      *out++ = new IfStmt( noLabels, cond, new ExprStmt( call ), NULL );
+
+                //      UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
+                //      increment->get_args().push_back( index->clone() );
+                //      *out++ = new ExprStmt( increment );
+                // } else {
+                //      std::list< Statement * > branches;
+                //      for (...) { // loop over conditions?
+                //              std::list< Statement * > stmts;
+                //              build( idx, end, back_inserter( stmts ) );
+                //              CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
+                //              branches.push_back( caseStmt );
+                //      }
+                //      *out++ = new SwitchStmt( noLabels, index->clone(), branches );
+                // }
+        }
+
+        // generate switch statement, consuming all of expander's elements
+        Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
+                std::list< Statement * > results;
+                build( dst, indices.begin(), indices.end(), back_inserter( results ) );
+                assert( results.size() <= 1 );
+                return ! results.empty() ? results.front() : NULL;
         }
 

src/InitTweak/InitTweak.h

@@ -61 +61 @@
         bool isConstExpr( Expression * expr );
         bool isConstExpr( Initializer * init );
+
+        class InitExpander {
+        public:
+                // expand by stepping through init to get each list of arguments
+                InitExpander( Initializer * init );
+
+                // always expand to expr
+                InitExpander( Expression * expr );
+
+                // iterator-like interface
+                std::list< Expression * > operator*();
+                InitExpander & 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
+                Statement * buildListInit( UntypedExpr * callExpr );
+                void addArrayIndex( Expression * index, Expression * dimension );
+
+                class ExpanderImpl;
+        private:
+                std::shared_ptr< ExpanderImpl > expander;
+                std::list< Expression * > cur;
+
+                // invariant: list of size 2N (elements come in pairs [index, dimension])
+                typedef std::list< Expression * > IndexList;
+                IndexList indices;
+        };
 } // namespace
 

src/SymTab/Autogen.cc

@@ -189 +189 @@
                 }
 
+                InitTweak::InitExpander srcParam( src );
+
                 // assign to destination (and return value if generic)
                 UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
                 derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
                 Expression *dstselect = new MemberExpr( field, derefExpr );
-                genImplicitCall( src, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
+                genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
 
                 if ( isGeneric && returnVal ) {
@@ -199 +201 @@
                         derefRet->get_args().push_back( new VariableExpr( returnVal ) );
                         Expression *retselect = new MemberExpr( field, derefRet );
-                        genImplicitCall( src, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
+                        genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
                 } // if
         }

src/SymTab/Autogen.h

@@ -22 +22 @@
 #include "SynTree/Declaration.h"
 #include "SynTree/Initializer.h"
+#include "InitTweak/InitTweak.h"
 
 namespace SymTab {
@@ -36 +37 @@
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        void genCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward = true );
+        void genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         template< typename OutputIterator >
-        void genScalarCall( Expression *srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
+        void genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
                 // want to be able to generate assignment, ctor, and dtor generically,
                 // so fname is either ?=?, ?{}, or ^?{}
@@ -48 +49 @@
                 fExpr->get_args().push_back( new AddressExpr( dstParam ) );
 
-                if ( srcParam ) {
+    Statement * listInit = srcParam.buildListInit( fExpr );
+    if ( listInit ) {
+      *out++ = listInit;
+    }
+
+    std::list< Expression * > args = *++srcParam;
+    fExpr->get_args().splice( fExpr->get_args().end(), args );
+/*              if ( srcParam ) {
+                        // xxx -
+                        // make srcParam more complicated
+                        // if srcParam contains
                         fExpr->get_args().push_back( srcParam );
                 }
-
+*/
                 *out++ = new ExprStmt( noLabels, fExpr );
         }
@@ -58 +69 @@
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( Expression *srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
@@ -100 +111 @@
                 dstParam = dstIndex;
 
-                // srcParam is NULL for default ctor/dtor
-                if ( srcParam ) {
-                        UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-                        srcIndex->get_args().push_back( srcParam );
-                        srcIndex->get_args().push_back( new VariableExpr( index ) );
-                        srcParam = srcIndex;
-                }
+                // srcParam must keep track of the array indices to build the
+                // source parameter and/or array list initializer
+                srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
+
+                // if ( srcParam ) {
+                //      UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+                //      srcIndex->get_args().push_back( srcParam );
+                //      srcIndex->get_args().push_back( new VariableExpr( index ) );
+                //      srcParam = srcIndex;
+                // }
 
                 // for stmt's body, eventually containing call
@@ -122 +136 @@
 
         template< typename OutputIterator >
-        void genCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward ) {
+        void genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, forward );
@@ -135 +149 @@
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
-        void genImplicitCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+        void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                 assert( obj );

src/SynTree/Expression.cc

@@ -344 +344 @@
 }
 
+//// is this right? It's cloning the member, but the member is a declaration so probably shouldn't be cloned...
 MemberExpr::MemberExpr( const MemberExpr &other ) :
-                Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
 
 MemberExpr::~MemberExpr() {
-        delete member;
+        // delete member;
         delete aggregate;
 }