Changes in src/AST/Node.hpp [18e683b:52a4d69]

File:

• src/AST/Node.hpp (modified) (10 diffs)

src/AST/Node.hpp

@@ -10 +10 @@
 // Created On       : Wed May 8 10:27:04 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Jun  3 13:26:00 2019
-// Update Count     : 5
+// Last Modified On : Fri Jun 5 9:47:00 2020
+// Update Count     : 6
 //
 
@@ -38 +38 @@
         Node& operator= (const Node&) = delete;
         Node& operator= (Node&&) = delete;
-        virtual ~Node() = default;
+        virtual ~Node() {}
 
         virtual const Node * accept( Visitor & v ) const = 0;
@@ -57 +57 @@
         template<typename node_t>
         friend node_t * mutate(const node_t * node);
+        template<typename node_t>
+        friend node_t * shallowCopy(const node_t * node);
 
         mutable size_t strong_count = 0;
@@ -69 +71 @@
         }
 
-        void decrement(ast::Node::ref_type ref) const {
+        void decrement(ast::Node::ref_type ref, bool do_delete = true) const {
                 switch (ref) {
                         case ref_type::strong: strong_count--; break;
@@ -75 +77 @@
                 }
 
-                if(!strong_count && !weak_count) {
+                if( do_delete && !strong_count && !weak_count) {
                         delete this;
                 }
@@ -94 +96 @@
         assertf(
                 node->weak_count == 0,
-                "Error: mutating node with weak references to it will invalided some references"
+                "Error: mutating node with weak references to it will invalidate some references"
         );
         return node->clone();
@@ -104 +106 @@
         // skip mutate if equivalent
         if ( node->*field == val ) return node;
-        
+
         // mutate and return
         node_t * ret = mutate( node );
@@ -123 +125 @@
         (ret->*field)[i] = std::forward< field_t >( val );
         return ret;
+}
+
+/// Mutate an entire indexed collection by cloning to accepted value
+template<typename node_t, typename parent_t, typename coll_t>
+const node_t * mutate_each( const node_t * node, coll_t parent_t::* field, Visitor & v ) {
+        for ( unsigned i = 0; i < (node->*field).size(); ++i ) {
+                node = mutate_field_index( node, field, i, (node->*field)[i]->accept( v ) );
+        }
+        return node;
 }
 
@@ -219 +230 @@
         operator const node_t * () const { _check(); return node; }
 
+        const node_t * release() {
+                const node_t * ret = node;
+                if ( node ) {
+                        _dec(node, false);
+                        node = nullptr;
+                }
+                return ret;
+        }
+
         /// wrapper for convenient access to dynamic_cast
         template<typename o_node_t>
         const o_node_t * as() const { _check(); return dynamic_cast<const o_node_t *>(node); }
 
-        /// wrapper for convenient access to strict_dynamic_cast
+        /// Wrapper that makes sure dynamic_cast returns non-null.
         template<typename o_node_t>
-        const o_node_t * strict_as() const { _check(); return strict_dynamic_cast<const o_node_t *>(node); }
+        const o_node_t * strict_as() const {
+                if (const o_node_t * ret = as<o_node_t>()) return ret;
+                _strict_fail();
+        }
+
+        /// Wrapper that makes sure dynamic_cast does not fail.
+        template<typename o_node_t, decltype(nullptr) null>
+        const o_node_t * strict_as() const { return node ? strict_as<o_node_t>() : nullptr; }
 
         /// Returns a mutable version of the pointer in this node.
@@ -244 +271 @@
 
         void _inc( const node_t * other );
-        void _dec( const node_t * other );
+        void _dec( const node_t * other, bool do_delete = true );
         void _check() const;
+        void _strict_fail() const __attribute__((noreturn));
 
         const node_t * node;