# $Id: Makefile 1723 2007-03-29 21:32:04Z andres $

# Instructions:
# You can compile a debug bytecode app by specifying DEBUG=-g
# You can compile a profiled bytecode app by specifying
#      OCAMLC=ocamlcp DEBUG="-p a"
# You can compile a profiled native app by specifying PROFILE=-p

# Change whatever options (compilers, compiler options, and so on) in this file
-include ../config

# Cleanup spaces so that we recognize proper options
USEPARALLEL := $(strip $(USEPARALLEL))
USEINTERFACE := $(strip $(USEINTERFACE))
USEGRAPHICS := $(strip $(USEGRAPHICS))
USEWIN32 := $(strip $(USEWIN32))
USESHAREDHD := $(strip $(USESHAREDHD))

OCAMLMPI = ../ocamlmpi/
OCAML_INCLUDES := -I $(OCAMLMPI) -I +camlp4 -I ./grappa -I ./graphps $(LABLTK)

ifeq ($(USEWIN32), true)
	CCOPT := -ccopt -mno-cygwin $(CCOPT)
endif

-include $(PWD)/$(DEPEND)

GRAPHICS :=
ifeq ($(USEINTERFACE), ncurses)
	INTERFACE = status_ncurses.cma 
endif
ifeq ($(USEINTERFACE), flat)
	INTERFACE = status_flat.cma 
endif
ifeq ($(USEINTERFACE), gtk2)
	INTERFACE = status_gtk2.cma
	GRAPHICS := lablgtk.cma
	OCAML_INCLUDES := -I +lablgtk2 $(OCAML_INCLUDES)
endif
ifeq ($(USEINTERFACE), cocoa)
	INTERFACE = status_cocoa.cma
	CCOPT := -ccopt "-framework Cocoa" $(CCOPT)
endif

ifeq ($(USEINTERFACE), html)
	INTERFACE = status_html.cma
endif


ifeq ($(USEGRAPHICS), tk)
     GRAPHICS := labltk.cma $(GRAPHICS)
else
ifeq ($(USEGRAPHICS), ocaml)
     GRAPHICS := graphics.cma $(GRAPHICS)
endif
endif

ifeq ($(USEGRAPHICS), tk)
	LABLTK = -I +labltk
else
	LABLTK =
endif

PREPROCESSOR = -pp 'camlp4o pa_extend.cmo'


# Encapsulate all the options
DEFOPTS :=
ifeq ($(USEPARALLEL), true)
	DEFOPTS := $(DEFOPTS) -DUSEPARALLEL
ifeq ($(USENOSHAREDHD), true)
	DEFOPTS := $(DEFOPTS) -DUSENOSHAREDHD
endif
endif


ifeq ($(USEGRAPHICS), tk)
    DEFOPTS := $(DEFOPTS) -DUSEGRAPHICS=2
endif

ifeq ($(USEGRAPHICS), ocaml)
	DEFOPTS := $(DEFOPTS) -DUSEGRAPHICS=1
endif

NCURSES_LIBRARIES := 
ifeq ($(USEINTERFACE), ncurses)
	DEFOPTS := $(DEFOPTS) -DUSENCURSES
	NCURSES_LIBRARIES := -ccopt -lncurses -ccopt -lmenu
endif


ifeq ($(USEWIN32), true)
	DEFOPTS := $(DEFOPTS) -DUSEWIN32
endif

CPREPROCESSOR := -pp 'gcc -x c -E $(DEFOPTS)'


ifeq ($(USEWIN32), true)
	NCURSES_LIBRARIES :=
endif

SUBDIRS = grappa graphps

grappa/grappa.cmxa:
	$(MAKE) -C grappa grappa.cmxa

grappa/grappa.cma:
	$(MAKE) -C grappa grappa.cma

graphps/graphps.cmx: graphps/graphps.mli graphps/graphps.ml
	$(MAKE) -C graphps graphps.cmx

graphps/graphps.cmo: graphps/graphps.mli graphps/graphps.ml
	$(MAKE) -C graphps graphps.cmo

# run as "make target DEBUG=-g" to compile a debug executable
DEBUG = -g

all: mpoy.opt

# Useful groups of components
LANGUAGE = intSpec.cmo alphSpec.cmo wordSpec.cmo specIndex.cmo characSpec.cmo \
	hashedFuncs.cmo data.cmo poyParser.cmo

PARALLEL = methods.cmo 

# ftol.cmo register.cmo process.cmo comm.cmo parallel.cmo 

CHROM_OBJS = grappa/grappa.cma utl.cmo chromPam.cmo staMat.cmo utlPoy.cmo \
	utlGrappa.cmo incList.cmo sufNode.cmo sufTree.cmo subseq.cmo \
	seed.cmo block.cmo genAli.cmo aliMap.cmo chromAli.cmo chrom.cmo chromCS.cmo 


GENOME_OBJS = grappa/grappa.cma utl.cmo chromPam.cmo staMat.cmo utlPoy.cmo \
	utlGrappa.cmo genomeAli.cmo genome.cmo genomeCS.cmo


BREAKINV_OBJS = grappa/grappa.cma utl.cmo utlPoy.cmo \
	utlGrappa.cmo genAli.cmo breakinvAli.cmo breakinv.cmo breakinvCS.cmo

ANNCHROM_OBJS = grappa/grappa.cma utl.cmo utlPoy.cmo \
	utlGrappa.cmo genAli.cmo annchromAli.cmo annchrom.cmo annchromCS.cmo


CHARACTER = sleep.o timer.cmo array_ops.cmo char_add.cmo char_nonadd.cmo \
	sankCS.cmo seqCS.cmo chromCS.cmo genomeCS.cmo  breakinvCS.cmo annchromCS.cmo \
	dynamicCS.cmo nodeSig.cmo node.cmo allDirNode.cmo edge.cmo \
	characterScripting.cmo  metric.cmo

PARSER = parser.cmo $(LANGUAGE) 

ifeq ($(USEGRAPHICS), tk)
      TREEOUTPUT = asciiTree.cmo graphTree.cmo graphicTK.cmo graphicsPs.cmo
else 
ifeq ($(USEGRAPHICS), ocaml)
       TREEOUTPUT = asciiTree.cmo graphTree.cmo graphicsScreen.cmo graphicsPs.cmo	
else 
       TREEOUTPUT = asciiTree.cmo graphTree.cmo graphicsPs.cmo 
endif
endif

TREE = enum.cmo bitSet.cmo tree.cmo rtree.cmo hash_tbl.cmo gen_rtree.cmo \
	graphps/graphps.cmo $(TREEOUTPUT) ptree.cmo searchInformation.cmo \
	chartree.cmo sparceMatrix.cmo unionTree.cmo allDirChar.cmo sampler.cmo \
	queues.cmo tabus.cmo treeSearch.cmo impliedAlignment.cmo charTransform.cmo \
	mst.cmo build.cmo 

DISTANCE_LIBS = character.cmo addCS.cmo memstack.o add.o nonaddCS8.cmo \
	nonaddCSc8.o nonaddCS16.cmo nonaddCSc16.o nonaddCS32.cmo nonaddCSc32.o

SEQUENCE = all_sets.cmo alphabet.cmo cost_matrix.cmo matrix.cmo \
	primes.cmo fingerPrint.cmo sequence.cmo zarr.o avl.o algn.o

# Some personal tests that can be useful for everyone 
CAMLP4PROCESSED = poyParser.ml poyCommand.ml 

GETRUSAGE :=
ifeq ($(USEWIN32), false)
	GETRUSAGE := getrusage.o
endif

BASE_OBJS := sleep.o timer.cmo $(GETRUSAGE) compileFlags.cmo buildNumber.cmo \
	version.cmo sadmanlib.cma $(INTERFACE) \
	sexpr.cmo tags.cmo poyFormaters.cmo fileStream.cmo sequences.cma  \
	$(PARSER) distances.cma \
	$(CHROM_OBJS) $(BREAKINV_OBJS) $(ANNCHROM_OBJS) $(GENOME_OBJS) $(CHARACTER) trees.cma \
	diagnosis.cmo supports.cmo help.cmo helpIndex.cmo methods.cmo \
	analyzer.cmo poyCommand.cmo poyFile.cmo scripting.cmo 

MAIN_OBJS = $(BASE_OBJS) arguments.cmo compileFlags.cmo main.cmo

BASE_OBJS_OPT = $(patsubst %.cmo,%.cmx, $(patsubst %.cma,%.cmxa, $(BASE_OBJS)))

MAIN_OBJS_OPT = $(patsubst %.cmo,%.cmx, $(patsubst %.cma,%.cmxa, $(MAIN_OBJS)))

TEST_OBJS = $(BASE_OBJS) sadmanlib.cma test.cmo

TEST_OBJS_OPT = $(patsubst %.cmo,%.cmx, $(patsubst %.cma,%.cmxa, $(TEST_OBJS)))

UNIT_OBJS = $(BASE_OBJS) test_unit.cmo

SADMAN = sadmanOutput.cmo sadman.cmo

all_libs: status_ncurses.cma status_flat.cma sequences.cma distances.cma \
	trees.cma sadmanlib.cma sequences.cmxa distances.cmxa \
	trees.cmxa parsers.cmxa sadmanlib.cmxa

# If you keep a set of personal test programs and their make scripts,
# set them up in Makefile.local, don't add them on this Makefile directly. 
-include Makefile.local

clean:	
	rm -f *.annot *.cmi *.cmo *.cmx* *.o *.a *.so lparser.ml lparser.mli llexer.ml \
	mpoy_console mpoy mpoy.opt *.cma nonaddCS8.ml nonaddCS16.ml nonaddCS32.ml \
	nonaddCSc8.c nonaddCSc16.c nonaddCSc32.c mpoy.opt2 status.ml ocaml-str \
	$(LOCAL_CLEAN) 
	@for subs in $(SUBDIRS); do \
	  cd $$subs; \
	  $(MAKE) clean; \
	  cd ..; \
	done

sadmanOutput.cmo: compileFlags.cmo sadmanOutput.cmi 
sadmanOutput.cmx: compileFlags.cmx sadmanOutput.cmi 

depend: .depend

tags: otags ctags 

otags: *.ml
	otags -o otags $(filter-out poyParser.ml, $(wildcard *.ml))

ctags: *.c
	ctags -o ctags *.c

compileFlags.ml: ../config
	echo "(** automatically generated description of compile-time flags *)" \
	> $@
	echo >> $@
	echo "let cc = \"" `which gcc` `gcc --version` "\"" >> $@
	#echo "let ccopt = \"" $(CCOPT) "\"" >> $@
	echo "let ccopt = \"\"" >> $@
	echo "let ocamlc = \"" `which $(OCAMLC)` `$(OCAMLC) -version` "\"" \
	>> $@
	echo "let ocamlopt = \"" `which $(OCAMLOPT)` `$(OCAMLOPT) -version` \
	"\"" >> $@
	echo "let time = \"" `date -r` "\"" >> $@
	echo "let str_parallel = \"" `grep USEPARALLEL ../config` "\"" >> $@
	echo "let str_interface = \"" `grep USEINTERFACE ../config` "\"" >> $@
	echo "let str_graphics = \"" `grep USEGRAPHICS ../config` "\"" >> $@

# The libraries
status_ncurses.cma : dequeue.cmo status.cmi ncurses.o ncursesML.cmo \
	statusCommon.cmo status_ncurses.ml
	cp status_ncurses.ml status.ml
	$(OCAMLC) $(CCOPT) -custom -g -a -o $(@) $(NCURSES_LIBRARIES) ncurses.o \
	ncursesML.cmo dequeue.cmo statusCommon.cmo status.ml $(MKLIBOPT) $(PROFILE)

status_gtk2.cma: status.cmi statusCommon.cmo status_gtk2.ml
	cp status_gtk2.ml status.ml
	$(OCAMLC) -custom -g -a -o $@ -I +lablgtk2 statusCommon.cmo status.ml \
	$(MKLIBOPT) $(CCOPT) $(PROFILE)

status_cocoa.cma: status.cmi statusCommon.cmo status_cocoa.ml PoyStatus.o \
	PoyController.o CocoaCaml.o
	cp status_cocoa.ml status.ml
	$(OCAMLC) -custom -g -a -o $@ PoyStatus.o PoyController.o \
	CocoaCaml.o statusCommon.cmo status.ml $(MKLIBOPT) $(CCOPT) $(PROFILE)

status_html.cma: status.cmi statusCommon.cmo status_html.ml
	cp status_html.ml status.ml
	$(OCAMLC) -custom -g -a -o $@ statusCommon.cmo status.ml $(MKLIBOPT) \
	$(CCOPT) $(PROFILE)

status_flat.cma: status.cmi statusCommon.cmo status_flat.ml
	cp status_flat.ml status.ml
	$(OCAMLC) -custom -g -a -o $@ statusCommon.cmo status.ml $(MKLIBOPT) \
	$(CCOPT) $(PROFILE)

distances.cma: sequences.cma $(DISTANCE_LIBS)
	$(OCAMLC) $(OCAML_INCLUDES) -custom -a -o $@ $(^:sequences.cma=) $(MKLIBOPT) $(CCOPT)

parsers.cma : $(PARSER)
	$(OCAMLC) $(OCAML_INCLUDES) -custom -a -o $@ $^ $(MKLIBOPT) $(CCOPT)

trees.cma : $(CHARACTER) $(TREE)
	$(OCAMLC) $(OCAML_INCLUDES) -custom -a -o $@ $(MKLIBOPT) $(CCOPT) $(TREE)

sequences.cma: $(SEQUENCE)
	$(OCAMLC) $(OCAML_INCLUDES) -custom -a -o $@ $(^:methods.cmo=) $(MKLIBOPT) $(CCOPT)

sadmanlib.cma: $(SADMAN)
	$(OCAMLC) -a -o $@ $^ $(CCOPT) $(MKLIBOPT)

status_ncurses.cmxa : dequeue.cmx status.cmi ncurses.o ncursesML.cmx \
	statusCommon.cmx status_ncurses.ml
	cp status_ncurses.ml status.ml
	$(OCAMLOPT) $(CCOPT) -a -o $@ $(NCURSES_LIBRARIES) \
	ncurses.o dequeue.cmx ncursesML.cmx \
	statusCommon.cmx status.ml $(MKLIBOPT) $(PROFILE)

status_html.cmxa: status.cmi statusCommon.cmx status_html.ml
	cp status_html.ml status.ml
	$(OCAMLOPT) -a -o $@ statusCommon.cmx status.ml $(MKLIBOPT) \
	$(CCOPT) $(PROFILE)

status_flat.cmxa: status.cmi statusCommon.cmx status_flat.ml
	cp status_flat.ml status.ml
	$(OCAMLOPT) -a -o $@ statusCommon.cmx status.ml $(MKLIBOPT) \
	$(CCOPT) $(PROFILE)

status_gtk2.cmxa: status.cmi statusCommon.cmx status_gtk2.ml
	cp status_gtk2.ml status.ml
	$(OCAMLOPT) -a -o $@ -I +lablgtk2 statusCommon.cmx status.ml \
	$(MKLIBOPT) $(CCOPT) $(PROFILE)

status_cocoa.cmxa: status.cmi statusCommon.cmx status_cocoa.ml PoyStatus.o \
	PoyController.o CocoaCaml.o
	cp status_cocoa.ml status.ml
	$(OCAMLOPT) -a -o $@ PoyStatus.o PoyController.o \
	CocoaCaml.o statusCommon.cmx status.ml $(MKLIBOPT) $(CCOPT) $(PROFILE)


sequences.cmxa: $(SEQUENCE:.cmo=.cmx)
	$(OCAMLOPT) -a -o $@ $^ $(MKLIBOPT) $(CCOPT) $(PROFILE)

distances.cmxa: ${DISTANCE_LIBS:.cmo=.cmx}
	$(OCAMLOPT) -a -o $@ $^ $(MKLIBOPT) $(CCOPT) $(PROFILE)

parsers.cmxa : ${PARSER:.cmo=.cmx}
	$(OCAMLOPT) -a -o $@ $^ $(MKLIBOPT) $(CCOPT) $(PROFILE)

trees.cmxa : $(CHARACTER:.cmo=.cmx)  ${TREE:.cmo=.cmx}
	$(OCAMLOPT) $(OCAML_INCLUDES) -a -o $@ $(MKLIBOPT) $(CCOPT) ${TREE:.cmo=.cmx} $(PROFILE)

sadmanlib.cmxa: $(SADMAN:.cmo=.cmx)
	$(OCAMLOPT) -a -o $@ $^ $(MKLIBOPT) $(CCOPT) $(PROFILE)

.PHONY: subdirs $(SUBDIRS) clean driver doc buildNumber.ml

# -d .. puts stuff in prev directory
# -dot outputs dependency graph as .dot
FOR_DOC_FILES = $(filter-out $(wildcard $(CAMLP4PROCESSED:.ml=.mli)), $(wildcard *.mli)) \
	$(filter-out $(CAMLP4PROCESSED), $(wildcard *.ml))

doc: all_libs
	ocamldoc.opt -v -latex -keep-code -d ../doc/ -sort -stars $(OCAML_INCLUDES) \
	-colorize-code $(FOR_DOC_FILES) || true

graph: all_libs
	ocamldoc -v -dot -d ../doc/dependencies.dot $(OCAML_INCLUDES) \
	$(FOR_DOC_FILES) || true

subdirs: $(SUBDIRS)

# Poy language parser and lexer
lparser.mli lparser.ml: lparser.mly
	$(OCAMLYACC) -v lparser.mly

lparser.cmi lparser.cmo: lparser.ml lparser.mli
	$(OCAMLC) $(DEBUG) -c lparser.mli lparser.ml

lparser.cmx: lparser.ml lparser.mli
	$(OCAMLOPT) -c lparser.mli lparser.ml $(PROFILE) $(CCOPT)

llexer.ml: llexer.mll lparser.ml
	$(OCAMLLEX) llexer.mll

llexer.cmi llexer.cmo: llexer.ml
	$(OCAMLC) $(DEBUG) -c llexer.ml

llexer.cmx: llexer.ml
	$(OCAMLOPT) -c llexer.ml $(PROFILE) $(CCOPT)

parser.cmo: fileStream.cmo parser.cmi parser.ml 
	$(OCAMLC) $(OCAML_INCLUDES:-unsafe=) -c $(DEBUG:-unsafe=) parser.ml

parser.cmx: fileStream.cmx parser.ml 
	$(OCAMLOPT) $(OCAML_INCLUDES:-unsafe=) -c parser.ml $(PROFILE:-unsafe=) $(CCOPT:-unsafe)

status.cma status.cmxa: ../config

# All the libraries specialized for certain size in the character set.
# First we define the sed scripts that will replace the names with the
# approprate needs 
SED8 = sed "s/nonadd_/nonadd8_/g"
SED16 = sed "s/nonadd_/nonadd16_/g"
SED32 = sed "s/nonadd_/nonadd32_/g"

nonaddCS8.ml: nonaddCS.ml
	$(SED8) $< > $@

nonaddCS16.ml: nonaddCS.ml
	$(SED16) $< > $@

nonaddCS32.ml: nonaddCS.ml
	$(SED32) $< > $@

nonaddCSc8.o: nonaddCSc.c
	$(SED8) $< > ${@:.o=.c}
	$(OCAMLOPT) $(CCOPT) -ccopt -DCHARSIZE=8 -c -I $(INCLUDE) ${@:.o=.c} $(PROFILE)

nonaddCSc16.o: nonaddCSc.c
	$(SED16) $< > ${@:.o=.c}
	$(OCAMLOPT) $(CCOPT) -ccopt -DCHARSIZE=16 -c -I $(INCLUDE) ${@:.o=.c} $(PROFILE)

nonaddCSc32.o: nonaddCSc.c
	$(SED32) $< > ${@:.o=.c}
	$(OCAMLOPT) $(CCOPT) -ccopt -DCHARSIZE=32 -c -I $(INCLUDE) ${@:.o=.c} $(PROFILE)

add.o: memstack.o

# Help file gets made using OCaml script
help.txt: compileFlags.cmx sadmanOutput.cmx statusCommon.cmx \
	fileStream.cmx latex.ml ../doc/allcommands.tex
ifeq ($(USEPARALLEL), true)
	$(OCAMLOPT) $(OCAML_INCLUDES) $(CCOPT) -o latex_helper -cclib \
	-L$(OCAMLMPI) -cclib -l$(MPILNAME) \
	mpi.cmxa unix.cmxa compileFlags.cmx \
	sadmanOutput.cmx statusCommon.cmx fileStream.cmx latex.ml
else 
	$(OCAMLOPT) -o latex_helper unix.cmxa compileFlags.cmx \
	sadmanOutput.cmx statusCommon.cmx fileStream.cmx latex.ml
endif
	./latex_helper > help.txt 
	rm latex_helper

help.ml: help.txt ocaml-str helpRead.ml
	./ocaml-str
help.html: help.txt ocaml-str helpRead.ml
	./ocaml-str -html
# Static loading to support OS X and Cygwin...
ocaml-str:
	$(OCAMLC) str.cma helpRead.ml -o ocaml-str

# Poy Parser needs to be preprocessed and remove the unsafe option
poyParser.cmo: poyParser.ml
	ocamlc -g $(PREPROCESSOR:-unsafe=) $(OCAML_INCLUDES:-unsafe=) -c $<
poyCommand.cmo: poyCommand.ml
	ocamlc -g $(PREPROCESSOR:-unsafe=) $(OCAML_INCLUDES:-unsafe=) -c $<
poyParser.cmx: poyParser.ml
	$(OCAMLOPT) $(PREPROCESSOR:-unsafe=) $(OCAML_INCLUDES:-unsafe=) $(CCOPT:-unsafe=) -c $<
poyCommand.cmx: poyCommand.ml
	$(OCAMLOPT) $(PREPROCESSOR:-unsafe=) $(OCAML_INCLUDES:-unsafe=) $(CCOPT:-unsafe=) -c $<
poyParser.cma: poyParser.ml
	$(OCAMLC) -g $(PREPROCESSOR:-unsafe=) -I +camlp4 $(OCAML_INCLUDES:-unsafe=) -c $(DEBUG:-unsafe=) $<
status_gtk2.cmo: status_gtk2.ml
	$(OCAMLC) -g -I +lablgtk2 $(OCAML_INCLUDES) -c $(DEBUG) status_gtk2.ml
main.cmo: arguments.cmo main.ml
	$(OCAMLC) -g $(CPREPROCESSOR) $(OCAML_INCLUDES) -c $(DEBUG) main.ml
main.cmx: arguments.cmx main.ml
	$(OCAMLOPT) $(CPREPROCESSOR) $(OCAML_INCLUDES) -c main.ml
scripting.cmo: scripting.cmi scripting.ml
	$(OCAMLC)   $(CPREPROCESSOR) $(OCAML_INCLUDES) -c $(DEBUG) scripting.ml
scripting.cmx: scripting.cmi scripting.ml
	$(OCAMLOPT) $(CPREPROCESSOR) $(OCAML_INCLUDES) -c scripting.ml
timer.cmo: timer.cmi timer.ml
	$(OCAMLC)   $(CPREPROCESSOR) $(OCAML_INCLUDES) -c $(DEBUG) timer.ml
timer.cmx: timer.cmi timer.ml
	$(OCAMLOPT) $(CPREPROCESSOR) $(OCAML_INCLUDES) -c timer.ml
sampler.cmo: tree.cmi timer.cmi sequence.cmi ptree.cmi nodeSig.cmo edge.cmi \
    all_sets.cmi methods.cmi sampler.ml
	$(OCAMLC)   $(CPREPROCESSOR) $(OCAML_INCLUDES) -c $(DEBUG) sampler.ml
sampler.cmx: tree.cmx timer.cmx sequence.cmx ptree.cmx nodeSig.cmx edge.cmx \
    all_sets.cmx methods.cmx sampler.ml
	$(OCAMLOPT) $(CPREPROCESSOR) $(OCAML_INCLUDES) -c sampler.ml
fileStream.cmo: fileStream.ml
	$(OCAMLC)   $(CPREPROCESSOR) $(OCAML_INCLUDES) -c $(DEBUG) fileStream.ml
fileStream.cmx: fileStream.ml
	$(OCAMLOPT)   $(CPREPROCESSOR) $(OCAML_INCLUDES) -c fileStream.ml


# Generics for all the builds

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

CPREPROCESSED = fileStream.ml sampler.ml timer.ml scripting.ml main.ml
DOCFILTER = $(CAMLP4PROCESSED) $(CPREPROCESSED)

.depend: nonaddCS8.ml nonaddCS16.ml nonaddCS32.ml *.ml *.mli *.c *.h
	$(OCAMLDEP) $(OCAML_INCLUDES) \
	$(filter-out $(DOCFILTER), $(wildcard *.ml)) \
	$(filter-out $(DOCFILTER:.ml=.mli), $(wildcard *.mli)) > .depend 
	$(OCAMLDEP) $(PREPROCESSOR) $(CAMLP4PROCESSED) $(CAMLP4PROCESSED:.ml=.mli) >> .depend
	$(OCAMLDEP) $(CPREPROCESSOR) $(CPREPROCESSED) scripting.mli >> .depend
	$(OCAMLOPT) $(CCOPT) -ccopt -MM *.c >> .depend

ultrametric.cmo: status.cmi ultrametric.cmi ultrametric.ml
	ocamlfind ocamlc -v -g ultrametric.ml -package ocamlgraph -linkpkg
ultrametric.cmx: status.cmx ultrametric.cmi ultrametric.ml
	ocamlfind ocamlopt -v ultrametric.ml -package ocamlgraph -linkpkg

.ml.cmo:
	$(OCAMLC) $(OCAML_INCLUDES) -c $(DEBUG) $<

.ml.cma:
	$(OCAMLC) -I +camlp4 $(OCAML_INCLUDES) -c $(DEBUG) $<

.ml.cmx:
	$(OCAMLOPT) $(OCAML_INCLUDES) $(CCOPT) -c $< $(PROFILE)

.mli.cmi:
	$(OCAMLC) $(OCAML_INCLUDES) $(DEBUG) $<

.m.o:
	$(CC) -I `$(OCAMLC) -where` -c -framework Cocoa $< 

.c.o:
	$(OCAMLOPT) $(CCOPT) -c -I $(INCLUDE) $< $(PROFILE)

mpoy: $(MAIN_OBJS)
ifeq ($(USEPARALLEL), true)
	$(OCAMLC) -custom $(OCAML_INCLUDES) -cc mpicc -cclib -L$(OCAMLMPI) \
		-cclib -l$(MPILNAME) $(OCAMLMPI)/mpi.cma -cclib -l$(MPILNAME) \
		-cclib -lcamlgrappa $(CCOPT) $(DEBUG) -ccopt -L./ -o mpoy \
		$(GRAPHICS) camlp4.cma unix.cma str.cma bigarray.cma $^
else
		$(OCAMLC) -custom $(OCAML_INCLUDES) -cclib -L$(OCAMLMPI) \
		-cclib -lcamlgrappa $(CCOPT) $(DEBUG) -ccopt -L./ -o mpoy \
		$(GRAPHICS) camlp4.cma unix.cma str.cma bigarray.cma $^
endif


mpoy.opt: $(MAIN_OBJS_OPT)
ifeq ($(USEPARALLEL), true)
	$(OCAMLOPT) $(PREPROCESSOR) $(OCAML_INCLUDES) -cclib -L./grappa \
	-cclib -L./graphps -cclib -L./ \
	-cclib -L$(OCAMLMPI) $(CCOPT) $(NCURSES_LIBRARIES) $(PROFILE) \
	-cclib -l$(MPILNAME) -cclib -lcamlgrappa -o $@ mpi.cmxa $(GRAPHICS:.cma=.cmxa) camlp4.cmxa \
	unix.cmxa str.cmxa bigarray.cmxa $^
else
	$(OCAMLOPT) $(PREPROCESSOR) $(OCAML_INCLUDES) -verbose -ccopt -v -cclib -L./grappa \
	-cclib  -L/usr/lib -cclib -L./graphps -cclib -L./  \
	$(CCOPT) -cclib -lcamlgrappa $(NCURSES_LIBRARIES) $(PROFILE) -o mpoy.opt \
	$(GRAPHICS:.cma=.cmxa) camlp4.cmxa unix.cmxa str.cmxa bigarray.cmxa $^
endif

# Interactive console to test various features
#mpoy_console: sequences.cma parsers.cma distances.cma trees.cma 
mpoy_console: $(BASE_OBJS) scripting.cmo 
ifeq ($(USEPARALLEL), true)
	$(OCAMLTOP) $(PREPROCESSOR) $(OCAML_INCLUDES) -cc mpicc -cclib -L./ \
	-I $(OCAMLMPI) -cclib -L./grappa -cclib -L./graphps -custom -cclib \
	-L$(OCAMLMPI) $(CCOPT) $(PROFILE) \
	-cclib -l$(MPILNAME) -cclib -lcamlgrappa -o $@ mpi.cma $(GRAPHICS) camlp4o.cma unix.cma str.cma \
	bigarray.cma $^
else
	$(OCAMLTOP) $(CCOPT) $(PREPROCESSOR) $(OCAML_INCLUDES) -o $@ -cclib -L./grappa \
	-cclib -L./graphps -cclib -L./ -cclib -lcamlgrappa $(GRAPHICS) unix.cma camlp4o.cma str.cma \
	bigarray.cma $^
endif