# (c) 2001 jannet it services
# contact@jannet.de
# $Id$

ifndef YTOOLS_DEF_MK_INCLUDED
YTOOLS_DEF_MK_INCLUDED = true

include $(MODDIR)/make/platform.mk

# ----- pre-local.mk

ifneq ($(wildcard $(MODDIR)/make/pre-local.mk),)
include $(MODDIR)/make/pre-local.mk
endif

ifneq ($(wildcard $(TOPDIR)/make/pre-local.mk),)
include $(TOPDIR)/make/pre-local.mk
endif

ifneq ($(wildcard pre-local.mk),)
include pre-local.mk
endif

# ----- standard variables

ifeq ($(TARGET),mingw)
FLAVOUR_PREFIX        ?= win32-
FLAVOUR_SUFFIX        ?= -win32
FLAVOUR_PATH_PREFIX   ?= win32/
FLAVOUR_PATH_SUFFIX   ?= /win32
endif

PROJECT_DESCR_FILE    ?= $(wildcard $(TOPDIR)/doc/share/project.txt)
PROJECT               ?= $(patsubst $(FLAVOUR_PREFIX)%,%,$(notdir $(shell cd $(TOPDIR); pwd | sed 's/.*\///; s/-[0-9].*//')))
PROJECT_SHORT_NAME    ?= $(PROJECT)
PROJECT_CAPNAME        = $(shell echo $(PROJECT) | tr [a-z] [A-Z] | sed 's/-/_/g')
PROJECT_DESCR         ?= No description
CUSTOMER              ?= jannet

VERSION_FILE          ?= $(firstword $(wildcard VERSION $(TOPDIR)/VERSION))
VERSION               ?= $(shell cat $(VERSION_FILE))
DIST_VERSION          ?= $(shell sed -e "s/-dev//" $(VERSION_FILE))
HEX_VERSION            = $(shell echo $(DIST_VERSION) | \
	sed 's/-dev//; s/pre[^\.]*//; s/F[^\.]//; s/[\.-]/ /g' | xargs printf "0x%02x%02x%02x%02x")
BINARY_VERSION         = $(shell echo $(PROJECT)_$(DIST_VERSION) | tr [a-z] [A-Z] | sed 's/-[^-]*$$//; s/-/_/g') 
WINVERSION             = $(shell echo $(VERSION) | sed -e "s/\./_/g")
LOCAL_VERSION          = $(shell echo $(VERSION))
LOCAL_WINVERSION       = $(shell echo $(VERSION) | sed -e "s/\./_/g")
DIST_VERSION           = $(shell echo $(VERSION) | sed -e "s/-dev//")
DIST_WINVERSION        = $(shell echo $(WINVERSION) | sed -e "s/-dev//")
LOCAL_DIST_VERSION     = $(shell echo $(LOCAL_VERSION) | sed -e "s/-dev//")
LOCAL_DIST_WINVERSION  = $(shell echo $(LOCAL_WINVERSION) | sed -e "s/-dev//")
MAJOR_MINOR_RELEASE    = $(shell echo $(DIST_VERSION) | cut -d- -f1)
MAJOR_VERSION          = $(shell echo $(MAJOR_MINOR_RELEASE) | cut -d. -f1)
MINOR_VERSION          = $(shell echo $(MAJOR_MINOR_RELEASE) | cut -d. -f2)
RELEASE_VERSION        = $(shell echo $(MAJOR_MINOR_RELEASE) | cut -d. -f3)
BUILD_NUMBER           = $(shell echo $(DIST_VERSION) | cut -d- -f2)
CVS_RSH               ?= /usr/bin/ssh
ifneq ($(TARGET),mingw)
EXE                   ?= $(EXE_BASENAME)
else
EXE                   ?= $(EXE_BASENAME).exe
endif


# ----- input dirs
ifeq ($(PROJECT),ytools)
MOD_SCRIPT_DIR        ?= $(MODDIR)/devutil/scripts
else
MOD_SCRIPT_DIR        ?= $(firstword $(wildcard $(MODDIR)/devutil/scripts $(MODDIR)/bin))
endif
YTOOLS_DIR             = $(MODDIR)
PROJECT_STEM           = $(PROJECT)-$(DIST_VERSION)
CVS_ROOT_DIR           = $(shell test -d CVS && pwd | sed -e "s%`cat CVS/Repository`%%; s%/$$%%")
REV_SUBDIRS            = $(shell echo $(SUBDIRS) | awk '{for (i=NF; i>=1; i--) printf ("%s ",$$i)}')
FRESH_CVSDIR           = $(HOME)/local/src/cvs.fresh
IMAGE_DIR             ?= $(CVS_ROOT_DIR)/images
PCKG_DEPS_DIR          = $(MODDIR)/make/deps.d
PCKG_DEFS_DIR          = $(MODDIR)/make/defs.d

# ----- compilation options
USE_GFILTER           ?= true
TARGET                ?= Linux
OS                    ?= $(shell sh $(MOD_SCRIPT_DIR)/get_os.sh)
ifeq ($(shell uname -m),x86_64)
ARCH                   = x86_64
else
ARCH                   = x86
endif
FULL_NAME              = $(shell grep "^`id -nu`": /etc/passwd | cut -d: -f5)
DEVELOPMENT           ?= $(shell echo $(VERSION) | grep -q 'dev' && echo true)
USE_PROJECT_LIB       ?= true
USE_YTOOLS            ?= true
USE_EXCEPTIONS_IN_C   ?= true
REENTRANT             ?= true

export REENTRANT

USE_CFG_XXX_MK        ?= true
ifeq ($(USE_CFG_XXX_MK),true)
ifeq ($(DEVELOPMENT),true)
  -include $(MODDIR)/make/defs-dev.mk
  ifneq ($(wildcard $(TOPDIR)/make/cfg_dev.mk),)
	-include $(TOPDIR)/make/cfg_dev.mk
  endif
else
  -include $(MODDIR)/make/defs-dist.mk
  ifneq ($(wildcard $(TOPDIR)/make/cfg_dist.mk),)
	-include $(TOPDIR)/make/cfg_dist.mk
  endif
endif
endif

CFLAGS                += -D_FILE_OFFSET_BITS=64 -Wall -Wno-unused-value -fexceptions
CPPFLAGS              += -D_FILE_OFFSET_BITS=64 -Wall -Wno-unused-value -Wno-deprecated
LDFLAGS               += -Wall

ifeq ($(CATCH_ONLY_YERROR),true)
CFLAGS                += -DCATCH_ONLY_YERROR
CPPFLAGS              += -DCATCH_ONLY_YERROR
endif

ifneq ($(shell echo $(OS) | cut -d: -f1),suse-9)
SYSCFG_DIR            ?= /etc
SYSCFG_FILE           ?= /etc/rc.config
else
SYSCFG_DIR            ?= /etc/sysconfig
SYSCFG_FILE           ?= $(SYSCFG_DIR)/$(PROJECT)
endif
OPTS_PID_FILE         ?= $(PIDDIR)/$(PROJECT).pid

CFLAGS                += -DVERSION=$(HEX_VERSION)
CPPFLAGS              += -DVERSION=$(HEX_VERSION)

ifeq ($(TARGET),mingw)
CROSS_TOOL_DIR        ?= /opt/cross-tools
CROSS_TOOL_BIN_PREFIX ?= $(CROSS_TOOL_DIR)/bin/i686-pc-mingw32-
GCC                    = $(CROSS_TOOL_BIN_PREFIX)gcc
GPP                    = $(CROSS_TOOL_BIN_PREFIX)g++
STRIP                  = $(CROSS_TOOL_BIN_PREFIX)strip
RANLIB                 = $(CROSS_TOOL_BIN_PREFIX)ranlib
AR                     = $(CROSS_TOOL_BIN_PREFIX)ar
WINDRES                = $(CROSS_TOOL_BIN_PREFIX)windres
LDFLAGS               += -lws2_32
USE_GFILTER            = false
MS_LD                 ?= wine $(HOME)/local/mingw/packages/msvcpp/bin/LIB.EXE
LD                     = $(GPP)
else
GCC                    = gcc
GPP                    = g++
STRIP                  = strip
LD                     = $(GPP)
RANLIB                 = ranlib
AR                     = ar
endif

