# Kamailio build system

#
# makefile defs (CC, LD,a.s.o)
#
# Environment variables:
#   PREFIX, LOCALBASE, BASEDIR
#   INSTALL, TAR , CC, LEX, YACC,
#   CPUTYPE, CC_EXTRA_OPTS, LD_EXTRA_OPTS
#   exclude_modules, skip_modules, include_modules
#   extra_defs
#

# default silent, unless Q= 0|no|off|verbose|noisy
quiet?=$(if $(filter 0 no off verbose noisy,$(Q)),verbose,silent)

# check if already included/exported

# used for sanity checks for Makefile.defs inclusion (!= makefile_defs which
# specifies if we have a set of valid defs)
override makefile_defs_included:=1
ifeq ($(makefile_defs),1)
ifeq ($(quiet),verbose)
$(info Makefile.defs defs skipped)
endif # verbose

else

ifeq (,$(main_makefile))
# hack to automatically use config.mak in all the modules, without 
# changing the current module makefiles (which all include Makefile.defs):
# if not called from the main makefile (module, lib or ut):
# include config.mak, but if not present or incomplete (makefile_defs!=1)
# don't export the vars)
COREPATH?= ../..
include $(COREPATH)/config.mak
ifeq ($(quiet),verbose)
$(info config.mak included)
endif # verbose
# config.mak should set makefile_defs if complete
export makefile_defs

else
override makefile_defs=1
export makefile_defs


ifeq ($(quiet),verbose)
$(info normal Makefile.defs exec)
endif # verbose

-include Makefile.vars

# usage: $(call set_if_empty,VAR,value)
set_if_empty=$(if $($(1)),,$(eval override $(1)=$(2)))

# flavour: sip-router, ser or kamailio
$(call	set_if_empty,FLAVOUR,kamailio)

#prefix for various configs and scripts
#config name/name-prefix for distributed configs
CFG_NAME?=sip-router
#config name/name-prefix for distributed scripts
SCR_NAME=sip-router
#name in source tree
SRC_NAME=sip-router

ifeq ($(FLAVOUR),sip-router)
# main binary name
MAIN_NAME=ser
else ifeq ($(FLAVOUR),ser)
# main binary name
MAIN_NAME=ser
else ifeq ($(FLAVOUR),kamailio)
# main binary name
MAIN_NAME=kamailio
# use kamailio config
CFG_NAME=kamailio
# kamailio statistics on
KMSTATS ?= 1
# fast malloc statistics on
FMSTATS ?= 1
else # unknown:
# main binary name
MAIN_NAME=kamailio
endif

# application server support on
WITHAS ?= 1
# enable core hooks for SCTP
SCTP ?= 1

# what to install
INSTALL_FLAVOUR=$(FLAVOUR)

# version number
VERSION = 5
PATCHLEVEL = 0
SUBLEVEL =  0
EXTRAVERSION = -dev3

# memory manager switcher
# 0 - f_malloc (fast malloc)
# 1 - q_malloc (quick malloc)
# 2 - tlsf_malloc (O(1) malloc and free)
MEMMNG ?= 0
# memory debugger switcher
# 0 - off (no-debug mode)
# 1 - on (debug mode)
MEMDBG ?= 1

SER_VER = $(shell expr $(VERSION) \* 1000000 + $(PATCHLEVEL) \* 1000 + \
			$(SUBLEVEL) )
RELEASE:=$(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION)
OS := $(shell uname -s | sed -e s/SunOS/solaris/ -e s/CYGWIN.*/cygwin/ \
		 | tr "[A-Z]" "[a-z]" | tr "/" "_")

ifeq ($(OS),solaris)
	GETARCH=isainfo -n
ifeq ($(GETARCH),)
	GETARCH=uname -p
endif
else
	GETARCH=uname -m
endif

HOST_ARCH := $(shell $(GETARCH) |sed -e s/i.86/i386/ -e s/sun4[uv]/sparc64/  \
			-e s/armv[3-5].*/arm/  -e s/armv6.*/arm6/ \
			-e "s/Power Macintosh/ppc/" \
			-e "s/cobalt/mips2/" \
			-e s/amd64/x86_64/ -e s/sparcv9/sparc64/ )
# fix sparc -> sparc64
ifeq ($(HOST_ARCH),sparc)
	ifeq ($(shell uname -m),sun4u)
		HOST_ARCH := sparc64
	endif
	ifeq ($(shell uname -m),sun4v)
		HOST_ARCH := sparc64
	endif
endif

OSREL := $(shell uname -r)
# numerical version (good for comparisons: A.B.C => A*1000000+B*1000+C)
OSREL_N:= $(shell echo $(OSREL) | sed -e 's/^[^0-9]*//' \
		-e 's/^\([0-9][0-9]*\(\.[0-9][0-9]*\)*\).*$$/\1/g' | \
		(IFS=. read A B C D; R=0; \
		[ -n "$$A" ] && R=`expr $$R \* 1000 + $$A` && \
		[ -n "$$B" ] && R=`expr $$R \* 1000 + $$B` && \
		[ -n "$$C" ] && R=`expr $$R \* 1000 + $$C`; echo $$R ) )


# TLS support
CORE_TLS ?= 
# by default compile with tls hooks support (so that no ser recompile is
#  needed before the tls module can be used)
TLS_HOOKS=1
ifeq ($(CORE_TLS), 1)
	RELEASE:=$(RELEASE)-tls
	TLS_HOOKS:=0
endif
ifeq ($(TLS_HOOKS), 1)
#	RELEASE:=$(RELEASE)-tls
endif

# extra CC command line options (e.g  -march=athlon-mp)
CC_EXTRA_OPTS ?=

# extra LD command line options
LD_EXTRA_OPTS ?=

ifeq ($(OS), solaris)
#use GNU versions
INSTALL ?= ginstall
TAR ?= gtar
else
INSTALL ?= install
TAR ?= tar
endif

INSTALL_TOUCH = touch          # used to create the file first (good to 
                               #  make solaris install work)
INSTALL_CFG = $(INSTALL) -m 644
INSTALL_BIN = $(INSTALL) -m 755
INSTALL_SCRIPT = $(INSTALL) -m 755
INSTALL_MODULES = $(INSTALL) -m 755
INSTALL_LIB = $(INSTALL) -m 755
INSTALL_DOC = $(INSTALL) -m 644
INSTALL_MAN = $(INSTALL) -m 644
INSTALL_SHARE = $(INSTALL) -m 644

#set some vars from the environment (and not make builtins)
CC   := $(shell echo "$${CC}")
LEX  := $(shell echo "$${LEX}")
YACC := $(shell echo "$${YACC}")




# find compiler name & version
ifeq ($(CC),)
	CC=gcc
endif
LD= $(CC)
CC_LONGVER:=$(shell if  $(CC) -v 2>/dev/null; then \
						$(CC) -v 2>&1 ;\
					else \
						$(CC) -V 2>&1 ; \
					fi )
CC_OPT ?= -O9
MKTAGS=ctags

#find-out the compiler's name

ifneq (,$(findstring gcc, $(CC_LONGVER)))
	CC_NAME=gcc
	RPAREN=)
	CC_VER:=$(word 1,$(CC)) $(shell $(CC) - --version|head -n 1|\
				sed  -e 's/([^$(RPAREN)]*)//g' \
					 -e 's/^.*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/\1/'\
					 -e 's/^[^0-9].*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/')
#	CC_VER:=$(word 1,$(CC)) $(shell $(CC) - --version|head -n 1|cut -d" " -f 3\
#				|sed -e 's/^.*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/\1/'\
#				 	 -e 's/^[^0-9].*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/')
	# sed with POSIX.1 regex doesn't support |, + or ? 
        # (darwin, solaris ...) => this complicated expression
	MKDEP=$(CC) -MM -MG
	#transform gcc version into 2.9x or 3.0
	CC_SHORTVER:=$(shell echo "$(CC_VER)" | cut -d" " -f 2| \
				 sed -e 's/[^0-9]*-\(.*\)/\1/'| \
				 sed -e 's/2\.9.*/2.9x/' \
					-e 's/3\.[0-3]\..*/3.0/' \
					-e 's/3\.[0-3]/3.0/' \
					-e 's/3\.[4-9]\..*/3.4/' \
					-e 's/3\.[4-9]/3.4/' \
					-e 's/4\.[0-1]\..*/4.x/' \
					-e 's/4\.[0-1]/4.x/' \
					-e 's/4\.[2-4]\..*/4.2+/' \
					-e 's/4\.[2-4]$$/4.2+/' \
					-e 's/4\.[5-9]\..*/4.5+/' \
					-e 's/4\.[5-9]$$/4.5+/' \
					-e 's/5\.[0-9]\..*/5.0+/' \
					-e 's/5\.[0-9]$$/5.0+/')
