--- a/liboctave/Array.cc
+++ b/liboctave/Array.cc
@@ -77,7 +77,7 @@
       slice_data = rep->data;
     }
   else
-    octave_fill (slice_len, val, slice_data);
+    fill_or_memset (slice_len, val, slice_data);
 }
 
 template <class T>
@@ -569,7 +569,7 @@
           octave_idx_type step = stride[0], len = dim[0];
           if (step == 1)
             {
-              octave_ucopy (len, src, dest);
+              copy_or_memcpy (len, src, dest);
               dest += len;
             }
           else
@@ -832,8 +832,8 @@
     {
       if (lev == 0)
         {
-          octave_ucopy (cext[0], src, dest);
-          octave_fill (dext[0] - cext[0], rfv, dest + cext[0]);
+          copy_or_memcpy (cext[0], src, dest);
+          fill_or_memset (dext[0] - cext[0], rfv, dest + cext[0]);
         }
       else
         {
@@ -841,7 +841,7 @@
           for (k = 0; k < cext[lev]; k++)
             do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1);
 
-          octave_fill (dext[lev] - k * dd, rfv, dest + k * dd);
+          fill_or_memset (dext[lev] - k * dd, rfv, dest + k * dd);
         }
     }
 public:
@@ -1117,7 +1117,7 @@
                   Array<T> tmp (Array<T> (nn), dv, 0, n);
                   T *dest = tmp.fortran_vec ();
 
-                  octave_ucopy (nx, data (), dest);
+                  copy_or_memcpy (nx, data (), dest);
                   dest[nx] = rfv;
 
                   *this = tmp;
@@ -1129,8 +1129,8 @@
               T *dest = tmp.fortran_vec ();
 
               octave_idx_type n0 = std::min (n, nx), n1 = n - n0;
-              octave_ucopy (n0, data (), dest);
-              octave_fill (n1, rfv, dest + n0);
+              copy_or_memcpy (n0, data (), dest);
+              fill_or_memset (n1, rfv, dest + n0);
 
               *this = tmp;
             }
@@ -1157,22 +1157,22 @@
           const T *src = data ();
           if (r == rx)
             {
-              octave_ucopy (r * c0, src, dest);
+              copy_or_memcpy (r * c0, src, dest);
               dest += r * c0;
             }
           else
             {
               for (octave_idx_type k = 0; k < c0; k++)
                 {
-                  octave_ucopy (r0, src, dest);
+                  copy_or_memcpy (r0, src, dest);
                   src += rx;
                   dest += r0;
-                  octave_fill (r1, rfv, dest);
+                  fill_or_memset (r1, rfv, dest);
                   dest += r1;
                 }
             }
 
-          octave_fill (r * c1, rfv, dest);
+          fill_or_memset (r * c1, rfv, dest);
 
           *this = tmp;
         }
@@ -1557,8 +1557,8 @@
           Array<T> tmp (dim_vector (col_vec ? m : 1, !col_vec ? m : 1));
           const T *src = data ();
           T *dest = tmp.fortran_vec ();
-          octave_ucopy (l, src, dest);
-          octave_ucopy (n - u, src + u, dest + l);
+          copy_or_memcpy (l, src, dest);
+          copy_or_memcpy (n - u, src + u, dest + l);
           *this = tmp;
         }
       else
@@ -1609,9 +1609,9 @@
           l *= dl; u *= dl; n *= dl;
           for (octave_idx_type k = 0; k < du; k++)
             {
-              octave_ucopy (l, src, dest);
+              copy_or_memcpy (l, src, dest);
               dest += l;
-              octave_ucopy (n - u, src + u, dest);
+              copy_or_memcpy (n - u, src + u, dest);
               dest += n - u;
               src += n;
             }

--- a/liboctave/Array.h
+++ b/liboctave/Array.h
@@ -62,29 +62,29 @@
     int count;
 
     ArrayRep (T *d, octave_idx_type l, bool copy = false) 
-      : data (copy ? octave_new<T> (l) : d), len (l), count (1) 
+      : data (copy ? no_ctor_new<T> (l) : d), len (l), count (1) 
         { 
           if (copy)
-            octave_ucopy (l, d, data);
+            copy_or_memcpy (l, d, data);
         }
 
     ArrayRep (void) : data (0), len (0), count (1) { }
 
-    explicit ArrayRep (octave_idx_type n) : data (octave_new<T> (n)), len (n), count (1) { }
+    explicit ArrayRep (octave_idx_type n) : data (no_ctor_new<T> (n)), len (n), count (1) { }
 
     explicit ArrayRep (octave_idx_type n, const T& val)
-      : data (octave_new<T> (n)), len (n), count (1)
+      : data (no_ctor_new<T> (n)), len (n), count (1)
       {
-        octave_fill (n, val, data);
+        fill_or_memset (n, val, data);
       }
 
     ArrayRep (const ArrayRep& a)
-      : data (octave_new<T> (a.len)), len (a.len), count (1)
+      : data (no_ctor_new<T> (a.len)), len (a.len), count (1)
       {
-        octave_ucopy (a.len, a.data, data);
+        copy_or_memcpy (a.len, a.data, data);
       }
  
-    ~ArrayRep (void) { octave_delete<T> (data); }
+    ~ArrayRep (void) { no_ctor_delete<T> (data); }
 
     octave_idx_type length (void) const { return len; }
 
