[OpenSPARC-T2-SAM] / sam-t2 / devtools / v9 / share / swig / 1.3.26 / mzscheme / typemaps.i

/* typemaps.i --- mzscheme typemaps -*- c -*-
   Copyright 2000, 2001, 2004 Matthias Koeppe <mkoeppe@mail.math.uni-magdeburg.de>
   Based on code written by Oleg Tolmatcev.

   $Id: typemaps.i,v 1.11 2005/03/30 19:53:58 mkoeppe Exp $
*/

/* The MzScheme module handles all types uniformly via typemaps. Here
   are the definitions.  */

/* Pointers */

%typemap(in) SWIGTYPE * {
  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
}

%typemap(in) void * {
  $1 = SWIG_MustGetPtr($input, NULL, $argnum, 0);
}

%typemap(varin) SWIGTYPE * {
  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, 1, 0);
}

%typemap(varin) SWIGTYPE & {
  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
}

%typemap(varin) SWIGTYPE [ANY] {
  void *temp;
  int ii;
  $1_basetype *b = 0;
  temp = SWIG_MustGetPtr($input, $1_descriptor, 1, 0);
  b = ($1_basetype *) $1;
  for (ii = 0; ii < $1_size; ii++) b[ii] = *(($1_basetype *) temp + ii);
}
  

%typemap(varin) void * {
  $1 = SWIG_MustGetPtr($input, NULL, 1, 0);
}

%typemap(out) SWIGTYPE * {
  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
}

%typemap(out) SWIGTYPE *DYNAMIC {
  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
  $result = SWIG_NewPointerObj ($1, ty, $owner);
}
    
%typemap(varout) SWIGTYPE *, SWIGTYPE [] {
  $result = SWIG_NewPointerObj ($1, $descriptor, 0);
}

%typemap(varout) SWIGTYPE & {
  $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
}

/* C++ References */

#ifdef __cplusplus

%typemap(in) SWIGTYPE &, const SWIGTYPE & { 
  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
  if ($1 == NULL) scheme_signal_error("swig-type-error (null reference)");
}

%typemap(out) SWIGTYPE &, const SWIGTYPE & {
  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
}

%typemap(out) SWIGTYPE &DYNAMIC {
  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
  $result = SWIG_NewPointerObj ($1, ty, $owner);
}

#endif

/* Arrays */

%typemap(in) SWIGTYPE[] {
  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
}

%typemap(out) SWIGTYPE[] {
  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
}

/* Enums */
%typemap(in) enum SWIGTYPE {
  if (!SCHEME_INTP($input)) 
      scheme_wrong_type(FUNC_NAME, "integer", $argnum - 1, argc, argv);
  $1 = ($1_type) SCHEME_INT_VAL($input);
}

%typemap(varin) enum SWIGTYPE {
  if (!SCHEME_INTP($input)) 
      scheme_wrong_type(FUNC_NAME, "integer", 0, argc, argv);
  $1 = ($1_type) SCHEME_INT_VAL($input);
}

%typemap(out) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
%typemap(varout) enum SWIGTYPE "$result = scheme_make_integer_value($1);";


/* Pass-by-value */

%typemap(in) SWIGTYPE($&1_ltype argp) {
  argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
  $1 = *argp;
}

%typemap(varin) SWIGTYPE {
  $&1_ltype argp;
  argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, 1, 0);
  $1 = *argp;
}


%typemap(out) SWIGTYPE 
#ifdef __cplusplus
{
  $&1_ltype resultptr;
  resultptr = new $1_ltype(($1_ltype &) $1);
  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
} 
#else
{
  $&1_ltype resultptr;
  resultptr = ($&1_ltype) malloc(sizeof($1_type));
  memmove(resultptr, &$1, sizeof($1_type));
  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 1);
}
#endif

%typemap(varout) SWIGTYPE 
#ifdef __cplusplus
{
  $&1_ltype resultptr;
  resultptr = new $1_ltype(($1_ltype &) $1);
  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
} 
#else
{
  $&1_ltype resultptr;
  resultptr = ($&1_ltype) malloc(sizeof($1_type));
  memmove(resultptr, &$1, sizeof($1_type));
  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
}
#endif

/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
   for simple types. */

%define SIMPLE_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
%typemap(in) C_NAME {
    if (!MZ_PREDICATE($input))
	scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
    $1 = MZ_TO_C($input);
}
%typemap(varin) C_NAME {
    if (!MZ_PREDICATE($input))
	scheme_wrong_type(FUNC_NAME, #MZ_NAME, 0, argc, argv);
    $1 = MZ_TO_C($input);
}
%typemap(out) C_NAME {
    $result = C_TO_MZ($1);
}
%typemap(varout) C_NAME {
    $result = C_TO_MZ($1);
}
%typemap(in) C_NAME *INPUT (C_NAME temp) {
    temp = (C_NAME) MZ_TO_C($input);
    $1 = &temp;
}
%typemap(in,numinputs=0) C_NAME *OUTPUT (C_NAME temp) {
    $1 = &temp;
}
%typemap(argout) C_NAME *OUTPUT {
    Scheme_Object *s;
    s = C_TO_MZ(*$1);
    SWIG_APPEND_VALUE(s);
}
%typemap(in) C_NAME *BOTH = C_NAME *INPUT;
%typemap(argout) C_NAME *BOTH = C_NAME *OUTPUT;
%typemap(in) C_NAME *INOUT = C_NAME *INPUT;
%typemap(argout) C_NAME *INOUT = C_NAME *OUTPUT;
%enddef

SIMPLE_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
	   swig_make_boolean, boolean);
SIMPLE_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
	   scheme_make_character, character);
SIMPLE_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
	   scheme_make_character, character);
SIMPLE_MAP(int, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value, integer);
SIMPLE_MAP(short, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value, integer);
SIMPLE_MAP(long, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value, integer);
SIMPLE_MAP(ptrdiff_t, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value, integer);
SIMPLE_MAP(unsigned int, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value_from_unsigned, integer);
SIMPLE_MAP(unsigned short, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value_from_unsigned, integer);
SIMPLE_MAP(unsigned long, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value_from_unsigned, integer);
SIMPLE_MAP(size_t, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value_from_unsigned, integer);
SIMPLE_MAP(float, SCHEME_REALP, scheme_real_to_double,
	   scheme_make_double, real);
SIMPLE_MAP(double, SCHEME_REALP, scheme_real_to_double,
	   scheme_make_double, real);

SIMPLE_MAP(char *, SCHEME_STRINGP, SCHEME_STR_VAL, 
	   SCHEME_MAKE_STRING, string);
SIMPLE_MAP(const char *, SCHEME_STRINGP, SCHEME_STR_VAL, 
	   SCHEME_MAKE_STRING, string);

/* For MzScheme 30x:  Use these typemaps if you are not going to use
   UTF8 encodings in your C code. 
 SIMPLE_MAP(char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
 	   scheme_make_byte_string_without_copying,bytestring);
 SIMPLE_MAP(const char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
 	   scheme_make_byte_string_without_copying,bytestring);
*/

/* Const primitive references.  Passed by value */

%define REF_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
  %typemap(in) const C_NAME & (C_NAME temp) {
     if (!MZ_PREDICATE($input))
        scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
     temp = MZ_TO_C($input);
     $1 = &temp;
  }
  %typemap(out) const C_NAME & {
    $result = C_TO_MZ(*$1);
  }
%enddef

REF_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
	   swig_make_boolean, boolean);
REF_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
	   scheme_make_character, character);
REF_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
	   scheme_make_character, character);
REF_MAP(int, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value, integer);
REF_MAP(short, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value, integer);
REF_MAP(long, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value, integer);
REF_MAP(unsigned int, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value_from_unsigned, integer);
REF_MAP(unsigned short, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value_from_unsigned, integer);
REF_MAP(unsigned long, SCHEME_INTP, SCHEME_INT_VAL,
	   scheme_make_integer_value_from_unsigned, integer);
