# Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

# ARMv5 EXE/DLL ABIv2 Function Like Makefile (FLM)

# Knows how to build all possible ABIV2 executables for ARM

#

#

# Only build feature invariant binaries in non-product builds *and*

# Only build feature variant binaries in product builds.

#

# FEATUREVARIANTNAME != "" implies product build

# FEATUREVARIANT == 1 implies a feature variant binary

#

# test FEATUREVARIANTNAME=="" or FEATUREVARIANT==1

#

ifneq ($(or $(call equal,$(FEATUREVARIANTNAME),),$(call equal,$(FEATUREVARIANT),1)),)

$(if $(FLMDEBUG),$(info <flm name='e32abiv2' target='$(TARGET)' type='$(TARGETTYPE)' outputpath='$(OUTPUTPATH)' metasource='$(METASOURCE)' postlinkfiletype='$(POSTLINKFILETYPE)' />))

# Strip switch-type parameters

#

POSTLINKTARGETTYPE:=$(strip $(POSTLINKTARGETTYPE))

UID1:=$(strip $(UID1))

UID2:=$(strip $(UID2))

UID3:=$(strip $(UID3))

SID:=$(strip $(SECUREID))

VENDORID:=$(strip $(VENDORID))

AUTOEXPORTS:=$(strip $(AUTOEXPORTS))

DEFFILE:=$(strip $(DEFFILE))

IMPORTLIBRARYREQUIRED:=$(strip $(IMPORTLIBRARYREQUIRED))

EPOCALLOWDLLDATA:=$(strip $(EPOCALLOWDLLDATA))

PAGED:=$(strip $(PAGED))

# the output directories

VARIANTPLATFORM:=$(VARIANTPLATFORM)$(FEATUREVARIANTNAME)

RELEASABLEPATH:=$(RELEASEPATH)/$(VARIANTPLATFORM)/$(VARIANTTYPE)

INTERMEDIATEPATH:=$(OUTPUTPATH)/$(VARIANTPLATFORM)/$(VARIANTTYPE)

INTERMEDIATE_PLATFORM_PATH:=$(OUTPUTPATH)/$(VARIANTPLATFORM)

TRACE_MARKER_PATH:=$(OUTPUTPATH)

IMPORTLIBPATH:=$(RUNTIME_LIBS_PATH)

# LOCALLY USED VARIABLES

CLEANTARGETS:=

WHATRELEASE:=

# Work out which new/delete library to use for binaries.

CHECKLIB_TYPE:=symc++

STDCPPTAGFILE:=

ifeq ($(NOSTDCPP),1)

  ifeq ($(STDCPP),1)

    $(info <warning>STDCPP and NOSTDCPP both specified in $(PROJECT_META)</warning>)

  else

    ifeq ($(HAS_DEDICATED_OP_NEWDEL_LIB),1)

      DEFAULT_NEWLIB:=$(DEFAULT_SYMBIAN_NEWLIB)

    endif

  endif

else

  ifeq ($(STDCPP),1)

    CDEFS:=$(CDEFS) __SYMBIAN_STDCPP_SUPPORT__

    ifneq ($(SUPPORTS_STDCPP_NEWLIB),)

      ifeq ($(HAS_DEDICATED_OP_NEWDEL_LIB),1)

        DEFAULT_NEWLIB:=$(DEFAULT_STDCPP_NEWLIB)

      endif

      CHECKLIB_TYPE:=stdc++

      STDCPPTAGFILE:=$(EPOCROOT)/epoc32/tools/tag/tag_elf

    endif

  endif

endif

# If NEWLIB is specified in the MMP file, it overrides all the past stuff.

ifeq ($(NEWLIB),)

  NEWLIB:=$(DEFAULT_NEWLIB)

endif

##########################################################################

## OUTPUTS - externally relevant targets that this FLM generates

ifeq ($(EXPORTLIBRARY),)

  EXPORTLIBRARY:=$(TARGET)

endif

# This will insert the file version between the name and the extension.

# If there is more than one dot in generated filename the inserted position will be

# BEFORE the last but two dot. E.g name1.name2.name3.dll to name1.name2{version}.name3.dll

LIBEXT:=$(lastword $(subst .,$(CHAR_SPACE) ,$(EXPORTLIBRARY)))

LIBBASE:=$(patsubst %.$(LIBEXT),%,$(EXPORTLIBRARY))

ifneq ($(findstring .,$(EXPORTLIBRARY)),)

  # Please note $(EXPORTLIBRARY) doesn't include target type.

  VER_E32IMPORTLIBBASE:=$(IMPORTLIBPATH)/$(LIBBASE){$(VERSIONHEX)}.$(LIBEXT)

else

  VER_E32IMPORTLIBBASE:=$(IMPORTLIBPATH)/$(EXPORTLIBRARY){$(VERSIONHEX)}

endif

# Postlinkable targets need to be linked and elf2e32'd

ifneq ($(DOPOSTLINK),)

    E32TARGET:=$(RELEASABLEPATH)/$(TARGET)$(if $(EXPLICITVERSION),{$(VERSIONHEX)},).$(if $(REQUESTEDTARGETEXT),$(REQUESTEDTARGETEXT),$(POSTLINKFILETYPE))

    LINK_TARGET:=$(RELEASABLEPATH)/$(TARGET)$(if $(EXPLICITVERSION),{$(VERSIONHEX)},).$(if $(REQUESTEDTARGETEXT),$(REQUESTEDTARGETEXT),$(POSTLINKFILETYPE)).sym

    MAPFILE:=$(RELEASABLEPATH)/$(TARGET).$(if $(REQUESTEDTARGETEXT),$(REQUESTEDTARGETEXT),$(POSTLINKFILETYPE)).map

else

  E32TARGET:=

  LINK_TARGET:=

  MAPFILE:=

endif

# libs and klibs, on the other hand need to be archived

ifneq ($(call isoneof,$(TARGETTYPE),lib klib stdlib),)

  ARTARGET:=$(RELEASABLEPATH)/$(TARGET).lib

  # We need libs and klibs before we can link stuff with them:

  LIBRARY:: $(ARTARGET)

else

  ARTARGET:=

endif

ifneq ($(IMPORTLIBRARYREQUIRED),) # no dso files for plugins, animation dlls etc

  # make sure we don't build import libraries more than once for UDEB and UREL

  # Without this, wierd target-specific variable problems happen with LIBRARY in particular

  TMP_IMPORTLIBTARGET_ROOT:=$(IMPORTLIBPATH)/$(EXPORTLIBRARY)

  # ABIv2 .dso

  IMPORTLIBTARGET_DSO:=

  IMPORTLIBTARGETVERSIONED_DSO:=

  BUILDMARKER_IMPORTLIBTARGET_DSO:=TARGET_$(subst :,,$(VER_E32IMPORTLIBBASE)).dso

  WHATRELEASE:=$(WHATRELEASE) $(if $(EXPLICITVERSION),,$(TMP_IMPORTLIBTARGET_ROOT).dso)

  WHATRELEASE:=$(WHATRELEASE) $(VER_E32IMPORTLIBBASE).dso

  ifeq ($($(BUILDMARKER_IMPORTLIBTARGET_DSO)),)

    IMPORTLIBTARGET_DSO:=$(TMP_IMPORTLIBTARGET_ROOT).dso

    IMPORTLIBTARGETVERSIONED_DSO:=$(VER_E32IMPORTLIBBASE).dso

  endif

  # ABIv1 .lib (for specific builds, toolchains and host OS platforms only)

  IMPORTLIBTARGET_LIB:=

  IMPORTLIBTARGETVERSIONED_LIB:=

  BUILDMARKER_IMPORTLIBTARGET_LIB:=TARGET_$(subst :,,$(VER_E32IMPORTLIBBASE)).lib

  # Only for builds that require and support them, and only on windows

  ifeq ($(OSTYPE),cygwin)

  ifeq ($(GENERATE_ABIV1_IMPLIBS),1)

    WHATRELEASE:=$(WHATRELEASE) $(if $(EXPLICITVERSION),,$(TMP_IMPORTLIBTARGET_ROOT).lib)

    WHATRELEASE:=$(WHATRELEASE) $(VER_E32IMPORTLIBBASE).lib

    ifeq ($($(BUILDMARKER_IMPORTLIBTARGET_LIB)),)

      IMPORTLIBTARGET_LIB:=$(TMP_IMPORTLIBTARGET_ROOT).lib

      IMPORTLIBTARGETVERSIONED_LIB:=$(VER_E32IMPORTLIBBASE).lib

    endif

  endif

  endif

endif

# Try to make sure that we get the right linkas name

# If linkas is specified then split it up and

# put the hex version number in the right place

ifeq ($(LINKAS),)

  LINKASNAME=$(TARGET)

  LINKASTYPE=$(if $(REQUESTEDTARGETEXT),$(REQUESTEDTARGETEXT),$(POSTLINKFILETYPE))

else

  SPLIT_LINKAS=$(subst ., ,$(LINKAS))

  LINKASNAME=$(word 1,$(SPLIT_LINKAS))

  LINKASTYPE=$(word 2,$(SPLIT_LINKAS))

endif

# ignore UID3 if it is zero

ifeq ($(UID3),00000000)

  LINKASVERSIONED=$(LINKASNAME){$(VERSIONHEX)}.$(LINKASTYPE)

else

  LINKASVERSIONED=$(LINKASNAME){$(VERSIONHEX)}$(if $(UID3),[$(UID3)],).$(LINKASTYPE)

endif

##########################################################################

## TARGET GROUPS ##

RELEASABLES:=$(strip $(E32TARGET) $(ARTARGET) $(LINK_TARGET) $(MAPFILE))

# More targets to be added later

TARGETS:=$(strip $(E32TARGET) $(IMPORTLIBTARGET) $(LINK_TARGET) $(ARTARGET))

CREATABLEPATHS:=$(OUTPUTPATH)

CREATABLEPATHS:=$(CREATABLEPATHS) $(INTERMEDIATE_PLATFORM_PATH)

CREATABLEPATHS:=$(CREATABLEPATHS) $(INTERMEDIATEPATH)

CREATABLEPATHS:=$(CREATABLEPATHS) $(RELEASABLEPATH)

CREATABLEPATHS:=$(CREATABLEPATHS) $(RUNTIME_LIBS_PATH)

CREATABLEPATHS:=$(CREATABLEPATHS) $(IMPORTLIBPATH)

WHATRELEASE:=$(WHATRELEASE) $(RELEASABLES)

## HIGH LEVEL Targets ##

.PHONY:: $(ALLTARGET)

## GLOBAL TARGETS ############################################################

$(ALLTARGET):: $(RELEASABLES)

TARGET:: $(RELEASABLES)

## Internal targets ##

# Determine the name of the generated DSO file ###############################

# This is to generate the dso with the Some{Versionhex}.file.dso

# It reproduces what appears to be a problem in the current build system

# that affects messageintercept{000a0000}.esockdebug.dso whose

# filename differs from it's "linkas" name.

E32VAR:=$(subst .,$(CHAR_SPACE) ,$(TARGET))

E32SOME:=$(word 1,$(E32VAR))

E32VAR2:=$(patsubst $(E32SOME).%,%,$(TARGET))

# Separate '_SH' variables created for output into bash - Preserves '{' and '}'

ifneq ($(findstring .,$(TARGET)),)

	DSODEFFILENAMEBASE:=$(E32SOME){$(VERSIONHEX)}.$(E32VAR2)

else

	DSODEFFILENAMEBASE:=$(TARGET){$(VERSIONHEX)}

endif

GENERATED_DSO:=$(call dblquote,$(INTERMEDIATEPATH)/$(DSODEFFILENAMEBASE).dso)

GENERATED_DEFFILE:=$(INTERMEDIATEPATH)/$(DSODEFFILENAMEBASE).def

## IMPORT LIBRARY  ###########################################################

# Static libraries will be postlinked when they are used so don't try to postlink them

ifneq ($(IMPORTLIBRARYREQUIRED),)

ifneq ($(or $(DEFFILE),$(EXPORTUNFROZEN)),)

# Both ABIv2 .dso and ABIv1 .lib import library generation require a processed .def file,

# unless EXPORTUNFROZEN is being used

PREPPEDDEFFILE:=

ifneq ($(DEFFILE),)

  ifeq ($(EXPORTUNFROZEN),)

    PREPPEDDEFFILE:=$(INTERMEDIATEPATH)/$(TARGET).prep

    CLEANTARGETS:=$(CLEANTARGETS) $(PREPPEDDEFFILE)

    define importlibtarget_prepfile

      $(PREPPEDDEFFILE): $(DEFFILE)

		$(call startrule,importlibtarget_prepfile,FORCESUCCESS) \

		$(PREPDEF) $(call dblquote,$(DEFFILE)) $(call dblquote,$(PREPPEDDEFFILE)) \

		$(call endrule,importlibtarget_prepfile)

    endef

    $(eval $(importlibtarget_prepfile))

  endif

endif

# ABIv2 .dso

ifneq ($(IMPORTLIBTARGET_DSO),) # check that we haven't tried to specify this target already

  # By Now we're committed to producing a target for this DSO so it's safe to

  # set the marker that will prevent any further targets from being made.

  $(eval $(BUILDMARKER_IMPORTLIBTARGET_DSO):=1)

  ifneq ($(EXPLICITVERSION),)

    TARGETS:=$(strip $(TARGETS) $(IMPORTLIBTARGETVERSIONED_DSO))

    # Add this importlibrary to our global targets

    LIBRARY:: $(IMPORTLIBTARGETVERSIONED_DSO)

    $(ALLTARGET):: $(IMPORTLIBTARGETVERSIONED_DSO)

    TARGET:: $(IMPORTLIBTARGETVERSIONED_DSO)

  else

    TARGETS:=$(strip $(TARGETS) $(IMPORTLIBTARGETVERSIONED_DSO) $(IMPORTLIBTARGET_DSO))

    # Add this importlibrary to our global targets

    LIBRARY:: $(IMPORTLIBTARGET_DSO)

    $(ALLTARGET):: $(IMPORTLIBTARGETVERSIONED_DSO) $(IMPORTLIBTARGET_DSO)

    TARGET:: $(IMPORTLIBTARGETVERSIONED_DSO) $(IMPORTLIBTARGET_DSO)

  endif

  ifneq ($(EXPORTUNFROZEN),) # Unfrozen  - warn and create .dso as side-effect of the final postlink

    $(info <warning project='$(PROJECT_META)' component='$(COMPONENT_META)'>EXPORTUNFROZEN present in $(PROJECT_META) - unfrozen exports will be represented in import library.</warning> )

    define importlibtarget_unfrozen

      $(IMPORTLIBTARGET_DSO): $(IMPORTLIBTARGETVERSIONED_DSO)

		$(call startrule,importlibtarget_unfrozen,FORCESUCCESS) \

		$(GNUCP) $$(call dblquote,$$<) $$(call dblquote,$$@) \

		$(call endrule,importlibtarget_unfrozen)

    endef

    define importlibtarget_unfrozen_ver

      $(IMPORTLIBTARGETVERSIONED_DSO): $(E32TARGET)

		$(call startrule,importlibversioned_unfrozen,FORCESUCCESS) \

		$(GNUCP) "$(GENERATED_DSO)" "$$@" \

		$(call endrule,importlibversioned_unfrozen)

    endef

    ifeq ($(EXPLICITVERSION),)

      # Generate the general dso if we aren't

      # being asked to make just the specific version.

      $(eval $(importlibtarget_unfrozen))

    endif

    $(eval $(importlibtarget_unfrozen_ver))

  else

    ifneq ($(DEFFILE),) # Frozen - use the def file and create .dso directly

      define importlibtarget_func

       $(IMPORTLIBTARGET_DSO): $(IMPORTLIBTARGETVERSIONED_DSO)

	   $(call startrule,importlibtarget,FORCESUCCESS) \

	   $(GNUCP) "$$<" "$$@" \

	   $(call endrule,importlibtarget)

      endef

      ifeq ($(EXPLICITVERSION),)

          # Generate the general dso if we aren't

          # being asked to make just the specific version.

          $(eval $(importlibtarget_func))

      endif

      define importlibtargetversioned_func

        $(IMPORTLIBTARGETVERSIONED_DSO): $(ELF2E32) $(PREPPEDDEFFILE)

	      $(call startrule,importlibversioned,FORCESUCCESS) \

	      $(ELF2E32) --sid=0x$(if $(SID),$(SID),$(if $(UID3),$(UID3),0))  --version=$(VERSION)  	   \

	 	  --definput="$(PREPPEDDEFFILE)" 				   \

	 	  --dso=$$(call dblquote,$$@) 				   \

	 	  --linkas=$(call dblquote,$(LINKASVERSIONED)) \

	      $(call endrule,importlibversioned)

      endef

      $(eval $(importlibtargetversioned_func))

    endif #  ifneq ($(DEFFILE),)

  endif #  ifneq ($(EXPORTUNFROZEN),)

endif #  ifneq ($(IMPORTLIBTARGET_DSO),)

# ABIv1 .lib

ifneq ($(IMPORTLIBTARGETVERSIONED_LIB),) # check that we haven't tried to specify this target already

  # By Now we're committed to producing a target for this DSO so it's safe to

  # set the marker that will prevent any further targets from being made.

  $(eval $(BUILDMARKER_IMPORTLIBTARGET_LIB):=1)

  define abiv1_generatelib

    ifeq ($(EXPLICITVERSION),)

      LIBRARY:: $(IMPORTLIBTARGETVERSIONED_LIB) $(IMPORTLIBTARGET_LIB)

    else

      LIBRARY:: $(IMPORTLIBTARGETVERSIONED_LIB)

    endif

    # If frozen, a prepped .def file is used as the basis for .lib creation

    # If unfrozen, .lib files are based on the .def file generated by the final postlink

    $(IMPORTLIBTARGETVERSIONED_LIB): $(if $(EXPORTUNFROZEN),$(E32TARGET),$(PREPPEDDEFFILE))

	$(call startrule,importlibversioned_abiv1) \

        if [ -f "$(EPOCROOT)/epoc32/tools/def2dll.pl" -a -f "$(if $(EXPORTUNFROZEN),$(call dblquote,$(GENERATED_DEFFILE)),$(PREPPEDDEFFILE))" ]; then \

                 $(PERL) $(EPOCROOT)/epoc32/tools/def2dll.pl \

		--path=$(IMPORTLIBPATH) \

		--bldpath=$(INTERMEDIATEPATH) \

		--import=$(notdir $(basename $(IMPORTLIBTARGETVERSIONED_LIB))) \

		--deffile="$(if $(EXPORTUNFROZEN),$(call dblquote,$(GENERATED_DEFFILE)),$(PREPPEDDEFFILE))" \

		--linkAs=$(call dblquote,$(LINKASVERSIONED)) \

		--inter ; fi \

	$(call endrule,importlibversioned_abiv1)

    ifeq ($(EXPLICITVERSION),)

      $(IMPORTLIBTARGET_LIB): $(IMPORTLIBTARGETVERSIONED_LIB)

	$(call startrule,importlibtarget_abiv1) \

	if [ -f $(EPOCROOT)/epoc32/tools/def2dll.pl ]; then $(GNUCP) "$$<" "$$@" ; fi \

	$(call endrule,importlibtarget_abiv1)

    endif

  endef

  $(eval $(abiv1_generatelib))

endif #  ifneq ($(IMPORTLIBTARGET_LIB),)

endif #  ($(or $(DEFFILE),$(EXPORTUNFROZEN)),)

endif #  ifneq ($(IMPORTLIBRARYREQUIRED),)

## POSTLINK ##################################################################

# Set up the name of the exports file if this is a customdll

EXPTARGET:=

ifneq ($(DOPOSTLINK),)

  ifneq ($(and $(or $(STATICLIBRARY),$(ARMLIBS),$(ARMRT)),$(DEFFILE)),)

    EXPTARGET:=$(INTERMEDIATE_PLATFORM_PATH)/$(notdir $(VER_E32IMPORTLIBBASE)).exp

  endif

endif

# Generating the import library is enough if TARGETTYPE=implib #############

ifneq ($(DOPOSTLINK),)

# Capabilities

ADDED_CAPABILITIES:=$(subst $(CHAR_SPACE),+,$(filter-out -%,$(CAPABILITY)))

SUBTRACTED_CAPABILITIES:=$(subst $(CHAR_SPACE),,$(filter -%,$(CAPABILITY)))

FINAL_CAPABILITIES:=$(if $(ADDED_CAPABILITIES),$(ADDED_CAPABILITIES)$(SUBTRACTED_CAPABILITIES),NONE)

# Paging options for the old postlinker

POSTLINKER_PAGEDOPTION:=--defaultpaged

ifeq ($(PAGED),1)

  POSTLINKER_PAGEDOPTION:=--paged

endif

ifeq ($(PAGED),0)

  POSTLINKER_PAGEDOPTION:--unpaged

endif

CLEANTARGETS:=$(CLEANTARGETS) $(E32TARGET)

CLEANTARGETS:=$(CLEANTARGETS) $(GENERATED_DEFFILE)

CLEANTARGETS:=$(CLEANTARGETS) $(GENERATED_DSO)

endif # ifneq ($(DOPOSTLINK),)

ifneq ($(TARGETTYPE),implib)

## CUSTOM DLLS ###############################################################

# exp file

#

# This tends to help getting exported objects

# out of the arm libs and into custom dlls.

ifneq ($(EXPTARGET),)

ifeq ($(TARGET_$(EXPTARGET)),)

# We only need one of these exptargets for UDEB and UREL

TARGET_$(EXPTARGET):=1

EXPTARGETASMFILE:=$(INTERMEDIATE_PLATFORM_PATH)/$(notdir $(VER_E32IMPORTLIBBASE)).s

define e32expgen_func

$(EXPTARGET): $(DEFFILE) $(ELF2E32)

	$(call startrule,expgen) \

	$(ELF2E32) \

	   --definput=$$(call dblquote,$(DEFFILE)) \

	   --dump=a \

	   --output=$(call dblquote,$(EXPTARGETASMFILE)) && \

	$(ASM) $(TARGET_ARCH_OPTION) $(AAPCS_OPTION) $(ASM_OUTPUT_OPTION) $$(call dblquote, $$@) $(EXPTARGETASMFILE) \

	$(call endrule,expgen)

endef

$(eval $(e32expgen_func))

CLEANTARGETS:=$(CLEANTARGETS) $(EXPTARGET) $(EXPTARGETASMFILE)

endif

endif

## SOURCE FILES ##############################################################

# Source files can be either C++ files (.cpp) or Assmbler-in-C++ files (.cia)

# We have to split the two because they have the same link stage, the compile

# stage is different for each.

CPPFILEEXTENSIONS:=.cpp .CPP .Cpp .CPp .CpP .cPP .cpP .cPp .cc .CC \

	.Cc .c++ .C++ .cxx .CXX .Cxx .cXx .CxX .CXx .cC .cXX .cxX

CFILEEXTENSIONS:=.c .C

CIAFILEEXTENSIONS:=.CIA .cia .Cia .cIa .cIA .ciA .CIa .CiA

ASMFILEEXTENSIONS:=.s .S

# Extract the CPP files from our sources

CPPFILES:=$(call extractfilesoftype,$(CPPFILEEXTENSIONS),$(SOURCE))

CFILES:=$(call extractfilesoftype,$(CFILEEXTENSIONS),$(SOURCE))

ASMFILES:=$(call extractfilesoftype,$(ASMFILEEXTENSIONS),$(SOURCE))

# Find out what assember-in-c files there are

# If appropriate, work out what CPP files will be created from the assembler files

CIAFILES:=$(call extractfilesoftype,$(CIAFILEEXTENSIONS),$(SOURCE))

CIA_CPPFILES:=

ifeq ($(TRANSFORM_CIA),1)

  CIA_CPPFILES:=$(call relocatefiles,$(INTERMEDIATEPATH),$(call extractandmap,$(CIAFILEEXTENSIONS),_.cpp,$(CIAFILES)))

else

endif

## LINK ######################################################################

# Bring together all the .o files compiled from  .cpp, .c, .s and .cia files.

# These files are stored in the "non-releasable" output diretory.

define mapcpp2object

$(call relocatefiles,$(INTERMEDIATEPATH),$(call extractandmap,$(CPPFILEEXTENSIONS),.o,$1))

endef

define mapc2object

$(call relocatefiles,$(INTERMEDIATEPATH),$(call extractandmap,$(CFILEEXTENSIONS),.o,$1))

endef

define mapasm2object

$(call relocatefiles,$(INTERMEDIATEPATH),$(call extractandmap,$(ASMFILEEXTENSIONS),.o,$1))

endef

define mapcia2object

$(call relocatefiles,$(INTERMEDIATEPATH),$(call extractandmap,$(CIAFILEEXTENSIONS),_.o,$1))

endef

# Determine what object files will be linked by using the source files.

CPPFILES_LINKOBJECTS:=$(call mapcpp2object,$(CPPFILES))

CFILES_LINKOBJECTS:=$(call mapc2object,$(CFILES))

ifeq ($(TRANSFORM_CIA),1) 

  CIAFILES_LINKOBJECTS:=$(patsubst %_.cpp,%_.o,$(CIA_CPPFILES))

else

  CIAFILES_LINKOBJECTS:=$(call mapcia2object,$(CIAFILES))