Appel de commandes C/C++ dans OCaml

Dans un fichier lescmds.ml, écrire :

external ma_cmd : string -> int = "CamlMaCmd"

On définit ainsi la commande caml ma_cmd qui fait appel à la fonction C/C++ CamlMaCmd. Ici, la fonction prend une chaîne de caractères en entrée, et rend un entier, mais on peut bien sûr avoir la signature que l'on veut.

Dans un fichier cmds.cc, écrire :

extern "C" value CamlMaCmd (value v_str) {
  CAMLparam1 (v_str);
  CAMLlocal1 (v_res);

  std::string str = String_val (v_str);
  std::cout << "Bonjour " << str << " !\n";

  int l = str.size();
  v_res = Val_int (l);

  CAMLreturn (v_res);
}

Tout d'abord, comme les fonctions appelées par ocaml sont des fonctions C, il ne faut pas oublier de le préciser si on compile (comme moi) en C++.
Les macros CAMLparam1, CAMLlocal1, CAMLreturn sont utilisées par le ramasse-miettes (garbage collector) de ocaml. Il est TRÈS important de ne pas les oublier pour tout ce qui est de type value sous peine de bugs graves et introuvables… Si la fonction ne renvoie pas de résultat, elle se termine par :

CAMLreturn (Val_unit);

Les macros String_val et Val_int permettent de traduire des objets de type value de et vers des types C. Les plus courantes sont fournies, mais on peut aussi écrire ses propres fonctions si on a des types plus compliqués.
Avant de pouvoir compiler, il faut bien sûr ajouter les fichiers d'entête C++ :

#include <iostream>
#include <string>

et les fichiers d'entête OCaml :

extern "C" {
#include <memory.h>
#include <mlvalues.h>
} // FIN extern "C"

Une compilation C++ standard (en précisant tout de même le chemin pour les entêtes ocaml) :

g++ -o cmds.o -I/usr/local/lib/ocaml/caml/ -c cmds.c

La compilation ocaml pour fabriquer lescmds.cmi et lescmds.cmo :

ocamlc -c lescmds.ml

et enfin, l'édition de liens :

ocamlmktop -custom -cc "g++" -o test lescmds.cmo cmds.o

Lors de cette dernière étape, on a choisi ici de faire l'édition de liens avec l'interpréteur de commande (toplevel system). On verra plus loin qu'on peut aussi produire un simple exécutable.

On peut maintenant lancer :

./test

On se retrouve dans l'interpréteur de commande, et on peut lancer :

Lescmds.ma_cmd "Anne";;

Maintenant, on aimerait mieux avoir un accueil plus personnalisé. Pour cela, on ajoute une petite fonction dans lescmds.ml :

let intro () =
   Printf.printf "\n  Bienvenue !\n\n" ;
   Printf.printf "Pour tester  l'outil, tapez : ma_cmd \"votre nom\";;\n" ;
   Printf.printf "Pour quitter l'outil, tapez : #quit;; (avec le #)\n\n"

On veut qu'elle soit lancée automatiquement, et on en profite aussi pour ouvrir le module Lescmds afin de pouvoir taper directement ma_cmd au lieu de Lescmds.ma_cmd. Pour cela, on crée un fichier .ocamlinit qui contient :

Lescmds.intro();;
open Lescmds;;

Et voilà ! ça marche :-)

Pour produire un exécutable, il faut avoir quelque chose à exécuter. On va donc commencer par ajouter quelque chose à exécuter dans lescmds.ml, par exemple :

ma_cmd "depuis lescmds.ml";;

Pour changer, on décide d'utiliser ocamlopt (compilateur en code natif) plutôt que ocamlc qui produit du bytecode. On va donc construire lescmds.cmx à l'aide de la commande :

ocamlopt -cc "g++" -c lescmds.ml

On utilise le même fichier C/C++ que précédemment

ocamlopt -cc "g++" -o test2 lescmds.cmx cmds.o

On obtient bien :

$ ./test2
Bonjour depuis lescmds.ml !

Et comme on en veut toujours plus, on décide maintenant d'ajouter un main au programme C/C++

On ajoute une fonction main à cmds.c :

int main (int argc, char * argv[]) {
  caml_main (argv);
  std::cout << "Lancement du main...\n";
  return 0;
}

Il faut noter qu'on doit forcement commencer par un appel à caml_main.

On obtient bien :

Bonjour depuis lescmds.ml !
Lancement du main...

On voit qu'on a commencé par initialiser le module OCaml, puis lancé de main !

Il faut connaitre les commandes que l'on va vouloir appeler, car il faut leur ajouter une callback. On pense par exemple qu'il est beaucoup trop difficile de multiplier par 2 en C/C++ ;-) aussi décide-t-on de faire une petite commande ocaml :

let fois2 x = 2*x
let _ = Callback.register "caml_fois2" fois2 ;;

La seconde ligne sert à enregister la commande fois2, et à indiquer le nom qu'on souhaite lui donner côté C/C++ (caml_fois2 ici). Ce nom peut bien sûr être le même que le nom de la commande si on le souhaite.

Voici la fonction qui sert à appeler la commande :

int Fois2 (int x) {
  CAMLlocal2 (v_x, v_res);
  char * cmd = "caml_fois2";
  v_x =  Val_int (x);
  v_res = callback (*caml_named_value (cmd), v_x);
  int res = Int_val (v_res);
  std::cout << cmd << " (" << x << ") = " << res << "\n";
  return res;
}

On y retrouve les fonctions de traduction des types C/C++ vers le type value de ocaml, et l'appel à la fonction (callback) que l'on a retrouvée à partir de son nom (caml_named_value)

Exercice :

• ajouter un appel à cette merveilleuse fonction dans le main ;
• compiler/faire l'édition de liens ;
• exécuter ;
• et… ça marche !