REF_MAP(float, SCHEME_REALP, scheme_real_to_double,
	   scheme_make_double, real);
REF_MAP(double, SCHEME_REALP, scheme_real_to_double,
	   scheme_make_double, real);

/* Void */

%typemap(out) void "$result = scheme_void;";

/* Pass through Scheme_Object * */

%typemap (in) Scheme_Object * "$1=$input;";
%typemap (out) Scheme_Object * "$result=$1;";
%typecheck(SWIG_TYPECHECK_POINTER) Scheme_Object * "$1=1;";


/* ------------------------------------------------------------
 * String & length
 * ------------------------------------------------------------ */

//%typemap(in) (char *STRING, int LENGTH) {
//    int temp;
//    $1 = ($1_ltype) gh_scm2newstr($input, &temp);
//    $2 = ($2_ltype) temp;
//}


/* ------------------------------------------------------------
 * Typechecking rules
 * ------------------------------------------------------------ */

%typecheck(SWIG_TYPECHECK_INTEGER)
	 int, short, long,
 	 unsigned int, unsigned short, unsigned long,
	 signed char, unsigned char,
	 long long, unsigned long long,
	 const int &, const short &, const long &,
 	 const unsigned int &, const unsigned short &, const unsigned long &,
	 const long long &, const unsigned long long &,
	 enum SWIGTYPE
{
  $1 = (SCHEME_INTP($input)) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_BOOL) bool, bool &, const bool &
{
  $1 = (SCHEME_BOOLP($input)) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_DOUBLE)
	float, double,
	const float &, const double &
{
  $1 = (SCHEME_REALP($input)) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_STRING) char {
  $1 = (SCHEME_STRINGP($input)) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_STRING) char * {
  $1 = (SCHEME_STRINGP($input)) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
  void *ptr;
  if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0)) {
    $1 = 0;
  } else {
    $1 = 1;
  }
}

%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
  void *ptr;
  if (SWIG_ConvertPtr($input, (void **) &ptr, $&1_descriptor, 0)) {
    $1 = 0;
  } else {
    $1 = 1;
  }
}

