Changeset 24d6572 for src/ResolvExpr/CurrentObject.cc

Timestamp:

Jun 12, 2023, 2:45:32 PM (2 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ast-experimental, master

Children:

62d62db

Parents:

34b4268 (diff), 251ce80 (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' into ast-experimental

File:

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

src/ResolvExpr/CurrentObject.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Tue Jun 13 15:28:32 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul  1 09:16:01 2022
-// Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr 10  9:40:00 2023
+// Update Count     : 18
 //
 
@@ -26 +26 @@
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
-#include "AST/Print.hpp"                // for readonly
+#include "AST/Print.hpp"               // for readonly
 #include "AST/Type.hpp"
+#include "Common/Eval.h"               // for eval
 #include "Common/Indenter.h"           // for Indenter, operator<<
 #include "Common/SemanticError.h"      // for SemanticError
@@ -592 +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 );
@@ -631 +671 @@
         };
 
-        /// Iterates array types
-        class ArrayIterator final : public MemberIterator {
+        /// Iterates over an indexed type:
+        class IndexIterator : public MemberIterator {
+        protected:
                 CodeLocation location;
-                const ArrayType * array = nullptr;
-                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;
-                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 );
-                }
+                std::unique_ptr<MemberIterator> memberIter;
+        public:
+                IndexIterator( const CodeLocation & loc, size_t size ) :
+                        location( loc ), size( size )
+                {}
 
                 void setPosition( const Expr * expr ) {
@@ -665 +690 @@
                         auto arg = eval( expr );
                         index = arg.first;
-                        return;
 
                         // if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
@@ -683 +707 @@
 
                 void setPosition(
-                        std::deque< ptr< Expr > >::const_iterator begin,
-                        std::deque< ptr< Expr > >::const_iterator end
+                        std::deque<ast::ptr<ast::Expr>>::const_iterator begin,
+                        std::deque<ast::ptr<ast::Expr>>::const_iterator end
                 ) override {
                         if ( begin == end ) return;
@@ -695 +719 @@
 
                 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 {
@@ -833 +882 @@
 
                 const Type * getNext() final {
-                        return ( memberIter && *memberIter ) ? memberIter->getType() : nullptr;
+                        bool hasMember = memberIter && *memberIter;
+                        return hasMember ? memberIter->getType() : nullptr;
                 }
 
@@ -897 +947 @@
         };
 
-        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);
+        /// 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() ) );
                 }
 
                 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;
+                        memberIter.reset( index < size ?
+                                createMemberIterator( location, typeAtIndex() ) : nullptr );
                         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 {};
                 }
         };