Re: Interfacing C++ code with O'Caml

From: Thierry Bravier (bravier@dassault-aviation.fr)
Date: Thu Apr 17 1997 - 16:33:40 MET DST


Message-Id: <335634C4.2D49@dassault-aviation.fr>
Date: Thu, 17 Apr 1997 16:33:40 +0200
From: Thierry Bravier <bravier@dassault-aviation.fr>
To: caml-list@inria.fr
Subject: Re: Interfacing C++ code with O'Caml

This is a multi-part message in MIME format.

--------------246E48D1395
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit

Vincent wrote:

> I am trying to interface C++ code with O'Caml and
> I've noticed a mail from Christopher Jeris on
> Fri, 6 Dec 1996 about O'Caml/C++ interfacing.
>
> This looks a bit tricky and I just wonder if
> O'Caml current version includes C++ interfacing
> facilities (or if we could expect O'Caml next releases
> to do so).

Thierry Bravier Dassault Aviation - DGT / DTN / ELO / EAV
78, Quai Marcel Dassault F-92214 Saint-Cloud Cedex - France
Telephone : (33) 01 47 11 53 07 Telecopie : (33) 01 47 11 52 83
E-Mail : mailto:bravier@dassault-aviation.fr

--------------246E48D1395
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Content-Disposition: inline; filename="MAIL"

#==============================================================================
# File: README
# Language: fundamental
# Author: Thierry Bravier
# Time-stamp: <97/04/17 15:11:37 tb>
# Created: 97/04/17 14:57:38 tb
#==============================================================================
Dear caml community,

I also have interest in interfacing Ocaml with C/C++.

First, thanks to Xavier Leroy and to the whole ocaml team
for making ocaml available.

Here is a small contribution that might be useful to
C++ programmers.

These files include a C++ minimal API to ML values.

#------------------------------------------------------------------------------
README: This file.

#------------------------------------------------------------------------------
Makefile: Edit CXX variable to use your C++ compiler.

#------------------------------------------------------------------------------
ML.hh ML.cc: C++ API

        Features are:

        A ML class emulating the standard ocaml `value' type.

        ML objects are a kind of `smart' value since they are
        useable as any other type variable conforming to ocaml GC
        checking in and out protocol.

        a ML should be useable wherever a standard ocaml `value' is,
        thanks to a cast operator.

        Named values can be used through a name to ML constructor.

        Callbacks are there too. They are to be used with the
        functional call operator.

#------------------------------------------------------------------------------
ML_cc.cc:
        The C++ main of a test program for the API. (main () is there).

#------------------------------------------------------------------------------
ML_ml.ml:
        The ML part of the test program.

#------------------------------------------------------------------------------
The output of the test program is:

15:00:49 ocaml+C++> ML_cc
Begin
Middle
        x = 10
        x = 20
        x = 30
        x = 40
End

#------------------------------------------------------------------------------
Remarks:
        This is really a minimal API.

        I began thinking of how ML exceptions could be handled
        (I think mlraise() should be available to the C API) and it
        seems to be tricky, especially if you nest C++ calls in ML
        and ML calls in C++. It is even worse if you intend to
        try/catch C++ exceptions in ML and try/with ML exceptions in C++.

        The first difficulty is that, outside ML::init()/::caml_startup(),
        ML exceptions are not catchable allowing the user to call later
        a registered ML closure raising a fatal ML exception.

        Althouh this first version does not try to handle exceptions
        it still can be used (provided you garantee no ML exception
        will be raised outside startup).

        All suggestions are welcome as usual.

Thierry Bravier Dassault Aviation - DGT / DTN / ELO / EAV
78, Quai Marcel Dassault F-92214 Saint-Cloud Cedex - France
Telephone : (33) 01 47 11 53 07 Telecopie : (33) 01 47 11 52 83
E-Mail : mailto:bravier@dassault-aviation.fr

#==============================================================================

#==============================================================================
# File: Makefile
# Language: make
# Author: Thierry Bravier
# Time-stamp: <97/04/17 14:22:24 tb>
# Created: 97/04/17 14:21:17 tb
#==============================================================================
OCAMLC=ocamlc
STDLIB=/logiciel/ML/ocaml/stdlib

# C++ compiler: g++ or CC
CXX=g++
CCC=$(CXX)

CXXFLAGS=
CCFLAGS=$(CXXFLAGS)

CPPFLAGS=-I$(STDLIB)

LDFLAGS=-L$(STDLIB)
LDLIBS=-lcamlrun -ltermlib

#==============================================================================
OBJ=ML.o ML_ml.o ML_cc.o

#==============================================================================
ML_cc: $(OBJ)
        $(LINK.cc) -o $@ $(OBJ) $(LDLIBS)

ML_ml.o: ML_ml.ml
        $(OCAMLC) -custom -output-obj -o $@ ML_ml.ml

ML.o: ML.cc ML.hh
        $(COMPILE.cc) ML.cc

ML_cc.o: ML_cc.cc ML.hh
        $(COMPILE.cc) ML_cc.cc

#==============================================================================

// ============================================================================
// File: ML.hh
// Language: c++
// Author: Thierry Bravier
// Time-stamp: <97/04/17 14:37:13 tb>
// Created: 97/03/10 10:55:26 tb
// ============================================================================
#ifndef ML_HH
#define ML_HH

// ============================================================================
extern "C" {
#include <caml/mlvalues.h>
}

// ============================================================================
class ML {
public:
  static void init (char ** argv);

  ~ML (void); // delete ML

  ML (const value& v); // ML from value
  ML (const char *name); // ML from named value

  ML& operator = (const ML& rhs); // assignment

  operator value (void) const; // convert ML to value

  value operator () (void) const; // callback0
  value operator () (value v1) const; // callback1
  value operator () (value v1, value v2) const; // callback2
  value operator () (value v1, value v2, value v3) const; // callback3
private:
  value _value;
};

// ============================================================================
#endif /* ML_HH */

// ============================================================================

// ============================================================================
// File: ML.cc
// Language: c++
// Author: Thierry Bravier
// Time-stamp: <97/04/17 14:37:39 tb>
// Created: 97/03/10 10:55:26 tb
// ============================================================================
extern "C" {
#include <caml/mlvalues.h>
#include <caml/memory.h>
#include <caml/callback.h>
}

// ----------------------------------------------------------------------------
#include <iostream.h>
#include <stdlib.h>

#include "ML.hh"

// ============================================================================
// init
// ============================================================================
static int ready = 0;

static void get_ready (char **argv) {
  if (!ready) {
    ready = 1;
    ::caml_startup (argv);
  }
}

static void must_be_ready (void) {
  if (!ready) {
    cerr << "ML not initialized" << endl;
    ::exit (1);
  }
}

// ----------------------------------------------------------------------------
static value new_root (value *pv, value v) {
  must_be_ready ();
  ::register_global_root (pv);
  return *pv = v;
}

static void delete_root (value *pv) {
  must_be_ready ();
  ::remove_global_root (pv);
}

static value named_value (const char *name) {
  must_be_ready ();
  return *::caml_named_value ((char*) name);
}

// ----------------------------------------------------------------------------
void ML::init (char **argv) { get_ready (argv); }

// ============================================================================
// ML
// ============================================================================
ML::~ML (void) { delete_root (&_value); }

// ----------------------------------------------------------------------------
ML::ML (const value& v) : _value (new_root (&_value, v)) {}

ML::ML (const char *s) : _value (new_root (&_value, named_value (s))) {}

// ----------------------------------------------------------------------------
ML& ML::operator = (const ML& rhs) {
  if (this != &rhs) {
    delete_root (&_value);
    _value = new_root (&_value, rhs);
  }
  return *this;
}

// ----------------------------------------------------------------------------
ML::operator value (void) const { return _value; }

// ----------------------------------------------------------------------------
value ML::operator () (void) const {
  return ::callback (*this, Val_unit);
}

value ML::operator () (value v1) const {
  return ::callback (*this, v1);
}

value ML::operator () (value v1, value v2) const {
  return ::callback2 (*this, v1, v2);
}

value ML::operator () (value v1, value v2, value v3) const {
  return ::callback3 (*this, v1, v2, v3);
}

// ============================================================================

// ============================================================================
// File: ML_cc.cc
// Language: c++
// Author: Thierry Bravier
// Time-stamp: <97/04/17 14:24:56 tb>
// Created: 97/03/10 10:55:26 tb
// ============================================================================
#include <iostream.h>

#include "ML.hh"

// ============================================================================
main (int, char **argv) {
  cout << "Begin" << endl;
  ML::init (argv);
  cout << "Middle" << endl;
  {
    ML foo = "foo";
    ML bar = "bar";

    foo (bar);
  }
  cout << "End" << endl;
}

// ============================================================================

(* ============================================================================
 * File: ML_ml.ml
 * Language: caml
 * Author: Thierry Bravier
 * Time-stamp: <97/04/17 13:49:19 tb>
 * Created: 97/03/12 18:08:00 tb
 * ========================================================================= *)
open Callback
open Printf

(* ========================================================================= *)
let _ = begin
  Callback.register
    "foo" (List.iter (fun x -> printf "\tx = %d\n" x; flush stdout));
  Callback.register "bar" [10; 20; 30; 40]
end

(* ========================================================================= *)

--------------246E48D1395--



This archive was generated by hypermail 2b29 : Sun Jan 02 2000 - 11:58:10 MET