# Copyright (c) 2007-2010 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:

# Function Like Makefile (FLM) to create a resource header (.rsg)

# and resource files (.rsc, .r01, .r02 etc.)

#

#

## Parameters that are expected:

# TARGET

# TARGETPATH

# LANGUAGES

# HEADER

# HEADERONLY

# EPOCROOT

# MMPDEFS

# PRODUCT_INCLUDE

# SYSTEMINCLUDE

# USERINCLUDE

# GNUCPP

# GNUSED

# RCOMP

# OUTPUTPATH

# SOURCE

# BINCOPYDIRS

# The rss is pre-processed once for each language and results

# in a file with extension r$(LANGUAGE) where $(LANGUAGE) is

# either "sc" or a 2 (or more) digit number.

ifneq ($(TARGETPATH),)

RSCDIR:=$(subst //,/,$(EPOCROOT)/epoc32/data/z/$(TARGETPATH))

else

RSCDIR:=$(subst //,/,$(EPOCROOT)/epoc32/data)

endif

RESBASE:=$(RSCDIR)/$(TARGET_lower)

# Ensure that RELEASABLES and CLEANTARGETS cannot expand indefinitely in successive calls to this flm:

CLEANTARGETS:=

RELEASABLES:=

CREATABLEPATHS:=

# There is only one resource header (.rsg) file and we only

# make that if we are asked.

RSGDIR:=$(EPOCROOT)/epoc32/include

# If there are multiple LANGUAGES then it is the last one in the list

# which produces the header.

HEADLANG:=$(lastword $(LANGUAGES:SC=sc))

ifneq ($(or $(HEADER),$(HEADERONLY)),)

        RESOURCEHEADER:=$(RSGDIR)/$(HEADER)

else

        RESOURCEHEADER:=

endif

# we create intermediate .rpp and .d files

INTERBASE_TMP:=$(OUTPUTPATH)/$(TARGET_lower)_$(notdir $(basename $(SOURCE)))

LANGUAGES:=$(LANGUAGES:SC=sc) # ensure that we don't ever have to worry about case consistency w.r.t languages or get confused into thinking that SC!=sc (which it is)

LANGUAGES:=$(call uniq,$(LANGUAGES)) # remove any duplicates from the list (usually the result of multiple LANG lists both in and out of START RESOURCE blocks)

# common pre-processor options

# We really should be using -iquote with a recent cpp.  This is a note for when we do update:

#CPPOPT:=-nostdinc -undef -Wno-trigraphs -D_UNICODE -include $(PRODUCT_INCLUDE)\

# -I$(dir $(SOURCE)) $(foreach I, $(USERINCLUDE),-iquote $(I) ) $(foreach J,$(SYSTEMINCLUDE),-I $(J) )

CPPOPT:=-nostdinc -undef -Wno-trigraphs -D_UNICODE -include $(PRODUCT_INCLUDE)\

 -I$(dir $(SOURCE)) $(foreach I, $(USERINCLUDE),-I$(I) ) -I- $(foreach J,$(SYSTEMINCLUDE),-I$(J) )

CREATABLEPATHS:=$(CREATABLEPATHS) $(RSCDIR) $(RSGDIR) $(OUTPUTPATH) 

# We intend to generate the resource in an intermediate location and copy to the targetpath to

# ensure that when the "same" resource is built into separare target paths, it doesn't have to be 

# completely recreated each time - just copied.

RSCCOPYDIRS:=$(RSCDIR)

# additional binary resource copies performed based on BINCOPYDIRS

ifneq ($(BINCOPYDIRS),)

        RSCCOPYDIRS:=$(RSCCOPYDIRS) $(subst //,/,$(patsubst %,%/$(if $(TARGETPATH),/z/$(TARGETPATH),),$(BINCOPYDIRS)))

endif

CREATABLEPATHS:=$(CREATABLEPATHS) $(RSCCOPYDIRS)

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

# Correct dependency information when a header file can't be found.

# If the c preprocessor can't find a dependency it appears as it did in the #include statement

# e.g. "filename.mbg" or "filename.rsg" in the dependency file.

ifneq ($(NO_DEPEND_GENERATE),)

  # This version minimises the size of dependency files, to contain only .mbg and .rsg deps.

  # It allows resources to be built in the right order but doesn't impose the weight of

  # of full dependency information which can overwhelm make in large builds.

  # The strategy is filter lines which don't have .rsg or .mbg dependencies in them and

  # to sift each line to leave out non-relevant things like other header files, .hrh 

  # files etc.  In the end don't print anything at all if we did not find the target.

  define  DEPENDENCY_CORRECTOR

  { $(DEPCRUNCH) --extensions rsg,mbg --assume '$(EPOCROOT)/epoc32/include' ; } 

  endef

else

  # This can correct the dependencies by assuming that the file will be in epoc32\include as this is the default

  DEPENDENCY_CORRECTOR:=$(GNUSED)  -r 's% ([^ \/]+\.((rsg)|(mbg)))% $(EPOCROOT)\/epoc32\/include\/\1%ig' 

endif

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

# Include all the macros - but not if it has been done already

ifeq ($(include_resource_mk),)

include_resource_mk:=1

include $(FLMHOME)/resource.mk

endif

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

## Generate a string of resourcefiles optionally with a header OR

## just a header (HEADERONLY)

ifeq ($(HEADERONLY),)  # i.e IF NOT HEADERONLY

  # The resources that are not for the "HEADER language" will all depend on

  # that "headlang resource" - they will "sit in its dependency slipstream"

  # or in other words We only have to make one dependency file because

  # all of the other languages will benefit from it indirectly through their

  # dependency on the header language.

  # The guard is based on the languages we're building so that 2 resource blocks can 

  # create different languages if so needed (no known reason for this but someone

  # could do it and in the past it would have worked).

  GUARD:=TARGET_$(call sanitise,$(INTERBASE_TMP))

  $(if $(FLMDEBUG),$(info <debug>resource.flm: $(GUARD)=$($(GUARD)) LANGUAGES:=$(LANGUAGES)</debug>))

  # Don't generate new rules for languages we've already seen for this resource file

  # i.e. this allows one to define a single resource using two startresource blocks.

  #  each of which specifies one half of the languages.

  REMAINING_LANGUAGES:=$(filter-out $($(GUARD)),$(LANGUAGES))

  $(if $(FLMDEBUG),$(info <debug>resource.flm:  REMAINING_LANGUAGES=$(REMAINING_LANGUAGES)</debug>))

  ifneq ($(REMAINING_LANGUAGES),)

    $(GUARD):=$($(GUARD)) $(REMAINING_LANGUAGES)

    LANGUAGES:=$(REMAINING_LANGUAGES)

    # PRIMARYFILE is the resource that will have a dependency file and that all the other

    # resources will depend on. 

    PRIMARYFILE:=$(INTERBASE_TMP).r$(HEADLANG)

    DEPENDFILENAME:=$(INTERBASE_TMP).r$(HEADLANG).d

    $(if $(FLMDEBUG),$(info <debug>resource.flm:  in guard with primary file=$(PRIMARYFILE)</debug>))

    ifeq "$(MAKEFILE_GROUP)" "RESOURCE_DEPS"

      # Generate PRIMARYFILE's dependencies

      $(eval $(call resource.deps,$(INTERBASE_TMP).r$(HEADLANG),$(HEADLANG),$(DEPENDFILENAME)))

    else

        RESOURCE:: $(PRIMARYFILE)

        # invoke the macro that creates targets for building resources, once per language

        # For sc we generate $(INTERBASE_TMP).rsc and define LANGUAGE_SC and LANGUAGE_sc.

        $(foreach L,$(LANGUAGES),$(eval $(call resource.build,$(INTERBASE_TMP).r$(L),$(L),$(TARGET_lower).r$(L))))

        DEPENDFILE:=$(wildcard $(DEPENDFILENAME))

        ifneq "$(DEPENDFILE)" ""

          ifeq "$(filter %CLEAN,$(call uppercase,$(MAKECMDGOALS)))" ""

             -include $(DEPENDFILE)

          endif

        endif

    endif

  endif

  ifneq "$(MAKEFILE_GROUP)" "RESOURCE_DEPS"

    # Whether or not we have generated this resource for some other start

    # resource block, check if there are any new copies to be made for

    # this variant. e.g. winscw requires that we make some extra copies.

    # We tried to copy after running rcomp itself but we still need these

    # targets for the sake of dependencies or, for example, if someone

    # merely adds a new copy when the resource is up-to-date

    $(foreach L,$(LANGUAGES),$(eval $(call resource.makecopies,$(INTERBASE_TMP).r$(L),$(TARGET_lower).r$(L))))

  endif

else

  #

  # HEADERONLY was specified

  #

  GUARD:=TARGET_$(call sanitise,$(INTERBASE_TMP))_rsg

  $(if $(FLMDEBUG),$(info <debug>resource.flm: Headeronly $(INTERBASE_TMP) $(TARGET_lower).rsg LANGUAGES:=$(LANGUAGES)</debug>))

  ifeq ($($(GUARD)),)

      $(GUARD):=1  

      $(eval $(call resource.headeronly,$(INTERBASE_TMP),$(HEADLANG)))

      # The headeronly macro manages dependency including on its own

  endif

endif

ifneq "$(MAKEFILE_GROUP)" "RESOURCE_DEPS"

# Add header to releasables anyway despite guard since sone things

# like the abldcache want to see the rsg for each platform even

# if we only declare one rule.

# If there's no header then it will be blank which is fine.

RELEASABLES:=$(RELEASABLES) $(RESOURCEHEADER)

endif

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

## .rfi generation in support of the gccxml build

## Note that .rfi files are created from the dependency files generated from preprocessing resources to create .rpp files

ifneq ($(RFIFILE),)

  RESOURCE:: $(RFIFILE)

  RELEASABLES:=$(RELEASABLES) $(RFIFILE)

  CREATABLEPATHS:=$(CREATABLEPATHS) $(dir $(RFIFILE))/

  $(eval $(call generaterfifile,$(RFIFILE),$(PRIMARYFILE).d))

endif

## Clean up

$(call raptor_clean,$(CLEANTARGETS))

# make the output directories while reading makefile - some build engines prefer this

$(call makepath,$(CREATABLEPATHS))

# for the --what option and the log file

$(call raptor_release,$(RELEASABLES),RESOURCE)