diff options
Diffstat (limited to 'share/swig/2.0.11/ocaml/typemaps.i')
| -rw-r--r-- | share/swig/2.0.11/ocaml/typemaps.i | 335 |
1 files changed, 335 insertions, 0 deletions
diff --git a/share/swig/2.0.11/ocaml/typemaps.i b/share/swig/2.0.11/ocaml/typemaps.i new file mode 100644 index 0000000..a15dc16 --- /dev/null +++ b/share/swig/2.0.11/ocaml/typemaps.i @@ -0,0 +1,335 @@ +/* ----------------------------------------------------------------------------- + * typemaps.i + * + * The Ocaml module handles all types uniformly via typemaps. Here + * are the definitions. + * ----------------------------------------------------------------------------- */ + +/* Pointers */ + +%typemap(in) void "" + +%typemap(out) void "$result = Val_int(0);" + +%typemap(in) void * { + $1 = caml_ptr_val($input,$descriptor); +} + +%typemap(varin) void * { + $1 = ($ltype)caml_ptr_val($input,$descriptor); +} + +%typemap(out) void * { + $result = caml_val_ptr($1,$descriptor); +} + +%typemap(varout) void * { + $result = caml_val_ptr($1,$descriptor); +} + +#ifdef __cplusplus + +%typemap(in) SWIGTYPE & { + /* %typemap(in) SWIGTYPE & */ + $1 = ($ltype) caml_ptr_val($input,$1_descriptor); +} + +%typemap(varin) SWIGTYPE & { + /* %typemap(varin) SWIGTYPE & */ + $1 = *(($ltype) caml_ptr_val($input,$1_descriptor)); +} + +%typemap(out) SWIGTYPE & { + /* %typemap(out) SWIGTYPE & */ + CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr"); + if( fromval ) { + $result = callback(*fromval,caml_val_ptr((void *) &$1,$1_descriptor)); + } else { + $result = caml_val_ptr ((void *) &$1,$1_descriptor); + } +} + +#if 0 +%typemap(argout) SWIGTYPE & { + CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr"); + if( fromval ) { + swig_result = + caml_list_append(swig_result, + callback(*fromval,caml_val_ptr((void *) $1, + $1_descriptor))); + } else { + swig_result = + caml_list_append(swig_result, + caml_val_ptr ((void *) $1,$1_descriptor)); + } +} +#endif + +%typemap(argout) const SWIGTYPE & { } + +%typemap(in) SWIGTYPE { + $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ; +} + +%typemap(out) SWIGTYPE { + /* %typemap(out) SWIGTYPE */ + $&1_ltype temp = new $ltype((const $1_ltype &) $1); + CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr"); + if( fromval ) { + $result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor)); + } else { + $result = caml_val_ptr ((void *)temp,$&1_descriptor); + } +} + +%typemap(in) char *& (char *temp) { + /* %typemap(in) char *& */ + temp = (char*)caml_val_ptr($1,$descriptor); + $1 = &temp; +} + +%typemap(argout) char *& { + /* %typemap(argout) char *& */ + swig_result = caml_list_append(swig_result,caml_val_string_len(*$1, strlen(*$1))); +} + +#else + +%typemap(in) SWIGTYPE { + $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ; +} + +%typemap(out) SWIGTYPE { + /* %typemap(out) SWIGTYPE */ + void *temp = calloc(1,sizeof($ltype)); + CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr"); + memmove( temp, &$1, sizeof( $1_type ) ); + if( fromval ) { + $result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor)); + } else { + $result = caml_val_ptr ((void *)temp,$&1_descriptor); + } +} + +%apply SWIGTYPE { const SWIGTYPE & }; + +#endif + +/* The SIMPLE_MAP macro below defines the whole set of typemaps needed + for simple types. */ + +%define SIMPLE_MAP(C_NAME, C_TO_MZ, MZ_TO_C) +/* In */ +%typemap(in) C_NAME { + $1 = MZ_TO_C($input); +} +%typemap(varin) C_NAME { + $1 = MZ_TO_C($input); +} +%typemap(in) C_NAME & ($*1_ltype temp) { + temp = ($*1_ltype) MZ_TO_C($input); + $1 = &temp; +} +%typemap(varin) C_NAME & { + $1 = MZ_TO_C($input); +} +%typemap(directorout) C_NAME { + $1 = MZ_TO_C($input); +} +%typemap(in) C_NAME *INPUT ($*1_ltype temp) { + temp = ($*1_ltype) MZ_TO_C($input); + $1 = &temp; +} +%typemap(in,numinputs=0) C_NAME *OUTPUT ($*1_ltype temp) { + $1 = &temp; +} +/* Out */ +%typemap(out) C_NAME { + $result = C_TO_MZ($1); +} +%typemap(varout) C_NAME { + $result = C_TO_MZ($1); +} +%typemap(varout) C_NAME & { + /* %typemap(varout) C_NAME & (generic) */ + $result = C_TO_MZ($1); +} +%typemap(argout) C_NAME *OUTPUT { + swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1)); +} +%typemap(out) C_NAME & { + /* %typemap(out) C_NAME & (generic) */ + $result = C_TO_MZ(*$1); +} +%typemap(argout) C_NAME & { + swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1)); +} +%typemap(directorin) C_NAME { + args = caml_list_append(args,C_TO_MZ($1)); +} +%enddef + +SIMPLE_MAP(bool, caml_val_bool, caml_long_val); +SIMPLE_MAP(oc_bool, caml_val_bool, caml_long_val); +SIMPLE_MAP(char, caml_val_char, caml_long_val); +SIMPLE_MAP(signed char, caml_val_char, caml_long_val); +SIMPLE_MAP(unsigned char, caml_val_uchar, caml_long_val); +SIMPLE_MAP(int, caml_val_int, caml_long_val); +SIMPLE_MAP(short, caml_val_short, caml_long_val); +SIMPLE_MAP(wchar_t, caml_val_short, caml_long_val); +SIMPLE_MAP(long, caml_val_long, caml_long_val); +SIMPLE_MAP(ptrdiff_t, caml_val_int, caml_long_val); +SIMPLE_MAP(unsigned int, caml_val_uint, caml_long_val); +SIMPLE_MAP(unsigned short, caml_val_ushort, caml_long_val); +SIMPLE_MAP(unsigned long, caml_val_ulong, caml_long_val); +SIMPLE_MAP(size_t, caml_val_int, caml_long_val); +SIMPLE_MAP(float, caml_val_float, caml_double_val); +SIMPLE_MAP(double, caml_val_double, caml_double_val); +SIMPLE_MAP(long long,caml_val_ulong,caml_long_val); +SIMPLE_MAP(unsigned long long,caml_val_ulong,caml_long_val); + +/* Void */ + +%typemap(out) void "$result = Val_unit;"; + +/* Pass through value */ + +%typemap (in) value,caml::value,CAML_VALUE "$1=$input;"; +%typemap (out) value,caml::value,CAML_VALUE "$result=$1;"; + +/* Arrays */ + +%typemap(in) ArrayCarrier * { + $1 = ($ltype)caml_ptr_val($input,$1_descriptor); +} + +%typemap(out) ArrayCarrier * { + CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr"); + if( fromval ) { + $result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor)); + } else { + $result = caml_val_ptr ((void *)$1,$1_descriptor); + } +} + +#if 0 +%include <carray.i> +#endif + +/* Handle char arrays as strings */ + +%define %char_ptr_in(how) +%typemap(how) char *, signed char *, unsigned char * { + /* %typemap(how) char * ... */ + $1 = ($ltype)caml_string_val($input); +} +/* Again work around the empty array bound bug */ +%typemap(how) char [ANY], signed char [ANY], unsigned char [ANY] { + /* %typemap(how) char [ANY] ... */ + char *temp = caml_string_val($input); + strcpy((char *)$1,temp); + /* strncpy would be better but we might not have an array size */ +} +%enddef + +%char_ptr_in(in); +%char_ptr_in(varin); +%char_ptr_in(directorout); + +%define %char_ptr_out(how) +%typemap(how) + char *, signed char *, unsigned char *, + const char *, const signed char *, const unsigned char * { + $result = caml_val_string((char *)$1); +} +/* I'd like to use the length here but can't because it might be empty */ +%typemap(how) + char [ANY], signed char [ANY], unsigned char [ANY], + const char [ANY], const signed char [ANY], const unsigned char [ANY] { + $result = caml_val_string((char *)$1); +} +%enddef + +%char_ptr_out(out); +%char_ptr_out(varout); +%char_ptr_out(directorin); + +%define %swigtype_ptr_in(how) +%typemap(how) SWIGTYPE * { + /* %typemap(how) SWIGTYPE * */ + $1 = ($ltype)caml_ptr_val($input,$1_descriptor); +} +%typemap(how) SWIGTYPE (CLASS::*) { + /* %typemap(how) SWIGTYPE (CLASS::*) */ + void *v = caml_ptr_val($input,$1_descriptor); + memcpy(& $1, &v, sizeof(v)); +} +%enddef + +%define %swigtype_ptr_out(how) +%typemap(out) SWIGTYPE * { + /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */ + CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr"); + if( fromval ) { + $result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor)); + } else { + $result = caml_val_ptr ((void *)$1,$1_descriptor); + } +} +%typemap(how) SWIGTYPE (CLASS::*) { + /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */ + void *v; + memcpy(&v,& $1, sizeof(void *)); + $result = caml_val_ptr (v,$1_descriptor); +} +%enddef + +%swigtype_ptr_in(in); +%swigtype_ptr_in(varin); +%swigtype_ptr_in(directorout); +%swigtype_ptr_out(out); +%swigtype_ptr_out(varout); +%swigtype_ptr_out(directorin); + +%define %swigtype_array_fail(how,msg) +%typemap(how) SWIGTYPE [] { + failwith(msg); +} +%enddef + +%swigtype_array_fail(in,"Array arguments for arbitrary types need a typemap"); +%swigtype_array_fail(varin,"Assignment to global arrays for arbitrary types need a typemap"); +%swigtype_array_fail(out,"Array arguments for arbitrary types need a typemap"); +%swigtype_array_fail(varout,"Array variables need a typemap"); +%swigtype_array_fail(directorin,"Array results with arbitrary types need a typemap"); +%swigtype_array_fail(directorout,"Array arguments with arbitrary types need a typemap"); + +/* C++ References */ + +/* Enums */ +%define %swig_enum_in(how) +%typemap(how) enum SWIGTYPE { + $1 = ($type)caml_long_val_full($input,"$type_marker"); +} +%enddef + +%define %swig_enum_out(how) +%typemap(how) enum SWIGTYPE { + $result = callback2(*caml_named_value(SWIG_MODULE "_int_to_enum"),*caml_named_value("$type_marker"),Val_int((int)$1)); +} +%enddef + +%swig_enum_in(in) +%swig_enum_in(varin) +%swig_enum_in(directorout) +%swig_enum_out(out) +%swig_enum_out(varout) +%swig_enum_out(directorin) + + +/* Array reference typemaps */ +%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) } + +/* const pointers */ +%apply SWIGTYPE * { SWIGTYPE *const } + |