ifeq (,$(strip $(filter-out 3.0 3.4 4.x 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
	# dependencies can be generated on-the-fly while compiling *.c
	CC_MKDEP_OPTS=-MMD -MP
endif # 3.0 <= $(CC_SHORTVER) <= 4.x
endif # gcc

ifneq (, $(findstring Sun, $(CC_LONGVER)))
	CC_NAME=suncc
	CC_SHORTVER:=$(shell echo "$(CC_LONGVER)"|head -n 1| \
					sed -e 's/.*\([0-9]\.[0-9]\).*/\1/g' )
	CC_VER=$(CC) $(CC_SHORTVER)
	MKDEP=$(CC) -xM1 
endif

ifneq (, $(findstring Intel(R) C++ Compiler, $(CC_LONGVER)))
	# very nice: gcc compatible
	CC_NAME=icc
	CC_FULLVER:=$(shell echo "$(CC_LONGVER)"|head -n 1| \
					sed -e 's/.*Version \([0-9]\.[0-9]\.[0-9]*\).*/\1/g' )
	CC_SHORTVER:=$(shell echo "$(CC_FULLVER)" | cut -d. -f1,2 )
	CC_VER=$(CC) $(CC_FULLVER)
	MKDEP=$(CC) -MM 
endif

ifneq (, $(findstring clang, $(CC_LONGVER)))
	#clang should be gcc compatible
	CC_NAME=clang
	CC_FULLVER:=$(shell echo "$(CC_LONGVER)" | head -n 1 |  sed -e 's/.*version \([0-9]\.[0-9]\).*/\1/g' )
	CC_SHORTVER:=$(shell echo "$(CC_FULLVER)" | cut -d. -f1,2 )
	CC_VER=$(CC) $(CC_FULLVER)
	CC_OPT=-O3
	MKDEP=$(CC) -MM 
endif

ifeq (,$(CC_NAME))
#not found
	CC_NAME=$(CC)
	CC_SHORTVER=unknown
	CC_VER=unknown
	MKDEP=gcc -MM 
$(warning	Unknown compiler $(CC)\; supported compilers: \
			gcc, sun cc, intel icc )
endif

# ARCH detection
# predefined compiler macros for different architectures
# (see http://predef.sourceforge.net/prearch.html for a more complete list)
i386_macros= i386 __i386__ __i486__ __i586__ __i686__ \
			__i386 _M_IX86 __X86__ _X86_
x86_64_macros= __amd64__ __amd64 __x86_64__ __x86_64 _M_X64

sparc_macros= __sparc__ __sparc __sparcv8
sparc64_macros= __sparcv9 __sparc_v9__

arm_macros= __arm__ __thumb__
arm6_macros= __ARM_ARCH_6__

ppc_macros= __powerpc __powerpc__ __POWERPC__ __ppc__ _ARCH_PPC
ppc64_macros= __ppc64__ _ARCH_PPC64

mips_macros= __mips__ __mips _MIPS_ARCH_MIPS1
mips2_macros= _MIPS_ISA_MIPS2 _MIPS_ISA_MIPS3 _MIPS_ISA_MIPS4 \
			_MIPS_ARCH_MIPS2 _MIPS_ARCH_MIPS3 _MIPS_ARCH_MIPS4
mips64_macros= _MIPS_ISA_MIPS64 _MIPS_ARCH_MIPS64

alpha_macros= __alpha__ __alpha _M_ALPHA_

ifeq ($(CC_NAME),gcc)
#if gcc use gcc arch
predef_macros:=$(shell $(CC) -dM -E -x c $(CC_EXTRA_OPTS) $(extra_defs) \
					$(CFLAGS) /dev/null)

ifneq ($(strip $(filter $(i386_macros), $(predef_macros))),)
CC_ARCH=i386
else ifneq ($(strip $(filter $(x86_64_macros), $(predef_macros))),)
CC_ARCH=x86_64
else ifneq ($(strip $(filter $(sparc_macros), $(predef_macros))),)

ifneq ($(strip $(filter $(sparc64_macros), $(predef_macros))),)
CC_ARCH=sparc64
else # sparc64_macros
CC_ARCH=sparc
endif # sparc64_macros

else ifneq ($(strip $(filter $(arm_macros), $(predef_macros))),)

ifneq ($(strip $(filter $(arm6_macros), $(predef_macros))),)
CC_ARCH=arm6
else # arm6_macros
CC_ARCH=arm
endif # arm6_macros

else ifneq ($(strip $(filter $(ppc64_macros), $(predef_macros))),)
CC_ARCH=ppc64
else ifneq ($(strip $(filter $(ppc_macros), $(predef_macros))),)
CC_ARCH=ppc
else ifneq ($(strip $(filter $(mips_macros), $(predef_macros))),)

ifneq ($(strip $(filter $(mips64_macros), $(predef_macros))),)
CC_ARCH=mips64
else ifneq ($(strip $(filter $(mips2_macros), $(predef_macros))),)
CC_ARCH=mips2
else # mips2_macros
CC_ARCH=mips
endif # mips64_macros

else ifneq ($(strip $(filter $(alpha_macros), $(predef_macros))),)
CC_ARCH=alpha
else

$(warn "Unknown target compiler architecture")

endif # predefined macros tests (x86_macros, ...)

endif # gcc

ifdef CC_ARCH
ARCH:=$(CC_ARCH)
else
ARCH:=$(HOST_ARCH)
endif
$(info target architecture <$(ARCH)>, host architecture <$(HOST_ARCH)>)

LIBDIR ?=
ifeq ($(LIBDIR),)
ARCHBSZ= $(shell echo $(ARCH) | sed -e 's/.*64.*/64b/')
ifeq ($(ARCHBSZ),64b)
	LIBDIR = lib64
else
	LIBDIR = lib
endif
endif

# dirs
cfg_dir = etc/$(MAIN_NAME)/
bin_dir = sbin/
share_dir = share/$(MAIN_NAME)/
# lib/$(MAIN_NAME)/modules , lib/$(MAIN_NAME)/modules-s, lib/$(MAIN_NAME)/modules-k
modules_dir = $(LIBDIR)/$(MAIN_NAME)/
lib_dir = $(LIBDIR)/$(MAIN_NAME)/
run_dir = var/run/$(MAIN_NAME)/
doc_dir = doc/$(MAIN_NAME)/
man_dir = man/
data_dir = $(MAIN_NAME)/

ifeq ($(OS), linux)
	doc_dir = share/doc/$(MAIN_NAME)/
	man_dir = share/man/
	data_dir = share/$(MAIN_NAME)/
	LOCALBASE ?= /usr/local
endif

ifeq ($(OS), gnu_kfreebsd)
	doc_dir = share/doc/$(MAIN_NAME)/
	man_dir = share/man/
	data_dir = share/$(MAIN_NAME)/
	LOCALBASE ?= /usr/local
endif

ifeq ($(OS), freebsd)
	doc_dir = share/doc/$(MAIN_NAME)/
	man_dir = man/
	data_dir = share/$(MAIN_NAME)/
	LOCALBASE ?= /usr/local
endif

ifeq ($(OS), openbsd)
	doc_dir = share/doc/$(MAIN_NAME)/
	man_dir = man/
	data_dir = share/$(MAIN_NAME)/
	LOCALBASE ?= /usr/local
endif

ifeq ($(OS), netbsd)
	doc_dir = share/doc/$(MAIN_NAME)/
	man_dir = man/
	data_dir = share/$(MAIN_NAME)/
	LOCALBASE ?= /usr/pkg
endif

ifeq ($(OS), dragonfly)
	doc_dir = share/doc/$(MAIN_NAME)/
	man_dir = man/
	data_dir = share/$(MAIN_NAME)/
	LOCALBASE ?= /usr/pkg
endif

ifeq ($(OS), darwin)
	doc_dir = share/doc/$(MAIN_NAME)/
	man_dir = man/
	data_dir = share/$(MAIN_NAME)/
	LOCALBASE ?= /usr/local
endif

LOCALBASE ?= /usr/local

# Doxygen directory
doxygen_dir=doc/doxygen

BASEDIR ?= $(DESTDIR)
basedir = $(BASEDIR)
RUNBASEDIR ?= $(DESTDIR)
runbasedir = $(RUNBASEDIR)

# install location
PREFIX ?= $(LOCALBASE)
prefix = $(PREFIX)
# install path is $(basedir) $(prefix)
# example:
#  creating a bin. archive in /tmp, which unpacks in /usr/local
#  basedir=/tmp
#  prefix=/usr/local

# install prefixes for various stuff
cfg_prefix = $(basedir)$(prefix)
bin_prefix = $(basedir)$(prefix)
modules_prefix = $(basedir)$(prefix)
lib_prefix = $(basedir)$(prefix)
run_prefix = $(runbasedir)
doc_prefix = $(basedir)$(prefix)
man_prefix = $(basedir)$(prefix)
ut_prefix = $(basedir)$(prefix)
share_prefix = $(basedir)$(prefix)
data_prefix = $(basedir)$(prefix)


# target dirs for various stuff
cfg_target = $(prefix)/$(cfg_dir)
bin_target = $(prefix)/$(bin_dir)
#modules_target = $(prefix)/$(modules_dir)
lib_target = $(prefix)/$(lib_dir)
run_target = $(run_prefix)/$(run_dir)
doc_target = $(prefix)/$(doc_dir)
data_target = $(prefix)/$(data_dir)


# compile-time options
#
# -DSTATS
#		allows to print out number of packets processed on CTRL-C;
# 		implementation still nasty and reports per-process
# -DNO_DEBUG
#		turns off some of the debug messages (DBG(...)).
# -DNO_LOG
#		completely turns of all the logging (and DBG(...))
# -DEXTRA_DEBUG
#		compiles in some extra debugging code
# -DDNS_IP_HACK
#		faster ip address resolver for ip strings (e.g "127.0.0.1")
# -DSHM_MEM
#		compiles in shared mem. support, needed by some modules and
#		by USE_SHM_MEM
# -DSHM_MMAP
#		use mmap instead of SYSV shared memory
# -DPKG_MALLOC
#		uses a faster malloc (exclusive w/ USE_SHM_MEM)
# -DUSE_SHM_MEM
#		all pkg_malloc => shm_malloc (most mallocs use a common sh.
#		mem. segment); don't define PKG_MALLOC if you want this!
# -DDBG_QM_MALLOC
#		qm_malloc debug code, will cause pkg_malloc and shm_malloc
#		to keep and display lot of debuging information: file name,
#		function, line number of malloc/free call for each block,
#		extra error checking (trying to free the same pointer
#		twice, trying to free a pointer alloc'ed with a different
#		malloc etc.)
# -DVQ_MALLOC
#		additional option to PKG_MALLOC which utilizes a fater then
#		qm version
#		(not true anymore, q_malloc performs approx. the same)
# -DQ_MALLOC
#		custom quick malloc, recommended for debugging
# -DF_MALLOC
#		an even faster malloc, not recommended for debugging
# -DTLSF_MALLOC
#       an implemetation of the "two levels segregated fit" malloc algorithm
# -DDL_MALLOC
#		a malloc implementation based on Doug Lea's dl_malloc
# -DSF_MALLOC 
#		an experimental multi-CPU, pool based, multi-process safe version of 
#		F_MALLOC. Should give better performance on machines with lots of CPUs
#		after some tunning.
# -DLL_MALLOC
#		an experimental multi-CPU, pool based, multi-process safe, mostly
#		lockless version of SF_MALLOC/F_MALLOC. Not for production use for
#		now.
# -DDBG_MALLOC
#		issues additional debugging information if lock/unlock is called
# -DMEM_JOIN_FREE
#		enable the join of free memory chunks (see also mem_join cfg param)
# -DFAST_LOCK
#		uses fast arhitecture specific locking (see the arh. specific section)
# -DUSE_SYSV_SEM
#		uses sys v sems for locking (slower & limited number)
# -DUSE_PTHREAD_MUTEX
#		uses pthread mutexes, faster than sys v or posix sems, but do not 
#		work on all systems inter-processes (e.g. linux)
# -DUSE_POSIX_SEM
#		uses posix semaphores for locking (faster than sys v)
# -DUSE_FUTEX
#		uses futexes for locking (linux 2.6+)
# -DBUSY_WAIT
#		uses busy waiting on the lock (FAST_LOCK)
# -DADAPTIVE_WAIT
#		try busy waiting for a while and if the lock is still held go to
#		force reschedule (FAST_LOCK)
# -DADAPTIVE_WAIT_LOOPS=number
#		number of loops we busy wait, after "number" loops have elapsed we 
#		force a reschedule (FAST_LOCK)
# -DNOSMP
#		don't use smp compliant locking (faster but won't work on SMP machines)
#		(not yet enabled) (FAST_LOCK)
# -DNO_PINGTEL_TAG_HACK
#		if enabled, To-header-field will be less liberal and will not accept
#		'tag=' (tag parameter with equal sign and without value); it is called
#		this way because such message was sighted from a Pingtel phone
# -DUSE_TCP
#		compiles in tcp support
# -DDISABLE_NAGLE
#		disable the tcp Nagle algorithm (lower delay)
# -DUSE_TLS
#		compiles in tls support, requires -DUSE_TCP. Note: this is only 
#		generic support (parsing a.s.o.), it does not include the actual
#		"tls engine". If you really want tls you need also either
#		-DCORE_TLS and a tls/ subdir with the tls code or -DTLS_HOOKS and
#		the tls module loaded.
# -DCORE_TLS
#		compiles tls in-core support. Requires -DUSE_TLS, conflicts 
#		-DTLS_HOOKS. Please use make CORE_TLS=1 instead  (it will set all the
#		needed defines automatically and extra libraries needed for linking).
# -DTLS_HOOKS
#		compile tls module support (support for having the "tls engine" in a
#		module). Requires -DUSE_TLS, conflicts -DCORE_TLS.
#		Please use make TLS_HOOKS=1 (or TLS_HOOKS=0 to for disabling) instead
#		of setting -DTLS_HOOKS (it will set all the needed defines 
#		automatically)
# -DHAVE_RESOLV_RES
#		support for changing some of the resolver parameters present
#		 (_res structure in <resolv.h>)
# -DUSE_COMP
#		compiles in comp=[sergz|sigcomp] support (parsing uri & via, 
#		adding it to via, lumps a.s.o). WARNING: right now this option
#		is useless since the compression code doesn't exist yet.
# -DHONOR_MADDR
#		compiles in checks and use for maddr parameter in uri.
#		Required to support Windows Messenger 5.x over TCP connection
#		which (mis)uses this parameter.
# -DUSE_DNS_CACHE
#		use an internal dns cache instead of making dns requests each time
# -DUSE_DNS_CACHE_STATS
#		turns on DNS cache measurements
# -DUSE_DNS_FAILOVER
#		if the destination resolves to multiple ips, on send error fall back
#		to the others
# -DUSE_DST_BLACKLIST
#		blacklist bad destination (timeout, failed to connect, error sending
#        a.s.o)
# -DUSE_DST_BLACKLIST_STATS
#		turns on blacklist bad destination measurements
# -DPROFILING
#		if enabled profiling will be enabled for child processes
#		Don't forget to set PROFILE (see below)
# -DNO_SIG_DEBUG
#        turns off debugging messages in signal handlers (which might be 
#         unsafe)
# -DUSE_NAPTR
#		 turns on naptr support (but must be also enabled from the config)
# -DDNS_WATCHDOG_SUPPORT
#		turns on DNS watchdog support which can be used to inform the
#		core that the DNS servers are down. No DNS query is performed
#		when the servers are unreachable, and even expired resource
#		records are used from the cache. (requires external watchdog)
# -DWITH_AS_SUPPORT
#		adds support for Application Server interface
# Sometimes is needes correct non-quoted $OS. HACK: gcc translates known OS to number ('linux'), so there is added underscore

ifeq ($(OS), dragonfly)
	# Tell it that dragonflybsd is equivalent to compiling for freebsd, but
	# define also __OS_dragonfly (for fine-tunning like kqueue support).
	os_defs := -D__OS_freebsd -D__OS_dragonfly
	EQUIV_OS = freebsd
else
	os_defs := -D__OS_$(OS)
	EQUIV_OS = $(OS)
endif

C_DEFS= $(extra_defs) \
	 -DNAME='"$(MAIN_NAME)"' -DVERSION='"$(RELEASE)"' -DARCH='"$(ARCH)"' \
	 -DOS='$(OS)_' -DOS_QUOTED='"$(OS)"' -DCOMPILER='"$(CC_VER)"'\
	 -D__CPU_$(ARCH) $(os_defs) \
	 -DSER_VER=$(SER_VER) \
	 -DCFG_DIR='"$(cfg_target)"'\
	 -DRUN_DIR='"$(run_target)"'\
	 -DPKG_MALLOC \
	 -DSHM_MEM  -DSHM_MMAP \
	 -DDNS_IP_HACK \
	 -DUSE_MCAST \
	 -DUSE_TCP \
	 -DDISABLE_NAGLE \
	 -DHAVE_RESOLV_RES \
	 -DUSE_DNS_CACHE \
	 -DUSE_DNS_FAILOVER \
	 -DUSE_DST_BLACKLIST \
	 -DUSE_NAPTR \
	 -DWITH_XAVP \
	 #-DUSE_DNS_CACHE_STATS \
	 #-DUSE_DST_BLACKLIST_STATS \
	 #-DDNS_WATCHDOG_SUPPORT \
	 #-DLL_MALLOC \
	 #-DSF_MALLOC \
	 #-DDL_MALLOC \
	 #-DDBG_F_MALLOC \
	 #-DNO_DEBUG \
	 #-DEXTRA_DEBUG \
	 #-DVQ_MALLOC  \
	 #-DDBG_LOCK \
	 #-DNOSMP \
	 #-DUSE_SHM_MEM \
	 #-DSTATS \
	 #-DNO_LOG \
	 #-DPROFILING \
	 #-DNO_SIG_DEBUG

#PROFILE=  -pg	# set this if you want profiling
				# you may also want to set -DPROFILING

# WARNING: do not add mode=debug or mode=release anymore in the Makefile,
# use make mode=debug all instead. Anyway no by default ser is  compiled w/ 
# debugging symbols in all cases (-g). --andrei

# memory managers and related debug mode
C_DEFS+= -DMEM_JOIN_FREE
# enable f_malloc
C_DEFS+= -DF_MALLOC
# enable q_malloc
C_DEFS+= -DQ_MALLOC
# enable TLSF malloc
C_DEFS+= -DTLSF_MALLOC
ifeq 	($(MEMDBG), 1)
	C_DEFS+= -DDBG_SR_MEMORY
endif

ifneq ($(PKG_MEM_SIZE),)
	C_DEFS+= -DPKG_MEM_SIZE=$(PKG_MEM_SIZE)
endif
ifeq ($(CORE_TLS), 1)
	C_DEFS+= -DUSE_TLS -DCORE_TLS
endif
ifeq ($(TLS_HOOKS), 1)
	C_DEFS+= -DUSE_TLS -DTLS_HOOKS
endif
ifeq ($(KMSTATS), 1)
	C_DEFS+= -DUSE_CORE_STATS -DSTATISTICS
endif
ifeq ($(FMSTATS), 1)
	C_DEFS+= -DMALLOC_STATS
endif
ifeq ($(WITHAS), 1)
	C_DEFS+= -DWITH_AS_SUPPORT
endif

ifeq ($(SCTP), 1)
	C_DEFS+= -DUSE_SCTP
endif

ifeq ($(mode),)
	mode = release
endif

ifeq ($(mode),debug)
	C_DEFS+= -DEXTRA_DEBUG
endif

# platform dependent settings

# find ld & as name (gnu or solaris)
ifeq ($(OS), solaris)
ifeq ($(CC_NAME), gcc)
		LDGCC:=$(shell $(CC) -v 2>&1 | grep with-ld| \
				   sed -e 's/.*--with-ld=\([^ ][^ ]*\).*/\1/' )
		ASGCC:=$(shell $(CC) -v 2>&1 | grep with-as| \
				   sed -e 's/.*--with-as=\([^ ][^ ]*\).*/\1/' )
		LDPATH:=$(shell  if [ -z "$(LDGCC)" ] ; then echo "ld" ;\
						else \
						if $(LDGCC) -V 2>/dev/null 1>/dev/null; then \
							echo $(LDGCC); \
						else echo "ld" ; \
						fi\
						fi)
		ASPATH:=$(shell  if [ -z "$(ASGCC)" ] ; then echo "as" ;\
						else \
						if $(ASGCC) -V 2>/dev/null 1>/dev/null </dev/null; \
						then \
							echo $(ASGCC); \
						else echo "as" ; \
						fi\
						fi)
							
		LDTYPE:=$(shell if $(LDPATH) -V 1>/dev/null  2>/dev/null; then \
							if $(LDPATH) -V 2>&1|grep GNU >/dev/null; \
							then echo gnu; \
							else \
							if $(LDPATH) -V 2>&1|grep Solaris >/dev/null;\
							then echo solaris; \
							else \
								echo unknown ; \
							fi \
							fi \
						fi)
		ASTYPE:=$(shell if $(ASPATH) -V 1>/dev/null  2>/dev/null </dev/null; \
						then \
							if $(ASPATH) -V 2>&1 </dev/null | \
								grep GNU >/dev/null; then echo gnu; \
							else \
							if $(ASPATH) -V 2>&1 </dev/null | \
								grep Sun >/dev/null; then echo solaris; \
							else \
								echo unknown ; \
							fi \
							fi \
						fi)
#$(warning "using ld=$(LDPATH)/$(LDTYPE), as=$(ASPATH)/$(ASTYPE)")

endif
endif

# arch. specific definitions
ifeq ($(ARCH), i386)
	use_fast_lock=yes
endif

ifeq ($(ARCH), x86_64)
	use_fast_lock=yes
endif

ifeq ($(ARCH), sparc64)
ifeq 	($(CC_NAME), gcc)
	use_fast_lock=yes
endif
endif

ifeq ($(ARCH), sparc)
	use_fast_lock=yes
endif

ifeq ($(ARCH), arm)
	use_fast_lock=yes
	C_DEFS+=-DNOSMP # very unlikely to have an smp arm
endif

ifeq ($(ARCH), arm6)
	use_fast_lock=yes
	C_DEFS+=-DNOSMP # very unlikely to have an smp arm
endif

ifeq ($(ARCH), ppc)
	use_fast_lock=yes
endif

ifeq ($(ARCH), ppc64)
	use_fast_lock=yes
endif

ifeq ($(ARCH), mips)
# mips1 arch. (e.g. R3000) - no hardware locking support
	use_fast_lock=no
	C_DEFS+=-DMIPS_HAS_LLSC # likely
	C_DEFS+=-DNOSMP # very likely
endif

ifeq ($(ARCH), mips2)
# mips2 arch and newer (mips3=R4000, mips4=R5000 a.s.o)
	use_fast_lock=yes
endif

ifeq ($(ARCH), mips64)
# mips2 arch and newer (mips3=R4000, mips4=R5000 a.s.o)
	use_fast_lock=yes
endif

ifeq ($(ARCH), alpha)
	use_fast_lock=yes
	C_DEFS+=-DNOSMP # very likely
endif

ifeq ($(use_fast_lock), yes)
	C_DEFS+= -DFAST_LOCK -DADAPTIVE_WAIT -DADAPTIVE_WAIT_LOOPS=1024 
	found_lock_method=yes
endif

CFLAGS=
LDFLAGS=
C_INCLUDES=
# setting CFLAGS
ifeq ($(mode), release)
	#if i386
ifeq	($(ARCH), i386)
		# if gcc 
ifeq		($(CC_NAME), gcc) 
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS=-g $(CC_OPT) -funroll-loops  -Wcast-align $(PROFILE)
			#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
$(call				set_if_empty,CPUTYPE,athlon64)
					CFLAGS+=-m32 -minline-all-stringops \
							-falign-loops \
							-ftree-vectorize \
							-fno-strict-overflow \
							-mtune=$(CPUTYPE)
					LDFLAGS+=-m32
else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
$(call				set_if_empty,CPUTYPE,athlon64)
					CFLAGS+=-m32 -minline-all-stringops \
							-falign-loops \
							-ftree-vectorize \
							-mtune=$(CPUTYPE) 
					LDFLAGS+=-m32
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
$(call				set_if_empty,CPUTYPE,athlon)
					CFLAGS+=-m32 -minline-all-stringops \
							-falign-loops \
							-mtune=$(CPUTYPE) 
					LDFLAGS+=-m32
else
			#if gcc 3.0+
ifeq			($(CC_SHORTVER), 3.0)
$(call				set_if_empty,CPUTYPE,athlon)
					CFLAGS+=-minline-all-stringops \
							-falign-loops \
							-mcpu=$(CPUTYPE)
					# -m32 supported since gcc 3.2
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc >= 3.1 \
					for better results)
					
					CFLAGS+=-m486 \
							-malign-loops=4
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version  ($(CC_SHORTVER)), compile at your own risk!)

endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+

else		# CC_NAME, gcc
ifeq		($(CC_NAME), clang)
$(call                          set_if_empty,CPUTYPE,athlon64)
					C_DEFS+=-DCC_GCC_LIKE_ASM
					CFLAGS+=-g -m32 $(CC_OPT) -mtune=$(CPUTYPE)
					LDFLAGS+=-m32
else			# CC_NAME, clang
ifeq		($(CC_NAME), icc)
			C_DEFS+=-DCC_GCC_LIKE_ASM
			CFLAGS=-g -O3  -ipo -ipo_obj -unroll  $(PROFILE) \
					 -tpp6 -xK  #-openmp  #optimize for PIII 
				# -prefetch doesn't seem to work
				#( ty to inline acroos files, unroll loops,prefetch,
				# optimize for PIII, use PIII instructions & vect.,
				# mutlithread loops)
else
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, icc
endif		#CC_NAME, clang
endif		#CC_NAME, gcc
endif	#ARCH, i386

#x86_64
ifeq	($(ARCH), x86_64)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS=-g $(CC_OPT) -funroll-loops  -Wcast-align $(PROFILE)
			#if gcc 4.5+
			# don't add '-mtune=$(CPUTYPE)' - gcc failure
ifeq			($(CC_SHORTVER),$(filter $(CC_SHORTVER),4.5+ 5.0+))
$(call				set_if_empty,CPUTYPE,opteron)
					CFLAGS+=-m64 -minline-all-stringops \
							-falign-loops \
							-ftree-vectorize \
							-fno-strict-overflow
					LDFLAGS+=-m64
else
			#if gcc 4.2+
ifeq			($(CC_SHORTVER), 4.2+)
$(call				set_if_empty,CPUTYPE,opteron)
					CFLAGS+=-m64 -minline-all-stringops \
							-falign-loops \
							-ftree-vectorize \
							-fno-strict-overflow \
							-mtune=$(CPUTYPE)
					LDFLAGS+=-m64
else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
$(call				set_if_empty,CPUTYPE,opteron)
					CFLAGS+=-m64 -minline-all-stringops \
							-falign-loops \
							-ftree-vectorize \
							-mtune=$(CPUTYPE) 
					LDFLAGS+=-m64
else
			#if gcc 3.4
ifeq			($(CC_SHORTVER), 3.4)
$(call				set_if_empty,CPUTYPE,athlon64)
					CFLAGS+=-m64 -minline-all-stringops \
							-falign-loops 
					LDFLAGS+=-m64
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
$(call				set_if_empty,CPUTYPE,athlon64)
					CFLAGS+=-minline-all-stringops \
							-falign-loops 
							#-mcpu=$(CPUTYPE) \ # not working on all x86_64 gccs
							#-mcpu=athlon
					#-m64 on x86_64/x86 works starting with gcc 3.2
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc >= 3.1 \
					for better results)
					
					CFLAGS+=-m486 \
							-malign-loops=4
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version  ($(CC_SHORTVER)), compile at your own risk!)

endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 4.2+
endif			# CC_SHORTVER, 5.0+, 4.5+

else		# CC_NAME, gcc
ifeq            ($(CC_NAME), clang)
$(call                          set_if_empty,CPUTYPE,opteron)
					C_DEFS+=-DCC_GCC_LIKE_ASM
                                        CFLAGS+=-g -m64 \
                                                $(CC_OPT)        
                                        LDFLAGS+=-m64
else      	# CC_NAME, clang
ifeq		($(CC_NAME), icc)
			C_DEFS+=-DCC_GCC_LIKE_ASM
			CFLAGS=-g -O3  -ipo -ipo_obj -unroll  $(PROFILE) \
					 -tpp6 -xK  #-openmp  #optimize for PIII 
				# -prefetch doesn't seem to work
				#( ty to inline acroos files, unroll loops,prefetch,
				# optimize for PIII, use PIII instructions & vect.,
				# mutlithread loops)
else
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, icc
endif		#CC_NAME, clang
endif		#CC_NAME, gcc
endif	#ARCH, x86_64

	#if sparc64
ifeq	($(ARCH), sparc64)
			#if gcc
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM -DSPARC64_MODE
				#common stuff
				CFLAGS=-g $(CC_OPT) -funroll-loops  $(PROFILE) \
					#-Wcast-align \
					#-Wmissing-prototypes 
				#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
$(call				set_if_empty,CPUTYPE,ultrasparc)
					#use 32bit for now
					CFLAGS+=-m64 -mcpu=ultrasparc  \
							-mtune=$(CPUTYPE) \
							-fno-strict-overflow \
							-ftree-vectorize
					# use -m64 to force 64 bit (but add it also to LDFLAGS and
					#  don't forget to define SPARC64_MODE)
					# -m32 for 32 bit (default on solaris),
					# nothing for arch. default
					LDFLAGS+=-m64
else
				#if gcc 4.x
ifeq			($(CC_SHORTVER), 4.x)
$(call				set_if_empty,CPUTYPE,ultrasparc)
					#use 32bit for now
					CFLAGS+=-m64 -mcpu=ultrasparc  \
							-mtune=$(CPUTYPE) \
							-ftree-vectorize
					LDFLAGS+=-m64
else
				#if gcc 3.4
ifeq			($(CC_SHORTVER), 3.4)
$(call				set_if_empty,CPUTYPE,ultrasparc)
					#use 32bit for now
					CFLAGS+=-m64 -mcpu=ultrasparc -mtune=$(CPUTYPE)
					LDFLAGS+=-m64
else
				#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
$(call				set_if_empty,CPUTYPE,ultrasparc)
					#use 32bit for now
					CFLAGS+=-m64 -mcpu=ultrasparc -mtune=$(CPUTYPE)   \
					# -mcpu=v9 or ultrasparc? # -mtune implied by -mcpu
					#-mno-epilogue #try to inline function exit code
					#-mflat # omit save/restore
					#-,faster-structs #faster non Sparc ABI structure copy ops
					LDFLAGS+=-m64
else			# CC_SHORTVER, 3.0
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc >= 3.1 \
					for better results)
ifneq				($(OS), netbsd)
						# on netbsd/sparc64,  gcc 2.95.3 does not compile
						# ser with -mv8
						CFLAGS+= -mv9 
						# -m64/-m32 on sparc works starting with gcc 3.0
endif
ifeq					($(ASTYPE), solaris)
							CFLAGS+= -Wa,-xarch=v8plus
endif					
else			#CC_SHORTVER, 2.9x
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
					
					CFLAGS+= -mv9 
ifeq					($(ASTYPE), solaris)
							CFLAGS+= -Wa,-xarch=v8plus
endif					
	
endif			#CC_SHORTVER, 2.9x
endif			#CC_SHORTVER, 3.0
endif			#CC_SHORTVER, 3.4
endif			#CC_SHORTVER, 4.x
endif			#CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		#CC_NAME, gcc
ifeq		($(CC_NAME), suncc)
			C_DEFS+=-DSPARC64_MODE
			CFLAGS+= -m64 -g -xO5 -fast -native -xarch=v9 -xCC \
					-xc99 # C99 support
			# -Dinline="" # add this if cc < 5.3 (define inline as null)
else
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, suncc
endif		#CC_NAME, gcc
endif	#ARCH, sparc64

	#if sparc
ifeq	($(ARCH), sparc)
			#if gcc
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS=-g $(CC_OPT) -funroll-loops  $(PROFILE) \
					#-Wcast-align \
					#-Wmissing-prototypes 
				#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
$(call				set_if_empty,CPUTYPE,v8)
					#use 32bit for now
					CFLAGS+= -mtune=$(CPUTYPE) \
							-fno-strict-overflow \
							-ftree-vectorize
else
				#if gcc 4.x
ifeq			($(CC_SHORTVER), 4.x)
$(call				set_if_empty,CPUTYPE,v8)
					#use 32bit for now
					CFLAGS+= -mtune=$(CPUTYPE) \
							-ftree-vectorize
else
				#if gcc 3.4
ifeq			($(CC_SHORTVER), 3.4)
$(call				set_if_empty,CPUTYPE,v8)
					#use 32bit for now
					CFLAGS+= -mtune=$(CPUTYPE)
else
				#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
$(call				set_if_empty,CPUTYPE,v8)
					#use 32bit for now
					CFLAGS+= -mtune=$(CPUTYPE)   \
					#-mno-epilogue #try to inline function exit code
					#-mflat # omit save/restore
					#-,faster-structs #faster non Sparc ABI structure copy ops
else			# CC_SHORTVER, 3.0
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc >= 3.1 \
					for better results)
else			#CC_SHORTVER, 2.9x
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
					
endif			#CC_SHORTVER, 2.9x
endif			#CC_SHORTVER, 3.0
endif			#CC_SHORTVER, 3.4
endif			#CC_SHORTVER, 4.x
endif			#CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		#CC_NAME, gcc
ifeq		($(CC_NAME), suncc)
			CFLAGS+= -g -xO5 -fast -native -xCC \
					-xc99 # C99 support
			# -Dinline="" # add this if cc < 5.3 (define inline as null)
else
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, suncc
endif		#CC_NAME, gcc
endif	#ARCH, sparc

	#if ipaq/netwinder
ifeq	($(ARCH), arm)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS=-marm -march=armv5t $(CC_OPT) -funroll-loops -fsigned-char $(PROFILE)
			#if gcc 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
					CFLAGS+= -ftree-vectorize -fno-strict-overflow
					# not supported on arm: -minline-all-stringops 
else
			#if gcc 4.x+
ifeq			($(CC_SHORTVER), 4.x)
					CFLAGS+= -ftree-vectorize
					# not supported on arm: -minline-all-stringops 
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+=
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+= 
							#-mcpu=athlon
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					
					CFLAGS+=
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, arm 

	#if armv6 cpu 
ifeq	($(ARCH), arm6)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS=-march=armv6 $(CC_OPT) -funroll-loops -fsigned-char \
						$(PROFILE)
			#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
					CFLAGS+= -ftree-vectorize -fno-strict-overflow
else
			#if gcc 4.x+
ifeq			($(CC_SHORTVER), 4.x)
					CFLAGS+= -ftree-vectorize
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+=
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+= 
							#-mcpu=athlon
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					
					CFLAGS+=
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, arm6

	#if  mips (R3000)
ifeq	($(ARCH), mips)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS=$(CC_OPT) -funroll-loops  $(PROFILE)
			#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
					CFLAGS+=-mfp32 -march=r3000 \
							-ftree-vectorize -fno-strict-overflow
			# not supported on mips: -minline-all-stringops