%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
  void *ptr;
  if (SWIG_ConvertPtr($input, (void **) &ptr, 0, 0)) {
    $1 = 0;
  } else {
    $1 = 1;
  }
}
Commit	Line	Data
920dae64 AT	1	/* typemaps.i --- mzscheme typemaps -- c --
	2	Copyright 2000, 2001, 2004 Matthias Koeppe <mkoeppe@mail.math.uni-magdeburg.de>
	3	Based on code written by Oleg Tolmatcev.
	4
	5	$Id: typemaps.i,v 1.11 2005/03/30 19:53:58 mkoeppe Exp $
	6	*/
	7
	8	/* The MzScheme module handles all types uniformly via typemaps. Here
	9	are the definitions. */
	10
	11	/* Pointers */
	12
	13	%typemap(in) SWIGTYPE * {
	14	$1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
	15	}
	16
	17	%typemap(in) void * {
	18	$1 = SWIG_MustGetPtr($input, NULL, $argnum, 0);
	19	}
	20
	21	%typemap(varin) SWIGTYPE * {
	22	$1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, 1, 0);
	23	}
	24
	25	%typemap(varin) SWIGTYPE & {
	26	$1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
	27	}
	28
	29	%typemap(varin) SWIGTYPE [ANY] {
	30	void *temp;
	31	int ii;
	32	$1_basetype *b = 0;
	33	temp = SWIG_MustGetPtr($input, $1_descriptor, 1, 0);
	34	b = ($1_basetype *) $1;
	35	for (ii = 0; ii < $1_size; ii++) b[ii] = (($1_basetype ) temp + ii);
	36	}
	37
	38
	39	%typemap(varin) void * {
	40	$1 = SWIG_MustGetPtr($input, NULL, 1, 0);
	41	}
	42
	43	%typemap(out) SWIGTYPE * {
	44	$result = SWIG_NewPointerObj ($1, $descriptor, $owner);
	45	}
	46
	47	%typemap(out) SWIGTYPE *DYNAMIC {
	48	swig_type_info ty = SWIG_TypeDynamicCast($1_descriptor,(void *) &$1);
	49	$result = SWIG_NewPointerObj ($1, ty, $owner);
	50	}
	51
	52	%typemap(varout) SWIGTYPE *, SWIGTYPE [] {
	53	$result = SWIG_NewPointerObj ($1, $descriptor, 0);
	54	}
	55
	56	%typemap(varout) SWIGTYPE & {
	57	$result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
	58	}
	59
	60	/* C++ References */
	61
	62	#ifdef __cplusplus
	63
	64	%typemap(in) SWIGTYPE &, const SWIGTYPE & {
65	$1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
66	if ($1 == NULL) scheme_signal_error("swig-type-error (null reference)");
67	}
68
69	%typemap(out) SWIGTYPE &, const SWIGTYPE & {
70	$result = SWIG_NewPointerObj ($1, $descriptor, $owner);
71	}
72
73	%typemap(out) SWIGTYPE &DYNAMIC {
74	swig_type_info ty = SWIG_TypeDynamicCast($1_descriptor,(void *) &$1);
75	$result = SWIG_NewPointerObj ($1, ty, $owner);
76	}
77
78	#endif
79
80	/* Arrays */
81
82	%typemap(in) SWIGTYPE[] {
83	$1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
84	}
85
86	%typemap(out) SWIGTYPE[] {
87	$result = SWIG_NewPointerObj ($1, $descriptor, $owner);
88	}
89
90	/* Enums */
91	%typemap(in) enum SWIGTYPE {
92	if (!SCHEME_INTP($input))
93	scheme_wrong_type(FUNC_NAME, "integer", $argnum - 1, argc, argv);
94	$1 = ($1_type) SCHEME_INT_VAL($input);
95	}
96
97	%typemap(varin) enum SWIGTYPE {
98	if (!SCHEME_INTP($input))
99	scheme_wrong_type(FUNC_NAME, "integer", 0, argc, argv);
100	$1 = ($1_type) SCHEME_INT_VAL($input);
101	}
102
103	%typemap(out) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
104	%typemap(varout) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
105
106
107	/* Pass-by-value */
108
109	%typemap(in) SWIGTYPE($&1_ltype argp) {
110	argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
111	$1 = *argp;
112	}
113
114	%typemap(varin) SWIGTYPE {
115	$&1_ltype argp;
116	argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, 1, 0);
117	$1 = *argp;
118	}
119
120
121	%typemap(out) SWIGTYPE
122	#ifdef __cplusplus
123	{
124	$&1_ltype resultptr;
125	resultptr = new $1_ltype(($1_ltype &) $1);
126	$result = SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
127	}
128	#else
129	{
130	$&1_ltype resultptr;
131	resultptr = ($&1_ltype) malloc(sizeof($1_type));
132	memmove(resultptr, &$1, sizeof($1_type));
133	$result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 1);
134	}
135	#endif
136
137	%typemap(varout) SWIGTYPE
138	#ifdef __cplusplus
139	{
140	$&1_ltype resultptr;
141	resultptr = new $1_ltype(($1_ltype &) $1);
142	$result = SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
143	}
144	#else
145	{
146	$&1_ltype resultptr;
147	resultptr = ($&1_ltype) malloc(sizeof($1_type));
148	memmove(resultptr, &$1, sizeof($1_type));
149	$result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
150	}
151	#endif
152
153	/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
154	for simple types. */
155
156	%define SIMPLE_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
157	%typemap(in) C_NAME {
158	if (!MZ_PREDICATE($input))
159	scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
160	$1 = MZ_TO_C($input);
161	}
162	%typemap(varin) C_NAME {
163	if (!MZ_PREDICATE($input))
164	scheme_wrong_type(FUNC_NAME, #MZ_NAME, 0, argc, argv);
165	$1 = MZ_TO_C($input);
166	}
167	%typemap(out) C_NAME {
168	$result = C_TO_MZ($1);
169	}
170	%typemap(varout) C_NAME {
171	$result = C_TO_MZ($1);
172	}
173	%typemap(in) C_NAME *INPUT (C_NAME temp) {
174	temp = (C_NAME) MZ_TO_C($input);
175	$1 = &temp;
176	}
177	%typemap(in,numinputs=0) C_NAME *OUTPUT (C_NAME temp) {
178	$1 = &temp;
179	}
180	%typemap(argout) C_NAME *OUTPUT {
181	Scheme_Object *s;
182	s = C_TO_MZ(*$1);
183	SWIG_APPEND_VALUE(s);
184	}
185	%typemap(in) C_NAME BOTH = C_NAME INPUT;
186	%typemap(argout) C_NAME BOTH = C_NAME OUTPUT;
187	%typemap(in) C_NAME INOUT = C_NAME INPUT;
188	%typemap(argout) C_NAME INOUT = C_NAME OUTPUT;
189	%enddef
190
191	SIMPLE_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
192	swig_make_boolean, boolean);
193	SIMPLE_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
194	scheme_make_character, character);
195	SIMPLE_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
196	scheme_make_character, character);
197	SIMPLE_MAP(int, SCHEME_INTP, SCHEME_INT_VAL,
198	scheme_make_integer_value, integer);
199	SIMPLE_MAP(short, SCHEME_INTP, SCHEME_INT_VAL,
200	scheme_make_integer_value, integer);
201	SIMPLE_MAP(long, SCHEME_INTP, SCHEME_INT_VAL,
202	scheme_make_integer_value, integer);
203	SIMPLE_MAP(ptrdiff_t, SCHEME_INTP, SCHEME_INT_VAL,
204	scheme_make_integer_value, integer);
205	SIMPLE_MAP(unsigned int, SCHEME_INTP, SCHEME_INT_VAL,
206	scheme_make_integer_value_from_unsigned, integer);
207	SIMPLE_MAP(unsigned short, SCHEME_INTP, SCHEME_INT_VAL,
208	scheme_make_integer_value_from_unsigned, integer);
209	SIMPLE_MAP(unsigned long, SCHEME_INTP, SCHEME_INT_VAL,
210	scheme_make_integer_value_from_unsigned, integer);
211	SIMPLE_MAP(size_t, SCHEME_INTP, SCHEME_INT_VAL,
212	scheme_make_integer_value_from_unsigned, integer);
213	SIMPLE_MAP(float, SCHEME_REALP, scheme_real_to_double,
214	scheme_make_double, real);
215	SIMPLE_MAP(double, SCHEME_REALP, scheme_real_to_double,
216	scheme_make_double, real);
217
218	SIMPLE_MAP(char *, SCHEME_STRINGP, SCHEME_STR_VAL,
219	SCHEME_MAKE_STRING, string);
220	SIMPLE_MAP(const char *, SCHEME_STRINGP, SCHEME_STR_VAL,
221	SCHEME_MAKE_STRING, string);
222
223	/* For MzScheme 30x: Use these typemaps if you are not going to use
224	UTF8 encodings in your C code.
225	SIMPLE_MAP(char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
226	scheme_make_byte_string_without_copying,bytestring);
227	SIMPLE_MAP(const char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
228	scheme_make_byte_string_without_copying,bytestring);
229	*/
230
231	/* Const primitive references. Passed by value */
232
233	%define REF_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
234	%typemap(in) const C_NAME & (C_NAME temp) {
235	if (!MZ_PREDICATE($input))
236	scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
237	temp = MZ_TO_C($input);
238	$1 = &temp;
239	}
240	%typemap(out) const C_NAME & {
241	$result = C_TO_MZ(*$1);
242	}
243	%enddef
244
245	REF_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
246	swig_make_boolean, boolean);
247	REF_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
248	scheme_make_character, character);
249	REF_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
250	scheme_make_character, character);
251	REF_MAP(int, SCHEME_INTP, SCHEME_INT_VAL,
252	scheme_make_integer_value, integer);
253	REF_MAP(short, SCHEME_INTP, SCHEME_INT_VAL,
254	scheme_make_integer_value, integer);
255	REF_MAP(long, SCHEME_INTP, SCHEME_INT_VAL,
256	scheme_make_integer_value, integer);
257	REF_MAP(unsigned int, SCHEME_INTP, SCHEME_INT_VAL,
258	scheme_make_integer_value_from_unsigned, integer);
259	REF_MAP(unsigned short, SCHEME_INTP, SCHEME_INT_VAL,
260	scheme_make_integer_value_from_unsigned, integer);
261	REF_MAP(unsigned long, SCHEME_INTP, SCHEME_INT_VAL,
262	scheme_make_integer_value_from_unsigned, integer);
263	REF_MAP(float, SCHEME_REALP, scheme_real_to_double,
264	scheme_make_double, real);
265	REF_MAP(double, SCHEME_REALP, scheme_real_to_double,
266	scheme_make_double, real);
267
268	/* Void */
269
270	%typemap(out) void "$result = scheme_void;";
271
272	/* Pass through Scheme_Object * */
273
274	%typemap (in) Scheme_Object * "$1=$input;";
275	%typemap (out) Scheme_Object * "$result=$1;";
276	%typecheck(SWIG_TYPECHECK_POINTER) Scheme_Object * "$1=1;";
277
278
279	/* ------------------------------------------------------------
280	* String & length
281	* ------------------------------------------------------------ */
282
283	//%typemap(in) (char *STRING, int LENGTH) {
284	// int temp;
285	// $1 = ($1_ltype) gh_scm2newstr($input, &temp);
286	// $2 = ($2_ltype) temp;
287	//}
288
289
290	/* ------------------------------------------------------------
291	* Typechecking rules
292	* ------------------------------------------------------------ */
293
294	%typecheck(SWIG_TYPECHECK_INTEGER)
295	int, short, long,
296	unsigned int, unsigned short, unsigned long,
297	signed char, unsigned char,
298	long long, unsigned long long,
299	const int &, const short &, const long &,
300	const unsigned int &, const unsigned short &, const unsigned long &,
301	const long long &, const unsigned long long &,
302	enum SWIGTYPE
303	{
304	$1 = (SCHEME_INTP($input)) ? 1 : 0;
305	}
306
307	%typecheck(SWIG_TYPECHECK_BOOL) bool, bool &, const bool &
308	{
309	$1 = (SCHEME_BOOLP($input)) ? 1 : 0;
310	}
311
312	%typecheck(SWIG_TYPECHECK_DOUBLE)
313	float, double,
314	const float &, const double &
315	{
316	$1 = (SCHEME_REALP($input)) ? 1 : 0;
317	}
318
319	%typecheck(SWIG_TYPECHECK_STRING) char {
320	$1 = (SCHEME_STRINGP($input)) ? 1 : 0;
321	}
322
323	%typecheck(SWIG_TYPECHECK_STRING) char * {
324	$1 = (SCHEME_STRINGP($input)) ? 1 : 0;
325	}
326
327	%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
328	void *ptr;
329	if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0)) {
330	$1 = 0;
331	} else {
332	$1 = 1;
333	}
334	}
335
336	%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
337	void *ptr;
338	if (SWIG_ConvertPtr($input, (void **) &ptr, $&1_descriptor, 0)) {
339	$1 = 0;
340	} else {
341	$1 = 1;
342	}
343	}
344
345	%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
346	void *ptr;
347	if (SWIG_ConvertPtr($input, (void **) &ptr, 0, 0)) {
348	$1 = 0;
349	} else {
350	$1 = 1;
351	}
352	}
353
354