/trunk/Lib/ocaml/typemaps.i

  1/* -----------------------------------------------------------------------------
  2 * typemaps.i
  3 *
  4 * The Ocaml module handles all types uniformly via typemaps. Here
  5 * are the definitions.
  6 * ----------------------------------------------------------------------------- */
  7
  8/* Pointers */
  9
 10%typemap(in) void ""
 11
 12%typemap(out) void "$result = Val_int(0);"
 13
 14%typemap(in) void * {
 15    $1 = caml_ptr_val($input,$descriptor);
 16}
 17
 18%typemap(varin) void * {
 19    $1 = ($ltype)caml_ptr_val($input,$descriptor);
 20}
 21
 22%typemap(out) void * {
 23    $result = caml_val_ptr($1,$descriptor);
 24}
 25
 26%typemap(varout) void * {
 27    $result = caml_val_ptr($1,$descriptor);
 28}
 29
 30#ifdef __cplusplus
 31
 32%typemap(in) SWIGTYPE & {
 33    /* %typemap(in) SWIGTYPE & */
 34    $1 = ($ltype) caml_ptr_val($input,$1_descriptor);
 35}
 36
 37%typemap(varin) SWIGTYPE & {
 38    /* %typemap(varin) SWIGTYPE & */
 39    $1 = *(($ltype) caml_ptr_val($input,$1_descriptor));
 40}
 41
 42%typemap(out) SWIGTYPE & {
 43    /* %typemap(out) SWIGTYPE & */
 44    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
 45    if( fromval ) {
 46	$result = callback(*fromval,caml_val_ptr((void *) &$1,$1_descriptor));
 47    } else {
 48	$result = caml_val_ptr ((void *) &$1,$1_descriptor);
 49    }
 50}
 51
 52#if 0
 53%typemap(argout) SWIGTYPE & {
 54    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
 55    if( fromval ) {
 56	swig_result =
 57	    caml_list_append(swig_result,
 58			     callback(*fromval,caml_val_ptr((void *) $1,
 59							    $1_descriptor)));
 60    } else {
 61	swig_result =
 62	    caml_list_append(swig_result,
 63			     caml_val_ptr ((void *) $1,$1_descriptor));
 64    }
 65}
 66#endif
 67
 68%typemap(argout) const SWIGTYPE & { }
 69
 70%typemap(in) SWIGTYPE {
 71    $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ;
 72}
 73
 74%typemap(out) SWIGTYPE {
 75    /* %typemap(out) SWIGTYPE */
 76    $&1_ltype temp = new $ltype((const $1_ltype &) $1);
 77    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
 78    if( fromval ) {
 79	$result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor));
 80    } else {
 81	$result = caml_val_ptr ((void *)temp,$&1_descriptor);
 82    }
 83}
 84
 85%typemap(in) char *& (char *temp) {
 86  /* %typemap(in) char *& */
 87  temp = (char*)caml_val_ptr($1,$descriptor);
 88  $1 = &temp;
 89}
 90
 91%typemap(argout) char *& {
 92  /* %typemap(argout) char *& */
 93  swig_result =	caml_list_append(swig_result,caml_val_string_len(*$1, strlen(*$1)));
 94}
 95
 96#else
 97
 98%typemap(in) SWIGTYPE {
 99    $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ;
100}
101
102%typemap(out) SWIGTYPE {
103    /* %typemap(out) SWIGTYPE */
104    void *temp = calloc(1,sizeof($ltype));
105    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
106    memmove( temp, &$1, sizeof( $1_type ) );
107    if( fromval ) {
108	$result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor));
109    } else {
110	$result = caml_val_ptr ((void *)temp,$&1_descriptor);
111    }
112}
113
114%apply SWIGTYPE { const SWIGTYPE & };
115
116#endif
117
118/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
119   for simple types. */
120
121%define SIMPLE_MAP(C_NAME, C_TO_MZ, MZ_TO_C)
122/* In */
123%typemap(in) C_NAME {
124    $1 = MZ_TO_C($input);
125}
126%typemap(varin) C_NAME {
127    $1 = MZ_TO_C($input);
128}
129%typemap(in) C_NAME & ($*1_ltype temp) {
130    temp = ($*1_ltype) MZ_TO_C($input);
131    $1 = &temp;
132}
133%typemap(varin) C_NAME & {
134    $1 = MZ_TO_C($input);
135}
136%typemap(directorout) C_NAME {
137    $1 = MZ_TO_C($input);
138}
139%typemap(in) C_NAME *INPUT ($*1_ltype temp) {
140    temp = ($*1_ltype) MZ_TO_C($input);
141    $1 = &temp;
142}
143%typemap(in,numinputs=0) C_NAME *OUTPUT ($*1_ltype temp) {
144    $1 = &temp;
145}
146/* Out */
147%typemap(out) C_NAME {
148    $result = C_TO_MZ($1);
149}
150%typemap(varout) C_NAME {
151    $result = C_TO_MZ($1);
152}
153%typemap(varout) C_NAME & {
154    /* %typemap(varout) C_NAME & (generic) */
155    $result = C_TO_MZ($1);
156}
157%typemap(argout) C_NAME *OUTPUT {
158    swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1));
159}
160%typemap(out) C_NAME & {
161    /* %typemap(out) C_NAME & (generic) */
162    $result = C_TO_MZ(*$1);
163}
164%typemap(argout) C_NAME & {
165    swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1));
166}
167%typemap(directorin) C_NAME {
168    args = caml_list_append(args,C_TO_MZ($1));
169}
170%enddef
171
172SIMPLE_MAP(bool, caml_val_bool, caml_long_val);
173SIMPLE_MAP(oc_bool, caml_val_bool, caml_long_val);
174SIMPLE_MAP(char, caml_val_char, caml_long_val);
175SIMPLE_MAP(signed char, caml_val_char, caml_long_val);
176SIMPLE_MAP(unsigned char, caml_val_uchar, caml_long_val);
177SIMPLE_MAP(int, caml_val_int, caml_long_val);
178SIMPLE_MAP(short, caml_val_short, caml_long_val);
179SIMPLE_MAP(wchar_t, caml_val_short, caml_long_val);
180SIMPLE_MAP(long, caml_val_long, caml_long_val);
181SIMPLE_MAP(ptrdiff_t, caml_val_int, caml_long_val);
182SIMPLE_MAP(unsigned int, caml_val_uint, caml_long_val);
183SIMPLE_MAP(unsigned short, caml_val_ushort, caml_long_val);
184SIMPLE_MAP(unsigned long, caml_val_ulong, caml_long_val);
185SIMPLE_MAP(size_t, caml_val_int, caml_long_val);
186SIMPLE_MAP(float, caml_val_float, caml_double_val);
187SIMPLE_MAP(double, caml_val_double, caml_double_val);
188SIMPLE_MAP(long long,caml_val_ulong,caml_long_val);
189SIMPLE_MAP(unsigned long long,caml_val_ulong,caml_long_val);
190
191/* Void */
192
193%typemap(out) void "$result = Val_unit;";
194
195/* Pass through value */
196
197%typemap (in) value,caml::value,CAML_VALUE "$1=$input;";
198%typemap (out) value,caml::value,CAML_VALUE "$result=$1;";
199
200/* Arrays */
201
202%typemap(in) ArrayCarrier * {
203    $1 = ($ltype)caml_ptr_val($input,$1_descriptor);
204}
205
206%typemap(out) ArrayCarrier * {
207    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
208    if( fromval ) {
209	$result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor));
210    } else {
211	$result = caml_val_ptr ((void *)$1,$1_descriptor);
212    }
213}
214
215#if 0
216%include <carray.i>
217#endif
218
219/* Handle char arrays as strings */
220
221%define %char_ptr_in(how)
222%typemap(how)  char *, signed char *, unsigned char * {
223    /* %typemap(how) char * ... */
224    $1 = ($ltype)caml_string_val($input);
225}
226/* Again work around the empty array bound bug */
227%typemap(how) char [ANY], signed char [ANY], unsigned char [ANY] {
228    /* %typemap(how) char [ANY] ... */
229    char *temp = caml_string_val($input);
230    strcpy((char *)$1,temp); 
231    /* strncpy would be better but we might not have an array size */
232}
233%enddef
234
235%char_ptr_in(in);
236%char_ptr_in(varin);
237%char_ptr_in(directorout);
238
239%define %char_ptr_out(how) 
240%typemap(how) 
241    char *, signed char *, unsigned char *, 
242    const char *, const signed char *, const unsigned char * {
243    $result = caml_val_string((char *)$1);
244}
245/* I'd like to use the length here but can't because it might be empty */
246%typemap(how)
247    char [ANY], signed char [ANY], unsigned char [ANY],
248    const char [ANY], const signed char [ANY], const unsigned char [ANY] {
249    $result = caml_val_string((char *)$1);
250}
251%enddef
252
253%char_ptr_out(out);
254%char_ptr_out(varout);
255%char_ptr_out(directorin);
256
257%define %swigtype_ptr_in(how)
258%typemap(how) SWIGTYPE * {
259    /* %typemap(how) SWIGTYPE * */
260    $1 = ($ltype)caml_ptr_val($input,$1_descriptor);
261}
262%typemap(how) SWIGTYPE (CLASS::*) {
263    /* %typemap(how) SWIGTYPE (CLASS::*) */
264    void *v = caml_ptr_val($input,$1_descriptor);
265    memcpy(& $1, &v, sizeof(v));
266}
267%enddef
268
269%define %swigtype_ptr_out(how)
270%typemap(out) SWIGTYPE * {
271    /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */
272    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
273    if( fromval ) {
274	$result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor));
275    } else {
276	$result = caml_val_ptr ((void *)$1,$1_descriptor);
277    }
278}
279%typemap(how) SWIGTYPE (CLASS::*) {
280    /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */
281    void *v;
282    memcpy(&v,& $1, sizeof(void *));
283    $result = caml_val_ptr (v,$1_descriptor);
284}
285%enddef
286
287%swigtype_ptr_in(in);
288%swigtype_ptr_in(varin);
289%swigtype_ptr_in(directorout);
290%swigtype_ptr_out(out);
291%swigtype_ptr_out(varout);
292%swigtype_ptr_out(directorin);
293
294%define %swigtype_array_fail(how,msg)
295%typemap(how) SWIGTYPE [] {
296    failwith(msg);
297}
298%enddef
299
300%swigtype_array_fail(in,"Array arguments for arbitrary types need a typemap");
301%swigtype_array_fail(varin,"Assignment to global arrays for arbitrary types need a typemap");
302%swigtype_array_fail(out,"Array arguments for arbitrary types need a typemap");
303%swigtype_array_fail(varout,"Array variables need a typemap");
304%swigtype_array_fail(directorin,"Array results with arbitrary types need a typemap");
305%swigtype_array_fail(directorout,"Array arguments with arbitrary types need a typemap");
306
307/* C++ References */
308
309/* Enums */
310%define %swig_enum_in(how)
311%typemap(how) enum SWIGTYPE {
312    $1 = ($type)caml_long_val_full($input,"$type_marker");
313}
314%enddef
315
316%define %swig_enum_out(how)
317%typemap(how) enum SWIGTYPE {
318    $result = callback2(*caml_named_value(SWIG_MODULE "_int_to_enum"),*caml_named_value("$type_marker"),Val_int((int)$1));
319}
320%enddef
321
322%swig_enum_in(in)
323%swig_enum_in(varin)
324%swig_enum_in(directorout)
325%swig_enum_out(out)
326%swig_enum_out(varout)
327%swig_enum_out(directorin)
328
329
330/* Array reference typemaps */
331%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
332
333/* const pointers */
334%apply SWIGTYPE * { SWIGTYPE *const }
335