Changeset f8143a6 for src/AST/Pass.hpp

Timestamp:

Feb 7, 2022, 12:50:05 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

250583e

Parents:

b56ad5e

Message:

Change pass visitor to avoid more transient strong references

File:

• src/AST/Pass.hpp (modified) (1 diff)

src/AST/Pass.hpp

@@ -238 +238 @@
 
 private:
-        const ast::Stmt * call_accept( const ast::Stmt * );
-        const ast::Expr * call_accept( const ast::Expr * );
-
-        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
-
-        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
-
+
+        // Regular nodes
         template< typename node_t >
-        auto call_accept( const node_t * node ) -> typename std::enable_if<
+        struct result1 {
+                bool differs;
+                const node_t * value;
+
+                template< typename object_t, typename super_t, typename field_t >
+                void apply(object_t *, field_t super_t::* field);
+        };
+
+        result1<ast::Stmt> call_accept( const ast::Stmt * );
+        result1<ast::Expr> call_accept( const ast::Expr * );
+
+        template< typename node_t >
+        auto call_accept( const node_t * node )
+                -> typename std::enable_if<
                                 !std::is_base_of<ast::Expr, node_t>::value &&
                                 !std::is_base_of<ast::Stmt, node_t>::value
-                        , decltype( node->accept(*this) )
+                        , result1<
+                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
+                        >
                 >::type;
 
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+        result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
+
+        template<typename it_t, template <class...> class container_t>
+                static inline void take_all_delta( it_t it, container_t<ast::ptr<ast::Decl>> * decls, bool * mutated = nullptr ) {
+                        if(empty(decls)) return;
+
+                        std::transform(decls->begin(), decls->end(), it, [](ast::ptr<ast::Decl>&& decl) -> auto {
+                                        auto loc = decl->location;
+                                        auto stmt = new DeclStmt( loc, decl.release() );
+                                        return { {stmt}, -1, false };
+                                });
+                        decls->clear();
+                        if(mutated) *mutated = true;
+                }
+
+        // Container of statements
         template< template <class...> class container_t >
-        container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & );
-
+        struct resultNstmt {
+                struct delta {
+                        ptr<Stmt> nval;
+                        ssize_t old_idx;
+                        bool is_old;
+
+                        delta(const Stmt * s, ssize_t i, bool old) : nval{s}, old_idx{i}, is_old{old} {}
+                };
+
+                bool differs;
+                container_t< delta > values;
+
+                resultNstmt() : differs(false), values{} {}
+                resultNstmt(bool diff, container_t< delta > && vals) : differs(diff), values(vals) {}
+
+                template< typename object_t, typename super_t, typename field_t >
+                void apply(object_t *, field_t super_t::* field);
+
+                template< template <class...> class incontainer_t >
+                void take_all( incontainer_t<ast::ptr<ast::Stmt>> * stmts ) {
+                        if(!stmts || stmts->empty()) return;
+
+                        std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ), [](ast::ptr<ast::Stmt>& decl) -> delta {
+                                        return delta( decl.release(), -1, false );
+                                });
+                        stmts->clear();
+                        differs = true;
+                }
+
+                template< template <class...> class incontainer_t >
+                void take_all( incontainer_t<ast::ptr<ast::Decl>> * decls ) {
+                        if(!decls || decls->empty()) return;
+
+                        std::transform(decls->begin(), decls->end(), std::back_inserter( values ), [](ast::ptr<ast::Decl>& decl) -> auto {
+                                        auto loc = decl->location;
+                                        auto stmt = new DeclStmt( loc, decl.release() );
+                                        return delta( stmt, -1, false );
+                                });
+                        decls->clear();
+                        differs = true;
+                }
+        };
+
+        template< template <class...> class container_t >
+        resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
+
+        // Container of something
         template< template <class...> class container_t, typename node_t >
-        container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
+        struct resultN {
+                bool differs;
+                container_t<ptr<node_t>> values;
+
+                template< typename object_t, typename super_t, typename field_t >
+                void apply(object_t *, field_t super_t::* field);
+        };
+
+        template< template <class...> class container_t, typename node_t >
+        resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container );
 
 public:
         /// Logic to call the accept and mutate the parent if needed, delegates call to accept
-        template<typename node_t, typename parent_t, typename child_t>
-        void maybe_accept(const node_t * &, child_t parent_t::* child);
-
-        template<typename node_t, typename parent_t, typename child_t>
-        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
+        template<typename node_t, typename parent_t, typename field_t>
+        void maybe_accept(const node_t * &, field_t parent_t::* field);
+
+        template<typename node_t, typename parent_t, typename field_t>
+        void maybe_accept_as_compound(const node_t * &, field_t parent_t::* field);
 
 private: