ports//lang/nml/work/nml-0.92/Makefile

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


# The main Makefile

include config/Makefile

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
CAMLLEX=boot/ncamlrun boot/ocamllex
NLEX=boot/ncamlrun boot/nlex
DEPFLAGS=$(INCLUDES)
CAMLRUN=boot/ncamlrun
MKDIR=mkdir -p
NEWCAMLC=$(CAMLC) -nontyping
#-nontyping

NMLBOOT_INCLUDES=-I utils -I ocaml/parsing -I ocaml/typing \
         -I ocaml/bytecomp -I ocaml/driver \
         -I bootcomp -I main

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

INCLUDES=$(ORG_INCLUDES)

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

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

OPTDRIVER=ocaml/driver/opterrors.cmo ocaml/driver/optcompile.cmo \
  main/nterrors.cmo main/ncompile.cmo main/optmain.cmo
  
NTOPMAIN=main/ntopmain.cmo
NTOPLIB=main/toplevellib.cma

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

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

NOBJS= $(NTOPLIB) $(NTOPMAIN)

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

NBOOT=$(UTILS) $(PARSING) $(TYPING) $(COMP) $(BYTECOMP) \
  bootcomp/ast_gen.cmo bootcomp/stringinfo.cmo \
  bootcomp/string_ast.cmo bootcomp/nsyntaxerr.cmo bootcomp/nparser.cmo \
  bootcomp/nlexer.cmo bootcomp/postparse.cmo \
  bootcomp/nparse.cmo \
  bootcomp/nconvert.cmo \
  bootcomp/strtbl.cmo bootcomp/n2caml.cmo \
  bootcomp/nerrors.cmo \
  bootcomp/ncompile.cmo \
  main/main_args.cmo \
  ocaml/driver/errors.cmo ocaml/driver/compile.cmo \
  bootcomp/nmain.cmo


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


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

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_

################### poisson ##################



all: boot nmlc ocamlmklib nml ntylib otherlibraries ntools

rebuild: nmlc nml


ntylib::
	cd stdlib/nty; $(MAKE)


nml-boot::
	cd ocaml/byterun; $(MAKE) all
	cp ocaml/byterun/ocamlrun boot/ncamlrun
	cd ocaml/yacc; $(MAKE) all
	cp ocaml/yacc/ocamlyacc boot/ocamlyacc
	cd tools/yacc; $(MAKE) all
	cp tools/yacc/nyacc boot/nyacc
	if test -f boot/libcamlrun.a; then :; else \
          ln -s ../ocaml/byterun/libcamlrun.a boot/libcamlrun.a; fi
	if test -d stdlib/caml; then :; else \
          ln -s ../ocaml/byterun stdlib/caml; fi
	cd stdlib; $(MAKE) COMPILER=../boot/nmlc all
	cd stdlib; cp $(LIBFILES) ../boot
	$(MAKE) nboot

nboot: $(NBOOT)
	$(CAMLC) -o nmlc $(NBOOT)

boot:: 
	cd ocaml/byterun; $(MAKE) all
	cp ocaml/byterun/ocamlrun boot/ncamlrun
	cd ocaml/yacc; $(MAKE) all
	cp ocaml/yacc/ocamlyacc boot/ocamlyacc
	cd tools/yacc; $(MAKE) all
	cp tools/yacc/nyacc boot/nyacc
	cd stdlib; $(MAKE) COMPILER=../boot/nmlc all
	cd stdlib; cp $(LIBFILES) ../boot
	if test -f boot/libcamlrun.a; then :; else \
          ln -s ../ocaml/byterun/libcamlrun.a boot/libcamlrun.a; fi
	if test -d stdlib/caml; then :; else \
          ln -s ../ocaml/byterun stdlib/caml; fi

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

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

nmlc.opt: $(NCOMPOBJS:.cmo=.cmx)
	cd ocaml/asmrun; $(MAKE) meta.o dynlink.o
	$(CAMLOPT) $(LINKFLAGS) -ccopt "$(BYTECCLINKOPTS)" -o nmlc $(NCOMPOBJS:.cmo=.cmx) ocaml/asmrun/meta.o ocaml/asmrun/dynlink.o -cclib "$(DYNLINKOPTS)"

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

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


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

ntools:: 
	cd tools; $(MAKE) all

ocamlmklib::
	cd ocaml/tools; $(MAKE) ocamlmklib

opt: runtimeopt nmlo libraryopt otherlibrariesopt

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

nlex.opt::
	cd tools/lex; $(MAKE) opt

nmakegen.opt::
	cd tools/nmakegen; $(MAKE) opt

runtimeopt:
	cd ocaml/asmrun; $(MAKE) all
	if test -f stdlib/libasmrun.a; then :; else \
	ln -s ../ocaml/asmrun/libasmrun.a stdlib/libasmrun.a; fi
clean::
	cd ocaml/asmrun; $(MAKE) clean
	rm -f stdlib/libasmrun.a

alldepend::
	cd ocaml/asmrun; $(MAKE) depend

# Installation
install::
	if test -d $(BINDIR); then : ; else $(MKDIR) $(BINDIR); fi
	if test -d $(LIBDIR); then : ; else $(MKDIR) $(LIBDIR); fi
	if test -d $(MANDIR); then : ; else $(MKDIR) $(MANDIR); fi
	if test -f nmlc.exe; then mv nmlc.exe nmlc; else :; fi
	if test -f nmlo.exe; then mv nmlo.exe nmlo; else :; fi
	rm -f $(LIBDIR)/lib*.so
	cd ocaml/byterun; $(MAKE) install
	if test -r $(LIBDIR)/ld.conf; then :; else echo "$(LIBDIR)" > $(LIBDIR)/ld.conf; fi
	cp nmlc $(BINDIR)/nmlc$(EXE)
	cp nml $(BINDIR)/nml$(EXE)
	cd stdlib; $(MAKE) install
	cd stdlib/nty; $(MAKE) install
	cd tools; $(MAKE) install
	cp main/toplevellib.cma $(LIBDIR)/toplevellib.cma
	cp expunge $(LIBDIR)/expunge$(EXE)
	cp ocaml/typing/outcometree.cmi ocaml/typing/outcometree.mli $(LIBDIR)
	cp main/ntopmain.cmo $(LIBDIR)
	cp main/toploop.cmi main/topdirs.cmi $(LIBDIR)
	for i in $(OTHERLIBRARIES); do \
	  (cd otherlibs/$$i; $(MAKE) install) || exit $$?; done
	if test -f nmlo; then $(MAKE) installopt; else :; fi

installopt:
	cd ocaml/asmrun; $(MAKE) install
	cp nmlo $(BINDIR)/nmlo$(EXE)
	cd stdlib; $(MAKE) installopt
	set -e; for i in $(OTHERLIBRARIES); do (cd otherlibs/$$i; $(MAKE) installopt); done

clean:: partialclean

main/toplevellib.cma: $(NTOPLIBS)
	$(NEWCAMLC) -a -o main/toplevellib.cma $(NTOPLIBS)

clean::
	rm -f main/toplevellib.cma

######################### poisson ############################

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

utils/config.ml: utils/config.mlp config/Makefile
	@rm -f utils/config.ml
	sed -e 's|%%DONTYPING%%|$(DONTYPING)|' \
            -e 's|%%LIBDIR%%|$(LIBDIR)|' \
            -e 's|%%BYTERUN%%|$(BINDIR)/ncamlrun|' \
            -e 's|%%BYTECC%%|$(BYTECC) $(BYTECCCOMPOPTS)|' \
            -e 's|%%BYTELINK%%|$(BYTECC) $(BYTECCLINKOPTS)|' \
            -e 's|%%NATIVECC%%|$(NATIVECC) $(NATIVECCCOMPOPTS)|' \
            -e 's|%%NATIVELINK%%|$(NATIVECC) $(NATIVECCLINKOPTS)|' \
            -e 's|%%PARTIALLD%%|ld -r $(NATIVECCLINKOPTS)|' \
            -e 's|%%BYTECCLIBS%%|$(BYTECCLIBS)|' \
            -e 's|%%NATIVECCLIBS%%|$(NATIVECCLIBS)|' \
            -e 's|%%RANLIBCMD%%|$(RANLIBCMD)|' \
            -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%%|.so|' \
            utils/config.mlp > utils/config.ml
	@chmod -w utils/config.ml

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 | \
	awk -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; $(MAKE) primitives

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

clean::
	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; $(MAKE) cvt_emit

# The "expunge" utility

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

clean::
	rm -f expunge

# The runtime system for the bytecode compiler

runtime:
	cd ocaml/byterun; $(MAKE) all
	if test -f stdlib/libcamlrun.a; then :; else \
          ln -s ../ocaml/byterun/libcamlrun.a stdlib/libcamlrun.a; fi
clean::
	cd ocaml/byterun; $(MAKE) clean
	rm -f stdlib/libcamlrun.a

alldepend::
	cd ocaml/byterun; $(MAKE) depend

# The runtime system for the native-code compiler

# The library

library:
	cd stdlib; $(MAKE) all
library-cross:
	cd stdlib; $(MAKE) RUNTIME=../byterun/ncamlrun all
libraryopt:
	cd stdlib; $(MAKE) allopt
clean::
	cd stdlib; $(MAKE) clean
alldepend::
	cd stdlib; $(MAKE) depend

# The extra libraries

otherlibraries:
	set -e; for i in $(OTHERLIBRARIES); do (cd otherlibs/$$i; $(MAKE) all); done
otherlibrariesopt:
	set -e; for i in $(OTHERLIBRARIES); do (cd otherlibs/$$i; $(MAKE) allopt); done
clean::
	for i in $(OTHERLIBRARIES); do (cd otherlibs/$$i; $(MAKE) clean); done
alldepend::
	for i in $(OTHERLIBRARIES); do (cd otherlibs/$$i; $(MAKE) depend); done

# Choose the right machine-dependent files

ocaml/asmcomp/arch.ml: ocaml/asmcomp/$(ARCH)/arch.ml
	ln -s $(ARCH)/arch.ml ocaml/asmcomp/arch.ml

partialclean::
	rm -f ocaml/asmcomp/arch.ml

beforedepend:: ocaml/asmcomp/arch.ml

ocaml/asmcomp/proc.ml: ocaml/asmcomp/$(ARCH)/proc.ml
	ln -s $(ARCH)/proc.ml ocaml/asmcomp/proc.ml

partialclean::
	rm -f ocaml/asmcomp/proc.ml

beforedepend:: ocaml/asmcomp/proc.ml

ocaml/asmcomp/selection.ml: ocaml/asmcomp/$(ARCH)/selection.ml
	ln -s $(ARCH)/selection.ml ocaml/asmcomp/selection.ml

partialclean::
	rm -f ocaml/asmcomp/selection.ml

beforedepend:: ocaml/asmcomp/selection.ml

ocaml/asmcomp/reload.ml: ocaml/asmcomp/$(ARCH)/reload.ml
	ln -s $(ARCH)/reload.ml ocaml/asmcomp/reload.ml

partialclean::
	rm -f ocaml/asmcomp/reload.ml

beforedepend:: ocaml/asmcomp/reload.ml

ocaml/asmcomp/scheduling.ml: ocaml/asmcomp/$(ARCH)/scheduling.ml
	ln -s $(ARCH)/scheduling.ml ocaml/asmcomp/scheduling.ml

partialclean::
	rm -f ocaml/asmcomp/scheduling.ml

beforedepend:: ocaml/asmcomp/scheduling.ml

# Preprocess the code emitters

ocaml/asmcomp/emit.ml: ocaml/asmcomp/$(ARCH)/emit.mlp ocaml/tools/cvt_emit
	$(CAMLRUN) ocaml/tools/cvt_emit < ocaml/asmcomp/$(ARCH)/emit.mlp > ocaml/asmcomp/emit.ml \
	|| { rm -f ocaml/asmcomp/emit.ml; exit 2; }

partialclean::
	rm -f ocaml/asmcomp/emit.ml

beforedepend:: ocaml/asmcomp/emit.ml


# The replay debugger


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

clean::
	cd ocaml/yacc; $(MAKE) clean

# Default rules

.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 $<

clean::
	rm -f utils/*.cm[iox] utils/*.[so] utils/*~
	rm -f ocaml/parsing/*.cm[iox] ocaml/parsing/*.[so] ocaml/parsing/*~
	rm -f ocaml/typing/*.cm[iox] ocaml/typing/*.[so] ocaml/typing/*~
	rm -f ocaml/bytecomp/*.cm[iox] ocaml/bytecomp/*.[so] ocaml/bytecomp/*~
	rm -f ocaml/asmcomp/*.cm[iox] ocaml/asmcomp/*.[so] ocaml/asmcomp/*~
	rm -f ocaml/asmrun/*.cm[iox] ocaml/asmrun/*.[so] ocaml/asmrun/*~
	rm -f ocaml/driver/*.cm[iox] ocaml/driver/*.[so] ocaml/driver/*~
	rm -f ocaml/toplevel/*.cm[iox] ocaml/toplevel/*.[so] ocaml/toplevel/*~
	rm -f ocaml/tools/*.cm[iox] ocaml/tools/*.[so] ocaml/tools/*~
	rm -f parser/*.cm[iox] parser/*.[so] parser/*~
	rm -f n2caml/*.cm[iox] n2caml/*.[so] n2caml/*~
	rm -f typing/*.cm[iox] typing/*.[so] typing/*~
	rm -f lambda/*.cm[iox] lambda/*.[so] lambda/*~
	rm -f main/*.cm[iox] main/*.[so] main/*~
	rm -f *~
	rm -f stdlib/caml
	rm -f nmlc nml nmlo
	cd tools; $(MAKE) clean
	cd stdlib/nty; $(MAKE) clean
	cd ocaml/tools; $(MAKE) clean

depend: beforedepend
	nmakegen -d -f $(INCLUDES)
 
#	tools/nmlmake/nmlmake -d $(INCLUDES)

test::
	cd test/aparser; $(MAKE)
	cd test/bench; $(MAKE)
	cd test/bug; $(MAKE)
	cd test/hw; $(MAKE)

test-clean::
	cd test/aparser; $(MAKE) clean
	cd test/bench; $(MAKE) clean
	cd test/bug; $(MAKE) clean
	cd test/hw; $(MAKE) clean

alldepend:: depend

include .depend
syntax highlighted by Code2HTML, v. 0.9.1