ctypes stanza

CHANGES.md

@@ -206,6 +206,12 @@ Unreleased
 - Do not pass include directories containing native objects when compiling
   bytecode (#4200, @nojb)
 
+- If an .ml file is not used by an executable, Dune no longer report
+  parsing error in this file (#4330, @jeremiedimino)
+
+- Experimental ctypes support (#3905, fixes #135, @mbacarella)
+
+
 2.8.2 (21/01/2021)
 ------------------
 

Makefile

@@ -15,6 +15,7 @@ cinaps \
 coq-native \
 "coq>=8.12.1" \
 core_bench \
+ctypes \
 "csexp>=1.3.0" \
 js_of_ocaml \
 js_of_ocaml-compiler \

doc/foreign-code.rst

@@ -64,6 +64,51 @@ without the ``.h`` extension. When a library install header files,
 these are made visible to users of the library via the include search
 path.
 
+Support for ctypes stub generation
+----------------------------------
+
+It is possible to use the ``ctypes`` stanza to generate bindings for C
+libraries without writing any C code.
+
+You need only provide two OCaml modules, named ``Type_description`` and
+``Function_description`` which describe the types, values and functions you
+want to access in the C library from OCaml.  Additionally, you must list
+any C headers and a method for resolving build and link flags.
+
+If you're binding a library distributed by your OS, you can use the
+``pkg-config`` utility to resolve any build and link flags.  Alternatively,
+if you're using a locally installed library or a vendored library, you can
+provide the flags manually.
+
+The ``Type_description`` module must define a functor named ``Types`` with
+signature ``Ctypes.TYPE``.  The ``Function_description`` module must define
+a functor named ``Functions`` with signature ``Ctypes.FOREIGN``.
+
+.. code:: scheme
+
+  (executable
+    (name foo)
+    (libraries core)
+    (flags (:standard -w -9-27))
+    (ctypes
+      (external_library_name libfoo)
+      (build_flags_resolver pkg_config)
+      (headers (include "foo.h"))
+      (type_description
+        (instance Types)
+        (functor Type_description))
+      (function_description
+        (concurrency unlocked)
+        (instance Functions)
+        (functor Function_description))
+      (generated_entry_point C)))
+
+This stanza will introduce a module named ``C`` into your project, with the
+sub-modules ``Types`` and ``Functions`` that will have your fully bound C
+types, constants and functions.
+
+A complete example of using the ctypes stanza is available here (TBD).
+
 .. _foreign-sandboxing:
 
 Foreign build sandboxing

src/dune_engine/dune_project.ml

@@ -160,6 +160,8 @@ let equal = ( == )
 
 let hash = Hashtbl.hash
 
+let parsing_context t = t.parsing_context
+
 let packages t = t.packages
 
 let version t = t.version

src/dune_engine/dune_project.mli

@@ -75,6 +75,8 @@ val equal : t -> t -> bool
 
 val hash : t -> int
 
+val parsing_context : t -> Univ_map.t
+
 (** Return the path of the project file. *)
 val file : t -> Path.Source.t
 

src/dune_rules/cm_files.ml

@@ -6,14 +6,22 @@ type t =
   ; modules : Module.t list
   ; top_sorted_modules : Module.t list Action_builder.t
   ; ext_obj : string
+  ; excluded_modules : Module_name.Set.t
   }
 
-let make ~obj_dir ~modules ~top_sorted_modules ~ext_obj =
+let filter_excluded_modules t modules =
+  List.filter modules ~f:(fun module_ ->
+    let name = Module.name module_ in
+    not (Module_name.Set.mem t.excluded_modules name))
+
+let make ?(excluded_modules=[]) ~obj_dir ~modules ~top_sorted_modules ~ext_obj () =
   let modules = Modules.impl_only modules in
-  { obj_dir; modules; top_sorted_modules; ext_obj }
+  let excluded_modules = Module_name.Set.of_list excluded_modules in
+  { obj_dir; modules; top_sorted_modules; ext_obj; excluded_modules }
 
 let objects_and_cms t ~mode modules =
   let kind = Mode.cm_kind mode in
+  let modules = filter_excluded_modules t modules in
   let cm_files = Obj_dir.Module.L.cm_files t.obj_dir modules ~kind in
   match mode with
   | Byte -> cm_files
@@ -25,8 +33,11 @@ let unsorted_objects_and_cms t ~mode = objects_and_cms t ~mode t.modules
 
 let top_sorted_cms t ~mode =
   let kind = Mode.cm_kind mode in
-  Action_builder.map t.top_sorted_modules
-    ~f:(Obj_dir.Module.L.cm_files t.obj_dir ~kind)
+  Action_builder.map t.top_sorted_modules ~f:(fun modules ->
+    let modules = filter_excluded_modules t modules in
+    Obj_dir.Module.L.cm_files t.obj_dir ~kind modules)
 
 let top_sorted_objects_and_cms t ~mode =
-  Action_builder.map t.top_sorted_modules ~f:(objects_and_cms t ~mode)
+  Action_builder.map t.top_sorted_modules ~f:(fun modules ->
+    let modules = filter_excluded_modules t modules in
+    objects_and_cms t ~mode modules)

src/dune_rules/cm_files.mli

@@ -8,10 +8,12 @@ open Stdune
 type t
 
 val make :
-     obj_dir:Path.Build.t Obj_dir.t
+     ?excluded_modules:Module_name.t list
+  -> obj_dir:Path.Build.t Obj_dir.t
   -> modules:Modules.t
   -> top_sorted_modules:Module.t list Action_builder.t
   -> ext_obj:string
+  -> unit
   -> t
 
 val unsorted_objects_and_cms : t -> mode:Mode.t -> Path.t list

src/dune_rules/compilation_context.mli

@@ -13,7 +13,7 @@ type t
 
 (** Sets whether [-opaque] is going to be used during compilation. This
     constructs a different dependency graph for native executables. In
-    partricular, we can omit dependency on .cmx files. For mli only modules,
+    particular, we can omit dependency on .cmx files. For mli only modules,
     this setting is ignored and is always set when it's available. As there are
     no .cmx files for such modules anyway *)
 type opaque =