# ----- compilation options
CREATE_DEVEL          ?= true
#COMPILER_SUITE        ?= clang
COMPILER_SUITE        ?= gcc

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

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

ifeq ($(TARGET),mingw)
  ifneq ($(wildcard /usr/bin/i686-w64-mingw32-gcc),)
    PROJECT_CFLAGS      += -D_WINDOWS
    PROJECT_CPPFLAGS    += -D_WINDOWS
    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++
  LD                   ?= $(CROSS_TOOL_BIN_PREFIX)ld
  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++
  LD                   ?= ld
  CLANG                ?= clang
  CLANGPP              ?= clang++
  STRIP                ?= strip
  RANLIB               ?= ranlib
  AR                   ?= ar
endif # ifeq ($(TARGET),mingw)

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

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

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

CPP                   ?= g++

# ----- 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 "$(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
  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))

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              += $(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)

# -- 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.$(MAJOR_MINOR_RELEASE)
    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)