Changeset 39f84a4


Ignore:
Timestamp:
Jul 29, 2016, 11:40:28 AM (5 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, 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:
6 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/GenInit.cc

    r29e8bf5 r39f84a4  
    225225                                        std::list< Statement * > dtor;
    226226
    227                                         SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
    228                                         SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
     227                                        InitExpander srcParam( (Expression *)NULL );
     228                                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
     229                                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
    229230
    230231                                        // Currently genImplicitCall produces a single Statement - a CompoundStmt
  • src/InitTweak/InitTweak.cc

    r29e8bf5 r39f84a4  
    2020                };
    2121
    22                 class InitExpander : public Visitor {
     22                class InitExpander_OLD : public Visitor {
    2323                        public:
    24                         InitExpander() {}
    2524                        virtual void visit( SingleInit * singleInit );
    2625                        virtual void visit( ListInit * listInit );
     
    2827                };
    2928
    30                 void InitExpander::visit( SingleInit * singleInit ) {
     29                void InitExpander_OLD::visit( SingleInit * singleInit ) {
    3130                        argList.push_back( singleInit->get_value()->clone() );
    3231                }
    3332
    34                 void InitExpander::visit( ListInit * listInit ) {
     33                void InitExpander_OLD::visit( ListInit * listInit ) {
    3534                        // xxx - for now, assume no nested list inits
    3635                        std::list<Initializer*>::iterator it = listInit->begin_initializers();
     
    4241
    4342        std::list< Expression * > makeInitList( Initializer * init ) {
    44                 InitExpander expander;
     43                InitExpander_OLD expander;
    4544                maybeAccept( init, expander );
    4645                return expander.argList;
     
    5150                maybeAccept( init, finder );
    5251                return finder.hasDesignations;
     52        }
     53
     54        class InitExpander::ExpanderImpl {
     55        public:
     56                virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
     57        };
     58
     59        class InitImpl : public InitExpander::ExpanderImpl {
     60        public:
     61                InitImpl( Initializer * init ) {
     62                        if ( init ) inits.push_back( init );
     63                }
     64
     65                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
     66                        // this is wrong, but just a placeholder for now
     67                        return ! inits.empty() ? makeInitList( inits.front() ) : std::list< Expression * >();
     68                }
     69        private:
     70                std::list< Initializer * > inits;
     71        };
     72
     73        class ExprImpl : public InitExpander::ExpanderImpl {
     74        public:
     75                ExprImpl( Expression * expr ) : arg( expr ) {}
     76
     77                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
     78                        std::list< Expression * > ret;
     79                        Expression * expr = maybeClone( arg );
     80                        if ( expr ) {
     81                                for ( std::list< Expression * >::reverse_iterator it = indices.rbegin(); it != indices.rend(); ++it ) {
     82                                        // go through indices and layer on subscript exprs ?[?]
     83                                        ++it;
     84                                        UntypedExpr * subscriptExpr = new UntypedExpr( new NameExpr( "?[?]") );
     85                                        subscriptExpr->get_args().push_back( expr );
     86                                        subscriptExpr->get_args().push_back( (*it)->clone() );
     87                                        expr = subscriptExpr;
     88                                }
     89                                ret.push_back( expr );
     90                        }
     91                        return ret;
     92                }
     93        private:
     94                Expression * arg;
     95        };
     96
     97        InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
     98
     99        InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
     100
     101        std::list< Expression * > InitExpander::operator*() {
     102                return cur;
     103        }
     104
     105        InitExpander & InitExpander::operator++() {
     106                cur = expander->next( indices );
     107                return *this;
     108        }
     109
     110        // use array indices list to build switch statement
     111        void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
     112                indices.push_back( index );
     113                indices.push_back( dimension );
     114        }
     115
     116        template< typename OutIterator >
     117        void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator end, OutIterator out ) {
     118                if ( idx == end ) return;
     119                Expression * index = *idx++;
     120                assert( idx != end );
     121                Expression * dimension = *idx++;
     122
     123                // if ( idx == end ) {
     124                //      // loop through list of expressions belonging to the current initializer
     125                //      UntypedExpr * cond = new UntypedExpr( new NameExpr( "?<?") );
     126                //      cond->get_args().push_back( index->clone() );
     127                //      cond->get_args().push_back( dimension->clone() );
     128
     129                //      UntypedExpr * call = callExpr->clone();
     130                //      std::list< Expression * > args = *++expander; // xxx - need a way to indentify the end of an init list
     131                //      call->get_args().splice( args );
     132
     133                //      *out++ = new IfStmt( noLabels, cond, new ExprStmt( call ), NULL );
     134
     135                //      UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
     136                //      increment->get_args().push_back( index->clone() );
     137                //      *out++ = new ExprStmt( increment );
     138                // } else {
     139                //      std::list< Statement * > branches;
     140                //      for (...) { // loop over conditions?
     141                //              std::list< Statement * > stmts;
     142                //              build( idx, end, back_inserter( stmts ) );
     143                //              CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
     144                //              branches.push_back( caseStmt );
     145                //      }
     146                //      *out++ = new SwitchStmt( noLabels, index->clone(), branches );
     147                // }
     148        }
     149
     150        // generate switch statement, consuming all of expander's elements
     151        Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
     152                std::list< Statement * > results;
     153                build( dst, indices.begin(), indices.end(), back_inserter( results ) );
     154                assert( results.size() <= 1 );
     155                return ! results.empty() ? results.front() : NULL;
    53156        }
    54157
  • src/InitTweak/InitTweak.h

    r29e8bf5 r39f84a4  
    6161        bool isConstExpr( Expression * expr );
    6262        bool isConstExpr( Initializer * init );
     63
     64        class InitExpander {
     65        public:
     66                // expand by stepping through init to get each list of arguments
     67                InitExpander( Initializer * init );
     68
     69                // always expand to expr
     70                InitExpander( Expression * expr );
     71
     72                // iterator-like interface
     73                std::list< Expression * > operator*();
     74                InitExpander & operator++();
     75
     76                // builds statement which has the same semantics as a C-style list initializer
     77                // (for array initializers) using callExpr as the base expression to perform initialization
     78                Statement * buildListInit( UntypedExpr * callExpr );
     79                void addArrayIndex( Expression * index, Expression * dimension );
     80
     81                class ExpanderImpl;
     82        private:
     83                std::shared_ptr< ExpanderImpl > expander;
     84                std::list< Expression * > cur;
     85
     86                // invariant: list of size 2N (elements come in pairs [index, dimension])
     87                typedef std::list< Expression * > IndexList;
     88                IndexList indices;
     89        };
    6390} // namespace
    6491
  • src/SymTab/Autogen.cc

    r29e8bf5 r39f84a4  
    189189                }
    190190
     191                InitTweak::InitExpander srcParam( src );
     192
    191193                // assign to destination (and return value if generic)
    192194                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
    193195                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
    194196                Expression *dstselect = new MemberExpr( field, derefExpr );
    195                 genImplicitCall( src, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
     197                genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
    196198
    197199                if ( isGeneric && returnVal ) {
     
    199201                        derefRet->get_args().push_back( new VariableExpr( returnVal ) );
    200202                        Expression *retselect = new MemberExpr( field, derefRet );
    201                         genImplicitCall( src, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
     203                        genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
    202204                } // if
    203205        }
  • src/SymTab/Autogen.h

    r29e8bf5 r39f84a4  
    2222#include "SynTree/Declaration.h"
    2323#include "SynTree/Initializer.h"
     24#include "InitTweak/InitTweak.h"
    2425
    2526namespace SymTab {
     
    3637        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
    3738        template< typename OutputIterator >
    38         void genCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward = true );
     39        void genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward = true );
    3940
    4041        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
    4142        template< typename OutputIterator >
    42         void genScalarCall( Expression *srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
     43        void genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
    4344                // want to be able to generate assignment, ctor, and dtor generically,
    4445                // so fname is either ?=?, ?{}, or ^?{}
     
    4849                fExpr->get_args().push_back( new AddressExpr( dstParam ) );
    4950
    50                 if ( srcParam ) {
     51    Statement * listInit = srcParam.buildListInit( fExpr );
     52    if ( listInit ) {
     53      *out++ = listInit;
     54    }
     55
     56    std::list< Expression * > args = *++srcParam;
     57    fExpr->get_args().splice( fExpr->get_args().end(), args );
     58/*              if ( srcParam ) {
     59                        // xxx -
     60                        // make srcParam more complicated
     61                        // if srcParam contains
    5162                        fExpr->get_args().push_back( srcParam );
    5263                }
    53 
     64*/
    5465                *out++ = new ExprStmt( noLabels, fExpr );
    5566        }
     
    5869        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
    5970        template< typename OutputIterator >
    60         void genArrayCall( Expression *srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool forward = true ) {
     71        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool forward = true ) {
    6172                static UniqueName indexName( "_index" );
    6273
     
    100111                dstParam = dstIndex;
    101112
    102                 // srcParam is NULL for default ctor/dtor
    103                 if ( srcParam ) {
    104                         UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
    105                         srcIndex->get_args().push_back( srcParam );
    106                         srcIndex->get_args().push_back( new VariableExpr( index ) );
    107                         srcParam = srcIndex;
    108                 }
     113                // srcParam must keep track of the array indices to build the
     114                // source parameter and/or array list initializer
     115                srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
     116
     117                // if ( srcParam ) {
     118                //      UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
     119                //      srcIndex->get_args().push_back( srcParam );
     120                //      srcIndex->get_args().push_back( new VariableExpr( index ) );
     121                //      srcParam = srcIndex;
     122                // }
    109123
    110124                // for stmt's body, eventually containing call
     
    122136
    123137        template< typename OutputIterator >
    124         void genCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward ) {
     138        void genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward ) {
    125139                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
    126140                        genArrayCall( srcParam, dstParam, fname, out, at, forward );
     
    135149        /// ImplicitCtorDtorStmt node.
    136150        template< typename OutputIterator >
    137         void genImplicitCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
     151        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
    138152                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
    139153                assert( obj );
  • src/SynTree/Expression.cc

    r29e8bf5 r39f84a4  
    344344}
    345345
     346//// is this right? It's cloning the member, but the member is a declaration so probably shouldn't be cloned...
    346347MemberExpr::MemberExpr( const MemberExpr &other ) :
    347                 Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
     348                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
    348349}
    349350
    350351MemberExpr::~MemberExpr() {
    351         delete member;
     352        // delete member;
    352353        delete aggregate;
    353354}
Note: See TracChangeset for help on using the changeset viewer.