What is the simplest way to run pkg-config commands in a dune file [question]?

[UnixJunkie]

Hello,

To compile some C bindings, I would like dune to use the output of some pkg-config commands, such as:

• pkg-config --libs nlopt
• pkg-config --cflags nlopt

Am I dreaming, or dune has not support for creating a variable whose content is the output
of a system command (like the back quoting mechanism in the bash shell) ?

Thanks,
F.

[UnixJunkie]

If this is not supported, then I would strongly suggest it as a feature request.

[NielsMommen]

You can use dune's Configurator library for this purpose. It has a Pkg_config module which allows to query information about a package through pkg-config. You can then write the queried flags to sexpression files and read those generated files when compiling the C bindings.

Example

Consider the case where we want to link to some C code that uses gtksourceview2. Therefore, we would like to query flags through pkg-config in order to link the foreign stubs.

Assume you have following file structure

|-- lib
|   |-- flags
|   |   |-- discover.ml
|   |   |-- dune
|   |--
|   |-- foo_c.c
|   |-- foo.ml
|   |-- dune
|--

The dune file in lib/flags has following content:

(executable
 (name discover)
 (libraries dune-configurator))

(rule
 (targets cflags.sexp libs.sexp)
 (action
  (run %{dep:discover.exe})))

It declares an executable discover that generates cflags.sexp and libs.sexp. These files contain sexpressions which contain the flags discovered for gtksourceview2 through pkg-config. The implementation of discover could be something like:

module C = Configurator.V1

let get_gtksourceview_pkg_conf c =
  match C.Pkg_config.get c with
  | None -> C.die "Could not find 'pkg-config'"
  | Some pkg_conf -> (
      match
        C.Pkg_config.query_expr_err pkg_conf ~package:"gtksourceview-2.0"
          ~expr:""
      with
      | Ok cfg -> cfg
      | Error err -> C.die "%s" err)

let () =
  C.main ~args:[] ~name:"discover_gtksourceview_flags" @@ fun c ->
  let C.Pkg_config.{ cflags; libs } = get_gtksourceview_pkg_conf c in
  C.Flags.write_sexp "cflags.sexp" cflags;
  C.Flags.write_sexp "libs.sexp" libs

The user rule simply runs discover in order to generate cflags.sexp and libs.sexp

The dune file in lib looks like:

(library
 (name foo)
 (libraries lablgtk2 lablgtk2.sourceview2)
 ; Pass flags to c compiler when constructing the library
 ; archive file for the C stubs. E.g. to pass -lbar to the linker.
 (c_library_flags
  (:standard
   (:include flags/libs.sexp)))
 (foreign_stubs
  (language c)
  (flags
   (:include flags/cflags.sexp))
  (names foo_c)))

We use :include forms in order to include the flags that we previously generated. There is another example in dune's documentation.

[UnixJunkie]

this is too ugly

[UnixJunkie]

we should just specify in the dune file directly what is the command to run in order to get those flags

[Khady]

this is too ugly

What a interesting argument...

More seriously, nothing blocks you from having the pkg-config call directly in dune. There aren't variables, but the output can be put into a file which is used by another rule.

[UnixJunkie]

this is so ugly that it reminds me the ocamlbuild plugins that some people were so fan of writing (yes, code to compile your code); I never wrote a single one in my life