1 files changed, 0 insertions, 401 deletions
diff --git a/Lib/array.i b/Lib/array.i
deleted file mode 100644
index b592b39b5..000000000
--- a/Lib/array.i
+++ /dev/null
@@ -1,401 +0,0 @@
-//
-// array.i
-// Dave Beazley
-// November 30, 1996
-//
-// This SWIG library file provides access to C arrays.
-
-%module carray
-
-%section "SWIG C Array Module",info,after,pre,nosort,skip=1,chop_left=3,chop_right=0,chop_top=0,chop_bottom=0
-
-%text %{
-%include array.i
-
-This module provides scripting language access to various kinds of C/C++
-arrays. For each datatype, a collection of four functions are created :
-
-   <type>_array(size)              : Create a new array of given size
-   <type>_get(array, index)        : Get an element from the array
-   <type>_set(array, index, value) : Set an element in the array
-   <type>_destroy(array)           : Destroy an array
-
-The functions in this library are only low-level accessor functions
-designed to directly access C arrays.  Like C, no bounds checking is
-performed so use at your own peril.
-%}
-
-// Grab the SWIG exception library
-
-#ifndef AUTODOC
-%include exception.i
-#endif
-
-// A Typemap used to check input arguments.
-
-%typemap(check) int *, double *, float *, char **, short *, long * {
-  if (!$target) {
-    SWIG_exception(SWIG_ValueError,"Received a NULL Pointer");
-  }
-}
-
-%typemap(ret) int *, double *, float *, char **, short *, long * {
-  if (!$source) {
-    SWIG_exception(SWIG_MemoryError,"Out of memory.");
-  }
-}
-
-// -----------------------------------------------------------------------
-// Integer array support
-// -----------------------------------------------------------------------
-
-%subsection "Integer Arrays"
-%text %{
-The following functions provide access to integer arrays (mapped
-onto the C 'int' datatype. 
-%}
-
-%{
-#include <limits.h>
-
-/* Create a new integer array */
-
-  static int *int_array(int size) {
-#ifdef __cplusplus
-    return new int[size];
-#else
-    return (int *) malloc(size*sizeof(int));
-#endif
-  }
-
-  /* Destroy an integer array */
-
-  static void int_destroy(int *array) {
-    if (array) {
-#ifdef __cplusplus
-      delete [] array;
-#else
-      free(array);
-#endif
-    }
-  }
-
-  /* Return an element */
-
-  static int int_get(int *array, int index) {
-    if (array) {
-      return array[index];
-    } else {
-      return INT_MIN;
-    }
-  }
-   
-  /* Set an element */
-  
-  static int int_set(int *array, int index, int value) {
-    if (array) {
-      return (array[index] = value);
-    } else {
-      return INT_MIN;
-    }
-  }
-
-%}
-
-int *int_array(int nitems);
-/* Creates a new array of integers. nitems specifies the number of elements.
-   The array is created using malloc() in C and new() in C++. */
-
-void int_destroy(int *array);
-/* Destroys the given array. */
-
-int int_get(int *array, int index);
-/* Returns the value of array[index]. */
-
-int int_set(int *array, int index, int value);
-/* Sets array[index] = value.  Returns value. */
-
-
-// -----------------------------------------------------------------------
-// Floating point
-// -----------------------------------------------------------------------
-
-%subsection "Floating Point Arrays"
-/* The following functions provide access to arrays of floats and doubles. */
-
-
-%{
-  #include <float.h>
-
-  /* Create a new float array */
-
-  static float *float_array(int size) {
-#ifdef __cplusplus
-    return new float[size];
-#else
-    return (float *) malloc(size*sizeof(float));
-#endif
-  }
-
-  /* Destroy an array */
-
-  static void float_destroy(float *array) {
-    if (array) {
-#ifdef __cplusplus
-      delete [] array;
-#else
-      free(array);
-#endif
-    }
-  }
-
-  /* Return an element */
-
-  static float float_get(float *array, int index) {
-    if (array) {
-      return array[index];
-    } else {
-      return FLT_MIN;
-    }
-  }
-   
-  /* Set an element */
-  
-  static float float_set(float *array, int index, float value) {
-    if (array) {
-      return (array[index] = value);
-    } else {
-      return FLT_MIN;
-    }
-  }
-
-  /* Create a new double array */
-
-  static double *double_array(int size) {
-#ifdef __cplusplus
-    return new double[size];
-#else
-    return (double *) malloc(size*sizeof(double));
-#endif
-  }
-
-  /* Destroy an array */
-
-  static void double_destroy(double *array) {
-    if (array) {
-#ifdef __cplusplus
-      delete [] array;
-#else
-      free(array);
-#endif
-    }
-  }
-
-  /* Return an element */
-
-  static double double_get(double *array, int index) {
-    if (array) {
-      return array[index];
-    } else {
-      return FLT_MIN;
-    }
-  }
-   
-  /* Set an element */
-  
-  static double double_set(double *array, int index, double value) {
-    if (array) {
-      return (array[index] = value);
-    } else {
-      return FLT_MIN;
-    }
-  }
-
-%}
-
-double *double_array(int nitems);
-/* Creates a new array of doubles. nitems specifies the number of elements.
-   The array is created using malloc() in C and new() in C++. */
-
-void double_destroy(double *array);
-/* Destroys the given array. */
-
-double double_get(double *array, int index);
-/* Returns the value of array[index]. */
-
-double double_set(double *array, int index, double value);
-/* Sets array[index] = value.  Returns value. */
-
-float *float_array(int nitems);
-/* Creates a new array of floats. nitems specifies the number of elements.
-   The array is created using malloc() in C and new() in C++. */
-
-void float_destroy(float *array);
-/* Destroys the given array. */
-
-float float_get(float *array, int index);
-/* Returns the value of array[index]. */
-
-float float_set(float *array, int index, float value);
-/* Sets array[index] = value.  Returns value. */
-
-// -----------------------------------------------------------------------
-// Character strings
-// -----------------------------------------------------------------------
-
-%subsection "String Arrays"
-
-%text %{
-The following functions provide support for the 'char **' datatype.   This
-is primarily used to handle argument lists and other similar structures that
-need to be passed to a C/C++ function.
-%}
-
-#if defined(SWIGTCL)
-%text %{
-To convert from a Tcl list into a 'char **', the following code can be used :
-
-     # $list is a list
-     set args [string_array expr {[llength $list] + 1}]
-     set i 0
-     foreach a $list {
-        string_set $args $i $a
-        incr i 1
-     }
-     string_set $i ""
-     # $args is now a char ** type
-%}
-#elif defined(SWIGPERL)
-
-%text %{
-To convert from a Perl list into a 'char **', code similar to the following
-can be used :
-
-    # @list is a list
-    my $l = scalar(@list);
-    my $args = string_array($l+1);
-    my $i = 0;
-    foreach $arg (@list) {
-        string_set($args,$i,$arg);
-        $i++;
-    }   
-    string_set($args,$i,"");
-
-(of course, there is always more than one way to do it)
-%}
-#elif defined(SWIGPYTHON)
-
-%text %{
-To convert from a Python list to a 'char **', code similar to the following
-can be used :
-
-    # 'list' is a list
-    args = string_array(len(list)+1)
-    for i in range(0,len(list)):
-	string_set(args,i,list[i])
-    string_set(args,len(list),"")
-%}
-
-#endif
-
-%{
-/* Create character string arrays */
-
-static char **string_array(int size) {
-  char **a;
-  int i;
-#ifdef __cplusplus
-  a = new char *[size];
-#else
-  a = (char **) malloc(size*sizeof(char *));
-#endif
-  for (i = 0; i < size; i++)
-    a[i] = 0;
-  return a;
-}
-
-/* Destroy a string array */
-
-static void string_destroy(char **array) {
-  int i = 0;
-  if (array) {
-      while (array[i]) {
-#ifdef __cplusplus
-            delete array[i];
-#else
-            free(array[i]);
-#endif
-            i++;
-      }          	
-#ifdef __cplusplus
-     delete [] array;
-#else
-     free(array);
-#endif
-   }      
-}
-
-/* Get an element */
-
-static char *string_get(char **array_string, int index) {
-  if (array_string) 
-    if (array_string[index]) return (array_string[index]);
-    else return "";
-  else 
-    return "";
-}
-
-/* Set an element */
-
-static char *string_set(char **array_string, int index, char * val) {
-  if (array_string) {
-    if (array_string[index]) {
-#ifdef __cplusplus
-	delete array_string[index];
-#else
-        free(array_string[index]);
-#endif
-    }	
-    if (strlen(val) > 0) {
-#ifdef __cplusplus
-      array_string[index] = new char[strlen(val)+1];
-#else
-      array_string[index] = (char *) malloc(strlen(val)+1);
-#endif
-      strcpy(array_string[index],val);
-      return array_string[index];
-    } else {
-      array_string[index] = 0;
-      return val;
-    }
-  } else return val;
-}
-
-%}
-
-char **string_array(int nitems);
-/* Creates a new array of strings. nitems specifies the number of elements.
-   The array is created using malloc() in C and new() in C++. Each element
-   of the array is set to NULL upon initialization. */
-
-void string_destroy(char **array);
-/* Destroys the given array. Each element of the array is assumed to be
-   a NULL-terminated string allocated with malloc() or new().  All of
-   these strings will be destroyed as well. (It is probably only safe to
-   use this function on an array created by string_array) */
-
-char *string_get(char **array, int index);
-/* Returns the value of array[index]. Returns a string of zero length
-   if the corresponding element is NULL. */
-
-char *string_set(char **array, int index, char *value);
-/* Sets array[index] = value.  value is assumed to be a NULL-terminated
-   string.  A string of zero length is mapped into a NULL value.  When
-   setting the value, the value will be copied into a new string allocated
-   with malloc() or new().  Any previous value in the array will be
-   destroyed. */
-
-
-%typemap(check) int *, double *, float *, char **, short *, long * = PREVIOUS;
-%typemap(out) int *, double *, float *, char **, short *, long * = PREVIOUS;
-