You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
320 lines
8.6 KiB
320 lines
8.6 KiB
4 years ago
|
/* -----------------------------------------------------------------------------
|
||
|
* 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.
|
||
|
*
|
||
|
* 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(($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);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#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_name));
|
||
|
}
|
||
|
%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)
|