#################################################################################
#                Cameleon                                                       #
#                                                                               #
#    Copyright (C) 2004-2008 Institut National de Recherche en Informatique     #
#    et en Automatique. All rights reserved.                                    #
#                                                                               #
#    This program is free software; you can redistribute it and/or modify       #
#    it under the terms of the GNU Library General Public License as            #
#    published by the Free Software Foundation; either version 2 of the         #
#    License, or any later version.                                             #
#                                                                               #
#    This program is distributed in the hope that it will be useful,            #
#    but WITHOUT ANY WARRANTY; without even the implied warranty of             #
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
#    GNU Library General Public License for more details.                       #
#                                                                               #
#    You should have received a copy of the GNU Library General Public          #
#    License along with this program; if not, write to the Free Software        #
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA                   #
#    02111-1307  USA                                                            #
#                                                                               #
#    Contact: Maxence.Guesdon@inria.fr                                          #
#                                                                               #
#################################################################################

include ../master.Makefile

SYSTEM_INCLUDES= \
	-I +threads \
	-I +ocamldoc \
	-I ocaml/parsing \
	-I ocaml/typing \
	$(OCAML_DRIVER_INCLUDES) \
	-I ocaml/utils \
	$(PCRE_INCLUDES) \
	$(LABLGTK2_INCLUDES) \
	$(LABLGTKSOURCEVIEW_INCLUDES) \
	$(XMLLIGHT_INCLUDES)

MY_INCLUDES= \
	-I odot \
	-I okey \
	-I utils \
	-I odiff \
	-I tdl \
	-I rss \
	-I tmpl-engine \
	-I sqml \
	-I config_file \
	-I configwin \
	-I gtksv-utils \
	-I report \
	-I dbforge \
	-I ocamlcvs \
	-I editor \
	-I cameleon \
	-I camtop \
	-I custop \
	-I multiclip \
	-I plugins \
	-I snippets

INCLUDES= \
	$(SYSTEM_INCLUDES) \
	$(MY_INCLUDES)

MKCHAMO_INCLUDES= \
	-I +threads \
	-I +ocamldoc \
	$(OCAML_DRIVER_INCLUDES) \
	-I $(LIBDIR) \
	$(PCRE_INCLUDES) \
	$(LABLGTK2_INCLUDES) \
	$(LABLGTKSOURCEVIEW_INCLUDES) \
	$(XMLLIGHT_INCLUDES)

COMPFLAGS=$(INCLUDES)
LINKFLAGS=$(INCLUDES)
LINKFLAGS_BYTE=$(INCLUDES)

#OCAMLPP=-pp "$(OCAMLBIN)/camlp4o "

TOOLS=$(REPORT) $(REPORT_GUI) $(TMPL_ENGINE) \
	$(DBFORGE) $(DBFORGE_GUI) \
	$(OCAMLCVS) $(TDL) $(TDL_EXPORT) $(TDL_HTML) $(TDL_SVN) \
	$(RSS) $(RSS_EXPORT)\
	$(EDITOR) $(CAMELEON) $(CAM_CONFIG) $(DOCBROWSER)
TOOLS_BYTE=$(REPORT_BYTE) $(REPORT_GUI_BYTE) \
	$(TMPL_ENGINE_BYTE) \
	$(DBFORGE_BYTE) $(DBFORGE_GUI_BYTE) \
	$(OCAMLCVS_BYTE) \
	$(TDL_BYTE) $(TDL_EXPORT_BYTE) $(TDL_HTML_BYTE) $(TDL_SVN_BYTE) \
	$(RSS_BYTE) $(RSS_EXPORT_BYTE) \
	$(EDITOR_BYTE) $(CAMELEON_BYTE) $(CAM_CONFIG_BYTE) $(DOCBROWSER_BYTE) $(CAMTOP)

ifeq ($(USE_LABLGTKSOURCEVIEW),yes)
GTKSV_UTILS_CMX=gtksv-utils/gtksv_utils.cmx
GTKSV_UTILS_CMO=gtksv-utils/gtksv_utils.cmo
endif

UTILS=utils/gstuff.cmx \
	utils/gmylist.cmx \
	utils/gmytree.cmx \
	utils/gdir.cmx \
	utils/ffind.cmx \
	utils/dtypes.cmx \
	$(GTKSV_UTILS_CMX)
UTILS_BYTE=utils/gstuff.cmo \
	utils/gmylist.cmo \
	utils/gmytree.cmo \
	utils/gdir.cmo \
	utils/ffind.cmo \
	utils/dtypes.cmo \
	$(GTKSV_UTILS_CMO)

PLUGINS=plugins/test.cmo plugins/dep_view.cma

# Compilation
#############

# Cameleon
# files shared with editor
CAMELEON_SHARED_CMOFILES=\
	cameleon/cam_messages.cmo \
	cameleon/cam_config.cmo \
	cameleon/cam_dbg.cmo \
	cameleon/cam_misc.cmo \
	cameleon/cam_constant.cmo \
	cameleon/cam_rc.cmo \
	cameleon/cam_com_history.cmo \
	cameleon/cam_hooks.cmo \
	cameleon/cam_commands.cmo \
	cameleon/cam_log.cmo \
	cameleon/cam_args.cmo

CAMELEON_COMMON_CMOFILES=\
	$(EDITOR_COMMON_CMOFILES) \
	cameleon/cam_chamo.cmo \
	cameleon/cam_gui_base.cmo \
	cameleon/cam_gui.cmo \
	cameleon/cam_keymaps.cmo \
	cameleon/cam_view.cmo \
	cameleon/cam_dir_view.cmo \
	cameleon/cam_doc.cmo \
	cameleon/cam_doc_gui.cmo

PRE_CAMELEON_CMOFILES=$(CAMELEON_COMMON_CMOFILES) \
	cameleon/cam_minibuffer.cmo \
	cameleon/cam_files.cmo \
	cameleon/cam_cvs_view.cmo \
	cameleon/cam_files_view.cmo \
	cameleon/cam_modules_view.cmo \
	cameleon/cam_multiview.cmo \
	cameleon/cam_bbar.cmo \
	cameleon/cam_new_project.cmo \
	cameleon/cam_menus.cmo \
	cameleon/cam_server.cmo \
	cameleon/cam_plug.cmo \
	cameleon/cam_rss.cmo

CAMELEON_CMOFILES=$(PRE_CAMELEON_CMOFILES) \
	editor/ed_eval.cmo \
	cameleon/cam_plugins.cmo \
	cameleon/cam_main.cmo

CAMELEON_CMXFILES=$(PRE_CAMELEON_CMOFILES:.cmo=.cmx) \
	cameleon/cam_main.cmx

CAMELEON_CMIFILES= $(CAMELEON_CMOFILES:.cmo=.cmi)

CAM_CONFIG_CMOFILES=\
	cameleon/cam_installation.cmo \
	cameleon/cam_config.cmo \
	cameleon/cam_config_main.cmo

CAM_CONFIG_CMXFILES=$(CAM_CONFIG_CMOFILES:.cmo=.cmx)
CAM_CONFIG_CMIFILES=$(CAM_CONFIG_CMOFILES:.cmo=.cmi)

DOCBROWSER_CMOFILES=$(CAMELEON_COMMON_CMOFILES) \
	cameleon/cam_docbrowser.cmo

DOCBROWSER_CMXFILES= $(DOCBROWSER_CMOFILES:.cmo=.cmx)
DOCBROWSER_CMIFILES= $(DOCBROWSER_CMOFILES:.cmo=.cmi)

# Editor

EDITOR_COMMON_CMOFILES=\
	utils/dtypes.cmo \
	$(CAMELEON_SHARED_CMOFILES) \
	editor/ed_config.cmo \
	editor/ed_messages.cmo \
	editor/ed_prefs.cmo \
	editor/ed_gui_base.cmo \
	editor/ed_keymaps.cmo \
	editor/ed_gui_rc.cmo \
	editor/ed_bookmarks.cmo \
	editor/ed_fstack.cmo \
	editor/ed_sourceview_rc.cmo \
	editor/ed_minibuffer_rc.cmo \
	editor/ed_minibuffer.cmo \
	editor/ed_charsets.cmo \
	editor/ed_core_rc.cmo \
	editor/ed_outputs.cmo \
	editor/ed_misc.cmo \
	editor/ed_view_rc.cmo \
	editor/ed_view.cmo \
	editor/ed_multiclip_rc.cmo \
	editor/ed_multiclip.cmo \
	editor/ed_odoc_rc.cmo \
	editor/ed_odoc.cmo \
	editor/ed_tdl_rc.cmo \
	editor/ed_tdl.cmo \
	editor/ed_sourceview.cmo \
	editor/ed_sourceview_expand.cmo \
	editor/ed_ocamloutput.cmo \
	editor/ed_ocaml_lexer.cmo \
	editor/ed_mode_ocaml_rc.cmo \
	editor/ed_ocamlbuild.cmo \
	editor/ed_mode_ocaml.cmo \
	editor/ed_mode_makefile_rc.cmo \
	editor/ed_mode_makefile.cmo \
	editor/ed_mode_changelog_rc.cmo \
	editor/ed_mode_changelog.cmo \
	editor/ed_gui.cmo \
	editor/ed_layout.cmo

EDITOR_COMMON_CMIFILES=$(EDITOR_COMMON_CMOFILES:.cmo=.cmi)
EDITOR_COMMON_CMXFILES=$(EDITOR_COMMON_CMOFILES:.cmo=.cmx)

EDITOR_CMOFILES=$(EDITOR_COMMON_CMOFILES) \
	editor/ed_eval.cmo \
	editor/ed_main.cmo
EDITOR_CMXFILES=$(EDITOR_COMMON_CMOFILES:.cmo=.cmx) editor/ed_main.cmx
EDITOR_CMIFILES=$(EDITOR_COMMON_CMOFILES:.cmo=.cmi) editor/ed_main.cmi

LIBEDITOR=editor/chamo.cmxa
LIBEDITOR_A=$(LIBEDITOR:.cmxa=.a)

EDITOR_LIBS=$(LIBEDITOR) $(LIBEDITOR_A)

EDITOR_LINK_LIBS=str.cmxa unix.cmxa threads.cmxa xml-light.cmxa \
	lablgtk.cmxa lablglade.cmxa gtkThread.cmx gtkInit.cmx \
	okey.cmx config_file.cmx configwin.cmxa \
	utils/gmylist.cmx utils/gmytree.cmx \
	multiclip/multiclip.cmx multiclip/multiclip_gui.cmx \
	cameleon/cam_installation.cmx \
	tdl.cmxa tdl_gui.cmxa lablgtksourceview.cmxa \
	gtksv-utils/gtksv_utils.cmx odoc_info.cmxa \
	pcre.cmxa
EDITOR_LINK_LIBS_BYTE=str.cma unix.cma threads.cma xml-light.cma \
	toplevellib.cma \
	lablgtk.cma lablglade.cma gtkThread.cmo gtkInit.cmo \
	okey.cmo config_file.cmo configwin.cma \
	utils/gmylist.cmo utils/gmytree.cmo \
	multiclip/multiclip.cmo multiclip/multiclip_gui.cmo \
	cameleon/cam_installation.cmo \
	tdl.cma tdl_gui.cma lablgtksourceview.cma \
	gtksv-utils/gtksv_utils.cmo odoc_info.cma \
	pcre.cma
MKCHAMO_LINK_LIBS=str.cmxa unix.cmxa threads.cmxa xml-light.cmxa \
	lablgtk.cmxa lablglade.cmxa gtkThread.cmx gtkInit.cmx \
	okey.cmx config_file.cmx configwin.cmxa \
	gmylist.cmx gmytree.cmx \
	multiclip.cmx multiclip_gui.cmx \
	cam_installation.cmx \
	tdl.cmxa tdl_gui.cmxa lablgtksourceview.cmxa \
	gtksv_utils.cmx odoc_info.cmxa \
	pcre.cmxa

MKCHAMO_SCRIPT=editor/make_my_chamo
# Okey

LIBOKEY=okey/okey.cmx
LIBOKEY_BYTE=$(LIBOKEY:.cmx=.cmo)
LIBOKEY_CMI=$(LIBOKEY:.cmx=.cmi)
LIBOKEY_O=$(LIBOKEY:.cmx=.o)

OKEY_LIBS=$(LIBOKEY) $(LIBOKEY_BYTE) $(LIBOKEY_CMI) $(LIBOKEY_O)

# Odot

LIBODOT=odot/odot.cmxa
LIBODOT_BYTE=$(LIBODOT:.cmxa=.cma)
LIBODOT_CMI=$(LIBODOT:.cmxa=.cmi)
LIBODOT_A=$(LIBODOT:.cmxa=.a)
LIBODOT_VIEW=odot/odot_view.cmx
LIBODOT_VIEW_BYTE=$(LIBODOT_VIEW:.cmx=.cmo)
LIBODOT_VIEW_CMI=$(LIBODOT_VIEW:.cmx=.cmi)
LIBODOT_VIEW_O=$(LIBODOT_VIEW:.cmx=.o)
ODOT_LIBS=$(LIBODOT) $(LIBODOT_BYTE) $(LIBODOT_CMI) $(LIBODOT_A) \
	$(LIBODOT_VIEW) $(LIBODOT_VIEW_BYTE) $(LIBODOT_VIEW_CMI) $(LIBODOT_VIEW_O)



# Config_file

LIBCF=config_file/config_file.cmx
LIBCF_BYTE=$(LIBCF:.cmx=.cmo)
LIBCF_CMI=$(LIBCF:.cmx=.cmi)
LIBCF_O=$(LIBCF:.cmx=.o)

CF_LIBS=$(LIBCF) $(LIBCF_BYTE) $(LIBCF_CMI) $(LIBCF_O)

# Configwin

CW_COMMON_CMOFILES=\
	configwin/configwin_keys.cmo \
	configwin/configwin_types.cmo \
	configwin/configwin_messages.cmo \
	configwin/configwin_ihm.cmo

LIBCW_CMOFILES=$(CW_COMMON_CMOFILES) configwin/configwin.cmo
LIBCW_CMIFILES=$(LIBCW_CMOFILES:.cmo=.cmi)
LIBCW_CMXFILES=$(LIBCW_CMOFILES:.cmo=.cmx)

LIBCW=configwin/configwin.cmxa
LIBCW_BYTE=$(LIBCW:.cmxa=.cma)
LIBCW_CMI=$(LIBCW:.cmxa=.cmi)
LIBCW_A=$(LIBCW:.cmxa=.a)

CW_LIBS=$(LIBCW) $(LIBCW_BYTE) $(LIBCW_CMI) $(LIBCW_A)

# Tdl

TDL_COMMON_CMOFILES=\
	tdl/tdl_messages.cmo \
	tdl/tdl_date.cmo \
	tdl/tdl_types.cmo \
	tdl/tdl_io.cmo \
	tdl/tdl_filter.cmo \
	tdl/tdl_filter_parser.cmo \
	tdl/tdl_filter_lexer.cmo \
	tdl/tdl.cmo

LIBTDL_CMOFILES=$(TDL_COMMON_CMOFILES)
LIBTDL_CMIFILES=$(LIBTDL_CMOFILES:.cmo=.cmi)
LIBTDL_CMXFILES=$(LIBTDL_CMOFILES:.cmo=.cmx)

TDL_EXPORT_CMOFILES=tdl/tdl_export.cmo
TDL_EXPORT_CMIFILES=$(TDL_EXPORT_CMOFILES:.cmo=.cmi)
TDL_EXPORT_CMXFILES=$(TDL_EXPORT_CMOFILES:.cmo=.cmx)

TDL_SVN_CMOFILES=tdl/tdl_svn.cmo
TDL_SVN_CMIFILES=$(TDL_SVN_CMOFILES:.cmo=.cmi)
TDL_SVN_CMXFILES=$(TDL_SVN_CMOFILES:.cmo=.cmx)

TDL_HTML_CMOFILES=tdl/tdl2html.cmo
TDL_HTML_CMIFILES=$(TDL_HTML_CMOFILES:.cmo=.cmi)
TDL_HTML_CMXFILES=$(TDL_HTML_CMOFILES:.cmo=.cmx)

LIBTDL=tdl/tdl.cmxa
LIBTDL_BYTE=$(LIBTDL:.cmxa=.cma)
LIBTDL_CMI=$(LIBTDL:.cmxa=.cmi)
LIBTDL_A=$(LIBTDL:.cmxa=.a)

LIBTDL_GUI_CMOFILES=\
	tdl/tdl_gui_rc.cmo \
	tdl/tdl_gui_base.cmo \
	tdl/tdl_gui.cmo
LIBTDL_GUI_CMIFILES=$(LIBTDL_GUI_CMOFILES:.cmo=.cmi)
LIBTDL_GUI_CMXFILES=$(LIBTDL_GUI_CMOFILES:.cmo=.cmx)

LIBTDL_GUI=tdl/tdl_gui.cmxa
LIBTDL_GUI_BYTE=$(LIBTDL_GUI:.cmxa=.cma)
LIBTDL_GUI_CMI=$(LIBTDL_GUI:.cmxa=.cmi)
LIBTDL_GUI_A=$(LIBTDL_GUI:.cmxa=.a)

TDL_CMOFILES=tdl/tdl_main.cmo
TDL_CMIFILES=$(TDL_CMOFILES:.cmo=.cmi)
TDL_CMXFILES=$(TDL_CMOFILES:.cmo=.cmx)

ODOC_TDL_CMOFILES=$(TDL_COMMON_CMOFILES) tdl/odoc_tdl.cmo
ODOC_TDL=tdl/odoc_tdl.cma
ODOC_TDL_CMI=$(ODOC_TDL:.cma=.cmi)

TDL_LIBS=$(LIBTDL) $(LIBTDL_BYTE) $(LIBTDL_CMI) $(LIBTDL_A) \
	$(LIBTDL_GUI) $(LIBTDL_GUI_BYTE) $(LIBTDL_GUI_CMI) $(LIBTDL_GUI_A)

# RSS

RSS_COMMON_CMOFILES=\
	rss/rss_messages.cmo \
	rss/rss_date.cmo \
	rss/rss_types.cmo \
	rss/rss_io.cmo \
	rss/rss.cmo

LIBRSS_CMOFILES=$(RSS_COMMON_CMOFILES)
LIBRSS_CMIFILES=$(LIBRSS_CMOFILES:.cmo=.cmi)
LIBRSS_CMXFILES=$(LIBRSS_CMOFILES:.cmo=.cmx)

LIBRSS=rss/rss.cmxa
LIBRSS_BYTE=$(LIBRSS:.cmxa=.cma)
LIBRSS_CMI=$(LIBRSS:.cmxa=.cmi)
LIBRSS_A=$(LIBRSS:.cmxa=.a)

LIBRSS_GUI_CMOFILES=\
	rss/rss_gui_base.cmo \
	rss/rss_gui.cmo
LIBRSS_GUI_CMIFILES=$(LIBRSS_GUI_CMOFILES:.cmo=.cmi)
LIBRSS_GUI_CMXFILES=$(LIBRSS_GUI_CMOFILES:.cmo=.cmx)

LIBRSS_GUI=rss/rss_gui.cmxa
LIBRSS_GUI_BYTE=$(LIBRSS_GUI:.cmxa=.cma)
LIBRSS_GUI_CMI=$(LIBRSS_GUI:.cmxa=.cmi)
LIBRSS_GUI_A=$(LIBRSS_GUI:.cmxa=.a)

RSS_CMOFILES=rss/rss_gui_main.cmo
RSS_CMIFILES=$(RSS_CMOFILES:.cmo=.cmi)
RSS_CMXFILES=$(RSS_CMOFILES:.cmo=.cmx)

RSS_EXPORT_CMOFILES=rss/rss_export.cmo
RSS_EXPORT_CMIFILES=$(RSS_EXPORT_CMOFILES:.cmo=.cmi)
RSS_EXPORT_CMXFILES=$(RSS_EXPORT_CMOFILES:.cmo=.cmx)

RSS_LIBS=$(LIBRSS) $(LIBRSS_BYTE) $(LIBRSS_CMI) $(LIBRSS_A) \
	$(LIBRSS_GUI) $(LIBRSS_GUI_BYTE) $(LIBRSS_GUI_CMI) $(LIBRSS_GUI_A)


# Tmpl-engine

TMPL_COMMON_CMOFILES=\
	tmpl-engine/template.cmo \
	tmpl-engine/tmplParser.cmo \
	tmpl-engine/tmplLexer.cmo \
	tmpl-engine/tmplIO.cmo


TMPL_CMOFILES=$(TMPL_COMMON_CMOFILES) \
	tmpl-engine/main.cmo
TMPL_CMXFILES= $(TMPL_CMOFILES:.cmo=.cmx)
TMPL_CMIFILES= $(TMPL_CMOFILES:.cmo=.cmi)

TMPL_LIB_CMOFILES=$(TMPL_COMMON_CMOFILES)
TMPL_LIB_CMXFILES= $(TMPL_LIB_CMOFILES:.cmo=.cmx)
TMPL_LIB_CMIFILES= $(TMPL_LIB_CMOFILES:.cmo=.cmx)

LIBTMPL=tmpl-engine/tmpl-engine.cmxa
LIBTMPL_BYTE=$(LIBTMPL:.cmxa=.cma)
LIBTMPL_CMI=$(LIBTMPL:.cmxa=.cmi)
LIBTMPL_A=$(LIBTMPL:.cmxa=.a)

TMPL_LIBS=$(LIBTMPL) $(LIBTMPL_BYTE) $(LIBTMPL_A) #$(LIBTMPL_CMI)

# SQML

SQML_CMOFILES=\
	sqml/sqml_sqlstx.cmo \
	sqml/sqml_helper_lp.cmo \
	sqml/sqml_parser.cmo \
	sqml/sqml_lexer.cmo \
	sqml/sqml_pp.cmo \
	sqml/sqml.cmo

SQML_CMXFILES= $(SQML_CMOFILES:.cmo=.cmx)
SQML_CMIFILES= $(SQML_CMOFILES:.cmo=.cmi)

LIBSQML=sqml/sqml.cmxa
LIBSQML_BYTE=$(LIBSQML:.cmxa=.cma)
LIBSQML_CMI=$(LIBSQML:.cmxa=.cmi)
LIBSQML_A=$(LIBSQML:.cmxa=.a)

SQML_LIBS=$(LIBSQML) $(LIBSQML_BYTE) $(LIBSQML_A) $(LIBSQML_CMI)

# Report

REPORT_COMMON_CMOFILES=\
	report/rep_installation.cmo \
	report/rep_messages.cmo \
	report/rep_misc.cmo \
	report/rep_args.cmo \
	report/rep_desc.cmo \
	report/rep_buffer.cmo \
	report/rep_types.cmo \
	report/rep_io.cmo \
	report/rep_gen.cmo


REPORT_CMOFILES=$(REPORT_COMMON_CMOFILES) \
	report/rep_gen_code.cmo \
	report/rep_main.cmo
REPORT_CMXFILES= $(REPORT_CMOFILES:.cmo=.cmx)
REPORT_CMIFILES= $(REPORT_CMOFILES:.cmo=.cmi)

REPORT_GUI_CMOFILES=$(REPORT_COMMON_CMOFILES) \
	report/rep_gui_base.cmo \
	report/rep_gui.cmo \
	report/rep_gui_main.cmo
REPORT_GUI_CMXFILES= $(REPORT_GUI_CMOFILES:.cmo=.cmx)
REPORT_GUI_CMIFILES= $(REPORT_GUI_CMOFILES:.cmo=.cmi)

REPORT_LIB_CMOFILES=$(REPORT_COMMON_CMOFILES) \
	report/report.cmo
REPORT_LIB_CMXFILES= $(REPORT_LIB_CMOFILES:.cmo=.cmx)
REPORT_LIB_CMIFILES= $(REPORT_LIB_CMOFILES:.cmo=.cmi)

REPORT_LIB_GUI_CMOFILES=$(REPORT_COMMON_CMOFILES) \
	report/rep_gui_base.cmo \
	report/rep_gui.cmo \
	report/report_gui.cmo
REPORT_LIB_GUI_CMXFILES=$(REPORT_LIB_GUI_CMOFILES:.cmo=.cmx)
REPORT_LIB_GUI_CMIFILES=$(REPORT_LIB_GUI_CMOFILES:.cmo=.cmi)

LIBREPORT=report/report.cmxa
LIBREPORT_BYTE=$(LIBREPORT:.cmxa=.cma)
LIBREPORT_CMI=$(LIBREPORT:.cmxa=.cmi)
LIBREPORT_A=$(LIBREPORT:.cmxa=.a)

LIBREPORT_GUI=report/report_gui.cmxa
LIBREPORT_GUI_BYTE=$(LIBREPORT_GUI:.cmxa=.cma)
LIBREPORT_GUI_CMI=$(LIBREPORT_GUI:.cmxa=.cmi)
LIBREPORT_GUI_A=$(LIBREPORT_GUI:.cmxa=.a)

REPORT_LIBS=$(LIBREPORT) $(LIBREPORT_BYTE) $(LIBREPORT_CMI) $(LIBREPORT_A) \
	$(LIBREPORT_GUI) $(LIBREPORT_GUI_BYTE) $(LIBREPORT_GUI_CMI) $(LIBREPORT_GUI_A)

# Topcameleon

CAMTOP_COMMON_CMOFILES=\
	cameleon/cam_installation.cmo \
	cameleon/cam_messages.cmo \
	camtop/$(CAMTOP_SOURCEVIEW_MODULE_CMO) \
	camtop/camtop_installation.cmo \
	camtop/camtop_messages.cmo \
	camtop/camtop_outvalue.cmo \
	camtop/camtop_toplevel_base.cmo

CAMTOP_CMOFILES=$(CAMTOP_COMMON_CMOFILES)\
	camtop/camtop_toplevel.cmo
CAMTOP_CMI=camtop/camtop_toplevel.cmi
CAMTOP_CMO=$(CAMTOP_CMI:.cmi=.cmo)
CAMTOP_CMIFILES= $(CAMTOP_CMOFILES:.cmo=.cmi)

CAMTOP_LIB_CMOFILES=$(CAMTOP_COMMON_CMOFILES)

CAMTOP_LIB_CMIFILES= $(CAMTOP_LIB_CMOFILES:.cmo=.cmi)

LIBCAMTOP_BYTE=camtop/topcameleon.cma
LIBCAMTOP_CMI=$(LIBCAMTOP_BYTE:.cma=.cmi)

CAMTOP_LIBS=$(LIBCAMTOP_BYTE) $(LIBCAMTOP_CMI) $(CAMTOP_CMO)

# DBForge

DBFORGE_COMMON_CMOFILES=\
	dbforge/dbf_installation.cmo \
	dbforge/dbf_misc.cmo \
	dbforge/dbf_sql.cmo \
	dbforge/dbf_sql_gen.cmo \
	dbforge/dbf_sql_vgen.cmo \
	dbforge/dbf_sql_qgen.cmo \
	dbforge/dbf_sql_io.cmo

DBFORGE_COMMON_CMIFILES= $(DBFORGE_COMMON_CMOFILES:.cmo=.cmi)
DBFORGE_COMMON_CMXFILES= $(DBFORGE_COMMON_CMOFILES:.cmo=.cmx)

DBFORGE_COMMON_GUI_CMOFILES=$(DBFORGE_COMMON_CMOFILES) \
	dbforge/dbf_gtk2Misc.cmo \
	dbforge/dbf_gladeWidgets.cmo \
	dbforge/dbf_dbStores.cmo \
	dbforge/dbf_selectWidget.cmo \
	dbforge/dbf_dbWidget.cmo \
	dbforge/dbf_columnGUI.cmo \
	dbforge/dbf_indexGUI.cmo \
	dbforge/dbf_virtualTableGUI.cmo \
	dbforge/dbf_tableGUI.cmo \
	dbforge/dbf_queryGUI.cmo \
	dbforge/dbf_gui.cmo

DBFORGE_CMOFILES= $(DBFORGE_COMMON_CMOFILES)\
	dbforge/dbf_old.cmo \
	dbforge/dbf_dbforge.cmo
DBFORGE_CMXFILES= $(DBFORGE_CMOFILES:.cmo=.cmx)
DBFORGE_CMIFILES= $(DBFORGE_CMOFILES:.cmo=.cmi)

DBFORGE_GUI_CMOFILES=$(DBFORGE_COMMON_GUI_CMOFILES) \
	dbforge/dbf_main.cmo
DBFORGE_GUI_CMXFILES= $(DBFORGE_GUI_CMOFILES:.cmo=.cmx)
DBFORGE_GUI_CMIFILES= $(DBFORGE_GUI_CMOFILES:.cmo=.cmi)

DBFORGE_LIB_GUI_CMOFILES=$(DBFORGE_COMMON_GUI_CMOFILES) \
	dbforge/dbforge_gui.cmo

DBFORGE_LIB_GUI_CMXFILES=$(DBFORGE_LIB_GUI_CMOFILES:.cmo=.cmx)
DBFORGE_LIB_GUI_CMIFILES=$(DBFORGE_LIB_GUI_CMOFILES:.cmo=.cmi)

LIBDBFORGE_CORE=dbforge/dbforge.cmxa
LIBDBFORGE_CORE_BYTE=$(LIBDBFORGE_CORE:.cmxa=.cma)
LIBDBFORGE_CORE_A=$(LIBDBFORGE_CORE:.cmxa=.a)

LIBDBFORGE_GUI=dbforge/dbforge_gui.cmxa
LIBDBFORGE_GUI_BYTE=$(LIBDBFORGE_GUI:.cmxa=.cma)
LIBDBFORGE_GUI_CMI=$(LIBDBFORGE_GUI:.cmxa=.cmi)
LIBDBFORGE_GUI_A=$(LIBDBFORGE_GUI:.cmxa=.a)

LIBDBFORGE_CMOFILES= \
	dbforge/dbf_lib/dbf_sql_driver.cmo \
	dbforge/dbf_lib/dbf_sql_misc.cmo
LIBDBFORGE_CMIFILES=$(LIBDBFORGE_CMOFILES:.cmo=.cmi)
LIBDBFORGE_CMXFILES=$(LIBDBFORGE_CMOFILES:.cmo=.cmx)
LIBDBFORGE_OFILES=$(LIBDBFORGE_CMOFILES:.cmo=.o)
LIBDBFORGE_SRCFILES=$(LIBDBFORGE_CMOFILES:.cmo=.ml) \
	dbforge/dbf_lib/dbf_mysql.ml \
	dbforge/dbf_lib/dbf_mysql.mli
LIBDBFORGE=$(LIBDBFORGE_CMXFILES) $(LIBDBFORGE_CMIFILES)
LIBDBFORGE_BYTE=$(LIBDBFORGE_CMOFILES) $(LIBDBFORGE_CMIFILES)

DBFORGE_LIBS=$(DBFORGE_COMMON_CMIFILES) \
	$(LIBDBFORGE_CORE) $(LIBDBFORGE_CORE_BYTE) \
	$(LIBDBFORGE_CORE_A) \
	$(LIBDBFORGE_GUI) $(LIBDBFORGE_GUI_BYTE) \
	$(LIBDBFORGE_GUI_CMI) $(LIBDBFORGE_GUI_A) \
	$(LIBDBFORGE_CMXFILES) $(LIBDBFORGE_OFILES) \
	$(LIBDBFORGE_CMOFILES) \
	$(LIBDBFORGE_CMIFILES) \
	$(LIBDBFORGE_SRCFILES)

# CamlCVS

OCAMLCVS_COMMON_CMOFILES=\
	ocamlcvs/ocvs_messages.cmo \
	ocamlcvs/ocvs_types.cmo \
	ocamlcvs/ocvs_misc.cmo \
	ocamlcvs/ocvs_config.cmo \
	ocamlcvs/ocvs_revision.cmo \
	ocamlcvs/ocvs_commands.cmo \
	ocamlcvs/ocvs_behav.cmo \
	ocamlcvs/ocvs_list.cmo \
	ocamlcvs/ocvs_tree.cmo

OCAMLCVS_CMOFILES=$(OCAMLCVS_COMMON_CMOFILES) \
	ocamlcvs/ocvs.cmo
OCAMLCVS_CMXFILES= $(OCAMLCVS_CMOFILES:.cmo=.cmx)
OCAMLCVS_CMIFILES= $(OCAMLCVS_CMOFILES:.cmo=.cmi)

OCAMLCVS_LIB_CMOFILES=$(OCAMLCVS_COMMON_CMOFILES) \
	ocamlcvs/ocamlcvs.cmo
OCAMLCVS_LIB_CMXFILES= $(OCAMLCVS_LIB_CMOFILES:.cmo=.cmx)
OCAMLCVS_LIB_CMIFILES= $(OCAMLCVS_LIB_CMOFILES:.cmo=.cmi)

LIBOCAMLCVS=ocamlcvs/ocamlcvs.cmxa
LIBOCAMLCVS_BYTE=$(LIBOCAMLCVS:.cmxa=.cma)
LIBOCAMLCVS_CMI=$(LIBOCAMLCVS:.cmxa=.cmi)
LIBOCAMLCVS_A=$(LIBOCAMLCVS:.cmxa=.a)

OCAMLCVS_LIBS=$(LIBOCAMLCVS) $(LIBOCAMLCVS_BYTE) $(LIBOCAMLCVS_CMI) $(LIBOCAMLCVS_A)

# Odiff library

ODIFF_LIB_CMOFILES=\
	odiff/odiff_types.cmo \
	odiff/odiff_parser.cmo \
	odiff/odiff_lexer.cmo \
	odiff/odiff.cmo

ODIFF_LIB_CMXFILES= $(ODIFF_LIB_CMOFILES:.cmo=.cmx)
ODIFF_LIB_CMIFILES= $(ODIFF_LIB_CMOFILES:.cmo=.cmi)

ODIFF_LIB_GUI_CMOFILES=\
	odiff/odiff_messages.cmo \
	odiff/odiff_merge.cmo \
	odiff/odiff_box.cmo \
	odiff/odiff_gui.cmo
ODIFF_LIB_GUI_CMXFILES= $(ODIFF_LIB_GUI_CMOFILES:.cmo=.cmx)
ODIFF_LIB_GUI_CMIFILES= $(ODIFF_LIB_GUI_CMOFILES:.cmo=.cmi)

LIBODIFF=odiff/odiff.cmxa
LIBODIFF_BYTE=$(LIBODIFF:.cmxa=.cma)
LIBODIFF_CMI=$(LIBODIFF:.cmxa=.cmi)
LIBODIFF_A=$(LIBODIFF:.cmxa=.a)

LIBODIFF_GUI=odiff/odiff_gui.cmxa
LIBODIFF_GUI_BYTE=$(LIBODIFF_GUI:.cmxa=.cma)
LIBODIFF_GUI_CMI=$(LIBODIFF_GUI:.cmxa=.cmi)
LIBODIFF_GUI_A=$(LIBODIFF_GUI:.cmxa=.a)

ODIFF_LIBS=$(LIBODIFF) $(LIBODIFF_BYTE) $(LIBODIFF_CMI) $(LIBODIFF_A) \
	$(LIBODIFF_GUI) $(LIBODIFF_GUI_BYTE) $(LIBODIFF_GUI_CMI) $(LIBODIFF_GUI_A)

# Custop library
LIBCUSTOP=custop/custop_base.cmx custop/custop_installation.cmx custop/custop.cmx
LIBCUSTOP_BYTE=$(LIBCUSTOP:.cmx=.cmo)
LIBCUSTOP_CMI=$(LIBCUSTOP:.cmx=.cmi)
LIBCUSTOP_O=$(LIBCUSTOP:.cmx=.o)

CUSTOP_LIBS=$(LIBCUSTOP) $(LIBCUSTOP_BYTE) $(LIBCUSTOP_CMI) $(LIBCUSTOP_O)

# Multiclip library
LIBMULTICLIP=multiclip/multiclip.cmx multiclip/multiclip_gui.cmx
LIBMULTICLIP_BYTE=$(LIBMULTICLIP:.cmx=.cmo)
LIBMULTICLIP_CMI=$(LIBMULTICLIP:.cmx=.cmi)
LIBMULTICLIP_O=$(LIBMULTICLIP:.cmx=.o)

MULTICLIP_LIBS=$(LIBMULTICLIP) $(LIBMULTICLIP_BYTE) $(LIBMULTICLIP_CMI) $(LIBMULTICLIP_O)

OCAMLDOC_GENERATORS=$(ODOC_TDL)

SNIPPETS_CMOFILES=snippets/remove_trailing_whitespace.cmo \
	snippets/remote_files.cmo \
	snippets/greek_ocaml.cmo \
	snippets/ocaml_make.cmo \
	snippets/r_mode.cmo \
	snippets/stack_backtraces.cmo
SNIPPETS_CMIFILES=$(SNIPPETS_CMOFILES:.cmo=.cmi)

opt: libs tools
byte: libs_byte tools_byte ocamldoc_generators
libs: $(UTILS) libodot libcf libokey \
	$(LIBCW) $(LIBTDL) $(LIBTDL_GUI) \
	$(LIBRSS) $(LIBRSS_GUI) \
	$(LIBREPORT) $(LIBREPORT_GUI) \
	$(LIBSQML) $(LIBTMPL) $(LIBDBFORGE_CORE) $(LIBDBFORGE_GUI) $(LIBDBFORGE) \
	$(LIBODIFF) $(LIBODIFF_GUI) \
	$(LIBOCAMLCVS) $(LIBEDITOR) \
	libcustop libmulticlip

libs_byte: $(UTILS_BYTE) libodot_byte libcf_byte libokey_byte \
	$(LIBCW_BYTE) \
	$(LIBTDL_BYTE) $(LIBTDL_GUI_BYTE) \
	$(LIBRSS_BYTE) $(LIBRSS_GUI_BYTE) \
	$(LIBREPORT_BYTE) $(LIBREPORT_GUI_BYTE) \
	$(LIBSQML_BYTE) \
	$(LIBTMPL_BYTE) $(LIBDBFORGE_CORE_BYTE) \
	$(LIBDBFORGE_GUI_BYTE) $(LIBDBFORGE_BYTE) \
	$(LIBODIFF_BYTE) $(LIBODIFF_GUI_BYTE) \
	$(LIBOCAMLCVS_BYTE) \
	libcustop_byte libmulticlip_byte

tools: libs $(TOOLS)
tools_byte: libs_byte $(TOOLS_BYTE)

snippets: $(SNIPPETS_CMIFILES) $(SNIPPETS_CMOFILES)

ifeq ($(OCAMLOPT),)
all: byte plugins
else
all: byte plugins opt
endif

libodot:
	cd odot && make MASTER=$(ROOT)/master.Makefile opt gui_opt
libodot_byte:
	cd odot && make MASTER=$(ROOT)/master.Makefile byte gui_byte

libcf: $(LIBCF_CMI) $(LIBCF)
libcf_byte: $(LIBCF_CMI) $(LIBCF_BYTE)

libokey: $(LIBOKEY_CMI) $(LIBOKEY)
libokey_byte: $(LIBOKEY_CMI) $(LIBOKEY_BYTE)

libcustop: $(LIBCUSTOP_CMI) $(LIBCUSTOP)
libcustop_byte: $(LIBCUSTOP_CMI) $(LIBCUSTOP_BYTE)

libmulticlip: $(LIBCMULTICLIP_CMI) $(LIBMULTICLIP)
libmulticlip_byte: $(LIBMULTICLIP_CMI) $(LIBMULTICLIP_BYTE)

plugins: $(PLUGINS)

ocamldoc_generators:$(OCAMLDOC_GENERATORS)

$(CAMELEON): $(LIBOCAMLCVS) $(LIBOKEY) $(LIBCF) $(LIBCW) \
	$(LIBMULTICLIP) \
	$(CAMELEON_CMIFILES) $(CAMELEON_CMXFILES) \
	utils/gmylist.cmx
	$(OCAMLOPT) -o $@ $(LINKFLAGS) str.cmxa unix.cmxa threads.cmxa \
	odoc_info.cmxa lablgtk.cmxa lablglade.cmxa gtkInit.cmx \
	lablgtksourceview.cmxa xml-light.cmxa \
	cameleon/cam_installation.cmx \
	okey.cmx config_file.cmx odot.cmxa odot_view.cmx \
	configwin.cmxa gstuff.cmx gmylist.cmx gmytree.cmx gdir.cmx ffind.cmx \
	gtksv-utils/gtksv_utils.cmx rss.cmxa rss_gui.cmxa tdl.cmxa tdl_gui.cmxa \
	$(LIBMULTICLIP) \
	odiff.cmxa odiff_gui.cmxa ocamlcvs.cmxa \
	pcre.cmxa \
	$(CAMELEON_CMXFILES)

$(CAMELEON_BYTE): $(LIBOCAMLCVS_BYTE) $(LIBOKEY_BYTE) $(LIBCF_BYTE) $(LIBCW_BYTE) \
	$(LIBMULTICLIP_BYTE) \
	$(CAMELEON_CMIFILES) $(CAMELEON_CMOFILES) utils/gmylist.cmo
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) -linkall str.cma unix.cma threads.cma \
	toplevellib.cma \
	cameleon/cam_installation.cmo \
	odoc_info.cma lablgtk.cma lablglade.cma gtkInit.cmo \
	lablgtksourceview.cma xml-light.cma \
	okey.cmo config_file.cmo odot.cma odot_view.cmo \
	configwin.cma gstuff.cmo gmylist.cmo gmytree.cmo gdir.cmo ffind.cmo \
	gtksv-utils/gtksv_utils.cmo rss.cma rss_gui.cma tdl.cma tdl_gui.cma \
	$(LIBMULTICLIP_BYTE) \
	odiff.cma odiff_gui.cma ocamlcvs.cma \
	pcre.cma \
	$(CAMELEON_CMOFILES)

$(CAM_CONFIG): $(CAM_CONFIG_CMIFILES) $(CAM_CONFIG_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) unix.cmxa $(CAM_CONFIG_CMXFILES)

$(CAM_CONFIG_BYTE): $(CAM_CONFIG_CMIFILES) $(CAM_CONFIG_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) unix.cma $(CAM_CONFIG_CMOFILES)

$(DOCBROWSER): $(DOCBROWSER_CMIFILES) $(DOCBROWSER_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) str.cmxa unix.cmxa threads.cmxa \
	odoc_info.cmxa lablgtk.cmxa lablglade.cmxa gtkInit.cmx \
	lablgtksourceview.cmxa xml-light.cmxa \
	okey.cmx config_file.cmx configwin.cmxa \
	cameleon/cam_installation.cmx \
	gstuff.cmx gdir.cmx gmylist.cmx gmytree.cmx \
	$(LIBMULTICLIP) \
	gtksv-utils/gtksv_utils.cmx tdl.cmxa tdl_gui.cmxa \
	pcre.cmxa \
	$(DOCBROWSER_CMXFILES)

$(DOCBROWSER_BYTE): $(DOCBROWSER_CMIFILES) $(DOCBROWSER_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) str.cma unix.cma threads.cma \
	odoc_info.cma lablgtk.cma lablglade.cma gtkInit.cmo \
	lablgtksourceview.cma xml-light.cma \
	okey.cmo config_file.cmo configwin.cma \
	cameleon/cam_installation.cmo \
	gstuff.cmo gdir.cmo gmylist.cmo gmytree.cmo \
	gtksv-utils/gtksv_utils.cmo tdl.cma tdl_gui.cma \
	$(LIBMULTICLIP_BYTE) \
	pcre.cma \
	$(DOCBROWSER_CMOFILES)

$(EDITOR): $(LIBOKEY) $(LIBCF) $(LIBCW) $(LIBTDL) \
	$(GTKSV_UTILS_CMI) $(GTKSV_UTILS_CMX) \
	utils/gmylist.cmx utils/gmytree.cmx \
	$(LIBMULTICLIP) \
	$(EDITOR_CMIFILES) $(EDITOR_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) $(EDITOR_LINK_LIBS) \
	$(EDITOR_CMXFILES)

$(EDITOR_BYTE): $(LIBOKEY_BYTE) $(LIBCF_BYTE) $(LIBCW_BYTE) $(LIBTDL_BYTE) \
	$(GTKSV_UTILS_CMI) $(GTKSV_UTILS_CMO) \
	utils/gmylist.cmo utils/gmytree.cmo \
	$(LIBMULTICLIP_BYTE) \
	$(EDITOR_CMIFILES) $(EDITOR_CMOFILES)
	$(OCAMLC) -linkall -o $@ $(LINKFLAGS_BYTE) $(EDITOR_LINK_LIBS_BYTE) \
	$(EDITOR_CMOFILES)

$(LIBEDITOR): $(LIBOKEY) $(LIBCF) $(LIBCW) $(LIBTDL) \
	$(GTKSV_UTILS_CMI) $(GTKSV_UTILS_CMX) \
	utils/gmylist.cmx utils/gmytree.cmx \
	$(LIBMULTICLIP) \
	$(EDITOR_COMMON_CMIFILES) $(EDITOR_COMMON_CMXFILES)
	$(OCAMLOPT) -a -o $@ -linkall $(LINKFLAGS) \
	$(EDITOR_COMMON_CMXFILES)

editor/make_my_chamo: dummy
	@echo -n "Creating $@... "
	$(RM) $(MKCHAMO_SCRIPT)
	@echo "# Multi-shell script.  Works under Bourne Shell, MPW Shell, zsh." > $(MKCHAMO_SCRIPT)
	@echo "if : == x" >> $(MKCHAMO_SCRIPT)
	@echo "then # Bourne Shell or zsh" >> $(MKCHAMO_SCRIPT)
	@echo "exec $(OCAMLOPT) $(MKCHAMO_INCLUDES) -linkall $(MKCHAMO_LINK_LIBS) chamo.cmxa \"\$$@\" ed_main.cmx" >> $(MKCHAMO_SCRIPT)
	@echo "else #MPW Shell" >> $(MKCHAMO_SCRIPT)
	@echo "$(OCAMLOPT) $(MKCHAMO_INCLUDES) -linkall $(MKCHAMO_LINK_LIBS) chamo.cmxa {\"parameters\"} ed_main.cmx" >> $(MKCHAMO_SCRIPT)
	@echo "End # uppercase E because "end" is a keyword in zsh" >> $(MKCHAMO_SCRIPT)
	@echo "fi" >> $(MKCHAMO_SCRIPT)
	@chmod ugo+rx $(MKCHAMO_SCRIPT)
	@chmod a-w $(MKCHAMO_SCRIPT)
	@echo done

$(LIBCW): $(LIBCW_CMIFILES) $(LIBCW_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(LIBCW_CMXFILES)
$(LIBCW_BYTE): $(LIBCW_CMIFILES) $(LIBCW_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(LIBCW_CMOFILES)

$(LIBTDL): cameleon/cam_installation.cmx $(LIBTDL_CMIFILES) $(LIBTDL_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(LIBTDL_CMXFILES)
$(LIBTDL_BYTE): cameleon/cam_installation.cmo $(LIBTDL_CMIFILES) $(LIBTDL_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(LIBTDL_CMOFILES)

$(LIBTDL_GUI): $(LIBTDL) $(LIBTDL_GUI_CMIFILES) $(LIBTDL_GUI_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(LIBTDL_GUI_CMXFILES)
$(LIBTDL_GUI_BYTE): $(LIBTDL_BYTE) $(LIBTDL_GUI_CMIFILES) $(LIBTDL_GUI_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(LIBTDL_GUI_CMOFILES)

$(TDL): $(LIBTDL) $(LIBTDL_GUI) $(TDL_CMIFILES) $(TDL_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa unix.cmxa lablgtk.cmxa lablglade.cmxa gmytree.cmx \
	okey.cmx config_file.cmx configwin.cmxa \
	xml-light.cmxa $(LIBTDL) cameleon/cam_installation.cmx $(LIBTDL_GUI) \
	$(TDL_CMXFILES)

$(TDL_BYTE): $(LIBTDL_BYTE) $(LIBTDL_GUI_BYTE) $(TDL_CMIFILES) $(TDL_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS) \
	str.cma unix.cma lablgtk.cma lablglade.cma gmytree.cmo \
	okey.cmo config_file.cmo configwin.cma \
	xml-light.cma $(LIBTDL_BYTE) cameleon/cam_installation.cmo $(LIBTDL_GUI_BYTE) \
	$(TDL_CMOFILES)

$(TDL_EXPORT): $(LIBTDL) $(LIBRSS) $(TDL_EXPORT_CMIFILES) $(TDL_EXPORT_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	unix.cmxa xml-light.cmxa str.cmxa $(LIBTDL) $(LIBRSS) $(TDL_EXPORT_CMXFILES)

$(TDL_EXPORT_BYTE): $(LIBTDL_BYTE) $(LIBRSS_BYTE) $(TDL_EXPORT_CMIFILES) $(TDL_EXPORT_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS) \
	unix.cma xml-light.cma str.cma $(LIBTDL_BYTE) $(LIBRSS_BYTE) $(TDL_EXPORT_CMOFILES)

$(TDL_SVN): $(LIBTDL) $(TDL_SVN_CMIFILES) $(TDL_SVN_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	unix.cmxa xml-light.cmxa str.cmxa $(LIBTDL) $(TDL_SVN_CMXFILES)

$(TDL_SVN_BYTE): $(LIBTDL_BYTE) $(TDL_SVN_CMIFILES) $(TDL_SVN_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS) \
	unix.cma xml-light.cma str.cma $(LIBTDL_BYTE) $(TDL_SVN_CMOFILES)

$(TDL_HTML): $(LIBTDL) $(TDL_HTML_CMIFILES) $(TDL_HTML_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	unix.cmxa xml-light.cmxa str.cmxa $(LIBTDL) $(TDL_HTML_CMXFILES)

$(TDL_HTML_BYTE): $(LIBTDL_BYTE) $(TDL_HTML_CMIFILES) $(TDL_HTML_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS) \
	unix.cma xml-light.cma str.cma $(LIBTDL_BYTE) $(TDL_HTML_CMOFILES)

$(LIBRSS): cameleon/cam_installation.cmx $(LIBRSS_CMIFILES) $(LIBRSS_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(LIBRSS_CMXFILES)
$(LIBRSS_BYTE): cameleon/cam_installation.cmo $(LIBRSS_CMIFILES) $(LIBRSS_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(LIBRSS_CMOFILES)

$(LIBRSS_GUI): $(LIBRSS) $(LIBRSS_GUI_CMIFILES) $(LIBRSS_GUI_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(LIBRSS_GUI_CMXFILES)
$(LIBRSS_GUI_BYTE): $(LIBRSS_BYTE) $(LIBRSS_GUI_CMIFILES) $(LIBRSS_GUI_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(LIBRSS_GUI_CMOFILES)

$(RSS): $(LIBRSS) $(LIBRSS_GUI) $(RSS_CMIFILES) $(RSS_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa unix.cmxa lablgtk.cmxa lablglade.cmxa gmytree.cmx \
	okey.cmx config_file.cmx configwin.cmxa \
	xml-light.cmxa $(LIBRSS) cameleon/cam_installation.cmx $(LIBRSS_GUI) \
	$(RSS_CMXFILES)

$(RSS_BYTE): $(LIBRSS_BYTE) $(LIBRSS_GUI_BYTE) $(RSS_CMIFILES) $(RSS_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS) \
	str.cma unix.cma lablgtk.cma lablglade.cma gmytree.cmo \
	okey.cmo config_file.cmo configwin.cma \
	xml-light.cma $(LIBRSS_BYTE) cameleon/cam_installation.cmo $(LIBRSS_GUI_BYTE) \
	$(RSS_CMOFILES)

$(RSS_EXPORT): $(LIBRSS) $(RSS_EXPORT_CMIFILES) $(RSS_EXPORT_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	unix.cmxa xml-light.cmxa str.cmxa $(LIBRSS) $(RSS_EXPORT_CMXFILES)

$(RSS_EXPORT_BYTE): $(LIBRSS_BYTE) $(RSS_EXPORT_CMIFILES) $(RSS_EXPORT_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS) \
	unix.cma xml-light.cma str.cma $(LIBRSS_BYTE) $(RSS_EXPORT_CMOFILES)

$(ODOC_TDL): $(ODOC_TDL_CMIFILES) $(ODOC_TDL_CMOFILES)
	$(OCAMLC) -a -o $@ $(INCLUDES) xml-light.cma $(ODOC_TDL_CMOFILES)

$(REPORT): $(REPORT_CMIFILES) $(REPORT_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa xml-light.cmxa \
	$(REPORT_CMXFILES)

$(REPORT_BYTE): $(REPORT_CMIFILES) $(REPORT_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) \
	str.cma xml-light.cma \
	$(REPORT_CMOFILES)

$(REPORT_GUI): $(REPORT_GUI_CMIFILES) $(REPORT_GUI_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa lablgtk.cmxa lablglade.cmxa config_file.cmx \
	okey.cmx configwin.cmxa xml-light.cmxa \
	$(REPORT_GUI_CMXFILES)

$(REPORT_GUI_BYTE): $(REPORT_GUI_CMIFILES) $(REPORT_GUI_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) \
	str.cma lablgtk.cma lablglade.cma config_file.cmo \
	okey.cmo configwin.cma xml-light.cma \
	$(REPORT_GUI_CMOFILES)

$(LIBREPORT): $(REPORT_LIB_CMIFILES) $(REPORT_LIB_CMXFILES) $(LIBREPORT_CMI)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(REPORT_LIB_CMXFILES)
$(LIBREPORT_BYTE): $(REPORT_LIB_CMIFILES) $(REPORT_LIB_CMOFILES) $(LIBREPORT_CMI)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(REPORT_LIB_CMOFILES)

$(LIBREPORT_GUI): $(REPORT_LIB_GUI_CMIFILES) $(REPORT_LIB_GUI_CMXFILES) $(LIBREPORT_GUI_CMI)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(REPORT_LIB_GUI_CMXFILES)
$(LIBREPORT_GUI_BYTE): $(REPORT_LIB_GUI_CMIFILES) $(REPORT_LIB_GUI_CMOFILES) $(LIBREPORT_GUI_CMI)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(REPORT_LIB_GUI_CMOFILES)

ifeq ($(USE_LABLGTKSOURCEVIEW),yes)
CAMTOP_GTKSV_FILES=$(LABLGTKSOURCEVIEW_CMA) xml-light.cma gtkInit.cmo $(GTKSV_UTILS_CMO)
endif

$(CAMTOP): $(CAMTOP_CMIFILES) $(CAMTOP_CMOFILES) $(LIBCAMTOP_BYTE)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) \
	ocaml/utils/config.cmo \
          ocaml/utils/clflags.cmo \
	toplevellib.cma \
	unix.cma lablgtk.cma lablglade.cma \
	okey.cmo config_file.cmo configwin.cma gmylist.cmo $(CAMTOP_GTKSV_FILES) \
	$(CAMTOP_CMOFILES)

$(LIBCAMTOP_BYTE): $(CAMTOP_LIB_CMIFILES) $(CAMTOP_LIB_CMOFILES)
	$(OCAMLC) -a -o $@ $(LINKFLAGS_BYTE) \
	ocaml/utils/config.cmo \
          ocaml/utils/clflags.cmo \
	toplevellib.cma \
	unix.cma lablgtk.cma lablglade.cma $(LABLGTKSOURCEVIEW_CMA) \
	okey.cmo config_file.cmo configwin.cma gmylist.cmo $(CAMTOP_GTKSV_FILES) \
	$(CAMTOP_LIB_CMOFILES)
	$(CP) $(CAMTOP_CMI) $(LIBCAMTOP_CMI)


$(DBFORGE): $(DBFORGE_CMIFILES) $(DBFORGE_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa xml-light.cmxa sqml.cmxa \
	$(DBFORGE_CMXFILES)

$(DBFORGE_BYTE): $(DBFORGE_CMIFILES) $(DBFORGE_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) \
	str.cma xml-light.cma sqml.cma \
	$(DBFORGE_CMOFILES)

$(DBFORGE_GUI): $(DBFORGE_GUI_CMIFILES) $(DBFORGE_GUI_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa lablgtk.cmxa lablglade.cmxa config_file.cmx \
	okey.cmx configwin.cmxa xml-light.cmxa sqml.cmxa \
	$(DBFORGE_GUI_CMXFILES)

$(DBFORGE_GUI_BYTE): $(DBFORGE_GUI_CMIFILES) $(DBFORGE_GUI_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) \
	str.cma lablgtk.cma lablglade.cma config_file.cmo \
	okey.cmo configwin.cma xml-light.cma sqml.cma \
	$(DBFORGE_GUI_CMOFILES)

$(LIBDBFORGE_GUI): $(DBFORGE_LIB_GUI_CMIFILES) $(DBFORGE_LIB_GUI_CMXFILES) $(LIBDBFORGE_GUI_CMI)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(DBFORGE_LIB_GUI_CMXFILES)
$(LIBDBFORGE_GUI_BYTE): $(DBFORGE_LIB_GUI_CMIFILES) $(DBFORGE_LIB_GUI_CMOFILES) $(LIBDBFORGE_GUI_CMI)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(DBFORGE_LIB_GUI_CMOFILES)


$(LIBDBFORGE_CORE): $(DBFORGE_COMMON_CMIFILES) $(DBFORGE_COMMON_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(DBFORGE_COMMON_CMXFILES)
$(LIBDBFORGE_CORE_BYTE): $(DBFORGE_COMMON_CMIFILES) $(DBFORGE_COMMON_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(DBFORGE_COMMON_CMOFILES)

$(LIBSQML): $(SQML_CMIFILES) $(SQML_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(SQML_CMXFILES)
$(LIBSQML_BYTE): $(SQML_CMIFILES) $(SQML_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(SQML_CMOFILES)


$(TMPL_ENGINE): $(TMPL_CMIFILES) $(TMPL_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa \
	$(TMPL_CMXFILES)

$(TMPL_ENGINE_BYTE): $(TMPL_CMIFILES) $(TMPL_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) \
	str.cma \
	$(TMPL_CMOFILES)

$(LIBTMPL): $(TMPL_CMIFILES) $(TMPL_CMXFILES)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(TMPL_CMXFILES)
$(LIBTMPL_BYTE): $(TMPL_CMIFILES) $(TMPL_CMOFILES)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(TMPL_CMOFILES)

$(OCAMLCVS): $(OCAMLCVS_CMIFILES) $(OCAMLCVS_CMXFILES)
	$(OCAMLOPT) -o $@ $(LINKFLAGS) \
	str.cmxa unix.cmxa lablgtk.cmxa gstuff.cmx odiff.cmxa odiff_gui.cmxa \
	$(OCAMLCVS_CMXFILES)

$(OCAMLCVS_BYTE): $(OCAMLCVS_CMIFILES) $(OCAMLCVS_CMOFILES)
	$(OCAMLC) -o $@ $(LINKFLAGS_BYTE) \
	str.cma unix.cma lablgtk.cma gstuff.cmo odiff.cma odiff_gui.cma \
	$(OCAMLCVS_CMOFILES)

$(LIBOCAMLCVS): $(OCAMLCVS_LIB_CMIFILES) $(OCAMLCVS_LIB_CMXFILES) $(LIBOCAMLCVS_CMI)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(OCAMLCVS_LIB_CMXFILES)
$(LIBOCAMLCVS_BYTE): $(OCAMLCVS_LIB_CMIFILES) $(OCAMLCVS_LIB_CMOFILES) $(OCAMLCVS_LIB_CMI)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(OCAMLCVS_LIB_CMOFILES)

$(LIBODIFF): $(ODIFF_LIB_CMIFILES) $(ODIFF_LIB_CMXFILES) $(LIBODIFF_CMI)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(ODIFF_LIB_CMXFILES)
$(LIBODIFF_BYTE): $(ODIFF_LIB_CMIFILES) $(ODIFF_LIB_CMOFILES) $(ODIFF_LIB_CMI)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(ODIFF_LIB_CMOFILES)

$(LIBODIFF_GUI): $(LIBODIFF) $(ODIFF_LIB_GUI_CMIFILES) $(ODIFF_LIB_GUI_CMXFILES) $(LIBODIFF_GUI_CMI)
	$(OCAMLOPT) -a -o $@ $(LINKFLAGS) $(ODIFF_LIB_GUI_CMXFILES)
$(LIBODIFF_GUI_BYTE): $(LIBODIFF_BYTE) $(ODIFF_LIB_GUI_CMIFILES) $(ODIFF_LIB_GUI_CMOFILES) $(ODIFF_LIB_GUI_CMI)
	$(OCAMLC) -a -custom -o $@ $(LINKFLAGS_BYTE) $(ODIFF_LIB_GUI_CMOFILES)


plugins/dep_view.cma: cameleon/cam_plug.cmi plugins/dep_view.cmo plugins/typdep_view.cmo
	$(OCAMLC) -a -o $@ plugins/dep_view.cmo plugins/typdep_view.cmo


### Test stuff
testocamlmode.x: editor/ed_ocaml_lexer.cmo editor/test_ocaml_mode.cmo
	$(OCAMLC) -o $@ $^

### Exporting snippets
camlget: cameleon_snippets.cga

cameleon_snippets.cga: $(SNIPPETS_CMIFILES) $(SNIPPETS_CMOFILES)
	$(OCAMLDOC) -g odoc_ar.cma $(INCLUDES) -o $@ $(SNIPPETS_CMOFILES:.cmo=.ml) $(SNIPPETS_CMOFILES:.cmo=.mli)

# Documentation :
#################
dump.odoc: cameleon/*.ml cameleon/*.mli \
	utils/*.ml utils/*.mli \
	gtksv-utils/*.ml gtksv-utils/*.mli \
	tmpl-engine/*.ml \
	sqml/*.ml sqml/*.mli \
	config_file/*.ml config_file/*.mli \
	odiff/*.ml odiff/*.mli \
	okey/*.ml okey/*.mli \
	tdl/*.ml tdl/*.mli \
	rss/*.ml rss/*.mli \
	configwin/*.ml configwin/*.mli \
	report/*.ml report/*.mli \
	dbforge/*.ml dbforge/*.mli \
	dbforge/dbf_lib/dbf_sql_misc.ml dbforge/dbf_lib/dbf_sql_driver.ml \
	ocamlcvs/*.ml ocamlcvs/*.mli \
	odot/*.ml odot/*.mli \
	editor/*.ml editor/*.mli \
	custop/*.ml custop/*.mli \
	multiclip/*.ml multiclip/*.mli \
	$(GTKSV_UTILS_CMO:.cmo=.ml) $(GTKSV_UTILS_CMO:.cmo=.mli)
	$(OCAMLDOCOPT) \
	$(INCLUDES) -keep-code $(COMPFLAGS) -sort -dump $@ \
	`ls $^ | grep -v example.ml | grep -v example2.ml | grep -v test | grep -v cam_rss`

$(ROOT)/doc/cameleon.odoc:cameleon/*.ml cameleon/*.mli \
	utils/*.ml utils/*.mli \
	tmpl-engine/*.ml \
	sqml/*.ml sqml/*.mli \
	config_file/*.ml config_file/*.mli \
	okey/*.ml okey/*.mli \
	tdl/*.ml tdl/*.mli \
	rss/*.ml rss/*.mli \
	configwin/*.ml configwin/*.mli \
	odiff/*.ml odiff/*.mli \
	report/*.ml report/*.mli \
	dbforge/*.ml dbforge/*.mli \
	dbforge/dbf_lib/dbf_sql_misc.ml dbforge/dbf_lib/dbf_sql_driver.ml \
	ocamlcvs/*.ml ocamlcvs/*.mli \
	odot/*.ml odot/*.mli \
	custop/*.ml custop/*.mli \
	multiclip/*.ml multiclip/*.mli \
	editor/*.ml editor/*.mli \
	$(GTKSV_UTILS_CMO:.cmo=.ml) $(GTKSV_UTILS_CMO:.cmo=.mli)
	$(OCAMLDOCOPT) \
	$(INCLUDES) -keep-code $(COMPFLAGS) -sort -dump $@ \
	ocamlcvs/ocamlcvs.mli \
	odot/odot.mli odot/odot_view.mli \
	$(GTKSV_UTILS_CMO:.cmo=.ml) $(GTKSV_UTILS_CMO:.cmo=.mli) \
	odiff/*.ml odiff/*.mli \
	okey/okey.mli \
	tdl/tdl.mli tdl/tdl_gui.ml \
	rss/rss.mli rss/rss_gui.ml \
	configwin/configwin.mli \
	config_file/config_file.mli \
	sqml/sqml.ml \
	utils/gdir.mli \
	utils/gmylist.mli \
	utils/gmytree.mli \
	utils/gstuff.mli \
	utils/ffind.mli \
	report/report.mli report/report_gui.mli \
	dbforge/dbforge_gui.mli \
	dbforge/dbf_lib/dbf_sql_misc.ml dbforge/dbf_lib/dbf_sql_driver.ml \
	editor/*.mli editor/ed_mode_ocaml.ml editor/ed_mode_ocaml_rc.ml \
	custop/*.mli custop/*.ml \
	multiclip/*.mli multiclip/*.ml \
	cameleon/*.mli

dumps.odoc:
	for i in editor cameleon utils config_file gtksv-utils okey \
	configwin report dbforge odiff odot ocamlcvs custop multiclip; do \
	$(OCAMLDOCOPT) $(INCLUDES) -keep-code $(COMPFLAGS) -sort -dump $$i/dump.odoc \
	$$i/*.ml $$i/*.mli; done

doc: all dump.odoc
	$(MKDIR) ocamldoc
	$(OCAMLDOCOPT) $(COMPFLAGS) \
	-html \
	-load dump.odoc \
	-intro $(ROOT)/doc/reference_doc_intro.text \
	-d ocamldoc

websitedoc: $(ROOT)/doc/cameleon.odoc
	$(MKDIR) $(ROOT)/../website/refdoc
	$(MKDIR) $(ROOT)/../website/snippets
	$(OCAMLDOCOPT) $(COMPFLAGS) \
	-html \
	-load $< \
	-intro $(ROOT)/doc/web_reference_doc_intro.text \
	-d $(ROOT)/../website/refdoc
	$(OCAMLDOC) $(COMPFLAGS) \
	$(INCLUDES) -keep-code \
	-g odoc_htmlcg.cmo \
	-intro $(ROOT)/doc/snippets_index.text \
	-d $(ROOT)/../website/snippets \
	$(SNIPPETS_CMOFILES:.cmo=.ml) $(SNIPPETS_CMOFILES:.cmo=.mli)
	$(CP) $(ROOT)/images/camlget.png $(ROOT)/../website/snippets/

oug: cameleon.ougd

cameleon.ougd: files.sorted all
	ls -U `cat $< ` | grep -v dbf_old | grep -v odot_types.ml | grep -v configwin_keys > files
	$(CP) files files_
	rpl ".ml" ".mli" files_
	(ls -U `cat files_ ` >> files || true )
	cp files files_
	(for i in `cat files_`; do echo $(ROOT)/src/$$i ; done) > files
	oug.x --no-reduce -pp camlp4o -I +oug $(INCLUDES) `cat files` --dump-data $@

files.sorted: */*.ml
	$(CP) odot/odot_types.mli odot/odot_types.ml
	ls */*.ml | grep -v draft | grep -v ocaml/ > files
	ocamldsort -pp camlp4o $(MY_INCLUDES) `cat files ` > $@
	$(RM) odot/odot_types.ml

todo: dump.odoc
	$(MKDIR) ocamldoc
	$(OCAMLDOC) -o todo.tdl \
	-I $(ROOT)/src/tdl/ \
	-g odoc_tdl.cma \
	-load $^
#	$(OCAMLDOC) -d ocamldoc -o ocamldoc/todo.html \
#	-g $(ROOT)/utils/odoc_todo.cmo \
#	-load $^ -t "To-do list"

dot: dep.dot
dep.dot: dump.odoc
	$(OCAMLDOCOPT) -load $< -o $@ -dot -dot-reduce
dep.ps:dep.dot
	dot -Tps -o $@ $<

# backup, clean and depend :
############################

GENERATED_FILES= \
	report/rep_gui_base.ml \
	tdl/tdl_gui_base.ml \
	tdl/tdl_filter_parser.ml \
	tdl/tdl_filter_parser.mli \
	rss/rss_gui_base.ml \
	dbforge/dbf_gladeWidgets.ml \
	tmpl-engine/tmplParser.ml \
	tmpl-engine/tmplParser.mli \
	odiff/odiff_parser.ml \
	odiff/odiff_parser.mli \
	odiff/odiff_lexer.ml \
	sqml/sqml_parser.ml \
	sqml/sqml_parser.mli \
	sqml/sqml_lexer.ml \
	editor/ed_gui_base.ml \
	editor/ed_ocaml_lexer.ml \
	cameleon/cam_gui_base.ml \
	custop/custop_base.ml \
	dbforge/dbf_sql_gen.ml \
	dbforge/dbf_sql_vgen.ml \
	dbforge/dbf_sql_qgen.ml

cleanocamldoc:
	$(RM) -r ocamldoc
	$(MKDIR) ocamldoc

distclean: clean
	$(RM) cameleon/cam_installation.ml cameleon/cam_config.ml
	$(RM) camtop/camtop_installation.ml camtop/cam-mktop2
	$(RM) editor/ed_charsets.ml
	$(RM) dbforge/dbf_installation.ml
	$(RM) report/rep_installation.ml
	(cd odot && $(MAKE) distclean)
	$(MAKE) cleanocamldoc

clean: dummy
	$(RM) *~ \#*\#
	$(RM) */*.a */*.so *.odoc
	$(RM) $(TOOLS) $(TOOLS_BYTE)
	$(RM) $(GENERATED_FILES) odiff/odiff_parser.output tdl/tdl_filter_parser.output
	$(RM) cameleon_snippets.cga
	(cd odot && $(MAKE) clean)
	(cd utils && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd tmpl-engine && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd sqml && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc sqml_parser.output)
	(cd config_file && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd custop && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd multiclip && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd gtksv-utils && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd tdl && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd rss && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd okey && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd configwin && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd report && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd dbforge && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd dbforge/dbf_lib && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd odiff && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd ocamlcvs && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd editor && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd cameleon && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd camtop && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd plugins && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd snippets && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)
	(cd draft && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc testpcre.x testgtk.x)
	$(RM) tmpl-engine/tmplParser.output
	$(RM) tdl/tdl_filter_parser.mli
	$(RM) tdl/tdl_filter_lexer.mli

cleansqml:
	(cd sqml && $(RM) *~ \#*\# *.cmo *.cmi *.cmx *.a *.o *.cma *.cmxa *.annot *.odoc)

.depend depend:
	$(RM) .depend
	$(OCAMLDEP) \
	-I utils -I tmpl-engine -I sqml -I tdl -I rss \
	-I config_file -I okey -I configwin -I report \
	-I dbforge -I ocamlcvs -I editor -I cameleon -I custop -I multiclip \
	-I plugins -I gtksv-utils \
	`ls cameleon/*.ml cameleon/*.mli | grep -v commands.ml` cameleon/cam_commands.mli \
	editor/*.ml editor/*.mli \
	camtop/*.ml \
	$(GTKSV_UTILS_CMO:.cmo=.ml) $(GTKSV_UTILS_CMO:.cmo=.mli) \
	utils/*.ml utils/*.mli \
	odiff/*.ml odiff/*.mli \
	tdl/*.ml tdl/*.mli \
	rss/*.ml rss/*.mli \
	tmpl-engine/*.ml tmpl-engine/*.mli \
	sqml/*.ml sqml/*.mli \
	config_file/*.ml config_file/*.mli \
	okey/*.ml okey/*.mli \
	configwin/*.ml configwin/*.mli \
	report/*.ml report/*.mli \
	dbforge/*.ml dbforge/*.mli \
	ocamlcvs/*.ml ocamlcvs/*.mli \
	odot/*.ml odot/*.mli \
	custop/*.ml custop/*.mli \
	multiclip/*.ml multiclip/*.mli \
	plugins/*.ml \
	  > .depend
	(cd odot && $(MAKE) depend)

alldepend: $(GENERATED_FILES)
	$(MAKE) depend
dummy:

include .depend

#################
# Installation
#################
install: installtools installlibs installplugins installodocgenerators

installtools: dummy
	$(MAKE) $(MKCHAMO_SCRIPT)
	@echo
	@echo Installing tools to $(BINDIR)...
	@echo
	@$(MKDIR) $(BINDIR)
	@for i in $(TOOLS) $(TOOLS_BYTE); do \
	if test -f $$i; then \
		$(CP) $$i $(BINDIR); echo $(BINDIR)/`basename $$i` installed; \
	else \
		echo $$i NOT installed ; \
	fi; done
	@$(CP) $(MKCHAMO_SCRIPT) $(BINDIR) && echo $(BINDIR)/`basename $(MKCHAMO_SCRIPT)` installed
	@$(MKDIR) $(GLADEDIR)
	@$(MKDIR) $(DTDDIR)
	@$(CP) report/report.glade $(GLADEDIR) && echo $(GLADEDIR)/report.glade installed
	@$(CP) dbforge/dbforge.glade $(GLADEDIR)  && echo $(GLADEDIR)/dbforge.glade installed
	@$(CP) dbforge/db.dtd $(DTDDIR)  && echo $(DTDDIR)/db.dtd installed
	@$(CP) cameleon/cameleon.glade $(GLADEDIR) && echo $(GLADEDIR)/cameleon.glade installed
	@$(CP) tdl/tdl.glade $(GLADEDIR) && echo $(GLADEDIR)/tdl.glade installed
	@$(CP) rss/rssgui.glade $(GLADEDIR) && echo $(GLADEDIR)/rssgui.glade installed
	@$(CP) camtop/camtop.glade $(GLADEDIR) && echo $(GLADEDIR)/camtop.glade installed
	@$(CP) custop/custop.glade $(GLADEDIR) && echo $(GLADEDIR)/custop.glade installed
	@if test -f $(EDITOR_BYTE) || test -f $(EDITOR); then \
		$(CP) editor/chamo.glade $(GLADEDIR) && echo $(GLADEDIR)/chamo.glade installed; \
	fi
	@if test -f $(CAMTOP); then \
		$(CP) camtop/cam-mktop2 $(BINDIR); echo $(BINDIR)/cam-mktop2 installed; \
	fi

installlibs: dummy
	@echo
	@echo Installing libraries to $(LIBDIR)...
	@echo
	@$(MKDIR) $(LIBDIR)
	@for i in $(OKEY_LIBS) $(ODIFF_LIBS) $(ODOT_LIBS) $(CF_LIBS) \
	$(CW_LIBS) $(TDL_LIBS) $(RSS_LIBS) $(SQML_LIBS) \
	$(TMPL_LIBS) $(REPORT_LIBS) $(DBFORGE_LIBS) $(OCAMLCVSLIBS) \
	$(CUSTOP_LIBS) $(MULTICLIP_LIBS) \
	$(UTILS:.cmx=.cmi) $(UTILS:.cmx=.o) $(UTILS) $(UTILS_BYTE) $(CAMTOP_LIBS) $(EDITOR_LIBS) \
	cameleon/cam_installation.cmx cameleon/cam_installation.o \
	editor/ed_main.cmx editor/ed_main.o \
	cameleon/cam_plug.cmi $(EDITOR_CMIFILES); do \
	if test -f $$i; then \
		$(CP) $$i $(LIBDIR); echo $(LIBDIR)/`basename $$i` installed; \
	else \
		echo $$i NOT installed ; \
	fi; done

installplugins: dummy
	@echo
	@echo Installing plugins to $(PLUGINSDIR)...
	@echo
	@$(MKDIR) $(PLUGINSDIR)
	@for i in $(PLUGINS); do \
	if test -f $$i; then \
		$(CP) $$i $(PLUGINSDIR); echo $(PLUGINSDIR)/`basename $$i` installed; \
	else \
		echo $$i NOT installed ; \
	fi; done

installodocgenerators: dummy
	@echo
	@echo Installing OCamldoc generators to $(OCAMLDOC_PLUGINSDIR)...
	@echo
	@$(MKDIR) $(OCAMLDOC_PLUGINSDIR)
	@for i in $(OCAMLDOC_GENERATORS); do \
	if test -f $$i; then \
		$(CP) $$i $(OCAMLDOC_PLUGINSDIR); echo $(OCAMLDOC_PLUGINSDIR)/`basename $$i` installed; \
	else \
		echo $$i NOT installed ; \
	fi; done

###########################
# additional dependencies
###########################

draft/testpcre.x: draft/testpcre.ml
	$(OCAMLC) $(INCLUDES) -o $@ pcre.cma $<


draft/testgtk.x: draft/testgtk.ml
	$(OCAMLC) $(INCLUDES) -o $@ lablgtk.cma $<

report/rep_gui_base.ml: report/report.glade
	$(LABLGLADECC) -hide-default $< > $@

tdl/tdl_gui_base.ml: tdl/tdl.glade
	$(LABLGLADECC) -hide-default $< > $@

rss/rss_gui_base.ml: rss/rssgui.glade
	$(LABLGLADECC) -hide-default $< > $@

camtop/camtop_toplevel_base.ml: camtop/camtop.glade
	$(LABLGLADECC) -hide-default $< > $@

custop/custop_base.ml: custop/custop.glade
	$(LABLGLADECC) -hide-default $< > $@

dbforge/dbf_gladeWidgets.ml: dbforge/dbforge.glade
	$(LABLGLADECC) -hide-default $< > $@

dbforge/dbf_sql_gen.ml: dbforge/templates/sql_table.tmpl.ml $(TMPL_ENGINE_BYTE)
	$(ROOT)/src/$(TMPL_ENGINE_BYTE) $< > $@

dbforge/dbf_sql_vgen.ml: dbforge/templates/sql_vtable.tmpl.ml $(TMPL_ENGINE_BYTE)
	$(ROOT)/src/$(TMPL_ENGINE_BYTE) $< > $@

dbforge/dbf_sql_qgen.ml: dbforge/templates/sql_query.tmpl.ml $(TMPL_ENGINE_BYTE)
	$(ROOT)/src/$(TMPL_ENGINE_BYTE) $< > $@

editor/ed_gui_base.ml: editor/chamo.glade
	$(LABLGLADECC) -hide-default $< > $@

cameleon/cam_gui_base.ml: cameleon/cameleon.glade
	$(LABLGLADECC) -hide-default $< > $@

cameleon/cam_plug.mli: cameleon/cam_plug.ml
	$(OCAMLC) -i $(INCLUDES) $< > $@

editor/moregtk.o: editor/moregtk.c
	$(OCAMLC) -c -ccopt "$(GTK_INCLUDES) $(LABLGTK2_INCLUDES)" $<
	mv moregtk.o $@

ifeq ($(USE_LABLGTKSOURCEVIEW),yes)
camtop/*.cm*:gtksv-utils/gtksv_utils.cmo gtksv-utils/gtksv_utils.cmi
endif
camtop/camtop_toplevel.cmo:camtop/camtop_outvalue.cmo
odiff/odiff_parser.cmo: odiff/odiff_parser.cmi
odiff/odiff_parser.cmx: odiff/odiff_parser.cmi
odiff/odiff_lexer.cmi: odiff/odiff_parser.cmi
odiff/odiff_lexer.cmo: odiff/odiff_parser.cmo

tdl/tdl_filter_parser.cmo: tdl/tdl_filter.cmo
tdl/tdl_filter_parser.cmx: tdl/tdl_filter.cmx
tdl/tdl_filter_parser.cmi: tdl/tdl_filter.cmi
tdl/tdl_filter_lexer.cmo: tdl/tdl_filter_parser.cmo
tdl/tdl_filter_lexer.cmx: tdl/tdl_filter_parser.cmx
tdl/tdl_filter_lexer.cmi: tdl/tdl_filter_parser.cmi
tdl/tdl.cmx:tdl/tdl_filter_lexer.cmx

.PRECIOUS: tdl/tdl_filter_parser.mli

$(OCAMLCVS_CMOFILES) $(OCAMLCVS_CMIFILES): $(LIBODIFF_CMI) $(LIBODIFF_BYTE) $(LIBODIFF_GUI_CMI) $(LIBODIFF_GUI_BYTE)
$(OCAMLCVS_CMXFILES) $(OCAMLCVS_CMIFILES): $(LIBODIFF_CMI) $(LIBODIFF) $(LIBODIFF_GUI_CMI) $(LIBODIFF_GUI)
#	echo
#	echo $(LIBODIFF_CMI) $(LIBODIFF) $(LIBODIFF_GUI_CMI) $(LIBODIFF_GUI)
#	echo
$(ODIFF_LIB_GUI_CMOFILES) $(ODIFF_LIB_GUI_CMIFILES): $(LIBODIFF_CMI) $(LIBODIFF_BYTE)
$(ODIFF_LIB_GUI_CMXFILES) $(ODIFF_LIB_GUI_CMIFILES): $(LIBODIFF_CMI) $(LIBODIFF)

ocamlcvs/ocvs_list.cmx: odiff/odiff_gui.cmxa

cameleon/cam_commands.cmo: cameleon/cam_commands.ml
	$(OCAMLC) $(COMPFLAGS) -c -pp "$(OCAMLBIN)/camlp4o" $<
cameleon/cam_commands.cmx: cameleon/cam_commands.ml
	$(OCAMLOPT) $(COMPFLAGS) -c -pp "$(OCAMLBIN)/camlp4o" $<
