Man Linux: Main Page and Category List


       ocamldep - Dependency generator for Objective Caml


       ocamldep [ options ] filename ...


       The ocamldep(1) command scans a set of Objective Caml source files (.ml
       and .mli files) for  references  to  external  compilation  units,  and
       outputs  dependency lines in a format suitable for the make(1) utility.
       This ensures that make will compile the source  files  in  the  correct
       order,  and  recompile  those  files that need to when a source file is

       The typical usage is:

       ocamldep options *.mli *.ml > .depend

       where .depend is the file that should contain the dependencies.

       Dependencies  are  generated  both  for  compiling  with  the  bytecode
       compiler ocamlc(1) and with the native-code compiler ocamlopt(1).


       The following command-line options are recognized by ocamldep(1).

       -I directory
              Add  the given directory to the list of directories searched for
              source files. If a  source  file  mentions  an  external
              compilation  unit  Bar,  a  dependency  on that unit’s interface
              bar.cmi is generated only if the source for bar is found in  the
              current  directory  or  in one of the directories specified with
              -I.  Otherwise, Bar is assumed to be a module from the  standard
              library,  and  no  dependencies are generated. For programs that
              span multiple directories, it is recommended to pass ocamldep(1)
              the same -I options that are passed to the compiler.

              Output       raw       dependencies       of       the      form
              filename: Module1 Module2 ... ModuleN                      where
              Module1, ..., ModuleN  are  the  names  of the compilation units
              referenced within the file filename, but  these  names  are  not
              resolved  to source file names.  Such raw dependencies cannot be
              used by make(1), but can be post-processed by other  tools  such
              as Omake(1).

              Generate   dependencies  for  a  pure  native-code  program  (no
              bytecode version).  When an implementation file (.ml  file)  has
              no  explicit  interface  file (.mli file), ocamldep(1) generates
              dependencies on  the  bytecode  compiled  file  (.cmo  file)  to
              reflect  interface changes.  This can cause unnecessary bytecode
              recompilations for programs that  are  compiled  to  native-code
              only.   The  flag -native causes dependencies on native compiled
              files (.cmx) to be generated instead of on  .cmo  files.   (This
              flag  makes no difference if all source files have explicit .mli
              interface files.)

       -pp command
              Cause ocamldep(1) to call the given command  as  a  preprocessor
              for each source file.

       -slash Under Unix, this option does nothing.

              Print version and exit.

       -help or --help
              Display a short usage summary and exit.


       ocamlc(1), ocamlopt(1).
       The Objective Caml users manual, chapter "Dependency generator".