Remove "net" flag to release methods.

This flag is redundant. The behavior should be handled in other ways.

vvp/vpi_signal.cc

@@ -762,8 +762,7 @@ static vpiHandle signal_put_value(vpiHandle ref, s_vpi_value*vp, int flags)
 	    assert(sig);
 
 	    vvp_net_ptr_t ptr(rfp->node, 0);
-	      /* Assume this is a net. (XXXX Are we sure?) */
+	    sig->release(ptr);
-	    sig->release(ptr, true);
 	    return ref;
       }
 

vvp/vthread.cc

@@ -3925,9 +3925,9 @@ static bool do_release_vec(vthread_t thr, vvp_code_t cp, bool net_flag)
 	/* Do we release all or part of the net? */
       vvp_net_ptr_t ptr (net, 0);
       if (full_sig) {
-	    net->fil->release(ptr, net_flag);
+	    net->fil->release(ptr);
       } else {
-	    net->fil->release_pv(ptr, net_flag, base, width);
+	    net->fil->release_pv(ptr, base, width);
       }
 
       return true;
@@ -3955,7 +3955,7 @@ bool of_RELEASE_WR(vthread_t thr, vvp_code_t cp)
 
 	// Send a command to this signal to unforce itself.
       vvp_net_ptr_t ptr (net, 0);
-      net->fil->release(ptr, type==0);
+      net->fil->release(ptr);
       return true;
 }
 

vvp/vvp_net.h

@@ -1133,9 +1133,8 @@ class vvp_net_fil_t  : public vvp_vpi_callback {
       virtual bool filter_real(double&val);
       virtual bool filter_long(long&val);
 
-      virtual void release(vvp_net_ptr_t ptr, bool net) =0;
+      virtual void release(vvp_net_ptr_t ptr) =0;
-      virtual void release_pv(vvp_net_ptr_t ptr, bool net,
+      virtual void release_pv(vvp_net_ptr_t ptr, unsigned base, unsigned wid) =0;
-                              unsigned base, unsigned wid) =0;
 
 	// The %force/link instruction needs a place to write the
 	// source node of the force, so that subsequent %force and

vvp/vvp_net_sig.cc

@@ -245,31 +245,7 @@ void vvp_fun_signal_base::deassign_pv(unsigned base, unsigned wid)
 	    assign_mask_ = vvp_vector2_t();
       }
 }
-#if 0
-void vvp_fun_signal4_sa::release(vvp_net_ptr_t ptr, bool net)
-{
-      vvp_vector2_t mask (vvp_vector2_t::FILL1, bits4_.size());
-      assert(!net);
 
-	// Variables keep their forced value after the release.
-      bits4_ = filtered_vec4(bits4_);
-      release_mask(mask);
-}
-#endif
-#if 0
-void vvp_fun_signal4_sa::release_pv(vvp_net_ptr_t ptr, bool net,
-                                    unsigned base, unsigned wid)
-{
-      assert(bits4_.size() >= base + wid);
-
-      vvp_vector2_t mask (vvp_vector2_t::FILL0, bits4_.size());
-      for (unsigned idx = 0 ; idx < wid ; idx += 1)
-	    mask.set_bit(base+idx, 1);
-
-      bits4_ = filtered_vec4(bits4_);
-      release_mask(mask);
-}
-#endif
 unsigned vvp_fun_signal4_sa::value_size() const
 {
       return bits4_.size();
@@ -757,21 +733,17 @@ void vvp_wire_vec4::force_fil_real(double val, vvp_vector2_t mask)
       assert(0);
 }
 
-void vvp_wire_vec4::release(vvp_net_ptr_t ptr, bool net)
+void vvp_wire_vec4::release(vvp_net_ptr_t ptr)
 {
-      assert(net);
-
 	// Wires revert to their unforced value after release.
       vvp_vector2_t mask (vvp_vector2_t::FILL1, width_);
       release_mask(mask);
       ptr.ptr()->send_vec4(bits4_, 0);
 }
 
-void vvp_wire_vec4::release_pv(vvp_net_ptr_t ptr, bool net,
+void vvp_wire_vec4::release_pv(vvp_net_ptr_t ptr, unsigned base, unsigned wid)
-                                    unsigned base, unsigned wid)
 {
       assert(bits4_.size() >= base + wid);
-      assert(net);
 
       vvp_vector2_t mask (vvp_vector2_t::FILL0, bits4_.size());
       for (unsigned idx = 0 ; idx < wid ; idx += 1)
@@ -858,21 +830,17 @@ void vvp_wire_vec8::force_fil_real(double val, vvp_vector2_t mask)
       assert(0);
 }
 
-void vvp_wire_vec8::release(vvp_net_ptr_t ptr, bool net)
+void vvp_wire_vec8::release(vvp_net_ptr_t ptr)
 {
-      assert(net);
-
 	// Wires revert to their unforced value after release.
       vvp_vector2_t mask (vvp_vector2_t::FILL1, width_);
       release_mask(mask);
       ptr.ptr()->send_vec8(bits8_);
 }
 
-void vvp_wire_vec8::release_pv(vvp_net_ptr_t ptr, bool net,
+void vvp_wire_vec8::release_pv(vvp_net_ptr_t ptr, unsigned base, unsigned wid)
-			       unsigned base, unsigned wid)
 {
       assert(width_ >= base + wid);
-      assert(net);
 
       vvp_vector2_t mask (vvp_vector2_t::FILL0, width_);
       for (unsigned idx = 0 ; idx < wid ; idx += 1)
@@ -955,21 +923,16 @@ void vvp_wire_real::force_fil_real(double val, vvp_vector2_t mask)
 	    force_ = val;
 }
 
-void vvp_wire_real::release(vvp_net_ptr_t ptr, bool net)
+void vvp_wire_real::release(vvp_net_ptr_t ptr)
 {
-      assert(net);
-
 	// Wires revert to their unforced value after release.
       vvp_vector2_t mask (vvp_vector2_t::FILL1, 1);
       release_mask(mask);
       ptr.ptr()->send_real(bit_, 0);
 }
 
-void vvp_wire_real::release_pv(vvp_net_ptr_t ptr, bool net,
+void vvp_wire_real::release_pv(vvp_net_ptr_t ptr, unsigned base, unsigned wid)
-			       unsigned base, unsigned wid)
 {
-      assert(net);
-
       vvp_vector2_t mask (vvp_vector2_t::FILL0, 1);
       for (unsigned idx = 0 ; idx < wid ; idx += 1)
 	    mask.set_bit(base+idx, 1);

vvp/vvp_net_sig.h

@@ -150,11 +150,6 @@ class vvp_fun_signal4_sa : public vvp_fun_signal4 {
       vvp_vector4_t vec4_value() const;
       vvp_vector4_t vec4_unfiltered_value() const;
 
-	// Commands
-      void release(vvp_net_ptr_t port, bool net);
-      void release_pv(vvp_net_ptr_t port, bool net,
-                      unsigned base, unsigned wid);
-
     private:
       vvp_vector4_t bits4_;
 };
@@ -328,8 +323,8 @@ class vvp_wire_vec4 : public vvp_wire_base {
       void force_fil_vec4(const vvp_vector4_t&val, vvp_vector2_t mask);
       void force_fil_vec8(const vvp_vector8_t&val, vvp_vector2_t mask);
       void force_fil_real(double val, vvp_vector2_t mask);
-      void release(vvp_net_ptr_t ptr, bool net);
+      void release(vvp_net_ptr_t ptr);
-      void release_pv(vvp_net_ptr_t ptr, bool net, unsigned base, unsigned wid);
+      void release_pv(vvp_net_ptr_t ptr, unsigned base, unsigned wid);
 
 	// Implementation of vvp_signal_value methods
       unsigned value_size() const;
@@ -362,8 +357,8 @@ class vvp_wire_vec8 : public vvp_wire_base {
       void force_fil_vec4(const vvp_vector4_t&val, vvp_vector2_t mask);
       void force_fil_vec8(const vvp_vector8_t&val, vvp_vector2_t mask);
       void force_fil_real(double val, vvp_vector2_t mask);
-      void release(vvp_net_ptr_t ptr, bool net);
+      void release(vvp_net_ptr_t ptr);
-      void release_pv(vvp_net_ptr_t ptr, bool net, unsigned base, unsigned wid);
+      void release_pv(vvp_net_ptr_t ptr, unsigned base, unsigned wid);
 
 	// Implementation of vvp_signal_value methods
       unsigned value_size() const;
@@ -397,8 +392,8 @@ class vvp_wire_real : public vvp_wire_base {
       void force_fil_vec4(const vvp_vector4_t&val, vvp_vector2_t mask);
       void force_fil_vec8(const vvp_vector8_t&val, vvp_vector2_t mask);
       void force_fil_real(double val, vvp_vector2_t mask);
-      void release(vvp_net_ptr_t ptr, bool net);
+      void release(vvp_net_ptr_t ptr);
-      void release_pv(vvp_net_ptr_t ptr, bool net, unsigned base, unsigned wid);
+      void release_pv(vvp_net_ptr_t ptr, unsigned base, unsigned wid);
 
 	// Implementation of vvp_signal_value methods
       unsigned value_size() const;