diff --git a/vvp/array.cc b/vvp/array.cc
index 67c68e8a5..62b2766ef 100644
--- a/vvp/array.cc
+++ b/vvp/array.cc
@@ -301,7 +301,7 @@ void __vpiArray::put_word_value(struct __vpiArrayWord*word, p_vpi_value vp, int)
 {
       unsigned index = word->get_index();
       vvp_vector4_t val = vec4_from_vpi_value(vp, vals_width);
-      array_set_word(this, index, 0, val);
+      set_word(index, 0, val);
 }
 
 vpiHandle __vpiArray::get_iter_index(struct __vpiArrayIterator*, int idx)
@@ -529,13 +529,13 @@ static void vpi_array_vthr_A_get_value(vpiHandle ref, p_vpi_value vp)
 
       unsigned index = obj->get_address();
       if (vpi_array_is_real(parent)) {
-	    double tmp = array_get_word_r(parent, index);
+	    double tmp = parent->get_word_r(index);
 	    vpip_real_get_value(tmp, vp);
       } else if (vpi_array_is_string(parent)) {
-	    string tmp = array_get_word_str(parent, index);
+	    string tmp = parent->get_word_str(index);
 	    vpip_string_get_value(tmp, vp);
       } else {
-	    vvp_vector4_t tmp = array_get_word(parent, index);
+	    vvp_vector4_t tmp = parent->get_word(index);
 	    unsigned width = parent->get_word_size();
 	    vpip_vec4_get_value(tmp, width, parent->signed_flag, vp);
       }
@@ -554,11 +554,11 @@ static vpiHandle vpi_array_vthr_A_put_value(vpiHandle ref, p_vpi_value vp, int)
 
       if (vpi_array_is_real(parent)) {
 	    double val = real_from_vpi_value(vp);
-	    array_set_word(parent, index, val);
+	    parent->set_word(index, val);
       } else {
 	    unsigned width = parent->get_word_size();
 	    vvp_vector4_t val = vec4_from_vpi_value(vp, width);
-	    array_set_word(parent, index, 0, val);
+	    parent->set_word(index, 0, val);
       }
 
       return ref;
@@ -656,128 +656,125 @@ static void vpi_array_vthr_APV_get_value(vpiHandle ref, p_vpi_value vp)
 
       unsigned index = obj->word_sel;
       if (vpi_array_is_real(parent)) {
-	    double tmp = array_get_word_r(parent, index);
+	    double tmp = parent->get_word_r(index);
 	    vpip_real_get_value(tmp, vp);
       } else {
-	    vvp_vector4_t tmp = array_get_word(parent, index);
+	    vvp_vector4_t tmp = parent->get_word(index);
 	    tmp = tmp.subvalue(obj->part_bit, obj->part_wid);
 	    vpip_vec4_get_value(tmp, obj->part_wid, parent->signed_flag, vp);
       }
 }
 
-void array_set_word(vvp_array_t arr,
-		    unsigned address,
-		    unsigned part_off,
-		    vvp_vector4_t val)
+void __vpiArray::set_word(unsigned address, unsigned part_off, vvp_vector4_t val)
 {
-      if (address >= arr->get_size())
+      if (address >= get_size())
 	    return;
 
-      if (arr->vals4) {
-	    assert(arr->nets == 0);
-	    if (part_off != 0 || val.size() != arr->vals_width) {
-		  vvp_vector4_t tmp = arr->vals4->get_word(address);
+      if (vals4) {
+	    assert(nets == 0);
+	    if (part_off != 0 || val.size() != vals_width) {
+		  vvp_vector4_t tmp = vals4->get_word(address);
 		  if ((part_off + val.size()) > tmp.size()) {
 			cerr << "part_off=" << part_off
 			     << " val.size()=" << val.size()
-			     << " arr->vals[address].size()=" << tmp.size()
-			     << " arr->vals_width=" << arr->vals_width << endl;
+			     << " vals[address].size()=" << tmp.size()
+			     << " vals_width=" << vals_width << endl;
 			assert(0);
 		  }
 		  tmp.set_vec(part_off, val);
-		  arr->vals4->set_word(address, tmp);
+		  vals4->set_word(address, tmp);
 	    } else {
-		  arr->vals4->set_word(address, val);
+		  vals4->set_word(address, val);
 	    }
-	    array_word_change(arr, address);
+	    array_word_change(this, address);
 	    return;
       }
 
-      if (arr->vals) {
-	    assert(arr->nets == 0);
+      if (vals) {
+	    assert(nets == 0);
 	      // FIXME: For now, assume no part select of word?
 	    assert(part_off==0);
-	    assert(val.size() == arr->vals_width);
-	    arr->vals->set_word(address, val);
-	    array_word_change(arr, address);
+	    assert(val.size() == vals_width);
+	    vals->set_word(address, val);
+	    array_word_change(this, address);
 	    return;
       }
 
-      assert(arr->nets != 0);
+      assert(nets != 0);
 
 	// Select the word of the array that we affect.
-      vpiHandle word = arr->nets[address];
+      vpiHandle word = nets[address];
       struct __vpiSignal*vsig = dynamic_cast<__vpiSignal*>(word);
       assert(vsig);
 
       vsig->node->send_vec4_pv(val, part_off, val.size(), vpip_size(vsig), 0);
-      array_word_change(arr, address);
+      array_word_change(this, address);
 }
 
-void array_set_word(vvp_array_t arr, unsigned address, double val)
+void __vpiArray::set_word(unsigned address, double val)
 {
-      assert(arr->vals != 0);
-      assert(arr->nets == 0);
+      assert(vals != 0);
+      assert(nets == 0);
 
-      if (address >= arr->vals->get_size())
+      if (address >= vals->get_size())
 	    return;
 
-      arr->vals->set_word(address, val);
-      array_word_change(arr, address);
+      vals->set_word(address, val);
+      array_word_change(this, address);
 }
 
-void array_set_word(vvp_array_t arr, unsigned address, const string&val)
+void __vpiArray::set_word(unsigned address, const string&val)
 {
-      assert(arr->vals != 0);
-      assert(arr->nets == 0);
+      assert(vals != 0);
+      assert(nets == 0);
 
-      if (address >= arr->vals->get_size())
+      if (address >= vals->get_size())
 	    return;
 
-      arr->vals->set_word(address, val);
-      array_word_change(arr, address);
+      vals->set_word(address, val);
+      array_word_change(this, address);
 }
 
-void array_set_word(vvp_array_t arr, unsigned address, const vvp_object_t&val)
+void __vpiArray::set_word(unsigned address, const vvp_object_t&val)
 {
-      assert(arr->vals != 0);
-      assert(arr->nets == 0);
+      assert(vals != 0);
+      assert(nets == 0);
 
-      if (address >= arr->vals->get_size())
+      if (address >= vals->get_size())
 	    return;
 
-      arr->vals->set_word(address, val);
-      array_word_change(arr, address);
+      vals->set_word(address, val);
+      array_word_change(this, address);
 }
 
-vvp_vector4_t array_get_word(vvp_array_t arr, unsigned address)
+vvp_vector4_t __vpiArray::get_word(unsigned address)
 {
-      if (arr->vals4) {
-	    assert(arr->nets == 0);
-	    assert(arr->vals == 0);
-	    return arr->vals4->get_word(address);
+      if (vals4) {
+	    assert(nets == 0);
+	    assert(vals == 0);
+	    return vals4->get_word(address);
       }
 
-      if (arr->vals) {
-	    assert(arr->nets == 0);
-	    assert(arr->vals4== 0);
-	    if (address >= arr->vals->get_size())
-		  return vvp_vector4_t(arr->vals_width, BIT4_X);
+      if (vals) {
+	    assert(nets == 0);
+	    assert(vals4== 0);
+	    if (address >= vals->get_size())
+		  return vvp_vector4_t(vals_width, BIT4_X);
 
 	    vvp_vector4_t val;
-	    arr->vals->get_word(address, val);
+	    vals->get_word(address, val);
 	    return val;
       }
 
-      assert(arr->vals4 == 0);
-      assert(arr->vals == 0);
-      assert(arr->nets != 0);
+      assert(vals4 == 0);
+      assert(vals == 0);
+      assert(nets != 0);
 
-      if (address >= arr->get_size()) {
+      if (address >= get_size()) {
 	      // Reading outside the array. Return X's but get the
 	      // width by looking at a word that we know is present.
-	    assert(arr->get_size() > 0);
-	    vpiHandle word = arr->nets[0];
+	    assert(get_size() > 0);
+	    vpiHandle word = nets[0];
 	    assert(word);
 	    struct __vpiSignal*vsig = dynamic_cast<__vpiSignal*>(word);
 	    assert(vsig);
@@ -786,7 +783,7 @@ vvp_vector4_t array_get_word(vvp_array_t arr, unsigned address)
 	    return vvp_vector4_t(sig->value_size(), BIT4_X);
       }
 
-      vpiHandle word = arr->nets[address];
+      vpiHandle word = nets[address];
       struct __vpiSignal*vsig = dynamic_cast<__vpiSignal*>(word);
       assert(vsig);
       vvp_signal_value*sig = dynamic_cast<vvp_signal_value*> (vsig->node->fil);
@@ -797,23 +794,23 @@ vvp_vector4_t array_get_word(vvp_array_t arr, unsigned address)
       return val;
 }
 
-double array_get_word_r(vvp_array_t arr, unsigned address)
+double __vpiArray::get_word_r(unsigned address)
 {
-      if (arr->vals) {
-	    assert(arr->vals4 == 0);
-	    assert(arr->nets  == 0);
+      if (vals) {
+	    assert(vals4 == 0);
+	    assert(nets  == 0);
 	      // In this context, address out of bounds returns 0.0
 	      // instead of an error.
-	    if (address >= arr->vals->get_size())
+	    if (address >= vals->get_size())
 		  return 0.0;
 
 	    double val;
-	    arr->vals->get_word(address, val);
+	    vals->get_word(address, val);
 	    return val;
       }
 
-      assert(arr->nets);
-      vpiHandle word = arr->nets[address];
+      assert(nets);
+      vpiHandle word = nets[address];
       struct __vpiRealVar*vsig = dynamic_cast<__vpiRealVar*>(word);
       assert(vsig);
       vvp_signal_value*sig = dynamic_cast<vvp_signal_value*> (vsig->net->fil);
@@ -821,47 +818,46 @@ double array_get_word_r(vvp_array_t arr, unsigned address)
 
       double val = sig->real_value();
       return val;
-
 }
 
-void array_get_word_obj(vvp_array_t arr, unsigned address, vvp_object_t&val)
+void __vpiArray::get_word_obj(unsigned address, vvp_object_t&val)
 {
-      if (arr->vals) {
-	    assert(arr->vals4 == 0);
-	    assert(arr->nets  == 0);
+      if (vals) {
+	    assert(vals4 == 0);
+	    assert(nets  == 0);
 	      // In this context, address out of bounds returns 0.0
 	      // instead of an error.
-	    if (address >= arr->vals->get_size()) {
+	    if (address >= vals->get_size()) {
 		  val = vvp_object_t();
 		  return;
 	    }
 
-	    arr->vals->get_word(address, val);
+	    vals->get_word(address, val);
 	    return;
       }
 
-      assert(arr->nets);
+      assert(nets);
 	// Arrays of string nets not implemented!
       assert(0);
       return;
 }
 
-string array_get_word_str(vvp_array_t arr, unsigned address)
+string __vpiArray::get_word_str(unsigned address)
 {
-      if (arr->vals) {
-	    assert(arr->vals4 == 0);
-	    assert(arr->nets  == 0);
+      if (vals) {
+	    assert(vals4 == 0);
+	    assert(nets  == 0);
 	      // In this context, address out of bounds returns 0.0
 	      // instead of an error.
-	    if (address >= arr->vals->get_size())
+	    if (address >= vals->get_size())
 		  return "";
 
 	    string val;
-	    arr->vals->get_word(address, val);
+	    vals->get_word(address, val);
 	    return val;
       }
 
-      assert(arr->nets);
+      assert(nets);
 	// Arrays of string nets not implemented!
       assert(0);
       return "";
@@ -1181,9 +1177,9 @@ void vvp_fun_arrayport_sa::recv_vec4(vvp_net_ptr_t port, const vvp_vector4_t&bit
 	    if (! addr_valid_flag)
 		  addr_ = arr_->get_size();
 	    if (vpi_array_is_real(arr_))
-		  port.ptr()->send_real(array_get_word_r(arr_, addr_), 0);
+		  port.ptr()->send_real(arr_->get_word_r(addr_), 0);
 	    else
-		  port.ptr()->send_vec4(array_get_word(arr_,addr_), 0);
+		  port.ptr()->send_vec4(arr_->get_word(addr_), 0);
 
 	    break;
 
@@ -1198,9 +1194,9 @@ void vvp_fun_arrayport_sa::check_word_change(unsigned long addr)
       if (addr != addr_) return;
 
       if (vpi_array_is_real(arr_)) {
-	    net_->send_real(array_get_word_r(arr_, addr_), 0);
+	    net_->send_real(arr_->get_word_r(addr_), 0);
       } else {
-	    net_->send_vec4(array_get_word(arr_, addr_), 0);
+	    net_->send_vec4(arr_->get_word(addr_), 0);
       }
 }
 
@@ -1287,10 +1283,10 @@ void vvp_fun_arrayport_aa::recv_vec4(vvp_net_ptr_t port, const vvp_vector4_t&bit
                   addr_valid_flag = vector4_to_value(bit, *addr);
                   if (! addr_valid_flag) *addr = arr_->get_size();
                   if (vpi_array_is_real(arr_)) {
-			port.ptr()->send_real(array_get_word_r(arr_, *addr),
+			port.ptr()->send_real(arr_->get_word_r(*addr),
 					      context);
                   } else {
-			port.ptr()->send_vec4(array_get_word(arr_, *addr),
+			port.ptr()->send_vec4(arr_->get_word(*addr),
 					      context);
                   }
                   break;
@@ -1318,9 +1314,9 @@ void vvp_fun_arrayport_aa::check_word_change_(unsigned long addr,
 	    return;
 
       if (vpi_array_is_real(arr_)) {
-	    net_->send_real(array_get_word_r(arr_, addr), context);
+	    net_->send_real(arr_->get_word_r(addr), context);
       } else {
-	    net_->send_vec4(array_get_word(arr_, addr), context);
+	    net_->send_vec4(arr_->get_word(addr), context);
       }
 }
 
diff --git a/vvp/array.h b/vvp/array.h
index 1016580ff..6aa021225 100644
--- a/vvp/array.h
+++ b/vvp/array.h
@@ -37,20 +37,6 @@ extern void array_attach_word(vvp_array_t array, unsigned addr, vpiHandle word);
 extern void array_alias_word(vvp_array_t array, unsigned long addr,
                              vpiHandle word, int msb, int lsb);
 
-extern void array_set_word(vvp_array_t arr, unsigned idx,
-			    unsigned off, vvp_vector4_t val);
-extern void array_set_word(vvp_array_t arr, unsigned idx,
-			   double val);
-extern void array_set_word(vvp_array_t arr, unsigned idx,
-			   const std::string&val);
-extern void array_set_word(vvp_array_t arr, unsigned idx,
-			   const vvp_object_t&val);
-
-extern vvp_vector4_t array_get_word(vvp_array_t array, unsigned address);
-extern double array_get_word_r(vvp_array_t array, unsigned address);
-extern void array_get_word_obj(vvp_array_t array, unsigned address, vvp_object_t&val);
-extern std::string array_get_word_str(vvp_array_t array, unsigned address);
-
 /* VPI hooks */
 
 extern value_callback* vpip_array_word_change(p_cb_data data);
diff --git a/vvp/event.cc b/vvp/event.cc
index 47b3d143a..d95ce975c 100644
--- a/vvp/event.cc
+++ b/vvp/event.cc
@@ -137,7 +137,7 @@ evctl_array::evctl_array(vvp_array_t memory, unsigned index,
 
 void evctl_array::run_run()
 {
-      array_set_word(mem_, idx_, off_, value_);
+      mem_->set_word(idx_, off_, value_);
 }
 
 void schedule_evctl(vvp_array_t memory, unsigned index,
@@ -163,7 +163,7 @@ evctl_array_r::evctl_array_r(vvp_array_t memory, unsigned index,
 
 void evctl_array_r::run_run()
 {
-      array_set_word(mem_, idx_, value_);
+      mem_->set_word(idx_, value_);
 }
 
 void schedule_evctl(vvp_array_t memory, unsigned index,
diff --git a/vvp/schedule.cc b/vvp/schedule.cc
index 4a62bf4de..c6bb71030 100644
--- a/vvp/schedule.cc
+++ b/vvp/schedule.cc
@@ -306,7 +306,7 @@ struct assign_array_word_s  : public event_s {
 void assign_array_word_s::run_run(void)
 {
       count_assign_events += 1;
-      array_set_word(mem, adr, off, val);
+      mem->set_word(adr, off, val);
 }
 
 static const size_t ARRAY_W_CHUNK_COUNT = 8192 / sizeof(struct assign_array_word_s);
@@ -396,7 +396,7 @@ struct assign_array_r_word_s  : public event_s {
 void assign_array_r_word_s::run_run(void)
 {
       count_assign_events += 1;
-      array_set_word(mem, adr, val);
+      mem->set_word(adr, val);
 }
 static const size_t ARRAY_R_W_CHUNK_COUNT = 8192 / sizeof(struct assign_array_r_word_s);
 static slab_t<sizeof(assign_array_r_word_s),ARRAY_R_W_CHUNK_COUNT> array_r_w_heap;
diff --git a/vvp/vpi_priv.h b/vvp/vpi_priv.h
index 1bdb5d64e..cc70185f5 100644
--- a/vvp/vpi_priv.h
+++ b/vvp/vpi_priv.h
@@ -608,6 +608,16 @@ struct __vpiArray : public __vpiArrayBase, public __vpiHandle {
       inline vpiHandle vpi_iterate(int code) { return vpi_array_base_iterate(code); }
       vpiHandle vpi_index(int idx);
 
+      void set_word(unsigned idx, unsigned off, vvp_vector4_t val);
+      void set_word(unsigned idx, double val);
+      void set_word(unsigned idx, const std::string&val);
+      void set_word(unsigned idx, const vvp_object_t&val);
+
+      vvp_vector4_t get_word(unsigned address);
+      double get_word_r(unsigned address);
+      void get_word_obj(unsigned address, vvp_object_t&val);
+      std::string get_word_str(unsigned address);
+
       const char*name; /* Permanently allocated string */
       __vpiDecConst first_addr;
       __vpiDecConst last_addr;
diff --git a/vvp/vthread.cc b/vvp/vthread.cc
index 1ebe5afc0..32a0d8a29 100644
--- a/vvp/vthread.cc
+++ b/vvp/vthread.cc
@@ -3262,7 +3262,7 @@ bool of_LOAD_AR(vthread_t thr, vvp_code_t cp)
       if (thr_get_bit(thr, 4) == BIT4_1) {
 	    word = 0.0;
       } else {
-	    word = array_get_word_r(cp->array, adr);
+	    word = cp->array->get_word_r(adr);
       }
 
       thr->push_real(word);
@@ -3294,7 +3294,7 @@ bool of_LOAD_AV(vthread_t thr, vvp_code_t cp)
 	    return true;
       }
 
-      vvp_vector4_t word = array_get_word(cp->array, adr);
+      vvp_vector4_t word = cp->array->get_word(adr);
 
       if (word.size() > wid)
 	    word.resize(wid);
@@ -3451,7 +3451,7 @@ bool of_LOAD_AVP0(vthread_t thr, vvp_code_t cp)
         /* We need a vector this wide to make the math work correctly.
          * Copy the base bits into the vector, but keep the width. */
       vvp_vector4_t sig_value(wid, BIT4_0);
-      sig_value.copy_bits(array_get_word(cp->array, adr));
+      sig_value.copy_bits(cp->array->get_word(adr));
 
       load_vp0_common(thr, cp, sig_value);
       return true;
@@ -3471,7 +3471,7 @@ bool of_LOAD_AVP0_S(vthread_t thr, vvp_code_t cp)
 	    return true;
       }
 
-      vvp_vector4_t tmp (array_get_word(cp->array, adr));
+      vvp_vector4_t tmp (cp->array->get_word(adr));
 
         /* We need a vector this wide to make the math work correctly.
          * Copy the base bits into the vector, but keep the width. */
@@ -3505,7 +3505,7 @@ bool of_LOAD_AVX_P(vthread_t thr, vvp_code_t cp)
 
       long use_index = thr->words[index].w_int;
 
-      vvp_vector4_t word = array_get_word(cp->array, adr);
+      vvp_vector4_t word = cp->array->get_word(adr);
 
       if ((use_index >= (long)word.size()) || (use_index < 0)) {
 	    thr_put_bit(thr, bit, BIT4_X);
@@ -3543,7 +3543,7 @@ bool of_LOAD_OBJA(vthread_t thr, vvp_code_t cp)
       if (thr_get_bit(thr, 4) == BIT4_1) {
 	    ; // Return nil
       } else {
-	    array_get_word_obj(cp->array, adr, word);
+	    cp->array->get_word_obj(adr, word);
       }
 
       thr->push_object(word);
@@ -3591,7 +3591,7 @@ bool of_LOAD_STRA(vthread_t thr, vvp_code_t cp)
       if (thr_get_bit(thr, 4) == BIT4_1) {
 	    word = "";
       } else {
-	    word = array_get_word_str(cp->array, adr);
+	    word = cp->array->get_word_str(adr);
       }
 
       thr->push_str(word);
@@ -5051,7 +5051,7 @@ bool of_SET_AV(vthread_t thr, vvp_code_t cp)
 	/* Make a vector of the desired width. */
       vvp_vector4_t value = vthread_bits_to_vector(thr, bit, wid);
 
-      array_set_word(cp->array, adr, off, value);
+      cp->array->set_word(adr, off, value);
       return true;
 }
 
@@ -5482,7 +5482,7 @@ bool of_STORE_OBJA(vthread_t thr, vvp_code_t cp)
       vvp_object_t val;
       thr->pop_object(val);
 
-      array_set_word(cp->array, adr, val);
+      cp->array->set_word(adr, val);
 
       return true;
 }
@@ -5653,7 +5653,7 @@ bool of_STORE_REALA(vthread_t thr, vvp_code_t cp)
       unsigned adr = thr->words[idx].w_int;
 
       double val = thr->pop_real();
-      array_set_word(cp->array, adr, val);
+      cp->array->set_word(adr, val);
 
       return true;
 }
@@ -5678,7 +5678,7 @@ bool of_STORE_STRA(vthread_t thr, vvp_code_t cp)
       unsigned adr = thr->words[idx].w_int;
 
       string val = thr->pop_str();
-      array_set_word(cp->array, adr, val);
+      cp->array->set_word(adr, val);
 
       return true;
 }
@@ -5861,7 +5861,7 @@ bool of_TEST_NUL_A(vthread_t thr, vvp_code_t cp)
 	    return true;
       }
 
-      array_get_word_obj(cp->array, adr, word);
+      cp->array->get_word_obj(adr, word);
       if (word.test_nil())
 	    thr_put_bit(thr, 4, BIT4_1);
       else