# ----- compilation options
#COMPILER_SUITE             ?= clang
COMPILER_SUITE              ?= gcc
LIBTYPE                     ?= shared

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

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

ifeq ($(findstring $(TARGET_OS),linux),)
  USE_SYSTEMD               := false
endif

ifeq ($(DEVELOPMENT),true)
  export G_SLICE             = always-malloc
  export G_DEBUG             = gc-friendly,resident-modules
  export MALLOC_CHECK_       = 2
endif

USE_PROJECT_LIB             ?= true
EXPORT_PROJECT_LIB          ?= $(USE_PROJECT_LIB)
USE_JW_BUILD                ?= true
USE_EXCEPTIONS_IN_C         ?= true

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

SYSCFG_DIR                  ?= /etc/sysconfig
SYSCFG_FILE                 ?= $(SYSCFG_DIR)/$(PROJECT)
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

# ----- tool chain

ifneq ($(TARGET_TRIPLET),$(HOST_TRIPLET)) # we're cross-compiling

  TC_BIN_PREFIX             ?= $(TARGET_TRIPLET)-
  TC_SYS_ROOT               ?= /usr/$(TARGET_TRIPLET)

  ifeq ($(TARGET),mingw)

    ifneq ($(wildcard $(TC_BIN_PREFIX)gcc),)
      CROSS_TOOL_DIR        ?=
      TC_SYS_ROOT           ?= /usr/$(TARGET_TRIPLET)/sys-root/mingw
    else
      CROSS_TOOL_DIR        ?= /opt/cross-tools
      TC_BIN_PREFIX         ?= $(CROSS_TOOL_DIR)/bin/i686-pc-mingw32-
    endif

    PROJECT_CFLAGS          += -D_WINDOWS
    PROJECT_CPPFLAGS        += -D_WINDOWS
    BUILD_LDFLAGS           += -lws2_32
    WINDRES                 ?= $(TC_BIN_PREFIX)windres
    USE_GFILTER             ?= false
    MS_LD                   ?= wine $(HOME)/local/mingw/packages/msvcpp/bin/LIB.EXE
  endif

  #PROJECT_CFLAGS           += -I$(TC_SYS_ROOT)/include
  #PROJECT_CPPFLAGS         += -I$(TC_SYS_ROOT)/include
  #PROJECT_LDFLAGS          += -L$(TC_SYS_ROOT)/lib

else # we're not cross-compiling

  TC_SYS_ROOT               ?= /usr
  ifeq ($(LIBTYPE),shared)
    LIBFLAGS                += -ldl
  else
    LIBFLAGS                += -l:libdl.a
  endif
  LIBFLAGS                  += -pthread

endif

ifeq ($(TARGET_ARCH),x86_64)
  BUILD_CFLAGS              += -fPIC
  BUILD_CPPFLAGS            += -fPIC
  LIBFLAGS                  +=
endif

ifeq ($(TARGET_TRIPLET),arm-none-eabi)
  BUILD_CFLAGS              += -mcpu=cortex-m3 -mthumb
  BUILD_CPPFLAGS            += -mcpu=cortex-m3 -mthumb
endif

ifeq ($(COMPILER_SUITE),gcc)

  GCC                       ?= $(TC_BIN_PREFIX)gcc
  GPP                       ?= $(TC_BIN_PREFIX)g++
  CPP                       ?= $(GPP)
  GNU_LD                    ?= $(TC_BIN_PREFIX)ld
  CLANG                     ?= $(TC_BIN_PREFIX)clang
  CLANGPP                   ?= $(TC_BIN_PREFIX)clang++
  STRIP                     ?= $(TC_BIN_PREFIX)strip
  RANLIB                    ?= $(TC_BIN_PREFIX)ranlib
  AR                        ?= $(TC_BIN_PREFIX)ar
  PKG_CONFIG_EXE            ?= $(TC_BIN_PREFIX)pkg-config
  CPP_FILT                  ?= $(TC_BIN_PREFIX)c++filt
  OBJCOPY                   ?= $(TC_BIN_PREFIX)objcopy
  OBJDUMP                   ?= $(TC_BIN_PREFIX)objdump

  # 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))

  # Not needed anywhere
  #GNU_LD_VERSION           := $(shell $(LD) -V | $(SED) '/GNU ld/ !d; s/(.*)//; s/[^0-9.-]*//')
  #GNU_LD_VERSION_NUMBERS   := $(subst ., ,$(GNU_LD_VERSION))
  #GNU_LD_MAJOR             := $(word 1,$(GNU_LD_VERSION_NUMBERS))
  #GNU_LD_MINOR             := $(word 2,$(GNU_LD_VERSION_NUMBERS))
  #GNU_LD_REV               := $(word 3,$(GNU_LD_VERSION_NUMBERS))

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

  ifneq ($(GCC_VERSION),4.1.0)
    ifneq ($(GCC_VERSION),4.5.1)
      BUILD_CFLAGS          += -std=gnu11
      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

