###############################################################################
# Makefile for modules - building and installing
#
# Copyright 2005 Nintendo.  All rights reserved.
#
# These coded instructions, statements, and computer programs contain
# proprietary information of Nintendo of America Inc. and/or Nintendo
# Company Ltd., and are protected by Federal copyright law.  They may
# not be disclosed to third parties or copied or duplicated in any form,
# in whole or in part, without the prior written consent of Nintendo.
###############################################################################

###############################################################################
#
# This makefile can support one library per module, and any number of
# executables.
# The library is specified by the following variables in the module makefile:
#   LIBNAME     - name of the library, with no suffix
#   CLIBSRCS    - c sources to be included in library
#   ASMLIBSRCS	- assembly sources to be included in library
#
# Executables rely on the following:
#   BINNAMES    - names of all executables, with no suffix
#   CSRCS       - all c sources to be built
#   ASMSRCS     - all assembly sources to be built
# Finally to show dependencies, each BINNAME should have its own rule at the
# bottom of the module makefile, such as :
# $(FULLBIN_ROOT)/cachedemo$(BINSUFFIX): cachedemo.o \
#		      	$(REVOLUTION_LIBS)
# If a linker command file is required, define the variable:
#   LCF_FILE = myLCFfile.lcf
#
# The following pre-defined variables are relied upon :
# FULLBIN_ROOT - a pointer to the binary directory of this module
# BINSUFFIX    - the suffix of the binary (e.g. "D" if debug version, ".elf" if
#                an EPPC binary
# REVOLUTION_LIBS  - list of all Dolphin libraries appropriate for this target.
#
###############################################################################

MKDIRP := mkdir -p

ifdef MAKE_ON_CYGWIN
CLEAN_DEPEND := sed -f "$(REVOLUTION_SDK_ROOT)/build/buildtools/eppccleandepend.sed"
endif

CYGPATH := sed -e 'sX\/cygdrive\/\([a-zA-Z]\+\)\/X\1:\/Xg'

# first, figure out which directory tree we are in, and set PROJ_ROOT
# accordingly.
ifdef CPBUILD
ifeq ($(DEMO),TRUE)
PROJ_ROOT	= $(CP_DEMO_ROOT)
endif

ifeq ($(LIB),TRUE)
PROJ_ROOT	= $(CP_LIB_ROOT)
endif

else # CPBUILD
ifeq ($(DEMO),TRUE)
PROJ_ROOT	= $(DEMO_ROOT)
endif

ifeq ($(LIB),TRUE)
PROJ_ROOT	= $(LIB_ROOT)
endif
endif # CPBUILD

ifeq ($(TEST), TRUE)
PROJ_ROOT	= $(TEST_ROOT)
endif

ifeq ($(SAMPLE), TRUE)
PROJ_ROOT	= $(SAMPLE_ROOT)
endif

ifeq ($(CHAR_PIPELINE), TRUE)
PROJ_ROOT	= $(CHAR_PIPELINE_ROOT)
endif

ifeq ($(BUILD_TOOL), TRUE)
PROJ_ROOT	= $(MAKE_ROOT)
endif

# Paths relevant to this module - they are all based off of PROJ_ROOT

# BINOBJ AND BINLIB MUST BE LOCAL BECAUSE OF BUG IN COMPILERS...they
# cannot take absolute output path
# however, the dependency code DOES generate full paths, so we need those
# for pattern matching
MODULE_ROOT	    = $(PROJ_ROOT)/$(MODULENAME)
FULLSRC_ROOT    = $(MODULE_ROOT)/src

BINOBJ_ROOT     = obj/$(ARCH_TARGET)/$(BUILD_TARGET)
DEP_ROOT        = depend/$(ARCH_TARGET)/$(BUILD_TARGET)
FULLBINOBJ_ROOT = $(BINOBJ_ROOT)
FULLDEP_ROOT    = $(MODULE_ROOT)/$(DEP_ROOT)

BINLIB_ROOT     = lib/$(ARCH_TARGET)
FULLBINLIB_ROOT = $(MODULE_ROOT)/$(BINLIB_ROOT)
FULLBIN_ROOT    = bin/$(ARCH_TARGET)
BIN_ROOT        = bin/$(ARCH_TARGET)
VPATH           = $(FULLBIN_ROOT):$(FULLBINOBJ_ROOT)

# Suffix rules
.SUFFIXES:
.SUFFIXES: .s .h .c .o .cpp

###############################################################################
#
#   Generate lists of objects to be built
#
###############################################################################

ALLCSRCS    = $(CSRCS) $(CLIBSRCS)
ALLCPPSRCS  = $(CPPSRCS) $(CPPLIBSRCS)
ALLASMSRCS  = $(ASMSRCS) $(ASMLIBSRCS)

ifdef CSRCS
OBJECTS     += $(addprefix $(FULLBINOBJ_ROOT)/, $(CSRCS:.c=.o))
ifdef WADNAMES
OBJECTS     += $(addprefix $(FULLBINOBJ_ROOT)/, $(CSRCS:.c=$(NANDAPPSUFFIX).o))
endif
endif
ifdef CPPSRCS
OBJECTS     += $(addprefix $(FULLBINOBJ_ROOT)/, $(CPPSRCS:.cpp=.o))
ifdef WADNAMES
OBJECTS     += $(addprefix $(FULLBINOBJ_ROOT)/, $(CPPSRCS:.cpp=$(NANDAPPSUFFIX).o))
endif
endif
ifdef ASMSRCS
OBJECTS     += $(addprefix $(FULLBINOBJ_ROOT)/, $(ASMSRCS:.s=.o))
endif
ifdef CLIBSRCS
LIBOBJECTS  += $(addprefix $(FULLBINOBJ_ROOT)/, $(CLIBSRCS:.c=.o))
endif
ifdef CPPLIBSRCS
LIBOBJECTS  += $(addprefix $(FULLBINOBJ_ROOT)/, $(CPPLIBSRCS:.cpp=.o))
endif
ifdef ASMLIBSRCS
LIBOBJECTS  += $(addprefix $(FULLBINOBJ_ROOT)/, $(ASMLIBSRCS:.s=.o))
endif

ALLOBJECTS  = $(OBJECTS) $(LIBOBJECTS)

# if we're building debug versions, need to change names of built libs/bins
ifdef LIBNAME
TARGET_LIB	= $(FULLBINLIB_ROOT)/$(LIBNAME)$(LIBSUFFIX)
endif

ifdef BINNAMES
TARGET_BINS	= $(addprefix $(FULLBIN_ROOT)/,$(addsuffix $(BINSUFFIX), $(BINNAMES)))
endif

ifdef WADNAMES
TARGET_WADS	= $(addprefix $(FULLBIN_ROOT)/,$(addsuffix $(WADSUFFIX), $(WADNAMES)))
endif

ifdef PLFNAMES
TARGET_PLFS     = $(addprefix $(FULLBIN_ROOT)/,$(addsuffix $(PLFSUFFIX), $(PLFNAMES)))
endif

ifdef RELNAMES
TARGET_PLFS     = $(addprefix $(FULLBIN_ROOT)/,$(addsuffix $(PLFSUFFIX), $(RELNAMES)))
TARGET_PREPLFS  = $(addprefix $(FULLBIN_ROOT)/,$(addsuffix $(PREPLFSUFFIX), $(RELNAMES)))
endif

ifdef PUBLISHARGS
PUBLISH_TARGET	:= $(subst $(comma),$(space),$(PUBLISHARGS))
endif

###############################################################################
#
#   Generic building rules
#
###############################################################################

# GENERIC ASM FILE BUILDING
$(FULLBINOBJ_ROOT)/%.o: src/%.s
	@if [ ! -d $(@D) ] ; then \
		echo ">>> Creating $(@D)" ; \
		$(MKDIRP) $(@D) ; \
	fi
	@if [ ! -d $(dir $(FULLDEP_ROOT)/$*) ] ; then \
		echo ">>> Creating $(dir $(FULLDEP_ROOT)/$*)" ; \
		$(MKDIRP) $(dir $(FULLDEP_ROOT)/$*) ; \
	fi
	@if [ ! -d $(MODULE_ROOT)/include ] ; then \
	    echo ">>> Creating $(MODULE_ROOT)/include" ;\
		$(MKDIRP) $(MODULE_ROOT)/include ; \
	fi
	@echo ""
	@echo "$< --> $@"
ifdef EPPC
	$(AS) $(ASFLAGS) $(INCLUDES) -c $< -o $(subst $(FULLBINOBJ_ROOT)/,$(BINOBJ_ROOT)/,$@) -MD
ifndef SNSYS
	@echo -n "$(FULLBINOBJ_ROOT)/$*.o: " > $(FULLDEP_ROOT)/$*.d ;\
	$(CLEAN_DEPEND) $(notdir $*).d >> $(FULLDEP_ROOT)/$*.d ;\
	rm -f $(notdir $*).d
else # SNSYS
endif # SNSYS
else # EPPC
endif # EPPC


# GENERIC C FILE BUILDING
$(FULLBINOBJ_ROOT)/%.o: src/%.c
	@if [ ! -d $(@D) ] ; then \
		echo ">>> Creating $(@D)" ; \
		$(MKDIRP) $(@D) ; \
	fi
	@if [ ! -d $(dir $(FULLDEP_ROOT)/$*) ] ; then \
		echo ">>> Creating $(dir $(FULLDEP_ROOT)/$*)" ; \
		$(MKDIRP) $(dir $(FULLDEP_ROOT)/$*) ; \
	fi
	@if [ ! -d $(MODULE_ROOT)/include ] ; then \
	    echo ">>> Creating $(MODULE_ROOT)/include" ;\
		$(MKDIRP) $(MODULE_ROOT)/include ; \
	fi
	@echo ""
	@echo ">> $< --> $(BINOBJ_ROOT)/$(subst $(FULLBINOBJ_ROOT)/,,$@)"
ifdef EPPC
	$(CC) $(CCFLAGS) $(INCLUDES) $(PREFIX_FILE) $(COMPILE) $< \
		-o $(subst $(FULLBINOBJ_ROOT)/,$(BINOBJ_ROOT)/,$@) -MD
ifndef SNSYS
	@echo -n "$(FULLBINOBJ_ROOT)/$*.o: " > $(FULLDEP_ROOT)/$*.d ;\
	$(CLEAN_DEPEND) $(notdir $*).d >> $(FULLDEP_ROOT)/$*.d ;\
	rm -f $(notdir $*).d
else # SNSYS
endif # SNSYS
else # EPPC
endif # EPPC

# GENERIC C FILE BUILDING FOR NANDAPP
$(FULLBINOBJ_ROOT)/%$(NANDAPPSUFFIX).o: src/%.c
	@if [ ! -d $(@D) ] ; then \
		echo ">>> Creating $(@D)" ; \
		$(MKDIRP) $(@D) ; \
	fi
	@if [ ! -d $(dir $(FULLDEP_ROOT)/$*) ] ; then \
		echo ">>> Creating $(dir $(FULLDEP_ROOT)/$*)" ; \
		$(MKDIRP) $(dir $(FULLDEP_ROOT)/$*) ; \
	fi
	@if [ ! -d $(MODULE_ROOT)/include ] ; then \
	    echo ">>> Creating $(MODULE_ROOT)/include" ;\
		$(MKDIRP) $(MODULE_ROOT)/include ; \
	fi
	@echo ""
	@echo ">> $< --> $(BINOBJ_ROOT)/$(subst $(FULLBINOBJ_ROOT)/,,$@)"
ifdef EPPC
	$(CC) $(CCFLAGS) -DNANDAPP=TRUE $(INCLUDES) $(PREFIX_FILE) $(COMPILE) $< \
		-o $(subst $(FULLBINOBJ_ROOT)/,$(BINOBJ_ROOT)/,$@) -MD
ifndef SNSYS
	@echo -n "$(FULLBINOBJ_ROOT)/$*.o: " > $(FULLDEP_ROOT)/$*.d ;\
	$(CLEAN_DEPEND) $(notdir $*).d >> $(FULLDEP_ROOT)/$*.d ;\
	rm -f $(notdir $*).d
else # SNSYS
endif # SNSYS
else # EPPC
endif # EPPC

# GENERIC CXX FILE BUILDING
$(FULLBINOBJ_ROOT)/%.o: src/%.cpp
	@if [ ! -d $(@D) ] ; then \
		echo ">>> Creating $(@D)" ; \
		$(MKDIRP) $(@D) ; \
	fi
	@if [ ! -d $(dir $(FULLDEP_ROOT)/$*) ] ; then \
		echo ">>> Creating $(dir $(FULLDEP_ROOT)/$*)" ; \
		$(MKDIRP) $(dir $(FULLDEP_ROOT)/$*) ; \
	fi
	@if [ ! -d $(MODULE_ROOT)/include ] ; then \
	    echo ">>> Creating $(MODULE_ROOT)/include" ;\
		$(MKDIRP) $(MODULE_ROOT)/include ; \
	fi
	@echo ""
	@echo ">> $< --> $(BINOBJ_ROOT)/$(subst $(FULLBINOBJ_ROOT)/,,$@)"
ifdef EPPC
	$(CC) $(CCFLAGS) $(INCLUDES) $(COMPILE) $< \
		-o $(subst $(FULLBINOBJ_ROOT)/,$(BINOBJ_ROOT)/,$@) -MD
ifndef SNSYS
	@echo -n "$(FULLBINOBJ_ROOT)/$*.o: " > $(FULLDEP_ROOT)/$*.d ;\
	$(CLEAN_DEPEND) $(notdir $*).d >> $(FULLDEP_ROOT)/$*.d ;\
	rm -f $(notdir $*).d
else # SNSYS
endif # SNSYS
else # EPPC
endif # EPPC

# GENERIC CXX FILE BUILDING FOR NANDAPP
$(FULLBINOBJ_ROOT)/%$(NANDAPPSUFFIX).o: src/%.cpp
	@if [ ! -d $(@D) ] ; then \
		echo ">>> Creating $(@D)" ; \
		$(MKDIRP) $(@D) ; \
	fi
	@if [ ! -d $(dir $(FULLDEP_ROOT)/$*) ] ; then \
		echo ">>> Creating $(dir $(FULLDEP_ROOT)/$*)" ; \
		$(MKDIRP) $(dir $(FULLDEP_ROOT)/$*) ; \
	fi
	@if [ ! -d $(MODULE_ROOT)/include ] ; then \
	    echo ">>> Creating $(MODULE_ROOT)/include" ;\
		$(MKDIRP) $(MODULE_ROOT)/include ; \
	fi
	@echo ""
	@echo ">> $< --> $(BINOBJ_ROOT)/$(subst $(FULLBINOBJ_ROOT)/,,$@)"
ifdef EPPC
	$(CC) $(CCFLAGS) -DNANDAPP=TRUE $(INCLUDES) $(COMPILE) $< \
		-o $(subst $(FULLBINOBJ_ROOT)/,$(BINOBJ_ROOT)/,$@) -MD
ifndef SNSYS
	@echo -n "$(FULLBINOBJ_ROOT)/$*.o: " > $(FULLDEP_ROOT)/$*.d ;\
	$(CLEAN_DEPEND) $(notdir $*).d >> $(FULLDEP_ROOT)/$*.d ;\
	rm -f $(notdir $*).d
else # SNSYS
endif # SNSYS
else # EPPC
endif # EPPC

# GENERIC .elf/executable BUILDING
# linker command file is used whenever LCF_FILE is defined.
# Note it is only used when linking executables.

ifdef LCF_FILE
LDFLAGS += -lcf $(LCF_FILE)
endif # LCF_FILE

$(FULLBIN_ROOT)/%$(BINSUFFIX):
	@echo ""
	@echo ">> $(notdir $+) --> $(subst $(FULLBIN_ROOT)/,,$@)"
ifdef MAKE_ON_CYGWIN
	$(LD) $(shell echo $(filter-out %.lcf %.dol, $+) |$(CYGPATH)) $(LDFLAGS) -o $(shell echo $@ |$(CYGPATH))
else
	$(LD) $(filter-out %.lcf %.dol, $+) $(LDFLAGS) -o $@
endif # MAKE_ON_CYGWIN

# Generate .wad (for NAND application)
ifdef CNT_IDX
ifdef MAKE_ON_CYGWIN
DVD_ROOT = $(shell cygpath -m $(word 2, $(shell getndenv)))
else
DVD_ROOT = $(shell echo $(word 2, $(shell getndenv)))
endif
ARC_DIR = archives
CONTENT_INDEX = $(subst $(comma),$(space),$(CNT_IDX))
CNT_FILES = $(foreach val,$(CONTENT_INDEX),$(DVD_ROOT)/content$(val)/content$(val).arc)
WAD_CNT = $(subst $(space),$(comma), \
			$(foreach val,$(CONTENT_INDEX),$(DVD_ROOT)/$(ARC_DIR)/content$(val).arc))
endif # CNT_IDX
ifdef CNT_ARG
CNT_FILES += $(subst $(comma),$(space),$(CNT_ARG))
WAD_CNT := $(WAD_CNT)$(comma)$(CNT_ARG)
endif # CNT_ARG

ifdef NANDAPP
ifndef NOEXPORT
NANDAPP_TARGET = $(foreach val, $(BINNAMES), $(val)$(REGION_SUFFIX)$(WADSUFFIX))
endif
endif #NANDAPP

ifdef NANDAPP
ifdef WAD_APP
%$(REGION_SUFFIX)$(WADSUFFIX): $(FULLBIN_ROOT)/$(WAD_APP)$(BINSUFFIX) $(CNT_FILES)
ifdef COUNTRY_REGION
	setcountrycode $(COUNTRY_REGION)
endif
ifdef PARENTAL_CONTROL_ID_LIST
	setnparentalcontrol $(PARENTAL_CONTROL_ID_LIST)
endif
ifndef NOCOMPRESS
	@if [ ! -f $(ROOT)/X86/bin/makeWad.exe ] ; then \
		echo "NADK is not installed. Exiting..."; \
	else \
		echo ""; \
		echo ">> $(WAD_APP)$(BINSUFFIX) $(notdir $(CNT_FILES)) --> $@"; \
		echo makedol -f $(FULLBIN_ROOT)/$(WAD_APP)$(BINSUFFIX) -d $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX); \
		makedol -f $(FULLBIN_ROOT)/$(WAD_APP)$(BINSUFFIX) -d $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX); \
		echo "ntcompress -lex -A32 -o $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX)$(LZ77SUFFIX) $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX)"; \
		ntcompress -lex -A32 -o $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX)$(LZ77SUFFIX) $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX); \
		echo makeWad -n $(WAD_APP)$(ASUFFIX) -l $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX)$(LZ77SUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		makeWad -n $(WAD_APP)$(ASUFFIX) -l $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX)$(LZ77SUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		echo mv $(WAD_APP)$(WADSUFFIX) -> $(FULLBIN_ROOT)/$@; \
		mv $(WAD_APP)$(WADSUFFIX) $(FULLBIN_ROOT)/$@; \
	fi
else
	@if [ ! -f $(ROOT)/X86/bin/makeWad.exe ] ; then \
		echo "NADK is not installed. Exiting..."; \
	else \
		echo ""; \
		echo ">> $(WAD_APP)$(BINSUFFIX) $(notdir $(CNT_FILES)) --> $@"; \
		echo makedol -f $(FULLBIN_ROOT)/$(WAD_APP)$(BINSUFFIX) -d $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX); \
		echo makeWad -n $(WAD_APP)$(ASUFFIX) -l $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		makedol -f $(FULLBIN_ROOT)/$(WAD_APP)$(BINSUFFIX) -d $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX); \
		makeWad -n $(WAD_APP)$(ASUFFIX) -l $(FULLBIN_ROOT)/$(WAD_APP)$(DOLSUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		echo mv $(WAD_APP)$(WADSUFFIX) -> $(FULLBIN_ROOT)/$@; \
		mv $(WAD_APP)$(WADSUFFIX) $(FULLBIN_ROOT)/$@; \
	fi
endif # NOCOMPRESS
else
%$(REGION_SUFFIX)$(WADSUFFIX): $(FULLBIN_ROOT)/%$(BINSUFFIX) $(CNT_FILES)
ifdef COUNTRY_REGION
	setcountrycode $(COUNTRY_REGION)
endif
ifdef PARENTAL_CONTROL_ID_LIST
	setnparentalcontrol $(PARENTAL_CONTROL_ID_LIST)
endif
ifndef NOCOMPRESS
	@if [ ! -f $(ROOT)/X86/bin/makeWad.exe ] ; then \
		echo "NADK is not installed. Exiting..."; \
	else \
		echo ""; \
		echo ">> $*$(BINSUFFIX) $(notdir $(CNT_FILES)) --> $@"; \
		echo makedol -f $(FULLBIN_ROOT)/$*$(BINSUFFIX) -d $(FULLBIN_ROOT)/$*$(DOLSUFFIX); \
		makedol -f $(FULLBIN_ROOT)/$*$(BINSUFFIX) -d $(FULLBIN_ROOT)/$*$(DOLSUFFIX); \
		echo "ntcompress -lex -A32 -o $(FULLBIN_ROOT)/$*$(DOLSUFFIX)$(LZ77SUFFIX) $(FULLBIN_ROOT)/$*$(DOLSUFFIX)"; \
		ntcompress -lex -A32 -o $(FULLBIN_ROOT)/$*$(DOLSUFFIX)$(LZ77SUFFIX) $(FULLBIN_ROOT)/$*$(DOLSUFFIX); \
		echo makeWad -n $*$(ASUFFIX) -l $(FULLBIN_ROOT)/$*$(DOLSUFFIX)$(LZ77SUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		makeWad -n $*$(ASUFFIX) -l $(FULLBIN_ROOT)/$*$(DOLSUFFIX)$(LZ77SUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		echo mv $*$(WADSUFFIX) -> $(FULLBIN_ROOT)/$@; \
		mv $*$(WADSUFFIX) $(FULLBIN_ROOT)/$@; \
	fi
else
	@if [ ! -f $(ROOT)/X86/bin/makeWad.exe ] ; then \
		echo "NADK is not installed. Exiting..."; \
	else \
		echo ""; \
		echo ">> $*$(BINSUFFIX) $(notdir $(CNT_FILES)) --> $@"; \
		echo makedol -f $(FULLBIN_ROOT)/$*$(BINSUFFIX) -d $(FULLBIN_ROOT)/$*$(DOLSUFFIX); \
		echo makeWad -n $*$(ASUFFIX) -l $(FULLBIN_ROOT)/$*$(DOLSUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		makedol -f $(FULLBIN_ROOT)/$*$(BINSUFFIX) -d $(FULLBIN_ROOT)/$*$(DOLSUFFIX); \
		makeWad -n $*$(ASUFFIX) -l $(FULLBIN_ROOT)/$*$(DOLSUFFIX)$(WAD_CNT) $(WAD_OPTION); \
		echo mv $*$(WADSUFFIX) -> $(FULLBIN_ROOT)/$@; \
		mv $*$(WADSUFFIX) $(FULLBIN_ROOT)/$@; \
	fi
endif # NOCOMPRESS
endif # WAD_APP
endif # NANDAPP


ifndef CNT_IDX
%.arc:
else
$(DVD_ROOT)/content%.arc:
endif
	@if [ ! -d $(DVD_ROOT)/$(ARC_DIR) ] ; then \
		echo ""; \
	    echo ">>> Creating $(DVD_ROOT)/$(ARC_DIR)" ;\
		echo ""; \
		$(MKDIRP) $(DVD_ROOT)/$(ARC_DIR) ; \
	fi
	@if [ ! -d $(@D) ] ; then \
	    echo "$(@D) is not exist!" ; \
	else \
		echo "------------------------------------------------------------------" ; \
		echo "Archiving $(@D)"; \
		cd $(@D); \
		darch -c * $(@F); \
		darch -t $(@F); \
		echo "$(DVD_ROOT)/archives/$(@F)"; \
		mv $(@F) $(DVD_ROOT)/$(ARC_DIR); \
	fi




# Generate .plf (partial link file)
ifdef EPPC
$(FULLBIN_ROOT)/%$(PLFSUFFIX):
	@echo ""
	@echo ">> $(notdir $+) --> $(subst $(FULLBIN_ROOT)/,,$@)"
ifdef MAKE_ON_CYGWIN
ifdef REL_LCF_FILE
	$(LD) $(shell echo $(filter-out %.lcf,$+) |$(CYGPATH)) $(REL_LDFLAGS) -lcf $(REL_LCF_FILE) -o $(shell echo $@ |$(CYGPATH))
else # REL_LCF_FILE
# obsolete (for compatibility with 4/3/01 SDK)
ifdef LCF_FILE
	$(LD) $(shell echo $(filter-out %.lcf,$+) |$(CYGPATH)) $(REL_LDFLAGS) -lcf $(LCF_FILE) -o $(shell echo $@ |$(CYGPATH))
else # LCF_FILE
	$(LD) $(shell echo $(filter-out %.lcf,$+) |$(CYGPATH)) $(REL_LDFLAGS) -o $(shell echo $@ |$(CYGPATH))
endif # LCF_FILE
endif # REL_LCF_FILE
else # MAKE_ON_CYGWIN
ifdef REL_LCF_FILE
	$(LD) $(filter-out %.lcf,$+) $(REL_LDFLAGS) -lcf $(REL_LCF_FILE) -o $@
else # REL_LCF_FILE
# obsolete (for compatibility with 4/3/01 SDK)
ifdef LCF_FILE
	$(LD) $(filter-out %.lcf,$+) $(REL_LDFLAGS) -lcf $(LCF_FILE)     -o $@
else # LCF_FILE
	$(LD) $(filter-out %.lcf,$+) $(REL_LDFLAGS)                      -o $@
endif # LCF_FILE
endif # REL_LCF_FILE
endif # MAKE_ON_CYGWIN
endif # EPPC

# Generate .preplf (partial link file)
ifdef EPPC
$(FULLBIN_ROOT)/%$(PREPLFSUFFIX):
	@echo ""
	@echo ">> $(notdir $+) --> $(subst $(FULLBIN_ROOT)/,,$@)"
ifdef MAKE_ON_CYGWIN
ifdef PREREL_LCF_FILE
	$(LD) $(shell echo $(filter-out %.lcf,$+) |$(CYGPATH)) $(PREREL_LDFLAGS) -lcf $(PREREL_LCF_FILE) -o $(shell echo $@ |$(CYGPATH))
else # PREREL_LCF_FILE
	$(LD) $(shell echo $(filter-out %.lcf,$+) |$(CYGPATH)) $(PREREL_LDFLAGS)) -o $(shell echo $@ |$(CYGPATH))
endif # PREREL_LCF_FILE
else # MAKE_ON_CYGWIN
ifdef PREREL_LCF_FILE
	$(LD) $(filter-out %.lcf,$+) $(PREREL_LDFLAGS) -lcf $(PREREL_LCF_FILE) -o $@
else # PREREL_LCF_FILE
	$(LD) $(filter-out %.lcf,$+) $(PREREL_LDFLAGS) -o $@
endif # PREREL_LCF_FILE
endif # MAKE_ON_CYGWIN
endif # EPPC

# Generate .dol
ifdef EPPC
$(FULLBIN_ROOT)/%$(DOLSUFFIX): $(FULLBIN_ROOT)/%$(BINSUFFIX)
	@echo ""
	@echo ">> $(notdir $+) --> $(subst $(FULLBIN_ROOT)/,,$@)"
	"$(ROOT)/X86/bin/makedol.exe" -f $< -d $@
endif

# GENERIC dependency building
ifdef X86

$(FULLDEP_ROOT)/%$(DEPSUFFIX): src/%.c
	@if [ ! -d $(@D) ] ; then \
		echo ">>> Creating $(@D)" ; \
		$(MKDIRP) $(@D) ; \
	fi
	@if [ ! -d $(MODULE_ROOT)/include ] ; then \
	    echo ">>> Creating $(MODULE_ROOT)/include" ;\
		$(MKDIRP) $(MODULE_ROOT)/include ; \
	fi
	@echo "Refreshing dependency $@"
	@rm -f $@
	@echo -n "$(FULLBINOBJ_ROOT)/$*.o " > $@
	@$(CC) $(CCFLAGS) $(INCLUDES) -MM $(MODULE_ROOT)/$< | tr -d '\r' >> $@

endif



# GENERIC LIBRARY LINKING
$(TARGET_LIB): $(LIBOBJECTS)
	@echo ""
	@echo ">> New $(notdir $?) --> linking $@"
ifdef MAKE_ON_CYGWIN
	$(AR) $(ARFLAGS) $(LIBOBJECTS) -o $(shell echo $(TARGET_LIB) |$(CYGPATH))
else # MAKE_ON_CYGWIN
	$(AR) $(ARFLAGS) $(LIBOBJECTS) -o $(TARGET_LIB)
endif # MAKE_ON_CYGWIN

###############################################################################
#
#   Miscellaneous targets - cleaning and setup
#
###############################################################################

SETUP_ROOTS = $(BINOBJ_ROOT) $(INSTALL_ROOT) $(BINLIB_ROOT) $(BIN_ROOT)

setup: $(SETUP_ROOTS)

$(INSTALL_ROOT):
	@echo "Creating $(INSTALL_ROOT)" ; \
	rm -rf $(INSTALL_ROOT) ; \
	$(MKDIRP) $(BASEINSTALL_ROOT) ; \
	$(MKDIRP) $(BASEINSTALL_ROOT)/$(ARCH_TARGET) ; \
	$(MKDIRP) $(INSTALL_ROOT)/include ; \
	$(MKDIRP) $(INSTALL_ROOT)/lib ; \
	$(MKDIRP) $(INSTALL_ROOT)/bin

$(BINOBJ_ROOT):
	@echo "Creating $(BINOBJ_ROOT)" ; \
	$(MKDIRP) $(MODULE_ROOT)/obj ; \
	$(MKDIRP)  $(MODULE_ROOT)/obj/$(ARCH_TARGET) ; \
	$(MKDIRP)  $(MODULE_ROOT)/obj/$(ARCH_TARGET)/DEBUG ; \
	$(MKDIRP)  $(MODULE_ROOT)/obj/$(ARCH_TARGET)/NDEBUG

$(BINLIB_ROOT):
	@echo "Creating $(BINLIB_ROOT)" ; \
	$(MKDIRP) $(MODULE_ROOT)/lib ; \
	$(MKDIRP) $(BINLIB_ROOT)

$(BIN_ROOT):
	@echo "Creating $(BIN_ROOT)" ; \
	$(MKDIRP) $(MODULE_ROOT)/bin ; \
	$(MKDIRP) $(BIN_ROOT)

build: setup $(NANDAPP_TARGET)
# ifdef MULTIPROCESSOR
# 	@$(MAKE) -j X86=$(X86) PLATFORM=$(PLATFORM) INCLUDEDEPS=TRUE dobuild
# else
	@$(MAKE) X86=$(X86) PLATFORM=$(PLATFORM) INCLUDEDEPS=TRUE dobuild
#endif

dobuild: $(OBJECTS) $(TARGET_LIB) $(TARGET_BINS) $(TARGET_DOLS) $(TARGET_WADS) $(TARGET_PLFS) $(TARGET_PREPLFS)

cleandep:
	rm -rf depend/$(ARCH_TARGET)/DEBUG/*
	rm -rf depend/$(ARCH_TARGET)/NDEBUG/*

cleantilde:
	rm -f $(addprefix src/, $(ALLCSRCS:.c=.c~))
	rm -f $(addprefix src/, $(ALLCSRCS:.c=.BAK))
	rm -f *~ *.BAK
	rm -f include/*~ include/*.BAK

clobberdemoinstall:
ifdef DEMO
ifdef MODULENAME
	rm -rf $(INSTALL_ROOT)/bin/demos/$(MODULENAME)/*
endif
endif

clobbertest:
ifdef TEST
ifdef MODULENAME
	rm -rf $(INSTALL_ROOT)/bin/tests/$(MODULENAME)/*
endif
endif

clobberlib:
	rm -rf $(BINLIB_ROOT)/*
ifdef LIBNAME
	rm -f $(INSTALL_ROOT)/lib/$(LIBNAME)$(LIBSUFFIX)
endif

cleanidb:
ifdef MAC
# 	rm -f $(BIN_ROOT)/*.idb
endif

cleandis:
	rm -f src/*.c.s

cleanobj:
	rm -rf obj/$(ARCH_TARGET)/DEBUG/*
	rm -rf obj/$(ARCH_TARGET)/NDEBUG/*

clobberbin:
	rm -rf $(BIN_ROOT)/*
	rm -f *.MAP

cleanuser:
ifdef CLEANFILES
	rm -rf $(CLEANFILES)
endif

clean:		cleanobj cleandep cleantilde cleanidb cleandis cleanuser

clobber:	clean clobberbin clobberlib clobberdemoinstall clobbertest

superclobber: clobber
	rm -rf bin
	rm -rf obj
	rm -rf lib
	rm -rf depend

###############################################################################
#
# Module installation - copy binaries and libraries to appropriate locations
# All libraries are installed.
# Only demo binaries are installed.
#
###############################################################################

install: build
ifndef SNSYS
	@echo -n "$(MODULE_ROOT) - ";
	@if [ `ls lib/$(ARCH_TARGET) 2> /dev/null | wc -l` = "0" ] ; then \
		echo -n "No libs to export..." ; \
	else \
		echo -n "Exporting libs..." ; \
		if [ ! -d $(INSTALL_ROOT)/lib ] ; then \
			echo -n "Creating $(INSTALL_ROOT)/lib..." ; \
			$(MKDIRP) $(INSTALL_ROOT)/lib ; \
		fi ; \
		cp -uR lib/$(ARCH_TARGET)/* $(INSTALL_ROOT)/lib ; \
		chmod +w $(INSTALL_ROOT)/lib/*  ; \
	fi
ifdef DEMO
	@if [ `ls bin/$(ARCH_TARGET) 2> /dev/null | wc -l` = "0" ] ; then \
		echo -n "No binaries to export..." ; \
	else \
		echo -n "Exporting binaries..." ; \
		if [ ! -d $(INSTALL_ROOT)/bin/demos/$(MODULENAME) ] ; then \
			echo -n "Creating $(INSTALL_ROOT)/bin/demos/$(MODULENAME)..." ; \
			$(MKDIRP) $(INSTALL_ROOT)/bin/demos ; \
			$(MKDIRP) $(INSTALL_ROOT)/bin/demos/$(MODULENAME) ; \
		fi ; \
		cp -uR bin/$(ARCH_TARGET)/* $(INSTALL_ROOT)/bin/demos/$(MODULENAME)/ ; \
		chmod +w $(INSTALL_ROOT)/bin/demos/$(MODULENAME)/*  ; \
	fi
endif
ifdef TEST
	@if [ `ls bin/$(ARCH_TARGET) 2> /dev/null | wc -l` = "0" ] ; then \
		echo -n "No binaries to export..." ; \
	else \
		echo -n "Exporting binaries..." ; \
		if [ ! -d $(INSTALL_ROOT)/bin/tests/$(MODULENAME) ] ; then \
			echo -n "Creating $(INSTALL_ROOT)/bin/tests/$(MODULENAME)..." ; \
			$(MKDIRP) $(INSTALL_ROOT)/bin/tests ; \
			$(MKDIRP) $(INSTALL_ROOT)/bin/tests/$(MODULENAME) ; \
		fi ; \
		cp -uR bin/$(ARCH_TARGET)/* $(INSTALL_ROOT)/bin/tests/$(MODULENAME)/ ; \
		chmod +w $(INSTALL_ROOT)/bin/tests/$(MODULENAME)/*  ; \
	fi
endif
ifdef APPLOADER
	@if [ `ls bin/$(ARCH_TARGET) 2> /dev/null | wc -l` = "0" ] ; then \
		echo -n "No binaries to export..." ; \
	else \
		echo -n "Exporting apploader binaries..." ; \
		if [ ! -d $(INSTALL_ROOT)/boot ] ; then \
			echo -n "Creating $(INSTALL_ROOT)/boot..." ; \
			$(MKDIRP) $(INSTALL_ROOT)/boot ; \
		fi ; \
		cp -u bin/$(ARCH_TARGET)/apploader$(IMGSUFFIX) $(INSTALL_ROOT)/boot/ ; \
		chmod +w $(INSTALL_ROOT)/boot/*  ; \
	fi
endif
ifdef TOOL
	@if [ `ls bin/$(ARCH_TARGET) 2> /dev/null | wc -l` = "0" ] ; then \
		echo -n "No binaries to export..." ; \
	else \
		echo -n "Exporting makedol binaries..." ; \
		if [ ! -d $(INSTALL_ROOT)/bin ] ; then \
			echo -n "Creating $(INSTALL_ROOT)/bin..." ; \
			$(MKDIRP) $(INSTALL_ROOT)/bin ; \
		fi ; \
		cp -uR bin/$(ARCH_TARGET)/* $(INSTALL_ROOT)/bin/ ; \
		chmod +w $(INSTALL_ROOT)/bin/*  ; \
	fi
endif
	@echo ""
endif # SNSYS

###############################################################################
#
# Module autotest - convert binaries to dol/wad and copy to dvdroot
#
###############################################################################

ifdef EPPC

AUTOTEST_DVDROOT_MODULE   = $(AUTOTEST_DVDROOT_TESTS)/$(MODULENAME)
AUTOTEST_MODULE_TESTDOLS  = $(addprefix $(AUTOTEST_DVDROOT_MODULE)/,$(addsuffix $(DOLSUFFIX), $(BINNAMES_AUTOTEST)))
AUTOTEST_MODULE_TESTWADS  = $(addprefix $(AUTOTEST_DVDROOT_MODULE)/,$(addsuffix $(REGION_SUFFIX)$(WADSUFFIX), $(WADNAMES_AUTOTEST)))

$(FULLBIN_ROOT)/%$(REGION_SUFFIX)$(WADSUFFIX): $(FULLBIN_ROOT)/%$(NANDAPPSUFFIX)$(BINSUFFIX)
	@$(MAKE) $*$(NANDAPPSUFFIX)$(REGION_SUFFIX)$(WADSUFFIX) NANDAPP=TRUE WAD_OPTION=$(WAD_OPTION_$*)
	rm -rf $(FULLBIN_ROOT)/$*$(NANDAPPSUFFIX)$(REGION_SUFFIX)$(DOLSUFFIX) $(FULLBIN_ROOT)/$*$(NANDAPPSUFFIX)$(REGION_SUFFIX)$(DOLSUFFIX)$(LZ77SUFFIX)
	mv $(FULLBIN_ROOT)/$*$(NANDAPPSUFFIX)$(REGION_SUFFIX)$(WADSUFFIX) $@

.PHONY: autotest_setdvdroot autotest_targets_dvdroot autotest_targets autotest autotest_runone autotest_manual autotest_clean

$(AUTOTEST_DVDROOT_MODULE) $(AUTOTEST_DVDROOT_IMPORT) $(AUTOTEST_DVDROOT_DATA_ARC):
	@ if [ ! -d $@ ] ; then \
	    echo ">>> Creating $@" ; \
	    $(MKDIRP) $@ ; \
	  fi

$(AUTOTEST_DVDROOT_MODULE)/%$(DOLSUFFIX): $(FULLBIN_ROOT)/%$(DOLSUFFIX) $(AUTOTEST_DVDROOT_MODULE)
	@ cp -upv $< $@

$(AUTOTEST_DVDROOT_MODULE)/%$(REGION_SUFFIX)$(WADSUFFIX): $(FULLBIN_ROOT)/%$(REGION_SUFFIX)$(WADSUFFIX) $(AUTOTEST_DVDROOT_MODULE)
	@ cp -upv $< $@

ifdef AUTOTEST_DATATITLE_GAMECODE
CCFLAGS += -DAUTOTEST_DATATITLE_GAMECODE=\"$(AUTOTEST_DATATITLE_GAMECODE)\"

$(AUTOTEST_DVDROOT_IMPORT)/$(AUTOTEST_DATATITLE_GAMECODE).wad: $(AUTOTEST_DVDROOT_IMPORT) $(AUTOTEST_DVDROOT_DATA_ARC)
	@ if [ -d $(AUTOTEST_DVDROOT_DATA)/$(AUTOTEST_DATATITLE_GAMECODE)/content1 ] ; then \
	  echo ">>> Packaging files into datatitle" ; \
	  echo "    $(notdir $(AUTOTEST_DVDROOT_DATA))/$(AUTOTEST_DATATITLE_GAMECODE)/content1/* -> $(notdir $(AUTOTEST_DVDROOT_IMPORT))/$(AUTOTEST_DATATITLE_GAMECODE).wad" ; \
	  cd $(AUTOTEST_DVDROOT_DATA)/$(AUTOTEST_DATATITLE_GAMECODE)/content1; \
	  darchD -c * $(AUTOTEST_DVDROOT_DATA_ARC)/$(AUTOTEST_DATATITLE_GAMECODE).arc; \
	  darchD -tv $(AUTOTEST_DVDROOT_DATA_ARC)/$(AUTOTEST_DATATITLE_GAMECODE).arc; \
	  cd $(AUTOTEST_DVDROOT_DATA_ARC); \
	  makeWad -f -n $(AUTOTEST_DATATITLE_GAMECODE) -l $(AUTOTEST_DVDROOT_DATA_ARC)/$(AUTOTEST_DATATITLE_GAMECODE).arc -gc $(AUTOTEST_DATATITLE_GAMECODE) -E 0x00000000 -e 0xffffffff; \
	  mv $(AUTOTEST_DATATITLE_GAMECODE).wad $(AUTOTEST_DVDROOT_IMPORT); \
	fi

autotest: $(AUTOTEST_DVDROOT_IMPORT)/$(AUTOTEST_DATATITLE_GAMECODE).wad
endif

autotest_setdvdroot:
	@echo ""
	@setndenv DvdRoot "$(AUTOTEST_DVDROOT)"
	@ if [ ! -f $(AUTOTEST_STUB_PATH)/$(AUTOTEST_STUB).elf ] || [ ! -f $(AUTOTEST_DVDROOT)/autotest.dol ] ; then \
	  echo ">>> Building autotest module" ; \
	  $(MAKE) -C $(AUTOTEST_MAKEPATH) NDEBUG=TRUE; \
	fi

autotest_targets_dvdroot: $(AUTOTEST_MODULE_TESTDOLS) $(AUTOTEST_MODULE_TESTWADS)

# This must be 2 separate make commands below.  This is so this target works after fresh checkout/superclobber
autotest_targets:
	@$(MAKE) build
	@$(MAKE) autotest_targets_dvdroot
	@ if [ -e "autotest_config.txt" ] ; then \
	    cp autotest_config.txt $(AUTOTEST_DVDROOT_MODULE)/autotest_config.txt; \
	  else \
	    echo no $(AUTOTEST_DVDROOT_MODULE)/autotest_config.txt; \
	  fi; \

# uterm timeout set non-zero so that it can be auto-terminated by EOF "\004" in serial output
# autotest_stub -> autotest.dol -> test1.dol -> autotest.dol -> test2.dol -> ...
autotest: autotest_targets autotest_setdvdroot
	ndrun $(AUTOTEST_STUB_PATH)/$(AUTOTEST_STUB).elf -a -runmodule $(MODULENAME) $(ARGS)
	@ echo "Opening serial port..."; \
	  AUTOTEST_LOG=autotest_`date +%y%m%d%H%M`.txt; \
	  if [ "$(TIMEOUT)" != "" ] ; then \
	    uterm "" $$AUTOTEST_LOG "" "" $(TIMEOUT); \
	  else \
	    uterm "" $$AUTOTEST_LOG "" "" 900; \
	  fi; \
	  if [ $$? -ne 0 ] ; then \
	    ndstop; \
	    echo error; \
	  else \
	    echo ok; \
	  fi; \
	  grep -i 'AutoTest: ' $$AUTOTEST_LOG; \
	  grep -i 'Failed' $$AUTOTEST_LOG; \
	  echo "Log: $$AUTOTEST_LOG"

autotest_runone: $(addprefix $(AUTOTEST_DVDROOT_MODULE)/, $(TESTDOL)) autotest_setdvdroot
	ndrun $(AUTOTEST_STUB_PATH)/$(AUTOTEST_STUB).elf -a -runone $(TESTDOL) $(ARGS)
	@ echo "Opening serial port..."; \
	  AUTOTEST_LOG=autotest_`date +%y%m%d%H%M`.txt; \
	  if [ "$(TIMEOUT)" != "" ] ; then \
	    uterm "" $$AUTOTEST_LOG "" "" $(TIMEOUT); \
	  else \
	    uterm "" $$AUTOTEST_LOG "" "" 900; \
	  fi; \
	  if [ $$? -ne 0 ] ; then \
	    ndstop; \
	    echo error; \
	  else \
	    echo ok; \
	  fi; \
	  grep -i 'AutoTest: ' $$AUTOTEST_LOG; \
	  grep -i 'Failed' $$AUTOTEST_LOG; \
	  echo "Log: $$AUTOTEST_LOG"

autotest_manual: autotest_setdvdroot
	@ if [ "$(ARGS)" != "" ] ; then \
	  ndrun $(AUTOTEST_STUB_PATH)/$(AUTOTEST_STUB).elf -a $(ARGS); \
	else \
	  ndrun $(AUTOTEST_STUB_PATH)/$(AUTOTEST_STUB).elf -a -manual; \
	fi

autotest_clean:
	rm -rf $(AUTOTEST_DVDROOT_TESTS)
	rm -rf $(AUTOTEST_DVDROOT_IMPORT)

endif # EPPC

# Generate dependency files
ifdef INCLUDEDEPS
ifneq (,$(firstword $(ALLASMSRCS)))
-include $(addprefix $(FULLDEP_ROOT)/, $(ALLASMSRCS:.s=$(DEPSUFFIX)))
endif
ifneq (,$(firstword $(ALLCSRCS)))
-include $(addprefix $(FULLDEP_ROOT)/, $(ALLCSRCS:.c=$(DEPSUFFIX)))
endif
ifneq (,$(firstword $(ALLCPPSRCS)))
-include $(addprefix $(FULLDEP_ROOT)/, $(ALLCPPSRCS:.cpp=$(DEPSUFFIX)))
endif
endif