Changeset 6adeb5f for src

Timestamp:

Apr 10, 2023, 9:25:28 PM (22 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

a1b41e3

Parents:

372b6d3 (diff), a085470 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/ResolvExpr/CurrentObject.cc (modified) (2 diffs)

src/ResolvExpr/CurrentObject.cc

@@ -10 +10 @@
 // Created On       : Tue Jun 13 15:28:32 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Apr  6 16:25:00 2023
-// Update Count     : 17
+// Last Modified On : Mon Apr 10  9:40:00 2023
+// Update Count     : 18
 //
 
@@ -937 +937 @@
         };
 
-        class TupleIterator final : public AggregateIterator {
-                MemberList * memberList;
-
-                TupleIterator( const CodeLocation & loc,
-                        const ast::TupleType * inst, MemberList * memberList )
-                : AggregateIterator(
-                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, *memberList
-                ), memberList( memberList ) {}
-
-                // The two layer constructor, this helper and the destructor
-                // are all to pretend that Tuples have members (they do not).
-                static MemberList * newImaginaryMembers( const ast::TupleType * inst ) {
-                        auto ret = new MemberList();
-                        ret->reserve( inst->types.size() );
-                        for ( const ast::Type * type : inst->types ) {
-                                ret->emplace_back( new ast::ObjectDecl(
-                                        CodeLocation(), "", type,
-                                        new ast::ListInit( CodeLocation(), {}, {}, ast::NoConstruct )
-                                ) );
-                        }
-                        return ret;
-                }
-
-        public:
-                TupleIterator( const CodeLocation & loc, const TupleType * inst )
-                : TupleIterator( loc, inst, newImaginaryMembers( inst ) ) {}
-
-                virtual ~TupleIterator() {
-                        delete memberList;
+        /// Iterates across the positions in a tuple:
+        class TupleIterator final : public MemberIterator {
+                CodeLocation location;
+                ast::TupleType const * const tuple;
+                size_t index = 0;
+                size_t size = 0;
+                std::unique_ptr<MemberIterator> sub_iter;
+
+                const ast::Type * typeAtIndex() const {
+                        assert( index < size );
+                        return tuple->types[ index ].get();
+                }
+
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * type )
+                : location( loc ), tuple( type ), size( type->size() ) {
+                        PRINT( std::cerr << "Creating tuple iterator: " << type << std::endl; )
+                        sub_iter.reset( createMemberIterator( loc, typeAtIndex() ) );
+                }
+
+                void setPosition( const ast::Expr * expr ) {
+                        auto arg = eval( expr );
+                        index = arg.first;
+                }
+
+                void setPosition(
+                                std::deque< ptr< Expr > >::const_iterator begin,
+                                std::deque< ptr< Expr > >::const_iterator end ) {
+                        if ( begin == end ) return;
+
+                        setPosition( *begin );
+                        sub_iter->setPosition( ++begin, end );
+                }
+
+                std::deque< InitAlternative > operator*() const override {
+                        return first();
                 }
 
                 operator bool() const override {
-                        return curMember != members.end() || (memberIter && *memberIter);
+                        return index < size;
                 }
 
                 TupleIterator & bigStep() override {
-                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
-                        atbegin = false;
-                        memberIter = nullptr;
-                        curType = nullptr;
-                        while ( curMember != members.end() ) {
-                                ++curMember;
-                                if ( init() ) return *this;
-                        }
+                        ++index;
+                        sub_iter.reset( index < size ?
+                                createMemberIterator( location, typeAtIndex() ) : nullptr );
                         return *this;
+                }
+
+                TupleIterator & smallStep() override {
+                        if ( sub_iter ) {
+                                PRINT( std::cerr << "has member iter: " << *sub_iter << std::endl; )
+                                sub_iter->smallStep();
+                                if ( !sub_iter ) {
+                                        PRINT( std::cerr << "has valid member iter" << std::endl; )
+                                        return *this;
+                                }
+                        }
+                        return bigStep();
+                }
+
+                const ast::Type * getType() override {
+                        return tuple;
+                }
+
+                const ast::Type * getNext() override {
+                        return ( sub_iter && *sub_iter ) ? sub_iter->getType() : nullptr;
+                }
+
+                std::deque< InitAlternative > first() const override {
+                        PRINT( std::cerr << "first in TupleIterator (" << index << "/" << size << ")" << std::endl; )
+                        if ( sub_iter && *sub_iter ) {
+                                std::deque< InitAlternative > ret = sub_iter->first();
+                                for ( InitAlternative & alt : ret ) {
+                                        alt.designation.get_and_mutate()->designators.emplace_front(
+                                                ConstantExpr::from_ulong( location, index ) );
+                                }
+                                return ret;
+                        }
+                        return {};
                 }
         };