Makefile.include

# global optimisation options
GCC_OPT_OPT = -finline-limit=1200 -ffast-math -W -Wall -Wextra -O3 -fomit-frame-pointer -fPIC

# GCC 3.3 optimisation options that are not included in -O3
GCC_33_OPT = -ftracer -fgcse-sm
# GCC 3.4 optimisation options that are not included in -O3
GCC_34_OPT = $(GCC_33_OPT) -fgcse-las -fpeel-loops
# GCC 4.0 optimisation options that are not included in -O3
GCC_40_OPT = $(GCC_34_OPT) -fmodulo-sched -ftree-loop-linear -ftree-loop-im -fweb\
 -ftree-loop-ivcanon -fivopts -ftree-vectorize -fvariable-expansion-in-unroller
# GCC 4.1 optimisation options that are not included in -O3
GCC_41_OPT = $(GCC_40_OPT) -funsafe-loop-optimizations
# GCC 4.2 optimisation options that are not included in -O3
GCC_42_OPT = $(GCC_41_OPT)
# GCC 4.3 optimisation options that are not included in -O3
GCC_43_OPT = $(GCC_42_OPT) -fmodulo-sched-allow-regmoves -fipa-cp -fvect-cost-model
# GCC 4.4 optimisation options that are not included in -O3
GCC_44_OPT = $(GCC_43_OPT)

# define architecture; it will affect file extentions, dynamic flags.
# now LINUX, WINDOWS(untested), MACOSX are supported
OS = LINUX

# ALL_DEF is an external defines
GENERAL_DEFINES = $(GCC_OPT_OPT) $(GCC_42_OPT) $(ALL_DEF)

#---------------------------------------------------------
# please do not change following lines
#---------------------------------------------------------

# Set default goal immediatly, to make it possible to define rules
default_goal: all

ifdef INTERNAL_LIBRARY
override LIBRARY := $(INTERNAL_LIBRARY)
endif

# tune some parameters depends on OS

EXEEXT =
LIBEXT =
DLLEXT =
OS_DEF =

# define Linux flags

ifeq ($(OS),LINUX)
override EXEEXT :=
override LIBEXT := .a
override DLLEXT := .so
override OS_DEF :=
endif

#define Mc OS X flags
ifeq ($(OS),MACOSX)
override EXEEXT :=
override LIBEXT := .a
override DLLEXT := .jnilib
override OS_DEF := -mmacosx-version-min=10.4
endif

#define Windows flags (untested)
ifeq ($(OS),WINDOWS)
override EXEEXT := .exe
override LIBEXT := .lib
override DLLEXT := .dll
override OS_DEF :=
endif

# System variables definitions should be expanded immidiately,
# either user defines those or not
# (The following lines are written because of their ':=' operator)
# We can't set default values here: WIs' rules.cvslvk may use +=

override INCLUDES := $(INCLUDES)
override DEFINES := $(DEFINES) $(GENERAL_DEFINES)
override LDFLAGS := $(LDFLAGS)

override BUILD_DIR := obj

$(BUILD_DIR):
	mkdir -p $(BUILD_DIR)

# Set C++ compilers and linker

override CXX := g++$(GCC_SUFFIX) $(OS_DEF)

# Library building tools

ifdef LIBRARY

# If LTYPE is 'shared', gcc -shared is used
# $(LIBRARY) is library name.

ifeq ($(LTYPE),shared)
override LIBRARY_NAME := lib$(LIBRARY)$(DLLEXT)
endif

ifeq ($(LTYPE),static)
override LIBRARY_NAME := lib$(LIBRARY)$(LIBEXT)
endif

endif  # ifdef LIBRARY

# Split LDFLAGS into -L..., -l... and others
override CL_LDFLAGS_DIRS := $(filter -L%,$(LDFLAGS))
override CL_LDFLAGS_LIBS := $(filter -l%,$(LDFLAGS))
override CL_LDFLAGS_OTHER := $(filter-out $(CL_LDFLAGS_DIRS) $(CL_LDFLAGS_LIBS),$(LDFLAGS))

# Internal library variables
#
# Executable may use some internal libraries (libraries from the same module).
# The subdirs should be in USE_IL variable
# Current restrictions:
#   each library should be in a subdir;
#   subdir name and library name should be the same 
# The subdirs of the used internal libraries should be in CL_USE_IL variable
# When internal libraries are used, executable is linked separately during build
# and during installation.
# During build, rpaths to the build directories of the shared libraries are
# set, and during install - rpaths for the install directory is set

ifneq ($(USE_IL),)

# includes may be just added to $(INCLUDES)
override INCLUDES += $(USE_IL:%=-I%)
# -l flags also may be just added to $(CL_LDFLAGS_LIBS)
override CL_LDFLAGS_LIBS += $(patsubst %,-l%,$(notdir $(USE_IL)))
# -L flags can't be just added because of rpath logic, so we use $(CL_LDFLAGS_OTHER)
override CL_IL_DIRS := $(USE_IL:%=-L%)
endif

#update LD_FLAGS wrt DEFINES

ifneq ($(filter -g,$(DEFINES)),)
override CL_LDFLAGS_OTHER += -g
else
override CL_LDFLAGS_OTHER += -s
endif
ifneq ($(filter -m64,$(DEFINES)),)
override CL_LDFLAGS_OTHER += -m64
endif
ifneq ($(filter -m32,$(DEFINES)),)
override CL_LDFLAGS_OTHER += -m32
endif
ifneq ($(filter -pg,$(DEFINES)),)
override CL_LDFLAGS_OTHER += -pg
endif
ifneq ($(filter -fprofile-generate,$(DEFINES)),)
override CL_LDFLAGS_OTHER += -fprofile-generate
endif

# Compute the final LDFLAGS
override LDFLAGS := $(CL_IL_DIRS) $(CL_LDFLAGS_DIRS) $(CL_LDFLAGS_LIBS) $(CL_LDFLAGS_OTHER)

# Add $(INCLUDES) and $(DEFINES) to $(CXXFLAGS)
override CXXFLAGS += $(INCLUDES) $(DEFINES)

# make object files based on sources
override OBJECTS := $(addprefix $(BUILD_DIR)/,$(addsuffix .o,$(basename $(notdir $(SOURCES)))))

# Rules for building object files

override CXX_COMPILE_COMMAND = $(CXX) -c $(CXXFLAGS) -o $@ $<

$(BUILD_DIR)/%.o: %.cpp
	$(CXX_COMPILE_COMMAND)

# Make things like "make file.o" work
%: $(BUILD_DIR)/%

ifdef SUBDIRS
all_subdirs clean_subdirs dep_subdirs:
	for dir in $(SUBDIRS); do \
	  (cd $$dir && $(MAKE) `echo $@ | cut -d_ -f1`) || exit 1; \
	done
ifeq ($(EXECUTABLE)$(LIBRARY),)
all: all_subdirs
endif
else # No SUBDIRS
all_subdirs clean_subdirs dep_subdirs:
endif # SUBDIRS

# defining "dep" rule

ifeq ($(EXECUTABLE)$(LIBRARY),)
dep: dep_subdirs
else
dep: dep_subdirs .deps

#create .deps file that contains dependencies for all *.c[pp] files
.deps: $(SOURCES)
	rm -f .deps
	touch .deps
	for file in $(SOURCES); do \
		$(CXX) $(CXXFLAGS) -MM $$file > .deps.tmp ; \
		sed '1 s/^\(.*\)/$(BUILD_DIR)\/\1/' .deps.tmp > .deps.tmp2 ; \
		cat .deps.tmp2 >> .deps ; \
		echo >> .deps ; \
	done
	rm -f .deps.tmp .deps.tmp2

# use this file to remember dependencies
include .deps

# now make libs/executables dependant on the libs they uses

# here we have all libraries of which current goal depends
override LIB_DEPS := $(filter -l%, $(LDFLAGS))

# make sure that goals for those libraries that are NOT from the project still exists
ifneq ($(LIB_DEPS),)
$(LIB_DEPS) :
endif

endif # deps for non-empty dirs

# main rule

ifdef EXECUTABLE

all: all_subdirs $(EXECUTABLE)

$(EXECUTABLE): $(BUILD_DIR) $(BUILD_DIR)/$(EXECUTABLE)
	rm -f $(EXECUTABLE) && ln -s $(BUILD_DIR)/$(EXECUTABLE) $(EXECUTABLE)

$(BUILD_DIR)/$(EXECUTABLE): $(OBJECTS) $(LIB_DEPS)
	$(CXX) $(OBJECTS) $(LDFLAGS) -o $@

endif # EXECUTABLE


ifdef LIBRARY

all: all_subdirs $(LIBRARY_NAME)

$(LIBRARY_NAME): $(BUILD_DIR) $(BUILD_DIR)/$(LIBRARY_NAME)
	rm -f $@ && ln -s $(BUILD_DIR)/$@ .

# define shared flags
SHARED_FLAGS =
ifeq ($(OS),LINUX)
override SHARED_FLAGS := -shared -Wl,-h,$(LIBRARY_NAME)
endif
ifeq ($(OS),MACOSX)
override SHARED_FLAGS := -dynamiclib
endif
ifeq ($(OS),WINDOWS)
override SHARED_FLAGS := 
endif

ifeq ($(LTYPE),shared)
$(BUILD_DIR)/$(LIBRARY_NAME): $(OBJECTS) $(LIB_DEPS)
	$(CXX) $(SHARED_FLAGS) -o $@ $(OBJECTS) $(LDFLAGS)
endif

ifeq ($(LTYPE),static)
$(BUILD_DIR)/$(LIBRARY_NAME): $(OBJECTS)
	ar cr $@ $(OBJECTS)
	ranlib $(BUILD_DIR)/$(LIBRARY_NAME)
endif


endif

# The generic "clean" rule

clean: clean_subdirs
	rm -rf $(BUILD_DIR) $(LIBRARY_NAME) $(EXECUTABLE) .deps