Changeset 6d51bd7 for src/AST/Node.hpp

Timestamp:

May 15, 2019, 10:15:44 AM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

be567e9

Parents:

712348a

Message:

Fixes to the new templated pass and started on conversions

File:

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

src/AST/Node.hpp

@@ -30 +30 @@
         // change/share reference counts
         Node() = default;
-        Node(const Node&) : strong_ref(0), weak_ref(0) {}
-        Node(Node&&) : strong_ref(0), weak_ref(0) {}
+        Node(const Node&) : strong_count(0), weak_count(0) {}
+        Node(Node&&) : strong_count(0), weak_count(0) {}
         Node& operator= (const Node&) = delete;
         Node& operator= (Node&&) = delete;
         virtual ~Node() = default;
 
-        virtual Node* accept( Visitor& v ) = 0;
+        virtual const Node * accept( Visitor & v ) const = 0;
 
         /// Types of node references
@@ -46 +46 @@
         inline void increment(ref_type ref) const {
                 switch (ref) {
-                        case ref_type::strong: strong_ref++; break;
-                        case ref_type::weak  : weak_ref  ++; break;
+                        case ref_type::strong: strong_count++; break;
+                        case ref_type::weak  : weak_count  ++; break;
                 }
         }
@@ -53 +53 @@
         inline void decrement(ref_type ref) const {
                 switch (ref) {
-                        case ref_type::strong: strong_ref--; break;
-                        case ref_type::weak  : weak_ref  --; break;
+                        case ref_type::strong: strong_count--; break;
+                        case ref_type::weak  : weak_count  --; break;
                 }
 
-                if(!strong_ref && !weak_ref) {
+                if(!strong_count && !weak_count) {
                         delete this;
                 }
         }
+private:
+        /// Make a copy of this node; should be overridden in subclass with more precise return type
+        virtual const Node * clone() const = 0;
 
+        /// Must be copied in ALL derived classes
         template<typename node_t>
         friend auto mutate(const node_t * node);
 
-private:
-        /// Make a copy of this node; should be overridden in subclass with more precise return type
-        virtual Node* clone() const = 0;
-
-        mutable size_t strong_ref = 0;
-        mutable size_t weak_ref = 0;
+        mutable size_t strong_count = 0;
+        mutable size_t weak_count = 0;
 };
 
@@ -100 +100 @@
 public:
         ptr_base() : node(nullptr) {}
-        ptr_base( node_t * n ) : node(n) { if( !node ) node->increment(ref_t); }
-        ~ptr_base() { if( node ) node->decrement(ref_t); }
+        ptr_base( const node_t * n ) : node(n) { if( !node ) increment(node, ref_t); }
+        ~ptr_base() { if( node ) decrement(node, ref_t); }
 
         template< enum  Node::ref_type o_ref_t >
         ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.node) {
                 if( !node ) return;
-                node->increment(ref_t);
+                increment(node, ref_t);
         }
 
         template< enum  Node::ref_type o_ref_t >
         ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.node) {
-                if( node ) node->increment(ref_t);
+                if( node ) increment(node, ref_t);
+        }
+
+        template<typename o_node_t>
+        ptr_base & operator=( const o_node_t * node ) {
+                assign(strict_dynamic_cast<const node_t *>(node));
+                return *this;
         }
 
@@ -136 +142 @@
 
 private:
-        void assign(node_t * other ) {
-                if( other ) other->increment(ref_t);
-                if( node  ) node ->decrement(ref_t);
+        void assign(const node_t * other ) {
+                if( other ) increment(other, ref_t);
+                if( node  ) decrement(node , ref_t);
                 node = other;
         }
 
 protected:
-        node_t * node;
+        const node_t * node;
 };