/* -----------------------------------------------------------------------------
 * 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 }