OMyMakefile

# ==========================
# OMyMakefile
# ==========================
# Useful functions to build OCaml projects

#| A flag to tell that we can use OMyMakefile functions
WithOMy=true

#| The prefix. Equal to the PREFIX environment variable
try
  # PREFIX=<prefix> omake  or  omake PREFIX=<prefix>
  if $(not $(defined PREFIX)):
    PREFIX=$(getenv PREFIX)
    export PREFIX
default
  try
    # If opam is available we use its prefix
    PREFIX=$(shell opam config var prefix)
    export PREFIX
  default
    eprintln(Specify PREFIX environment variable.)
    exit 1 
  export PREFIX

#| OMy requires OCamlFind!
USE_OCAMLFIND = true
OCAMLFIND_DESTDIR= $(shell ocamlfind printconf destdir)
OCAMLFIND_QUERY(name) = 
    return $(shell ocamlfind query $(name))

#| We fed up with the warning
setenv(OCAMLFIND_IGNORE_DUPS_IN, $(OCAMLFIND_DESTDIR)/ocaml/compiler-libs)

# Misc tools
# ======================================================================

#|ditto.
mkdir_if_not_exists(dir) =
  if $(not $(test -e $(dir))):
    mkdir -p $(dir) 
  return

#| filter list
#  example::
#     is_url(file) =
#       match $(file)
#       case $'://'
#         return true
#       default
#         return false
# 
#     DOWNLOAD_URLS[]=$(list_filter $(fun x, $(is_url $(x))), $(URLS))
list_filter(pred, list) =
  result=
  foreach(x, $(list))
    if $(apply $(pred), $(x))
      result+=$(x)
      export
    export
  return $(result)

# Common phonies
# ==================================================================
.PHONY: all install uninstall clean veryclean

# Directories
# =====================================================================

#| The build root directory  
BIG_ROOT=$(dir .)

# Installation mark files
# =======================================================================

#| To enable the installation mark files, you must define INSTALLED path variable
# for the mark file directory like INSTALLED=$(BIG_ROOT)/installed and make sure
# the directory $(INSTALLED) exists. This preparation must be done outside of 
# this OMyMakefile.

#|Returns the installation mark files of $(packs)
Installed(packs) = 
  if $(defined INSTALLED)
      return $(addsuffix .installed, $(addprefix $(INSTALLED)/, $(packs)))
  else
      return $(array) # empty

#|Create md5 sum file of files $(targets)
CreateCheckSum(pack, targets)=
    chan=$(fopen $(pack), w)
    fprintln($(chan), $(string $(targets)))
    fprintln($(chan), $(string $(digest $(targets))))
    close($(chan))

#|Create $(Installed $(pack)) file from the digests of $(targets)
CreateInstalled(pack, targets)=
    if $(defined INSTALLED)
        println(dump md5 $(INSTALLED)/$(pack))
        CreateCheckSum($(INSTALLED)/$(pack).installed, $(targets))

# OCaml 
# ========================================================================

#| OCAMLANY is either byte or native
OCAMLANY =
    if $(OCAMLC_EXISTS)
        value $(OCAMLC)
    else 
        value $(OCAMLOPT)

#|Path to the OCaml library directory
OCAML_WHERE = $(shell $(OCAMLANY) -where)

#|Version without extensions
OCAML_VERSION = $(shell $(OCAMLANY) -version | sed -e 's/^\([0-9.]*\).*/\1/')

#|Set NATIVE_ENABLED false locally if a project does not requre opt compilation.
NATIVE_SHARED_ENABLED = $(OCAMLOPT_EXISTS)

#|BYTE_ENABLED = true by default
BYTE_ENABLED = true

#|The default warning and errors. If you want to use different warning and error switches, redefine the variable.
OCAMLFLAGS = -g 

#|Warnings not to be printed, separted with space
OCAMLWARNING_IGNORE[] = 3 4 9 40 41 42 44 45 48

#|Warnings treated as non errors
OCAMLWARNING_NON_ERROR[] = 4 9 40 41 42 44 45 48

#|If it is false, warnings do not stop the compilation even if they are listed in OCAMLWARNING_NON_ERROR
#If you are in developing something, override it to true!
OCAMLWARNING_STOP_AT_ERROR_WARNING=false

#|The maximum warning value.
# This is the maximum warning ID NOT of your current OCaml compiler,
#                                BUT of the OCaml compiler used by the author of OMyMakefile.
OCAMLWARNING_MAX= 50

#|Function to build warning switches
OCAMLWARNING_MAKE()=
    if $(OCAMLWARNING_STOP_AT_ERROR_WARNING)
        return -w $(concat -,A $(OCAMLWARNING_IGNORE)) -warn-error +1..$(concat -, $(OCAMLWARNING_MAX) $(OCAMLWARNING_NON_ERROR))
    else
        return -w $(concat -,A $(OCAMLWARNING_IGNORE)) -warn-error a

#|Global variable to be defined as empty
OCAMLPACKAGEFLAGS=

#|Preinstalled libraries which are always available for normal ocaml.
#
# You may want to add the required packages which are built and installed out of OMy framework:
#
#::
#
#   include OMyMakefile
#   
#   OCAML_PREINSTALLED_PACKS += llvm # llvm has been installed already, independently
#   
#   Subdirs()
#
# It includes "findlib" by default. If you want to build findlib in OMy framework, you have to remove it from the list.
OCAML_PREINSTALLED_PACKS[]= bigarray dynlink graphics num num-top stdlib str threads unix findlib compiler-libs compiler-libs.common compiler-libs.bytecomp compiler-libs.optcomp compiler-libs.toplevel

if $(and $(not $(NATIVE_ENABLED)) $(not $(BYTE_ENABLED)))
   err. =
       extends $(UnbuildableException)
       message = $(string $"You must turn on either NATIVE_ENABLED or BYTE_ENABLED")
       raise $(err)

#|OMyMakefile assumes installation with .cmt files
OCAMLANNOTFLAGS= -annot -bin-annot

#|Redefinition of compiler commands
OCamlC() =
    value $(OCAMLFIND) $(OCAMLC) \
        $(OCAMLPACKAGEFLAGS) \
        $(LAZY_OCAMLFINDFLAGS) \
        $(PREFIXED_OCAMLPACKS) \
        $(OCAMLFLAGS) \
        $(OCAMLWARNING_MAKE) \
        $(OCAMLCFLAGS) \
        $(OCAMLANNOTFLAGS) \
        $(OCAMLPPFLAGS) \
        $(PREFIXED_OCAMLINCLUDES)

OCamlOpt() =
    value $(OCAMLFIND) $(OCAMLOPT) \
        $(OCAMLPACKAGEFLAGS) \
        $(LAZY_OCAMLFINDFLAGS) \
        $(PREFIXED_OCAMLPACKS) \
        $(OCAMLFLAGS)\
        $(OCAMLWARNING_MAKE) \
        $(OCAMLOPTFLAGS) \
        $(OCAMLANNOTFLAGS) \
        $(OCAMLPPFLAGS) \
        $(PREFIXED_OCAMLINCLUDES)

#|Additional implicit rules by file extensions
# annot, cmt, cmti files
%.annot %.cmt: %.ml %.cmi
	$(OCamlC) -c $<

%.cmti: %.mli 
	$(OCamlC) -c $<

#|We recommend to have OCAMLPARAM=_,g=1,annot=1,bin-annot=1

#|Enable the backtrace
setenv(OCAMLRUNPARAM, b)

# Very clean
# ======================================================================

#| OCaml object files which are not real targets of OMake are not be
# auto-cleaned away by ``omake clean``. This is not good in some situations
# at linking.
WithOCamlVeryClean() =
    veryclean: 
        rm -f *.cm* *.annot *.o *.a *.so *.exe *.byt *.opt *.run

# Packages
# =========================================================

#| OCaml packages required for compilation. MyCaml* functions automatically add necessary dependencies over packages in $(OCAMLPACKS).
# 
# .. note:: They are also required for dependency analysis.
OCAMLPACKS[]=

# Dependencies
# =========================================================================

#|Returns packages managed by OMy framework
OMyManagedPackages(packages) =
   # need to rename camlimages.jpeg => camlimages
   packages_prefix=
   foreach(x, $(packages))
       match $(x)
       case $"^\([^.]+\).*"
          packages_prefix += $1
          export
       default
          packages_prefix += $(x)
          export
       export
   return $(set-diff $(packages_prefix), $(OCAML_PREINSTALLED_PACKS))

#|Add dependencies of OCaml compiled files (cmx, cmo, etc.) over $(files).
#
# .. note:: These functions introduce implicit rules: *you may need to export it, if you use this function in a local context.*
OCamlRequire(files) =
    .SCANNER: scan-ocaml-%: $(files)
    %.cmx %.cmo %.cmi %.cma %.cmxa %.cmxs %.annot %.cmt %.cmti: $(files)
    export

#|Add dependencies of OCaml compiled files (cmx, cmo, etc.) over $(packages).
# $(packages) listed in OCAML_PREINSTALLED_PACKS are ignored.
#
# .. note:: These functions introduce implicit rules: *you may need to export it, if you use this function in a local context.*
#
# .. note:: Usually you do not need to call this function. Use OCAMLPACKS variable instead. 
OCamlRequirePackages(packages) =
    if $(defined INSTALLED)
      required_packs = $(OMyManagedPackages $(packages))
      # replacing the following two lines makes something wrong...
      .SCANNER: scan-ocaml-%: $(Installed $(required_packs))
      %.cmx %.cmo %.cmi %.cma %.cmxa %.cmxs %.annot %.cmt %.cmti: $(Installed $(required_packs))
      export
    export

#|``omake xxx.auto.mli`` generates .mli file from xxx.ml 
%.auto.mli: %.ml
	$(OCamlC) -i -c $< > $@

# Build rules
# ==========================================================

OCamlLibrary(name, files) =
   # XXX: JYH: these variables should be marked private in 0.9.9
   protected.name = $(file $(name))

   protected.OFILES   = $(addsuffix $(EXT_OBJ), $(files))
   protected.CMOFILES = $(addsuffix .cmo, $(files))
   protected.CMXFILES = $(addsuffix .cmx, $(files))

   protected.CLIB      = $(file $(name)$(EXT_LIB))
   protected.BYTELIB   = $(file $(name).cma)
   protected.NATIVELIB = $(file $(name).cmxa)
   protected.NATIVESHAREDLIB = $(file $(name).cmxs)

   #
   # Link commands
   #
   $(BYTELIB): $(CMOFILES)
        $(OCAMLFIND) $(OCAMLLINK) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) $(OCAMLCFLAGS) \
                $(OCAML_LIB_FLAGS) -a -o $@ $(OCamlLinkSort $(CMOFILES))

   $(NATIVELIB) $(CLIB): $(CMXFILES) $(OFILES)
        $(OCAMLFIND) $(OCAMLOPTLINK) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) $(OCAMLOPTFLAGS) \
                $(OCAML_LIB_FLAGS) -a -o $(NATIVELIB) $(OCamlLinkSort $(CMXFILES))

   $(NATIVESHAREDLIB): $(CMXFILES) $(OFILES)
         $(OCAMLFIND) $(OCAMLOPTLINK) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) $(OCAMLOPTFLAGS) \
                 $(OCAML_LIB_FLAGS) -shared -o $(NATIVESHAREDLIB) $(OCamlLinkSort $(CMXFILES))

   return $(array $(if $(NATIVE_ENABLED), $(NATIVELIB)), \
                  $(if $(NATIVE_ENABLED), $(CLIB)), \
                  $(if $(NATIVE_SHARED_ENABLED), $(NATIVESHAREDLIB)), \
                  $(if $(BYTE_ENABLED), $(BYTELIB)))

OCAML_BYTE_LINK_FLAGS =

# The original OCamlPackage does not work properly when omake -j n
# where n > 1.  It sometimes creates .cmo/.cmx files with strange module
# signature checksum of itself, because it runs the byte and native
# packaging command in parallel at the same time. See details at:
#
# https://github.com/ocaml-omake/omake/issues/73
# https://github.com/ocaml/opam-repository/pull/8306
#
# Here, we try the packaging in sequence.
FixedOCamlPackage(name, files) =
   # XXX: JYH: these variables should be marked private in 0.9.9
   protected.OFILES   = $(addsuffix $(EXT_OBJ), $(files))
   protected.CMOFILES = $(addsuffix .cmo, $(files))
   protected.CMXFILES = $(addsuffix .cmx, $(files))

   protected.OBJ       = $(file $(name)$(EXT_OBJ))
   protected.CMO       = $(file $(name).cmo)
   protected.CMX       = $(file $(name).cmx)
   protected.CMI       = $(file $(name).cmi)
   protected.MLI       = $(file $(name).mli)

   protected.BYTE_TARGETS   = $(CMO)
   protected.NATIVE_TARGETS = $(CMX) $(OBJ)

   protected.TARGETS = $(file $(name).cmt) $(CMI)

   if $(NATIVE_ENABLED)
       TARGETS += $(NATIVE_TARGETS)
       export

   if $(BYTE_ENABLED)
       TARGETS += $(BYTE_TARGETS)
       export

   protected.BYTE_DEPS = $(CMOFILES)
   protected.NATIVE_DEPS = $(CMXFILES) $(OFILES)
   protected.DEPS =

   if $(NATIVE_ENABLED)
       DEPS += $(NATIVE_DEPS)
       export

   if $(BYTE_ENABLED)
       DEPS += $(BYTE_DEPS)
       export

# For now, do not consider about packages with .mli
#        if $(target-exists $(MLI))
#            $(CMI): $(MLI) :scanner: scan-ocaml-$(name).mli
#                 $(OCamlC) -c $<

   $(TARGETS): $(DEPS)
      if $(BYTE_ENABLED)
           $(OCAMLFIND) $(OCAMLC) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) \
               $(OCAMLCFLAGS) $(OCAML_LIB_FLAGS) -pack $(OCAMLANNOTFLAGS) -o $(CMO) $(OCamlLinkSort $(CMOFILES))
      if $(NATIVE_ENABLED)
           $(OCAMLFIND) $(OCAMLOPTLINK) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) \
               $(OCAMLOPTFLAGS) $(OCAML_LIB_FLAGS) -pack $(OCAMLANNOTFLAGS) -o $(CMX) $(OCamlLinkSort $(CMXFILES))

   return $(TARGETS)

# Add implicit dependencies over the packages declared in OCAMLPACKS
# If this function is used in a local scope, you may want to export. 
AddLocalOCamlPackageDependencies() =
  # We make sure the required libraries are installed
  OCamlRequirePackages($(OCAMLPACKS))
  export

#| Add a rule for OCaml package $(library_name).cmo, $(library_name).cmx and etc.
#     library_name
#         target package name
#     files
#         ML module names (without .ml)
#     cmodules
#         C source files (without .c)
#     linkopts
#         C library link option (without OCaml -cclib options)    
#
#  You can specify MyOCamlPackageExtras before using this function to install files out of the scope of this rule.   
#  
#  If $(NO_INSTALL) is defined, omake install does not install the package
#
#  Example::
#
#      MyOCamlPackage(foo, alpha beta, $(EMPTY), $(EMPTY))
#
#  Todo: external C library
MyOCamlPackage(library_name, files, cmodules, linkopts) =
  WithOCamlVeryClean()
  AddLocalOCamlPackageDependencies()
  export # The above thing is local: need to be exported

  CSTUBS=$(addsuffix .o,$(cmodules))
  CMO_S=$(addsuffix .cmo,$(library_name))
  CMX_S=$(addsuffix .cmx,$(library_name))
  CMO=$(library_name).cmo
  CMI=$(library_name).cmi
  CMA=$(library_name).cma
  CMX=$(library_name).cmx
  CMXA=$(library_name).cmxa
  CMXS=$(library_name).cmxs
  CMT=$(library_name).cmt
  O=$(library_name).o
  A=$(library_name).a

  if $(not $(defined PACKAGE_NAME))
    findlib_name=$(lowercase $(library_name))
    export
  else
    findlib_name=$(PACKAGE_NAME)
    export

  if $(not $(defined MyOCamlPackageExtras))
    MyOCamlPackageExtras[]=
    export

  CSTUBLIBRARIES=
  if $(not $(equal $(cmodules), $(EMPTY)))
    CSTUBLIBRARIES= dll$(library_name).so lib$(library_name).a 
    export

  $(CMA) $(CMXA) $(CMXS) $(A) $(CSTUBLIBRARIES) : $(CSTUBS) $(CMO_S) $(CMX_S)
      if $(not $(equal $(cmodules), $(EMPTY)))
          ocamlmklib -verbose -o $(library_name) $(CSTUBS) $(linkopts) $(CMO_S) $(CMX_S)
          $(OCamlOpt) -shared -o $(CMXS) $(CMX_S) # CR jfuruse: right?
      else
          $(OCamlC) -a -o $(CMA) $(CMO_S)
          $(OCamlOpt) -a -o $(CMXA) $(CMX_S)
          $(OCamlOpt) -shared -o $(CMXS) $(CMX_S)

  ## the followings are necessary for packing

  OCAMLPACKAGEFLAGS += -for-pack $(capitalize $(library_name))

  ## build rule

  .DEFAULT: $(FixedOCamlPackage $(library_name), $(files))

  ## clean

  AutoClean()

  clean:
	rm -f $(CMT)

  ## install

  # CR jfuruse: x.cmi is required if x.mli does not exist!
  targets[]= META $(glob i, *.mli) $(CMI) $(CMO) $(CMX) $(CMA) $(CMXA) $(CMXS) $(CMT) $(O) $(A) $(CSTUBLIBRARIES) $(MyOCamlPackageExtras)

  if $(not $(defined NO_INSTALL))
    if $(defined INSTALLED)
      $(Installed $(findlib_name)): $(targets)
        $(OCAMLFIND) remove $(findlib_name)
        section:
              $(OCAMLFIND) install $(findlib_name) $(targets)
              CreateInstalled($(findlib_name), $(targets))

      install: $(Installed $(findlib_name))

      uninstall:
        rm -f $(Installed $(findlib_name))
        $(OCAMLFIND) remove $(findlib_name)
      export
    else
      install: $(targets)
        $(OCAMLFIND) remove $(findlib_name)
        $(OCAMLFIND) install $(findlib_name) $(targets)

      uninstall:
	$(OCAMLFIND) remove $(findlib_name)
      export
    export

############################################################## build ocaml exec

MyOCamlGenericProgram(name, files) =
  WithOCamlVeryClean()
  AddLocalOCamlPackageDependencies()
  export # The above thing is local: need to be exported

  # We must write these two separately, or something messy happens!
  $(name).run: $(Installed $(OMyManagedPackages $(OCAMLPACKS)))
  $(name).opt: $(Installed $(OMyManagedPackages $(OCAMLPACKS)))

  # CR jfuruse: forgot to add the deps over the packages!
  .DEFAULT: $(OCamlProgram $(name), $(files))

  # The following clean the files twice if MyOCamlPackge coexists,
  # but who cases ?
  AutoClean()

#| Add a rule to build a test program $(name)
#      name
#          Name of the program
#      files
#          OCaml module names (without .ml)
MyOCamlTestProgram(name, files) =
  # We need -linkall not to miss any module for test
  OCAML_LINK_FLAGS += -linkall
  MyOCamlGenericProgram($(name), $(files))

#| Add a rule to build a program $(name)
#      name
#          Name of the program
#      files
#          OCaml module names (without .ml)
#  In addition to MyOCamlTestProgram, the binary is installed by omake install
MyOCamlProgram(name, files) =
  WithOCamlVeryClean()
  MyOCamlGenericProgram($(name), $(files))
  export # The above thing is local: need to be exported # really?

  if $(not $(defined NO_INSTALL))
    install: $(name)$(EXE) $(name).run $(name).opt
      install $(name)$(EXE) $(name).run $(name).opt $(PREFIX)/bin
    uninstall:
      rm -f $(PREFIX)/bin/$(name)$(EXE) $(PREFIX)/bin/$(name).run $(PREFIX)/bin/$(name).opt
    export

MyOCamlApplication(name, files) =
  MyOCamlProgram($(name), $(files))

# This does not install exe
MyOCamlPPX(name, files) =
  export
  WithOCamlVeryClean()
  MyOCamlGenericProgram($(name), $(files))
  TARGETS[]=$(name).opt $(name).run $(name)$(EXE)
  value $(TARGETS)

# This does not install exe
MyOCamlPPXTargets(name) =
  return $(name).run $(name).opt $(name)$(EXE)

MyOCamlFindPackage(findlib_name, files) =
    AddLocalOCamlPackageDependencies()
    targets[]= META $(files)

    if $(defined INSTALLED)
      $(Installed $(findlib_name)): $(targets)
        $(OCAMLFIND) remove $(findlib_name)
        section:
              $(OCAMLFIND) install $(findlib_name) $(targets)
              CreateInstalled($(findlib_name), $(targets))

      install: $(Installed $(findlib_name))

      uninstall:
        rm -f $(Installed $(findlib_name))
        $(OCAMLFIND) remove $(findlib_name)
      export
    else
      install: $(targets)
        $(OCAMLFIND) remove $(findlib_name)
        $(OCAMLFIND) install $(findlib_name) $(targets)

      uninstall:
	$(OCAMLFIND) remove $(findlib_name)
      export
    export



#| Add a rule to build a toplevel $(name)
#      name
#          Name of the program
#      files
#          OCaml module names (without .ml)
OCamlTop(name, files) =
   # XXX: JYH: these variables should be marked private in 0.9.9
   protected.CMOFILES  = $(addsuffix .cmo, $(files))
   # protected.CMXFILES  = $(addsuffix .cmx, $(files))
   # protected.OFILES    = $(addsuffix $(EXT_OBJ), $(files))

   protected.CMAFILES  = $(addsuffix .cma,  $(OCAML_LIBS))
   # protected.CMXAFILES = $(addsuffix .cmxa, $(OCAML_LIBS))
   protected.ARFILES   = $(addsuffix $(EXT_LIB), $(OCAML_LIBS))
   protected.CMA_OTHER_FILES = $(addsuffix .cma, $(OCAML_OTHER_LIBS))
   # protected.CMXA_OTHER_FILES = $(addsuffix .cmxa, $(OCAML_OTHER_LIBS))

   protected.CLIBS = $(addsuffix $(EXT_LIB), $(OCAML_CLIBS))

   protected.name = $(file $(name))

   protected.PROG     = $(file $(name)$(EXE))
   protected.BYTEPROG = $(file $(name).run)
   # protected.OPTPROG  = $(file $(name).opt)

   #
   # Rules to build byte-code and native targets
   #
   $(BYTEPROG): $(CMAFILES) $(CMOFILES) $(CLIBS)
        $(OCAMLFIND) $(OCAMLMKTOP) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) $(OCAMLCFLAGS)\
                $(OCAMLWARNING_MAKE) \
                $(PREFIXED_OCAMLINCLUDES) $(OCAML_BYTE_LINK_FLAGS)\
                -o $@ $(CMA_OTHER_FILES) $(CMAFILES) $(OCamlLinkSort $(CMOFILES))\
                $(CLIBS) $(OCAML_LINK_FLAGS)

   $(PROG): $(BYTEPROG)
        ln-or-cp $< $@

   return $(array $(PROG), $(BYTEPROG))

MyOCamlTop(name, files) =
  WithOCamlVeryClean()
  AddLocalOCamlPackageDependencies()
  export # The above thing is local: need to be exported

  $(name): $(Installed $(OMyManagedPackages $(OCAMLPACKS)))

  # CR jfuruse: forgot to add the deps over the packages!
  .DEFAULT: $(OCamlTop $(name), $(files))

  # The following clean the files twice if MyOCamlPackge coexists,
  # but who cases ?
  AutoClean()
  export # The above thing is local: need to be exported

  if $(not $(defined NO_INSTALL))
    install: $(name) $(name).run
      install $(name) $(name).run $(PREFIX)/bin
    uninstall:
      rm -f $(PREFIX)/bin/$(name) $(PREFIX)/bin/$(name).run
    export

#|  Add rules to build OCaml library $(name)
#        name
#            Name of the library
#        files
#            OCaml module name (without .ml)
#
#   .. note :: Probably you should use MyOCamlPackage
MyOCamlLibrary(library_name, files) =
  WithOCamlVeryClean()
  AddLocalOCamlPackageDependencies()
  protected.CMIFILES = $(addsuffix .cmi, $(files))
  protected.CMXFILES = $(addsuffix .cmx, $(files))
  targets = $(OCamlLibrary $(library_name), $(files)) $(CMIFILES) $(CMXFILES) $(glob i, *.mli) 

  if $(not $(defined PACKAGE_NAME))
    findlib_name=$(lowercase $(library_name))
    export
  else
    findlib_name=$(PACKAGE_NAME)
    export

  if $(not $(defined MyOCamlPackageExtras))
    MyOCamlPackageExtras[]=
    export

  .DEFAULT: $(targets)

  export # The above thing is local: need to be exported

  if $(not $(defined NO_INSTALL))
    targets[] += META $(MyOCamlPackageExtras)
    cmts =  $(addsuffix .cmt,  $(removesuffix $(glob i, *.cmo)))
    cmts += $(addsuffix .cmti, $(removesuffix $(glob i, *.mli)))
    if $(defined INSTALLED)
      $(Installed $(findlib_name)): $(targets) $(MyOCamlPackageExtras)
        $(OCAMLFIND) remove $(findlib_name)
        section:
              $(OCAMLFIND) install $(findlib_name) $(targets) $(cmts)
              CreateInstalled($(findlib_name), $(targets))

      install: $(Installed $(findlib_name))

      uninstall:
        rm -f $(Installed $(findlib_name))
        $(OCAMLFIND) remove $(findlib_name)
      export
    else
      install: $(targets)
        $(OCAMLFIND) remove $(findlib_name)
        $(OCAMLFIND) install $(findlib_name) $(targets) $(cmts)

      uninstall:
	$(OCAMLFIND) remove $(findlib_name)
      export
    export

  # The following clean the files twice if MyOCamlPacakge coexists,
  # but who cases ?
  AutoClean()

# Auto clean
# ====================================================================

#| Install clean command which cleans all the target files exists under the directory. Use with care.
AutoClean()=
    .PHONY: clean
    clean:
        rm -f $(filter-proper-targets $(ls R, .))

# Subdir traversal
# =====================================================================

#| Recursively traverse the subdirs except $(dirs)
Subdirs_except(dirs) =
  # println(PWD: $(shell pwd))

  # need to export since .SUBDIRS is evaluated in the global scope
  export VISIT_SUBDIRS

  sub_omakefiles = $(glob i, */OMakefile)
  subdirs = $(sub_omakefiles.map $(dirname))

  VISIT_SUBDIRS=$(set-diff $(subdirs), $(dirs))

  # The rule
  .SUBDIRS: $(VISIT_SUBDIRS)

#| Recursively traverse all the subdirs
Subdirs() =
  Subdirs_except($(array))

#| Recursively traverse the given subdirs $(dirs)
Subdirs_only(dirs) =
 .SUBDIRS: $(dirs)

# Dependency dot files for Graphviz
# ======================================================================

#| Add a rule for ``depend.dot`` for a dependency graph of OCaml files in the current directory
Dot() =
	depend.dot: $(ls *.ml *.mli)
	    $(OCAMLFIND) ocamldoc -I +threads $(OCAMLPACKAGEFLAGS) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLPPFLAGS) $(PREFIXED_OCAMLINCLUDES) -dot -dot-include-all -dot-reduce $+ -o $@


# Build .merlin file
# ======================================================================

WithMerlin() =
  .merlin:
    section:
      chan=$(fopen $@, wb)
      fprintln($(chan), PKG $(string $(OCAMLPACKS)))
      foreach(x, $(OCAMLINCLUDES))
        fprintln($(chan), S $(x))
      fprintln($(chan), FLG $(OCAMLWARNING_MAKE))
      close($(chan))
  .DEFAULT: .merlin
  export

# Unused code
#
#  #| Obtain files installed as PACK
#  GET_OCAMLFIND_OBJS(pack)=
#      return $(Files $(OCAMLFIND_DESTDIR)/$(pack))