#
#  $Id$
#
#  CONFIG_COMMON
#
#  This file is to be maintained by the community.
#
# Common Configuration Information

#-------------------------------------------------------
# Build architectures

# CROSS1 will be defined only when CROSS_COMPILER_HOST_ARCHS is NOT defined
CROSS1 = $(CROSS_COMPILER_TARGET_ARCHS$(word 1,$(CROSS_COMPILER_HOST_ARCHS)))

# CROSS2 will be defined only when CROSS_COMPILER_HOST_ARCHS is defined
# and EPICS_HOST_ARCH is one of it's words
CROSS2 = $(CROSS_COMPILER_TARGET_ARCHS$(filter-out 1,$(words $(filter $(EPICS_HOST_ARCH),$(CROSS_COMPILER_HOST_ARCHS)))))

BUILD_ARCHS = $(EPICS_HOST_ARCH) $(CROSS1) $(CROSS2)

#-------------------------------------------------------
# Ext, app, and module configure dir targets
CONFIG_TARGETS += CONFIG_APP_INCLUDE RULES_INCLUDE
CONFIG_INSTALLS += ../RULES_BUILD

#-------------------------------------------------------
# Check configure/RELEASE file for consistency
CHECK_RELEASE_YES = checkRelease
CHECK_RELEASE_NO =

#-------------------------------------------------------
# Cross compile default, HOST or CROSS, CONFIG.crossCommon will override
BUILD_CLASS = HOST

#-------------------------------------------------------
# Prefix and suffix
DEP=.depends
DIVIDER = .
OBJ = .
RES = .

#-------------------------------------------------------
# Default for perl if it's on the PATH,
# otherwise override this in os/CONFIG_SITE.<host_arch>.Common
PERL=perl

#-------------------------------------------------------
# tools for installing libraries and products
INSTALL = $(PERL) $(TOOLS)/installEpics.pl
INSTALL_PRODUCT = $(INSTALL)
INSTALL_LIBRARY = $(INSTALL)

#---------------------------------------------------------------
# tools for making header dependancies and variable replacement
MKMF                       = $(PERL) $(TOOLS)/mkmf.pl
REPLACEVAR                 = $(PERL) $(TOOLS)/replaceVAR.pl

#-------------------------------------------------------
# Directories

INSTALL_LOCATION            = $(TOP)
TOOLS                       = $(CONFIG)/tools

INSTALL_LOCATION_LIB        = $(INSTALL_LOCATION)/lib
INSTALL_LOCATION_BIN        = $(INSTALL_LOCATION)/bin

INSTALL_HOST_BIN            = $(INSTALL_LOCATION_BIN)/$(EPICS_HOST_ARCH)
INSTALL_HOST_LIB            = $(INSTALL_LOCATION_LIB)/$(EPICS_HOST_ARCH)

INSTALL_INCLUDE             = $(INSTALL_LOCATION)/include
INSTALL_DOC                 = $(INSTALL_LOCATION)/doc
INSTALL_HTML                = $(INSTALL_LOCATION)/html
INSTALL_TEMPLATES           = $(INSTALL_LOCATION)/templates
INSTALL_DBD                 = $(INSTALL_LOCATION)/dbd
INSTALL_DB                  = $(INSTALL_LOCATION)/db
INSTALL_CONFIG              = $(INSTALL_LOCATION)/configure
INSTALL_JAVA                = $(INSTALL_LOCATION)/javalib

#Directory for OS independant build created files
COMMON_DIR = ../O.Common

ifdef T_A

INSTALL_LIB                 = $(INSTALL_LOCATION_LIB)/$(T_A)
INSTALL_SHRLIB              = $(INSTALL_LOCATION_LIB)/$(T_A)
INSTALL_TCLLIB              = $(INSTALL_LOCATION_LIB)/$(T_A)
INSTALL_BIN                 = $(INSTALL_LOCATION_BIN)/$(T_A)

#--------------------------------------------------
# vpath directories
GENERIC_SRC_DIRS = .. $(SRC_DIRS)
OS_SRC_DIRS += . $(foreach dir, .. $(SRC_DIRS), \
            $(dir)/os/$(OS_CLASS) $(dir)/os/posix $(dir)/os/default )
ALL_SRC_DIRS = $(OS_SRC_DIRS) $(GENERIC_SRC_DIRS)

#--------------------------------------------------
# compile line include directories
INSTALL_INCLUDES += \
       -I$(INSTALL_INCLUDE)/os/$(OS_CLASS) \
       -I$(INSTALL_INCLUDE)
GENERIC_SRC_INCLUDES = $(addprefix -I, $(GENERIC_SRC_DIRS))

#--------------------------------------------------
# Target filename definitions
OBJSNAME = $(addsuffix $(OBJ),$(basename $(OBJS)))
PRODNAME = $(addsuffix $(EXE),$(basename $(PROD)))
TESTPRODNAME = $(addsuffix $(EXE),$(basename $(TESTPROD)))

SHRLIBNAME = $(SHRLIBNAME_$(SHARED_LIBRARIES))

JAVA =
JAR =

#--------------------------------------------------
# obj files

TARGET_OBJS =  $($*_LDOBJS) $(addsuffix $(OBJ),$(basename $($*_OBJS)))

PRODUCT_OBJS = $(addsuffix $(OBJ),$(basename $(SRCS) $(PROD_SRCS) $(PROD_OBJS)))
PROD_LD_OBJS = $(LDOBJS) $(TARGET_OBJS) $(PRODUCT_OBJS)

LIBRARY_OBJS = $(addsuffix $(OBJ),$(basename $(SRCS) $(LIB_SRCS) $(LIBSRCS) $(LIB_OBJS)))
LIBRARY_LD_OBJS = $(LDOBJS) $(TARGET_OBJS) $(LIBRARY_OBJS)

#--------------------------------------------------
# WIN95/NT resource files

TARGET_RESS = $(addsuffix $(RES),$(basename $($*_RCS)))

PROD_RESS = $(addsuffix $(RES),$(basename $(RCS) $(PROD_RCS)))
PROD_LD_RESS = $(TARGET_RESS) $(PROD_RESS)

LIBRARY_RESS = $(addsuffix $(RES),$(basename $(RCS) $(LIBRARY_RCS)))
LIBRARY_LD_RESS = $(TARGET_RESS) $(LIBRARY_RESS)

#--------------------------------------------------
# WIN95/NT source browser
PROD_BAF = $(addsuffix $(BAF), $(basename $(PROD)))
LIB_BAF=$(addsuffix $(BAF),$(basename $(LIBRARY)))

#--------------------------------------------------
# C preprocessor, compiler, and linker flag defaults

# Target architecture specific (solaris,sun4,mv167,...) flags
ARCH_DEP_CPPFLAGS =
ARCH_DEP_CFLAGS =
ARCH_DEP_CXXFLAGS = $(ARCH_DEP_CFLAGS)
ARCH_DEP_LDFLAGS =
ARCH_DEP_LDLIBS =

# Target operating system specific (Unix,Vx,WIN32...) flags
OP_SYS_CPPFLAGS =
OP_SYS_CFLAGS =
OP_SYS_CXXFLAGS = $(OP_SYS_CFLAGS)
OP_SYS_LDFLAGS =
OP_SYS_INCLUDES =
OP_SYS_LDLIBS =

# SOURCE* used by WIN32 only
SOURCE_CFLAG =
SOURCE_CXXCFLAG =

# Makefile specific flags
USR_INCLUDES =
USR_CFLAGS =
USR_CXXFLAGS =
USR_LDFLAGS =
USR_LIBS =
USR_CPPFLAGS =
USR_DBDFLAGS =
USR_ARFLAGS =

# Target specific options
TARGET_INCLUDES = $($(basename $@)_INCLUDES_$(T_A)) $($(basename $@)_INCLUDES)
TARGET_CFLAGS = $($(basename $@)_CFLAGS_$(T_A)) $($(basename $@)_CFLAGS)
TARGET_CXXFLAGS = $($(basename $@)_CXXFLAGS_$(T_A)) $($(basename $@)_CXXFLAGS)
TARGET_LDFLAGS = $($(basename $@)_LDFLAGS_$(T_A)) $($(basename $@)_LDFLAGS)
TARGET_CPPFLAGS = $($(basename $@)_CPPFLAGS_$(T_A)) $($(basename $@)_CPPFLAGS)

TARGET_INCLUDES += $($(basename $@)_INCLUDES_$(OS_CLASS)) $($(basename $@)_INCLUDES)
TARGET_CFLAGS += $($(basename $@)_CFLAGS_$(OS_CLASS)) $($(basename $@)_CFLAGS)
TARGET_CXXFLAGS += $($(basename $@)_CXXFLAGS_$(OS_CLASS)) $($(basename $@)_CXXFLAGS)
TARGET_LDFLAGS += $($(basename $@)_LDFLAGS_$(OS_CLASS)) $($(basename $@)_LDFLAGS)
TARGET_CPPFLAGS += $($(basename $@)_CPPFLAGS_$(OS_CLASS)) $($(basename $@)_CPPFLAGS)

# Level of ansi conformance flags
CONFORM_CPPFLAGS = $(CONFORM_CPPFLAGS_$(firstword $($(basename $@)_CMPLR_$(T_A)) \
 $($(basename $@)_CMPLR_$(OS_CLASS)) $($(basename $@)_CMPLR) $(CMPLR)))
CONFORM_CFLAGS = $(CONFORM_CFLAGS_$(firstword $($(basename $@)_CMPLR_$(T_A)) \
 $($(basename $@)_CMPLR_$(OS_CLASS)) $($(basename $@)_CMPLR) $(CMPLR)))
CONFORM_CXXFLAGS = $(CONFORM_CXXFLAGS_$(firstword $($(basename $@)_CMPLR_$(T_A)) \
 $($(basename $@)_CMPLR_$(OS_CLASS)) $($(basename $@)_CMPLR) $(CXXCMPLR)))

# Warnings flags
WARN_CFLAGS = $(WARN_CFLAGS_$(firstword $($(basename $@)_WARN_$(T_A)) \
 $($(basename $@)_WARN_$(OS_CLASS)) $($(basename $@)_WARN) $($(BUILD_CLASS)_WARN)))
WARN_CXXFLAGS = $(WARN_CXXFLAGS_$(firstword $($(basename $@)_WARN_$(T_A)) \
 $($(basename $@)_WARN_$(OS_CLASS)) $($(basename $@)_WARN) $($(BUILD_CLASS)_WARN)))

# Optimization flags
OPT_CFLAGS = $(OPT_CFLAGS_$(firstword $($(basename $@)_OPT_$(T_A)) \
 $($(basename $@)_OPT_$(OS_CLASS)) $($(basename $@)_OPT) $($(BUILD_CLASS)_OPT)))
OPT_CXXFLAGS = $(OPT_CXXFLAGS_$(firstword $($(basename $@)_OPT_$(T_A)) \
 $($(basename $@)_OPT_$(OS_CLASS)) $($(basename $@)_OPT) $($(BUILD_CLASS)_OPT)))

# Posix flags
POSIX=YES
POSIX_CPPFLAGS=$(POSIX_CPPFLAGS_$(POSIX))
POSIX_LDLIBS=$(POSIX_LDLIBS_$(POSIX))

# Static build flags
STATIC_CFLAGS = $(STATIC_CFLAGS_$(STATIC_BUILD))
STATIC_CXXCFLAGS = $(STATIC_CXXFLAGS_$(STATIC_BUILD))
STATIC_LDFLAGS = $(STATIC_LDFLAGS_$(STATIC_BUILD))
STATIC_LDLIBS = $(STATIC_LDLIBS_$(STATIC_BUILD))

#--------------------------------------------------
# Flags

INCLUDES = -I. $(GENERIC_SRC_INCLUDES) $(INSTALL_INCLUDES) $(RELEASE_INCLUDES)\
 $(TARGET_INCLUDES) $(USR_INCLUDES) $(OP_SYS_INCLUDES) $(CROSS_INCLUDES)

CFLAGS = $(CONFORM_CFLAGS) $(CROSS_CFLAGS) $(OPT_CFLAGS) $(DEBUG_CFLAGS)\
 $(WARN_CFLAGS) $(TARGET_CFLAGS) $(USR_CFLAGS) $(ARCH_DEP_CFLAGS)\
 $(CODE_CFLAGS) $(STATIC_CFLAGS) $(OP_SYS_CFLAGS)

CXXFLAGS = $(CONFORM_CXXFLAGS) $(CROSS_CXXFLAGS) $(OPT_CXXFLAGS)\
 $(DEBUG_CXXFLAGS) $(WARN_CXXFLAGS) $(TARGET_CXXFLAGS) $(USR_CXXFLAGS)\
 $(ARCH_DEP_CXXFLAGS) $(CODE_CXXFLAGS) $(STATIC_CXXCFLAGS) $(OP_SYS_CXXFLAGS)

LDFLAGS = $(OPT_LDFLAGS) $(TARGET_LDFLAGS) $(USR_LDFLAGS) $(PROD_LDFLAGS)\
 $(ARCH_DEP_LDFLAGS) $(STATIC_LDFLAGS) $(OP_SYS_LDFLAGS) $(CROSS_LDFLAGS)

LDLIBS = $(PROD_LDLIBS) $(STATIC_LDLIBS)\
 $(POSIX_LDLIBS) $(ARCH_DEP_LDLIBS) $(OP_SYS_LDLIBS)

CPPFLAGS += $(CONFORM_CPPFLAGS) $(CROSS_CPPFLAGS) $(POSIX_CPPFLAGS)\
 $(BASE_CPPFLAGS) $(TARGET_CPPFLAGS) $(USR_CPPFLAGS) $(ARCH_DEP_CPPFLAGS)\
 $(OP_SYS_CPPFLAGS) $(OP_SYS_INCLUDE_CPPFLAGS) $(CODE_CPPFLAGS)

#--------------------------------------------------
# ar definition default
ARFLAGS =
ARCMD = $(AR) $(ARFLAGS) $(USR_ARFLAGS) $@  $(LIBRARY_LD_OBJS)

#--------------------------------------------------
# ld default
LDCMD = $(LD) -o $@ $^

#--------------------------------------------------
# Build compile line here

COMPILE.c = $(CC) -c $(CPPFLAGS) $(CFLAGS) $(INCLUDES) $(SOURCE_FLAG)
COMPILE.cpp = $(CCC) -c $(CPPFLAGS) $(CXXFLAGS) $(INCLUDES) $(SOURCE_CXXFLAG)

#--------------------------------------------------
# Build depends command here

HOST_HDEPENDS_CMD = MKMF
CROSS_HDEPENDS_CMD = MKMF

HDEPENDS_CMD = $($(BUILD_CLASS)_HDEPENDS_CMD)

HDEPENDS.c_CMPLR = $(CC)
HDEPENDS.cpp_CMPLR = $(CCC)
HDEPENDSFLAGS_CMPLR += $(CPPFLAGS) $(INCLUDES) $< > $*$(DEP)

HDEPENDS.c_MKMF =  $(PERL) $(TOOLS)/mkmf.pl
HDEPENDS.cpp_MKMF = $(PERL) $(TOOLS)/mkmf.pl
HDEPENDSFLAGS_MKMF = -m $*$(DEP) $(HDEPENDS_INCLUDES_MKMF) $@ $<
HDEPENDS_INCLUDES_MKMF = $(filter .%,$(subst -I,,$(INCLUDES)))

HDEPENDS.c = $(HDEPENDS.c_$(HDEPENDS_CMD))
HDEPENDS.cpp = $(HDEPENDS.cpp_$(HDEPENDS_CMD))
HDEPENDSFLAGS = $(HDEPENDSFLAGS_$(HDEPENDS_CMD))
HDEPENDS_FLAGS = $(HDEPENDS_FLAGS_$(HDEPENDS_CMD))
HDEPENDS_CMD.c   = -$(HDEPENDS.c) $(HDEPENDS_FLAGS) $(HDEPENDSFLAGS)
HDEPENDS_CMD.cpp = -$(HDEPENDS.cpp) $(HDEPENDS_FLAGS) $(HDEPENDSFLAGS)
HDEPENDS_TARGETS_CMD = $(PERL) $(TOOLS)/makeDependsTargets.pl $*$(DEP)

#--------------------------------------------------
# depends definition

TARGET_SRCS = $(foreach name, $(TESTPROD) $(PROD) $(LIBRARY), $($(name)_SRCS))
SRC_FILES =  $(LIB_SRCS) $(LIBSRCS) $(SRCS) $(PROD_SRCS) $(TARGET_SRCS)
HDEPENDS_FILES = $(addsuffix $(DEP),$(notdir $(basename $(SRC_FILES))))

#---------------------------------------------------------------
# Names of installed items
#
#	each list starts with the destination directory name(s)
#	to make sure it's there

INSTALL_PROD= $(PRODNAME:%= $(INSTALL_BIN)/%)
INSTALL_LIBS= $(LIBNAME:%=$(INSTALL_LIB)/%)
INSTALL_MUNCHS= $(MUNCHNAME:%=$(INSTALL_BIN)/%)
INSTALL_SHRLIBS= $(SHRLIBNAME:%=$(INSTALL_SHRLIB)/%)
INSTALL_DLL_LINK_LIBS=$(DLL_LINK_LIBNAME:%=$(INSTALL_LIB)/%)
INSTALL_TCLLIBS=$(TCLLIBNAME:%=$(INSTALL_TCLLIB)/%)
INSTALL_TCLINDEX=$(TCLINDEX:%=$(INSTALL_TCLLIB)/%)
INSTALL_SCRIPTS = $(SCRIPTS:%= $(INSTALL_BIN)/%)
INSTALL_OBJS = $(OBJSNAME:%= $(INSTALL_BIN)/%)

INSTALL_DOCS = $(DOCS:%= $(INSTALL_DOC)/%)
INSTALL_HTMLS = $(HTMLS:%= $(INSTALL_HTML)/$(HTMLS_DIR)/%)

INSTALL_TEMPLATE = $(addprefix $(INSTALL_TEMPLATES_SUBDIR)/, \
                   $(subst $(CONFIG),top/configure,$(TEMPLATES)))
INSTALL_CONFIGS = $(CONFIGS:%= $(INSTALL_CONFIG)/%)

#---------------------------------------------------------------
#
# auto determine the directory paths that things are installed to
# RULES:
# 1) found in any one of several os specific area
#       => install to $(INSTALL_INCLUDE)/os/$(OS_CLASS)
# 2) not foundin (1) and found in generic area
#       => install to $(INSTALL_INCLUDE)
# 3) not found in (1) or (2) then may be (not yet) computer generated
#       => install into $(INSTALL_INCLUDE)/os/$(OS_CLASS) and let
#       build rules work on vpath
#
# These rules guarantee that the users include from
# no more than two directories
#
INSTALL_INC += $(foreach inc, $(INC), \
    $(firstword \
        $(OS_INSTALL_INC) \
        $(GENERIC_INSTALL_INC) \
        $(GENERATED_INSTALL_INC) ) )

#
# Rule 1
#
OS_INSTALL_INC = $(addprefix $(INSTALL_INCLUDE)/os/$(OS_CLASS)/, $(INSTALL_INC_ggg) )
INSTALL_INC_ggg = $(foreach dir, $(OS_SRC_DIRS), $(INSTALL_INC_fff)  )
INSTALL_INC_fff = $(subst $(dir)/, , $(INSTALL_INC_eee) )
INSTALL_INC_eee = $(wildcard $(addsuffix /$(inc), $(dir)) )

#
# Rule 2
#
GENERIC_INSTALL_INC = $(addprefix $(INSTALL_INCLUDE)/, $(INSTALL_INC_ccc) )
INSTALL_INC_ccc = $(foreach dir, .. $(SRC_DIRS), $(INSTALL_INC_bbb)  )
INSTALL_INC_bbb = $(subst $(dir)/, , $(INSTALL_INC_aaa) )
INSTALL_INC_aaa = $(wildcard $(addsuffix /$(inc), $(dir)) )

#
# Rule 3
#
GENERATED_INSTALL_INC = $(INSTALL_INCLUDE)/$(inc)

COMMON_INC += $(filter $(COMMON_DIR)/%, $(foreach file, $(INC), \
    $(firstword  $(SOURCE_INC) $(COMMON_DIR)/$(file) ) ) )
SOURCE_INC = $(wildcard $(file) $(SOURCE_INC_bbb) )
SOURCE_INC_bbb = $(foreach dir, $(ALL_SRC_DIRS), $(SOURCE_INC_aaa)  )
SOURCE_INC_aaa = $(addsuffix /$(file), $(dir) )

endif