#

# This Source Code Form is subject to the terms of the Mozilla Public

# License, v. 2.0. If a copy of the MPL was not distributed with this

# file, You can obtain one at http://mozilla.org/MPL/2.0/.

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

###                                                                 ###

###              R U L E S   O F   E N G A G E M E N T              ###

###                                                                 ###

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

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

# Double-Colon rules for utilizing the binary release model.          #

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

all:: export libs 

ifeq ($(AUTOCLEAN),1)

autobuild:: clean export private_export libs program install

else

autobuild:: export private_export libs program install

endif

platform::

	@echo $(OBJDIR_NAME)

ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

USE_NT_C_SYNTAX=1

endif

#

# IMPORTS will always be associated with a component.  Therefore,

# the "import" rule will always change directory to the top-level

# of a component, and traverse the IMPORTS keyword from the

# "manifest.mn" file located at this level only.

#

# note: if there is a trailing slash, the component will be appended

#       (see import.pl - only used for xpheader.jar)

import::

	@echo "== import.pl =="

	@$(PERL) -I$(CORE_DEPTH)/coreconf $(CORE_DEPTH)/coreconf/import.pl \

		"RELEASE_TREE=$(RELEASE_TREE)"   \

		"IMPORTS=$(IMPORTS)"             \

		"VERSION=$(VERSION)" \

		"OS_ARCH=$(OS_ARCH)"             \

		"PLATFORM=$(PLATFORM)" \

		"OVERRIDE_IMPORT_CHECK=$(OVERRIDE_IMPORT_CHECK)"   \

		"ALLOW_VERSION_OVERRIDE=$(ALLOW_VERSION_OVERRIDE)" \

		"SOURCE_RELEASE_PREFIX=$(SOURCE_RELEASE_XP_DIR)"   \

		"SOURCE_MD_DIR=$(SOURCE_MD_DIR)"      \

		"SOURCE_XP_DIR=$(SOURCE_XP_DIR)"      \

		"FILES=$(IMPORT_XPCLASS_JAR) $(XPHEADER_JAR) $(MDHEADER_JAR) $(MDBINARY_JAR)" \

		"$(IMPORT_XPCLASS_JAR)=$(IMPORT_XP_DIR)|$(IMPORT_XPCLASS_DIR)|"    \

		"$(XPHEADER_JAR)=$(IMPORT_XP_DIR)|$(SOURCE_XP_DIR)/public/|v" \

		"$(MDHEADER_JAR)=$(IMPORT_MD_DIR)|$(SOURCE_MD_DIR)/include|"        \

		"$(MDBINARY_JAR)=$(IMPORT_MD_DIR)|$(SOURCE_MD_DIR)|"

# On Mac OS X ranlib needs to be rerun after static libs are moved.

ifeq ($(OS_TARGET),Darwin)

	find $(SOURCE_MD_DIR)/lib -name "*.a" -exec $(RANLIB) {} \;

endif

export:: 

	+$(LOOP_OVER_DIRS)

private_export::

	+$(LOOP_OVER_DIRS)

release_export::

	+$(LOOP_OVER_DIRS)

release_classes::

	+$(LOOP_OVER_DIRS)

libs program install:: $(TARGETS)

ifdef LIBRARY

	$(INSTALL) -m 664 $(LIBRARY) $(SOURCE_LIB_DIR)

endif

ifdef SHARED_LIBRARY

	$(INSTALL) -m 775 $(SHARED_LIBRARY) $(SOURCE_LIB_DIR)

ifdef MOZ_DEBUG_SYMBOLS

ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

	$(INSTALL) -m 644 $(SHARED_LIBRARY:$(DLL_SUFFIX)=pdb) $(SOURCE_LIB_DIR)

endif

endif

endif

ifdef IMPORT_LIBRARY

	$(INSTALL) -m 775 $(IMPORT_LIBRARY) $(SOURCE_LIB_DIR)

endif

ifdef PROGRAM

	$(INSTALL) -m 775 $(PROGRAM) $(SOURCE_BIN_DIR)

ifdef MOZ_DEBUG_SYMBOLS

ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

	$(INSTALL) -m 644 $(PROGRAM:$(PROG_SUFFIX)=.pdb) $(SOURCE_BIN_DIR)

endif

endif

endif

ifdef PROGRAMS

	$(INSTALL) -m 775 $(PROGRAMS) $(SOURCE_BIN_DIR)

endif

	+$(LOOP_OVER_DIRS)

tests::

	+$(LOOP_OVER_DIRS)

clean clobber::

	rm -rf $(ALL_TRASH)

	+$(LOOP_OVER_DIRS)

realclean clobber_all::

	rm -rf $(wildcard *.OBJ) dist $(ALL_TRASH)

	+$(LOOP_OVER_DIRS)

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

# Double-Colon rules for populating the binary release model.         #

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

release_clean::

	rm -rf $(SOURCE_XP_DIR)/release/$(RELEASE_MD_DIR)

release:: release_clean release_export release_classes release_policy release_md release_jars release_cpdistdir

release_cpdistdir::

	@echo "== cpdist.pl =="

	@$(PERL) -I$(CORE_DEPTH)/coreconf $(CORE_DEPTH)/coreconf/cpdist.pl \

		"RELEASE_TREE=$(RELEASE_TREE)" \

		"CORE_DEPTH=$(CORE_DEPTH)" \

		"MODULE=${MODULE}" \

		"OS_ARCH=$(OS_ARCH)" \

		"RELEASE=$(RELEASE)" \

		"PLATFORM=$(PLATFORM)" \

		"RELEASE_VERSION=$(RELEASE_VERSION)" \

		"SOURCE_RELEASE_PREFIX=$(SOURCE_RELEASE_XP_DIR)" \

		"RELEASE_XP_DIR=$(RELEASE_XP_DIR)" \

		"RELEASE_MD_DIR=$(RELEASE_MD_DIR)" \

		"FILES=$(XPCLASS_JAR) $(XPCLASS_DBG_JAR) $(XPHEADER_JAR) $(MDHEADER_JAR) $(MDBINARY_JAR) XP_FILES MD_FILES" \

		"$(XPCLASS_JAR)=$(SOURCE_RELEASE_CLASSES_DIR)|x"\

		"$(XPCLASS_DBG_JAR)=$(SOURCE_RELEASE_CLASSES_DBG_DIR)|x"\

		"$(XPHEADER_JAR)=$(SOURCE_RELEASE_XPHEADERS_DIR)|x" \

		"$(MDHEADER_JAR)=$(SOURCE_RELEASE_MDHEADERS_DIR)|m" \

		"$(MDBINARY_JAR)=$(SOURCE_RELEASE_MD_DIR)|m" \

		"XP_FILES=$(XP_FILES)|xf" \

		"MD_FILES=$(MD_FILES)|mf"

# $(SOURCE_RELEASE_xxx_JAR) is a name like yyy.jar

# $(SOURCE_RELEASE_xx_DIR)  is a name like 

release_jars::

	@echo "== release.pl =="

	@$(PERL) -I$(CORE_DEPTH)/coreconf $(CORE_DEPTH)/coreconf/release.pl \

		"RELEASE_TREE=$(RELEASE_TREE)" \

		"PLATFORM=$(PLATFORM)" \

		"OS_ARCH=$(OS_ARCH)" \

		"RELEASE_VERSION=$(RELEASE_VERSION)" \

		"SOURCE_RELEASE_DIR=$(SOURCE_RELEASE_DIR)" \

		"FILES=$(XPCLASS_JAR) $(XPCLASS_DBG_JAR) $(XPHEADER_JAR) $(MDHEADER_JAR) $(MDBINARY_JAR)" \

		"$(XPCLASS_JAR)=$(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_CLASSES_DIR)|b"\

		"$(XPCLASS_DBG_JAR)=$(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_CLASSES_DBG_DIR)|b"\

		"$(XPHEADER_JAR)=$(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_XPHEADERS_DIR)|a" \

		"$(MDHEADER_JAR)=$(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_MDHEADERS_DIR)|a" \

		"$(MDBINARY_JAR)=$(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_MD_DIR)|bi"

# Rules for releasing classes.

# We have to do some REALLY gross stuff to deal with multiple classes in one

# file, as well as nested classes, which have a filename of the form

# ContainingClass$NestedClass.class.

# RELEASE_CLASSES simply performs a required patsubst on CLASSES

# RELEASE_CLASS_PATH is RELEASE_CLASSES with the path (in ns/dist) prepended

# RELEASE_NESTED is all the nested classes in RELEASE_CLASS_PATH.  We use a

#   foreach and wildcard to get all the files that start out like one of the

#   class files, then have a $.  So, for each class file, we look for file$*

# RELEASE_FILES is the combination of RELEASE_NESTED and the class files

#   specified by RELEASE_CLASSES which have .class appended to them.  Note that

#   the RELEASE_NESTED don't need to have .class appended because they were

#   read in from the wildcard as complete filenames.

#

# The _DBG versions are the debuggable ones.

ifneq ($(CLASSES),)

RELEASE_CLASSES := $(patsubst %,%,$(CLASSES))

ifdef BUILD_OPT

	RELEASE_CLASS_PATH := $(patsubst %,$(SOURCE_CLASSES_DIR)/$(PACKAGE)/%, $(RELEASE_CLASSES))

	RELEASE_NESTED := $(foreach file,$(RELEASE_CLASS_PATH),$(wildcard $(file)$$*))

	RELEASE_FILES := $(patsubst %,%.class,$(RELEASE_CLASS_PATH)) $(RELEASE_NESTED)

else

	RELEASE_DBG_CLASS_PATH:= $(patsubst %,$(SOURCE_CLASSES_DBG_DIR)/$(PACKAGE)/%, $(RELEASE_CLASSES))

	RELEASE_DBG_NESTED := $(foreach file,$(RELEASE_DBG_CLASS_PATH),$(wildcard $(file)$$*))

	RELEASE_DBG_FILES := $(patsubst %,%.class,$(RELEASE_DBG_CLASS_PATH)) $(RELEASE_DBG_NESTED)

endif

# Substitute \$ for $ so the shell doesn't choke

ifdef BUILD_OPT

release_classes::

	$(INSTALL) -m 444 $(subst $$,\$$,$(RELEASE_FILES)) $(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_CLASSES_DIR)/$(PACKAGE)

else

release_classes::

	$(INSTALL) -m 444 $(subst $$,\$$,$(RELEASE_DBG_FILES)) $(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_CLASSES_DBG_DIR)/$(PACKAGE)

endif

endif

release_policy::

	+$(LOOP_OVER_DIRS)

ifndef NO_MD_RELEASE

    ifdef LIBRARY

        MD_LIB_RELEASE_FILES +=  $(LIBRARY)

    endif

    ifdef SHARED_LIBRARY

        MD_LIB_RELEASE_FILES +=  $(SHARED_LIBRARY)

    endif

    ifdef IMPORT_LIBRARY

        MD_LIB_RELEASE_FILES +=  $(IMPORT_LIBRARY)

    endif

    ifdef PROGRAM

        MD_BIN_RELEASE_FILES +=  $(PROGRAM)

    endif

    ifdef PROGRAMS

        MD_BIN_RELEASE_FILES +=  $(PROGRAMS)

    endif

endif

release_md::

ifneq ($(MD_LIB_RELEASE_FILES),)

	$(INSTALL) -m 444 $(MD_LIB_RELEASE_FILES) $(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_LIB_DIR)

endif

ifneq ($(MD_BIN_RELEASE_FILES),)

	$(INSTALL) -m 555 $(MD_BIN_RELEASE_FILES) $(SOURCE_RELEASE_PREFIX)/$(SOURCE_RELEASE_BIN_DIR)

endif

	+$(LOOP_OVER_DIRS)

alltags:

	rm -f TAGS

	find . -name dist -prune -o \( -name '*.[hc]' -o -name '*.cp' -o -name '*.cpp' \) -print | xargs etags -a

	find . -name dist -prune -o \( -name '*.[hc]' -o -name '*.cp' -o -name '*.cpp' \) -print | xargs ctags -a

$(PROGRAM): $(OBJS) $(EXTRA_LIBS)

	@$(MAKE_OBJDIR)

ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

	$(MKPROG) $(subst /,\\,$(OBJS)) -Fe$@ -link $(LDFLAGS) $(subst /,\\,$(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS))

ifdef MT

	if test -f $@.manifest; then \

		$(MT) -NOLOGO -MANIFEST $@.manifest -OUTPUTRESOURCE:$@\;1; \

		rm -f $@.manifest; \

	fi

endif	# MSVC with manifest tool

else

	$(MKPROG) -o $@ $(CFLAGS) $(OBJS) $(LDFLAGS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS)

endif

get_objs:

	@echo $(OBJS)

$(LIBRARY): $(OBJS)

	@$(MAKE_OBJDIR)

	rm -f $@

ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

	$(AR) $(subst /,\\,$(OBJS))

else

	$(AR) $(OBJS)

endif

	$(RANLIB) $@

ifeq ($(OS_TARGET),OS2)

$(IMPORT_LIBRARY): $(MAPFILE)

	rm -f $@

	$(IMPLIB) $@ $<

	$(RANLIB) $@

endif

ifdef SHARED_LIBRARY_LIBS

ifdef BUILD_TREE

SUB_SHLOBJS = $(foreach dir,$(SHARED_LIBRARY_DIRS),$(shell $(MAKE) -C $(dir) --no-print-directory get_objs))

else

SUB_SHLOBJS = $(foreach dir,$(SHARED_LIBRARY_DIRS),$(addprefix $(dir)/,$(shell $(MAKE) -C $(dir) --no-print-directory get_objs)))

endif

endif

$(SHARED_LIBRARY): $(OBJS) $(RES) $(MAPFILE) $(SUB_SHLOBJS)

	@$(MAKE_OBJDIR)

	rm -f $@

ifeq ($(OS_TARGET)$(OS_RELEASE), AIX4.1)

	echo "#!" > $(OBJDIR)/lib$(LIBRARY_NAME)_syms

	nm -B -C -g $(OBJS) \

	| awk '/ [T,D] / {print $$3}' \

	| sed -e 's/^\.//' \

	| sort -u >> $(OBJDIR)/lib$(LIBRARY_NAME)_syms

	$(LD) $(XCFLAGS) -o $@ $(OBJS) -bE:$(OBJDIR)/lib$(LIBRARY_NAME)_syms \

	-bM:SRE -bnoentry $(OS_LIBS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS)

else

ifeq (,$(filter-out WIN%,$(OS_TARGET)))

ifdef NS_USE_GCC

	$(LINK_DLL) $(OBJS) $(SUB_SHLOBJS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS) $(LD_LIBS) $(RES)

else

	$(LINK_DLL) -MAP $(DLLBASE) $(subst /,\\,$(OBJS) $(SUB_SHLOBJS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS) $(LD_LIBS) $(RES))

ifdef MT

	if test -f $@.manifest; then \

		$(MT) -NOLOGO -MANIFEST $@.manifest -OUTPUTRESOURCE:$@\;2; \

		rm -f $@.manifest; \

	fi

endif	# MSVC with manifest tool

endif

else

	$(MKSHLIB) -o $@ $(OBJS) $(SUB_SHLOBJS) $(LD_LIBS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS)

	chmod +x $@

endif

endif

ifeq (,$(filter-out WIN%,$(OS_TARGET)))

$(RES): $(RESNAME)

	@$(MAKE_OBJDIR)

# The resource compiler does not understand the -U option.

ifdef NS_USE_GCC

	$(RC) $(filter-out -U%,$(DEFINES)) $(INCLUDES:-I%=--include-dir %) -o $@ $<

else

	$(RC) $(filter-out -U%,$(DEFINES)) $(INCLUDES) -Fo$@ $<

endif

	@echo $(RES) finished

endif

$(MAPFILE): $(MAPFILE_SOURCE)

	@$(MAKE_OBJDIR)

	$(PROCESS_MAP_FILE)

$(OBJDIR)/$(PROG_PREFIX)%$(PROG_SUFFIX): $(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX)

	@$(MAKE_OBJDIR)

ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

	$(MKPROG) $< -Fe$@ -link \

	$(LDFLAGS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS)

ifdef MT

	if test -f $@.manifest; then \

		$(MT) -NOLOGO -MANIFEST $@.manifest -OUTPUTRESOURCE:$@\;1; \

		rm -f $@.manifest; \

	fi

endif	# MSVC with manifest tool

else

	$(MKPROG) -o $@ $(CFLAGS) $< \

	$(LDFLAGS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS)

endif

WCCFLAGS1 := $(subst /,\\,$(CFLAGS))

WCCFLAGS2 := $(subst -I,-i=,$(WCCFLAGS1))

WCCFLAGS3 := $(subst -D,-d,$(WCCFLAGS2))

# Translate source filenames to absolute paths. This is required for

# debuggers under Windows & OS/2 to find source files automatically

ifeq (,$(filter-out OS2 AIX,$(OS_TARGET)))

# OS/2 and AIX

NEED_ABSOLUTE_PATH := 1

PWD := $(shell pwd)

else

# Windows

ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

NEED_ABSOLUTE_PATH := 1

ifdef .PYMAKE

PWD := $(CURDIR)

else

PWD := $(shell pwd)

ifeq (,$(findstring ;,$(PATH)))

ifndef USE_MSYS

PWD := $(subst \,/,$(shell cygpath -w $(PWD)))

endif

endif

endif

else

# everything else

PWD := $(shell pwd)

endif

endif

# The quotes allow absolute paths to contain spaces.

core_abspath = "$(if $(findstring :,$(1)),$(1),$(if $(filter /%,$(1)),$(1),$(PWD)/$(1)))"

$(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.c

	@$(MAKE_OBJDIR)

ifdef USE_NT_C_SYNTAX

	$(CC) -Fo$@ -c $(CFLAGS) $(call core_abspath,$<)

else

ifdef NEED_ABSOLUTE_PATH

	$(CC) -o $@ -c $(CFLAGS) $(call core_abspath,$<)

else

	$(CC) -o $@ -c $(CFLAGS) $<

endif

endif

$(PROG_PREFIX)%$(OBJ_SUFFIX): %.c

ifdef USE_NT_C_SYNTAX

	$(CC) -Fo$@ -c $(CFLAGS) $(call core_abspath,$<)

else

ifdef NEED_ABSOLUTE_PATH

	$(CC) -o $@ -c $(CFLAGS) $(call core_abspath,$<)

else

	$(CC) -o $@ -c $(CFLAGS) $<

endif

endif

ifneq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET)))

$(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.s

	@$(MAKE_OBJDIR)

	$(AS) -o $@ $(ASFLAGS) -c $<

endif

$(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.asm

	@$(MAKE_OBJDIR)

	$(AS) -Fo$@ $(ASFLAGS) -c $<

$(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.S

	@$(MAKE_OBJDIR)

	$(AS) -o $@ $(ASFLAGS) -c $<

$(OBJDIR)/$(PROG_PREFIX)%: %.cpp