Makefile.nt

#**************************************************************************
#*                                                                        *
#*                                 OCaml                                  *
#*                                                                        *
#*            Xavier Leroy, projet Cristal, INRIA Rocquencourt            *
#*                                                                        *
#*   Copyright 1999 Institut National de Recherche en Informatique et     *
#*     en Automatique.                                                    *
#*                                                                        *
#*   All rights reserved.  This file is distributed under the terms of    *
#*   the GNU Lesser General Public License version 2.1, with the          *
#*   special exception on linking described in the file LICENSE.          *
#*                                                                        *
#**************************************************************************

# The main Makefile

include Makefile.shared

# For users who don't read the INSTALL file
defaultentry:
	@echo "Please refer to the instructions in file README.win32.adoc."

FLEXDLL_SUBMODULE_PRESENT:=$(wildcard flexdll/Makefile)
ifeq "$(FLEXDLL_SUBMODULE_PRESENT)" ""
  BOOT_FLEXLINK_CMD=
else
  BOOT_FLEXLINK_CMD=FLEXLINK_CMD="../boot/ocamlrun ../flexdll/flexlink.exe"
  CAMLOPT:=OCAML_FLEXLINK="boot/ocamlrun flexdll/flexlink.exe" $(CAMLOPT)
endif

# FlexDLL sources missing error messages
# Different git mechanism displayed depending on whether this source tree came
# from a git clone or a source tarball.

flexdll/Makefile:
	@echo In order to bootstrap FlexDLL, you need to place the sources in
	@echo flexdll.
	@echo This can either be done by downloading a source tarball from
	@echo \  http://alain.frisch.fr/flexdll.html
	@if [ -d .git ]; then \
	  echo or by checking out the flexdll submodule with; \
	  echo \  git submodule update --init; \
	else \
	  echo or by cloning the git repository; \
	  echo \  git clone https://github.com/alainfrisch/flexdll.git; \
	fi
	@false

# Bootstrapping FlexDLL - leaves a bytecode image of flexlink.exe in flexdll/
flexdll: flexdll/Makefile
	cd byterun && $(MAKEREC) BOOTSTRAPPING_FLEXLINK=yes ocamlrun$(EXE)
	cp byterun/ocamlrun.exe boot/ocamlrun.exe
	cd stdlib && $(MAKEREC) COMPILER=../boot/ocamlc stdlib.cma std_exit.cmo
	cd stdlib && cp stdlib.cma std_exit.cmo *.cmi ../boot
	cd flexdll && \
	 $(MAKECMD) MSVC_DETECT=0 TOOLCHAIN=$(TOOLCHAIN) TOOLPREF=$(TOOLPREF) \
	            CHAINS=$(FLEXDLL_CHAIN) NATDYNLINK=false \
	            OCAMLOPT="../boot/ocamlrun ../boot/ocamlc -I ../boot" \
	            flexlink.exe support
	cd byterun && $(MAKEREC) clean
	$(MAKEREC) partialclean

flexlink.opt:
	cd flexdll && \
	mv flexlink.exe flexlink && \
	$(MAKECMD) OCAML_FLEXLINK="../boot/ocamlrun ./flexlink" MSVC_DETECT=0 \
	           TOOLCHAIN=$(TOOLCHAIN) TOOLPREF=$(TOOLPREF) \
	           OCAMLOPT="../ocamlopt.opt -I ../stdlib" flexlink.exe && \
	mv flexlink.exe flexlink.opt && \
	mv flexlink flexlink.exe

# Recompile the system using the bootstrap compiler
all: runtime ocamlc ocamllex ocamlyacc ocamltools library ocaml \
  otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC)

# The compilation of ocaml will fail if the runtime has changed.
# Never mind, just do make bootstrap to reach fixpoint again.

# Compile everything the first time
world: coldstart all

# Core bootstrapping cycle
coreboot:
# Save the original bootstrap compiler
	$(MAKEREC) backup
# Promote the new compiler but keep the old runtime
# This compiler runs on boot/ocamlrun and produces bytecode for
# byterun/ocamlrun
	$(MAKEREC) promote-cross
# Rebuild ocamlc and ocamllex (run on byterun/ocamlrun)
	$(MAKEREC) partialclean
	$(MAKEREC) ocamlc ocamllex ocamltools
# Rebuild the library (using byterun/ocamlrun ./ocamlc)
	$(MAKEREC) library-cross
# Promote the new compiler and the new runtime
	$(MAKEREC) promote
# Rebuild the core system
	$(MAKEREC) partialclean
	$(MAKEREC) core