else ifeq ($(COMPILER_SUITE),clang)

  # clang
  CLANG_CPPFLAGS            += -Wno-unused-private-field -Wno-self-assign-field -Wno-overloaded-virtual
  CC                         = $(CLANG)
  CPP                        = $(CLANGPP)
  LD                         = $(CLANGPP)

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

endif # COMPILER_SUITE

# -- 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 *.sx)
#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 %.sx,%.o,$(patsubst %.S,%.o,$(SFILES))))

#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)
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)

# ==

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 ($(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
  # see https://stackoverflow.com/questions/4492799
  BUILD_LDFLAGS             += -fstack-protector
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

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

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

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

ifeq ($(USE_GFILTER),true)
  GFILT                      = sh $(firstword $(wildcard $(MODDIR)/contrib/gfilt/gfilt $(MODDIR)/bin/gfilt))
  ifneq ($(strip $(GFILT)),sh)
    GPP                      = $(GFILT)
  endif
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_EXE) --cflags libsystemd)
  BUILD_CPPFLAGS            += -D_USE_SYSTEMD_ $(shell $(PKG_CONFIG_EXE) --cflags libsystemd)
  BUILD_LDFLAGS             += $(shell $(PKG_CONFIG_EXE) --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
  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

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

  # breaks constexpr
  #NO_OPT_FLAGS             += -fno-builtin

  _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
  ifeq ($(LIBTYPE),shared)
    GCC_LDFLAGS             += -shared-libgcc
  endif
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))

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

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

ifeq ($(USE_GLIB),true)
  PROJECT_CFLAGS            += $(shell $(PKG_CONFIG_EXE) --cflags glib-2.0)
  PROJECT_CPPFLAGS          += $(shell $(PKG_CONFIG_EXE) --cflags glib-2.0)
  LIBFLAGS                  += $(shell $(PKG_CONFIG_EXE) --libs glib-2.0)
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                += $(LOCAL_CFLAGS) $(PROJECT_CFLAGS) $(COMPLILER_CFLAGS) $(INCLUDE)
BUILD_CPPFLAGS              += $(LOCAL_CPPFLAGS) $(PROJECT_CPPFLAGS) $(COMPILER_CPPFLAGS) $(INCLUDE)
BUILD_LDFLAGS               += $(LOCAL_LDFLAGS) $(PROJECTLIB_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)

REAL_CFLAGS                 ?= $(BUILD_CFLAGS)
REAL_CPPFLAGS               ?= $(BUILD_CPPFLAGS)
REAL_LDFLAGS                ?= $(BUILD_LDFLAGS)

# -- 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 ($(TC_SYS_ROOT),)
    CONTRIB_LIBS_PATH       += $(CROSS_TOOL_DIR)/bin
  else
    CONTRIB_LIBS_PATH       += $(TC_SYS_ROOT)/lib
  endif
endif

INSTALL_LIBDIR              ?= $(EXE_PREFIX)/lib

ifeq ($(LIBTYPE),shared)
  ifneq ($(TARGET),mingw)
    BUILD_LDFLAGS           += -rdynamic
  endif
else
  LIB_SO                    ?=
  BUILD_LDFLAGS             += -static
endif

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.$(MAJOR_MINOR_RELEASE)
    SO_PREFIX               ?= lib
    LIB_SO                  ?= $(BUILD_LIBDIR)/lib$(LIBNAME).$(SO_SUFFIX)
    LINKS_SO                += $(filter-out $(LIB_SO),$(shell $(ECHO) $(LIB_SO) | $(SED) -e "s/\.so\..*$$/.so/"))
    INSTALLED_LINKS_SO      += $(filter-out $(INSTALLED_LIB_SO),$(shell $(ECHO) $(INSTALLED_LIB_SO) | $(SED) -e "s/\.so\..*$$/.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)