#  Oukseh Lee
#
#  Copyright(c) 2000-2004 Research On Program Analysis System
#  http://ropas.snu.ac.kr
#
#  All rights reserved. This file is distributed under the terms of
#  an Open Source License.

# The main Makefile

!include config\Makefile.nt

#### COOKCU ##### BEGIN

CAMLC=boot\ncamlrun boot\nmlc -I boot
CAMLOPT=boot\ncamlrun .\nmlo -I stdlib -nontyping
COMPFLAGS=$(INCLUDES)
LINKFLAGS=
CAMLYACC=boot\ocamlyacc
NYACC=boot\nyacc
YACCFLAGS=-v
NLEX=boot\ncamlrun boot\nlex
CAMLLEX=boot\ncamlrun boot\ocamllex

DEPFLAGS=$(INCLUDES)
CAMLRUN=boot\ncamlrun
MKDIR=mkdir -p
NEWCAMLC=$(CAMLC) -nontyping
NMLDEP=tools\nmldep\nmldep

INCLUDES=-I utils -I parser -I ocaml/parsing -I ocaml/typing \
         -I typing -I ocaml/bytecomp -I ocaml/asmcomp \
		 -I ocaml/driver -I ocaml/toplevel \
         -I main -I n2caml -I lambda

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

OPTUTILS=$(UTILS)

PARSING=parser/linenum.cmo parser/location.cmo \
  ocaml/parsing/longident.cmo \
  ocaml/parsing/syntaxerr.cmo ocaml/parsing/parser.cmo \
  ocaml/parsing/lexer.cmo ocaml/parsing/parse.cmo ocaml/parsing/printast.cmo

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

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

BYTECOMP=ocaml/bytecomp/meta.cmo ocaml/bytecomp/instruct.cmo \
  ocaml/bytecomp/bytegen.cmo \
  ocaml/bytecomp/printinstr.cmo ocaml/bytecomp/opcodes.cmo \
  ocaml/bytecomp/emitcode.cmo \
  ocaml/bytecomp/bytesections.cmo ocaml/bytecomp/dll.cmo ocaml/bytecomp/symtable.cmo \
  ocaml/bytecomp/bytelibrarian.cmo ocaml/bytecomp/bytelink.cmo

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


NUTILS = utils/nconfig.cmo utils/nmisc.cmo

NTYPER = typing/setmap.cmo typing/debug.cmo \
         typing/scope.cmo typing/ntypes.cmo typing/printty.cmo \
         typing/error.cmo \
         typing/unify.cmo typing/nenv.cmo typing/printenv.cmo typing/npredef.cmo \
         typing/absyn.cmo typing/infer.cmo typing/dump.cmo \
         typing/init.cmo

NPARSER=parser/ast_gen.cmo parser/info.cmo \
    parser/string_ast.cmo parser/nsyntaxerr.cmo parser/nparser.cmo \
    parser/nlexer.cmo parser/postparse.cmo \
    parser/nparse.cmo

NTOCAML= n2caml/fake.cmo n2caml/ast2fake.cmo n2caml/nconvert.cmo \
  n2caml/strtbl.cmo n2caml/strtbl_build.cmo n2caml/n2caml.cmo \
  n2caml/absyn2ast.cmo lambda/record.cmo

NDRIVER=ocaml/driver/errors.cmo ocaml/driver/compile.cmo \
  main/nterrors.cmo main/ncompile.cmo \
  main/main_args.cmo main/noption.cmo main/nmain.cmo

OPTDRIVER=ocaml/driver/opterrors.cmo ocaml/driver/optcompile.cmo \
  main/nterrors.cmo main/ncompile.cmo main/optmain.cmo

NTOP=ocaml/driver/errors.cmo ocaml/driver/compile.cmo \
  main/nterrors.cmo main/ncompile.cmo\
  main/genprintval.cmo main/toploop.cmo \
  ocaml/toplevel/trace.cmo main/topdirs.cmo main/ntopmain.cmo

NTOPMAIN=main/ntopmain.cmo
NTOPLIB=main/toplevellib.cma

NCOMPOBJS= $(UTILS) $(NUTILS) $(PARSING) \
  $(TYPING) $(NTYPING) $(COMP) $(BYTECOMP) $(NPARSER) $(NTYPER) $(NTOCAML) $(NDRIVER)

NOPTOBJS=$(UTILS) $(NUTILS) $(PARSING) $(TYPING) $(COMP) \
        $(NPARSER) $(NTYPER) $(NTOCAML) $(ASMCOMP) $(OPTDRIVER)

NTOPLIBS=$(UTILS) $(NUTILS) $(PARSING) $(TYPING) $(NTYPING) \
  $(COMP) $(BYTECOMP) $(NPARSER) $(NTYPER) $(NTOCAML) $(NTOP)

NOBJS= $(NTOPLIB) $(NTOPMAIN)

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

PERVASIVES=arg array buffer 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 int32 int64 nativeint outcometree \
  arrayLabels listLabels stringLabels stdLabels \
  interop nml_setmaphash_ nml_typing_

NTYFILES=pervasives.nty stdlib.nty unix.nty

LIBFILES=stdlib.cma std_exit.cmo *.cmi camlheader
UNIXLIB=unix.cma unix.cmi unix.cmo libunix.lib


all: boot nmlc nml ntylib otherlibraries ntools

opt: runtimeopt nmlo libraryopt otherlibrariesopt

opt.opt: nmlc.opt nmlo.opt nlex.opt

rebuild: nmlc nml

ntylib::
	cd stdlib\nty & $(MAKEREC) all

boot:: config\m.h config\s.h
	cd ocaml\byterun & $(MAKEREC) all
	cp ocaml\byterun\ncamlrun.exe boot\ncamlrun.exe
	cd ocaml\yacc & $(MAKEREC) all
	cp ocaml\yacc\ocamlyacc.exe boot\ocamlyacc.exe
	cd tools\yacc & $(MAKEREC) all
	cp tools\yacc\nyacc.exe boot\nyacc.exe
	cd stdlib & $(MAKEREC) COMPILER=../boot/nmlc all
	cd stdlib & cp $(LIBFILES) ..\boot
	cp ocaml\byterun\libcamlrun.lib boot\libcamlrun.lib

config\m.h:
	cd config & cp m-nt.h m.h

config\s.h:
	cd config & cp s-nt.h s.h

clean::
	rm -f config/m.h config/s.h

clean::
	cd stdlib\nty & $(MAKEREC) clean

win32::
	cd config & cp m-nt.h m.h
	cd config & cp s-nt.h s.h

unix::  
	cd config & cp m-unix.h m.h
	cd config & cp s-unix.h s.h


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

clean::
	rm -f nml

nmlc: $(NCOMPOBJS)
	$(CAMLC) $(LINKFLAGS) -o nmlc $(NCOMPOBJS)

nmlc.opt: $(NCOMPOBJS:.cmo=.cmx)
	cd ocaml\asmrun & $(MAKEREC) meta.obj
	$(CAMLOPT) $(LINKFLAGS) -o nmlc.opt \
		$(NCOMPOBJS:.cmo=.cmx) ocaml\asmrun\meta.obj ocaml\asmrun\dynlink.obj

clean::
	rm -f nmlc

nmlo: $(NOPTOBJS)
	$(CAMLC) $(LINKFLAGS) -o nmlo $(NOPTOBJS)

nmlo.opt: $(NOPTOBJS:.cmo=.cmx)
	$(CAMLOPT) $(LINKFLAGS) -o nmlo.opt $(NOPTOBJS:.cmo=.cmx)

nlex.opt:
	cd lex & $(MAKEREC) allopt

clean::
	rm -f nmlo

ntools:: 
	cd tools & $(MAKEREC) all

clean::
	cd tools & $(MAKEREC) clean

clean::
	cd ocaml\tools & $(MAKEREC) clean

# Start up the system from the distribution compiler

# Installation
install::
	if not exist $(BINDIR) mkdir $(BINDIR)
	if not exist $(LIBDIR) mkdir $(LIBDIR)
	cd ocaml\byterun & $(MAKEREC) install
	echo $(LIBDIR)> $(LIBDIR)\ld.conf
	cp nmlc $(BINDIR)\nmlc.exe
	cp nml $(BINDIR)\nml.exe
	cd stdlib & $(MAKEREC) install
	cd stdlib\nty & $(MAKEREC) install
	cp main\toploop.cmi $(LIBDIR)\toploop.cmi
	cp main\topdirs.cmi $(LIBDIR)\topdirs.cmi
	cp main\ntopmain.cmo $(LIBDIR)\ntopmain.cmo
	cp main\toplevellib.cma $(LIBDIR)\toplevellib.cma
	$(NEWCAMLC) -a -o $(LIBDIR)\toplevellib.cma $(NTOPLIB)
	cp expunge $(LIBDIR)\expunge.exe
	cp ocaml\typing\outcometree.cmi $(LIBDIR)\outcometree.cmi
	cp ocaml\typing\outcometree.mli $(LIBDIR)\outcometree.mli
 	cd tools & $(MAKEREC) install
	for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) install & cd ..\..)
	copy /a README $(DISTRIB)\Readme.txt
	copy /a README.win32 $(DISTRIB)\Win32.txt
	copy /a LICENSE $(DISTRIB)\License.txt
	copy /a Changes $(DISTRIB)\Changes.txt
  
installopt:
	cd ocaml\asmrun & $(MAKEREC) install
	cp nmlo $(BINDIR)\nmlo.exe
	cd stdlib & $(MAKEREC) installopt
	for %i in ($(OTHERLIBRARIES)) do (cd otherlibs\%i & $(MAKEREC) installopt & cd ..\..)

# The compiler

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

clean::
	rm -f ocamlc

# The native-code compiler

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

clean::
	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

main\toplevellib.cma: $(NTOPLIBS)
	$(CAMLC) -a -o $@ $(NTOPLIBS)

clean::
	rm -f ocaml/toplevel/toplevellib.cma

##### COOKCU ############################

parser/nparser.n: parser/nparser.ny
	$(NYACC) $(YACCFLAGS) parser/nparser.ny
clean::
	rm -f parser/nparser.n parser/nparser.output

beforedepend:: parser/nparser.n 

parser/nlexer.n: parser/nlexer.nl
	$(NLEX) parser/nlexer.nl

clean::
	rm -f parser/nlexer.n

beforedepend:: parser/nlexer.n

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


# The configuration file

#### COOKCU ####  utils/config.mlp -> utils/config.ml (config/Makefile)



# The configuration file

utils\config.ml: utils\config.mlp config\Makefile.nt
    @rm -f utils\config.ml
	    sed -e "s|%%%%DONTYPING%%%%|$(DONTYPING)|" \
		    -e "s|%%%%LIBDIR%%%%|$(LIBDIR:\=\\\\\\\\)|" \
		    -e "s|%%%%BYTERUN%%%%|ncamlrun|" \
		    -e "s|%%%%BYTECC%%%%|$(BYTECC) $(BYTECCCOMPOPTS)|" \
		    -e "s|%%%%BYTELINK%%%%|$(BYTECC) $(BYTECCLINKOPTS)|" \
		    -e "s|%%%%NATIVECC%%%%|$(NATIVECC) $(NATIVECCCOMPOPTS)|" \
		    -e "s|%%%%NATIVELINK%%%%|$(NATIVECC) $(NATIVECCLINKOPTS)|" \
		    -e "s|%%%%PARTIALLD%%%%|lib /nologo /debugtype:cv|" \
		    -e "s|%%%%BYTECCLIBS%%%%|$(BYTECCLIBS)|" \
		    -e "s|%%%%NATIVECCLIBS%%%%|$(NATIVECCLIBS)|" \
		    -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|" \
		    -e "s|%%%%EXT_DLL%%%%|.dll|" \
		    utils\config.mlp > utils\config.ml
    @attrib +r utils\config.ml




##### COOKCU ##### END

clean::
	rm -f utils\config.ml

beforedepend:: utils\config.ml

# The parser

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

clean::
	rm -f ocaml\parsing\parser.mli ocaml\parsing\parser.ml ocaml\parsing\parser.output

beforedepend:: ocaml\parsing\parser.mli ocaml\parsing\parser.ml

# The lexer

ocaml\parsing\lexer.ml: ocaml\parsing\lexer.mll
	$(CAMLLEX) ocaml\parsing\lexer.mll

clean::
	rm -f ocaml\parsing\lexer.ml

beforedepend:: ocaml\parsing\lexer.ml

# The auxiliary lexer for counting line numbers

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

clean::
	rm -f parser\linenum.ml

beforedepend:: parser\linenum.ml

# The numeric opcodes

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

clean::
	rm -f ocaml\bytecomp\opcodes.ml

beforedepend:: ocaml\bytecomp\opcodes.ml

# The predefined exceptions and primitives

ocaml\byterun\primitives:
	cd ocaml\byterun & $(MAKEREC) primitives

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

ocaml\asmcomp\arch.ml: ocaml\asmcomp\$(ARCH)\arch.ml
	cp ocaml\asmcomp\$(ARCH)\arch.ml ocaml\asmcomp\arch.ml

ocaml\asmcomp\proc.ml: ocaml\asmcomp\$(ARCH)\proc_nt.ml
	cp ocaml\asmcomp\$(ARCH)\proc_nt.ml ocaml\asmcomp\proc.ml

ocaml\asmcomp\selection.ml: ocaml\asmcomp\$(ARCH)\selection.ml
	cp ocaml\asmcomp\$(ARCH)\selection.ml ocaml\asmcomp\selection.ml

ocaml\asmcomp\reload.ml: ocaml\asmcomp\$(ARCH)\reload.ml
	cp ocaml\asmcomp\$(ARCH)\reload.ml ocaml\asmcomp\reload.ml

ocaml\asmcomp\scheduling.ml: ocaml\asmcomp\$(ARCH)\scheduling.ml
	cp ocaml\asmcomp\$(ARCH)\scheduling.ml ocaml\asmcomp\scheduling.ml

ocaml\asmcomp\emit.ml: ocaml\asmcomp\$(ARCH)\emit_nt.mlp ocaml\tools\cvt_emit
	boot\ncamlrun ocaml\tools\cvt_emit < ocaml\asmcomp\$(ARCH)\emit_nt.mlp > ocaml\asmcomp\emit.ml

clean::
	rm -f ocaml\asmcomp\arch.ml
	rm -f ocaml\asmcomp\proc.ml
	rm -f ocaml\asmcomp\selection.ml
	rm -f ocaml\asmcomp\emit.ml
	rm -f ocaml\asmcomp\reload.ml
	rm -f ocaml\asmcomp\scheduling.ml



clemn::
	rm -f ocaml\bytecomp\runtimedef.ml

beforedepend:: ocaml\bytecomp\runtimedef.ml

# Choose the right machine-dependent files

ocaml\tools\cvt_emit: ocaml\tools\cvt_emit.mll
	cd ocaml\tools && $(MAKEREC) cvt_emit

# The "expunge" utility

expunge: $(EXPUNGEOBJS)
	$(CAMLC) $(LINKFLAGS) -o expunge $(EXPUNGEOBJS)

clean::
	rm -f expunge

# The runtime system for the bytecode compiler

runtime: makeruntime stdlib\libcamlrun.lib

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

# The runtime system for the native-code compiler

runtimeopt: makeruntimeopt stdlib\libasmrun.lib

makeruntimeopt:
	cd ocaml\asmrun & $(MAKEREC) all

stdlib\libasmrun.lib: ocaml\asmrun\libasmrun.lib
	cp ocaml\asmrun\libasmrun.lib stdlib\libasmrun.lib

clean::
    cd ocaml\asmrun & $(MAKEREC) clean
    rm -f stdlib\libasmrun.lib

#library

library:
	cd stdlib & $(MAKEREC) all
libraryopt:
	cd stdlib & $(MAKEREC) allopt
clean::
	cd stdlib & $(MAKEREC) clean
alldepend::
	cd stdlib & $(MAKEREC) depend

# Tools

ocamltools:
	cd tools & $(MAKEREC) all
clean::
	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 ..\..)

# The replay debugger
#
#ocamldebugger: 
#	cd debugger; $(MAKEREC) all
#partialclean::
#	cd debugger; $(MAKEREC) clean
#alldepend::
#	cd debugger; $(MAKEREC) depend
#

clean::
	rm -f boot/*.cm* boot/*.nty boot/camlheader boot/*.a boot/nyacc boot/ocamlyacc boot/ncamlrun

clean::
	cd ./yacc; $(MAKEREC) clean

# Default rules

#### COOKCU #####

.SUFFIXES: .ml .mli .n .cmo .cmi .cmx .ns .nty

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

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

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

.n.cmo:
	$(NEWCAMLC) $(COMPFLAGS) -c $<

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

.ns.nty:
	$(NEWCAMLC) $(COMPFLAGS) -c $<

#### COOKCU ##### END

#### COOKCU ##### (optional)

clean::
    cd stdlib & $(MAKEREC) clean
	rm -f boot/*.exe boot/*.lib
	rm -f utils/config.ml
	rm -f utils/*.cm[iox] utils/*.[so] utils/*.obj utils/*~
	rm -f ocaml/parsing/*.cm[iox] ocaml/parsing/*.[so] ocaml/parsing/*.obj ocaml/parsing/*~
	rm -f ocaml/typing/*.cm[iox] ocaml/typing/*.[so] ocaml/typing/*.obj ocaml/typing/*~
	rm -f ocaml/bytecomp/*.cm[iox] ocaml/bytecomp/*.[so] ocaml/bytecomp/*.obj ocaml/bytecomp/*~
	rm -f ocaml/asmcomp/*.cm[iox] ocaml/asmcomp/*.[so] ocaml/asmcomp/*.obj ocaml/asmcomp/*~
	rm -f ocaml/driver/*.cm[iox] ocaml/driver/*.[so] ocaml/driver/*.obj ocaml/driver/*~
	rm -f ocaml/toplevel/*.cm[iox] ocaml/toplevel/*.[so] ocaml/toplevel/*.obj ocaml/toplevel/*~
	rm -f ocaml/tools/*.cm[iox] ocaml/tools/*.[so] ocaml/tools/*~
	rm -f utils/*.cm[iox] utils/*.[so] utils/*~
	rm -f parser/*.cm[iox] parser/*.[so] parser/*.obj parser/*~
	rm -f n2caml/*.cm[iox] n2caml/*.[so] n2caml/*.obj n2caml/*~
	rm -f typing/*.cm[iox] typing/*.[so] typing/*.obj typing/*~
	rm -f lambda/*.cm[iox] lambda/*.[so] lambda/*.obj lambda/*~
	rm -f main/*.cm[iox] main/*.[so] main/*.obj main/*~
	rm -f nml nmlc nmlo
	rm -Rf stdlib/caml
	cd ocaml\yacc & $(MAKEREC) clean
	rm -f *~

depend: beforedepend ocamltools ntools
	(for d in utils parsing typing bytecomp asmcomp driver toplevel \
              n/utils n/parser n/typing n/ntyping n/n2caml n/driver n/toplevel ; \
         do $(CAMLDEP) $(DEPFLAGS) $$d/*.mli $$d/*.ml; \
         done) > .depend
	(for d in n/utils n/parser n/typing n/ntyping n/n2caml n/driver n/toplevel ; \
         do $(NMLDEP) $(DEPFLAGS) $$d/*.n; \
         done) >> .depend

alldepend:: depend

!include .depend