# -- use of supplementary libraries

ifneq ($(filter feedfs-nexus,$(PREREQ_BUILD)),)
FEEDFS_NEXUS_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-nexus /opt/$(FLAVOUR_PATH_PREFIX)feedfs-nexus))
FEEDFS_NEXUS_VERSION       = $(call version,$(FEEDFS_NEXUS_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-nexus-run = $(FEEDFS_NEXUS_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-nexus-devel = $(FEEDFS_NEXUS_VERSION)
PREREQ_BUILD              += feedfs-objects feedfs-dsp
INCLUDE                   += -I$(FEEDFS_NEXUS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_NEXUS_DIR)/lib -lfeedfs-nexus
EXE_SEARCH_PATH           += $(FEEDFS_NEXUS_DIR)/bin
PREREQ                    += FEEDFS_NEXUS
endif

ifneq ($(filter feedfs-xchange,$(PREREQ_BUILD)),)
FEEDFS_XCHANGE_DIR         = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-xchange /opt/$(FLAVOUR_PATH_PREFIX)feedfs-xchange))
FEEDFS_XCHANGE_VERSION     = $(call version,$(FEEDFS_XCHANGE_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-xchange-run = $(FEEDFS_XCHANGE_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-xchange-devel = $(FEEDFS_XCHANGE_VERSION)
PREREQ_BUILD              += xchange feedfs-objects
INCLUDE                   += -I$(FEEDFS_XCHANGE_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_XCHANGE_DIR)/lib -lfeedfs-xchange
EXE_SEARCH_PATH           += $(FEEDFS_XCHANGE_DIR)/bin
PREREQ                    += FEEDFS_XCHANGE
endif

ifneq ($(filter feedfs-ict,$(PREREQ_BUILD)),)
FEEDFS_ICT_DIR            = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-ict /opt/$(FLAVOUR_PATH_PREFIX)feedfs-ict))
FEEDFS_ICT_VERSION        = $(call version,$(FEEDFS_ICT_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-ict-run = $(FEEDFS_ICT_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-ict-devel = $(FEEDFS_ICT_VERSION)
PREREQ_BUILD              += feedfs-objects feedfs-dsp
INCLUDE                   += -I$(FEEDFS_ICT_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_ICT_DIR)/lib -lfeedfs-ict
EXE_SEARCH_PATH           += $(FEEDFS_ICT_DIR)/bin
PREREQ                    += FEEDFS_ICT
endif

ifneq ($(filter xchange-nexus,$(PREREQ_BUILD)),)
XCHANGE_NEXUS_DIR          = $(firstword $(wildcard $(CVS_PROJ_DIR)/xchange-nexus /opt/$(FLAVOUR_PATH_PREFIX)xchange-nexus))
XCHANGE_NEXUS_VERSION      = $(call version,$(XCHANGE_NEXUS_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)xchange-nexus-run = $(XCHANGE_NEXUS_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)xchange-nexus-devel = $(XCHANGE_NEXUS_VERSION)
PREREQ_BUILD              += xchange devnet
INCLUDE                   += -I$(XCHANGE_NEXUS_DIR)/include
LIBFLAGS                  += -L$(XCHANGE_NEXUS_DIR)/lib -lxchange-nexus
EXE_SEARCH_PATH           += $(XCHANGE_NEXUS_DIR)/bin
PREREQ                    += XCHANGE_NEXUS
endif

ifneq ($(filter feedfs-mixer,$(PREREQ_BUILD)),)
FEEDFS_MIXER_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-mixer /opt/$(FLAVOUR_PATH_PREFIX)feedfs-mixer))
FEEDFS_MIXER_VERSION       = $(call version,$(FEEDFS_MIXER_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-mixer-run = $(FEEDFS_MIXER_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-mixer-devel = $(FEEDFS_MIXER_VERSION)
PREREQ_BUILD              += feedfs-dsp
INCLUDE                   += -I$(FEEDFS_MIXER_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_MIXER_DIR)/lib -lfeedfs-mixer
EXE_SEARCH_PATH           += $(FEEDFS_MIXER_DIR)/bin
PREREQ                    += FEEDFS_MIXER
endif

ifneq ($(filter feedfs-dsp,$(PREREQ_BUILD)),)
FEEDFS_DSP_DIR            = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-dsp /opt/$(FLAVOUR_PATH_PREFIX)feedfs-dsp))
FEEDFS_DSP_VERSION        = $(call version,$(FEEDFS_DSP_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-dsp-run = $(FEEDFS_DSP_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-dsp-devel = $(FEEDFS_DSP_VERSION)
PREREQ_BUILD              += feedfs-objects feedfs-circuit devnet
INCLUDE                   += -I$(FEEDFS_DSP_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_DSP_DIR)/lib -lfeedfs-dsp
EXE_SEARCH_PATH           += $(FEEDFS_DSP_DIR)/bin
PREREQ                    += FEEDFS_DSP
endif

ifneq ($(filter site,$(PREREQ_BUILD)),)
SITE_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/site /opt/$(FLAVOUR_PATH_PREFIX)site))
SITE_VERSION               = $(call version,$(SITE_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)site-run = $(SITE_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)site-devel = $(SITE_VERSION)
PREREQ_BUILD              += ytools
#INCLUDE                   += -I$(SITE_DIR)/include
#LIBFLAGS                  += -L$(SITE_DIR)/lib -lsite
#EXE_SEARCH_PATH           += $(SITE_DIR)/bin
PREREQ                    += SITE
endif

ifneq ($(filter jux2,$(PREREQ_BUILD)),)
JUX2_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/jux2 /opt/$(FLAVOUR_PATH_PREFIX)jux2))
JUX2_VERSION               = $(call version,$(JUX2_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jux2-run = $(JUX2_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jux2-devel = $(JUX2_VERSION)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += feedfs-wt
PREREQ_BUILD              += btools
PREREQ_BUILD              += jux
INCLUDE                   += -I$(JUX2_DIR)/include
LIBFLAGS                  += -L$(JUX2_DIR)/lib -ljux2
EXE_SEARCH_PATH           += $(JUX2_DIR)/bin
PREREQ                    += JUX2
endif

ifneq ($(filter jux,$(PREREQ_BUILD)),)
JUX_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/jux /opt/$(FLAVOUR_PATH_PREFIX)jux))
JUX_VERSION               = $(call version,$(JUX_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jux-run = $(JUX_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jux-devel = $(JUX_VERSION)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += feedfs-net
PREREQ_BUILD              += feedfs-local
PREREQ_BUILD              += btools
PREREQ_BUILD              += jux-shared
INCLUDE                   += -I$(JUX_DIR)/include
LIBFLAGS                  += -L$(JUX_DIR)/lib -ljux
EXE_SEARCH_PATH           += $(JUX_DIR)/bin
PREREQ                    += JUX
endif

ifneq ($(filter jux-client-java,$(PREREQ_BUILD)),)
JUX_CLIENT_JAVA_DIR        = $(firstword $(wildcard $(CVS_PROJ_DIR)/jux-client-java /opt/$(FLAVOUR_PATH_PREFIX)jux-client-java))
JUX_CLIENT_JAVA_VERSION    = $(call version,$(JUX_CLIENT_JAVA_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jux-client-java-run = $(JUX_CLIENT_JAVA_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jux-client-java-devel = $(JUX_CLIENT_JAVA_VERSION)
PREREQ_BUILD              += jux-client
LIBFLAGS                  += -L$(JUX_CLIENT_JAVA_DIR)/lib -ljux-client-java
PREREQ                    += JUX_CLIENT_JAVA
endif

ifneq ($(filter jux-client,$(PREREQ_BUILD)),)
JUX_CLIENT_DIR             = $(firstword $(wildcard $(CVS_PROJ_DIR)/jux-client /opt/$(FLAVOUR_PATH_PREFIX)jux-client))
JUX_CLIENT_VERSION         = $(call version,$(JUX_CLIENT_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jux-client-run = $(JUX_CLIENT_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jux-client-devel = $(JUX_CLIENT_VERSION)
PREREQ_BUILD              += feedfs-net
PREREQ_BUILD              += jux-shared
INCLUDE                   += -I$(JUX_CLIENT_DIR)/include
LIBFLAGS                  += -L$(JUX_CLIENT_DIR)/lib -ljux-client
EXE_SEARCH_PATH           += $(JUX_CLIENT_DIR)/bin
PREREQ                    += JUX_CLIENT
endif

ifneq ($(filter jux-shared,$(PREREQ_BUILD)),)
JUX_SHARED_DIR             = $(firstword $(wildcard $(CVS_PROJ_DIR)/jux-shared /opt/$(FLAVOUR_PATH_PREFIX)jux-shared))
JUX_SHARED_VERSION         = $(call version,$(JUX_SHARED_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)jux-shared-run = $(JUX_SHARED_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)jux-shared-devel = $(JUX_SHARED_VERSION)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += btools
INCLUDE                   += -I$(JUX_SHARED_DIR)/include
LIBFLAGS                  += -L$(JUX_SHARED_DIR)/lib -ljux-shared
PREREQ                    += JUX_SHARED
endif

ifneq ($(filter ccasfs,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += cconsole
INCLUDE                   += -I$(CCASFS_DIR)/include
#LIBFLAGS                  += -L$(CCONSOLE_DIR)/lib -lcconsole
EXE_SEARCH_PATH           += $(CCASFS_DIR)/bin
PREREQ                    += CCASFS
endif

ifneq ($(filter cconsole,$(PREREQ_BUILD)),)
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
PREREQ                    += CCONSOLE
endif

ifneq ($(filter dspcd,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += dspider-shared
PREREQ_BUILD              += userver
INCLUDE                   += -I$(DSPCD_DIR)/include
LIBFLAGS                  += -L$(DSPCD_EXE_PREFIX)/lib -ldspcd
PREREQ                    += DSPCD
endif

ifneq ($(filter dspcd-ec,$(PREREQ_BUILD)),)
DSPCD_EC_DIR               = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dspcd-ec $(CVS_PROJ_DIR)/dspc/src/dspcd /opt/$(FLAVOUR_PATH_PREFIX)dspider/dspcd-ec))
DSPCD_EC_EXE_PREFIX        = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dspcd-ec $(CVS_PROJ_DIR)/dspc/src/dspcd /opt/$(FLAVOUR_PATH_PREFIX)dspider))
# include $(DSPCD_DIR)/make/public.mk
DSPIDER_DSPCD_EC_VERSION  = $(call version,$(DSPCD_EC_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-dspcd-ec-run = $(DSPIDER_DSPCD_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-dspcd-ec-devel = $(DSPIDER_DSPCD_VERSION)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += dspider-shared-ec
PREREQ_BUILD              += userver xchange
INCLUDE                   += -I$(DSPCD_EC_DIR)/include
LIBFLAGS                  += -L$(DSPCD_EC_EXE_PREFIX)/lib -ldspcd-ec
PREREQ                    += DSPCD_EC
endif

ifneq ($(filter dsprout,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += dspider-shared
PREREQ_BUILD              += userver
INCLUDE                   += -I$(DSPROUT_DIR)/include
LIBFLAGS                  += -L$(DSPROUT_EXE_PREFIX)/lib -ldsprout
EXE_SEARCH_PATH           += $(DSPROUT_DIR)/bin
PREREQ                    += DSPROUT
endif

ifneq ($(filter dspider-shared,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(DSPIDER_SHARED_DIR)/include
LIBFLAGS                  += -L$(DSPIDER_SHARED_EXE_PREFIX)/lib -ldspider-shared
EXE_SEARCH_PATH           += $(DSPIDER_SHARED_DIR)/bin
PREREQ                    += DSPIDER_SHARED
endif

ifneq ($(filter dspider-shared-ec,$(PREREQ_BUILD)),)
DSPIDER_SHARED_EC_DIR      = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/shared-ec $(CVS_PROJ_DIR)/dspc/src/shared /opt/$(FLAVOUR_PATH_PREFIX)dspider/shared-ec))
DSPIDER_SHARED_EC_EXE_PREFIX  = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/shared-ec $(CVS_PROJ_DIR)/dspc/src/shared /opt/$(FLAVOUR_PATH_PREFIX)dspider))
include $(DSPIDER_SHARED_EC_DIR)/make/public.mk
DSPIDER_SHARED_EC_VERSION  = $(call version,$(DSPIDER_SHARED_EC_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-shared-ec-run = $(DSPIDER_SHARED_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-shared-ec-devel = $(DSPIDER_SHARED_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(DSPIDER_SHARED_EC_DIR)/include
LIBFLAGS                  += -L$(DSPIDER_SHARED_EC_EXE_PREFIX)/lib -ldspider-shared-ec
EXE_SEARCH_PATH           += $(DSPIDER_SHARED_EC_DIR)/bin
PREREQ                    += DSPIDER_EC_SHARED
endif

ifneq ($(filter feedfs-qt,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_QT_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_QT_DIR)/lib -lfeedfs-qt
EXE_SEARCH_PATH           += $(FEEDFS_QT_DIR)/bin
PREREQ                    += FEEDFS_QT
endif

ifneq ($(filter feedfs-wt,$(PREREQ_BUILD)),)
FEEDFS_WT_DIR              = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-wt /opt/$(FLAVOUR_PATH_PREFIX)feedfs-wt))
FEEDFS_WT_VERSION          = $(call version,$(FEEDFS_WT_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-wt-run = $(FEEDFS_WT_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-wt-devel = $(FEEDFS_WT_VERSION)
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += ytools
PREREQ_BUILD              += feedfs-gui
PREREQ_BUILD              += feedfs-ini
PREREQ_BUILD              += wt-jannet
INCLUDE                   += -I$(FEEDFS_WT_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_WT_DIR)/lib -lfeedfs-wt
EXE_SEARCH_PATH           += $(FEEDFS_WT_DIR)/bin
PREREQ                    += FEEDFS_WT
endif

ifneq ($(filter feedfs-circuit-wt,$(PREREQ_BUILD)),)
FEEDFS_CIRCUIT_WT_DIR      = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-circuit-wt /opt/$(FLAVOUR_PATH_PREFIX)feedfs-circuit-wt))
FEEDFS_CIRCUIT_WT_VERSION  = $(call version,$(FEEDFS_CIRCUIT_WT_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-circuit-wt-run = $(FEEDFS_CIRCUIT_WT_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-circuit-wt-devel = $(FEEDFS_CIRCUIT_WT_VERSION)
PREREQ_BUILD              += feedfs-wt
INCLUDE                   += -I$(FEEDFS_CIRCUIT_WT_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_CIRCUIT_WT_DIR)/lib # -lfeedfs-circuit-wt
EXE_SEARCH_PATH           += $(FEEDFS_CIRCUIT_WT_DIR)/bin
PREREQ                    += FEEDFS_CIRCUIT_WT
endif

ifneq ($(filter feedfs-gui,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += feedfs-objects
INCLUDE                   += -I$(FEEDFS_GUI_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_GUI_DIR)/lib -lfeedfs-gui
EXE_SEARCH_PATH           += $(FEEDFS_GUI_DIR)/bin
PREREQ                    += FEEDFS_GUI
endif

ifneq ($(filter feedfs-bz,$(PREREQ_BUILD)),)
FEEDFS_BZ_DIR              = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-bz /opt/$(FLAVOUR_PATH_PREFIX)feedfs-bz))
FEEDFS_BZ_VERSION          = $(call version,$(FEEDFS_BZ_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-bz-run = $(FEEDFS_BZ_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-bz-devel = $(FEEDFS_BZ_VERSION)
PREREQ_BUILD              += feedfs-objects
INCLUDE                   += -I$(FEEDFS_BZ_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_BZ_DIR)/lib -lfeedfs-bz
EXE_SEARCH_PATH           += $(FEEDFS_BZ_DIR)/bin
PREREQ                    += FEEDFS_BZ
endif

ifneq ($(filter feedfsd,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFSD_DIR)/include
LIBFLAGS                  += -L$(FEEDFSD_DIR)/lib -lfeedfsd
EXE_SEARCH_PATH           += $(FEEDFSD_DIR)/bin
PREREQ                    += FEEDFSD
endif

ifneq ($(filter feedfs-ldap,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_LDAP_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_LDAP_DIR)/lib -lfeedfs-ldap -lldap
EXE_SEARCH_PATH           += $(FEEDFS_LDAP_DIR)/bin
PREREQ                    += FEEDFS_LDAP
endif

ifneq ($(filter feedfs-utils,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_UTILS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_UTILS_DIR)/lib -lfeedfs-utils
EXE_SEARCH_PATH           += $(FEEDFS_UTILS_DIR)/bin
PREREQ                    += FEEDFS_UTILS
endif

ifneq ($(filter feedfs-net,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += xchange
PREREQ_BUILD              += feedfs-fmemfs
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_NET_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_NET_DIR)/lib -lfeedfs-net
EXE_SEARCH_PATH           += $(FEEDFS_NET_DIR)/bin
PREREQ                    += FEEDFS_NET
endif

ifneq ($(filter feedfs-parport,$(PREREQ_BUILD)),)
FEEDFS_PARPORT_DIR         = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-parport /opt/$(FLAVOUR_PATH_PREFIX)feedfs-parport))
FEEDFS_PARPORT_VERSION     = $(call version,$(FEEDFS_PARPORT_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-parport-run = $(FEEDFS_PARPORT_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-parport-devel = $(FEEDFS_PARPORT_VERSION)
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_PARPORT_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_PARPORT_DIR)/lib -lfeedfs-parport
EXE_SEARCH_PATH           += $(FEEDFS_PARPORT_DIR)/bin
PREREQ                    += FEEDFS_PARPORT
endif

ifneq ($(filter feedfs-circuit,$(PREREQ_BUILD)),)
FEEDFS_CIRCUIT_DIR         = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-circuit /opt/$(FLAVOUR_PATH_PREFIX)feedfs-circuit))
FEEDFS_CIRCUIT_VERSION     = $(call version,$(FEEDFS_CIRCUIT_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-circuit-run = $(FEEDFS_CIRCUIT_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-circuit-devel = $(FEEDFS_CIRCUIT_VERSION)
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_CIRCUIT_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_CIRCUIT_DIR)/lib -lfeedfs-circuit
EXE_SEARCH_PATH           += $(FEEDFS_CIRCUIT_DIR)/bin
PREREQ                    += FEEDFS_CIRCUIT
endif

ifneq ($(filter feedfs-ini,$(PREREQ_BUILD)),)
FEEDFS_INI_DIR             = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-ini /opt/$(FLAVOUR_PATH_PREFIX)feedfs-ini))
FEEDFS_INI_VERSION         = $(call version,$(FEEDFS_INI_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-ini-run = $(FEEDFS_INI_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-ini-devel = $(FEEDFS_INI_VERSION)
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_INI_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_INI_DIR)/lib # -lfeedfs-ini
EXE_SEARCH_PATH           += $(FEEDFS_INI_DIR)/bin
PREREQ                    += FEEDFS_INI
endif

ifneq ($(filter feedfs-local,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
# no build-time linkage necessary, no headers exported
LD_LIB_PATH               += $(FEEDFS_LOCAL_DIR)/lib
EXE_SEARCH_PATH           += $(FEEDFS_LOCAL_DIR)/bin
PREREQ                    += FEEDFS_LOCAL
endif

ifneq ($(filter feedfs-rewrite,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
LD_LIB_PATH               += $(FEEDFS_REWRITE_DIR)/lib
EXE_SEARCH_PATH           += $(FEEDFS_REWRITE_DIR)/bin 
INCLUDE                   += -I$(FEEDFS_REWRITE_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_REWRITE_DIR)/lib -lfeedfs-rewrite

PREREQ                    += FEEDFS_REWRITE
endif

ifneq ($(filter feedfs-fmemfs,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
# 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
PREREQ                    += FEEDFS_FMEMFS
endif

ifneq ($(filter feedfs-syslog,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
# 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
PREREQ                    += FEEDFS_SYSLOG
endif

ifneq ($(filter feedfs-objects,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_OBJECTS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_OBJECTS_DIR)/lib -lfeedfs-objects
EXE_SEARCH_PATH           += $(FEEDFS_OBJECTS_DIR)/bin
PREREQ                    += FEEDFS_OBJECTS
endif

ifneq ($(filter feedfs,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += valdi
PREREQ_BUILD              += auth
INCLUDE                   += -I$(FEEDFS_DIR)/include
LIBFLAGS                  += -L$(FEEDFS_DIR)/lib -lfeedfs
EXE_SEARCH_PATH           += $(FEEDFS_DIR)/bin
PREREQ                    += FEEDFS
endif

ifneq ($(filter userver,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += xchange
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(USERVER_DIR)/include
LIBFLAGS                  += -L$(USERVER_DIR)/lib -luserver
EXE_SEARCH_PATH           += $(USERVER_DIR)/bin
PREREQ                    += USERVER
endif

ifneq ($(filter xchange-shell,$(PREREQ_BUILD)),)
XCHANGE_SHELL_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/xchange-shell /opt/$(FLAVOUR_PATH_PREFIX)xchange-shell))
XCHANGE_SHELL_VERSION       = $(call version,$(XCHANGE_SHELL_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)xchange-shell-run = $(XCHANGE_SHELL_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)xchange-shell-devel = $(XCHANGE_SHELL_VERSION)
PREREQ_BUILD              += xchange shell
INCLUDE                   += -I$(XCHANGE_SHELL_DIR)/include
LIBFLAGS                  += -L$(XCHANGE_SHELL_DIR)/lib -lxchange-shell
EXE_SEARCH_PATH           += $(XCHANGE_SHELL_DIR)/bin
PREREQ                    += XCHANGE_SHELL
endif

ifneq ($(filter xchange-pcap,$(PREREQ_BUILD)),)
XCHANGE_PCAP_DIR           = $(firstword $(wildcard $(CVS_PROJ_DIR)/xchange-pcap /opt/$(FLAVOUR_PATH_PREFIX)xchange-pcap))
XCHANGE_PCAP_VERSION       = $(call version,$(XCHANGE_PCAP_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)xchange-pcap-run = $(XCHANGE_PCAP_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)xchange-pcap-devel = $(XCHANGE_PCAP_VERSION)
PREREQ_BUILD              += xchange
INCLUDE                   += -I$(XCHANGE_PCAP_DIR)/include
#LIBFLAGS                  += -L$(XCHANGE_PCAP_DIR)/lib -lxchange-pcap
LIBFLAGS                  += -L$(XCHANGE_PCAP_DIR)/lib
EXE_SEARCH_PATH           += $(XCHANGE_PCAP_DIR)/bin
PREREQ                    += XCHANGE_PCAP
endif

ifneq ($(filter xchange,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += valdi
INCLUDE                   += -I$(XCHANGE_DIR)/include
LIBFLAGS                  += -L$(XCHANGE_DIR)/lib -lxchange
EXE_SEARCH_PATH           += $(XCHANGE_DIR)/bin
PREREQ                    += XCHANGE
endif

ifneq ($(filter ntv2,$(PREREQ_BUILD)),)
NTV2_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/ntv2 /opt/$(FLAVOUR_PATH_PREFIX)ntv2))
NTV2_VERSION               = $(call version,$(NTV2_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)ntv2-run = $(NTV2_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)ntv2-devel = $(NTV2_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(NTV2_DIR)/include
LIBFLAGS                  += -L$(NTV2_DIR)/lib -lntv2
EXE_SEARCH_PATH           += $(NTV2_DIR)/bin
PREREQ                    += NTV2
endif

ifneq ($(filter btools,$(PREREQ_BUILD)),)
BTOOLS_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/btools /opt/$(FLAVOUR_PATH_PREFIX)dspider-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)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(BTOOLS_DIR)/include
LIBFLAGS                  += -L$(BTOOLS_DIR)/lib -ldspider-btools
EXE_SEARCH_PATH           += $(BTOOLS_DIR)/bin
PREREQ                    += BTOOLS
endif

ifneq ($(filter jackjart,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(JACKJART_DIR)/include
LIBFLAGS                  += -L$(JACKJART_DIR)/lib -ldspider-jackjart
EXE_SEARCH_PATH           += $(JACKJART_DIR)/bin
PREREQ                    += JACKJART
endif

ifneq ($(filter jackrtai,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(JACKRTAI_DIR)/include
LIBFLAGS                  += -L$(JACKRTAI_DIR)/lib -ldspider-jackrtai
EXE_SEARCH_PATH           += $(JACKRTAI_DIR)/bin
PREREQ                    += JACKRTAI
endif

ifneq ($(filter jackdummy,$(PREREQ_BUILD)),)
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)dspider-jackdummy-run = $(JACKDUMMY_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-jackdummy-devel = $(JACKDUMMY_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(JACKDUMMY_DIR)/include
LIBFLAGS                  += -L$(JACKDUMMY_DIR)/lib -ldspider-jackdummy
EXE_SEARCH_PATH           += $(JACKDUMMY_DIR)/bin
PREREQ                    += JACKDUMMY
endif

ifneq ($(filter alsart,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(ALSART_DIR)/include
LIBFLAGS                  += -L$(ALSART_DIR)/lib -lalsart
EXE_SEARCH_PATH           += $(ALSART_DIR)/bin
PREREQ                    += ALSART
endif

ifneq ($(filter jackmix,$(PREREQ_BUILD)),)
JACKMIX_DIR               = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dspcd-plugins/jackmix /opt/$(FLAVOUR_PATH_PREFIX)dspider/jackmix))
JACKMIX_VERSION           = $(call version,$(JACKMIX_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-jackmix-run = $(JACKMIX_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-jackmix-devel = $(JACKMIX_VERSION)
PREREQ_BUILD              += ytools btools
INCLUDE                   += -I$(JACKMIX_DIR)/include
LIBFLAGS                  += -L$(JACKMIX_DIR)/lib -ldspider-jackmix
LD_LIB_PATH               += $(JACKMIX_DIR)/dsplib
EXE_SEARCH_PATH           += $(JACKMIX_DIR)/bin
PREREQ                    += JACKMIX
endif

ifneq ($(filter scmjm,$(PREREQ_BUILD)),)
SCMJM_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dspcd-plugins/scmjm /opt/$(FLAVOUR_PATH_PREFIX)dspider/scmjm))
SCMJM_VERSION             = $(call version,$(SCMJM_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-scmjm-run = $(SCMJM_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-scmjm-devel = $(SCMJM_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(SCMJM_DIR)/include
LIBFLAGS                  += -L$(SCMJM_DIR)/lib -ldspider-scmjm
LD_LIB_PATH               += $(SCMJM_DIR)/dsplib
EXE_SEARCH_PATH           += $(SCMJM_DIR)/bin
PREREQ                    += SCMJM
endif

ifneq ($(filter scm,$(PREREQ_BUILD)),)
SCM_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/dspc/src/dspcd-plugins/scm /opt/$(FLAVOUR_PATH_PREFIX)dspider/scm))
SCM_VERSION               = $(call version,$(SCM_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)dspider-scm-run = $(SCM_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)dspider-scm-devel = $(SCM_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(SCM_DIR)/include
LIBFLAGS                  += -L$(SCM_DIR)/lib -ldspider-scm
EXE_SEARCH_PATH           += $(SCM_DIR)/bin
PREREQ                    += SCM
endif

ifneq ($(filter dspfs,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(DSPFS_DIR)/include
LIBFLAGS                  += -L$(DSPFS_DIR)/lib -ldspfs
EXE_SEARCH_PATH           += $(DSPFS_DIR)/bin
PREREQ                    += DSPFS
endif

ifneq ($(filter auth,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
PREREQ_BUILD              += valdi
INCLUDE                   += -I$(AUTH_DIR)/include
LIBFLAGS                  += -L$(AUTH_DIR)/lib -lauth
EXE_SEARCH_PATH           += $(AUTH_DIR)/bin
PREREQ                    += AUTH
endif

ifneq ($(filter emscren-v8,$(PREREQ_BUILD)),)
EMSCREN_V8_DIR             = $(firstword $(wildcard $(CVS_PROJ_DIR)/emscren-v8 /opt/$(FLAVOUR_PATH_PREFIX)emscren-v8))
EMSCREN_V8_VERSION         = $(call version,$(EMSCREN_V8_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)emscren-v8-run = $(EMSCREN_V8_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)emscren-v8-devel = $(EMSCREN_V8_VERSION)
PREREQ_BUILD              += ytools
#INCLUDE                   += -I$(EMSCREN_V8_DIR)/include
LIBFLAGS                  += -L$(EMSCREN_V8_DIR)/lib
#LIBFLAGS                  += -L$(EMSCREN_V8_DIR)/lib -lemscren-v8
EXE_SEARCH_PATH           += $(EMSCREN_V8_DIR)/bin
PREREQ                    += EMSCREN_V8
endif

ifneq ($(filter emscren,$(PREREQ_BUILD)),)
EMSCREN_DIR                 = $(firstword $(wildcard $(CVS_PROJ_DIR)/emscren /opt/$(FLAVOUR_PATH_PREFIX)emscren))
EMSCREN_VERSION             = $(call version,$(EMSCREN_DIR))
#RPM_REQUIRES_RUN           += $(FLAVOUR_PREFIX)emscren-run = $(EMSCREN_VERSION)
#RPM_REQUIRES_DEVEL         += $(FLAVOUR_PREFIX)emscren-devel = $(EMSCREN_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(EMSCREN_DIR)/include
LIBFLAGS                  += -L$(EMSCREN_DIR)/lib
LIBFLAGS                  += -L$(EMSCREN_DIR)/lib -lemscren
EXE_SEARCH_PATH           += $(EMSCREN_DIR)/bin
PREREQ                    += EMSCREN
endif

ifneq ($(filter valdi,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
#INCLUDE                   += -I$(VALDI_DIR)/include
LIBFLAGS                  += -L$(VALDI_DIR)/lib
#LIBFLAGS                  += -L$(VALDI_DIR)/lib -lvaldi
EXE_SEARCH_PATH           += $(VALDI_DIR)/bin
PREREQ                    += VALDI
endif

ifneq ($(filter feedfs-cmd,$(PREREQ_BUILD)),)
FEEDFS_CMD_DIR             = $(firstword $(wildcard $(CVS_PROJ_DIR)/feedfs-cmd /opt/$(FLAVOUR_PATH_PREFIX)feedfs-cmd))
FEEDFS_CMD_VERSION         = $(call version,$(FEEDFS_CMD_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)feedfs-cmd-run = $(FEEDFS_CMD_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)feedfs-cmd-devel = $(FEEDFS_CMD_VERSION)
PREREQ_BUILD              += feedfs-objects
PREREQ_BUILD              += feedfs-utils
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(FEEDFS_CMD_DIR)/include
#LIBFLAGS                  += -L$(FEEDFS_CMD_DIR)/lib -lfeedfs-cmd
LIBFLAGS                  += -L$(FEEDFS_CMD_DIR)/lib
EXE_SEARCH_PATH           += $(FEEDFS_CMD_DIR)/bin
PREREQ                    += FEEDFS_CMD
endif

ifneq ($(filter shell,$(PREREQ_BUILD)),)
SHELL_DIR                   = $(firstword $(wildcard $(CVS_PROJ_DIR)/shell /opt/$(FLAVOUR_PATH_PREFIX)shell))
SHELL_VERSION               = $(call version,$(SHELL_DIR))
#RPM_REQUIRES_RUN           += $(FLAVOUR_PREFIX)shell-run = $(SHELL_VERSION)
#RPM_REQUIRES_DEVEL         += $(FLAVOUR_PREFIX)shell-devel = $(SHELL_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(SHELL_DIR)/include
LIBFLAGS                  += -L$(SHELL_DIR)/lib -lshell
EXE_SEARCH_PATH           += $(SHELL_DIR)/bin
PREREQ                    += SHELL
endif

ifneq ($(filter wt-jannet,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
INCLUDE                   += -I$(WT_JANNET_DIR)/include
LD_LIB_PATH               += $(WT_JANNET_DIR)/lib
EXE_SEARCH_PATH           += $(WT_JANNET_DIR)/bin
LIBFLAGS                  += -L$(WT_JANNET_DIR)/lib -lwt-jannet
PREREQ                    += WT_JANNET
CATCH_ONLY_YERROR          = false
endif

ifneq ($(filter apache2-jannet,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += feedfs
# no build-time linkage necessary, no headers exported
LD_LIB_PATH               += $(APACHE2_JANNET_DIR)/lib
EXE_SEARCH_PATH           += $(APACHE2_JANNET_DIR)/bin
PREREQ                    += APACHE2_JANNET
endif

ifneq ($(filter fptest,$(PREREQ_BUILD)),)
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)
PREREQ_BUILD              += ytools
INCLUDE                    += -I$(FPTEST_DIR)/include
LIBFLAGS                   += -L$(FPTEST_DIR)/lib -lfptest -L$(HOME)/opt/iowkit/lib -liowkit
EXE_SEARCH_PATH            += $(FPTEST_DIR)/bin
PREREQ                    += FPTEST
endif

ifneq ($(filter fpanel,$(PREREQ_BUILD)),)
FPANEL_DIR                  = $(firstword $(wildcard $(CVS_PROJ_DIR)/fpanel /opt/$(FLAVOUR_PATH_PREFIX)fpanel))
FPANEL_VERSION              = $(call version,$(FPANEL_DIR))
#RPM_REQUIRES_RUN           += $(FLAVOUR_PREFIX)fpanel-run = $(FPANEL_VERSION)
#RPM_REQUIRES_DEVEL         += $(FLAVOUR_PREFIX)fpanel-devel = $(FPANEL_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                    += -I$(FPANEL_DIR)/include
LIBFLAGS                   += -L$(FPANEL_DIR)/lib -lfpanel -L$(HOME)/opt/iowkit/lib -liowkit
EXE_SEARCH_PATH            += $(FPANEL_DIR)/bin
PREREQ                    += FPANEL
endif

ifneq ($(filter devnet,$(PREREQ_BUILD)),)
DEVNET_DIR                = $(firstword $(wildcard $(CVS_PROJ_DIR)/devnet /opt/$(FLAVOUR_PATH_PREFIX)devnet))
DEVNET_VERSION            = $(call version,$(DEVNET_DIR))
#RPM_REQUIRES_RUN          += $(FLAVOUR_PREFIX)devnet-run = $(DEVNET_VERSION)
#RPM_REQUIRES_DEVEL        += $(FLAVOUR_PREFIX)devnet-devel = $(DEVNET_VERSION)
PREREQ_BUILD              += ytools
INCLUDE                   += -I$(DEVNET_DIR)/include
LIBFLAGS                  += -L$(DEVNET_DIR)/lib -ldevnet
EXE_SEARCH_PATH           += $(DEVNET_DIR)/bin
PREREQ                    += DEVNET
endif

ifneq ($(filter ytools,$(PREREQ_BUILD)),)
 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))
 RPM_REQUIRES_DEVEL        += glib2-devel
 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
PREREQ                    += YTOOLS
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