# makefile helpers
FIND_SUBDIRS           = $(filter-out . .. ./nomake ./CVS $(addprefix ./,$(IGNORE_SUBDIRS)), $(shell find . -maxdepth 1 -type d))
SUBDIRS_TO_ITERATE     = $(filter-out $(IGNORE_SUBDIRS),$(SUBDIRS))

# compiler and linker
GCC_VERSION            = $(shell  gcc -v 2>&1 | grep version | awk '{ print $$3;}')
GCC_MAJOR              = $(shell  gcc -v 2>&1 | grep version | awk '{ split($$3,a,"."); print a[1];}')
GCC_MINOR              = $(shell  gcc -v 2>&1 | grep version | awk '{ split($$3,a,"."); print a[2];}')
GCC_REV                = $(shell  gcc -v 2>&1 | grep version | awk '{ split($$3,a,"."); print a[3];}')

LD_VERSION             = $(shell ld --version | sed '/GNU ld/ !d; s/.*[^ ]\+\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/\1/')
LD_MAJOR               = $(shell echo $(LD_VERSION) | cut -d. -f1)
LD_MINOR               = $(shell echo $(LD_VERSION) | cut -d. -f2)
LD_REV                 = $(shell echo $(LD_VERSION) | cut -d. -f3)
UPDATE_REPO_SH         = /opt/packager-server/bin/packager-server schedule-rebuild

# -- target files and dirs

SRC_SUFFIX            += $(sort $(suffix $(wildcard $(TOPDIR)/hdr/*)))
LOCAL_SRC             += Makefile $(wildcard $(addprefix *,$(SRC_SUFFIX)))
SRC_HEADERED          += $(shell if [ "$(LOCAL_SRC)" ]; then grep -ic "it services" $(LOCAL_SRC) | sed '/:0$$/ d; s/:.*$$//'; fi)
SRC_UNHEADERED        += $(filter-out $(SRC_HEADERED),$(LOCAL_SRC))
LOCAL_C               += $(wildcard *.c)
LOCAL_CPP             += $(wildcard *.cc *.cpp *.C)
LOCAL_H               += $(wildcard *.h *.H)
SFILES                += $(wildcard *.S)
PREREQ_H              += $(foreach dir,$(PREREQ_DIR),$(wildcard $(dir)/*.h))
ALL_H                 += $(LOCAL_H) $(PREREQ_H)
SRC_ALL_CPP           += $(LOCAL_C) $(LOCAL_CPP) $(LOCAL_H)
SRC_C                 += $(filter %.c, $(SRC_ALL_CPP))
SRC_CPP               += $(filter %.cc %.cpp %.C, $(SRC_ALL_CPP))
OBJ                   += $(patsubst %.cpp,%.o,$(patsubst %.cc,%.o,$(patsubst %.c,%.o,$(filter %.c %.cpp %.cc, $(SRC_ALL_CPP)))))
OBJ                   += $(patsubst %.S,%.o,$(SFILES))

PREREQ_DIR            += $(addprefix $(MODDIR)/,$(LOCAL_PREREQ))
PREREQ_DONE           += $(addsuffix /all.done,$(PREREQ_DIR))
PREREQ_C              += $(foreach dir,$(PREREQ_DIR),$(wildcard $(dir)/*.c)) 
PREREQ_CPP            += $(foreach dir,$(PREREQ_DIR),$(wildcard $(dir)/*.c)) \
                         $(foreach dir,$(PREREQ_DIR),$(wildcard $(dir)/*.cpp)) 
PREREQ_CSRC           += $(PREREQ_H) $(PREREQ_C) $(PREREQ_CPP)

CONTRIB_MOD           += $(addprefix contrib/,$(CONTRIB_LIBS))
REQUIRED              := $(CONTRIB_MOD) $(REQUIRED)

REQUIRED_DIR          += $(patsubst %,$(MODDIR)/%,$(REQUIRED))
REQUIRED_DONE         += $(patsubst %,%/all.done,$(REQUIRED_DIR))
REQUIRED_H            += $(foreach dir,$(REQUIRED_DIR),$(wildcard $(dir)/*.h))  
REQUIRED_C            += $(foreach dir,$(REQUIRED_DIR),$(wildcard $(dir)/*.c)) 
REQUIRED_CPP          += $(foreach dir,$(REQUIRED_DIR),$(wildcard $(dir)/*.cpp)) \
                         $(foreach dir,$(PREREQ_DIR),$(wildcard $(dir)/*.cpp)) 
REQUIRED_CSRC         += $(REQUIRED_H) $(REQUIRED_C) $(REQUIRED_CPP)

ALL_C                 += $(LOCAL_C) $(PREREQ_CPP)
ALL_CPP               += $(LOCAL_CPP) $(PREREQ_CPP)
ALL_CSRC              += $(LOCAL_CSRC) $(PREREQ_CSRC)

FTP_PCKG_DIR           = /pub/packages
JANNET_PROJ_DIR        = rsync_ssh://ftp.jannet.de:/home/ftp/dat$(FTP_PCKG_DIR)
UPLOAD_URL_RPM_BIN     = rsync_ssh://ftp.jannet.de:/home/ftp/dat/pub/packages/rpm/bin/
UPLOAD_URL_RPM_SRC     = rsync_ssh://ftp.jannet.de:/home/ftp/dat/pub/packages/rpm/src/
PUBLIC_PATH_DEVEL_DOC  = /proj/devel-docs
UPLOAD_URL_DEVEL_DOC   = rsync_ssh://root@feitnix.jannet.de:/srv/www/htdocs/jannet.de_443/$(PUBLIC_PATH_DEVEL_DOC)

IMAGES                += $(wildcard *.png *.jpg *.bmp)

# -- standard dirs and files for build and install

# -- CFG
CONFIG_FILE           ?= $(CONFIG_DIR)/$(PROJECT).conf
SYSCFG_FILE           ?= $(SYSCFG_DIR)/$(PROJECT)
BUILD_CFGDIR           = $(TOPDIR)/conf
ifeq ($(CONFIG_SUBDIR),)
INSTALL_CFGDIR        ?= $(CONFIG_DIR)
else
INSTALL_CFGDIR        ?= $(CONFIG_DIR)/$(CONFIG_SUBDIR)
endif
LOCAL_CFG             ?= $(wildcard *.conf *.xml)
INSTALLED_CFG         ?= $(addprefix $(INSTALL_CFGDIR)/,$(LOCAL_CFG))

# -- SYSCFG
SYSCFG_FILES          += $(basename $(wildcard *.sysconf))
BUILD_SYSCFG           = $(TOPDIR)/conf
BUILD_SYSCFGDIR        = $(BUILD_SYSCFG)
INSTALL_SYSCFGDIR     ?= $(SYSCFG_DIR)
INSTALLED_SYSCFG      ?= $(addprefix $(INSTALL_SYSCFGDIR)/,$(SYSCFG_FILES))

# -- HDR
BUILD_HDRDIR          ?= $(TOPDIR)/include/$(HDRDIR_SCOPE_SUFFIX)
SRC_H                 += $(filter %.h %.H, $(SRC_ALL_CPP))
BUILD_H                = $(addprefix $(BUILD_HDRDIR)/,$(SRC_H))
BUILD_HDR              = $(addprefix $(BUILD_HDRDIR)/,$(SRC_H))
INSTALL_HDRDIR        ?= $(PREFIX)/include
INSTALLED_HDR         += $(addprefix $(INSTALL_HDRDIR)/,$(SRC_H))

# -- DOC
DOCS                  += $(wildcard VERSION README CHANGES TODO LICENSE AUTHORS CREDITS *.pdf *.txt *.html)
DOCSUBDIRS            += $(wildcard html tex info examples src)

BUILD_DOCDIR          ?= $(TOPDIR)/doc
BUILD_DOC             ?= $(DOC_PREFIX)
# TODO: use INSTALL_DOCDIR ?= $(DOC_PREFIX) which currently would break
#       <MODULE>_VERSION below
INSTALL_DOCDIR        ?= $(PREFIX)
INSTALLED_DOC         ?= $(addprefix $(INSTALL_DOCDIR)/,$(DOCS))

# -- LIB

#BUILD_PIDIR            = $(BUILD_LIBDIR)
#BUILD_PI               = $(addprefix $(BUILD_PIDIR)/,$(PLUGIN))
#INSTALL_PIDIR          = $(INSTALL_LIBDIR)
#INSTALLED_PI           = $(addprefix $(INSTALL_PIDIR)/,$(PLUGIN))

BUILD_LIBDIR           = $(TOPDIR)/lib
LOCAL_LIBS            += $(CONTRIB_LIBS) $(PLUGIN)
ifeq ($(TARGET),mingw)
CONTRIB_LIBS_PATH     += $(CROSS_TOOL_DIR)/bin
endif

LIBTYPE               ?= shared
INSTALL_LIBDIR        ?= $(EXE_PREFIX)/lib
ifeq ($(USE_PROJECT_LIB),true)
LIBNAME               ?= $(PROJECT)
MEMBERS               += $(LIB_A)($(OBJ))
VERSION_SCRIPT         = $(BUILD_LIBDIR)/version.ldscript
# TODO: use something like this as unifying variable, there are far too many
#       lib-related variables
LOCAL_LIBS            +=
ifneq ($(TARGET),mingw)
LIB_A                  = $(BUILD_LIBDIR)/lib$(LIBNAME).a
SO_SUFFIX              = so.$(shell echo $(VERSION) | cut -d- -f1)
SO_PREFIX             ?= lib
LIB_SO                 = $(BUILD_LIBDIR)/lib$(LIBNAME).$(SO_SUFFIX)
LINKS_SO              += $(shell echo $(LIB_SO) | sed -e "s/\.so\..*$$/.so/" | grep -v $(LIB_SO))
INSTALLED_LINKS_SO    += $(shell echo $(INSTALLED_LIB_SO) | sed -e "s/\.so\..*$$/.so/" | grep -v $(INSTALLED_LIB_SO))
INSTALLED_LIB_A        = $(INSTALL_LIBDIR)/lib$(LIBNAME).a
else
LIB_A                  = $(BUILD_LIBDIR)/lib$(LIBNAME)-static.a
#WINRES_RC_TMPL         = $(MODDIR)/make/winres-minimal.rc.tmpl
WINRES_RC_TMPL         = $(MODDIR)/make/winres.rc.tmpl
WINRES_RC              = $(BUILD_LIBDIR)/$(PROJECT).rc
WINRES_O               = $(WINRES_RC).o
SO_SUFFIX              = dll
SO_PREFIX             ?=
LIB_DEF                = $(BUILD_LIBDIR)/$(LIBNAME).def
MSVCPP_IMPLIB          = $(BUILD_LIBDIR)/$(LIBNAME).lib
LIB_SO                 = $(BUILD_LIBDIR)/$(LIBNAME).dll
INSTALLED_LIB_A        = $(INSTALL_LIBDIR)/lib$(LIBNAME).a
endif # mingw
endif # USE_PROJECT_LIB
INSTALLED_LIB_SO       = $(addprefix $(INSTALL_LIBDIR)/,$(notdir $(LIB_SO)))
INSTALLED_DEF          = $(addprefix $(INSTALL_LIBDIR)/,$(wildcard *.lib *.exp))
INSTALLED_LIB         += $(addprefix $(INSTALL_LIBDIR)/,$(LOCAL_LIBS))
BUILD_LIB             += $(addprefix $(BUILD_LIBDIR)/,$(LOCAL_LIBS))
INSTALLED_ALL_LIBS     = $(addprefix $(INSTALL_LIBDIR)/,$(wildcard *.a))
INSTALLED_LIB         += $(INSTALLED_LIB_SO) $(INSTALLED_SHOBJS) \
	$(INSTALLED_LINKS_SO) $(sort $(INSTALLED_LIB_A) $(INSTALLED_ALL_LIBS)) \
	$(INSTALLED_DEF)
BUILD_LIB             += $(LIB_SO)

## -- PI
#BUILD_PIDIR            = $(BUILD_LIBDIR)
#BUILD_PI               = $(addprefix $(BUILD_PIDIR)/,$(PLUGIN))
#INSTALL_PIDIR          = $(INSTALL_LIBDIR)
#INSTALLED_PI           = $(addprefix $(INSTALL_PIDIR)/,$(PLUGIN))

# -- EXE
EXE_SH                += $(wildcard *.sh *.pl *.pm *.py *.bat)
EXE_SH                += $(patsubst %.sh.tmpl,%.sh,$(wildcard *.sh.tmpl))

#EXE_ALL               += $(EXE) $(wildcard *.a *.dll *.so *.so.*)
BUILD_EXE_BIN         += $(addprefix $(BUILD_EXEDIR)/,$(EXE) $(EXE_SH))
INSTALLED_EXE_BIN     += $(addprefix $(INSTALL_EXEDIR)/,$(EXE_BIN))

BUILD_EXEDIR           = $(TOPDIR)/bin
INSTALL_EXEDIR        ?= $(EXE_PREFIX)/bin
BUILD_EXE             += $(BUILD_EXE_BIN)
INSTALLED_EXE         += $(addprefix $(INSTALL_EXEDIR)/,$(EXE) $(EXE_SH)) $(INSTALLED_EXE_BIN)

# -- SCRIPT

#BUILD_SCRIPTDIR        = $(TOPDIR)/bin
#INSTALL_SCRIPTDIR     ?= $(EXE_PREFIX)/bin
#BUILD_SCRIPT          += $(addprefix $(BUILD_SCRIPTDIR)/,$(EXE_SH))
#INSTALLED_SCRIPT      += $(addprefix $(INSTALL_SCRIPTDIR)/,$(EXE_SH))

# -- CGI
EXE_CGI               += $(wildcard *.cgi)
EXE_CGI               += $(patsubst %.cgi.tmpl,%.cgi,$(wildcard *.cgi.tmpl))

BUILD_CGIDIR           = $(TOPDIR)/bin
INSTALL_CGIDIR         = $(CGI_DIR)
BUILD_CGI             += $(addprefix $(BUILD_CGIDIR)/,$(EXE_CGI))
INSTALLED_CGI         += $(addprefix $(INSTALL_CGIDIR)/,$(EXE_CGI))

# -- HTML
BUILD_HTMLDIR          = $(TOPDIR)/htdocs
LOCAL_HTML            += $(wildcard *.html *.css *.php) $(IMAGES)
HTML_SUBDIR           ?= $(shell pwd | sed 's%.*/htdocs/%%')
ifeq ($(HTML_SUBDIR),)
INSTALL_HTMLDIR        = $(PROJECT_HTMLDIR)
else
INSTALL_HTMLDIR        = $(PROJECT_HTMLDIR)/$(HTML_SUBDIR)
endif
INSTALLED_HTML        += $(addprefix $(INSTALL_HTMLDIR)/,$(LOCAL_HTML))

# -- INIT
BUILD_INITDIR          = $(TOPDIR)/bin
INSTALL_INITDIR        = $(INIT_PREFIX)/init.d
_INIT_SCRIPTS          = $(basename $(wildcard *.init))
INIT_SCRIPTS          += $(_INIT_SCRIPTS)
BUILD_INIT            += $(addprefix $(BUILD_INITDIR)/,$(INIT_SCRIPTS))
INSTALLED_INIT        += $(addprefix $(INSTALL_INITDIR)/,$(INIT_SCRIPTS))

# -- MAKE
BUILD_MAKEDIR          = $(TOPDIR)/make
MKFILES               += $(filter-out pckg-defs.mk pckg-deps.mk local.mk,$(wildcard *.mk))
INSTALL_MAKEDIR       ?= $(PREFIX)/make
INSTALLED_MAKE        += $(addprefix $(INSTALL_MAKEDIR)/,$(MKFILES))

# -- IMG
BUILD_IMG             ?= 
BUILD_IMGDIR          ?= $(TOPDIR)/images
INSTALL_IMGDIR        ?= $(IMG_PREFIX)/images
INSTALLED_IMG         ?= $(addprefix $(INSTALL_IMGDIR)/,$(IMAGES))

# -- LOG
BUILD_LOGDIR          ?= $(TOPDIR)/log
BUILD_LOG             ?= 
INSTALL_LOGDIR        ?= $(LOG_PREFIX)/$(PROJECT)
INSTALLED_LOG         ?= 

# -- PROFILE
# TODO: path_ file is omnipresent
BUILD_PROFILEDIR       = $(TOPDIR)/profile.d
#PROFILE               += path_$(PROJECT).sh
INSTALL_PROFILEDIR    ?= $(PROFILE_DIR)
INSTALLED_PROFILE     ?= $(addprefix $(INSTALL_PROFILEDIR)/,$(PROFILE))

# -- JAVA
BUILD_JAVADIR           = $(TOPDIR)/share/java
BUILD_JAVADIR_CLASSES   = classes
JAVA_JARS              ?= $(wildcard *.jar)
INSTALL_JAVADIR        ?= $(JAVADIR)
INSTALLED_JAVA         ?= $(addprefix $(INSTALL_JAVADIR)/,$(JAVA_JARS))

# -- LD_CONF
ifneq ($(TARGET),mingw)
LD_CONF            += ld-$(PROJECT).conf
BUILD_LD_CONFDIR    = $(TOPDIR)/lib/ld.so.conf.d
INSTALL_LD_CONFDIR  = $(LD_CONF_DIR)
INSTALLED_LD_CONF   = $(addprefix $(INSTALL_LD_CONFDIR)/,$(LD_CONF))
endif

# -- LOGROT
ifneq ($(TARGET),mingw)
LOGROT            += $(basename $(wildcard *.logrotate))
BUILD_LOGROTDIR    = $(TOPDIR)/bin/logrotate.d
INSTALL_LOGROTDIR  = $(LOGROT_DIR)
INSTALLED_LOGROT   = $(addprefix $(INSTALL_LOGROTDIR)/,$(LOGROT))
endif

# -- RSYSLOG
ifneq ($(TARGET),mingw)
RSYSLOG           += $(wildcard *.rsyslog)
BUILD_RSYSLOGDIR   = $(TOPDIR)/bin/rsyslog.d
INSTALL_RSYSLOGDIR = $(RSYSLOG_DIR)
INSTALLED_RSYSLOG  = $(addprefix $(INSTALL_RSYSLOGDIR)/,$(patsubst %.rsyslog,%.conf,$(RSYSLOG)))
endif

# -- CRONTAB
ifneq ($(TARGET),mingw)
CRONTAB             += $(wildcard *.crontab)
BUILD_CRONTABDIR    = $(TOPDIR)/cron.d
INSTALLED_CRONTAB   = $(addprefix $(INSTALL_CRONTABDIR)/,$(CRONTAB))
endif

# ==

ifeq ($(DEVELOPMENT),true)
	CFLAGS        += -D_DEVELOPMENT_
	CPPFLAGS      += -D_DEVELOPMENT_
endif

CORE                  += $(wildcard core core.* vgcore vgcore.*)

ifeq ($(GCC_MAJOR),4)
	CFLAGS        += -DGCC_HASCLASSVISIBILITY
	CPPFLAGS      += -DGCC_HASCLASSVISIBILITY
endif

ifeq ($(USE_QT),true)
	include $(MODDIR)/make/qt-defs.mk
endif

ifeq ($(USE_X),true)
  ifeq ($(ARCH),x86)
    LDFLAGS           += -L/usr/X11/lib -lXext -lX11
  else
    LDFLAGS           += -L/usr/X11/lib64 -lXext -lX11
  endif
endif

LPPFLAGS              += -lstdc++

ifeq ($(ARCH),x86_64)
	CFLAGS        += -fPIC
	CPPFLAGS      += -fPIC
	LIBFLAGS      +=
endif

ifeq ($(GCC_MAJOR),2)
LPPFLAGS              += -lm
CFLAGS                += -I/usr/local/include
CPPFLAGS              += -I/usr/local/include
else
  ifeq ($(GCC_MAJOR),3)
    ifeq ($(GCC_MINOR),3)
      LPPFLAGS          += -lgcc_s
      # LPPFLAGS          += -L/usr/local/gcc3.3/lib
    endif
  endif
endif

ifeq ($(LIBTYPE),shared)
  ifneq ($(TARGET),mingw)
	LDFLAGS               += -rdynamic
  endif
endif

# TODO: this shoud be only conditional, but breaks, because not all headers
#       do a conditional include of timer headers, yet
GENERATE_FUNC_TIMERS   = $(MODDIR)/YStopWatchThreadList/generate_func_timers.sh

RM                     = rm
AR                     = ar

ifeq ($(LOG_THREAD_NAMES), true)
	CFLAGS        += -DSLOG_THREAD_NAMES
	CPPFLAGS      += -DSLOG_THREAD_NAMES
endif

ifdef INSTALL_LOG
	INSTALL=$(MOD_SCRIPT_DIR)/log_install.sh -l $(INSTALL_LOG)
	LINK_LIB=$(MOD_SCRIPT_DIR)/log_install.sh -L -l $(INSTALL_LOG)
else
	ifndef INSTALL
		INSTALL      = install
	endif
	ifndef LINK_LIB
		LINK_LIB=$(MOD_SCRIPT_DIR)/log_install.sh -L
	endif
endif


# ----- function definitions

define make_subdirs
	set -e; for D in $(SUBDIRS) ; do make -C $$D ; done
endef

define make_subdirs_target
	set -e; for D in $(SUBDIRS) ; do make -C $$D $@; done
endef

define install_local_cfg
	$(INSTALL) -o $(CFGOWNER) -g $(CFGGROUP) -m $(CFGMODE) $< $@
endef

define cvs_files
	sh $(MOD_SCRIPT_DIR)/list-cvs-files.sh
endef

define add_flavour_prefix
	sed "s/\([^ ][^ ]*\) *\([<>=]*\) *\([^ ]*\)/$(FLAVOUR_PREFIX)\1 \2 \3/g"
endef

define beautify_lib_path
	sed 's/:/\n  + /g'
endef

#$(shell cat $1/VERSION | sed 's/-dev//; s/-[^-]*$$//')
define cat_version
$(shell cat $1/VERSION | sed 's/-dev//')
endef

define version
$(shell cat $1/VERSION | sed 's/-.*//')
endef

define install_links
	cwd=`pwd`; \
		echo "o in $(INSTALL_$(1)DIR):" ;\
		for f in $(notdir $(INSTALLED_$(1))); do  \
			cd $(INSTALL_$(1)DIR); \
			echo "  sudo ln -sf $$cwd/$$f" ; \
			sudo ln -sf $$cwd/$$f; \
		done;
endef

# ----- local.mk

ifneq ($(wildcard $(MODDIR)/make/local.mk),)
include $(MODDIR)/make/local.mk
endif

ifneq ($(wildcard $(TOPDIR)/make/local.mk),)
include $(TOPDIR)/make/local.mk
endif

ifneq ($(wildcard local.mk),)
include local.mk
endif

# ----- standard features, switched on with USE_XXX = true

CPP                   ?= g++

ifeq ($(USE_GFILTER),true)
	GFILT          = sh $(firstword $(wildcard $(MODDIR)/contrib/gfilt/gfilt $(MODDIR)/bin/gfilt))
	ifneq ($(strip $(GFILT)),sh)
		GPP    = $(GFILT)
	endif
endif

CC                     = $(GCC)
CPP                    = $(GPP)

PROJECTLIB_LDFLAGS  += -L$(TOPDIR)/lib

ifeq ($(USE_PROJECT_LIB),true)
	PROJECTLIB_LDFLAGS    += -l$(LIBNAME)
endif

ifeq ($(USE_YTOOLS),true)
	ifeq ($(TARGET),mingw)
	YTOOLS_LDFLAGS        += -lglib-2.0 -lws2_32 -lstdc++
	endif
endif

ifeq ($(USE_TIMER),true)
	CFLAGS      += -D_USE_TIMER_
	CPPFLAGS    += -D_USE_TIMER_
endif

ifeq ($(USE_GCOV),true)
	CFLAGS      += --coverage
	CPPFLAGS    += --coverage
	LDFLAGS     += --coverage
endif

ifeq ($(USE_PROFILER),true)
	CFLAGS      += -pg
	CPPFLAGS    += -pg
	LDFLAGS     += -pg
endif

ifeq ($(USE_YAMD),true)
	CC           = yamd-gcc
endif

ifeq ($(USE_MPATROL),true)
	CFLAGS      += -include /usr/include/mpatrol.h
	#CPPFLAGS   += -include /usr/include/mpatrol.h
	LDFLAGS     += -lmpatrolmt -lbfd -liberty
endif

ifeq ($(USE_VALGRIND),true)
	CFLAGS      += -include /usr/include/valgrind/memcheck.h -D_VALGRIND_
	CPPFLAGS    += -include /usr/include/valgrind/memcheck.h -D_VALGRIND_
	# LDFLAGS   += 
endif

ifeq ($(USE_STACK_PROTECTOR),true)
	CFLAGS      += -fstack-protector-all
#	CFLAGS      += -fstack-protector
endif

ifeq ($(USE_DBMALLOC),true)
	CONTRIB_LIBS += dbmalloc
	CFLAGS      += -DDBMALLOC -DEXITFUN=_exit -I$(TOPDIR)/contrib/dbmalloc
	CPPFLAGS    += -DDBMALLOC -DEXITFUN=_exit -I$(TOPDIR)/contrib/dbmalloc
	LDFLAGS     += -ldbmalloc
endif

ifeq ($(USE_DMALLOC),true)
	CFLAGS      += -DDMALLOC -DDMALLOC_FUNC_CHECK -DSTORE_SEEN_COUNT
	CPPFLAGS    += -DDMALLOC -DDMALLOC_FUNC_CHECK -DSTORE_SEEN_COUNT
	LDFLAGS     += -ldmallocthcxx -ldmallocth
endif

ifeq ($(USE_MEMWATCH),true)
	CFLAGS      += -DMEMWATCH -DMW_STDIO
	CPPFLAGS    += -DMEMWATCH -DMW_STDIO
endif

ifeq ($(USE_EFENCE),true)
	CFLAGS      += -DEFENCE
	CPPFLAGS    += -DEFENCE
	LDFLAGS     += -lefence
endif

ifeq ($(USE_TRACING),true)
	CFLAGS      += -D_DO_TRACE_
	CPPFLAGS    += -D_DO_TRACE_
endif

ifeq ($(USE_ASSERTIONS),false)
	CFLAGS      += -DNDEBUG
	CPPFLAGS    += -DNDEBUG
endif

ifeq ($(COMPILE_DEBUG_CODE),true)
	CFLAGS      += -D_DEBUG_
	CPPFLAGS    += -D_DEBUG_
endif

ifeq ($(COMPILE_DEBUG_LOG),true)
	CFLAGS      += -D_LOG_DEBUG_
	CPPFLAGS    += -D_LOG_DEBUG_
endif

ifeq ($(USE_MPATROL),true)
	CFLAGS      += -include $(MODDIR)/include/mpatrol.h
	CPPFLAGS    += -include $(MODDIR)/include/mpatrol.h
	LDFLAGS     += -lmpatrolmt -lbfd -liberty
endif

ifeq ($(BREAK_ABI),true)
	CFLAGS      += -D_BREAK_ABI_
	CPPFLAGS    += -D_BREAK_ABI_
endif

ifeq ($(USE_STACK_CHECK),true)
	CFLAGS      += -fstack-check
	CPPFLAGS    += -fstack-check
endif

ifeq ($(USE_COMPILER_DEBUG_OPTS),true)
	CFLAGS      += -g3
	CPPFLAGS    += -g3
	LDFLAGS     += -g3
endif

ifeq ($(USE_COMPILER_OPTIMIZATION_OPTS),true)
	CFLAGS      += -funroll-loops -O2
	CPPFLAGS    += -funroll-loops -O2
else
	_NO_OPT_FLAGS = \
		-O0 \
		-fno-implicit-inline-templates \
		-fno-implement-inlines \
		-fno-default-inline \
		-fno-inline \
		-finline-limit=0 \
		-fkeep-inline-functions \
		-fno-inline-functions-called-once \
		-fno-inline-functions \
		-fno-early-inlining
	CFLAGS      += $(NO_OPT_FLAGS)
	CPPFLAGS    += $(NO_OPT_FLAGS)
	LDFLAGS     += $(NO_OPT_FLAGS)
endif

ifeq ($(USE_EXCEPTIONS_IN_C),true)
	CFLAGS      += -fexceptions
	LDFLAGS     += -shared-libgcc
endif

ifeq ($(STRIP_SYMBOLS),true)
	STRIP_DONE  ?= strip.done
endif

INCLUDE               += $(LOCAL_INCLUDE) -I.

ifeq ($(USE_PROJECT_LIB),true)
INCLUDE               += $(PROJECT_INCLUDE) -I$(TOPDIR)/include 
LIBFLAGS              += -L$(BUILD_LIBDIR)
endif

# -- use of supplementary libraries

ifeq ($(USE_CCASFS),true)
CCASFS_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/ccasfs /opt/$(FLAVOUR_PATH_PREFIX)dspider/ccasfs))
CCASFS_VERSION             = $(call version,$(CCASFS_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-ccasfs-run = $(CCASFS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-ccasfs-devel = $(CCASFS_VERSION)
USE_YTOOLS                 = true
USE_CCONSOLE               = true
INCLUDE                   += -I$(CCASFS_DIR)/include
#LIBFLAGS                  += -L$(CCONSOLE_DIR)/lib -lcconsole
EXE_SEARCH_PATH           += $(CCASFS_DIR)/bin
endif

ifeq ($(USE_CCONSOLE),true)
CCONSOLE_DIR               = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/cconsole /opt/$(FLAVOUR_PATH_PREFIX)dspider/cconsole))
CCONSOLE_VERSION           = $(call version,$(CCONSOLE_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-cconsole-run = $(CCONSOLE_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-cconsole-devel = $(CCONSOLE_VERSION)
INCLUDE                   += -I$(CCONSOLE_DIR)/include
ifeq ($(DEVELOPMENT),true)
LIBFLAGS                  += -L$(CCONSOLE_DIR)/lib
else
# this is actually redundant to a definition in proj/dspc/src/cconsole/make/cfg_dist.mk:
LIBFLAGS                  += -L$(ENV_PREFIX)/opt/$(FLAVOUR_PATH_PREFIX)dspider/feedfs/bin
endif
LIBFLAGS                  += -ldspider-cconsole
EXE_SEARCH_PATH           += $(CCONSOLE_DIR)/bin
endif

ifeq ($(USE_DSPCD),true)
DSPCD_DIR                  = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dspcd /opt/$(FLAVOUR_PATH_PREFIX)dspider/dspcd))
DSPCD_EXE_PREFIX           = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dspcd /opt/$(FLAVOUR_PATH_PREFIX)dspider))
# include $(DSPCD_DIR)/make/public.mk
DSPIDER_DSPCD_VERSION      = $(call version,$(DSPCD_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-dspcd-run = $(DSPIDER_DSPCD_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-dspcd-devel = $(DSPIDER_DSPCD_VERSION)
USE_YTOOLS                 = true
USE_DSPIDER_SHARED         = true
USE_USERVER                = true
INCLUDE                   += -I$(DSPCD_DIR)/include
LIBFLAGS                  += -L$(DSPCD_EXE_PREFIX)/lib -ldspcd
EXE_SEARCH_PATH           += $(DSCD_DIR)/bin
endif

ifeq ($(USE_DSPROUT),true)
DSPROUT_DIR                = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dsprout /opt/dspider/$(FLAVOUR_PATH_PREFIX)dsprout))
DSPROUT_EXE_PREFIX         = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dsprout /opt/$(FLAVOUR_PATH_PREFIX)dspider))
DSPROUT_VERSION            = $(call version,$(DSPROUT_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dsprout-run = $(DSPROUT_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dsprout-devel = $(DSPROUT_VERSION)
USE_YTOOLS                 = true
USE_DSPIDER_SHARED         = true
USE_USERVER                = true
INCLUDE                   += -I$(DSPROUT_DIR)/include
LIBFLAGS                  += -L$(DSPROUT_EXE_PREFIX)/lib -ldsprout
EXE_SEARCH_PATH           += $(DSPROUT_DIR)/bin
endif

ifeq ($(USE_DSPIDER_SHARED),true)
DSPIDER_SHARED_DIR         = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/shared /opt/$(FLAVOUR_PATH_PREFIX)dspider/shared))
DSPIDER_SHARED_EXE_PREFIX  = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/shared /opt/$(FLAVOUR_PATH_PREFIX)dspider))
include $(DSPIDER_SHARED_DIR)/make/public.mk
DSPIDER_SHARED_VERSION     = $(call version,$(DSPIDER_SHARED_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-shared-run = $(DSPIDER_SHARED_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-shared-devel = $(DSPIDER_SHARED_VERSION)
USE_YTOOLS                 = true
INCLUDE                   += -I$(DSPIDER_SHARED_DIR)/include
LIBFLAGS                  += -L$(DSPIDER_SHARED_EXE_PREFIX)/lib -ldspider-shared
EXE_SEARCH_PATH           += $(DSPIDER_SHARED_DIR)/bin
endif

ifeq ($(USE_FEEDFS_QT),true)
FEEDFS_QT_DIR              = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-qt /opt/$(FLAVOUR_PATH_PREFIX)feedfs-qt))
FEEDFS_QT_VERSION          = $(call version,$(FEEDFS_QT_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-qt-run = $(FEEDFS_QT_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-qt-devel = $(FEEDFS_QT_VERSION)
USE_FEEDFS_UTILS           = true
USE_FEEDFS                 = true
USE_YTOOLS                 = true
INCLUDE                   += -I$(FEEDFS_QT_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_QT_DIR)/lib -lfeedfs-qt
EXE_SEARCH_PATH           += $(FEEDFS_QT_DIR)/bin
endif

ifeq ($(USE_FEEDFS_GUI),true)
FEEDFS_GUI_DIR             = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-gui /opt/$(FLAVOUR_PATH_PREFIX)feedfs-gui))
FEEDFS_GUI_VERSION         = $(call version,$(FEEDFS_GUI_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-gui-run = $(FEEDFS_GUI_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-gui-devel = $(FEEDFS_GUI_VERSION)
USE_FEEDFS_UTILS           = true
USE_FEEDFS                 = true
USE_YTOOLS                 = true
USE_FEEDFS_QT              = true
INCLUDE                   += -I$(FEEDFS_GUI_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_GUI_DIR)/lib -lfeedfs-gui
EXE_SEARCH_PATH           += $(FEEDFS_GUI_DIR)/bin
endif

ifeq ($(USE_FEEDFSD),true)
FEEDFSD_DIR                = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfsd /opt/$(FLAVOUR_PATH_PREFIX)feedfsd))
FEEDFSD_VERSION            = $(call version,$(FEEDFSD_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfsd-run = $(FEEDFSD_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfsd-devel = $(FEEDFSD_VERSION)
USE_FEEDFS                 = true
USE_YTOOLS                 = true
INCLUDE                   += -I$(FEEDFSD_DIR)/include
LIBFLAGS                  += -L$(FEEDFSD_DIR)/lib -lfeedfsd
EXE_SEARCH_PATH           += $(FEEDFSD_DIR)/bin
endif

ifeq ($(USE_FEEDFS_LDAP),true)
FEEDFS_LDAP_DIR            = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-ldap /opt/$(FLAVOUR_PATH_PREFIX)feedfs-ldap))
FEEDFS_LDAP_VERSION        = $(call version,$(FEEDFS_LDAP_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-ldap-run = $(FEEDFS_LDAP_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-ldap-devel = $(FEEDFS_LDAP_VERSION)
USE_FEEDFS                 = true
USE_YTOOLS                 = true
INCLUDE                   += -I$(FEEDFS_LDAP_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_LDAP_DIR)/lib -lfeedfs-ldap -lldap
EXE_SEARCH_PATH           += $(FEEDFS_LDAP_DIR)/bin
endif

ifeq ($(USE_FEEDFS_UTILS),true)
FEEDFS_UTILS_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-utils /opt/$(FLAVOUR_PATH_PREFIX)feedfs-utils))
FEEDFS_UTILS_VERSION       = $(call version,$(FEEDFS_UTILS_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-utils-run = $(FEEDFS_UTILS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-utils-devel = $(FEEDFS_UTILS_VERSION)
USE_FEEDFS_OBJECTS         = true
USE_FEEDFS                 = true
USE_YTOOLS                 = true
INCLUDE                   += -I$(FEEDFS_UTILS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_UTILS_DIR)/lib -lfeedfs-utils
EXE_SEARCH_PATH           += $(FEEDFS_UTILS_DIR)/bin
endif

ifeq ($(USE_FEEDFS_NET),true)
FEEDFS_NET_DIR             = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-net /opt/$(FLAVOUR_PATH_PREFIX)feedfs-net))
FEEDFS_NET_VERSION         = $(call version,$(FEEDFS_NET_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-net-run = $(FEEDFS_NET_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-net-devel = $(FEEDFS_NET_VERSION)
USE_FEEDFS_OBJECTS         = true
USE_FEEDFS_UTILS           = true
USE_XCHANGE                = true
USE_YTOOLS                 = true
INCLUDE                   += -I$(FEEDFS_NET_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_NET_DIR)/lib -lfeedfs-net
EXE_SEARCH_PATH           += $(FEEDFS_NET_DIR)/bin
endif

ifeq ($(USE_FEEDFS_LOCAL),true)
FEEDFS_LOCAL_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-local /opt/$(FLAVOUR_PATH_PREFIX)feedfs-local))
FEEDFS_LOCAL_VERSION       = $(call version,$(FEEDFS_LOCAL_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-local-run = $(FEEDFS_LOCAL_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-local-devel = $(FEEDFS_LOCAL_VERSION)
USE_FEEDFS                 = true
# no build-time linkage necessary, no headers exported
LD_LIB_PATH               += $(FEEDFS_LOCAL_DIR)/lib
EXE_SEARCH_PATH           += $(FEEDFS_LOCAL_DIR)/bin
endif

ifeq ($(USE_FEEDFS_REWRITE),true)
FEEDFS_REWRITE_DIR         = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-rewrite /opt/$(FLAVOUR_PATH_PREFIX)feedfs-rewrite))
FEEDFS_REWRITE_VERSION     = $(call version,$(FEEDFS_REWRITE_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-rewrite-run = $(FEEDFS_REWRITE_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-rewrite-devel = $(FEEDFS_REWRITE_VERSION)
USE_FEEDFS                 = true
# no build-time linkage necessary, no headers exported
LD_LIB_PATH               += $(FEEDFS_REWRITE_DIR)/lib
EXE_SEARCH_PATH           += $(FEEDFS_REWRITE_DIR)/bin
LIBFLAGS                  += -lboost_regex
endif

ifeq ($(USE_FEEDFS_FMEMFS),true)
FEEDFS_FMEMFS_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-fmemfs /opt/$(FLAVOUR_PATH_PREFIX)feedfs-fmemfs))
FEEDFS_FMEMFS_VERSION       = $(call version,$(FEEDFS_FMEMFS_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-fmemfs-run = $(FEEDFS_FMEMFS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-fmemfs-devel = $(FEEDFS_FMEMFS_VERSION)
USE_FEEDFS                 = true
# no build-time linkage necessary, no headers exported
LD_LIB_PATH               += $(FEEDFS_FMEMFS_DIR)/lib
INCLUDE                   += -I$(FEEDFS_FMEMFS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_FMEMFS_DIR)/lib -lfeedfs-fmemfs
EXE_SEARCH_PATH           += $(FEEDFS_FMEMFS_DIR)/bin
endif

ifeq ($(USE_FEEDFS_SYSLOG),true)
FEEDFS_SYSLOG_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-syslog /opt/$(FLAVOUR_PATH_PREFIX)feedfs-syslog))
FEEDFS_SYSLOG_VERSION       = $(call version,$(FEEDFS_SYSLOG_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-syslog-run = $(FEEDFS_SYSLOG_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-syslog-devel = $(FEEDFS_SYSLOG_VERSION)
USE_FEEDFS                 = true
# no build-time linkage necessary, no headers exported
LD_LIB_PATH               += $(FEEDFS_SYSLOG_DIR)/lib
INCLUDE                   += -I$(FEEDFS_SYSLOG_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_SYSLOG_DIR)/lib -lfeedfs-syslog
EXE_SEARCH_PATH           += $(FEEDFS_SYSLOG_DIR)/bin
endif

ifeq ($(USE_FEEDFS_OBJECTS),true)
FEEDFS_OBJECTS_DIR         = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-objects /opt/$(FLAVOUR_PATH_PREFIX)feedfs-objects))
FEEDFS_OBJECTS_VERSION     = $(call version,$(FEEDFS_OBJECTS_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-objects-run = $(FEEDFS_OBJECTS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-objects-devel = $(FEEDFS_OBJECTS_VERSION)
USE_FEEDFS                 = true
USE_YTOOLS                 = true
INCLUDE                   += -I$(FEEDFS_OBJECTS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_OBJECTS_DIR)/lib -lfeedfs-objects
EXE_SEARCH_PATH           += $(FEEDFS_OBJECTS_DIR)/bin
endif

ifeq ($(USE_FEEDFS),true)
FEEDFS_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs /opt/$(FLAVOUR_PATH_PREFIX)feedfs))
FEEDFS_VERSION             = $(call version,$(FEEDFS_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-run = $(FEEDFS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-devel = $(FEEDFS_VERSION)
USE_YTOOLS                 = true
USE_VALDI                  = true
USE_AUTH                   = true
INCLUDE                   += -I$(FEEDFS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_DIR)/lib -lfeedfs
EXE_SEARCH_PATH           += $(FEEDFS_DIR)/bin
endif

ifeq ($(USE_USERVER),true)
USERVER_DIR                = $(firstword $(wildcard $(CVS_PROJ_DIR)/userver /opt/$(FLAVOUR_PATH_PREFIX)userver))
USERVER_VERSION            = $(call version,$(USERVER_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)userver-run = $(USERVER_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)userver-devel = $(USERVER_VERSION)
USE_XCHANGE                = true
USE_YTOOLS                 = true
INCLUDE                   += -I$(USERVER_DIR)/include
LIBFLAGS                  += -L$(USERVER_DIR)/lib -luserver
EXE_SEARCH_PATH           += $(USERVER_DIR)/bin
endif

ifeq ($(USE_XCHANGE),true)
XCHANGE_DIR                = $(firstword $(wildcard $(CVS_PROJ_DIR)/xchange /opt/$(FLAVOUR_PATH_PREFIX)xchange))
XCHANGE_VERSION            = $(call version,$(XCHANGE_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)xchange-run = $(XCHANGE_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)xchange-devel = $(XCHANGE_VERSION)
USE_YTOOLS                 = true
USE_VALDI                  = true
INCLUDE                   += -I$(XCHANGE_DIR)/include
LIBFLAGS                  += -L$(XCHANGE_DIR)/lib -lxchange
EXE_SEARCH_PATH           += $(XCHANGE_DIR)/bin
endif

ifeq ($(USE_BTOOLS),true)
BTOOLS_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/btools /opt/$(FLAVOUR_PATH_PREFIX)btools))
BTOOLS_VERSION             = $(call version,$(BTOOLS_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-btools-run = $(BTOOLS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-btools-devel = $(BTOOLS_VERSION)
USE_YTOOLS                 = true
INCLUDE                   += -I$(BTOOLS_DIR)/include
LIBFLAGS                  += -L$(BTOOLS_DIR)/lib -ldspider-btools
EXE_SEARCH_PATH           += $(BTOOLS_DIR)/bin
endif

ifeq ($(USE_JACKJART),true)
JACKJART_DIR               = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/io/jackjart /opt/$(FLAVOUR_PATH_PREFIX)dspider/jackjart))
JACKJART_VERSION           = $(call version,$(JACKJART_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jackjart-run = $(JACKJART_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jackjart-devel = $(JACKJART_VERSION)
USE_YTOOLS                 = true
INCLUDE                   += -I$(JACKJART_DIR)/include
LIBFLAGS                  += -L$(JACKJART_DIR)/lib -ldspider-jackjart
EXE_SEARCH_PATH           += $(JACKJART_DIR)/bin
endif

ifeq ($(USE_JACKRTAI),true)
JACKRTAI_DIR               = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/io/jackrtai /opt/$(FLAVOUR_PATH_PREFIX)dspider/jackrtai))
JACKRTAI_VERSION           = $(call version,$(JACKRTAI_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jackrtai-run = $(JACKRTAI_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jackrtai-devel = $(JACKRTAI_VERSION)
USE_YTOOLS                 = true
INCLUDE                   += -I$(JACKRTAI_DIR)/include
LIBFLAGS                  += -L$(JACKRTAI_DIR)/lib -ldspider-jackrtai
EXE_SEARCH_PATH           += $(JACKRTAI_DIR)/bin
endif

ifeq ($(USE_JACKDUMMY),true)
JACKDUMMY_DIR              = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/io/jackdummy /opt/$(FLAVOUR_PATH_PREFIX)dspider/jackdummy))
JACKDUMMY_VERSION          = $(call version,$(JACKDUMMY_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jackdummy-run = $(JACKDUMMY_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jackdummy-devel = $(JACKDUMMY_VERSION)
USE_YTOOLS                 = true
INCLUDE                   += -I$(JACKDUMMY_DIR)/include
LIBFLAGS                  += -L$(JACKDUMMY_DIR)/lib -ldspider-jackdummy
EXE_SEARCH_PATH           += $(JACKDUMMY_DIR)/bin
endif

ifeq ($(USE_ALSART),true)
ALSART_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/io/alsart /opt/$(FLAVOUR_PATH_PREFIX)dspider/alsart))
ALSART_VERSION             = $(call version,$(ALSART_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)alsart-run = $(ALSART_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)alsart-devel = $(ALSART_VERSION)
USE_YTOOLS                 = true
INCLUDE                   += -I$(ALSART_DIR)/include
LIBFLAGS                  += -L$(ALSART_DIR)/lib -lalsart
EXE_SEARCH_PATH           += $(ALSART_DIR)/bin
endif

ifeq ($(USE_DSPFS),true)
DSPFS_DIR                  = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspfs /opt/$(FLAVOUR_PATH_PREFIX)dspfs))
DSPFS_VERSION              = $(call version,$(DSPFS_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspfs-run = $(DSPFS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspfs-devel = $(DSPFS_VERSION)
USE_YTOOLS                 = true
INCLUDE                   += -I$(DSPFS_DIR)/include
LIBFLAGS                  += -L$(DSPFS_DIR)/lib -ldspfs
EXE_SEARCH_PATH           += $(DSPFS_DIR)/bin
endif

ifeq ($(USE_AUTH),true)
AUTH_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/auth /opt/$(FLAVOUR_PATH_PREFIX)auth))
AUTH_VERSION               = $(call version,$(AUTH_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)auth-run = $(AUTH_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)auth-devel = $(AUTH_VERSION)
USE_YTOOLS                 = true
USE_VALDI                  = true
INCLUDE                   += -I$(AUTH_DIR)/include
LIBFLAGS                  += -L$(AUTH_DIR)/lib -lauth
EXE_SEARCH_PATH           += $(AUTH_DIR)/bin
endif

ifeq ($(USE_VALDI),true)
VALDI_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/valdi /opt/$(FLAVOUR_PATH_PREFIX)valdi))
VALDI_VERSION               = $(call version,$(VALDI_DIR))
RPM_REQUIRES_RUN           += $(FLAVOUR_PREFIX)valdi-run = $(VALDI_VERSION)
RPM_REQUIRES_DEVEL         += $(FLAVOUR_PREFIX)valdi-devel = $(VALDI_VERSION)
USE_YTOOLS                  = true
#INCLUDE                   += -I$(VALDI_DIR)/include
#LIBFLAGS                  += -L$(VALDI_DIR)/lib -lvaldi
EXE_SEARCH_PATH           += $(VALDI_DIR)/bin
endif

ifeq ($(USE_WT_JANNET),true)
USE_WT                     = true
include $(MODDIR)/make/wt-defs.mk
WT_JANNET_DIR              = $(firstword $(wildcard $(CVS_PROJ_DIR)/wt-jannet /opt/$(FLAVOUR_PATH_PREFIX)wt-jannet))
WT_JANNET_VERSION          = $(call version,$(WT_JANNET_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)wt-jannet-run = $(WT_JANNET_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)wt-jannet-devel = $(WT_JANNET_VERSION)
USE_FEEDFS                 = true
INCLUDE                   += -I$(WT_JANNET_DIR)/include
LIBFLAGS                  += -L$(WT_JANNET_DIR)/lib -lwt-jannet
LD_LIB_PATH               += $(WT_JANNET_DIR)/lib
EXE_SEARCH_PATH           += $(WT_JANNET_DIR)/bin
endif

ifeq ($(USE_APACHE2_JANNET),true)
APACHE2_JANNET_DIR         = $(firstword $(wildcard $(CVS_PROJ_DIR)/apache2-jannet /opt/$(FLAVOUR_PATH_PREFIX)apache2-jannet))
APACHE2_JANNET_VERSION     = $(call version,$(APACHE2_JANNET_DIR))
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)apache2-jannet-run = $(APACHE2_JANNET_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)apache2-jannet-devel = $(APACHE2_JANNET_VERSION)
USE_FEEDFS                 = true
# no build-time linkage necessary, no headers exported
LD_LIB_PATH               += $(APACHE2_JANNET_DIR)/lib
EXE_SEARCH_PATH           += $(APACHE2_JANNET_DIR)/bin
endif

ifeq ($(USE_FPTEST),true)
FPTEST_DIR                  = $(firstword $(wildcard $(CVS_PROJ_DIR)/fptest /opt/$(FLAVOUR_PATH_PREFIX)fptest))
FPTEST_VERSION              = $(call version,$(FPTEST_DIR))
RPM_REQUIRES_RUN           += $(FLAVOUR_PREFIX)fptest-run = $(FPTEST_VERSION)
RPM_REQUIRES_DEVEL         += $(FLAVOUR_PREFIX)fptest-devel = $(FPTEST_VERSION)
USE_YTOOLS                  = true
INCLUDE                    += -I$(FPTEST_DIR)/include
LIBFLAGS                   += -L$(FPTEST_DIR)/lib -lfptest -L$(HOME)/opt/iowkit/lib -liowkit
EXE_SEARCH_PATH            += $(FPTEST_DIR)/bin
endif

ifeq ($(USE_YTOOLS),true)
ifneq ($(PROJECT),ytools)
YTOOLS_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/ytools /opt/$(FLAVOUR_PATH_PREFIX)ytools))
else
YTOOLS_DIR                 = $(TOPDIR)
endif
YTOOLS_VERSION             = $(call version,$(YTOOLS_DIR))
ifneq ($(PROJECT),ytools)
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)ytools-run = $(YTOOLS_VERSION)
RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)ytools-devel = $(YTOOLS_VERSION)
endif
INCLUDE                   += -I$(YTOOLS_DIR)/include
LIBFLAGS                  += -L$(YTOOLS_DIR)/lib -lytools
EXE_SEARCH_PATH           += $(YTOOLS_DIR)/bin
endif

ifeq ($(USE_SCOPE_CASMIX),true)
SCOPE_CASMIX_DIR           = /opt/scope-casmix
SCOPE_CASMIX_VERSION       = $(call version,/usr/share/doc/packages/scope-casmix-devel)
RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)scope-casmix >= $(SCOPE_CASMIX_VERSION)
RPM_REQUIRES_DEVEL        += scope-casmix-devel >= $(SCOPE_CASMIX_VERSION)
INCLUDE                   += -I$(SCOPE_CASMIX_DIR)/include
LIBFLAGS                  += -L$(SCOPE_CASMIX_DIR)/lib -lscope-casmix
EXE_SEARCH_PATH           += $(SCOPE_CASMIX_DIR)/bin
endif

ifeq ($(USE_SNDFILE),true)
LIBFLAGS                  += -lsndfile
endif

ifeq ($(USE_FFTW),true)
LIBFLAGS                  += -lfftw3
endif

ifeq ($(USE_GLIB),true)
  ifneq ($(TARGET),mingw)
    ifeq ($(ARCH),x86)
      PROJECT_CFLAGS      += $(shell PKG_CONFIG_PATH=/opt/gnome/lib/pkgconfig pkg-config --cflags glib-2.0)
      PROJECT_CPPFLAGS    += $(shell PKG_CONFIG_PATH=/opt/gnome/lib/pkgconfig pkg-config --cflags glib-2.0)
      LIBFLAGS            += $(shell PKG_CONFIG_PATH=/opt/gnome/lib/pkgconfig pkg-config --libs glib-2.0)
    endif
    ifeq ($(ARCH),x86_64)
      PROJECT_CFLAGS      += $(shell export PKG_CONFIG_PATH=/opt/gnome/lib64/pkgconfig; pkg-config --cflags glib-2.0)
      PROJECT_CPPFLAGS    += $(shell export PKG_CONFIG_PATH=/opt/gnome/lib64/pkgconfig; pkg-config --cflags glib-2.0)
      LIBFLAGS            += $(shell export PKG_CONFIG_PATH=/opt/gnome/lib64/pkgconfig; pkg-config --libs glib-2.0)
    endif
    LIBFLAGS              += -ldl -lpthread
  else
    INCLUDE               += -I$(CROSS_TOOL_DIR)/include/glib-2.0 -I$(CROSS_TOOL_DIR)/lib/glib-2.0/include
    LIBFLAGS              += -lglib-2.0
  endif
endif

CFLAGS                    += $(LOCAL_CFLAGS)   $(PROJECT_CFLAGS)    $(INCLUDE)
CPPFLAGS                  += $(LOCAL_CPPFLAGS) $(PROJECT_CPPFLAGS)  $(INCLUDE)
LDFLAGS                   += $(LOCAL_LDFLAGS) $(PROJECTLIB_LDFLAGS) $(PROJECT_LDFLAGS) $(LPPFLAGS) $(LIBFLAGS)
#RPM_REQUIRES               = $(shell echo "$(RPM_REQUIRES_RUN) $(RPM_REQUIRES_DEVEL)" | $(add_flavour_prefix))
RPM_REQUIRES              += $(RPM_REQUIRES_RUN) $(RPM_REQUIRES_DEVEL)

endif