@@ -169,7 +169,7 @@
   T *
   coerce (const U *a, octave_idx_type len)
   {
-    T *retval = octave_new<T> (len);
+    T *retval = no_ctor_new<T> (len);
 
     for (octave_idx_type i = 0; i < len; i++)
       retval[i] = T (a[i]);

--- a/liboctave/ChangeLog
+++ b/liboctave/ChangeLog
@@ -1,3 +1,13 @@
+2009-11-03  Jaroslav Hajek  <highegg@gmail.com>
+
+	* oct-mem.h: Rename octave_ucopy -> copy_or_memcpy,
+	octave_fill -> fill_or_memset, octave_new -> no_ctor_new,
+	octave_delete -> no_ctor_delete.
+	* Array.h: Update.
+	* Array.cc: Update.
+	* idx-vector.h: Update.
+	* idx-vector.cc: Update.
+
 2009-11-03  Jaroslav Hajek  <highegg@gmail.com>
 
 	* oct-mem.h: New source.

--- a/liboctave/idx-vector.cc
+++ b/liboctave/idx-vector.cc
@@ -636,7 +636,7 @@
         {
           idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep);
           const octave_idx_type *rdata = r->get_data ();
-          octave_ucopy (len, rdata, data);
+          copy_or_memcpy (len, rdata, data);
         }
       break;
     default:

--- a/liboctave/idx-vector.h
+++ b/liboctave/idx-vector.h
@@ -518,7 +518,7 @@
       switch (rep->idx_class ())
         {
         case class_colon:
-          octave_ucopy (len, src, dest);
+          copy_or_memcpy (len, src, dest);
           break;
         case class_range:
           {
@@ -526,7 +526,7 @@
             octave_idx_type start = r->get_start (), step = r->get_step ();
             const T *ssrc = src + start;
             if (step == 1)
-              octave_ucopy (len, ssrc, dest);
+              copy_or_memcpy (len, ssrc, dest);
             else if (step == -1)
               std::reverse_copy (ssrc - len + 1, ssrc + 1, dest);
             else if (step == 0)
@@ -576,7 +576,7 @@
       switch (rep->idx_class ())
         {
         case class_colon:
-          octave_ucopy (len, src, dest);
+          copy_or_memcpy (len, src, dest);
           break;
         case class_range:
           {
@@ -584,7 +584,7 @@
             octave_idx_type start = r->get_start (), step = r->get_step ();
             T *sdest = dest + start;
             if (step == 1)
-              octave_ucopy (len, src, sdest);
+              copy_or_memcpy (len, src, sdest);
             else if (step == -1)
               std::reverse_copy (src, src + len, sdest - len + 1);
             else

--- a/liboctave/oct-mem.h
+++ b/liboctave/oct-mem.h
@@ -39,11 +39,11 @@
 // Unaliased copy. This boils down to memcpy, even for octave_int and complex types.
 
 template <class T>
-inline void octave_ucopy (octave_idx_type n, const T *src, T *dest)
+inline void copy_or_memcpy (octave_idx_type n, const T *src, T *dest)
 { std::copy (src, src + n, dest); }
 
 #define DEFINE_POD_UCOPY(T) \
-inline void octave_ucopy (octave_idx_type n, const T *src, T *dest) \
+inline void copy_or_memcpy (octave_idx_type n, const T *src, T *dest) \
 { std::memcpy (dest, src, n * sizeof (T)); }
 
 DEFINE_POD_UCOPY (double)
@@ -66,25 +66,31 @@
 // Fill by value, with a check for zero. This boils down to memset if value is
 // a POD zero.
 template <class T>
-inline void octave_fill (octave_idx_type n, const T& value, T *dest)
+inline void fill_or_memset (octave_idx_type n, const T& value, T *dest)
 { std::fill_n (dest, n, value); }
 
 template <class T>
-inline bool octave_fill_iszero (const T& value)
-{ return value == T(); }
+inline bool helper_is_zero_mem (const T& value)
+{ 
+  typedef typename query_integer_type<sizeof (T), false>::type IT; // get integer type of the same size.
+  return *(reinterpret_cast<const IT *>(&value)) == 0; 
+}
 
 template <class T>
-inline bool octave_fill_iszero (const std::complex<T>& value)
-{ return value.real () == T() && value.imag () == T(); }
+inline bool helper_is_zero_mem (const std::complex<T>& value)
+{
+  return (helper_is_zero_mem (value.real ()) 
+          && helper_is_zero_mem (value.imag ())); 
+}
 
 template <class T>
-inline bool octave_fill_iszero (const octave_int<T>& value)
+inline bool helper_is_zero_mem (const octave_int<T>& value)
 { return value.value () == T(); }
 
 #define DEFINE_POD_FILL(T) \
-inline void octave_fill (octave_idx_type n, const T& value, T *dest) \
+inline void fill_or_memset (octave_idx_type n, const T& value, T *dest) \
 { \
-  if (octave_fill_iszero (value)) \
+  if (helper_is_zero_mem (value)) \
     std::memset (dest, 0, n * sizeof (T)); \
   else \
     std::fill_n (dest, n, value); \
@@ -110,18 +116,18 @@
 // Uninitialized allocation. Will not initialize memory for complex and octave_int.
 // Memory allocated by octave_new should be freed by octave_delete.
 template <class T>
-inline T *octave_new (octave_idx_type n)
+inline T *no_ctor_new (octave_idx_type n)
 { return new T[n]; }
 template <class T>
-inline void octave_delete (T *ptr)
+inline void no_ctor_delete (T *ptr)
 { delete [] ptr; }
 
 #define DEFINE_POD_NEW_DELETE(T) \
 template <> \
-inline T *octave_new<T > (octave_idx_type n) \
+inline T *no_ctor_new<T > (octave_idx_type n) \
 { return reinterpret_cast<T *> (new char[n * sizeof (T)]); } \
 template <> \
-inline void octave_delete<T > (T *ptr) \
+inline void no_ctor_delete<T > (T *ptr) \
 { delete [] reinterpret_cast<char *> (ptr); }
 
 DEFINE_POD_NEW_DELETE (Complex)