1HEADmaster

1 files changed, 491 insertions, 0 deletions

diff --git a/devtools/swigwin-1.3.34/Lib/guile/list-vector.i b/devtools/swigwin-1.3.34/Lib/guile/list-vector.i
new file mode 100644
index 0000000..d98cae5
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/guile/list-vector.i
@@ -0,0 +1,491 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * list_vector.i
+ *
+ * Guile typemaps for converting between arrays and Scheme lists or vectors  
+ * ----------------------------------------------------------------------------- */
+
+/* Here is a macro that will define typemaps for converting between C
+   arrays and Scheme lists or vectors when passing arguments to the C
+   function.
+
+   TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(C_TYPE, SCM_TO_C, C_TO_SCM, SCM_TYPE)
+   
+   Supported calling conventions:
+
+   func(int VECTORLENINPUT, [const] C_TYPE *VECTORINPUT)
+
+       Scheme wrapper will take one argument, a vector.  A temporary C
+       array of elements of type C_TYPE will be allocated and filled
+       with the elements of the vectors, converted to C with the
+       SCM_TO_C function.  Length and address of the array are passed
+       to the C function.
+
+       SCM_TYPE is used to describe the Scheme type of the elements in
+       the Guile procedure documentation.
+   
+   func(int LISTLENINPUT, [const] C_TYPE *LISTINPUT)
+
+       Likewise, but the Scheme wrapper will take one argument, a list.
+
+   func(int *VECTORLENOUTPUT, C_TYPE **VECTOROUTPUT)
+
+       Scheme wrapper will take no arguments.  Addresses of an integer
+       and a C_TYPE * variable will be passed to the C function.  The
+       C function is expected to return address and length of a
+       freshly allocated array of elements of type C_TYPE through
+       these pointers.  The elements of this array are converted to
+       Scheme with the C_TO_SCM function and returned as a Scheme
+       vector. 
+
+       If the function has a void return value, the vector constructed
+       by this typemap becomes the return value of the Scheme wrapper.
+       Otherwise, the function returns multiple values.  (See
+       the documentation on how to deal with multiple values.)
+
+   func(int *LISTLENOUTPUT, C_TYPE **LISTOUTPUT)
+
+       Likewise, but the Scheme wrapper will return a list instead of
+       a vector.
+
+   It is also allowed to use "size_t LISTLENINPUT" rather than "int
+   LISTLENINPUT".  */
+
+%define TYPEMAP_LIST_VECTOR_INPUT_WITH_EXPR(C_TYPE, SCM_TO_C_EXPR, SCM_TYPE)
+
+  /* input */
+     
+     /* We make use of the new multi-dispatch typemaps here. */
+     
+     %typemap(in, doc="$NAME is a vector of " #SCM_TYPE " values")
+       (int VECTORLENINPUT, C_TYPE *VECTORINPUT),
+       (size_t VECTORLENINPUT, C_TYPE *VECTORINPUT)
+     {
+       SCM_VALIDATE_VECTOR($argnum, $input);
+       $1 = gh_vector_length($input);
+       if ($1 > 0) {
+	 $1_ltype i;
+	 $2 = (C_TYPE *) SWIG_malloc(sizeof(C_TYPE) * $1);
+	 for (i = 0; i<$1; i++) {
+	   SCM swig_scm_value = gh_vector_ref($input, gh_int2scm(i));
+	   $2[i] = SCM_TO_C_EXPR;
+	 }
+       }
+       else $2 = NULL;
+     }
+	 
+     %typemap(in, doc="$NAME is a list of " #SCM_TYPE " values")
+       (int LISTLENINPUT, C_TYPE *LISTINPUT),
+       (size_t LISTLENINPUT, C_TYPE *LISTINPUT)
+     {
+       SCM_VALIDATE_LIST($argnum, $input);
+       $1 = gh_length($input);
+       if ($1 > 0) {
+	 $1_ltype i;
+	 SCM rest;
+	 $2 = (C_TYPE *) SWIG_malloc(sizeof(C_TYPE) * $1);
+	 for (i = 0, rest = $input;
+	      i<$1;
+	      i++, rest = gh_cdr(rest)) {
+	   SCM swig_scm_value = gh_car(rest);
+	   $2[i] = SCM_TO_C_EXPR;
+	 }
+       }
+       else $2 = NULL;
+     }
+
+     /* Do not check for NULL pointers (override checks). */
+
+     %typemap(check) (int VECTORLENINPUT, C_TYPE *VECTORINPUT),
+                     (size_t VECTORLENINPUT, C_TYPE *VECTORINPUT),
+                     (int LISTLENINPUT, C_TYPE *LISTINPUT),
+                     (size_t LISTLENINPUT, C_TYPE *LISTINPUT)
+       "/* no check for NULL pointer */";
+
+     /* Discard the temporary array after the call. */
+
+     %typemap(freearg) (int VECTORLENINPUT, C_TYPE *VECTORINPUT),
+                     (size_t VECTORLENINPUT, C_TYPE *VECTORINPUT),
+                     (int LISTLENINPUT, C_TYPE *LISTINPUT),
+                     (size_t LISTLENINPUT, C_TYPE *LISTINPUT)
+       {if ($2!=NULL) SWIG_free($2);}
+
+%enddef
+
+  /* output */
+
+%define TYPEMAP_LIST_VECTOR_OUTPUT_WITH_EXPR(C_TYPE, C_TO_SCM_EXPR, SCM_TYPE)
+
+     /* First we make temporary variables ARRAYLENTEMP and ARRAYTEMP,
+	whose addresses we pass to the C function.  We ignore both
+	arguments for Scheme. */
+
+     %typemap(in,numinputs=0) (int *VECTORLENOUTPUT, C_TYPE **VECTOROUTPUT)
+                        (int arraylentemp, C_TYPE *arraytemp),
+                      (int *LISTLENOUTPUT, C_TYPE **LISTOUTPUT)
+                        (int arraylentemp, C_TYPE *arraytemp),
+		      (size_t *VECTORLENOUTPUT, C_TYPE **VECTOROUTPUT)
+                        (size_t arraylentemp, C_TYPE *arraytemp),
+                      (size_t *LISTLENOUTPUT, C_TYPE **LISTOUTPUT)
+                        (size_t arraylentemp, C_TYPE *arraytemp)
+     %{
+       $1 = &arraylentemp;
+       $2 = &arraytemp;
+     %}
+
+     /* In the ARGOUT typemaps, we convert the array into a vector or
+        a list and append it to the results. */
+
+     %typemap(argout, doc="$NAME (a vector of " #SCM_TYPE " values)") 
+          (int *VECTORLENOUTPUT, C_TYPE **VECTOROUTPUT),
+	  (size_t *VECTORLENOUTPUT, C_TYPE **VECTOROUTPUT)
+     {
+       $*1_ltype i;
+       SCM res = gh_make_vector(gh_int2scm(*$1),
+				SCM_BOOL_F);
+       for (i = 0; i<*$1; i++) {
+	 C_TYPE swig_c_value = (*$2)[i];
+	 SCM elt = C_TO_SCM_EXPR;
+	 gh_vector_set_x(res, gh_int2scm(i), elt);
+       }
+       SWIG_APPEND_VALUE(res);
+     }
+
+     %typemap(argout, doc="$NAME (a list of " #SCM_TYPE " values)")
+          (int *LISTLENOUTPUT, C_TYPE **LISTOUTPUT),
+	  (size_t *LISTLENOUTPUT, C_TYPE **LISTOUTPUT)
+     {
+       int i;
+       SCM res = SCM_EOL;
+       for (i = ((int)(*$1)) - 1; i>=0; i--) {
+         C_TYPE swig_c_value = (*$2)[i];
+	 SCM elt = C_TO_SCM_EXPR;
+	 res = gh_cons(elt, res);
+       }
+       SWIG_APPEND_VALUE(res);
+     }
+
+     /* In the FREEARG typemaps, get rid of the C vector.  
+        (This can be overridden if you want to keep the C vector.) */
+
+     %typemap(freearg) 
+          (int *VECTORLENOUTPUT, C_TYPE **VECTOROUTPUT),
+	  (size_t *VECTORLENOUTPUT, C_TYPE **VECTOROUTPUT), 
+	  (int *LISTLENOUTPUT, C_TYPE **LISTOUTPUT),
+	  (size_t *LISTLENOUTPUT, C_TYPE **LISTOUTPUT)
+     {
+        if ((*$2)!=NULL) free(*$2);
+     }
+
+%enddef
+
+%define TYPEMAP_LIST_VECTOR_INPUT_OUTPUT_WITH_EXPR(C_TYPE, SCM_TO_C_EXPR, C_TO_SCM_EXPR, SCM_TYPE)
+  TYPEMAP_LIST_VECTOR_INPUT_WITH_EXPR(C_TYPE, SCM_TO_C_EXPR, SCM_TYPE)
+  TYPEMAP_LIST_VECTOR_OUTPUT_WITH_EXPR(C_TYPE, C_TO_SCM_EXPR, SCM_TYPE)
+%enddef
+
+%define TYPEMAP_LIST_VECTOR_INPUT(C_TYPE, SCM_TO_C, SCM_TYPE)
+  TYPEMAP_LIST_VECTOR_INPUT_WITH_EXPR
+     (C_TYPE, SCM_TO_C(swig_scm_value), SCM_TYPE)
+%enddef
+
+%define TYPEMAP_LIST_VECTOR_OUTPUT(C_TYPE, C_TO_SCM, SCM_TYPE)
+  TYPEMAP_LIST_VECTOR_OUTPUT_WITH_EXPR
+     (C_TYPE, C_TO_SCM(swig_c_value), SCM_TYPE)
+%enddef
+
+%define TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(C_TYPE, SCM_TO_C, C_TO_SCM, SCM_TYPE)
+  TYPEMAP_LIST_VECTOR_INPUT_OUTPUT_WITH_EXPR
+     (C_TYPE, SCM_TO_C(swig_scm_value), C_TO_SCM(swig_c_value), SCM_TYPE)
+%enddef
+
+/* We use the macro to define typemaps for some standard types. */
+
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(bool, gh_scm2bool, gh_bool2scm, boolean);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(char, gh_scm2char, gh_char2scm, char);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(unsigned char, gh_scm2char, gh_char2scm, char);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(int, gh_scm2int, gh_int2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(short, gh_scm2int, gh_int2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(long, gh_scm2long, gh_long2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(ptrdiff_t, gh_scm2long, gh_long2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(unsigned int, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(unsigned short, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(unsigned long, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(size_t, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(float, gh_scm2double, gh_double2scm, real);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(double, gh_scm2double, gh_double2scm, real);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(char *, SWIG_scm2str, gh_str02scm, string);
+TYPEMAP_LIST_VECTOR_INPUT_OUTPUT(const char *, SWIG_scm2str, gh_str02scm, string);
+
+/* For the char *, free all strings after converting */
+
+     %typemap(freearg) 
+          (int *VECTORLENOUTPUT, char ***VECTOROUTPUT),
+	  (size_t *VECTORLENOUTPUT, char ***VECTOROUTPUT), 
+	  (int *LISTLENOUTPUT, char ***LISTOUTPUT),
+    (size_t *LISTLENOUTPUT, char ***LISTOUTPUT),
+    (int *VECTORLENOUTPUT, const char ***VECTOROUTPUT),
+    (size_t *VECTORLENOUTPUT, const char ***VECTOROUTPUT), 
+    (int *LISTLENOUTPUT, const char ***LISTOUTPUT),
+    (size_t *LISTLENOUTPUT, const char ***LISTOUTPUT)
+    {
+	 if ((*$2)!=NULL) {
+	     int i;
+	     for (i = 0; i < *$1; i++) {
+		 if ((*$2)[i] != NULL) free((*$2)[i]);
+	     }
+	     free(*$2);
+	 }
+     }
+
+%typemap(freearg) (int VECTORLENINPUT, char **VECTORINPUT),
+    (size_t VECTORLENINPUT, char **VECTORINPUT), 
+    (int LISTLENINPUT, char **LISTINPUT),
+    (size_t LISTLENINPUT, char **LISTINPUT),
+    (int VECTORLENINPUT, const char **VECTORINPUT),
+    (size_t VECTORLENINPUT, const char **VECTORINPUT), 
+    (int LISTLENINPUT, const char **LISTINPUT),
+    (size_t LISTLENINPUT, const char **LISTINPUT)
+{
+    if (($2)!=NULL) {
+	int i;
+	for (i = 0; i< $1; i++)
+	    if (($2)[i] != NULL) free(($2)[i]);
+	free($2);
+    }
+}
+
+
+/* Following is a macro that emits typemaps that are much more
+   flexible.  (They are also messier.)  It supports multiple parallel
+   lists and vectors (sharing one length argument each).
+
+   TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(C_TYPE, SCM_TO_C, C_TO_SCM, SCM_TYPE)
+   
+   Supported calling conventions:
+
+   func(int PARALLEL_VECTORLENINPUT, [const] C_TYPE *PARALLEL_VECTORINPUT, ...)  or
+   func([const] C_TYPE *PARALLEL_VECTORINPUT, ..., int PARALLEL_VECTORLENINPUT)
+
+   func(int PARALLEL_LISTLENINPUT, [const] C_TYPE *PARALLEL_LISTINPUT, ...) or
+   func([const] C_TYPE *PARALLEL_LISTINPUT, ..., int PARALLEL_LISTLENINPUT)
+
+   func(int *PARALLEL_VECTORLENOUTPUT, C_TYPE **PARALLEL_VECTOROUTPUT, ...) or
+   func(C_TYPE **PARALLEL_VECTOROUTPUT, int *PARALLEL_VECTORLENOUTPUT, ...)
+
+   func(int *PARALLEL_LISTLENOUTPUT, C_TYPE **PARALLEL_LISTOUTPUT) or
+   func(C_TYPE **PARALLEL_LISTOUTPUT, int *PARALLEL_LISTLENOUTPUT)
+
+   It is also allowed to use "size_t PARALLEL_LISTLENINPUT" rather than "int
+   PARALLEL_LISTLENINPUT".  */
+
+%define TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_WITH_EXPR(C_TYPE, SCM_TO_C_EXPR, SCM_TYPE)
+
+  /* input */
+     
+     /* Passing data is a little complicated here; just remember:
+	IGNORE typemaps come first, then IN, then CHECK.  But if
+	IGNORE is given, IN won't be used for this type.
+
+	We need to "ignore" one of the parameters because there shall
+	be only one argument on the Scheme side.  Here we only
+	initialize the array length to 0 but save its address for a
+	later change.  */
+     
+     %typemap(in,numinputs=0) int PARALLEL_VECTORLENINPUT (int *_global_vector_length),
+		      size_t PARALLEL_VECTORLENINPUT (size_t *_global_vector_length)
+     {		      
+       $1 = 0;
+       _global_vector_length = &$1;
+     }
+
+     %typemap(in,numinputs=0) int PARALLEL_LISTLENINPUT (int *_global_list_length),   
+		      size_t PARALLEL_LISTLENINPUT (size_t *_global_list_length)
+     {		      
+       $1 = 0;
+       _global_list_length = &$1;
+     }
+
+     /* All the work is done in IN. */
+
+     %typemap(in, doc="$NAME is a vector of " #SCM_TYPE " values") 
+		  C_TYPE *PARALLEL_VECTORINPUT,
+		  const C_TYPE *PARALLEL_VECTORINPUT
+     {
+       SCM_VALIDATE_VECTOR($argnum, $input);
+       *_global_vector_length = gh_vector_length($input);
+       if (*_global_vector_length > 0) {
+	 int i;
+	 $1 = (C_TYPE *) SWIG_malloc(sizeof(C_TYPE)
+			       * (*_global_vector_length));
+	 for (i = 0; i<*_global_vector_length; i++) {
+	   SCM swig_scm_value = gh_vector_ref($input, gh_int2scm(i));
+	   $1[i] = SCM_TO_C_EXPR;
+	 }
+       }
+       else $1 = NULL;
+     }
+	 
+     %typemap(in, doc="$NAME is a list of " #SCM_TYPE " values") 
+		  C_TYPE *PARALLEL_LISTINPUT,
+		  const C_TYPE *PARALLEL_LISTINPUT
+     {
+       SCM_VALIDATE_LIST($argnum, $input);
+       *_global_list_length = gh_length($input);
+       if (*_global_list_length > 0) {
+	 int i;
+	 SCM rest;
+	 $1 = (C_TYPE *) SWIG_malloc(sizeof(C_TYPE)
+			       * (*_global_list_length));
+	 for (i = 0, rest = $input;
+	      i<*_global_list_length;
+	      i++, rest = gh_cdr(rest)) {
+	   SCM swig_scm_value = gh_car(rest);
+	   $1[i] = SCM_TO_C_EXPR;
+	 }
+       }
+       else $1 = NULL;
+     }
+
+     /* Don't check for NULL pointers (override checks). */
+
+     %typemap(check) C_TYPE *PARALLEL_VECTORINPUT, 
+		     const C_TYPE *PARALLEL_VECTORINPUT,
+		     C_TYPE *PARALLEL_LISTINPUT, 
+		     const C_TYPE *PARALLEL_LISTINPUT
+       "/* no check for NULL pointer */";
+
+     /* Discard the temporary array after the call. */
+
+     %typemap(freearg) C_TYPE *PARALLEL_VECTORINPUT, 
+		       const C_TYPE *PARALLEL_VECTORINPUT,
+		       C_TYPE *PARALLEL_LISTINPUT, 
+		       const C_TYPE *PARALLEL_LISTINPUT
+       {if ($1!=NULL) SWIG_free($1);}
+
+%enddef
+
+%define TYPEMAP_PARALLEL_LIST_VECTOR_OUTPUT_WITH_EXPR(C_TYPE, C_TO_SCM_EXPR, SCM_TYPE)
+
+  /* output */
+
+     /* First we make a temporary variable ARRAYLENTEMP, use its
+        address as the ...LENOUTPUT argument for the C function and
+        "ignore" the ...LENOUTPUT argument for Scheme.  */
+
+     %typemap(in,numinputs=0) int *PARALLEL_VECTORLENOUTPUT (int _global_arraylentemp),
+		      size_t *PARALLEL_VECTORLENOUTPUT (size_t _global_arraylentemp),
+		      int *PARALLEL_LISTLENOUTPUT   (int _global_arraylentemp),
+		      size_t *PARALLEL_LISTLENOUTPUT   (size_t _global_arraylentemp)
+       "$1 = &_global_arraylentemp;";
+
+     /* We also need to ignore the ...OUTPUT argument. */
+
+     %typemap(in,numinputs=0) C_TYPE **PARALLEL_VECTOROUTPUT (C_TYPE *arraytemp),
+		      C_TYPE **PARALLEL_LISTOUTPUT   (C_TYPE *arraytemp)
+       "$1 = &arraytemp;";
+
+     /* In the ARGOUT typemaps, we convert the array into a vector or
+        a list and append it to the results. */
+
+     %typemap(argout, doc="$NAME (a vector of " #SCM_TYPE " values)") 
+		      C_TYPE **PARALLEL_VECTOROUTPUT
+     {
+       int i;
+       SCM res = gh_make_vector(gh_int2scm(_global_arraylentemp),
+				SCM_BOOL_F);
+       for (i = 0; i<_global_arraylentemp; i++) {
+         C_TYPE swig_c_value = (*$1)[i];
+	 SCM elt = C_TO_SCM_EXPR;
+	 gh_vector_set_x(res, gh_int2scm(i), elt);
+       }
+       SWIG_APPEND_VALUE(res);
+     }
+
+     %typemap(argout, doc="$NAME (a list of " #SCM_TYPE " values)") 
+		      C_TYPE **PARALLEL_LISTOUTPUT
+     {
+       int i;
+       SCM res = SCM_EOL;
+       if (_global_arraylentemp > 0) {
+         for (i = _global_arraylentemp - 1; i>=0; i--) {
+	   C_TYPE swig_c_value = (*$1)[i];	 
+	   SCM elt = C_TO_SCM_EXPR;
+	   res = gh_cons(elt, res);
+         }
+       }
+       SWIG_APPEND_VALUE(res);
+     }
+
+     /* In the FREEARG typemaps, get rid of the C vector.  
+        (This can be overridden if you want to keep the C vector.) */
+
+     %typemap(freearg) C_TYPE **PARALLEL_VECTOROUTPUT, 
+		       C_TYPE **PARALLEL_LISTOUTPUT
+     {
+        if ((*$1)!=NULL) free(*$1);
+     }
+
+%enddef
+
+%define TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT_WITH_EXPR(C_TYPE, SCM_TO_C_EXPR, C_TO_SCM_EXPR, SCM_TYPE)
+  TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_WITH_EXPR(C_TYPE, SCM_TO_C_EXPR, SCM_TYPE)
+  TYPEMAP_PARALLEL_LIST_VECTOR_OUTPUT_WITH_EXPR(C_TYPE, C_TO_SCM_EXPR, SCM_TYPE)
+%enddef
+
+%define TYPEMAP_PARALLEL_LIST_VECTOR_INPUT(C_TYPE, SCM_TO_C, SCM_TYPE)
+  TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_WITH_EXPR
+     (C_TYPE, SCM_TO_C(swig_scm_value), SCM_TYPE)
+%enddef
+
+%define TYPEMAP_PARALLEL_LIST_VECTOR_OUTPUT(C_TYPE, C_TO_SCM, SCM_TYPE)
+  TYPEMAP_PARALLEL_LIST_VECTOR_OUTPUT_WITH_EXPR
+     (C_TYPE, C_TO_SCM(swig_c_value), SCM_TYPE)
+%enddef
+
+%define TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(C_TYPE, SCM_TO_C, C_TO_SCM, SCM_TYPE)
+  TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT_WITH_EXPR
+    (C_TYPE, SCM_TO_C(swig_scm_value), C_TO_SCM(swig_c_value), SCM_TYPE)
+%enddef
+
+/* We use the macro to define typemaps for some standard types. */
+
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(bool, gh_scm2bool, gh_bool2scm, boolean);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(char, gh_scm2char, gh_char2scm, char);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(unsigned char, gh_scm2char, gh_char2scm, char);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(int, gh_scm2int, gh_int2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(short, gh_scm2int, gh_int2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(long, gh_scm2long, gh_long2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(ptrdiff_t, gh_scm2long, gh_long2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(unsigned int, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(unsigned short, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(unsigned long, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(size_t, gh_scm2ulong, gh_ulong2scm, integer);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(float, gh_scm2double, gh_double2scm, real);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(double, gh_scm2double, gh_double2scm, real);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(char *, SWIG_scm2str, gh_str02scm, string);
+TYPEMAP_PARALLEL_LIST_VECTOR_INPUT_OUTPUT(const char *, SWIG_scm2str, gh_str02scm, string);
+
+%typemap(freearg) char **PARALLEL_LISTINPUT, char **PARALLEL_VECTORINPUT,
+    const char **PARALLEL_LISTINPUT, const char **PARALLEL_VECTORINPUT
+{
+    if (($1)!=NULL) {
+	int i;
+	for (i = 0; i<*_global_list_length; i++)
+	    if (($1)[i] != NULL) SWIG_free(($1)[i]);
+	SWIG_free($1);
+    }
+}
+
+%typemap(freearg) char ***PARALLEL_LISTOUTPUT, char ***PARALLEL_VECTOROUTPUT,
+    const char ***PARALLEL_LISTOUTPUT, const char ***PARALLEL_VECTOROUTPUT
+{
+    if ((*$1)!=NULL) {
+	int i;
+	for (i = 0; i<_global_arraylentemp; i++)
+	    if ((*$1)[i] != NULL) free((*$1)[i]);
+	free(*$1);
+    }
+}