Map Clang AST from LibTooling to AST in OCaml

Question

I'm looking for a way to map C++ ASTs, produced by Clang, to another AST in OCaml. Currently I'm using clangml to do this, which is a great library that provides bindings from libclang to OCaml.

However, I need access to the Clang's preprocessor and inject some information from the preprocessor to my AST in OCaml. This is very limited in libclang (and sometimes not possible). Currently I'm able to achieve this by using a tool that I wrote with LibTooling. This tool extracts the information that I need from the preprocessor. Afterwards, when I traverse the Clang AST with clangml, the extracted information is scanned for relevant parts and is injected in the AST in OCaml.

Instead of using clangml, I would like to extend my tool with the ability to directly map the Clang AST to the one I need in OCaml.

E.g.: Assume a part of a simplified AST in OCaml:

type src_pos = string * int * int

type loc = src_pos * src_pos

type expr =
  | True of loc
  | False of loc
  | Var of loc * string
  | UInt of loc * int
  | ...

How would I translate the corresponding expressions from Clang to this format?

Currently I'm looking at several options:

• ctypes
• ppx_cstubs
• cstruct

They all seem to be able to achieve what I want, but I don't know what would be the best option. I also don't know what would be the best way to map the Clang AST nodes to the constructors in my OCaml AST. It seems that the listed libraries don't have options to map C structs to OCaml constructors. However, it is possible to map C structs to corresponding records in OCaml. The downside is that I would probably have to write translators that map records to constructors in OCaml for every node that exists in the OCaml AST. E.g.:

type src_pos_struct = {path: string; row: int; col: int}

type loc_struct = {p1: src_pos_struct; p2: src_pos_struct}

let loc_of_loc_struct ({p1; p2}: loc_struct): loc =
  (p1.path, p1.row, p1.col), (p2.path, p2.row, p2.col)
  
type 'a cpp_node = {loc: loc_struct; data: 'a}

type uint_data = {uint: int}

type uint_struct = uint_data cpp_node

let uint_of_struct (struct: uint_struct): expr =
  let loc = loc_of_loc_struct struct.loc in
  let uint = data.uint in
  UInt (loc, uint)
...

I think another option would be to expose OCaml functions to the libtooling tool. These functions would allow to construct OCaml constructors directly on the heap in OCaml. However, I don't exactly know how this would be done.

To wrap it up: is there a way to map C structs to OCaml constructorss directly? (without the need to write a lot of transformation functions). If not, what would be the suggested way to tackle this problem?