Changes in src/ResolvExpr/CurrentObject.cc [699a97d:8f06277]

File:

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

src/ResolvExpr/CurrentObject.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Tue Jun 13 15:28:32 2017
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Apr 10  9:40:00 2023
-// Update Count     : 18
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul  1 09:16:01 2022
+// Update Count     : 15
 //
 
@@ -593 +593 @@
 
 namespace ast {
-        /// Iterates members of a type by initializer.
-        class MemberIterator {
-        public:
-                virtual ~MemberIterator() {}
-
-                /// Internal set position based on iterator ranges.
-                virtual void setPosition(
-                        std::deque< ptr< Expr > >::const_iterator it,
-                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
-
-                /// Walks the current object using the given designators as a guide.
-                void setPosition( const std::deque< ptr< Expr > > & designators ) {
-                        setPosition( designators.begin(), designators.end() );
-                }
-
-                /// Retrieve the list of possible (Type,Designation) pairs for the
-                /// current position in the current object.
-                virtual std::deque< InitAlternative > operator* () const = 0;
-
-                /// True if the iterator is not currently at the end.
-                virtual operator bool() const = 0;
-
-                /// Moves the iterator by one member in the current object.
-                virtual MemberIterator & bigStep() = 0;
-
-                /// Moves the iterator by one member in the current subobject.
-                virtual MemberIterator & smallStep() = 0;
-
-                /// The type of the current object.
-                virtual const Type * getType() = 0;
-
-                /// The type of the current subobject.
-                virtual const Type * getNext() = 0;
-
-                /// Helper for operator*; aggregates must add designator to each init
-                /// alternative, but adding designators in operator* creates duplicates.
-                virtual std::deque< InitAlternative > first() const = 0;
-        };
-
         /// create a new MemberIterator that traverses a type correctly
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type );
@@ -671 +632 @@
         };
 
-        /// Iterates over an indexed type:
-        class IndexIterator : public MemberIterator {
-        protected:
+        /// Iterates array types
+        class ArrayIterator final : public MemberIterator {
                 CodeLocation location;
+                const ArrayType * array = nullptr;
+                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;
-                std::unique_ptr<MemberIterator> memberIter;
-        public:
-                IndexIterator( const CodeLocation & loc, size_t size ) :
-                        location( loc ), size( size )
-                {}
+                std::unique_ptr< MemberIterator > memberIter;
+
+                void setSize( const Expr * expr ) {
+                        auto res = eval( expr );
+                        if ( ! res.second ) {
+                                SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
+                        }
+                        size = res.first;
+                }
+
+        public:
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) : location( loc ), array( at ), base( at->base ) {
+                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, base ) );
+                        if ( at->isVarLen ) {
+                                SemanticError( location, at, "VLA initialization does not support @=: " );
+                        }
+                        setSize( at->dimension );
+                }
 
                 void setPosition( const Expr * expr ) {
@@ -690 +666 @@
                         auto arg = eval( expr );
                         index = arg.first;
+                        return;
 
                         // if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
@@ -707 +684 @@
 
                 void setPosition(
-                        std::deque<ast::ptr<ast::Expr>>::const_iterator begin,
-                        std::deque<ast::ptr<ast::Expr>>::const_iterator end
+                        std::deque< ptr< Expr > >::const_iterator begin,
+                        std::deque< ptr< Expr > >::const_iterator end
                 ) override {
                         if ( begin == end ) return;
@@ -719 +696 @@
 
                 operator bool() const override { return index < size; }
-        };
-
-        /// Iterates over the members of array types:
-        class ArrayIterator final : public IndexIterator {
-                const ArrayType * array = nullptr;
-                const Type * base = nullptr;
-
-                size_t getSize( const Expr * expr ) {
-                        auto res = eval( expr );
-                        if ( !res.second ) {
-                                SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
-                        }
-                        return res.first;
-                }
-
-        public:
-                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) :
-                                IndexIterator( loc, getSize( at->dimension) ),
-                                array( at ), base( at->base ) {
-                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
-                        memberIter.reset( createMemberIterator( loc, base ) );
-                        if ( at->isVarLen ) {
-                                SemanticError( location, at, "VLA initialization does not support @=: " );
-                        }
-                }
 
                 ArrayIterator & bigStep() override {
@@ -882 +834 @@
 
                 const Type * getNext() final {
-                        bool hasMember = memberIter && *memberIter;
-                        return hasMember ? memberIter->getType() : nullptr;
+                        return ( memberIter && *memberIter ) ? memberIter->getType() : nullptr;
                 }
 
@@ -947 +898 @@
         };
 
-        /// Iterates across the positions in a tuple:
-        class TupleIterator final : public IndexIterator {
-                ast::TupleType const * const tuple;
-
-                const ast::Type * typeAtIndex() const {
-                        assert( index < size );
-                        return tuple->types[ index ].get();
-                }
-
-        public:
-                TupleIterator( const CodeLocation & loc, const TupleType * type )
-                : IndexIterator( loc, type->size() ), tuple( type ) {
-                        PRINT( std::cerr << "Creating tuple iterator: " << type << std::endl; )
-                        memberIter.reset( createMemberIterator( loc, typeAtIndex() ) );
+        class TupleIterator final : public AggregateIterator {
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * inst )
+                : AggregateIterator(
+                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members
+                ) {}
+
+                operator bool() const override {
+                        return curMember != members.end() || (memberIter && *memberIter);
                 }
 
                 TupleIterator & bigStep() override {
-                        ++index;
-                        memberIter.reset( index < size ?
-                                createMemberIterator( location, typeAtIndex() ) : nullptr );
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        while ( curMember != members.end() ) {
+                                ++curMember;
+                                if ( init() ) return *this;
+                        }
                         return *this;
-                }
-
-                TupleIterator & smallStep() override {
-                        if ( memberIter ) {
-                                PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; )
-                                memberIter->smallStep();
-                                if ( !memberIter ) {
-                                        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 {
-                        bool hasMember = memberIter && *memberIter;
-                        return hasMember ? memberIter->getType() : nullptr;
-                }
-
-                std::deque< InitAlternative > first() const override {
-                        PRINT( std::cerr << "first in TupleIterator (" << index << "/" << size << ")" << std::endl; )
-                        if ( memberIter && *memberIter ) {
-                                std::deque< InitAlternative > ret = memberIter->first();
-                                for ( InitAlternative & alt : ret ) {
-                                        alt.designation.get_and_mutate()->designators.emplace_front(
-                                                ConstantExpr::from_ulong( location, index ) );
-                                }
-                                return ret;
-                        }
-                        return {};
                 }
         };