Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] create a closure in external C function?
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Xavier Leroy <Xavier.Leroy@i...>
Subject: Re: [Caml-list] create a closure in external C function?
> I want to create a function and return it from an external C function:
> 
> type ii = int -> int
> val f : int -> ii = "c_function"
> 
> where c_function looks something like this:
> 
> value c_function( value i )
> {
>     return Val_closure(&some_c_int_int_function);
> }
> 
> Is this possible?

Not directly, at least.  Building closures from C isn't impossible,
just very delicate and highly processor-dependent (in the case of the
native-code compiler).

> So, if you wanted to make this work you'd have to return a pointer
> to a caml function that calls _caml_c_call, which isn't really
> documented either (and looks platform specific, although it seems to
> just be jumping to the address of the passed C function after
> setting things up).

Right. caml_c_call does part of the job, but is indeed very
platform-specific.

If the C functions you're interested in all have the same type,
say "int" to "int", there is an easy solution: instead of returning
them to Caml as Caml functions, return them as values of an abstract
type, and provide a separate "invoke" primitive:

(* Caml code *)

type ii
external ii_invoke: ii -> int -> int = "ii_invoke"
external c_function: ... -> ii = "c_function"

(* C code *)

value c_function(...)
{
  return (value) &some_c_int_int_function;
}

value ii_invoke(value c_function, value arg)
{
  return Val_int(((int (*)(int)) c_function)(Int_val(arg)));
}

Then, on the Caml side, you can always partially apply ii_invoke to a
value of type ii to get back the int->int Caml function you're looking
for.

This solution easily extends to the case of a finite number of C
function types, known in advance.  As Fabrice noted, the hard part is
to deal with arbitrary many C function types, determined dynamically.
There, you'd need some kind of dynamic invocation interface for C
functions, and I don't know of any C library that provides this in a
portable or semi-portable fashion.  (The closest thing that comes to
my mind is run-time code generators such as `C or Dyn-C.)

Hope this helps,

- Xavier Leroy
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr