###########################################################################
#                              OCamlMakefile
#                  Copyright (C) 1999-2007  Markus Mottl
#
#                             For updates see:
#                http://www.ocaml.info/home/ocaml_sources.html
#
###########################################################################

# Modified by damien for .glade.ml compilation

# Set these variables to the names of the sources to be processed and
# the result variable. Order matters during linkage!

ifndef SOURCES
  SOURCES := foo.ml
endif
export SOURCES

ifndef RES_CLIB_SUF
  RES_CLIB_SUF := _stubs
endif
export RES_CLIB_SUF

ifndef RESULT
  RESULT := foo
endif
export RESULT := $(strip $(RESULT))

export LIB_PACK_NAME

ifndef DOC_FILES
  DOC_FILES := $(filter %.mli, $(SOURCES))
endif
export DOC_FILES
FIRST_DOC_FILE := $(firstword $(DOC_FILES))

export BCSUFFIX
export NCSUFFIX

ifndef TOPSUFFIX
  TOPSUFFIX := .top
endif
export TOPSUFFIX

# Eventually set include- and library-paths, libraries to link,
# additional compilation-, link- and ocamlyacc-flags
# Path- and library information needs not be written with "-I" and such...
# Define THREADS if you need it, otherwise leave it unset (same for
# USE_CAMLP4)!

export THREADS
export VMTHREADS
export ANNOTATE
export USE_CAMLP4

export INCDIRS
export LIBDIRS
export EXTLIBDIRS
export RESULTDEPS
export OCAML_DEFAULT_DIRS

export LIBS
export CLIBS
export CFRAMEWORKS

export OCAMLFLAGS
export OCAMLNCFLAGS
export OCAMLBCFLAGS

export OCAMLLDFLAGS
export OCAMLNLDFLAGS
export OCAMLBLDFLAGS

export OCAMLMKLIB_FLAGS

ifndef OCAMLCPFLAGS
  OCAMLCPFLAGS := a
endif
export OCAMLCPFLAGS

ifndef DOC_DIR
  DOC_DIR := doc
endif
export DOC_DIR

export PPFLAGS

export LFLAGS
export YFLAGS
export IDLFLAGS

export OCAMLDOCFLAGS

export OCAMLFIND_INSTFLAGS

export DVIPSFLAGS

export STATIC

# Add a list of optional trash files that should be deleted by "make clean"
export TRASH

ECHO := echo

ifdef REALLY_QUIET
  export REALLY_QUIET
  ECHO := true
  LFLAGS := $(LFLAGS) -q
  YFLAGS := $(YFLAGS) -q
endif

####################  variables depending on your OCaml-installation

SYSTEM := $(shell ocamlc -config 2>/dev/null | grep system | sed 's/system: //')
    # This may be
    # - mingw
    # - win32
    # - cygwin
    # - some other string means Unix
    # - empty means ocamlc does not support -config

ifeq ($(SYSTEM),mingw)
  MINGW=1
endif
ifeq ($(SYSTEM),win32)
  MSVC=1
endif

ifdef MINGW
  export MINGW
  WIN32   := 1
  CFLAGS_WIN32 := -mno-cygwin
  # The default value 'cc' makes 'ocamlc -cc "cc"' raises the error 'The
  # NTVDM CPU has encountered an illegal instruction'.
  CC := gcc
  # The OCaml C header files use this flag:
  CFLAGS += -D__MINGW32__
endif
ifdef MSVC
  export MSVC
  WIN32   := 1
  ifndef STATIC
    CPPFLAGS_WIN32 := -DCAML_DLL
  endif
  CFLAGS_WIN32 += -nologo
  EXT_OBJ := obj
  EXT_LIB := lib
  ifeq ($(CC),gcc)
    # work around GNU Make default value
    ifdef THREADS
      CC := cl -MT
    else
      CC := cl
    endif
  endif
  ifeq ($(CXX),g++)
    # work around GNU Make default value
    CXX := $(CC)
  endif
  CFLAG_O := -Fo
endif
ifdef WIN32
  EXT_CXX := cpp
  EXE     := .exe
endif

ifndef EXT_OBJ
  EXT_OBJ := o
endif
ifndef EXT_LIB
  EXT_LIB := a
endif
ifndef EXT_CXX
  EXT_CXX := cc
endif
ifndef EXE
  EXE := # empty
endif
ifndef CFLAG_O
  CFLAG_O := -o # do not delete this comment (preserves trailing whitespace)!
endif

export CC
export CXX
export CFLAGS
export CXXFLAGS
export LDFLAGS
export CPPFLAGS

ifndef RPATH_FLAG
  ifdef ELF_RPATH_FLAG
    RPATH_FLAG := $(ELF_RPATH_FLAG)
  else
    RPATH_FLAG := -R
  endif
endif
export RPATH_FLAG

ifndef MSVC
ifndef PIC_CFLAGS
  PIC_CFLAGS := -fPIC
endif
ifndef PIC_CPPFLAGS
  PIC_CPPFLAGS := -DPIC
endif
endif

export PIC_CFLAGS
export PIC_CPPFLAGS

BCRESULT  := $(addsuffix $(BCSUFFIX), $(RESULT))
NCRESULT  := $(addsuffix $(NCSUFFIX), $(RESULT))
TOPRESULT := $(addsuffix $(TOPSUFFIX), $(RESULT))

ifndef OCAMLFIND
  OCAMLFIND := ocamlfind
endif
export OCAMLFIND

ifndef OCAMLC
  OCAMLC := ocamlc
endif
export OCAMLC

ifndef OCAMLOPT
  OCAMLOPT := ocamlopt
endif
export OCAMLOPT

ifndef OCAMLMKTOP
  OCAMLMKTOP := ocamlmktop
endif
export OCAMLMKTOP

ifndef OCAMLCP
  OCAMLCP := ocamlcp
endif
export OCAMLCP

ifndef OCAMLDEP
  OCAMLDEP := ocamldep
endif
export OCAMLDEP

ifndef OCAMLLEX
  OCAMLLEX := ocamllex
endif
export OCAMLLEX

ifndef OCAMLYACC
  OCAMLYACC := ocamlyacc
endif
export OCAMLYACC

ifndef OCAMLMKLIB
  OCAMLMKLIB := ocamlmklib
endif
export OCAMLMKLIB

ifndef OCAML_GLADECC
  OCAML_GLADECC := lablgladecc2
endif
export OCAML_GLADECC

ifndef OCAML_GLADECC_FLAGS
  OCAML_GLADECC_FLAGS :=
endif
export OCAML_GLADECC_FLAGS

ifndef CAMELEON_REPORT
  CAMELEON_REPORT := report
endif
export CAMELEON_REPORT

ifndef CAMELEON_REPORT_FLAGS
  CAMELEON_REPORT_FLAGS :=
endif
export CAMELEON_REPORT_FLAGS

ifndef CAMELEON_ZOGGY
  CAMELEON_ZOGGY := camlp4o pa_zog.cma pr_o.cmo
endif
export CAMELEON_ZOGGY

ifndef CAMELEON_ZOGGY_FLAGS
  CAMELEON_ZOGGY_FLAGS :=
endif
export CAMELEON_ZOGGY_FLAGS

ifndef OXRIDL
  OXRIDL := oxridl
endif
export OXRIDL

ifndef CAMLIDL
  CAMLIDL := camlidl
endif
export CAMLIDL

ifndef CAMLIDLDLL
  CAMLIDLDLL := camlidldll
endif
export CAMLIDLDLL

ifndef NOIDLHEADER
  MAYBE_IDL_HEADER := -header
endif
export NOIDLHEADER

export NO_CUSTOM

ifndef CAMLP4
  CAMLP4 := camlp4
endif
export CAMLP4

ifndef REAL_OCAMLFIND
  ifdef PACKS
    ifndef CREATE_LIB
      ifdef THREADS
	PACKS += threads
      endif
    endif
    empty :=
    space := $(empty) $(empty)
    comma := ,
    ifdef PREDS
      PRE_OCAML_FIND_PREDICATES := $(subst $(space),$(comma),$(PREDS))
      PRE_OCAML_FIND_PACKAGES := $(subst $(space),$(comma),$(PACKS))
      OCAML_FIND_PREDICATES := -predicates $(PRE_OCAML_FIND_PREDICATES)
  #    OCAML_DEP_PREDICATES := -syntax $(PRE_OCAML_FIND_PREDICATES)
      OCAML_FIND_PACKAGES := $(OCAML_FIND_PREDICATES) -package $(PRE_OCAML_FIND_PACKAGES)
      OCAML_DEP_PACKAGES := $(OCAML_DEP_PREDICATES) -package $(PRE_OCAML_FIND_PACKAGES)
    else
      OCAML_FIND_PACKAGES := -package $(subst $(space),$(comma),$(PACKS))
      OCAML_DEP_PACKAGES :=
    endif
    OCAML_FIND_LINKPKG := -linkpkg
    REAL_OCAMLFIND := $(OCAMLFIND)
  endif
endif

export OCAML_FIND_PACKAGES
export OCAML_DEP_PACKAGES
export OCAML_FIND_LINKPKG
export REAL_OCAMLFIND

ifndef OCAMLDOC
  OCAMLDOC := ocamldoc
endif
export OCAMLDOC

ifndef LATEX
  LATEX := latex
endif
export LATEX

ifndef DVIPS
  DVIPS := dvips
endif
export DVIPS

ifndef PS2PDF
  PS2PDF := ps2pdf
endif
export PS2PDF

ifndef OCAMLMAKEFILE
  OCAMLMAKEFILE := OCamlMakefile
endif
export OCAMLMAKEFILE

ifndef OCAMLLIBPATH
  OCAMLLIBPATH := \
    $(shell $(OCAMLC) 2>/dev/null -where || echo /usr/lib/ocaml)
endif
export OCAMLLIBPATH

ifndef OCAML_LIB_INSTALL
  OCAML_LIB_INSTALL := $(OCAMLLIBPATH)/contrib
endif
export OCAML_LIB_INSTALL

###########################################################################

####################  change following sections only if
####################    you know what you are doing!

# delete target files when a build command fails
.PHONY: .DELETE_ON_ERROR
.DELETE_ON_ERROR:

# for pedants using "--warn-undefined-variables"
export MAYBE_IDL
export REAL_RESULT
export CAMLIDLFLAGS
export THREAD_FLAG
export RES_CLIB
export MAKEDLL
export ANNOT_FLAG
export C_OXRIDL
export SUBPROJS
export CFLAGS_WIN32
export CPPFLAGS_WIN32

INCFLAGS :=

SHELL := /bin/sh

MLDEPDIR := ._d
BCDIDIR  := ._bcdi
NCDIDIR  := ._ncdi

FILTER_EXTNS := %.mli %.ml %.mll %.mly %.idl %.oxridl %.c %.m %.$(EXT_CXX) %.rep %.zog %.glade

FILTERED     := $(filter $(FILTER_EXTNS), $(SOURCES))
SOURCE_DIRS  := $(filter-out ./, $(sort $(dir $(FILTERED))))

FILTERED_REP := $(filter %.rep, $(FILTERED))
DEP_REP      := $(FILTERED_REP:%.rep=$(MLDEPDIR)/%.d)
AUTO_REP     := $(FILTERED_REP:.rep=.ml)

FILTERED_ZOG := $(filter %.zog, $(FILTERED))
DEP_ZOG      := $(FILTERED_ZOG:%.zog=$(MLDEPDIR)/%.d)
AUTO_ZOG     := $(FILTERED_ZOG:.zog=.ml)

FILTERED_GLADE := $(filter %.glade, $(FILTERED))
DEP_GLADE      := $(FILTERED_GLADE:%.glade=$(MLDEPDIR)/%.d)
AUTO_GLADE     := $(FILTERED_GLADE:.glade=.ml)

FILTERED_ML  := $(filter %.ml, $(FILTERED))
DEP_ML       := $(FILTERED_ML:%.ml=$(MLDEPDIR)/%.d)

FILTERED_MLI := $(filter %.mli, $(FILTERED))
DEP_MLI      := $(FILTERED_MLI:.mli=.di)

FILTERED_MLL := $(filter %.mll, $(FILTERED))
DEP_MLL      := $(FILTERED_MLL:%.mll=$(MLDEPDIR)/%.d)
AUTO_MLL     := $(FILTERED_MLL:.mll=.ml)

FILTERED_MLY := $(filter %.mly, $(FILTERED))
DEP_MLY      := $(FILTERED_MLY:%.mly=$(MLDEPDIR)/%.d) $(FILTERED_MLY:.mly=.di)
AUTO_MLY     := $(FILTERED_MLY:.mly=.mli) $(FILTERED_MLY:.mly=.ml)

FILTERED_IDL := $(filter %.idl, $(FILTERED))
DEP_IDL      := $(FILTERED_IDL:%.idl=$(MLDEPDIR)/%.d) $(FILTERED_IDL:.idl=.di)
C_IDL        := $(FILTERED_IDL:%.idl=%_stubs.c)
ifndef NOIDLHEADER
 C_IDL += $(FILTERED_IDL:.idl=.h)
endif
OBJ_C_IDL    := $(FILTERED_IDL:%.idl=%_stubs.$(EXT_OBJ))
AUTO_IDL     := $(FILTERED_IDL:.idl=.mli) $(FILTERED_IDL:.idl=.ml) $(C_IDL)

FILTERED_OXRIDL := $(filter %.oxridl, $(FILTERED))
DEP_OXRIDL      := $(FILTERED_OXRIDL:%.oxridl=$(MLDEPDIR)/%.d) $(FILTERED_OXRIDL:.oxridl=.di)
AUTO_OXRIDL     := $(FILTERED_OXRIDL:.oxridl=.mli) $(FILTERED_OXRIDL:.oxridl=.ml) $(C_OXRIDL)

FILTERED_C_CXX := $(filter %.c %.m %.$(EXT_CXX), $(FILTERED))
OBJ_C_CXX      := $(FILTERED_C_CXX:.c=.$(EXT_OBJ))
OBJ_C_CXX      := $(OBJ_C_CXX:.m=.$(EXT_OBJ))
OBJ_C_CXX      := $(OBJ_C_CXX:.$(EXT_CXX)=.$(EXT_OBJ))

PRE_TARGETS  += $(AUTO_MLL) $(AUTO_MLY) $(AUTO_IDL) $(AUTO_OXRIDL) $(AUTO_ZOG) $(AUTO_REP) $(AUTO_GLADE)

ALL_DEPS     := $(DEP_ML) $(DEP_MLI) $(DEP_MLL) $(DEP_MLY) $(DEP_IDL) $(DEP_OXRIDL) $(DEP_ZOG) $(DEP_REP) $(DEP_GLADE)

MLDEPS       := $(filter %.d, $(ALL_DEPS))
MLIDEPS      := $(filter %.di, $(ALL_DEPS))
BCDEPIS      := $(MLIDEPS:%.di=$(BCDIDIR)/%.di)
NCDEPIS      := $(MLIDEPS:%.di=$(NCDIDIR)/%.di)

ALLML        := $(filter %.mli %.ml %.mll %.mly %.idl %.oxridl %.rep %.zog %.glade, $(FILTERED))

IMPLO_INTF   := $(ALLML:%.mli=%.mli.__)
IMPLO_INTF   := $(foreach file, $(IMPLO_INTF), \
                  $(basename $(file)).cmi $(basename $(file)).cmo)
IMPLO_INTF   := $(filter-out %.mli.cmo, $(IMPLO_INTF))
IMPLO_INTF   := $(IMPLO_INTF:%.mli.cmi=%.cmi)

IMPLX_INTF   := $(IMPLO_INTF:.cmo=.cmx)

INTF         := $(filter %.cmi, $(IMPLO_INTF))
IMPL_CMO     := $(filter %.cmo, $(IMPLO_INTF))
IMPL_CMX     := $(IMPL_CMO:.cmo=.cmx)
IMPL_ASM     := $(IMPL_CMO:.cmo=.asm)
IMPL_S       := $(IMPL_CMO:.cmo=.s)

OBJ_LINK     := $(OBJ_C_IDL) $(OBJ_C_CXX)
OBJ_FILES    := $(IMPL_CMO:.cmo=.$(EXT_OBJ)) $(OBJ_LINK)

EXECS        := $(addsuffix $(EXE), \
                            $(sort $(TOPRESULT) $(BCRESULT) $(NCRESULT)))
ifdef WIN32
  EXECS      += $(BCRESULT).dll $(NCRESULT).dll
endif

CLIB_BASE    := $(RESULT)$(RES_CLIB_SUF)
ifneq ($(strip $(OBJ_LINK)),)
  RES_CLIB     := lib$(CLIB_BASE).$(EXT_LIB)
endif

ifdef WIN32
DLLSONAME := $(CLIB_BASE).dll
else
DLLSONAME := dll$(CLIB_BASE).so
endif

NONEXECS     := $(INTF) $(IMPL_CMO) $(IMPL_CMX) $(IMPL_ASM) $(IMPL_S) \
		$(OBJ_FILES) $(PRE_TARGETS) $(BCRESULT).cma $(NCRESULT).cmxa \
		$(NCRESULT).$(EXT_LIB) $(BCRESULT).cmi $(BCRESULT).cmo \
		$(NCRESULT).cmi $(NCRESULT).cmx $(NCRESULT).o \
		$(RES_CLIB) $(IMPL_CMO:.cmo=.annot) \
		$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmo $(LIB_PACK_NAME).cmx $(LIB_PACK_NAME).o

ifndef STATIC
  NONEXECS += $(DLLSONAME)
endif

ifndef LIBINSTALL_FILES
  LIBINSTALL_FILES := $(RESULT).mli $(RESULT).cmi $(RESULT).cma \
		      $(RESULT).cmxa $(RESULT).$(EXT_LIB) $(RES_CLIB)
  ifndef STATIC
    ifneq ($(strip $(OBJ_LINK)),)
      LIBINSTALL_FILES += $(DLLSONAME)
    endif
  endif
endif

export LIBINSTALL_FILES

ifdef WIN32
  # some extra stuff is created while linking DLLs
  NONEXECS   += $(BCRESULT).$(EXT_LIB) $(BCRESULT).exp $(NCRESULT).exp $(CLIB_BASE).exp $(CLIB_BASE).lib
endif

TARGETS      := $(EXECS) $(NONEXECS)

# If there are IDL-files
ifneq ($(strip $(FILTERED_IDL)),)
  MAYBE_IDL := -cclib -lcamlidl
endif

ifdef USE_CAMLP4
  CAMLP4PATH := \
    $(shell $(CAMLP4) -where 2>/dev/null || echo /usr/lib/camlp4)
  INCFLAGS := -I $(CAMLP4PATH)
  CINCFLAGS := -I$(CAMLP4PATH)
endif

DINCFLAGS := $(INCFLAGS) $(SOURCE_DIRS:%=-I %) $(OCAML_DEFAULT_DIRS:%=-I %)
INCFLAGS := $(DINCFLAGS) $(INCDIRS:%=-I %)
CINCFLAGS += $(SOURCE_DIRS:%=-I%) $(INCDIRS:%=-I%) $(OCAML_DEFAULT_DIRS:%=-I%)

ifndef MSVC
  CLIBFLAGS += $(SOURCE_DIRS:%=-L%) $(LIBDIRS:%=-L%) \
               $(EXTLIBDIRS:%=-L%) $(OCAML_DEFAULT_DIRS:%=-L%)

  ifeq ($(ELF_RPATH), yes)
    CLIBFLAGS += $(EXTLIBDIRS:%=-Wl,$(RPATH_FLAG)%)
  endif
endif

ifndef PROFILING
  INTF_OCAMLC := $(OCAMLC)
else
  ifndef THREADS
    INTF_OCAMLC := $(OCAMLCP) -p $(OCAMLCPFLAGS)
  else
    # OCaml does not support profiling byte code
    # with threads (yet), therefore we force an error.
    ifndef REAL_OCAMLC
      $(error Profiling of multithreaded byte code not yet supported by OCaml)
    endif
    INTF_OCAMLC := $(OCAMLC)
  endif
endif

ifndef MSVC
  COMMON_LDFLAGS := $(LDFLAGS:%=-ccopt %) $(SOURCE_DIRS:%=-ccopt -L%) \
		    $(LIBDIRS:%=-ccopt -L%) $(EXTLIBDIRS:%=-ccopt -L%) \
		    $(EXTLIBDIRS:%=-ccopt -Wl $(OCAML_DEFAULT_DIRS:%=-ccopt -L%))

  ifeq ($(ELF_RPATH),yes)
    COMMON_LDFLAGS += $(EXTLIBDIRS:%=-ccopt -Wl,$(RPATH_FLAG)%)
  endif
else
  COMMON_LDFLAGS := -ccopt "/link -NODEFAULTLIB:LIBC $(LDFLAGS:%=%) $(SOURCE_DIRS:%=-LIBPATH:%) \
		    $(LIBDIRS:%=-LIBPATH:%) $(EXTLIBDIRS:%=-LIBPATH:%) \
		    $(OCAML_DEFAULT_DIRS:%=-LIBPATH:%) "
endif

CLIBS_OPTS := $(CLIBS:%=-cclib -l%) $(CFRAMEWORKS:%=-cclib '-framework %')
ifdef MSVC
  ifndef STATIC
  # MSVC libraries do not have 'lib' prefix
  CLIBS_OPTS := $(CLIBS:%=-cclib %.lib)
  endif
endif

ifneq ($(strip $(OBJ_LINK)),)
  ifdef CREATE_LIB
    OBJS_LIBS := -cclib -l$(CLIB_BASE) $(CLIBS_OPTS) $(MAYBE_IDL)
  else
    OBJS_LIBS := $(OBJ_LINK) $(CLIBS_OPTS) $(MAYBE_IDL)
  endif
else
  OBJS_LIBS := $(CLIBS_OPTS) $(MAYBE_IDL)
endif

ifdef LIB_PACK_NAME
  FOR_PACK_NAME := $(shell echo $(LIB_PACK_NAME) | awk '{print toupper(substr($$0,1,1))substr($$0,2)}')
endif

# If we have to make byte-code
ifndef REAL_OCAMLC
  BYTE_OCAML := y

  # EXTRADEPS is added dependencies we have to insert for all
  # executable files we generate.  Ideally it should be all of the
  # libraries we use, but it's hard to find the ones that get searched on
  # the path since I don't know the paths built into the compiler, so
  # just include the ones with slashes in their names.
  EXTRADEPS := $(addsuffix .cma,$(foreach i,$(LIBS),$(if $(findstring /,$(i)),$(i))))


  ifndef LIB_PACK_NAME
    SPECIAL_OCAMLFLAGS := $(OCAMLBCFLAGS)
  else	
    SPECIAL_OCAMLFLAGS := -for-pack $(FOR_PACK_NAME) $(OCAMLBCFLAGS)
  endif

  REAL_OCAMLC := $(INTF_OCAMLC)

  REAL_IMPL := $(IMPL_CMO)
  REAL_IMPL_INTF := $(IMPLO_INTF)
  IMPL_SUF := .cmo

  DEPFLAGS  :=
  MAKE_DEPS := $(MLDEPS) $(BCDEPIS)

  ifdef CREATE_LIB
    override CFLAGS := $(PIC_CFLAGS) $(CFLAGS)
    override CPPFLAGS := $(PIC_CPPFLAGS) $(CPPFLAGS)
    ifndef STATIC
      ifneq ($(strip $(OBJ_LINK)),)
	MAKEDLL := $(DLLSONAME)
	ALL_LDFLAGS := -dllib $(DLLSONAME)
      endif
    endif
  endif

  ifndef NO_CUSTOM
    ifneq "$(strip $(OBJ_LINK) $(THREADS) $(MAYBE_IDL) $(CLIBS) $(CFRAMEWORKS))" ""
      ALL_LDFLAGS += -custom
    endif
  endif

  ALL_LDFLAGS += $(INCFLAGS) $(OCAMLLDFLAGS) $(OCAMLBLDFLAGS) \
                 $(COMMON_LDFLAGS) $(LIBS:%=%.cma)
  CAMLIDLDLLFLAGS :=

  ifdef THREADS
    ifdef VMTHREADS
      THREAD_FLAG := -vmthread
    else
      THREAD_FLAG := -thread
    endif
    ALL_LDFLAGS := $(THREAD_FLAG) $(ALL_LDFLAGS)
    ifndef CREATE_LIB
      ifndef REAL_OCAMLFIND
        ALL_LDFLAGS := unix.cma threads.cma $(ALL_LDFLAGS)
      endif
    endif
  endif

# we have to make native-code
else
  EXTRADEPS := $(addsuffix .cmxa,$(foreach i,$(LIBS),$(if $(findstring /,$(i)),$(i))))
  ifndef PROFILING
    SPECIAL_OCAMLFLAGS := $(OCAMLNCFLAGS)
    PLDFLAGS :=
  else
    SPECIAL_OCAMLFLAGS := -p $(OCAMLNCFLAGS)
    PLDFLAGS := -p
  endif

  ifndef LIB_PACK_NAME
    SPECIAL_OCAMLFLAGS := $(OCAMLNCFLAGS)
  else	
    SPECIAL_OCAMLFLAGS := -for-pack $(FOR_PACK_NAME) $(OCAMLNCFLAGS)
  endif
  REAL_IMPL := $(IMPL_CMX)
  REAL_IMPL_INTF := $(IMPLX_INTF)
  IMPL_SUF := .cmx

  override CPPFLAGS := -DNATIVE_CODE $(CPPFLAGS)

  DEPFLAGS  := -native
  MAKE_DEPS := $(MLDEPS) $(NCDEPIS)

  ALL_LDFLAGS := $(PLDFLAGS) $(INCFLAGS) $(OCAMLLDFLAGS) \
                 $(OCAMLNLDFLAGS) $(COMMON_LDFLAGS)
  CAMLIDLDLLFLAGS := -opt

  ifndef CREATE_LIB
    ALL_LDFLAGS += $(LIBS:%=%.cmxa)
  else
    override CFLAGS := $(PIC_CFLAGS) $(CFLAGS)
    override CPPFLAGS := $(PIC_CPPFLAGS) $(CPPFLAGS)
  endif

  ifdef THREADS
    THREAD_FLAG := -thread
    ALL_LDFLAGS := $(THREAD_FLAG) $(ALL_LDFLAGS)
    ifndef CREATE_LIB
      ifndef REAL_OCAMLFIND
        ALL_LDFLAGS := unix.cmxa threads.cmxa $(ALL_LDFLAGS)
      endif
    endif
  endif
endif

export MAKE_DEPS

ifdef ANNOTATE
  ANNOT_FLAG := -dtypes
else
endif

ALL_OCAMLCFLAGS := $(THREAD_FLAG) $(ANNOT_FLAG) $(OCAMLFLAGS) \
                   $(INCFLAGS) $(SPECIAL_OCAMLFLAGS)

ifdef make_deps
  -include $(MAKE_DEPS)
  PRE_TARGETS :=
endif

###########################################################################
# USER RULES

# Call "OCamlMakefile QUIET=" to get rid of all of the @'s.
QUIET=@

# generates byte-code (default)
byte-code:		$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT) \
				REAL_RESULT="$(BCRESULT)" make_deps=yes
bc:	byte-code

byte-code-nolink:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
				REAL_RESULT="$(BCRESULT)" make_deps=yes
bcnl:	byte-code-nolink

top:			$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(TOPRESULT) \
				REAL_RESULT="$(BCRESULT)" make_deps=yes

# generates native-code

native-code:		$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(NCRESULT) \
				REAL_RESULT="$(NCRESULT)" \
				REAL_OCAMLC="$(OCAMLOPT)" \
				make_deps=yes
nc:	native-code

native-code-nolink:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
				REAL_RESULT="$(NCRESULT)" \
				REAL_OCAMLC="$(OCAMLOPT)" \
				make_deps=yes
ncnl:	native-code-nolink

# generates byte-code libraries
byte-code-library:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(BCRESULT).cma \
				REAL_RESULT="$(BCRESULT)" \
				CREATE_LIB=yes \
				make_deps=yes
bcl:	byte-code-library

# generates native-code libraries
native-code-library:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(NCRESULT).cmxa \
				REAL_RESULT="$(NCRESULT)" \
				REAL_OCAMLC="$(OCAMLOPT)" \
				CREATE_LIB=yes \
				make_deps=yes
ncl:	native-code-library

ifdef WIN32
# generates byte-code dll
byte-code-dll:		$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(BCRESULT).dll \
				REAL_RESULT="$(BCRESULT)" \
				make_deps=yes
bcd:	byte-code-dll

# generates native-code dll
native-code-dll:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(NCRESULT).dll \
				REAL_RESULT="$(NCRESULT)" \
				REAL_OCAMLC="$(OCAMLOPT)" \
				make_deps=yes
ncd:	native-code-dll
endif

# generates byte-code with debugging information
debug-code:		$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT) \
				REAL_RESULT="$(BCRESULT)" make_deps=yes \
				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
dc:	debug-code

debug-code-nolink:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
				REAL_RESULT="$(BCRESULT)" make_deps=yes \
				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
dcnl:	debug-code-nolink

# generates byte-code with debugging information (native code)
debug-native-code:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(NCRESULT) \
				REAL_RESULT="$(NCRESULT)" make_deps=yes \
				REAL_OCAMLC="$(OCAMLOPT)" \
				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
dnc:	debug-native-code

debug-native-code-nolink:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) nolink \
				REAL_RESULT="$(NCRESULT)" make_deps=yes \
				REAL_OCAMLC="$(OCAMLOPT)" \
				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
dncnl:	debug-native-code-nolink

# generates byte-code libraries with debugging information
debug-code-library:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(BCRESULT).cma \
				REAL_RESULT="$(BCRESULT)" make_deps=yes \
				CREATE_LIB=yes \
				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
dcl:	debug-code-library

# generates byte-code libraries with debugging information (native code)
debug-native-code-library:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(NCRESULT).cma \
				REAL_RESULT="$(NCRESULT)" make_deps=yes \
				REAL_OCAMLC="$(OCAMLOPT)" \
				CREATE_LIB=yes \
				OCAMLFLAGS="-g $(OCAMLFLAGS)" \
				OCAMLLDFLAGS="-g $(OCAMLLDFLAGS)"
dncl:	debug-native-code-library

# generates byte-code for profiling
profiling-byte-code:		$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT) \
				REAL_RESULT="$(BCRESULT)" PROFILING="y" \
				make_deps=yes
pbc:	profiling-byte-code

# generates native-code

profiling-native-code:		$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(NCRESULT) \
				REAL_RESULT="$(NCRESULT)" \
				REAL_OCAMLC="$(OCAMLOPT)" \
				PROFILING="y" \
				make_deps=yes
pnc:	profiling-native-code

# generates byte-code libraries
profiling-byte-code-library:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(BCRESULT).cma \
				REAL_RESULT="$(BCRESULT)" PROFILING="y" \
				CREATE_LIB=yes \
				make_deps=yes
pbcl:	profiling-byte-code-library

# generates native-code libraries
profiling-native-code-library:	$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(RES_CLIB) $(NCRESULT).cmxa \
				REAL_RESULT="$(NCRESULT)" PROFILING="y" \
				REAL_OCAMLC="$(OCAMLOPT)" \
				CREATE_LIB=yes \
				make_deps=yes
pncl:	profiling-native-code-library

# packs byte-code objects
pack-byte-code:			$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) $(BCRESULT).cmo \
				REAL_RESULT="$(BCRESULT)" \
				PACK_LIB=yes make_deps=yes
pabc:	pack-byte-code

# packs native-code objects
pack-native-code:		$(PRE_TARGETS)
			$(QUIET)$(MAKE) -r -f $(OCAMLMAKEFILE) \
				$(NCRESULT).cmx $(NCRESULT).o \
				REAL_RESULT="$(NCRESULT)" \
				REAL_OCAMLC="$(OCAMLOPT)" \
				PACK_LIB=yes make_deps=yes
panc:	pack-native-code

# generates HTML-documentation
htdoc:	$(DOC_DIR)/$(RESULT)/html/index.html

# generates Latex-documentation
ladoc:	$(DOC_DIR)/$(RESULT)/latex/doc.tex

# generates PostScript-documentation
psdoc:	$(DOC_DIR)/$(RESULT)/latex/doc.ps

# generates PDF-documentation
pdfdoc:	$(DOC_DIR)/$(RESULT)/latex/doc.pdf

# generates all supported forms of documentation
doc: htdoc ladoc psdoc pdfdoc

###########################################################################
# LOW LEVEL RULES

$(REAL_RESULT):		$(REAL_IMPL_INTF) $(OBJ_LINK) $(EXTRADEPS) $(RESULTDEPS)
			$(REAL_OCAMLFIND) $(REAL_OCAMLC) \
				$(OCAML_FIND_PACKAGES) $(OCAML_FIND_LINKPKG) \
				$(ALL_LDFLAGS) $(OBJS_LIBS) -o $@$(EXE) \
				$(REAL_IMPL)

nolink:			$(REAL_IMPL_INTF) $(OBJ_LINK)

ifdef WIN32
$(REAL_RESULT).dll:	$(REAL_IMPL_INTF) $(OBJ_LINK)
			$(CAMLIDLDLL) $(CAMLIDLDLLFLAGS) $(OBJ_LINK) $(CLIBS) \
				-o $@ $(REAL_IMPL)
endif

%$(TOPSUFFIX):		$(REAL_IMPL_INTF) $(OBJ_LINK) $(EXTRADEPS)
			$(REAL_OCAMLFIND) $(OCAMLMKTOP) \
				$(OCAML_FIND_PACKAGES) $(OCAML_FIND_LINKPKG) \
				$(ALL_LDFLAGS) $(OBJS_LIBS) -o $@$(EXE) \
				$(REAL_IMPL)

.SUFFIXES:		.mli .ml .cmi .cmo .cmx .cma .cmxa .$(EXT_OBJ) \
                        .mly .di .d .$(EXT_LIB) .idl %.oxridl .c .m .$(EXT_CXX) .h .so \
                        .rep .zog .glade

ifndef STATIC
ifdef MINGW
$(DLLSONAME):		$(OBJ_LINK)
			$(CC) $(CFLAGS) $(CFLAGS_WIN32) $(OBJ_LINK) -shared -o $@ \
			-Wl,--whole-archive $(wildcard $(foreach dir,$(LIBDIRS),$(CLIBS:%=$(dir)/lib%.a))) \
			 '$(OCAMLLIBPATH)/ocamlrun.a' \
			-Wl,--export-all-symbols \
			-Wl,--no-whole-archive \
			-Wl,--allow-multiple-definition \
			-Wl,--enable-auto-import
else
ifdef MSVC
$(DLLSONAME):		$(OBJ_LINK)
			link /NOLOGO /DLL /OUT:$@ $(OBJ_LINK) \
			 $(wildcard $(foreach dir,$(LIBDIRS),$(CLIBS:%=$(dir)/%.lib))) \
			 '$(OCAMLLIBPATH)/ocamlrun.lib'

else
$(DLLSONAME):		$(OBJ_LINK)
			$(OCAMLMKLIB) $(INCFLAGS) $(CLIBFLAGS) \
				-o $(CLIB_BASE) $(OBJ_LINK) $(CLIBS:%=-l%) $(CFRAMEWORKS:%=-framework %) \
				$(OCAMLMKLIB_FLAGS)
endif
endif
endif

ifndef LIB_PACK_NAME
$(RESULT).cma:		$(REAL_IMPL_INTF) $(MAKEDLL) $(EXTRADEPS) $(RESULTDEPS)
			$(REAL_OCAMLFIND) $(REAL_OCAMLC) -a $(ALL_LDFLAGS) $(OBJS_LIBS) -o $@ $(REAL_IMPL)

$(RESULT).cmxa $(RESULT).$(EXT_LIB):	$(REAL_IMPL_INTF) $(EXTRADEPS) $(RESULTDEPS)
			$(REAL_OCAMLFIND) $(OCAMLOPT) -a $(ALL_LDFLAGS) $(OBJS_LIBS) -o $@ $(REAL_IMPL)
else
# Packing a bytecode library
ifdef BYTE_OCAML
$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmo: $(REAL_IMPL_INTF)
			$(REAL_OCAMLFIND) $(REAL_OCAMLC) -pack -o $(LIB_PACK_NAME).cmo $(OCAMLLDFLAGS) $(REAL_IMPL)
# Packing into a unit which can be transformed into a library
# Remember the .ml's must have been compiled with -for-pack $(LIB_PACK_NAME)
else
$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmx: $(REAL_IMPL_INTF)
			$(REAL_OCAMLFIND) $(OCAMLOPT) -pack -o $(LIB_PACK_NAME).cmx  $(OCAMLLDFLAGS) $(REAL_IMPL)
endif

$(RESULT).cma:		$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmo $(MAKEDLL) $(EXTRADEPS) $(RESULTDEPS)
			$(REAL_OCAMLFIND) $(REAL_OCAMLC) -a $(ALL_LDFLAGS) $(OBJS_LIBS) -o $@ $(LIB_PACK_NAME).cmo

$(RESULT).cmxa $(RESULT).$(EXT_LIB):	$(LIB_PACK_NAME).cmi $(LIB_PACK_NAME).cmx $(EXTRADEPS) $(RESULTDEPS)
			$(REAL_OCAMLFIND) $(OCAMLOPT) -a $(filter-out -custom, $(ALL_LDFLAGS)) $(OBJS_LIBS) -o $@ $(LIB_PACK_NAME).cmx
endif

$(RES_CLIB): 		$(OBJ_LINK)
ifndef MSVC
  ifneq ($(strip $(OBJ_LINK)),)
		      $(AR) rcs $@ $(OBJ_LINK)
  endif
else
  ifneq ($(strip $(OBJ_LINK)),)
			lib -nologo -debugtype:cv -out:$(RES_CLIB) $(OBJ_LINK)
  endif
endif

.mli.cmi: $(EXTRADEPS)
			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
			if [ -z "$$pp" ]; then \
			  $(ECHO) $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c $(THREAD_FLAG) $(ANNOT_FLAG) \
				$(OCAMLFLAGS) $(INCFLAGS) $<; \
			  $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c $(THREAD_FLAG) $(ANNOT_FLAG) \
				$(OCAMLFLAGS) $(INCFLAGS) $<; \
			else \
			    $(ECHO) $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c -pp \"$$pp $(PPFLAGS)\" $(THREAD_FLAG) $(ANNOT_FLAG) \
				$(OCAMLFLAGS) $(INCFLAGS) $<; \
			    $(REAL_OCAMLFIND) $(INTF_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c -pp "$$pp $(PPFLAGS)" $(THREAD_FLAG) $(ANNOT_FLAG) \
				$(OCAMLFLAGS) $(INCFLAGS) $<; \
			fi

.ml.cmi .ml.$(EXT_OBJ) .ml.cmx .ml.cmo: $(EXTRADEPS)
			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
			if [ -z "$$pp" ]; then \
			  $(ECHO) $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c $(ALL_OCAMLCFLAGS) $<; \
			  $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c $(ALL_OCAMLCFLAGS) $<; \
			else \
			  $(ECHO) $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c -pp \"$$pp $(PPFLAGS)\" $(ALL_OCAMLCFLAGS) $<; \
			  $(REAL_OCAMLFIND) $(REAL_OCAMLC) $(OCAML_FIND_PACKAGES) \
				-c -pp "$$pp $(PPFLAGS)" $(ALL_OCAMLCFLAGS) $<; \
			fi

.PRECIOUS:		%.ml
%.ml:			%.mll
			$(OCAMLLEX) $(LFLAGS) $<

.PRECIOUS:              %.ml %.mli
%.ml %.mli:             %.mly
			$(OCAMLYACC) $(YFLAGS) $<
			$(QUIET)pp=`sed -n -e 's/.*(\*pp \([^*]*\) \*).*/\1/p;q' $<`; \
			if [ ! -z "$$pp" ]; then \
			  mv $*.ml $*.ml.temporary; \
			  echo "(*pp $$pp $(PPFLAGS)*)" > $*.ml; \
			  cat $*.ml.temporary >> $*.ml; \
			  rm $*.ml.temporary; \
			  mv $*.mli $*.mli.temporary; \
			  echo "(*pp $$pp $(PPFLAGS)*)" > $*.mli; \
			  cat $*.mli.temporary >> $*.mli; \
			  rm $*.mli.temporary; \
			fi


.PRECIOUS:		%.ml
%.ml:			%.rep
			$(CAMELEON_REPORT) $(CAMELEON_REPORT_FLAGS) -gen $<

.PRECIOUS:		%.ml
%.ml:			%.zog
			$(CAMELEON_ZOGGY)  $(CAMELEON_ZOGGY_FLAGS) -impl $< > $@

.PRECIOUS:		%.ml
%.ml:			%.glade
			$(OCAML_GLADECC)  $(OCAML_GLADECC_FLAGS) $< > $@

.PRECIOUS:		%.ml %.mli
%.ml %.mli:		%.oxridl
			$(OXRIDL) $<

.PRECIOUS:		%.ml %.mli %_stubs.c %.h
%.ml %.mli %_stubs.c %.h:		%.idl
			$(CAMLIDL) $(MAYBE_IDL_HEADER) $(IDLFLAGS) \
				$(CAMLIDLFLAGS) $<
			$(QUIET)if [ $(NOIDLHEADER) ]; then touch $*.h; fi

.c.$(EXT_OBJ):
			$(OCAMLC) -c -cc "$(CC)" -ccopt "$(CFLAGS) \
				$(CPPFLAGS) $(CPPFLAGS_WIN32) \
				$(CFLAGS_WIN32) $(CINCFLAGS) $(CFLAG_O)$@ " $<

.m.$(EXT_OBJ):
			$(CC) -c $(CFLAGS) $(CINCFLAGS) $(CPPFLAGS) \
				-I'$(OCAMLLIBPATH)' \
				$< $(CFLAG_O)$@

.$(EXT_CXX).$(EXT_OBJ):
			$(CXX) -c $(CXXFLAGS) $(CINCFLAGS) $(CPPFLAGS) \
				-I'$(OCAMLLIBPATH)' \
				$< $(CFLAG_O)$@

$(MLDEPDIR)/%.d:	%.ml
			$(QUIET)if [ ! -d $(@D) ]; then mkdir -p $(@D); fi
			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
			if [ -z "$$pp" ]; then \
			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
				$(DINCFLAGS) $< \> $@; \
			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
				$(DINCFLAGS) $< > $@; \
			else \
			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
				-pp \"$$pp $(PPFLAGS)\" $(DINCFLAGS) $< \> $@; \
			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(OCAML_DEP_PACKAGES) \
				-pp "$$pp $(PPFLAGS)" $(DINCFLAGS) $< > $@; \
			fi

$(BCDIDIR)/%.di $(NCDIDIR)/%.di:	%.mli
			$(QUIET)if [ ! -d $(@D) ]; then mkdir -p $(@D); fi
			$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $<`; \
			if [ -z "$$pp" ]; then \
			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) $(DINCFLAGS) $< \> $@; \
			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) $(DINCFLAGS) $< > $@; \
			else \
			  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) \
			    -pp \"$$pp $(PPFLAGS)\" $(DINCFLAGS) $< \> $@; \
			  $(REAL_OCAMLFIND) $(OCAMLDEP) $(DEPFLAGS) \
			    -pp "$$pp $(PPFLAGS)" $(DINCFLAGS) $< > $@; \
			fi

$(DOC_DIR)/$(RESULT)/html:
	mkdir -p $@

$(DOC_DIR)/$(RESULT)/html/index.html: $(DOC_DIR)/$(RESULT)/html $(DOC_FILES)
	rm -rf $</*
	$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $(FIRST_DOC_FILE)`; \
	if [ -z "$$pp" ]; then \
	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -html -d $< $(OCAMLDOCFLAGS) $(INCFLAGS) $(DOC_FILES); \
	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -html -d $< $(OCAMLDOCFLAGS) $(INCFLAGS) $(DOC_FILES); \
	else \
	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp \"$$pp $(PPFLAGS)\" -html -d $< $(OCAMLDOCFLAGS) \
	  	$(INCFLAGS) $(DOC_FILES); \
	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp "$$pp $(PPFLAGS)" -html -d $< $(OCAMLDOCFLAGS) \
	  	$(INCFLAGS) $(DOC_FILES); \
	fi

$(DOC_DIR)/$(RESULT)/latex:
	mkdir -p $@

$(DOC_DIR)/$(RESULT)/latex/doc.tex: $(DOC_DIR)/$(RESULT)/latex $(DOC_FILES)
	rm -rf $</*
	$(QUIET)pp=`sed -n -e '/^#/d' -e 's/(\*pp \([^*]*\) \*)/\1/p;q' $(FIRST_DOC_FILE)`; \
	if [ -z "$$pp" ]; then \
	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -latex $(OCAMLDOCFLAGS) $(INCFLAGS) \
	  	$(DOC_FILES) -o $@; \
	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -latex $(OCAMLDOCFLAGS) $(INCFLAGS) $(DOC_FILES) \
	  	-o $@; \
	else \
	  $(ECHO) $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp \"$$pp $(PPFLAGS)\" -latex $(OCAMLDOCFLAGS) \
	  	$(INCFLAGS) $(DOC_FILES) -o $@; \
	  $(REAL_OCAMLFIND) $(OCAMLDOC) $(OCAML_FIND_PACKAGES) -pp "$$pp $(PPFLAGS)" -latex $(OCAMLDOCFLAGS) \
	  	$(INCFLAGS) $(DOC_FILES) -o $@; \
	fi

$(DOC_DIR)/$(RESULT)/latex/doc.ps: $(DOC_DIR)/$(RESULT)/latex/doc.tex
	cd $(DOC_DIR)/$(RESULT)/latex && \
	  $(LATEX) doc.tex && \
	  $(LATEX) doc.tex && \
	  $(DVIPS) $(DVIPSFLAGS) doc.dvi -o $(@F)

$(DOC_DIR)/$(RESULT)/latex/doc.pdf: $(DOC_DIR)/$(RESULT)/latex/doc.ps
	cd $(DOC_DIR)/$(RESULT)/latex && $(PS2PDF) $(<F)

define make_subproj
.PHONY:
subproj_$(1):
	$$(eval $$(call PROJ_$(1)))
	$(QUIET)if [ "$(SUBTARGET)" != "all" ]; then \
	  $(MAKE) -f $(OCAMLMAKEFILE) $(SUBTARGET); \
	fi
endef

$(foreach subproj,$(SUBPROJS),$(eval $(call make_subproj,$(subproj))))

.PHONY:
subprojs: $(SUBPROJS:%=subproj_%)

###########################################################################
# (UN)INSTALL RULES FOR LIBRARIES

.PHONY: libinstall
libinstall:	all
	$(QUIET)printf "\nInstalling library with ocamlfind\n"
	$(OCAMLFIND) install $(OCAMLFIND_INSTFLAGS) $(RESULT) META $(LIBINSTALL_FILES)
	$(QUIET)printf "\nInstallation successful.\n"

.PHONY: libinstall-byte-code
libinstall-byte-code:	all
	$(QUIET)printf "\nInstalling byte-code library with ocamlfind\n"
	$(OCAMLFIND) install $(OCAMLFIND_INSTFLAGS) $(RESULT) META \
	  $(filter-out $(RESULT).$(EXT_LIB) $(RESULT).cmxa, $(LIBINSTALL_FILES))
	$(QUIET)printf "\nInstallation successful.\n"

.PHONY: libinstall-native-code
libinstall-native-code:	all
	$(QUIET)printf "\nInstalling native-code library with ocamlfind\n"
	$(OCAMLFIND) install $(OCAMLFIND_INSTFLAGS) $(RESULT) META \
	  $(filter-out $(DLLSONAME) $(RESULT).cma, $(LIBINSTALL_FILES))
	$(QUIET)printf "\nInstallation successful.\n"

.PHONY: libuninstall
libuninstall:
	$(QUIET)printf "\nUninstalling library with ocamlfind\n"
	$(OCAMLFIND) remove $(OCAMLFIND_INSTFLAGS) $(RESULT)
	$(QUIET)printf "\nUninstallation successful.\n"

.PHONY: rawinstall
rawinstall:	all
	$(QUIET)printf "\nInstalling library to: $(OCAML_LIB_INSTALL)\n"
	-install -d $(OCAML_LIB_INSTALL)
	for i in $(LIBINSTALL_FILES); do \
	  if [ -f $$i ]; then \
	    install -c -m 0644 $$i $(OCAML_LIB_INSTALL); \
	  fi; \
	done
	$(QUIET)printf "\nInstallation successful.\n"

.PHONY: rawuninstall
rawuninstall:
	$(QUIET)printf "\nUninstalling library from: $(OCAML_LIB_INSTALL)\n"
	cd $(OCAML_LIB_INSTALL) && rm $(notdir $(LIBINSTALL_FILES))
	$(QUIET)printf "\nUninstallation successful.\n"

###########################################################################
# MAINTENANCE RULES

.PHONY:	clean
clean::
	rm -f $(TARGETS) $(TRASH)
	rm -rf $(BCDIDIR) $(NCDIDIR) $(MLDEPDIR)

.PHONY:	cleanup
cleanup::
	rm -f $(NONEXECS) $(TRASH)
	rm -rf $(BCDIDIR) $(NCDIDIR) $(MLDEPDIR)

.PHONY: clean-doc
clean-doc::
	rm -rf $(DOC_DIR)/$(RESULT)

.PHONY: clean-all
clean-all:: clean clean-doc

.PHONY: nobackup
nobackup:
	rm -f *.bak *~ *.dup