# Check if fixpoint reached
	$(MAKEREC) compare

# Do a complete bootstrapping cycle
bootstrap:
	$(MAKEREC) coreboot
	$(MAKEREC) all
	$(MAKEREC) compare

LIBFILES=stdlib.cma std_exit.cmo *.cmi camlheader

# Start up the system from the distribution compiler
coldstart:
	cd byterun ; $(MAKEREC) $(BOOT_FLEXLINK_CMD) all
	cp byterun/ocamlrun.exe boot/ocamlrun.exe
	cd yacc ; $(MAKEREC) $(BOOT_FLEXLINK_CMD) all
	cp yacc/ocamlyacc.exe boot/ocamlyacc.exe
	cd stdlib ; \
	  $(MAKEREC) $(BOOT_FLEXLINK_CMD) \
	             COMPILER="../boot/ocamlc -use-prims ../byterun/primitives"\
	             all
	cd stdlib ; cp $(LIBFILES) ../boot

# Build the core system: the minimum needed to make depend and bootstrap
core: runtime ocamlc ocamllex ocamlyacc ocamltools library

# Save the current bootstrap compiler
MAXSAVED=boot/Saved/Saved.prev/Saved.prev/Saved.prev/Saved.prev/Saved.prev
backup:
	mkdir -p boot/Saved
	if test -d $(MAXSAVED); then rm -r $(MAXSAVED); fi
	mv boot/Saved boot/Saved.prev
	mkdir boot/Saved
	mv boot/Saved.prev boot/Saved/Saved.prev
	cp boot/ocamlrun.exe boot/Saved/ocamlrun.exe
	cd boot ; mv ocamlc ocamllex ocamldep ocamlyacc.exe Saved
	cd boot ; cp $(LIBFILES) Saved

# Promote the newly compiled system to the rank of cross compiler
# (Runs on the old runtime, produces code for the new runtime)
promote-cross:
	$(CAMLRUN) tools/stripdebug ocamlc boot/ocamlc
	$(CAMLRUN) tools/stripdebug lex/ocamllex boot/ocamllex
	cp yacc/ocamlyacc.exe boot/ocamlyacc.exe
	$(CAMLRUN) tools/stripdebug tools/ocamldep boot/ocamldep
	cd stdlib ; cp $(LIBFILES) ../boot

# Promote the newly compiled system to the rank of bootstrap compiler
# (Runs on the new runtime, produces code for the new runtime)
promote: promote-cross
	cp byterun/ocamlrun.exe boot/ocamlrun.exe

# Restore the saved bootstrap compiler if a problem arises
restore:
	cd boot/Saved ; mv * ..
	rmdir boot/Saved
	mv boot/Saved.prev boot/Saved

# Check if fixpoint reached
compare:
	@if $(CAMLRUN) tools/cmpbyt boot/ocamlc ocamlc \
         && $(CAMLRUN) tools/cmpbyt boot/ocamllex lex/ocamllex \
         && $(CAMLRUN) tools/cmpbyt boot/ocamldep tools/ocamldep; \
	then echo "Fixpoint reached, bootstrap succeeded."; \
	else echo "Fixpoint not reached, try one more bootstrapping cycle."; \
	fi

# Remove old bootstrap compilers
cleanboot:
	rm -rf boot/Saved/Saved.prev/*

# Compile the native-code compiler
opt-core:
	$(MAKEREC) runtimeopt
	$(MAKEREC) ocamlopt
	$(MAKEREC) libraryopt

opt:
	$(MAKEREC) opt-core
	$(MAKEREC) otherlibrariesopt ocamltoolsopt

# Native-code versions of the tools
# If the submodule is initialised, then opt.opt will build a native flexlink
opt.opt: core opt-core ocamlc.opt all ocamlopt.opt ocamllex.opt \
         ocamltoolsopt ocamltoolsopt.opt otherlibrariesopt $(OCAMLDOC_OPT) \
         $(if $(wildcard flexdll/Makefile),flexlink.opt)

# Complete build using fast compilers
world.opt: coldstart opt.opt

# Installation

COMPLIBDIR=$(LIBDIR)/compiler-libs

INSTALL_BINDIR=$(DESTDIR)$(BINDIR)
INSTALL_LIBDIR=$(DESTDIR)$(LIBDIR)
INSTALL_COMPLIBDIR=$(DESTDIR)$(COMPLIBDIR)
INSTALL_STUBLIBDIR=$(DESTDIR)$(STUBLIBDIR)
INSTALL_MANDIR=$(DESTDIR)$(MANDIR)
INSTALL_DISTRIB=$(DESTDIR)$(PREFIX)

install: installbyt installopt

installbyt:
	mkdir -p "$(INSTALL_BINDIR)"
	mkdir -p "$(INSTALL_LIBDIR)"
	mkdir -p "$(INSTALL_STUBLIBDIR)"
	mkdir -p "$(INSTALL_COMPLIBDIR)"
	cp VERSION "$(INSTALL_LIBDIR)/"
	cd byterun ; $(MAKEREC) install
	cp ocamlc "$(INSTALL_BINDIR)/ocamlc.exe"
	cp ocaml "$(INSTALL_BINDIR)/ocaml.exe"
	cp ocamlc "$(INSTALL_BINDIR)/ocamlc.byte.exe"
	cd stdlib ; $(MAKEREC) install
	cp lex/ocamllex "$(INSTALL_BINDIR)/ocamllex.exe"
	cp yacc/ocamlyacc.exe "$(INSTALL_BINDIR)/ocamlyacc.exe"
	cp lex/ocamllex "$(INSTALL_BINDIR)/ocamllex.byte.exe"
	cp utils/*.cmi utils/*.cmt utils/*.cmti \
	   parsing/*.cmi parsing/*.cmt parsing/*.cmti \
	   typing/*.cmi typing/*.cmt typing/*.cmti \
	   bytecomp/*.cmi bytecomp/*.cmt bytecomp/*.cmti \
	   driver/*.cmi driver/*.cmt driver/*.cmti \
	   toplevel/*.cmi toplevel/*.cmt toplevel/*.cmti "$(INSTALL_COMPLIBDIR)"
	cp compilerlibs/ocamlcommon.cma compilerlibs/ocamlbytecomp.cma \
	   compilerlibs/ocamltoplevel.cma $(BYTESTART) $(TOPLEVELSTART) \
	   "$(INSTALL_COMPLIBDIR)"
	cp expunge "$(INSTALL_LIBDIR)/expunge.exe"
	cp toplevel/topdirs.cmi "$(INSTALL_LIBDIR)"
	cd tools ; $(MAKEREC) install
	for i in $(OTHERLIBRARIES); do \
	  $(MAKEREC) -C otherlibs/$$i install || exit $$?; \
	done
	if test -n "$(WITH_OCAMLDOC)"; then \
	  (cd ocamldoc; $(MAKEREC) install); \
	fi
	if test -n "$(WITH_DEBUGGER)"; then \
	  (cd debugger; $(MAKEREC) install); \
	fi
	if test -n "$(FLEXDLL_SUBMODULE_PRESENT)"; then \
	  $(MAKEREC) install-flexdll; \
	fi
	cp config/Makefile "$(INSTALL_LIBDIR)/Makefile.config"
	if test -n "$(INSTALL_DISTRIB)"; then \
	   cp README.adoc "$(INSTALL_DISTRIB)/Readme.general.txt"; \
	   cp README.win32.adoc "$(INSTALL_DISTRIB)/Readme.windows.txt"; \
	   cp LICENSE "$(INSTALL_DISTRIB)/License.txt"; \
	   cp Changes "$(INSTALL_DISTRIB)/Changes.txt"; \
	fi

install-flexdll:
# The $(if ...) installs the correct .manifest file for MSVC and MSVC64
# (GNU make doesn't have ifeq as a function, hence slightly convoluted use of
#  filter-out)
	cp flexdll/flexlink.exe \
	   $(if $(filter-out mingw,$(TOOLCHAIN)),\
	     flexdll/default$(filter-out _i386,_$(ARCH)).manifest) \
	   $(INSTALL_BINDIR)/
	cp flexdll/flexdll_*.$(O) $(INSTALL_LIBDIR)

# Installation of the native-code compiler
installopt:
	cd asmrun && $(MAKEREC) install
	cp ocamlopt "$(INSTALL_BINDIR)/ocamlopt.exe"
	cp ocamlopt "$(INSTALL_BINDIR)/ocamlopt.byte.exe"
	cd stdlib && $(MAKEREC) installopt
	cp middle_end/*.cmi middle_end/*.cmt middle_end/*.cmti \
		"$(INSTALL_COMPLIBDIR)"
	cp middle_end/base_types/*.cmi middle_end/base_types/*.cmt \
		middle_end/base_types/*.cmti "$(INSTALL_COMPLIBDIR)"
	cp asmcomp/*.cmi asmcomp/*.cmt asmcomp/*.cmti "$(INSTALL_COMPLIBDIR)"
	cp compilerlibs/ocamloptcomp.cma $(OPTSTART) "$(INSTALL_COMPLIBDIR)"
	if test -n "$(WITH_OCAMLDOC)"; then \
	  (cd ocamldoc && $(MAKEREC) installopt); \
	fi
	for i in $(OTHERLIBRARIES); do \
	  $(MAKEREC) -C otherlibs/$$i installopt || exit $$?; \
	done
	if test -f ocamlopt.opt ; then $(MAKEREC) installoptopt; fi
	cd tools; $(MAKEREC) installopt
	if test -f ocamlopt.opt -a -f flexdll/flexlink.opt ; then \
	  cp -f flexdll/flexlink.opt $(INSTALL_BINDIR)/flexlink.exe ; \
	fi

installoptopt:
	cp ocamlc.opt "$(INSTALL_BINDIR)/ocamlc.opt$(EXE)"
	cp ocamlopt.opt "$(INSTALL_BINDIR)/ocamlopt.opt$(EXE)"
	cp lex/ocamllex.opt "$(INSTALL_BINDIR)/ocamllex.opt$(EXE)"
	cp ocamlc.opt "$(INSTALL_BINDIR)/ocamlc$(EXE)"
	cp ocamlopt.opt "$(INSTALL_BINDIR)/ocamlopt$(EXE)"
	cp lex/ocamllex.opt "$(INSTALL_BINDIR)/ocamllex$(EXE)"
	cp utils/*.cmx parsing/*.cmx typing/*.cmx bytecomp/*.cmx \
           driver/*.cmx asmcomp/*.cmx "$(INSTALL_COMPLIBDIR)"
	cp compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlcommon.$(A) \
           compilerlibs/ocamlbytecomp.cmxa compilerlibs/ocamlbytecomp.$(A) \
           compilerlibs/ocamloptcomp.cmxa compilerlibs/ocamloptcomp.$(A) \
           $(BYTESTART:.cmo=.cmx) $(BYTESTART:.cmo=.$(O)) \
           $(OPTSTART:.cmo=.cmx) $(OPTSTART:.cmo=.$(O)) \
           "$(INSTALL_COMPLIBDIR)"

# Run all tests

tests: opt.opt
	cd testsuite && $(MAKE) clean && $(MAKE) all

# The clean target

clean:: partialclean

# The compiler

compilerlibs/ocamlcommon.cma: $(COMMON)
	$(CAMLC) -a -o $@ $(COMMON)
partialclean::
	rm -f compilerlibs/ocamlcommon.cma

# The bytecode compiler

compilerlibs/ocamlbytecomp.cma: $(BYTECOMP)
	$(CAMLC) -a -o $@ $(BYTECOMP)
partialclean::
	rm -f compilerlibs/ocamlbytecomp.cma

ocamlc: compilerlibs/ocamlcommon.cma compilerlibs/ocamlbytecomp.cma $(BYTESTART)
	$(CAMLC) $(LINKFLAGS) -compat-32 -o ocamlc \
	         compilerlibs/ocamlcommon.cma \
	         compilerlibs/ocamlbytecomp.cma $(BYTESTART)

partialclean::
	rm -f ocamlc

# The native-code compiler

compilerlibs/ocamloptcomp.cma: $(MIDDLE_END) $(ASMCOMP)
	$(CAMLC) -a -o $@ $(MIDDLE_END) $(ASMCOMP)
partialclean::
	rm -f compilerlibs/ocamloptcomp.cma

ocamlopt: compilerlibs/ocamlcommon.cma compilerlibs/ocamloptcomp.cma \
          compilerlibs/ocamlbytecomp.cma $(OPTSTART)
	$(CAMLC) $(LINKFLAGS) -o ocamlopt \
          compilerlibs/ocamlcommon.cma compilerlibs/ocamloptcomp.cma \
	  compilerlibs/ocamlbytecomp.cma $(OPTSTART)

partialclean::
	rm -f ocamlopt

# The toplevel

compilerlibs/ocamltoplevel.cma: $(TOPLEVEL)
	$(CAMLC) -a -o $@ $(TOPLEVEL)
partialclean::
	rm -f compilerlibs/ocamltoplevel.cma

ocaml: compilerlibs/ocamlcommon.cma compilerlibs/ocamlbytecomp.cma \
       compilerlibs/ocamltoplevel.cma $(TOPLEVELSTART) expunge
	$(CAMLC) $(LINKFLAGS) -linkall -o ocaml.tmp \
          compilerlibs/ocamlcommon.cma compilerlibs/ocamlbytecomp.cma \
          compilerlibs/ocamltoplevel.cma $(TOPLEVELSTART)
	- $(CAMLRUN) ./expunge ocaml.tmp ocaml $(PERVASIVES)
	rm -f ocaml.tmp

partialclean::
	rm -f ocaml

# The native toplevel

compilerlibs/ocamlopttoplevel.cmxa: $(OPTTOPLEVEL:.cmo=.cmx)
	$(CAMLOPT) -a -o $@ $(OPTTOPLEVEL:.cmo=.cmx)
partialclean::
	rm -f compilerlibs/ocamlopttoplevel.cmxa

ocamlnat: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamloptcomp.cmxa \
    compilerlibs/ocamlbytecomp.cmxa \
    compilerlibs/ocamlopttoplevel.cmxa \
    $(OPTTOPLEVELSTART:.cmo=.cmx)
	$(CAMLOPT) $(LINKFLAGS) -linkall -o $@ $^

toplevel/opttoploop.cmx: otherlibs/dynlink/dynlink.cmxa

otherlibs/dynlink/dynlink.cmxa: otherlibs/dynlink/natdynlink.ml
	cd otherlibs/dynlink && $(MAKEREC) allopt


# The configuration file

utils/config.ml: utils/config.mlp config/Makefile
	@rm -f utils/config.ml
	sed -e "s|%%LIBDIR%%|$(LIBDIR)|" \
	    -e "s|%%BYTERUN%%|ocamlrun|" \
	    -e 's|%%CCOMPTYPE%%|$(CCOMPTYPE)|' \
	    -e "s|%%BYTECC%%|$(BYTECC) $(BYTECCCOMPOPTS)|" \
	    -e "s|%%NATIVECC%%|$(NATIVECC) $(NATIVECCCOMPOPTS)|" \
	    -e "s|%%PARTIALLD%%|$(PARTIALLD)|" \
	    -e "s|%%PACKLD%%|$(PACKLD)|" \
	    -e "s|%%BYTECCLIBS%%|$(BYTECCLIBS)|" \
	    -e "s|%%NATIVECCLIBS%%|$(NATIVECCLIBS)|" \
	    -e 's|%%RANLIBCMD%%|$(RANLIBCMD)|' \
	    -e 's|%%ARCMD%%|$(ARCMD)|' \
	    -e 's|%%BINUTILS_NM%%|$(BINUTILS_NM)|' \
	    -e 's|%%BINUTILS_OBJCOPY%%|$(BINUTILS_OBJCOPY)|' \
	    -e "s|%%ARCH%%|$(ARCH)|" \
	    -e "s|%%MODEL%%|$(MODEL)|" \
	    -e "s|%%SYSTEM%%|$(SYSTEM)|" \
	    -e "s|%%EXT_OBJ%%|.$(O)|" \
	    -e "s|%%EXT_ASM%%|.$(S)|" \
	    -e "s|%%EXT_LIB%%|.$(A)|" \
	    -e "s|%%EXT_DLL%%|.dll|" \
	    -e "s|%%SYSTHREAD_SUPPORT%%|true|" \
	    -e 's|%%ASM%%|$(ASM)|' \
	    -e 's|%%ASM_CFI_SUPPORTED%%|false|' \
	    -e 's|%%WITH_FRAME_POINTERS%%|false|' \
	    -e 's|%%WITH_SPACETIME%%|$(WITH_SPACETIME)|' \
	    -e 's|%%PROFINFO_WIDTH%%|$(PROFINFO_WIDTH)|' \
	    -e 's|%%LIBUNWIND_AVAILABLE%%|false|' \
	    -e 's|%%LIBUNWIND_LINK_FLAGS%%||' \
	    -e 's|%%MKDLL%%|$(MKDLL)|' \
	    -e 's|%%MKEXE%%|$(MKEXE)|' \
	    -e 's|%%MKMAINDLL%%|$(MKMAINDLL)|' \
	    -e 's|%%CC_PROFILE%%||' \
	    -e 's|%%HOST%%|$(HOST)|' \
	    -e 's|%%TARGET%%|$(TARGET)|' \
	    -e 's|%%FLAMBDA%%|$(FLAMBDA)|' \
	    -e 's|%%SAFE_STRING%%|$(SAFE_STRING)|' \
	    -e 's|%%FLEXLINK_FLAGS%%|$(FLEXLINK_FLAGS)|' \
	    utils/config.mlp > utils/config.ml

partialclean::
	rm -f utils/config.ml

beforedepend:: utils/config.ml

# The parser

parsing/parser.mli parsing/parser.ml: parsing/parser.mly
	$(CAMLYACC) $(YACCFLAGS) parsing/parser.mly

partialclean::
	rm -f parsing/parser.mli parsing/parser.ml parsing/parser.output

beforedepend:: parsing/parser.mli parsing/parser.ml

# The lexer

parsing/lexer.ml: parsing/lexer.mll
	$(CAMLLEX) parsing/lexer.mll

partialclean::
	rm -f parsing/lexer.ml

beforedepend:: parsing/lexer.ml

# Shared parts of the system compiled with the native-code compiler

compilerlibs/ocamlcommon.cmxa: $(COMMON:.cmo=.cmx)
	$(CAMLOPT) -a -o $@ $(COMMON:.cmo=.cmx)
partialclean::
	rm -f compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlcommon.$(A)

# The bytecode compiler compiled with the native-code compiler

compilerlibs/ocamlbytecomp.cmxa: $(BYTECOMP:.cmo=.cmx)
	$(CAMLOPT) -a -o $@ $(BYTECOMP:.cmo=.cmx)
partialclean::
	rm -f compilerlibs/ocamlbytecomp.cmxa compilerlibs/ocamlbytecomp.$(A)

ocamlc.opt: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlbytecomp.cmxa \
            $(BYTESTART:.cmo=.cmx)
	$(CAMLOPT) $(LINKFLAGS) -ccopt "$(BYTECCLINKOPTS)" -o ocamlc.opt \
          compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlbytecomp.cmxa \
          $(BYTESTART:.cmo=.cmx) -cclib "$(BYTECCLIBS)"

partialclean::
	rm -f ocamlc.opt

# The native-code compiler compiled with itself

compilerlibs/ocamloptcomp.cmxa: $(MIDDLE_END:.cmo=.cmx) $(ASMCOMP:.cmo=.cmx)
	$(CAMLOPT) -a -o $@ $(MIDDLE_END:.cmo=.cmx) $(ASMCOMP:.cmo=.cmx)
partialclean::
	rm -f compilerlibs/ocamloptcomp.cmxa compilerlibs/ocamloptcomp.$(A)

ocamlopt.opt: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamloptcomp.cmxa \
              compilerlibs/ocamlbytecomp.cmxa \
              $(OPTSTART:.cmo=.cmx)
	$(CAMLOPT) $(LINKFLAGS) -o ocamlopt.opt \
          compilerlibs/ocamlcommon.cmxa compilerlibs/ocamloptcomp.cmxa \
	  compilerlibs/ocamlbytecomp.cmxa \
          $(OPTSTART:.cmo=.cmx)

partialclean::
	rm -f ocamlopt.opt

$(COMMON:.cmo=.cmx) $(BYTECOMP:.cmo=.cmx) $(MIDDLE_END:.cmo=.cmx) \
$(ASMCOMP:.cmo=.cmx): ocamlopt

# The numeric opcodes

bytecomp/opcodes.ml: byterun/caml/instruct.h
	sed -n -e "/^enum/p" -e "s|,||g" -e "/^  /p" byterun/caml/instruct.h | \
	gawk -f tools/make-opcodes > bytecomp/opcodes.ml

partialclean::
	rm -f bytecomp/opcodes.ml

beforedepend:: bytecomp/opcodes.ml

# The predefined exceptions and primitives

byterun/primitives:
	cd byterun ; $(MAKEREC) primitives

bytecomp/runtimedef.ml: byterun/primitives byterun/caml/fail.h
	(echo 'let builtin_exceptions = [|'; \
	 sed -n -e 's|.*/\* \("[A-Za-z_]*"\) \*/$$|  \1;|p' \
	     byterun/caml/fail.h; \
	 echo '|]'; \
	 echo 'let builtin_primitives = [|'; \
	 sed -e 's/.*/  "&";/' byterun/primitives; \
	 echo '|]') > bytecomp/runtimedef.ml

partialclean::
	rm -f bytecomp/runtimedef.ml

beforedepend:: bytecomp/runtimedef.ml

# Choose the right machine-dependent files

asmcomp/arch.ml: asmcomp/$(ARCH)/arch.ml
	cp asmcomp/$(ARCH)/arch.ml asmcomp/arch.ml

partialclean::
	rm -f asmcomp/arch.ml

beforedepend:: asmcomp/arch.ml

asmcomp/proc.ml: asmcomp/$(ARCH)/proc.ml
	cp asmcomp/$(ARCH)/proc.ml asmcomp/proc.ml

partialclean::
	rm -f asmcomp/proc.ml

beforedepend:: asmcomp/proc.ml

asmcomp/selection.ml: asmcomp/$(ARCH)/selection.ml
	cp asmcomp/$(ARCH)/selection.ml asmcomp/selection.ml

partialclean::
	rm -f asmcomp/selection.ml

beforedepend:: asmcomp/selection.ml

asmcomp/CSE.ml: asmcomp/$(ARCH)/CSE.ml
	cp asmcomp/$(ARCH)/CSE.ml asmcomp/CSE.ml

partialclean::
	rm -f asmcomp/CSE.ml

beforedepend:: asmcomp/CSE.ml

asmcomp/reload.ml: asmcomp/$(ARCH)/reload.ml
	cp asmcomp/$(ARCH)/reload.ml asmcomp/reload.ml

partialclean::
	rm -f asmcomp/reload.ml

beforedepend:: asmcomp/reload.ml

asmcomp/scheduling.ml: asmcomp/$(ARCH)/scheduling.ml
	cp asmcomp/$(ARCH)/scheduling.ml asmcomp/scheduling.ml

partialclean::
	rm -f asmcomp/scheduling.ml

beforedepend:: asmcomp/scheduling.ml

# Preprocess the code emitters

asmcomp/emit.ml: asmcomp/$(ARCH)/emit.mlp tools/cvt_emit
	$(CAMLRUN) tools/cvt_emit < asmcomp/$(ARCH)/emit.mlp > asmcomp/emit.ml

partialclean::
	rm -f asmcomp/emit.ml

beforedepend:: asmcomp/emit.ml

tools/cvt_emit: tools/cvt_emit.mll
	cd tools ; $(MAKEREC) cvt_emit

# The "expunge" utility

expunge: compilerlibs/ocamlcommon.cma compilerlibs/ocamlbytecomp.cma \
         toplevel/expunge.cmo
	$(CAMLC) $(LINKFLAGS) -o expunge compilerlibs/ocamlcommon.cma \
	         compilerlibs/ocamlbytecomp.cma toplevel/expunge.cmo

partialclean::
	rm -f expunge

# The runtime system for the bytecode compiler

runtime: makeruntime stdlib/libcamlrun.$(A)

makeruntime:
	cd byterun ; $(MAKEREC) $(BOOT_FLEXLINK_CMD) all
stdlib/libcamlrun.$(A): byterun/libcamlrun.$(A)
	cp byterun/libcamlrun.$(A) stdlib/libcamlrun.$(A)
clean::
	cd byterun ; $(MAKEREC) clean
	rm -f stdlib/libcamlrun.$(A)
alldepend::
	cd byterun ; $(MAKEREC) depend

# The runtime system for the native-code compiler

runtimeopt: makeruntimeopt stdlib/libasmrun.$(A)

makeruntimeopt:
	cd asmrun ; $(MAKEREC) $(BOOT_FLEXLINK_CMD) all
stdlib/libasmrun.$(A): asmrun/libasmrun.$(A)
	cp asmrun/libasmrun.$(A) stdlib/libasmrun.$(A)
clean::
	cd asmrun ; $(MAKEREC) clean
	rm -f stdlib/libasmrun.$(A)
alldepend::
	cd asmrun ; $(MAKEREC) depend

# The library

library:
	cd stdlib && $(MAKEREC) $(BOOT_FLEXLINK_CMD) all
library-cross:
	cd stdlib \
	&& $(MAKEREC) $(BOOT_FLEXLINK_CMD) CAMLRUN=../byterun/ocamlrun all
libraryopt:
	cd stdlib && $(MAKEREC) $(BOOT_FLEXLINK_CMD) allopt
partialclean::
	cd stdlib && $(MAKEREC) clean
alldepend::
	cd stdlib && $(MAKEREC) depend

# The lexer and parser generators

ocamllex:
	cd lex ; $(MAKEREC) all
ocamllex.opt:
	cd lex ; $(MAKEREC) allopt
partialclean::
	cd lex ; $(MAKEREC) clean
alldepend::
	cd lex ; $(MAKEREC) depend

ocamlyacc:
	cd yacc ; $(MAKEREC) $(BOOT_FLEXLINK_CMD) all
clean::
	cd yacc ; $(MAKEREC) clean

# OCamldoc

ocamldoc:
	cd ocamldoc ; $(MAKEREC) all
ocamldoc.opt:
	cd ocamldoc ; $(MAKEREC) opt.opt
partialclean::
	cd ocamldoc ; $(MAKEREC) clean
alldepend::
	cd ocamldoc ; $(MAKEREC) depend

# The extra libraries

otherlibraries:
	for i in $(OTHERLIBRARIES); do \
	  $(MAKEREC) -C otherlibs/$$i all || exit $$?; \
	done
otherlibrariesopt:
	for i in $(OTHERLIBRARIES); \
	  do $(MAKEREC) -C otherlibs/$$i allopt || exit $$?; \
	done
partialclean::
	for i in $(OTHERLIBRARIES); \
	  do $(MAKEREC) -C otherlibs/$$i partialclean || exit $$?; \
	done
clean::
	for i in $(OTHERLIBRARIES); do \
	  $(MAKEREC) -C otherlibs/$$i clean || exit $$?; \
	done
alldepend::
	for i in $(OTHERLIBRARIES); do \
	  $(MAKEREC) -C otherlibs/$$i depend || exit $$?; \
	done

# The replay debugger

ocamldebugger: ocamlc ocamlyacc ocamllex
	cd debugger; $(MAKEREC) all
partialclean::
	cd debugger; $(MAKEREC) clean
alldepend::
	cd debugger; $(MAKEREC) depend

# Make clean in the test suite

clean::
	cd testsuite; $(MAKE) clean

# Default rules

.SUFFIXES: .ml .mli .cmo .cmi .cmx

.ml.cmo:
	$(CAMLC) $(COMPFLAGS) -c $<

.mli.cmi:
	$(CAMLC) $(COMPFLAGS) -c $<

.ml.cmx:
	$(CAMLOPT) $(COMPFLAGS) -c $<

partialclean::
	rm -f utils/*.cm* utils/*.$(O) utils/*.$(S)
	rm -f parsing/*.cm* parsing/*.$(O) parsing/*.$(S)
	rm -f typing/*.cm* typing/*.$(O) typing/*.$(S)
	rm -f bytecomp/*.cm* bytecomp/*.$(O) bytecomp/*.$(S)
	rm -f asmcomp/*.cm* asmcomp/*.$(O) asmcomp/*.$(S)
	rm -f middle_end/*.cm* middle_end/*.$(O) middle_end/*.$(S)
	rm -f middle_end/base_types/*.cm* middle_end/base_types/*.$(O) \
	      middle_end/base_types/*.$(S)
	rm -f driver/*.cm* driver/*.$(O) driver/*.$(S)
	rm -f toplevel/*.cm* toplevel/*.$(O) toplevel/*.$(S)
	rm -f tools/*.cm* tools/*.$(O) tools/*.$(S)

depend: beforedepend
	(for d in utils parsing typing bytecomp asmcomp middle_end \
	 middle_end/base_types driver toplevel; \
	 do $(CAMLDEP) -slash $(DEPFLAGS) $$d/*.mli $$d/*.ml; \
	 done) > .depend
	$(CAMLDEP) -slash $(DEPFLAGS) -native \
		-impl driver/compdynlink.mlopt >> .depend
	$(CAMLDEP) -slash $(DEPFLAGS) -bytecode \
		-impl driver/compdynlink.mlbyte >> .depend

alldepend:: depend

distclean:
	$(MAKEREC) clean
	rm -f asmrun/.depend.nt byterun/.depend.nt \
	            otherlibs/bigarray/.depend.nt  \
		    otherlibs/str/.depend.nt
	rm -f boot/ocamlrun boot/ocamlrun.exe boot/camlheader boot/ocamlyacc \
	      boot/*.cm* boot/libcamlrun.a
	rm -f config/Makefile config/m.h config/s.h
	rm -f tools/*.bak
	rm -f ocaml ocamlc
	rm -f testsuite/_log

.PHONY: all backup bootstrap checkstack clean
.PHONY: partialclean beforedepend alldepend cleanboot coldstart
.PHONY: compare core coreall
.PHONY: coreboot defaultentry depend distclean install installopt
.PHONY: library library-cross libraryopt
.PHONY: ocamldebugger ocamldoc
.PHONY: ocamldoc.opt ocamllex ocamllex.opt ocamltools ocamltoolsopt
.PHONY: ocamltoolsopt.opt ocamlyacc opt-core opt opt.opt otherlibraries
.PHONY: otherlibrariesopt promote promote-cross
.PHONY: restore runtime runtimeopt makeruntimeopt world world.opt
.PHONY: flexdll flexlink.opt flexdll-common-err flexdll-repo

include .depend