path: root/Makefile.nt

# The main Makefile

!include config\Makefile.nt

CAMLC=boot\ocamlrun boot\ocamlc -I boot
CAMLOPT=boot\ocamlrun .\ocamlopt -I stdlib
COMPFLAGS=$(INCLUDES)
LINKFLAGS=
CAMLYACC=boot\ocamlyacc
YACCFLAGS=
CAMLLEX=boot\ocamlrun boot\ocamllex
CAMLDEP=boot\ocamlrun tools\ocamldep
DEPFLAGS=$(INCLUDES)
CAMLRUN=byterun\ocamlrun

INCLUDES=-I utils -I parsing -I typing -I bytecomp -I asmcomp -I driver -I toplevel

UTILS=utils\misc.cmo utils\tbl.cmo utils\config.cmo \
  utils\clflags.cmo utils\terminfo.cmo utils\ccomp.cmo

OPTUTILS=$(UTILS) utils\nativeint.cmo

PARSING=parsing\linenum.cmo parsing\location.cmo parsing\longident.cmo \
  parsing\syntaxerr.cmo parsing\pstream.cmo parsing\parser.cmo \
  parsing\lexer.cmo parsing\parse.cmo

TYPING=typing\ident.cmo typing\path.cmo \
  typing\primitive.cmo typing\types.cmo \
  typing\btype.cmo \
  typing\subst.cmo typing\predef.cmo \
  typing\datarepr.cmo typing\env.cmo \
  typing\typedtree.cmo typing\ctype.cmo \
  typing\printtyp.cmo typing\includeclass.cmo \
  typing\mtype.cmo typing\includecore.cmo \
  typing\includemod.cmo typing\parmatch.cmo \
  typing\typetexp.cmo typing\typecore.cmo \
  typing\typedecl.cmo typing\typeclass.cmo \
  typing\typemod.cmo

COMP=bytecomp\lambda.cmo bytecomp\printlambda.cmo \
  bytecomp\typeopt.cmo bytecomp\translobj.cmo \
  bytecomp\matching.cmo bytecomp\translcore.cmo \
  bytecomp\translclass.cmo bytecomp\translmod.cmo \
  bytecomp\simplif.cmo bytecomp\runtimedef.cmo

BYTECOMP=bytecomp\meta.cmo bytecomp\instruct.cmo bytecomp\bytegen.cmo \
  bytecomp\printinstr.cmo bytecomp\opcodes.cmo bytecomp\emitcode.cmo \
  bytecomp\symtable.cmo bytecomp\bytelibrarian.cmo bytecomp\bytelink.cmo

ASMCOMP=asmcomp\arch.cmo asmcomp\cmm.cmo asmcomp\printcmm.cmo \
  asmcomp\reg.cmo asmcomp\mach.cmo asmcomp\proc.cmo \
  asmcomp\clambda.cmo asmcomp\compilenv.cmo \
  asmcomp\closure.cmo asmcomp\cmmgen.cmo \
  asmcomp\printmach.cmo asmcomp\selectgen.cmo asmcomp\selection.cmo \
  asmcomp\liveness.cmo asmcomp\spill.cmo asmcomp\split.cmo \
  asmcomp\interf.cmo asmcomp\coloring.cmo \
  asmcomp\reloadgen.cmo asmcomp\reload.cmo \
  asmcomp\printlinear.cmo asmcomp\linearize.cmo \
  asmcomp\schedgen.cmo asmcomp\scheduling.cmo \
  asmcomp\emitaux.cmo asmcomp\emit.cmo asmcomp\asmgen.cmo \
  asmcomp\asmlink.cmo asmcomp\asmlibrarian.cmo

DRIVER=driver\errors.cmo driver\compile.cmo driver\main_args.cmo driver\main.cmo

OPTDRIVER=driver\opterrors.cmo driver\optcompile.cmo driver\optmain.cmo

TOPLEVEL=driver\errors.cmo driver\compile.cmo \
  toplevel\genprintval.cmo \
  toplevel\printval.cmo toplevel\toploop.cmo \
  toplevel\trace.cmo toplevel\topdirs.cmo

TOPLEVELMAIN=toplevel\topmain.cmo

COMPOBJS=$(UTILS) $(PARSING) $(TYPING) $(COMP) $(BYTECOMP) $(DRIVER)

TOPLIB=$(UTILS) $(PARSING) $(TYPING) $(COMP) $(BYTECOMP) $(TOPLEVEL)

TOPOBJS=$(TOPLIB) $(TOPLEVELMAIN)

OPTOBJS=$(OPTUTILS) $(PARSING) $(TYPING) $(COMP) $(ASMCOMP) $(OPTDRIVER)

EXPUNGEOBJS=utils\misc.cmo utils\tbl.cmo \
  utils\config.cmo utils\clflags.cmo \
  typing\ident.cmo typing\path.cmo typing\types.cmo typing\btype.cmo \
  typing\predef.cmo bytecomp\runtimedef.cmo bytecomp\symtable.cmo \
  toplevel\expunge.cmo

PERVASIVES=arg array callback char digest filename format gc hashtbl \
  lexing list map obj parsing pervasives printexc printf queue random \
  set sort stack string stream sys oo genlex topdirs toploop weak lazy \
  marshal

# Recompile the system using the bootstrap compiler
all: runtime ocamlc ocamllex ocamlyacc ocamltools library ocaml otherlibraries

# 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

# Set up the configuration files
configure: FORCE
	cp config\m-nt.h config\m.h
	cp config\s-nt.h config\s.h
	cp config\Makefile.nt config\Makefile

# Complete bootstrapping cycle
bootstrap:
# 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
# Rebuild the library (using byterun\ocamlrun .\ocamlc)
	$(MAKEREC) library-cross
# Promote the new compiler and the new runtime
	$(MAKEREC) promote
# Rebuild everything, including ocaml and the tools
	$(MAKEREC) partialclean
	$(MAKEREC) all
# Check if fixpoint reached
	$(MAKEREC) compare

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

# Start up the system from the distribution compiler
coldstart:
	cd byterun & $(MAKEREC) all
	cp byterun\ocamlrun.exe boot\ocamlrun.exe
	cd yacc & $(MAKEREC) all
	cp yacc\ocamlyacc.exe boot\ocamlyacc.exe
	cd stdlib & $(MAKEREC) COMPILER=..\boot\ocamlc all
	cd stdlib & cp $(LIBFILES) ..\boot

# Save the current bootstrap compiler
MAXSAVED=boot\Saved\Saved.prev\Saved.prev\Saved.prev\Saved.prev\Saved.prev
backup:
	if not exist boot\Saved mkdir boot\Saved
	if exist $(MAXSAVED) rm -r $(MAXSAVED)
	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 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:
	cp ocamlc boot\ocamlc
	cp lex\ocamllex boot\ocamllex
	cp yacc\ocamlyacc.exe boot\ocamlyacc.exe
	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:
	fc /b boot\ocamlc ocamlc
	fc /b boot\ocamllex lex\ocamllex
	echo "Fixpoint reached, bootstrap succeeded."

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

# Compile the native-code compiler
opt: runtimeopt ocamlopt libraryopt otherlibrariesopt

# Installation
install: installbyt installopt

installbyt:
	cd byterun & $(MAKEREC) install
	cp ocamlc $(BINDIR)\ocamlc.exe
	cp ocaml $(BINDIR)\ocaml.exe
	cd stdlib & $(MAKEREC) install
	cp lex\ocamllex $(BINDIR)\ocamllex.exe
	cp yacc\ocamlyacc.exe $(BINDIR)\ocamlyacc.exe
	$(CAMLC) -a -o $(LIBDIR)\toplevellib.cma $(TOPLIB)
	cp expunge $(LIBDIR)\expunge.exe
	cp toplevel\topmain.cmo $(LIBDIR)\topmain.cmo
	cp toplevel\toploop.cmi $(LIBDIR)\toploop.cmi
	cp toplevel\topdirs.cmi $(LIBDIR)\topdirs.cmi
	cd tools & $(MAKEREC) install
	for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) install & cd ..\..)
	cd wingui & $(MAKE) -nologo install
	copy /a README $(DISTRIB)\Readme.gen
	copy /a README.win32 $(DISTRIB)\Readme.win
	copy /a LICENSE $(DISTRIB)\License.txt
	copy /a Changes $(DISTRIB)\Changes.txt

# Installation of the native-code compiler
installopt:
	cd asmrun & $(MAKEREC) install
	cp ocamlopt $(BINDIR)\ocamlopt.exe
	cd stdlib & $(MAKEREC) installopt
	for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) installopt & cd ..\..)

clean:: partialclean

# The compiler

ocamlc: $(COMPOBJS)
	$(CAMLC) $(LINKFLAGS) -o ocamlc $(COMPOBJS)

partialclean::
	rm -f ocamlc

# The native-code compiler

ocamlopt: $(OPTOBJS)
	$(CAMLC) $(LINKFLAGS) -o ocamlopt $(OPTOBJS)

partialclean::
	rm -f ocamlopt

# The toplevel

ocaml: $(TOPOBJS) expunge
	$(CAMLC) $(LINKFLAGS) -linkall -o ocaml.tmp $(TOPOBJS)
	- $(CAMLRUN) .\expunge ocaml.tmp ocaml $(PERVASIVES)
	rm -f ocaml.tmp

partialclean::
	rm -f ocaml

# The configuration file

utils\config.ml: utils\config.mlp config\Makefile.nt
	@rm -f utils\config.ml
	sed -e "s|%%%%LIBDIR%%%%|$(LIBDIR:\=/)|" \
            -e "s|%%%%BYTERUN%%%%|ocamlrun|" \
            -e "s|%%%%BYTECC%%%%|$(BYTECC) $(BYTECCLINKOPTS)|" \
            -e "s|%%%%NATIVECC%%%%|$(NATIVECC) $(NATIVECCLINKOPTS)|" \
            -e "s|%%%%PARTIALLD%%%%|lib /nologo /debugtype:cv|" \
            -e "s|%%%%CCLIBS%%%%|$(CCLIBS)|" \
            -e "s|%%%%ARCH%%%%|$(ARCH)|" \
            -e "s|%%%%MODEL%%%%|$(MODEL)|" \
            -e "s|%%%%SYSTEM%%%%|$(SYSTEM)|" \
            -e "s|%%%%EXT_OBJ%%%%|.obj|" \
            -e "s|%%%%EXT_ASM%%%%|.asm|" \
            -e "s|%%%%EXT_LIB%%%%|.lib|" \
            utils\config.mlp > utils\config.ml
	@attrib +r 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

# The auxiliary lexer for counting line numbers

parsing\linenum.ml: parsing\linenum.mll
	$(CAMLLEX) parsing\linenum.mll

partialclean::
	rm -f parsing\linenum.ml

beforedepend:: parsing\linenum.ml

# The bytecode compiler compiled with the native-code compiler

ocamlc.opt: $(COMPOBJS:.cmo=.cmx)
	cd asmrun & $(MAKEREC) meta.obj
	$(CAMLOPT) $(LINKFLAGS) -o ocamlc.opt $(COMPOBJS:.cmo=.cmx) asmrun\meta.obj

partialclean::
	rm -f ocamlc.opt

# The native-code compiler compiled with itself

ocamlopt.opt: $(OPTOBJS:.cmo=.cmx)
	$(CAMLOPT) $(LINKFLAGS) -o ocamlopt.opt $(OPTOBJS:.cmo=.cmx)

partialclean::
	rm -f ocamlopt.opt

$(OPTOBJS:.cmo=.cmx): ocamlopt

# The numeric opcodes

bytecomp\opcodes.ml: byterun\instruct.h
	sed -n -e "/^enum/p" -e "s|,||g" -e "/^  /p" byterun\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\fail.h
	echo let builtin_exceptions = ^[^| > bytecomp\runtimedef.ml
	sed -n -e "s|.*/\* \(\"[A-Za-z_]*\"\) \*/$$|  \1;|p" byterun\fail.h | \
        sed -e "$$s|;$$||" >> bytecomp\runtimedef.ml
	echo ^|^] >> bytecomp\runtimedef.ml
	echo let builtin_primitives = ^[^| >> bytecomp\runtimedef.ml
	sed -e "s|.*|  \"^&\";|" -e "$$s|;$$||" byterun\primitives \
        >> bytecomp\runtimedef.ml
	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_nt.ml
	cp asmcomp\$(ARCH)\proc_nt.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\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_nt.mlp tools\cvt_emit
	boot\ocamlrun tools\cvt_emit < asmcomp\$(ARCH)\emit_nt.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: $(EXPUNGEOBJS)
	$(CAMLC) $(LINKFLAGS) -o expunge $(EXPUNGEOBJS)

partialclean::
	rm -f expunge

# The runtime system for the bytecode compiler

runtime: makeruntime stdlib\libcamlrun.lib

makeruntime:
	cd byterun & $(MAKEREC) all
stdlib\libcamlrun.lib: byterun\libcamlrun.lib
	cp byterun\libcamlrun.lib stdlib\libcamlrun.lib
clean::
	cd byterun & $(MAKEREC) clean
	rm -f stdlib\libcamlrun.lib
alldepend::
	cd byterun & $(MAKEREC) depend

# The runtime system for the native-code compiler

runtimeopt: makeruntimeopt stdlib\libasmrun.lib

makeruntimeopt:
	cd asmrun & $(MAKEREC) all
stdlib\libasmrun.lib: asmrun\libasmrun.lib
	cp asmrun\libasmrun.lib stdlib\libasmrun.lib
clean::
	cd asmrun & $(MAKEREC) clean
	rm -f stdlib\libasmrun.lib
alldepend::
	cd asmrun & $(MAKEREC) depend

# The library

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

# The lexer and parser generators

ocamllex:
	cd lex & $(MAKEREC) all
partialclean::
	cd lex & $(MAKEREC) clean
alldepend::
	cd lex & $(MAKEREC) depend

ocamlyacc:
	cd yacc & $(MAKEREC) all
clean::
	cd yacc & $(MAKEREC) clean

# Tools

ocamltools:
	cd tools & $(MAKEREC) all
partialclean::
	cd tools & $(MAKEREC) clean
alldepend::
	cd tools & $(MAKEREC) depend

# The extra libraries

otherlibraries:
	-for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) all & cd ..\..)
otherlibrariesopt:
	-for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) allopt & cd ..\..)
partialclean::
	-for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) partialclean & cd ..\..)
clean::
	-for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) clean & cd ..\..)
alldepend::
	-for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) depend & cd ..\..)

# 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/*.obj utils/*.asm
	rm -f parsing/*.cm* parsing/*.obj parsing/*.asm
	rm -f typing/*.cm* typing/*.obj typing/*.asm
	rm -f bytecomp/*.cm* bytecomp/*.obj bytecomp/*.asm
	rm -f asmcomp/*.cm* asmcomp/*.obj asmcomp/*.asm
	rm -f driver/*.cm* driver/*.obj driver/*.asm
	rm -f toplevel/*.cm* toplevel/*.obj toplevel/*.asm
	rm -f tools/*.cm* tools/*.obj tools/*.asm

depend: beforedepend
	echo > .depend
	for %d in (utils parsing typing bytecomp asmcomp driver toplevel) do $(CAMLDEP) $(DEPFLAGS) %d\*.mli %d\*.ml >> .depend

alldepend:: depend

!include .depend

FORCE: