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

ifndef JW_BUILD_DEF_MK_INCLUDED
JW_BUILD_DEF_MK_INCLUDED = true

ifeq ($(MAKE_BENCHMARK),true)
  SHELL                = /bin/bash $(MOD_SCRIPT_DIR)/timed-make-shell.sh
endif

MAKEFLAGS             += -r

include $(MODDIR)/make/platform.mk
include $(MODDIR)/make/projects.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

# ----- executables
SED                   := $(shell which sed)
CAT                   := /bin/cat
SHELL                 ?= /bin/bash
BROWSER               ?= xdg-open
RM                    := $(shell which rm)
AR                     = /usr/bin/ar
PWD                   := $(shell which pwd)
CWD                   := $(shell $(PWD))
BIN_INSTALL           := /usr/bin/install
SUDO                  ?= /usr/bin/sudo

# ----- standard variables
ifneq ($(wildcard $(TOPDIR)/.git),)
  VCS                 ?= git
else ifneq ($(wildcard $(TOPDIR)/CVS),)
  VCS                 ?= cvs
endif

CVSTOPDIR             ?= $(PROJECTS_DIR)/..

ifeq ($(PROJECT),)
  PROJECT             := $(patsubst $(FLAVOUR_PREFIX)%,%,$(notdir $(realpath $(TOPDIR))))
endif

GET_OS_SH             ?= /bin/bash $(MOD_SCRIPT_DIR)/get-os.sh
OS                    ?= $(shell $(GET_OS_SH))
OS_NAME               ?= $(shell $(GET_OS_SH) name)

CREATE_DEVEL          ?= true
#COMPILER_SUITE        ?= clang
COMPILER_SUITE        ?= gcc

ifeq ($(TARGET),mingw)
FLAVOUR_PREFIX        ?= win32-
FLAVOUR_SUFFIX        ?= -win32
FLAVOUR_PATH_PREFIX   ?= win32/
FLAVOUR_PATH_SUFFIX   ?= /win32
  ifneq ($(wildcard /usr/bin/i686-w64-mingw32-gcc),)
    MINGW_SYS_ROOT      ?= /usr/i686-w64-mingw32/sys-root/mingw
  endif
endif

ifneq ($(filter debian%,$(OS)),)
  PKG_FORMAT          ?= debian
else
  PKG_FORMAT          ?= rpm
endif

ifeq ($(PKG_FORMAT),debian)
  RPM                 ?= /bin/bash $(MOD_SCRIPT_DIR)/dpm.sh
  RPM_ARCH            ?= $(shell dpkg --print-architecture)
  RPM_SUFFIX          ?= deb
else
  RPM                 ?= /bin/rpm
  RPM_ARCH            ?= $(ARCH)
  RPM_SUFFIX          ?= rpm
endif

ifeq ($(PKG_FORMAT),debian)
export INCLUDE_REV_IN_VERSIONS = true
endif

PROJECT_DESCR_FILE    ?= $(wildcard $(TOPDIR)/make/project.conf)
PROJECT_SHORT_NAME    ?= $(PROJECT)
PROJECT_CAPNAME        = $(shell echo $(PROJECT) | tr [a-z] [A-Z] | $(SED) 's/-/_/g')
PROJECT_DESCR         ?= $(call proj_query, summary $(PROJECT))
PROJECT_SUMMARY       ?= $(PROJECT_DESCR)
CUSTOMER              ?= jannet

ifneq ($(PROJECT_DESCR_FILE),)
ifeq ($(shell grep "^ *subpackages *=.*devel" $(PROJECT_DESCR_FILE)),)
CREATE_DEVEL           = false
endif
endif

ifneq ($(wildcard $(VERSION_FILE)),)
  VERSION             ?= $(shell $(CAT) $(VERSION_FILE))
endif
DIST_VERSION          ?= $(patsubst %-dev,%,$(VERSION))
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

# ----- input dirs
JW_BUILD_DIR           = $(MODDIR)
PROJECT_STEM           = $(PROJECT)-$(DIST_VERSION)

# only works if checked out true to CVS, i.e. below proj
ifeq ($(VCS),cvs)
  CVS_MODULE           = $(shell $(SED) "s%/$$%%" CVS/Repository)
  CVS_ROOT_DIR         = $(patsubst %/$(CVS_MODULE),%,$(CWD))
endif

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
TARGET                ?= Linux

ifndef ARCH
  ifeq ($(shell uname -m),armv7l)
    ARCH                    = armv7hl
    SYSTEM_LIBDIR_NAME      = lib
  else ifeq ($(shell uname -m),armv6l)
    ARCH                    = armv6hl
    SYSTEM_LIBDIR_NAME      = lib
  else ifeq ($(shell uname -m),aarch64)
    ARCH                    = aarch64
    SYSTEM_LIBDIR_NAME      = lib
  else ifeq ($(shell uname -m),x86_64)
    ARCH             = x86_64
    SYSTEM_LIBDIR_NAME      = lib64
  else
    ARCH_32                 = i586
    ARCH                    = $(ARCH_32)
    SYSTEM_LIBDIR_NAME      = lib
  endif
  SYSTEM_LIBDIR = /usr/$(SYSTEM_LIBDIR_NAME)
endif

ifeq ($(ARCH),$(ARCH_32))
PROJECT_CFLAGS        += -m32
PROJECT_CPPFLAGS      += -m32
PROJECT_LDFLAGS       += -m32
endif

ifeq ($(ARCH),armv7hl)
  PROJECT_CFLAGS        += -fPIC
  PROJECT_CPPFLAGS      += -fPIC
  PROJECT_LDFLAGS       +=
else ifeq ($(ARCH),aarch64)
  PROJECT_CFLAGS        += -fPIC
  PROJECT_CPPFLAGS      += -fPIC
  PROJECT_LDFLAGS       +=
endif

BUILD_USER            := $(shell id -un)
JANWARE_USER          ?= $(BUILD_USER)
JANWARE_CLIENT        ?= jw
JANWARE_WIKI          ?= $(JANWARE_CLIENT)
JANWARE_URL_DOC_MODULE   ?= https://janware.com/wiki/$(JANWARE_WIKI)/assets/types/data/sw/$(PROJECT)/$(notdir $(CWD))
JANWARE_URL_DOC_PROJECT  ?= https://janware.com/wiki/$(JANWARE_WIKI)/assets/types/data/sw/$(PROJECT)/$(PROJECT)
PKG_VENDOR            ?= janware GmbH

FULL_NAME             ?= $(shell id -nu | xargs getent passwd | cut -d: -f5)
USE_PROJECT_LIB       ?= true
EXPORT_PROJECT_LIB    ?= $(USE_PROJECT_LIB)
USE_JW_BUILD            ?= 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
  export G_SLICE=always-malloc
  export G_DEBUG=gc-friendly,resident-modules
  export MALLOC_CHECK_=2
else
  -include $(MODDIR)/make/defs-dist.mk
  ifneq ($(wildcard $(TOPDIR)/make/cfg_dist.mk),)
	-include $(TOPDIR)/make/cfg_dist.mk
  endif
endif
endif

USE_COMPILER_OPTIMIZATION_OPTS = false
USE_COMPILER_DEBUG_OPTS = true
COMPILE_DEBUG_CODE = true

BUILD_CFLAGS          += $(CFLAGS)
BUILD_CPPFLAGS        += $(CPPFLAGS)
BUILD_LDFLAGS         += $(LDFLAGS)

BUILD_CFLAGS          += -D_FILE_OFFSET_BITS=64 -Wall -Wno-unused-value -fexceptions -DPROJECT_STR=\"$(PROJECT)\"
BUILD_CPPFLAGS        += -D_FILE_OFFSET_BITS=64 -Wall -Wno-unused-value -Wno-deprecated -DPROJECT_STR=\"$(PROJECT)\"
BUILD_LDFLAGS         += -Wall

LOG_QUAL_PREFIX       ?= $(LOGID):

ifneq ($(LOG_QUAL_PREFIX),)
PROJECT_CFLAGS      += -DKEEP_FILES_OPEN -DLOG_QUAL_PREFIX=\"$(LOG_QUAL_PREFIX)\"
PROJECT_CPPFLAGS    += -DKEEP_FILES_OPEN -DLOG_QUAL_PREFIX=\"$(LOG_QUAL_PREFIX)\"
endif

ifeq ($(CATCH_ONLY_YERROR),true)
BUILD_CFLAGS          += -DCATCH_ONLY_YERROR
BUILD_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

USE_VERSION_MACROS    ?= true
ifeq ($(USE_VERSION_MACROS),true)
  BUILD_CFLAGS          += -DVERSION=$(HEX_VERSION) -DVERSION_STR=\"$(VERSION)\"
  BUILD_CPPFLAGS        += -DVERSION=$(HEX_VERSION) -DVERSION_STR=\"$(VERSION)\"
endif

ifeq ($(TARGET),mingw)
 ifneq ($(wildcard /usr/bin/i686-w64-mingw32-gcc),)
  MINGW_SYS_ROOT      ?= /usr/i686-w64-mingw32/sys-root/mingw
  CROSS_TOOL_DIR      ?=
  CROSS_TOOL_BIN_PREFIX ?= $(CROSS_TOOL_DIR)/usr/bin/i686-w64-mingw32-
  PROJECT_LDFLAGS     += -L$(MINGW_SYS_ROOT)/lib
  PROJECT_CFLAGS      += -I$(MINGW_SYS_ROOT)/include
  PROJECT_CPPFLAGS    += -I$(MINGW_SYS_ROOT)/include
 else
  CROSS_TOOL_DIR      ?= /opt/cross-tools
  CROSS_TOOL_BIN_PREFIX ?= $(CROSS_TOOL_DIR)/bin/i686-pc-mingw32-
 endif
 GCC                  ?= $(CROSS_TOOL_BIN_PREFIX)gcc
 GPP                  ?= $(CROSS_TOOL_BIN_PREFIX)g++
 CLANG                ?= $(CROSS_TOOL_BIN_PREFIX)clang
 CLANGPP              ?= $(CROSS_TOOL_BIN_PREFIX)clang++
 STRIP                ?= $(CROSS_TOOL_BIN_PREFIX)strip
 RANLIB               ?= $(CROSS_TOOL_BIN_PREFIX)ranlib
 AR                   ?= $(CROSS_TOOL_BIN_PREFIX)ar
 WINDRES              ?= $(CROSS_TOOL_BIN_PREFIX)windres
 BUILD_LDFLAGS        += -lws2_32
 USE_GFILTER          ?= false
 MS_LD                ?= wine $(HOME)/local/mingw/packages/msvcpp/bin/LIB.EXE
else
 GCC                  ?= gcc
 GPP                  ?= g++
 CLANG                ?= clang
 CLANGPP              ?= clang++
 STRIP                ?= strip
 RANLIB               ?= ranlib
 AR                   ?= ar
endif

# makefile helpers
FIND_SUBDIRS           = $(filter-out . .. nomake CVS $(IGNORE_SUBDIRS),\
	$(patsubst ./%,%,$(patsubst %/,%,$(dir $(shell find . -maxdepth 2 -mindepth 2 -a \( -iname Makefile -o -iname GNUmakefile \))))))
SUBDIRS_TO_ITERATE     = $(filter-out $(IGNORE_SUBDIRS),$(SUBDIRS))

# compiler and linker
# gcc
GCC_VERSION           := $(shell $(GCC) -v 2>&1 | $(SED) '/gcc.version/I !d; s/.*version *//I; s/ \+.*//')
GCC_VERSION_NUMBERS   := $(subst ., ,$(GCC_VERSION))
GCC_MAJOR             := $(word 1,$(GCC_VERSION_NUMBERS))
GCC_MINOR             := $(word 2,$(GCC_VERSION_NUMBERS))
GCC_REV               := $(word 3,$(GCC_VERSION_NUMBERS))

LD_VERSION            := $(shell ld -V | $(SED) '/GNU ld/ !d; s/(.*)//; s/[^0-9.-]*//')
LD_VERSION_NUMBERS    := $(subst ., ,$(LD_VERSION))
LD_MAJOR              := $(word 1,$(LD_VERSION_NUMBERS))
LD_MINOR              := $(word 2,$(LD_VERSION_NUMBERS))
LD_REV                := $(word 3,$(LD_VERSION_NUMBERS))

UPDATE_REPO_SH        := /opt/packager-server/bin/packager-server schedule-rebuild

# clang
CLANG_CPPFLAGS            += -Wno-unused-private-field -Wno-self-assign-field -Wno-overloaded-virtual

ifneq ($(GCC_VERSION),4.1.0)
ifneq ($(GCC_VERSION),4.5.1)
BUILD_CFLAGS          += -std=gnu99
BUILD_CPPFLAGS        += -std=c++11
#BUILD_CPPFLAGS        += -Wsuggest-override
endif
endif

ifeq ($(shell test $(GCC_MAJOR) -ge 5; echo $$?),0)
  ifeq ($(USE_CPP_FORCE_OVERRIDE),true)
    GCC_CPPFLAGS     += -Werror=suggest-override
  endif
endif

ifeq ($(USE_CPP_WARN_INCONSISTENT_OVERRIDE),true)
  CLANG_CPPFLAGS   += -Winconsistent-missing-override
endif

# -- 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 *.hpp)
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                   += $(addprefix $(FLAVOUR_PREFIX),$(patsubst %.C,%.o,$(patsubst %.cpp,%.o,$(patsubst %.cc,%.o,$(patsubst %.c,%.o,$(filter %.c %.cpp %.cc %.C, $(SRC_ALL_CPP)))))))
OBJ                   += $(addprefix $(FLAVOUR_PREFIX),$(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)

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 *.gif *.ico *.svg)
FONTS                 += $(wildcard *.woff *.svg)
LOCAL_MKFILES         ?= $(wildcard GNUmakefile makefile Makefile *.mk)

# -- standard dirs and files for build and install

# -- CFG
INSTALLATION_FILE_TYPES += 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             ?= $(filter-out %.site.conf, $(filter-out rsyslog-%, $(wildcard *.conf *.xml *.bprof *.jw-tmpl))) $(LOCAL_EXTRA_CFG)
INSTALLED_CFG         ?= $(addprefix $(INSTALL_CFGDIR)/,$(LOCAL_CFG))

# -- SYSCFG
INSTALLATION_FILE_TYPES += 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
INSTALLATION_FILE_TYPES += HDR
BUILD_HDRDIR_BASE     ?= $(TOPDIR)/include
BUILD_HDRDIR          ?= $(BUILD_HDRDIR_BASE)/$(HDRDIR_SCOPE_SUFFIX)
SRC_H                 += $(filter %.h %.H %.hpp, $(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
INSTALLATION_FILE_TYPES += DOC
DOCS                  += $(wildcard VERSION README* CHANGES TODO* LICENSE AUTHORS CREDITS RELEASES *.pdf *.txt *.html)
DOCSUBDIRS            += $(wildcard html tex info examples src)

BUILD_DOCDIR          ?= $(TOPDIR)/doc
BUILD_DOC             ?= $(DOC_PREFIX)
INSTALL_DOCDIR        ?= $(DOC_PREFIX)
INSTALLED_DOC         ?= $(addprefix $(INSTALL_DOCDIR)/,$(DOCS))

# -- LIB
INSTALLATION_FILE_TYPES += 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)
  ifeq ($(MINGW_SYS_ROOT),)
    CONTRIB_LIBS_PATH     += $(CROSS_TOOL_DIR)/bin
  else
    CONTRIB_LIBS_PATH     += $(MINGW_SYS_ROOT)/lib
  endif
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
BUILD_LIB             += $(LIB_SO)
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)

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

# -- EXE
INSTALLATION_FILE_TYPES += EXE
EXE_SH                += $(filter-out $(DONT_INSTALL),$(wildcard *.sh *.pl *.pm *.py *.bat *.feedfs))
EXE_SH                += $(patsubst %.sh.tmpl,%.sh,$(filter-out $(DONT_INSTALL),$(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
#INSTALLATION_FILE_TYPES += 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
INSTALLATION_FILE_TYPES += CGI
EXE_CGI               += $(filter-out $(DONT_INSTALL),$(wildcard *.cgi))
EXE_CGI               += $(patsubst %.cgi.tmpl,%.cgi,$(filter-out $(DONT_INSTALL),$(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
INSTALLATION_FILE_TYPES += HTML
BUILD_HTMLDIR          = $(TOPDIR)/htdocs
LOCAL_HTML            += $(filter-out $(DONT_INSTALL),$(wildcard *.html *.css *.php *.js) $(FONTS) $(IMAGES))
HTML_SUBDIR           ?= $(shell $(PWD) | $(SED) '/.*\/htdocs\(\/\|$$\)/!d; s%.*/htdocs\(/\|$$\)%%')
ifeq ($(HTML_SUBDIR),)
INSTALL_HTMLDIR       ?= $(PROJECT_HTMLDIR)
else
INSTALL_HTMLDIR       ?= $(PROJECT_HTMLDIR)/$(HTML_SUBDIR)
endif
INSTALLED_HTML        += $(addprefix $(INSTALL_HTMLDIR)/,$(LOCAL_HTML))

# -- TMPL
INSTALLATION_FILE_TYPES += TMPL
BUILD_TMPLDIR          = $(TOPDIR)/tmpl
LOCAL_TMPL            += $(filter-out $(DONT_INSTALL),$(wildcard *.tmpl))
TMPL_SUBDIR           ?= $(shell $(PWD) | $(SED) '/.*\/tmpl\(\/\|$$\)/!d; s%.*/tmpl\(/\|$$\)%%')
ifeq ($(TMPL_SUBDIR),)
INSTALL_TMPLDIR        = $(PROJECT_TMPLDIR)
else
INSTALL_TMPLDIR        = $(PROJECT_TMPLDIR)/$(TMPL_SUBDIR)
endif
INSTALLED_TMPL        += $(addprefix $(INSTALL_TMPLDIR)/,$(LOCAL_TMPL))

# -- SYSTEMD
INSTALLATION_FILE_TYPES += SYSTEMD
BUILD_SYSTEMDDIR          = $(TOPDIR)/bin/systemd
LOCAL_SYSTEMD            += $(filter-out $(DONT_INSTALL),$(wildcard *.service))
INSTALL_SYSTEMDDIR        = $(SYSTEMD_DIR)
INSTALLED_SYSTEMD        += $(addprefix $(INSTALL_SYSTEMDDIR)/,$(LOCAL_SYSTEMD))

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

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

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

# -- MO
INSTALLATION_FILE_TYPES += MO
BUILD_MO             ?= 
BUILD_MODIR          ?= $(CWD)
INSTALL_MODIR        ?= $(ENV_PREFIX)/usr/share/locale/$(GETTEXT_LOCALE)/LC_MESSAGES
INSTALLED_MO         ?= $(addprefix $(INSTALL_MODIR)/,$(wildcard *.mo))

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

# -- PROFILE
INSTALLATION_FILE_TYPES += 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
INSTALLATION_FILE_TYPES += JAVA
BUILD_JAVADIR           = $(TOPDIR)/share/java
BUILD_JAVADIR_CLASSES   = classes
JAVA_JARS              ?= $(filter-out $(DONT_INSTALL),$(wildcard *.jar))
INSTALL_JAVADIR        ?= $(JAVADIR)
INSTALLED_JAVA         ?= $(addprefix $(INSTALL_JAVADIR)/,$(JAVA_JARS))

# -- LD_CONF
INSTALLATION_FILE_TYPES += LD_CONF
ifneq ($(TARGET),mingw)
LD_CONF            += $(filter-out $(DONT_INSTALL),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)
INSTALLATION_FILE_TYPES += LOGROT
LOGROT            += $(basename $(filter-out $(DONT_INSTALL),$(wildcard *.logrotate)))
BUILD_LOGROTDIR    = $(TOPDIR)/bin/logrotate.d
INSTALL_LOGROTDIR  = $(LOGROT_DIR)
INSTALLED_LOGROT   = $(addprefix $(INSTALL_LOGROTDIR)/,$(LOGROT))
endif

# -- APACHE_CONF
ifneq ($(TARGET),mingw)
INSTALLATION_FILE_TYPES += APACHE_CONF
APACHE_CONF            += $(filter-out $(DONT_INSTALL),$(wildcard *.apache-conf))
BUILD_APACHE_CONFDIR    = $(TOPDIR)/bin/apache/conf.d
INSTALL_APACHE_CONFDIR  = $(APACHE_CONF_DIR)
INSTALLED_APACHE_CONF   = $(addprefix $(INSTALL_APACHE_CONFDIR)/,$(patsubst %.apache-conf,%.conf,$(APACHE_CONF)))
endif

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

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

# -- PKG_CONFIG
ifneq ($(TARGET),mingw)
INSTALLATION_FILE_TYPES += PKG_CONFIG
PKG_CONFIG            += $(sort $(filter-out $(DONT_INSTALL),$(wildcard *.pc) $(LOCAL_PKG_CONFIG)))
ifeq ($(DEVELOPMENT),true)
BUILD_PKG_CONFIGDIR    = $(MODDIR)/pkgconfig
else
BUILD_PKG_CONFIGDIR    = $(TOPDIR)/make
endif
LOCAL_PKG_CONFIG       = $(PROJECT).pc
BUILD_PKG_CONFIG       = $(BUILD_PKG_CONFIGDIR)/$(LOCAL_PKG_CONFIG)
INSTALLED_PKG_CONFIG   = $(addprefix $(INSTALL_PKG_CONFIGDIR)/,$(PKG_CONFIG))
endif

# ==

ifeq ($(DEVELOPMENT),true)
	BUILD_CFLAGS  += -D_DEVELOPMENT_
	BUILD_CPPFLAGS+= -D_DEVELOPMENT_
endif

CORE                  += $(filter-out $(wildcard *.intern-state*),$(wildcard core core.* vgcore vgcore.*))

ifeq ($(GCC_MAJOR),4)
	BUILD_CFLAGS  += -DGCC_HASCLASSVISIBILITY
	BUILD_CPPFLAGS+= -DGCC_HASCLASSVISIBILITY
endif

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

ifeq ($(USE_X),true)
  BUILD_LDFLAGS       += -L/usr/X11/$(SYSTEM_LIBDIR_NAME) -lXext -lX11
endif

LPPFLAGS              += -lstdc++

ifeq ($(ARCH),x86_64)
  ifneq ($(TARGET),mingw)
	BUILD_CFLAGS  += -fPIC
	BUILD_CPPFLAGS+= -fPIC
	LIBFLAGS      +=
  endif
endif

ifeq ($(GCC_MAJOR),2)
LPPFLAGS              += -lm
BUILD_CFLAGS          += -I/usr/local/include
BUILD_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 ($(TARGET),mingw)
BUILD_CFLAGS          += -DWIN32
BUILD_CPPFLAGS        += -DWIN32
endif

ifeq ($(LIBTYPE),shared)
  ifneq ($(TARGET),mingw)
	BUILD_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

PKG_SH_EXE             = /bin/bash $(MOD_SCRIPT_DIR)/pkg.sh
LOG_INSTALL_SH         = $(PKG_SH_EXE) log-install

ifeq ($(LOG_THREAD_NAMES), true)
	BUILD_CFLAGS  += -DSLOG_THREAD_NAMES
	BUILD_CPPFLAGS+= -DSLOG_THREAD_NAMES
endif

ifdef INSTALL_LINK
	INSTALL  = $(SUDO) $(LOG_INSTALL_SH) -WA $(LOG_INSTALL_EXTRA_OPTS)
	LINK_LIB = $(SUDO) $(LOG_INSTALL_SH) -LA $(LOG_INSTALL_EXTRA_OPTS)
else ifdef INSTALL_SYMLINK
	INSTALL  = $(SUDO) $(LOG_INSTALL_SH) -LA $(LOG_INSTALL_EXTRA_OPTS)
	LINK_LIB = $(SUDO) $(LOG_INSTALL_SH) -LA $(LOG_INSTALL_EXTRA_OPTS)
else
	ifdef INSTALL_LOG
		INSTALL  = $(LOG_INSTALL_SH) -p -l $(INSTALL_LOG) $(LOG_INSTALL_EXTRA_OPTS)
		LINK_LIB = $(LOG_INSTALL_SH) -L -l $(INSTALL_LOG) $(LOG_INSTALL_EXTRA_OPTS)
	else
		ifndef INSTALL
			INSTALL      = install
		endif
		ifndef LINK_LIB
			LINK_LIB     = $(LOG_INSTALL_SH) -L
		endif
	endif
endif

INSTALL_FILE          ?= $(INSTALL)
INSTALL_DIR           ?= $(INSTALL)

# ----- 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) -p -o $(CFGOWNER) -g $(CFGGROUP) -m $(CFGMODE) $< $@
endef

define cvs_files
	sh $(MOD_SCRIPT_DIR)/scm.sh ls-files -f
endef

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

define beautify_lib_path
	$(SED) 's/:/\n  + /g'
endef

ifeq ($(INCLUDE_REV_IN_VERSIONS),true)
  version = $(shell $(CAT) $1/VERSION | $(SED) 's/-dev//; s/[ 	]*//g')
else
  version = $(shell $(CAT) $1/VERSION | $(SED) 's/-.*//; s/[ 	]*//g')
endif

define install_links
	cwd="$(CWD)"; \
		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

ifeq "$(COMPILER_SUITE)" "gcc"
CC                     = $(GCC)
CPP                    = $(GPP)
LD                     = $(GPP)
endif

ifeq "$(COMPILER_SUITE)" "clang"
CC                     = $(CLANG)
CPP                    = $(CLANGPP)
LD                     = $(CLANGPP)
endif

ifeq ($(USE_PROJECT_LIB),true)
        PROJECTLIB_LDFLAGS += -L$(TOPDIR)/lib -l$(LIBNAME)
endif

ifneq ($(filter jw-build,$(PREREQ_BUILD)),)
	ifeq ($(TARGET),mingw)
	JW_BUILD_LDFLAGS  += -lglib-2.0 -lws2_32 -lstdc++
	endif
endif

ifeq ($(USE_SYSTEMD),true)
	BUILD_CFLAGS      += -D_USE_SYSTEMD_ $(shell pkg-config --cflags libsystemd)
	BUILD_CPPFLAGS    += -D_USE_SYSTEMD_ $(shell pkg-config --cflags libsystemd)
	BUILD_LDFLAGS     += $(shell pkg-config --libs libsystemd)
endif

ifeq ($(USE_TIMER),true)
	BUILD_CFLAGS      += -D_USE_TIMER_
	BUILD_CPPFLAGS    += -D_USE_TIMER_
endif

ifeq ($(USE_FAST_LOG),false)
	BUILD_CFLAGS      +=-D_USE_FAST_LOG_=0
	BUILD_CPPFLAGS    +=-D_USE_FAST_LOG_=0
endif

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

ifeq ($(USE_MPATROL),true)
	BUILD_CFLAGS      += -include /usr/include/mpatrol.h
	#BUILD_CPPFLAGS   += -include /usr/include/mpatrol.h
	BUILD_LDFLAGS     += -lmpatrolmt -lbfd -liberty
endif

ifeq ($(USE_VALGRIND),true)
	BUILD_CFLAGS      += -include /usr/include/valgrind/memcheck.h -D_VALGRIND_
	BUILD_CPPFLAGS    += -include /usr/include/valgrind/memcheck.h -D_VALGRIND_
	# BUILD_LDFLAGS   += 
endif

ifeq ($(USE_MCHECK),true)
	BUILD_LDFLAGS     += -lmcheck
endif

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

ifeq ($(USE_STACK_CHECKER),true)
  ifeq "$(COMPILER_SUITE)" "clang"
	BUILD_CFLAGS    += -fsanitize=address -fno-omit-frame-pointer
	BUILD_CPPFLAGS  += -fsanitize=address -fno-omit-frame-pointer
	BUILD_LDFLAGS   += -fsanitize=address
  else
  endif

endif

ifeq ($(USE_DBMALLOC),true)
	CONTRIB_LIBS += dbmalloc
	BUILD_CFLAGS      += -DDBMALLOC -DEXITFUN=_exit -I$(TOPDIR)/contrib/dbmalloc
	BUILD_CPPFLAGS    += -DDBMALLOC -DEXITFUN=_exit -I$(TOPDIR)/contrib/dbmalloc
	BUILD_LDFLAGS     += -ldbmalloc
endif

ifeq ($(USE_DMALLOC),true)
	BUILD_CFLAGS      += -DDMALLOC -DDMALLOC_FUNC_CHECK -DSTORE_SEEN_COUNT
	BUILD_CPPFLAGS    += -DDMALLOC -DDMALLOC_FUNC_CHECK -DSTORE_SEEN_COUNT
	BUILD_LDFLAGS     += -ldmallocthcxx -ldmallocth
endif

ifeq ($(USE_MEMWATCH),true)
	BUILD_CFLAGS      += -DMEMWATCH -DMW_STDIO
	BUILD_CPPFLAGS    += -DMEMWATCH -DMW_STDIO
endif

ifeq ($(USE_EFENCE),true)
	BUILD_CFLAGS      += -DEFENCE
	BUILD_CPPFLAGS    += -DEFENCE
	BUILD_LDFLAGS     += -lefence
endif

ifeq ($(USE_TRACING),true)
	BUILD_CFLAGS      += -D_DO_TRACE_
	BUILD_CPPFLAGS    += -D_DO_TRACE_
endif

ifeq ($(USE_ASSERTIONS),false)
	BUILD_CFLAGS      += -DNDEBUG
	BUILD_CPPFLAGS    += -DNDEBUG
endif

ifeq ($(COMPILE_DEBUG_CODE),true)
	BUILD_CFLAGS      += -D_DEBUG_
	BUILD_CPPFLAGS    += -D_DEBUG_
endif

ifeq ($(COMPILE_DEBUG_LOG),true)
	BUILD_CFLAGS      += -D_LOG_DEBUG_
	BUILD_CPPFLAGS    += -D_LOG_DEBUG_
endif

ifeq ($(USE_MPATROL),true)
	BUILD_CFLAGS      += -include $(MODDIR)/include/mpatrol.h
	BUILD_CPPFLAGS    += -include $(MODDIR)/include/mpatrol.h
	BUILD_LDFLAGS     += -lmpatrolmt -lbfd -liberty
endif

ifeq ($(BREAK_ABI),true)
	BUILD_CFLAGS      += -D_BREAK_ABI_
	BUILD_CPPFLAGS    += -D_BREAK_ABI_
endif

ifeq ($(USE_STACK_CHECK),true)
	BUILD_CFLAGS      += -fstack-check
	BUILD_CPPFLAGS    += -fstack-check
endif

ifeq ($(USE_COMPILER_DEBUG_OPTS),true)
	BUILD_CFLAGS      += -gdwarf-2 -g3 -ggdb
	BUILD_CPPFLAGS    += -gdwarf-2 -g3 -ggdb
	BUILD_LDFLAGS     += -gdwarf-2 -g3 -ggdb
endif

ifeq ($(CC),$(GCC))
	GCC_NO_OPT_FLAGS = \
		-fno-inline-functions-called-once \
		-fno-tree-loop-optimize \
		-fno-early-inlining \
		-fno-default-inline
else
  ifeq ($(CC),$(CLANG))
	BUILD_CFLAGS      += -Werror
	BUILD_CPPFLAGS    += -Werror
  endif
endif

ifeq ($(USE_COMPILER_OPTIMIZATION_OPTS),true)
	BUILD_CFLAGS      += -funroll-loops -O3
	BUILD_CPPFLAGS    += -funroll-loops -O3
else
	NO_OPT_FLAGS = \
		-O0 -g -fno-inline -fno-omit-frame-pointer \
		-fno-builtin -fno-optimize-sibling-calls \
		$(GCC_NO_OPT_FLAGS)
#		-fconserve-stack

	_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 \
		$(GCC_NO_OPT_FLAGS)

	BUILD_CFLAGS      += $(NO_OPT_FLAGS)
	BUILD_CPPFLAGS    += $(NO_OPT_FLAGS)
	BUILD_LDFLAGS     += $(NO_OPT_FLAGS)
endif

ifeq ($(USE_EXCEPTIONS_IN_C),true)
	BUILD_CFLAGS      += -fexceptions
	GCC_LDFLAGS       += -shared-libgcc
endif

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

INCLUDE                   += $(LOCAL_INCLUDE)

# force use of double quotes, allow header namespaces
ifeq ($(HDRDIR_SCOPE_SUFFIX),)
  INCLUDE                 += -I.
else
  INCLUDE                 += -iquote .
endif

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

INCLUDE                   += $(call proj_query, cflags  $(PREREQ_BUILD) $(PROJECT))

LDFLAGS_QUERY_ARGS         = $(addprefix --exclude ,$(LDFLAGS_EXCLUDE))
LIBFLAGS                  += $(call proj_query, ldflags $(LDFLAGS_QUERY_ARGS) --add-self $(PREREQ_BUILD))

# the following is necessary, because not all projects have build.libname = none in project.conf
ifeq ($(USE_PROJECT_LIB),true)
  LDFLAGS_QUERY_ARGS_SELF  = --add-self
endif
LIBFLAGS                  += $(call proj_query, ldflags  $(LDFLAGS_QUERY_ARGS) $(LDFLAGS_QUERY_ARGS_SELF) $(PROJECT))

#include $(MODDIR)/make/lib-deps.mk

BTOOLS_DIR             ?= $(call proj_dir, dspider-btools)
#DSPCD_DIR              ?= $(call proj_dir, dspcd)
#DSPCD_EC_DIR           ?= $(call proj_dir, dspcd-ec)
FEEDFSD_DIR            ?= $(call proj_dir, feedfsd)
FEEDFS_DIR             ?= $(call proj_dir, feedfs)
FEEDFS_GUI_DIR         ?= $(call proj_dir, feedfs-gui)
FEEDFS_OBJECTS_DIR     ?= $(call proj_dir, feedfs-objects)
FEEDFS_UTILS_DIR       ?= $(call proj_dir, feedfs-utils)
FEEDFS_WT_DIR          ?= $(call proj_dir, feedfs-wt)
JUX_SHARED_DIR         ?= $(call proj_dir, jux-shared)
SITE_DIR               ?= $(call proj_dir, site)
VALDI_DIR              ?= $(call proj_dir, valdi)
XCHANGE_DIR            ?= $(call proj_dir, xchange)

#PREREQ_INSTALL            ?= $(PREREQ_BUILD)
#PREREQ_RUN                ?= $(PREREQ_INSTALL)

# TODO: remove this
#PREREQ_BUILD              += $(PREREQ_RUN)
#PREREQ_BUILD              += $(PREREQ_INSTALL)

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

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

ifeq ($(USE_GLIB),true)
  ifneq ($(TARGET),mingw)
    PROJECT_CFLAGS        += $(shell pkg-config --cflags glib-2.0)
    PROJECT_CPPFLAGS      += $(shell pkg-config --cflags glib-2.0)
    LIBFLAGS              += $(shell pkg-config --libs glib-2.0)
    LIBFLAGS              += -ldl -lpthread
  else
    ifneq ($(wildcard $(CROSS_TOOL_DIR)/include/glib-2.0),)
      INCLUDE             += -I$(CROSS_TOOL_DIR)/include/glib-2.0 -I$(CROSS_TOOL_DIR)/lib/glib-2.0/include
      LIBFLAGS            += -lglib-2.0
    else
      PROJECT_CFLAGS      += $(shell /usr/bin/i686-w64-mingw32-pkg-config --cflags glib-2.0)
      PROJECT_CPPFLAGS    += $(shell /usr/bin/i686-w64-mingw32-pkg-config --cflags glib-2.0)
      LIBFLAGS            += $(shell /usr/bin/i686-w64-mingw32-pkg-config --libs glib-2.0)
    endif
  endif
endif

ifeq ($(CC),$(CLANG))
COMPILER_CFLAGS           += $(CLANG_CFLAGS)
COMPILER_CPPFLAGS         += $(CLANG_CPPFLAGS)
COMPILER_LDFLAGS          += $(CLANG_LDFLAGS)
endif

ifeq ($(CC),$(GCC))
COMPILER_CFLAGS           += $(GCC_CFLAGS)
COMPILER_CPPFLAGS         += $(GCC_CPPFLAGS)
COMPILER_LDFLAGS          += $(GCC_LDFLAGS)
endif

BUILD_CFLAGS              += $(PROJECT_CFLAGS) $(LOCAL_CFLAGS) $(COMPLILER_CFLAGS) $(INCLUDE)
BUILD_CPPFLAGS            += $(PROJECT_CPPFLAGS) $(LOCAL_CPPFLAGS) $(COMPILER_CPPFLAGS) $(INCLUDE)
BUILD_LDFLAGS             += $(PROJECTLIB_LDFLAGS) $(LOCAL_LDFLAGS) $(PROJECT_LDFLAGS) $(COMPILER_LDFLAGS) $(LPPFLAGS) $(LIBFLAGS)
#RPM_REQUIRES               = $(shell echo "$(RPM_REQUIRES_RUN) $(RPM_REQUIRES_DEVEL)" | $(add_flavour_prefix))
RPM_REQUIRES              += $(RPM_REQUIRES_RUN) $(RPM_REQUIRES_DEVEL)

all:

nothing:

doc-module:
	$(BROWSER) $(JANWARE_URL_DOC_MODULE)

doc-project:
	$(BROWSER) $(JANWARE_URL_DOC_PROJECT)

endif