Re: [Caml-list] Give back a Pair from C to OCaml?

[Oliver Bandel <oliver@first.in-berlin.de>]

Zitat von Richard Jones <rich@annexia.org>:

> On Thu, Jan 17, 2008 at 07:32:19PM +0100, Oliver Bandel wrote:
> > For example I can use "CAMLprim value <functionname> (.....){...}"
> > or I can throw out "CAMLprim" (which is, what I found in the
> > OReilly-book).
>
> It's not really a good idea to "throw out" CAMLprim.  It expands to
> something useful on Windows.
[...]

OK, I will let it inside.


>
> > Also "value x" or "int x" are working as C-parameters
> > of a function. But an OCaml-int is not the same like a
> > C-int, so I would expect gcc throw out at least a warning.
> > I have added "-Wall", but no warning there.
>
> value <> int.  On normal 64 bit architectures it's defined as a long,
> but basically they are not interchangable and you should always use
> 'value' when you mean an OCaml value.

Yes, and that was the reason why I asked ;-)

So, when sseing at the C-function, that it gets
parameters from OCaml, I have to use the parameters as
"value".... at least this way remembering it makes sense.

So I will look at "value" like on a typedef'd something.




>
> > Possibly that's because what is mentioned in "18.2",
> > that int's are "value".
> > But there is no distinction between the OCaml-ints and the
> > machine's C-ints in that text. Is "an unboxed integer" meant
> > to be a machine's native int, 32 Bits or 64 Bits, depending on the
> > machine?. Can it be given as parameter and return value as it is?
>
> No.  A Caml int is not represented the same way as a C int.
[...]

Yes, I know, but I didn't know, which "int" is meant ther in the
first text-passage of 18.2.


Following all the hints here from that list
(and the manual and some OReilly's book reading),
I have done this now:

========================================
CAMLprim value both_quad( value a, value b )
{
  /* declarations, CAML-allocations and conversions */
  long a_quad;
  long b_quad;
  long a_c;
  long b_c;

  CAMLparam2( a, b );
  CAMLlocal1( result );
  result = caml_alloc (2, 0);

  a_c = Long_val( a );
  b_c = Long_val( b );



  /* now start working */

  /* do the quad */
  /* ----------- */
  a_quad = a_c * a_c;
  b_quad = b_c * b_c;

  Store_field (result, 0, Val_long(a_quad));
  Store_field (result, 1, Val_long(b_quad));

  CAMLreturn( result );
}
========================================


This is only learncode, so don't await that it would make
sense to implement this in realworld ;-)
I only want to know if this is bugfree now, and can be used
without problems.
Or can I make it better somehow?

TIA,
   Oliver