# HG changeset patch
# User jwe
# Date 825900014 0
# Node ID 95e952f72d66d5a1c6b779f1a0227782741ef84d
# Parent  c1ffef39e94af964c8f936a3bb0b5f07a4085e42
[project @ 1996-03-04 00:33:32 by jwe]

diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array-C.cc
--- a/liboctave/Array-C.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array-C.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate Arrays of Complex values.
 
 #include "oct-cmplx.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array-ch.cc
--- a/liboctave/Array-ch.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array-ch.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate Arrays of char values.
 
 #include "Array.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array-d.cc
--- a/liboctave/Array-d.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array-d.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate Arrays of double values.
 
 #include "Array.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array-i.cc
--- a/liboctave/Array-i.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array-i.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate Arrays of integer values.
 
 #include "Array.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array-s.cc
--- a/liboctave/Array-s.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array-s.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate Arrays of short int values.
 
 #include "Array.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array-str.cc
--- a/liboctave/Array-str.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array-str.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate Arrays of strings.
 
 #include "Array.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array.cc
--- a/liboctave/Array.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -94,47 +94,6 @@
 }
 
 template <class T>
-T&
-Array<T>::checkelem (int n)
-{
-  if (n < 0 || n >= rep->length ())
-    {
-      (*current_liboctave_error_handler) ("range error");
-      static T foo;
-      return foo;
-    }
-  return elem (n);
-}
-
-template <class T>
-T
-Array<T>::elem (int n) const
-{
-  return rep->elem (n);
-}
-
-template <class T>
-T
-Array<T>::checkelem (int n) const
-{
-  if (n < 0 || n >= rep->length ())
-    {
-      (*current_liboctave_error_handler) ("range error");
-      T foo;
-      static T *bar = &foo;
-      return foo;
-    }
-  return elem (n);
-}
-
-template <class T>
-T
-Array<T>::operator () (int n) const
-{
-  return checkelem (n);
-}
-
-template <class T>
 void
 Array<T>::resize (int n)
 {
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array.h
--- a/liboctave/Array.h	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array.h	Mon Mar 04 00:40:14 1996 +0000
@@ -82,6 +82,15 @@
       }
   };
 
+  void make_unique (void)
+    {
+      if (rep->count > 1)
+	{
+	  --rep->count;
+	  rep = new ArrayRep (*rep);
+	}
+    }
+
 #ifdef HEAVYWEIGHT_INDEXING
   idx_vector *idx;
   int max_indices;
@@ -148,24 +157,55 @@
   int capacity (void) const { return rep->length (); }
   int length (void) const { return rep->length (); }
 
+  // XXX FIXME XXX -- would be nice to fix this so that we don't
+  // unnecessarily force a copy, but that is not so easy, and I see no
+  // clean way to do it.
+
   T& elem (int n)
     {
-      if (rep->count > 1)
-	{
-	  --rep->count;
-	  rep = new ArrayRep (*rep);
-	}
+      make_unique ();
       return rep->elem (n);
     }
 
-  T& checkelem (int n);
+  T& Array<T>::checkelem (int n)
+    {
+      if (n < 0 || n >= rep->length ())
+	{
+	  (*current_liboctave_error_handler) ("range error");
+	  static T foo;
+	  return foo;
+	}
+      else
+	return elem (n);
+    }
+
+#if defined (NO_BOUNDS_CHECKING)
+  T& operator () (int n) { return elem (n); }
+#else
   T& operator () (int n) { return checkelem (n); }
+#endif
+
+  T Array<T>::elem (int n) const { return rep->elem (n); }
 
-  T elem (int n) const;
-  T checkelem (int n) const;
-  T operator () (int n) const;
+  T Array<T>::checkelem (int n) const
+    {
+      if (n < 0 || n >= rep->length ())
+	{
+	  (*current_liboctave_error_handler) ("range error");
+	  T foo;
+	  static T *bar = &foo;
+	  return foo;
+	}
+      return elem (n);
+    }
 
-  // No checking.
+#if defined (NO_BOUNDS_CHECKING)
+  T Array<T>::operator () (int n) const { return elem (n); }
+#else
+  T Array<T>::operator () (int n) const { return checkelem (n); }
+#endif
+
+  // No checking, even for multiple references, ever.
 
   T& xelem (int n) { return rep->elem (n); }
   T xelem (int n) const { return rep->elem (n); }
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array2.cc
--- a/liboctave/Array2.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array2.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -45,54 +45,6 @@
 // Two dimensional array class.
 
 template <class T>
-T&
-Array2<T>::checkelem (int i, int j)
-{
-  if (i < 0 || j < 0 || i >= d1 || j >= d2)
-    {
-      (*current_liboctave_error_handler) ("range error");
-      static T foo;
-      return foo;
-    }
-  return Array<T>::elem (d1*j+i);
-}
-
-template <class T>
-T
-Array2<T>::elem (int i, int j) const
-{
-  return Array<T>::elem (d1*j+i);
-}
-
-template <class T>
-T
-Array2<T>::checkelem (int i, int j) const
-{
-  if (i < 0 || j < 0 || i >= d1 || j >= d2)
-    {
-      (*current_liboctave_error_handler) ("range error");
-      T foo;
-      static T *bar = &foo;
-      return foo;
-    }
-  return Array<T>::elem (d1*j+i);
-}
-
-template <class T>
-T
-Array2<T>::operator () (int i, int j) const
-{
-  if (i < 0 || j < 0 || i >= d1 || j >= d2)
-    {
-      (*current_liboctave_error_handler) ("range error");
-      T foo;
-      static T *bar = &foo;
-      return foo;
-    }
-  return Array<T>::elem (d1*j+i);
-}
-
-template <class T>
 void
 Array2<T>::resize (int r, int c)
 {
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/Array2.h
--- a/liboctave/Array2.h	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/Array2.h	Mon Mar 04 00:40:14 1996 +0000
@@ -116,14 +116,47 @@
   int columns (void) const { return d2; }
 
   T& elem (int i, int j) { return Array<T>::elem (d1*j+i); }
-  T& checkelem (int i, int j);
+
+  T& checkelem (int i, int j)
+    {
+      if (i < 0 || j < 0 || i >= d1 || j >= d2)
+	{
+	  (*current_liboctave_error_handler) ("range error");
+	  static T foo;
+	  return foo;
+	}
+      else
+	return elem (i, j);
+    }
+
+#if defined (NO_BOUNDS_CHECKING)
+  T& operator () (int i, int j) { return elem (i, j); }
+#else
   T& operator () (int i, int j) { return checkelem (i, j); }
+#endif
+
+  T elem (int i, int j) const { return Array<T>::elem (d1*j+i); }
 
-  T elem (int i, int j) const;
-  T checkelem (int i, int j) const;
-  T operator () (int i, int j) const;
+  T checkelem (int i, int j) const
+    {
+      if (i < 0 || j < 0 || i >= d1 || j >= d2)
+	{
+	  (*current_liboctave_error_handler) ("range error");
+	  T foo;
+	  static T *bar = &foo;
+	  return foo;
+	}
+      else
+	return elem (i, j);
+    }
 
-  // No checking.
+#if defined (NO_BOUNDS_CHECKING)
+  T operator () (int i, int j) const { return elem (i, j); }
+#else
+  T operator () (int i, int j) const { return checkelem (i, j); }
+#endif
+
+  // No checking of any kind, ever.
 
   T& xelem (int i, int j) { return Array<T>::xelem (d1*j+i); }
   T xelem (int i, int j) const { return Array<T>::xelem (d1*j+i); }
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/MArray-C.cc
--- a/liboctave/MArray-C.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/MArray-C.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate MArrays of Complex values.
 
 #include "oct-cmplx.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/MArray-ch.cc
--- a/liboctave/MArray-ch.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/MArray-ch.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate MArrays of char values.
 
 #include "MArray.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/MArray-d.cc
--- a/liboctave/MArray-d.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/MArray-d.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate MArrays of double values.
 
 #include "MArray.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/MArray-i.cc
--- a/liboctave/MArray-i.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/MArray-i.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate MArrays of int values.
 
 #include "MArray.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/MArray-s.cc
--- a/liboctave/MArray-s.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/MArray-s.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -20,6 +20,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 // Instantiate MArrays of short int values.
 
 #include "MArray.h"
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/MDiagArray2.cc
--- a/liboctave/MDiagArray2.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/MDiagArray2.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -47,7 +47,8 @@
     {
       (*current_liboctave_error_handler)
 	("nonconformant array operator += attempted");
-      return MDiagArray2<T> ();
+      static MDiagArray2<T> foo;
+      return foo;
     }
   else
     {
@@ -67,7 +68,8 @@
     {
       (*current_liboctave_error_handler)
 	("nonconformant array operator -= attempted");
-      return MDiagArray2<T> ();
+      static MDiagArray2<T> foo;
+      return foo;
     }
   else
     {
diff -r c1ffef39e94a -r 95e952f72d66 liboctave/pathsearch.cc
--- a/liboctave/pathsearch.cc	Sun Mar 03 20:06:08 1996 +0000
+++ b/liboctave/pathsearch.cc	Mon Mar 04 00:40:14 1996 +0000
@@ -131,7 +131,7 @@
       retval.resize (count);
 
       for (int i = 0; i < count; i++)
-	retval[i] = *tmp[i];
+	retval[i] = tmp[i];
     }
 
   return retval;