else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
					CFLAGS+=-march=r3000 \
							-ftree-vectorize
			# not supported on mips: -minline-all-stringops
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+= -march=r3000
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+= -march=r3000
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					
					CFLAGS+=-march=r3000
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, mips

	#if  >=mips2 (R4000, R5000, R6000 ....)
ifeq	($(ARCH), mips2)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS= -mips2 $(CC_OPT) -funroll-loops $(PROFILE)
			#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
					CFLAGS+=-ftree-vectorize -fno-strict-overflow
			# not supported on mips: -minline-all-stringops
else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
					CFLAGS+=-ftree-vectorize
			# not supported on mips: -minline-all-stringops
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+=
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+=
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					CFLAGS+=
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, mips2

#if  >=mips64
ifeq	($(ARCH), mips64)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS= -mips64 $(CC_OPT) -funroll-loops $(PROFILE)
			#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
					CFLAGS+=-ftree-vectorize -fno-strict-overflow
			# not supported on mips: -minline-all-stringops

else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
					CFLAGS+=-ftree-vectorize
			# not supported on mips: -minline-all-stringops
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+=
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+=
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					CFLAGS+=
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, mips64

#if  alpha
ifeq	($(ARCH), alpha)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS= $(CC_OPT) -funroll-loops $(PROFILE)
			#if gcc 5.0+, 4.5 or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
					CFLAGS+= -fno-strict-overflow
					# not supported: -minline-all-stringops
else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
					CFLAGS+= 
					# not supported: -minline-all-stringops
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+=
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+=
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					CFLAGS+=
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, alpha 

#if  ppc
ifeq	($(ARCH), ppc)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS=
			#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
$(call				set_if_empty,CPUTYPE,powerpc)
ifeq 				($(NOALTIVEC),)
						CFLAGS += $(CC_OPT) -funroll-loops -fsigned-char $(PROFILE)
						CFLAGS += -ftree-vectorize
						CFLAGS += -maltivec
						CFLAGS += -fno-strict-overflow
						CFLAGS += -mtune=$(CPUTYPE)
endif
else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
$(call				set_if_empty,CPUTYPE,powerpc)
ifeq 				($(NOALTIVEC),)
						CFLAGS += $(CC_OPT) -funroll-loops -fsigned-char $(PROFILE)
						CFLAGS += -ftree-vectorize
						CFLAGS += -maltivec
						CFLAGS += -mtune=$(CPUTYPE)
endif
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+=
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+=
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					CFLAGS+=
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, ppc 

#if  ppc64
ifeq	($(ARCH), ppc64)
		# if gcc 
ifeq		($(CC_NAME), gcc)
				C_DEFS+=-DCC_GCC_LIKE_ASM
				#common stuff
				CFLAGS= $(CC_OPT) -funroll-loops -fsigned-char $(PROFILE)
			#if gcc 5.0+, 4.5+ or 4.2+
ifeq (,$(strip $(filter-out 4.2+ 4.5+ 5.0+,$(CC_SHORTVER))))
$(call				set_if_empty,CPUTYPE,powerpc64)
					CFLAGS+=-ftree-vectorize \
							-fno-strict-overflow \
							-mtune=$(CPUTYPE) -maltivec
else
			#if gcc 4.0+
ifeq			($(CC_SHORTVER), 4.x)
$(call				set_if_empty,CPUTYPE,powerpc64)
					CFLAGS+=-ftree-vectorize \
							-mtune=$(CPUTYPE) -maltivec
else
			#if gcc 3.4+
ifeq			($(CC_SHORTVER), 3.4)
					CFLAGS+=
else
			#if gcc 3.0
ifeq			($(CC_SHORTVER), 3.0)
					CFLAGS+=
else
ifeq			($(CC_SHORTVER), 2.9x) #older gcc version (2.9[1-5])
$(warning 			Old gcc detected ($(CC_SHORTVER)), use  gcc 3.0.x \
					for better results)
					CFLAGS+=
else
				#really old version
$(warning			You are using an old and unsupported gcc \
					 version ($(CC_SHORTVER)), compile at your own risk!)
	
endif			# CC_SHORTVER, 2.9x
endif			# CC_SHORTVER, 3.0
endif			# CC_SHORTVER, 3.4
endif			# CC_SHORTVER, 4.x
endif			# CC_SHORTVER, 5.0+, 4.5+ or 4.2+
	
else		# CC_NAME, gcc
				#other compilers
$(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)
endif		#CC_NAME, gcc
endif	#ARCH, ppc 

CFLAGS+= $(CC_EXTRA_OPTS)


# setting LDFLAGS
ifeq	($(CC_NAME), gcc)
ifeq		($(LDTYPE), solaris)
		# solaris ld
		LDFLAGS+=-O2 $(PROFILE)
		MOD_LDFLAGS:=-G $(LDFLAGS)
		LIB_LDFLAGS:=-G $(LDFLAGS)
		LIB_SONAME=-Wl,-h,
		LD_RPATH=-Wl,-R,
else		
		#gcc and maybe others, => gnu ld
		LDFLAGS+=-Wl,-O2 -Wl,-E $(PROFILE) 
		MOD_LDFLAGS:=-shared $(LDFLAGS)
		LIB_LDFLAGS:=-shared $(LDFLAGS)
		LIB_SONAME=-Wl,-soname,
		LD_RPATH=-Wl,-rpath,
endif
endif
ifeq	($(CC_NAME), icc)
	#gcc and maybe others
	LDFLAGS+=-Wl,-O2 -Wl,-E $(PROFILE) 
	MOD_LDFLAGS:=-shared $(LDFLAGS)
	LIB_LDFLAGS:=-shared $(LDFLAGS)
	LIB_SONAME=-Wl,-soname,
	LD_RPATH=-Wl,-rpath,
endif
ifeq	($(CC_NAME), suncc)
	# -dy?
	LDFLAGS+=-xO5 $(PROFILE)
	MOD_LDFLAGS:=-G $(LDFLAGS)
	LIB_LDFLAGS:=-G $(LDFLAGS)
	LIB_SONAME="-h "
	LD_RPATH=-"-R "
endif
	# we need -fPIC -DPIC only for shared objects, we don't need them for
	# the executable file, because it's always loaded at a fixed address
	# -andrei

ifeq ($(CC_NAME), clang)
	LDFLAGS+=-Wl,-O2 -Wl,-E $(PROFILE)
        MOD_LDFLAGS:=-shared $(LDFLAGS)
        LIB_LDFLAGS:=-shared $(LDFLAGS)
        LIB_SONAME=-Wl,-soname,
        LD_RPATH=-Wl,-rpath,
endif

LDFLAGS+= $(LD_EXTRA_OPTS)
MOD_LDFLAGS+= $(LD_EXTRA_OPTS)
LIB_LDFLAGS+= $(LD_EXTRA_OPTS)

else	#mode,release
ifeq	($(CC_NAME), gcc)
		CFLAGS=-g -Wcast-align $(PROFILE)
		C_DEFS+=-DCC_GCC_LIKE_ASM
ifeq		($(ARCH), sparc64)
			C_DEFS+=SPARC64_MODE
			CFLAGS+= -mcpu=ultrasparc -m64
			LDFLAGS+=-m64
endif
ifeq		($(LDTYPE), solaris)
			#solaris ld
			LDFLAGS+=-g $(PROFILE)
			MOD_LDFLAGS:=-G $(LDFLAGS)
			LIB_LDFLAGS:=-G $(LDFLAGS)
			LIB_SONAME=-Wl,-h,
			LD_RPATH=-Wl,-R,
else
			#gnu or other ld type
			LDFLAGS+=-g -Wl,-E $(PROFILE)
			MOD_LDFLAGS:=-shared $(LDFLAGS)
			LIB_LDFLAGS:=-shared $(LDFLAGS)
			LIB_SONAME=-Wl,-soname,
			LD_RPATH=-Wl,-rpath,
endif
endif
ifeq	($(CC_NAME), icc)
		C_DEFS+=-DCC_GCC_LIKE_ASM
		CFLAGS=-g  $(PROFILE)
		LDFLAGS+=-g -Wl,-E $(PROFILE)
		MOD_LDFLAGS:=-shared $(LDFLAGS)
		LIB_LDFLAGS:=-shared $(LDFLAGS)
		LIB_SONAME=-Wl,-soname,
		LD_RPATH=-Wl,-rpath,
endif
ifeq	($(CC_NAME), suncc)
		CFLAGS= -g $(PROFILE)
		LDFLAGS+=-g $(PROFILE)
		MOD_LDFLAGS:=-G $(LDFLAGS)
		LIB_LDFLAGS:=-G $(LDFLAGS)
		LIB_SONAME="-h "
		LD_RPATH=-"-R "
endif

endif #mode=release


# set pedantic compiler options
ifeq ($(CC_NAME), gcc)
		CFLAGS+= -Wall
else # no gcc
ifeq ($(CC_NAME), icc)
		CFLAGS+= -Wall
else # no icc
ifeq ($(CC_NAME), suncc)
		# FIXME: is the default (-Xa ?) enough?
endif # CC_NAME=suncc
endif # CC_NAME=icc
endif # CC_NAME=gcc

#CFLAGS used for compiling the modules, libraries and utils
ifeq	($(CC_NAME), gcc)
MOD_CFLAGS=-fPIC -DPIC $(CFLAGS)
LIB_CFLAGS=-fPIC -DPIC $(CFLAGS)
endif
ifeq	($(CC_NAME), icc)
MOD_CFLAGS=-Kpic $(CFLAGS)
LIB_CFLAGS=-Kpic $(CFLAGS)
endif
ifeq	($(CC_NAME), suncc)
# FIMXE: use -KPIC instead -xcode ?
MOD_CFLAGS=-xcode=pic32  $(CFLAGS)
LIB_CFLAGS=-xcode=pic32  $(CFLAGS)
endif
ifeq    ($(CC_NAME), clang)
MOD_CFLAGS=-fPIC -DPIC $(CFLAGS)
LIB_CFLAGS=-fPIC -DPIC $(CFLAGS)
endif

UTILS_CFLAGS=$(CFLAGS)
# LDFLAGS uses for compiling the utils
UTILS_LDFLAGS=$(LDFLAGS)

ifeq ($(LEX),)
	LEX=flex
endif
ifeq ($(YACC),)
	YACC=bison
endif
YACC_FLAGS=-d -b cfg
# on solaris add -lxnet (e.g. LIBS= -lxnet)
LIBS= -ldl -lresolv
LIB_PREFIX:=lib
LIB_SUFFIX:=.so


#os specific stuff
ifeq ($(OS), linux)
# by default use futexes if available
	use_futex= yes
	C_DEFS+=-DHAVE_GETHOSTBYNAME2 -DHAVE_UNION_SEMUN -DHAVE_SCHED_YIELD \
			-DHAVE_MSG_NOSIGNAL -DHAVE_MSGHDR_MSG_CONTROL -DHAVE_ALLOCA_H \
			-DHAVE_TIMEGM -DHAVE_SCHED_SETSCHEDULER -DUSE_RAW_SOCKS
	ifneq ($(found_lock_method), yes)
		#C_DEFS+= -DUSE_POSIX_SEM
		C_DEFS+=-DUSE_PTHREAD_MUTEX
		LIBS+= -lpthread
		#C_DEFS+= -DUSE_SYSV_SEM  # try posix sems
		found_lock_method=yes
	else
		ifneq (,$(findstring -DUSE_POSIX_SEM, $(C_DEFS)))
			LIBS+=-lpthread
		endif
		ifneq (,$(findstring -DUSE_PTHREAD_MUTEX, $(C_DEFS)))
			LIBS+=-lpthread
		endif
	endif
        # check for >= 2.5.44

	ifeq ($(shell [ $(OSREL_N) -ge 2005044 ] && echo has_epoll), has_epoll)
		ifeq ($(NO_EPOLL),)
			C_DEFS+=-DHAVE_EPOLL
			# linux + gcc >= 3.0 + -malign-double + epoll => problems
			CFLAGS_RM+=-malign-double
			#CFLAGS:=$(filter-out -malign-double, $(CFLAGS))
		endif
	endif
	# check for >= 2.2.0
	ifeq ($(shell [ $(OSREL_N) -ge 2002000 ] && echo has_sigio), has_sigio)
		ifeq ($(NO_SIGIO),)
			C_DEFS+=-DHAVE_SIGIO_RT -DSIGINFO64_WORKARROUND
		endif
	endif
	# check for >= 2.5.70
	ifeq ($(shell [ $(OSREL_N) -ge 2005070 ] && echo has_futex), has_futex)
		ifeq ($(use_futex), yes)
			C_DEFS+=-DUSE_FUTEX
		endif
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
endif

ifeq ($(OS), gnu_kfreebsd)
# by default use futexes if available
	use_futex= yes
	C_DEFS+=-DHAVE_GETHOSTBYNAME2 -DHAVE_UNION_SEMUN -DHAVE_SCHED_YIELD \
			-DHAVE_MSG_NOSIGNAL -DHAVE_MSGHDR_MSG_CONTROL -DHAVE_ALLOCA_H \
			-DHAVE_TIMEGM -DHAVE_SCHED_SETSCHEDULER -DUSE_RAW_SOCKS
	ifneq ($(found_lock_method), yes)
		#C_DEFS+= -DUSE_POSIX_SEM
		C_DEFS+=-DUSE_PTHREAD_MUTEX
		LIBS+= -lpthread
		#C_DEFS+= -DUSE_SYSV_SEM  # try posix sems
		found_lock_method=yes
	else
		ifneq (,$(findstring -DUSE_POSIX_SEM, $(C_DEFS)))
			LIBS+=-lpthread
		endif
		ifneq (,$(findstring -DUSE_PTHREAD_MUTEX, $(C_DEFS)))
			LIBS+=-lpthread
		endif
	endif

	# check for ver >= 4.1
	ifeq ($(shell [ $(OSREL_N) -gt 4001 ] && echo has_kqueue), has_kqueue)
		ifeq ($(NO_KQUEUE),)
			C_DEFS+=-DHAVE_KQUEUE
		endif
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
endif

ifeq  ($(OS), solaris)
	C_DEFS+= -DHAVE_GETIPNODEBYNAME -DHAVE_SYS_SOCKIO_H -DHAVE_SCHED_YIELD \
			-DHAVE_ALLOCA_H -DUSE_SIGACTION
	ifneq ($(found_lock_method), yes)
		C_DEFS+= -DUSE_PTHREAD_MUTEX  # try pthread sems
		found_lock_method=yes
	endif
	# check for ver >= 5.7
	ifeq ($(shell [ $(OSREL_N) -gt 5007 ] && echo has_devpoll), has_devpoll)
		ifeq ($(NO_DEVPOLL),)
			C_DEFS+=-DHAVE_DEVPOLL
		endif
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
	# check for filio.h
	filio_h_locations= /usr/include/sys/filio.h \
						$(LOCALBASE)/include/sys/filio.h
	has_filio_h=$(shell for r in $(filio_h_locations); do \
						if  [ -r "$$r" ] ; then echo yes; exit; fi \
						done;\
				)
	ifeq ($(has_filio_h), yes)
		C_DEFS+=-DHAVE_FILIO_H
	endif
	ifeq ($(mode), release)
		#use these only if you're using gcc with Solaris ld
		#LDFLAGS=-O2 $(PROFILE)
		#MOD_LDFLAGS=-O2 -G
	else
		#LDFLAGS=-g $(PROFILE)
		#MOD_LDFLAGS=-g -G
	endif
	YACC=yacc

ifeq ($(CC_NAME), suncc)
	LIBS= -lfast -ldl -lresolv
endif
	OLD_SOLARIS= $(shell echo "$(OSREL)" | \
				sed -e 's/^5\.[0-6][^0-9]*$$/yes/' )
	LIBS+= -L$(LOCALBASE)/lib -lxnet -lsocket -lnsl 
ifeq	($(OLD_SOLARIS), yes)
		LIBS+=-lposix4
else
		LIBS+=-lrt
endif
	# -lrt needed for sched_yield
endif

ifeq ($(OS), freebsd)
	C_DEFS+=-DHAVE_SOCKADDR_SA_LEN -DHAVE_GETHOSTBYNAME2 -DHAVE_UNION_SEMUN \
		-DHAVE_SCHED_YIELD -DHAVE_MSGHDR_MSG_CONTROL \
		-DHAVE_CONNECT_ECONNRESET_BUG -DHAVE_TIMEGM \
		-DHAVE_NETINET_IN_SYSTM -DUSE_RAW_SOCKS
	ifneq ($(found_lock_method), yes)
		C_DEFS+= -DUSE_PTHREAD_MUTEX  # try pthread sems
		found_lock_method=yes
		LIBS+= -pthread   #dlopen is in libc
	else
		LIBS=   #dlopen is in libc
	endif
	# check for ver >= 4.1
	ifeq ($(shell [ $(OSREL_N) -gt 4001 ] && echo has_kqueue), has_kqueue)
		ifeq ($(NO_KQUEUE),)
			C_DEFS+=-DHAVE_KQUEUE
		endif
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
	YACC=yacc
endif

ifeq ($(OS), dragonfly)
	C_DEFS+=-DHAVE_SOCKADDR_SA_LEN -DHAVE_GETHOSTBYNAME2 -DHAVE_UNION_SEMUN \
		-DHAVE_SCHED_YIELD -DHAVE_MSGHDR_MSG_CONTROL \
		-DHAVE_CONNECT_ECONNRESET_BUG -DHAVE_TIMEGM \
		-DHAVE_NETINET_IN_SYSTM
	ifneq ($(found_lock_method), yes)
		C_DEFS+= -DUSE_PTHREAD_MUTEX  # try pthread sems
		found_lock_method=yes
		LIBS+= -pthread   #dlopen is in libc
	else
		LIBS=   #dlopen is in libc
	endif
	# dragonfly was forked from freebsd 4.8 => all version have kqueue
	ifeq ($(NO_KQUEUE),)
		C_DEFS+=-DHAVE_KQUEUE
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
	YACC=yacc
endif

ifeq ($(OS), openbsd)
	C_DEFS+=-DHAVE_SOCKADDR_SA_LEN  -DHAVE_GETHOSTBYNAME2 \
		-DHAVE_UNION_SEMUN -DHAVE_MSGHDR_MSG_CONTROL \
		-DHAVE_CONNECT_ECONNRESET_BUG -DHAVE_TIMEGM \
		-DHAVE_NETINET_IN_SYSTM -DUSE_SIGWAIT \
		-DHAVE_SCHED_YIELD
	ifneq ($(found_lock_method), yes)
		C_DEFS+= -DUSE_PTHREAD_MUTEX  # try pthread sems
		found_lock_method=yes
	endif
	# check for ver >=2 9
	ifeq ($(shell [ $(OSREL_N) -ge 2009 ] && echo has_kqueue), has_kqueue)
		ifeq ($(NO_KQUEUE),)
			C_DEFS+=-DHAVE_KQUEUE
		endif
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
	# (symbols on openbsd are prefixed by "_")
	YACC=yacc
	# unfortunately pthread is needed for sigwait
	LIBS= -lpthread
endif   # if opensd
	
ifeq ($(OS), netbsd)
	C_DEFS+=-DHAVE_SOCKADDR_SA_LEN -DHAVE_GETHOSTBYNAME2 \
		-DHAVE_MSGHDR_MSG_CONTROL -DHAVE_CONNECT_ECONNRESET_BUG -DHAVE_TIMEGM
	ifneq ($(found_lock_method), yes)
		C_DEFS+= -DUSE_SYSV_SEM  # try pthread sems
		found_lock_method=yes
	endif
	# check for ver >= 2.0.0
	ifeq ($(shell [ $(OSREL_N) -ge 2000000 ] && echo has_kqueue), has_kqueue)
		ifeq ($(NO_KQUEUE),)
			C_DEFS+=-DHAVE_KQUEUE
			# netbsd + kqueue and -malign-double don't work
			CFLAGS_RM+=-malign-double
			#CFLAGS:=$(filter-out -malign-double, $(CFLAGS))
		endif
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
	YACC=yacc
	LIBS=  
endif

# OS X support, same as freebsd
ifeq ($(OS), darwin)
	C_DEFS+=-DHAVE_SOCKADDR_SA_LEN -DHAVE_GETHOSTBYNAME2 -DHAVE_UNION_SEMUN \
		-DHAVE_SCHED_YIELD -DHAVE_MSGHDR_MSG_CONTROL \
		-DUSE_ANON_MMAP \
		-DNDEBUG -DHAVE_CONNECT_ECONNRESET_BUG -DHAVE_TIMEGM \
		-DUSE_SIGWAIT
	# -DNDEBUG used to turn off assert (assert wants to call
	# eprintf which doesn't seem to be defined in any shared lib
	ifneq ($(found_lock_method), yes)
		C_DEFS+= -DUSE_PTHREAD_MUTEX  # try pthread sems
		found_lock_method=yes
		C_DEFS+= -DUSE_SYSV_SEM  # try sys v sems (pthread don't work for
		                       # processes and unnamed posix sems are not
		                       # supported)
	endif
	LIBS= -lresolv  #dlopen is in libc
	ifeq ($(NO_KQUEUE),)
		C_DEFS+=-DHAVE_KQUEUE
	endif
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
	LDFLAGS=        # darwin doesn't like -O2 or -E
	# the modules uses symbols from ser => either 
	# -flat_namespace -undefined_suppress or -bundle_loader ../../$(MAIN_NAME)
	MOD_LDFLAGS:= -bundle -flat_namespace -undefined suppress
	# for libs using symbols from ser (e.g srdb2, kcore a.s.o) we
	# need -flat_namespace -undefined suppress
	LIB_LDFLAGS:= -dynamiclib -flat_namespace -undefined suppress
	LIB_SUFFIX:=.dylib
	# on darwin soname should include the full path
	# (it kind of combines rpath & soname)
	LIB_SONAME=
	# no equiv. for rpath on darwin
	LD_RPATH=
	YACC=yacc
endif

ifneq (,$(findstring cygwin, $(OS)))
	# cygwin does support IPV6 starting from version 1.7, but (still?) doesn't support fd passing so no TCP
	#C_DEFS:=$(filter-out -DUSE_TCP, $(C_DEFS))
	DEFS_RM+=-DUSE_TCP
	C_DEFS+=-DHAVE_UNION_SEMUN -DHAVE_SCHED_YIELD \
			-DHAVE_MSG_NOSIGNAL -DHAVE_MSGHDR_MSG_CONTROL -DHAVE_ALLOCA_H \
			-DHAVE_TIMEGM -DHAVE_SCHED_SETSCHEDULER
	ifneq ($(found_lock_method), yes)
		C_DEFS+= -DUSE_POSIX_SEM
		#C_DEFS+= -DUSE_SYSV_SEM  # try posix sems
		# PTHREAD_MUTEX do not work for processes (try test/pthread_test.c)
		#LIBS+= -lpthread
		found_lock_method=yes
	else
		ifneq (,$(findstring -DUSE_POSIX_SEM, $(C_DEFS)))
			#LIBS+=-lpthread
		endif
		ifneq (,$(findstring -DUSE_PTHREAD_MUTEX, $(C_DEFS)))
$(error PTHREAD_MUTEX do not work for processes on Windows/CYGWIN)
		endif
	endif
	# check for >= 2.5.70
	ifeq ($(NO_SELECT),)
		C_DEFS+=-DHAVE_SELECT
	endif
endif

#add libssl if needed
ifeq ($(CORE_TLS), 1)
C_INCLUDES+= -I$(LOCALBASE)/ssl/include
LIBS+= -L$(LOCALBASE)/lib -L$(LOCALBASE)/ssl/lib -lssl -lcrypto \
		$(TLS_EXTRA_LIBS)
# NOTE: depending on the way in which libssl was compiled you might
#       have to add -lz -lkrb5   (zlib and kerberos5).
#       E.g.: make CORE_TLS=1 EXTRA_TLS_LIBS="-lz -lkrb5"
endif

ifneq ($(found_lock_method), yes)
$(warning	No locking method found so far, trying SYS V sems)
		C_DEFS+= -DUSE_SYSV_SEM  # try sys v sems
		found_lock_method=yes
endif


endif # ifeq (,$(main_makefile))
endif  # ifeq ($(makefile_defs), 1)

# if incomplete or missing config.mak, or already exported vars, don't
# try to export/re-export
ifeq ($(makefile_defs),1) 
ifneq ($(exported_vars),1)


override exported_vars:=1
export exported_vars

# variable changeable only at configure time (once saved in config.mak they
#  cannot be overwritten from environment or command line, unless make cfg
#  is run)
saved_fixed_vars:=	MAIN_NAME  CFG_NAME SCR_NAME FLAVOUR INSTALL_FLAVOUR \
		SRC_NAME RELEASE OS ARCH \
		C_DEFS DEFS_RM PROFILE CC LD MKDEP MKTAGS LDFLAGS C_INCLUDES \
		CC_MKDEP_OPTS \
		MOD_LDFLAGS LIB_LDFLAGS UTILS_LDFLAGS LIB_SONAME LD_RPATH \
		LIB_SUFFIX LIB_PREFIX \
		LIBS \
		LEX YACC YACC_FLAGS \
		PREFIX LOCALBASE \
		TAR \
		INSTALL INSTALL_CFG INSTALL_BIN INSTALL_MODULES INSTALL_DOC \
		INSTALL_MAN INSTALL_LIB INSTALL_TOUCH INSTALL_SHARE \
		Q

# variable changeable at compile time
# extra: prefix DESTDIR BASEDIR basedirt
saved_chg_vars:=\
		CC_EXTRA_OPTS CPUTYPE CFLAGS_RM CFLAGS MOD_CFLAGS LIB_CFLAGS UTILS_CFLAGS \
		BASEDIR basedir DESTDIR LIBDIR RUNBASEDIR runbasedir \
		PREFIX prefix \
		cfg_prefix cfg_dir bin_prefix bin_dir modules_prefix modules_dir \
		doc_prefix doc_dir man_prefix man_dir ut_prefix ut_dir \
		share_prefix share_dir lib_prefix lib_dir data_prefix data_dir \
		cfg_target lib_target data_target run_prefix run_dir run_target


#export relevant variables to the sub-makes
export $(saved_fixed_vars)
export $(saved_chg_vars)


endif # ifneq ($(exported_vars),1)
endif # ifeq ($(makefile_defs),1)