Version française
Home     About     Download     Resources     Contact us    

This site is updated infrequently. For up-to-date information, please visit the new OCaml website at

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

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

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  Archives: