CLibrary

# Makefile fragment for C and C++ libraries for applications and modules

INCLUDED_CLIBRARY = YES

#
# This makefile provides the following phony targets:
#
#    all_libs  export_hdrs  export_libs  install
#
#
# This fragment uses the following macros set by the master makefile.
#
#
# COMPONENT          (the name of the component)
# TARGET       (opt) (the leafname of the primary target - otherwise ${COMPONENT})
# LIBRARY      (opt) (the leafname of the application library - otherwise ${TARGET})
# LIBRARYZM    (opt) (the leafname of the module library - otherwise ${LIBRARY}zm)
# LIBRARYD     (opt) (the leafname of the debug app library - otherwise ${LIBRARY}d)
# LIBRARYDZM   (opt) (the leafname of the debug module library - otherwise ${LIBRARY}dzm)
# LIBRARIES    (opt) (libraries to build/export - otherwise ${LIBRARY} and ${LIBRARYZM})
# LIBEXT       (opt) (subdir or filename extension for library files - otherwise a)
# LIB_DEPENDS  (opt) (any extra dependencies to assert before making LIBRARIES)
# EXPDIR       (opt) (the target directory - otherwise ${LIBDIR}/${TARGET} or
#                                  for a disc install ${INSTDIR}/${TARGET})
# DIRS         (opt) (stamp object for directory creation - otherwise _dirs)
# HDRS         (opt) (header files to export, no h. prefix - otherwise ${TARGET})
# ASMHDRS      (opt) (assembly header files to export, no Hdr. prefix - otherwise none)
# EXPORTS      (opt) (dependencies for export_hdrs phase - otherwise deduced from ${HDRS} and ${ASMHDRS})
# OBJS               (object files, no o. or oz. prefixes)
# DBG_OBJS     (opt) (debug build object files, no o. or oz. prefixes - otherwise ${OBJS})
# APP_OBJS     (opt) (release application object files, no o. or oz. prefixes - otherwise ${OBJS})
# APP_DBG_OBJS (opt) (debug application object files, no o. or oz. prefixes - otherwise ${DBG_OBJS})
# MOD_OBJS     (opt) (release module object files, no o. or oz. prefixes - otherwise ${OBJS})
# MOD_DBG_OBJS (opt) (debug module object files, no o. or oz. prefixes - otherwise ${DBG_OBJS})
# CUSTOMLIB    (opt) (set to "custom" to override the application library rule)
# CUSTOMLIBZM  (opt) (set to "custom" to override the module library rule)
# CUSTOMLIBD   (opt) (set to "custom" to override the debug application library rule)
# CUSTOMLIBDZM (opt) (set to "custom" to override the debug module library rule)
# SOURCES_TO_SYMLINK (opt) (files which need be linked to by the link farm, in addition to contents of c and h directories)
#
#
# It relies on the following from the build system:
#
#
# PHASE            (export phase discriminator)
#
#
# It relies on the following generic tool macros from the StdTools makefile
#
#
# CP + CPFLAGS     (copy, cp etc.)
# WIPE + WFLAGS    (recursive delete)
# RM               (non-recursive delete)
# AS + ASFLAGS     (assembler)
# MKDIR            (cdir/mkdir -p)
# ECHO
# AR + ARFLAGS     (libfile/ar)
# TOUCH            (create/touch)
# NOP
#
#
# It relies on the following from the StdRules makefile
#
#
# .c.o  .c.oz  .c++.o  .cpp.o  .c++.oz  .c++.oz  .s.o  .s.oz
#
#
# It relies on the following from the DbgRules makefile
#
#
# CDFLAGS  C++DFLAGS  ASDFLAGS
# .c.od  .c.odz  .c++.od  .cpp.od  .c++.odz  .cpp.odz  .s.od  .s.odz
#
#

LIBDIR        = ${BUILDDIR}/Export/${APCS}/Lib

TARGET       ?= ${COMPONENT}
LIBRARY      ?= ${TARGET}
LIBRARYZM    ?= ${LIBRARY}zm
LIBRARYD     ?= ${LIBRARY}d
LIBRARYDZM   ?= ${LIBRARY}dzm
LIBRARIES    ?= ${LIBRARYZM} ${LIBRARY}
LIBEXT       ?= a
DIRS         ?= _dirs
HDRS         ?= ${TARGET}
ASMHDRS      ?=
DBG_OBJS     ?= ${OBJS}
APP_OBJS     ?= ${OBJS}
APP_DBG_OBJS ?= ${DBG_OBJS}
MOD_OBJS     ?= ${OBJS}
MOD_DBG_OBJS ?= ${DBG_OBJS}
APP_OBJS_     = $(addsuffix .o,${APP_OBJS})
APP_DBG_OBJS_ = $(addsuffix .od,${APP_DBG_OBJS})
MOD_OBJS_     = $(addsuffix .oz,${MOD_OBJS})
MOD_DBG_OBJS_ = $(addsuffix .odz,${MOD_DBG_OBJS})

EXPORTING_HDRS    = $(addsuffix .exphdr,${HDRS})
EXPORTING_ASMHDRS = $(addsuffix .expasm,${ASMHDRS})
EXPORTS          ?= ${EXPORTING_HDRS} ${EXPORTING_ASMHDRS}
EXPORTING_LIBS    = $(addsuffix .explib,${LIBRARIES})
TARGET_LIBS       = $(addsuffix .${LIBEXT},${LIBRARIES})

ifeq ($(filter install%,${MAKECMDGOALS}),)
EXPDIR       ?= ${LIBDIR}/${TARGET}
else
EXPDIR       ?= ${INSTDIR}/${TARGET}
endif

SOURCES_TO_SYMLINK += $(wildcard c/*) $(wildcard h/*) $(wildcard s/*)

ifeq ("${INCLUDED_STDTOOLS}","")
include StdTools
endif

ifneq (objs,$(notdir ${CURDIR}))

# Makefile invoked from same directory
# Create link farm, then execute the makefile from within it

ifeq (clean,${MAKECMDGOALS})
# With a double-colon rule which can have additional actions assigned from the
# master makefile, we'd normally need the master makefile to include the
# ${CURDIR} check to ensure that it's performed on the same invocation as us.
# However, there's no real benefit to performing clean from within the objs
# directory, and it adds an ordering problem between the different double-colon
# rules (the one that deletes the objs directory has to be last otherwise the
# cwd is invalid for the others) so to simplify things, we only ever do cleans
# from the same directory as the Makefile.
clean::
	@echo Cleaning...
	@rm -rf objs
	@echo ${COMPONENT}: cleaned
else
all_libs export export_hdrs export_libs links: ${SYMLINK_DEPEND}
	$(foreach linksource,${SOURCES_TO_SYMLINK}, \
		$(shell \
			linkdest=`echo ${linksource} | sed -e 's,\([^/]\+\)/\([^/]\+\)$$,\2.\1,' -e 's,^,objs/,'`; \
			linkdestdir=`echo $$linkdest | sed -e 's,/[^/]\+$$,,'`; \
			linkbackpath=`echo $$linkdestdir | sed -e 's,[^/]\+,..,g'`; \
			[ -d ${linksource} ] || [ -L $$linkdest ] || mkdir -p $$linkdestdir; \
			[ -d ${linksource} ] || [ -L $$linkdest ] || ln -s $$linkbackpath/${linksource} $$linkdest; \
		 ) \
	)
	@mkdir -p objs
ifneq (links,${MAKECMDGOALS})
	@${MAKE} -C objs -f ../$(firstword ${MAKEFILE_LIST}) ${MAKECMDGOALS}
endif
endif

else

# Makefile invoked from objs subdirectory

ifeq ("${INCLUDED_STDRULES}","")
include StdRules
endif
ifeq ("${INCLUDED_DBGRULES}","")
include DbgRules
endif

all_libs: ${TARGET_LIBS}
	@${ECHO} ${COMPONENT}: library built

# GNU make seems to treat any double-colon rule with no dependencies as
# always out-of-date, therefore always rebuilds it and anything which in turn
# depends on the target of the double-colon rule. So use a single-colon rule
# instead. If any cross builds need to create extra directories on a
# per-component basis, we'll cross that bridge when we get to it.
${DIRS}:
	${TOUCH} $@

export: export_${PHASE}
	@${NOP}

install export_: export_libs export_hdrs
	@${NOP}

create_exp_hdr_dirs:
	${MKDIR} ${EXPDIR}

create_exp_lib_dir:
	${MKDIR} ${EXPDIR}

.SUFFIXES: .exphdr .expasm .explib .h .Hdr .${LIBEXT}
.h.exphdr:;         ${CP} $< ${EXPDIR}/$< ${CPFLAGS}
.Hdr.expasm:;       ${CP} $< ${EXPDIR}/$* ${CPFLAGS}
.${LIBEXT}.explib:; ${CP} $< ${EXPDIR}/$< ${CPFLAGS}

export_hdrs: create_exp_hdr_dirs ${DIRS} ${EXPORTS}
	[ ! -f ../VersionNum ] || ${CP} ../VersionNum ${EXPDIR}/LibVersion ${CPFLAGS}
	@${ECHO} ${COMPONENT}: header export complete

export_libs: create_exp_lib_dir ${DIRS} ${TARGET_LIBS} ${EXPORTING_LIBS}
	[ ! -f ../VersionNum ] || ${CP} ../VersionNum ${EXPDIR}/LibVersion ${CPFLAGS}
	@${ECHO} ${COMPONENT}: library export complete

${LIBRARY}${CUSTOMLIB}.${LIBEXT}: ${LIBDEPENDS} ${DIRS} ${APP_OBJS_}
	${AR} ${ARFLAGS} ${LIBRARY}.${LIBEXT} ${APP_OBJS_}

${LIBRARYZM}${CUSTOMLIBZM}.${LIBEXT}: ${LIBDEPENDS} ${DIRS} ${MOD_OBJS_}
	${AR} ${ARFLAGS} ${LIBRARYZM}.${LIBEXT} ${MOD_OBJS_}

${LIBRARYD}${CUSTOMLIBD}.${LIBEXT}: ${LIBDEPENDS} ${DIRS} ${APP_DBG_OBJS_}
	${AR} ${ARFLAGS} ${LIBRARYD}.${LIBEXT} ${APP_DBG_OBJS_}

${LIBRARYDZM}${CUSTOMLIBDZM}.${LIBEXT}: ${LIBDEPENDS} ${DIRS} ${MOD_DBG_OBJS_}
	${AR} ${ARFLAGS} ${LIBRARYDZM}.${LIBEXT} ${MOD_DBG_OBJS_}

include $(wildcard *.d)
include $(wildcard *.dz)
include $(wildcard *.dd)
include $(wildcard *.ddz)

endif

# EOF