# # The contents of this file are subject to the Mozilla Public # License Version 1.1 (the "License"); you may not use this file # except in compliance with the License. You may obtain a copy of # the License at http://www.mozilla.org/MPL/ # # Software distributed under the License is distributed on an "AS # IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or # implied. See the License for the specific language governing # rights and limitations under the License. # # The Original Code is the Netscape security libraries. # # The Initial Developer of the Original Code is Netscape # Communications Corporation. Portions created by Netscape are # Copyright (C) 1994-2000 Netscape Communications Corporation. All # Rights Reserved. # # Contributor(s): # # Alternatively, the contents of this file may be used under the # terms of the GNU General Public License Version 2 or later (the # "GPL"), in which case the provisions of the GPL are applicable # instead of those above. If you wish to allow use of your # version of this file only under the terms of the GPL and not to # allow others to use your version of this file under the MPL, # indicate your decision by deleting the provisions above and # replace them with the notice and other provisions required by # the GPL. If you do not delete the provisions above, a recipient # may use your version of this file under either the MPL or the # GPL. # ####################################################################### ### ### ### 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 ifdef XP_OS2_VACPP 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) endif ifdef IMPORT_LIBRARY $(INSTALL) -m 775 $(IMPORT_LIBRARY) $(SOURCE_LIB_DIR) endif ifdef PROGRAM $(INSTALL) -m 775 $(PROGRAM) $(SOURCE_BIN_DIR) 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) #ifdef ALL_PLATFORMS #all_platforms:: $(NFSPWD) # @d=`$(NFSPWD)`; \ # if test ! -d LOGS; then rm -rf LOGS; mkdir LOGS; fi; \ # for h in $(PLATFORM_HOSTS); do \ # echo "On $$h: $(MAKE) $(ALL_PLATFORMS) >& LOGS/$$h.log";\ # rsh $$h -n "(chdir $$d; \ # $(MAKE) $(ALL_PLATFORMS) >& LOGS/$$h.log; \ # echo DONE) &" 2>&1 > LOGS/$$h.pid & \ # sleep 1; \ # done # #$(NFSPWD): # cd $(@D); $(MAKE) $(@F) #endif ####################################################################### # 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 ifdef XP_OS2_VACPP # list of libs (such as -lnspr4) do not work for our compiler # change it to be $(DIST)/lib/nspr4.lib EXTRA_SHARED_LIBS := $(filter-out -L%,$(EXTRA_SHARED_LIBS)) EXTRA_SHARED_LIBS := $(patsubst -l%,$(DIST)/lib/%.$(LIB_SUFFIX),$(EXTRA_SHARED_LIBS)) endif $(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)) else ifdef XP_OS2_VACPP $(MKPROG) -Fe$@ $(CFLAGS) $(OBJS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS) else $(MKPROG) -o $@ $(CFLAGS) $(OBJS) $(LDFLAGS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS) endif endif get_objs: @echo $(OBJS) $(LIBRARY): $(OBJS) @$(MAKE_OBJDIR) rm -f $@ ifeq (,$(filter-out WIN%,$(OS_TARGET))) $(AR) $(subst /,\\,$(OBJS)) else $(AR) $(OBJS) endif $(RANLIB) $@ ifeq ($(OS_TARGET),OS2) $(IMPORT_LIBRARY): $(MAPFILE) rm -f $@ $(IMPLIB) $@ $(MAPFILE) $(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)) endif else ifdef XP_OS2_VACPP $(MKSHLIB) $(DLLFLAGS) $(LDFLAGS) $(OBJS) $(SUB_SHLOBJS) $(LD_LIBS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) else $(MKSHLIB) -o $@ $(OBJS) $(SUB_SHLOBJS) $(LD_LIBS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) endif chmod +x $@ ifeq ($(OS_TARGET),Darwin) ifdef MAPFILE nmedit -s $(MAPFILE) $@ endif endif 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): $(LIBRARY_NAME).def @$(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) $(OBJDIR)/$(PROG_PREFIX)$*$(OBJ_SUFFIX) -Fe$@ -link \ $(LDFLAGS) $(EXTRA_LIBS) $(EXTRA_SHARED_LIBS) $(OS_LIBS) else $(MKPROG) -o $@ $(OBJDIR)/$(PROG_PREFIX)$*$(OBJ_SUFFIX) \ $(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%,$(OS_TARGET))) NEED_ABSOLUTE_PATH := 1 PWD := $(shell pwd) endif ifeq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET))) NEED_ABSOLUTE_PATH := 1 ifeq (,$(findstring ;,$(PATH))) PWD := $(subst \,/,$(shell cygpath -w `pwd`)) else PWD := $(shell pwd) endif endif ifdef NEED_ABSOLUTE_PATH abspath = $(if $(findstring :,$(1)),$(1),$(if $(filter /%,$(1)),$(1),$(PWD)/$(1))) else abspath = $(1) endif $(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.c @$(MAKE_OBJDIR) ifdef USE_NT_C_SYNTAX $(CC) -Fo$@ -c $(CFLAGS) $(call abspath,$<) else ifdef NEED_ABSOLUTE_PATH $(CC) -o $@ -c $(CFLAGS) $(call abspath,$<) else $(CC) -o $@ -c $(CFLAGS) $< endif endif $(PROG_PREFIX)%$(OBJ_SUFFIX): %.c ifdef USE_NT_C_SYNTAX $(CC) -Fo$@ -c $(CFLAGS) $(call abspath,$<) else ifdef NEED_ABSOLUTE_PATH $(CC) -o $@ -c $(CFLAGS) $(call abspath,$<) else $(CC) -o $@ -c $(CFLAGS) $< endif endif ifndef XP_OS2_VACPP ifneq (,$(filter-out _WIN%,$(NS_USE_GCC)_$(OS_TARGET))) $(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.s @$(MAKE_OBJDIR) $(AS) -o $@ $(ASFLAGS) -c $< endif endif $(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.asm @$(MAKE_OBJDIR) ifdef XP_OS2_VACPP $(AS) -Fdo:$(OBJDIR) $(ASFLAGS) $(subst /,\\,$<) else $(AS) -Fo$@ $(ASFLAGS) -c $< endif $(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.S @$(MAKE_OBJDIR) $(AS) -o $@ $(ASFLAGS) -c $< $(OBJDIR)/$(PROG_PREFIX)%: %.cpp @$(MAKE_OBJDIR) ifdef USE_NT_C_SYNTAX $(CCC) -Fo$@ -c $(CFLAGS) $(call abspath,$<) else ifdef NEED_ABSOLUTE_PATH $(CCC) -o $@ -c $(CFLAGS) $(call abspath,$<) else $(CCC) -o $@ -c $(CFLAGS) $< endif endif # # Please keep the next two rules in sync. # $(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.cc @$(MAKE_OBJDIR) $(CCC) -o $@ -c $(CFLAGS) $< $(OBJDIR)/$(PROG_PREFIX)%$(OBJ_SUFFIX): %.cpp @$(MAKE_OBJDIR) ifdef STRICT_CPLUSPLUS_SUFFIX echo "#line 1 \"$<\"" | cat - $< > $(OBJDIR)/t_$*.cc $(CCC) -o $@ -c $(CFLAGS) $(OBJDIR)/t_$*.cc rm -f $(OBJDIR)/t_$*.cc else ifdef USE_NT_C_SYNTAX $(CCC) -Fo$@ -c $(CFLAGS) $(call abspath,$<) else ifdef NEED_ABSOLUTE_PATH $(CCC) -o $@ -c $(CFLAGS) $(call abspath,$<) else $(CCC) -o $@ -c $(CFLAGS) $< endif endif endif #STRICT_CPLUSPLUS_SUFFIX %.i: %.cpp $(CCC) -C -E $(CFLAGS) $< > $*.i %.i: %.c ifeq (,$(filter-out WIN%,$(OS_TARGET))) $(CC) -C /P $(CFLAGS) $< else $(CC) -C -E $(CFLAGS) $< > $*.i endif ifneq (,$(filter-out WIN%,$(OS_TARGET))) %.i: %.s $(CC) -C -E $(CFLAGS) $< > $*.i endif %: %.pl rm -f $@; cp $*.pl $@; chmod +x $@ %: %.sh rm -f $@; cp $*.sh $@; chmod +x $@ ifdef DIRS $(DIRS):: @if test -d $@; then \ set $(EXIT_ON_ERROR); \ echo "cd $@; $(MAKE)"; \ cd $@; $(MAKE); \ set +e; \ else \ echo "Skipping non-directory $@..."; \ fi; \ $(CLICK_STOPWATCH) endif ################################################################################ # Bunch of things that extend the 'export' rule (in order): ################################################################################ $(JAVA_DESTPATH) $(JAVA_DESTPATH)/$(PACKAGE) $(JMCSRCDIR):: @if test ! -d $@; then \ echo Creating $@; \ rm -rf $@; \ $(NSINSTALL) -D $@; \ fi ################################################################################ ## IDL_GEN ifneq ($(IDL_GEN),) #export:: # $(IDL2JAVA) $(IDL_GEN) #all:: export #clobber:: # rm -f $(IDL_GEN:.idl=.class) # XXX wrong! endif ################################################################################ ### JSRCS -- for compiling java files ### ### NOTE: For backwards compatibility, if $(NETLIBDEPTH) is defined, ### replace $(CORE_DEPTH) with $(NETLIBDEPTH). ### ifneq ($(JSRCS),) ifneq ($(JAVAC),) ifdef NETLIBDEPTH CORE_DEPTH := $(NETLIBDEPTH) endif JAVA_EXPORT_SRCS=$(shell perl $(CORE_DEPTH)/coreconf/outofdate.pl $(PERLARG) -d $(JAVA_DESTPATH)/$(PACKAGE) $(JSRCS) $(PRIVATE_JSRCS)) export:: $(JAVA_DESTPATH) $(JAVA_DESTPATH)/$(PACKAGE) ifneq ($(JAVA_EXPORT_SRCS),) $(JAVAC) $(JAVA_EXPORT_SRCS) endif all:: export clobber:: rm -f $(SOURCE_XP_DIR)/classes/$(PACKAGE)/*.class endif endif # # JDIRS -- like JSRCS, except you can give a list of directories and it will # compile all the out-of-date java files in those directories. # # NOTE: recursing through these can speed things up, but they also cause # some builds to run out of memory # # NOTE: For backwards compatibility, if $(NETLIBDEPTH) is defined, # replace $(CORE_DEPTH) with $(NETLIBDEPTH). # ifdef JDIRS ifneq ($(JAVAC),) ifdef NETLIBDEPTH CORE_DEPTH := $(NETLIBDEPTH) endif # !!!!! THIS WILL CRASH SHMSDOS.EXE !!!!! # shmsdos does not support shell variables. It will crash when it tries # to parse the '=' character. A solution is to rewrite outofdate.pl so it # takes the Javac command as an argument and executes the command itself, # instead of returning a list of files. export:: $(JAVA_DESTPATH) $(JAVA_DESTPATH)/$(PACKAGE) @echo "!!! THIS COMMAND IS BROKEN ON WINDOWS--SEE rules.mk FOR DETAILS !!!" return -1 @for d in $(JDIRS); do \ if test -d $$d; then \ set $(EXIT_ON_ERROR); \ files=`echo $$d/*.java`; \ list=`perl $(CORE_DEPTH)/coreconf/outofdate.pl $(PERLARG) \ -d $(JAVA_DESTPATH)/$(PACKAGE) $$files`; \ if test "$${list}x" != "x"; then \ echo Building all java files in $$d; \ echo $(JAVAC) $$list; \ $(JAVAC) $$list; \ fi; \ set +e; \ else \ echo "Skipping non-directory $$d..."; \ fi; \ $(CLICK_STOPWATCH); \ done endif endif # # JDK_GEN -- for generating "old style" native methods # # Generate JDK Headers and Stubs into the '_gen' and '_stubs' directory # # NOTE: For backwards compatibility, if $(NETLIBDEPTH) is defined, # replace $(CORE_DEPTH) with $(NETLIBDEPTH). # ifneq ($(JDK_GEN),) ifneq ($(JAVAH),) ifdef NSBUILDROOT INCLUDES += -I$(JDK_GEN_DIR) -I$(SOURCE_XP_DIR) else INCLUDES += -I$(JDK_GEN_DIR) endif ifdef NETLIBDEPTH CORE_DEPTH := $(NETLIBDEPTH) endif JDK_PACKAGE_CLASSES := $(JDK_GEN) JDK_PATH_CLASSES := $(subst .,/,$(JDK_PACKAGE_CLASSES)) JDK_HEADER_CLASSFILES := $(patsubst %,$(JAVA_DESTPATH)/%.class,$(JDK_PATH_CLASSES)) JDK_STUB_CLASSFILES := $(patsubst %,$(JAVA_DESTPATH)/%.class,$(JDK_PATH_CLASSES)) JDK_HEADER_CFILES := $(patsubst %,$(JDK_GEN_DIR)/%.h,$(JDK_GEN)) JDK_STUB_CFILES := $(patsubst %,$(JDK_STUB_DIR)/%.c,$(JDK_GEN)) $(JDK_HEADER_CFILES): $(JDK_HEADER_CLASSFILES) $(JDK_STUB_CFILES): $(JDK_STUB_CLASSFILES) export:: @echo Generating/Updating JDK headers $(JAVAH) -d $(JDK_GEN_DIR) $(JDK_PACKAGE_CLASSES) @echo Generating/Updating JDK stubs $(JAVAH) -stubs -d $(JDK_STUB_DIR) $(JDK_PACKAGE_CLASSES) ifndef NO_MAC_JAVA_SHIT @if test ! -d $(CORE_DEPTH)/lib/mac/Java/; then \ echo "!!! You need to have a ns/lib/mac/Java directory checked out."; \ echo "!!! This allows us to automatically update generated files for the mac."; \ echo "!!! If you see any modified files there, please check them in."; \ fi @echo Generating/Updating JDK headers for the Mac $(JAVAH) -mac -d $(CORE_DEPTH)/lib/mac/Java/_gen $(JDK_PACKAGE_CLASSES) @echo Generating/Updating JDK stubs for the Mac $(JAVAH) -mac -stubs -d $(CORE_DEPTH)/lib/mac/Java/_stubs $(JDK_PACKAGE_CLASSES) endif endif endif # # JRI_GEN -- for generating "old style" JRI native methods # # Generate JRI Headers and Stubs into the 'jri' directory # # NOTE: For backwards compatibility, if $(NETLIBDEPTH) is defined, # replace $(CORE_DEPTH) with $(NETLIBDEPTH). # ifneq ($(JRI_GEN),) ifneq ($(JAVAH),) ifdef NSBUILDROOT INCLUDES += -I$(JRI_GEN_DIR) -I$(SOURCE_XP_DIR) else INCLUDES += -I$(JRI_GEN_DIR) endif ifdef NETLIBDEPTH CORE_DEPTH := $(NETLIBDEPTH) endif JRI_PACKAGE_CLASSES := $(JRI_GEN) JRI_PATH_CLASSES := $(subst .,/,$(JRI_PACKAGE_CLASSES)) JRI_HEADER_CLASSFILES := $(patsubst %,$(JAVA_DESTPATH)/%.class,$(JRI_PATH_CLASSES)) JRI_STUB_CLASSFILES := $(patsubst %,$(JAVA_DESTPATH)/%.class,$(JRI_PATH_CLASSES)) JRI_HEADER_CFILES := $(patsubst %,$(JRI_GEN_DIR)/%.h,$(JRI_GEN)) JRI_STUB_CFILES := $(patsubst %,$(JRI_GEN_DIR)/%.c,$(JRI_GEN)) $(JRI_HEADER_CFILES): $(JRI_HEADER_CLASSFILES) $(JRI_STUB_CFILES): $(JRI_STUB_CLASSFILES) export:: @echo Generating/Updating JRI headers $(JAVAH) -jri -d $(JRI_GEN_DIR) $(JRI_PACKAGE_CLASSES) @echo Generating/Updating JRI stubs $(JAVAH) -jri -stubs -d $(JRI_GEN_DIR) $(JRI_PACKAGE_CLASSES) ifndef NO_MAC_JAVA_SHIT @if test ! -d $(CORE_DEPTH)/lib/mac/Java/; then \ echo "!!! You need to have a ns/lib/mac/Java directory checked out."; \ echo "!!! This allows us to automatically update generated files for the mac."; \ echo "!!! If you see any modified files there, please check them in."; \ fi @echo Generating/Updating JRI headers for the Mac $(JAVAH) -jri -mac -d $(CORE_DEPTH)/lib/mac/Java/_jri $(JRI_PACKAGE_CLASSES) @echo Generating/Updating JRI stubs for the Mac $(JAVAH) -jri -mac -stubs -d $(CORE_DEPTH)/lib/mac/Java/_jri $(JRI_PACKAGE_CLASSES) endif endif endif # # JNI_GEN -- for generating JNI native methods # # Generate JNI Headers into the 'jni' directory # ifneq ($(JNI_GEN),) ifneq ($(JAVAH),) JNI_HEADERS := $(patsubst %,$(JNI_GEN_DIR)/%.h,$(JNI_GEN)) export:: @if test ! -d $(JNI_GEN_DIR); then \ echo $(JAVAH) -jni -d $(JNI_GEN_DIR) $(JNI_GEN); \ $(JAVAH) -jni -d $(JNI_GEN_DIR) $(JNI_GEN); \ else \ echo "Checking for out of date header files" ; \ perl $(CORE_DEPTH)/coreconf/jniregen.pl $(PERLARG) \ -d $(JAVA_DESTPATH) -j "$(JAVAH) -jni -d $(JNI_GEN_DIR)" $(JNI_GEN);\ fi endif endif # # JMC_EXPORT -- for declaring which java classes are to be exported for jmc # ifneq ($(JMC_EXPORT),) JMC_EXPORT_PATHS := $(subst .,/,$(JMC_EXPORT)) JMC_EXPORT_FILES := $(patsubst %,$(JAVA_DESTPATH)/$(PACKAGE)/%.class,$(JMC_EXPORT_PATHS)) # # We're doing NSINSTALL -t here (copy mode) because calling INSTALL will pick up # your NSDISTMODE and make links relative to the current directory. This is a # problem because the source isn't in the current directory: # export:: $(JMC_EXPORT_FILES) $(JMCSRCDIR) $(NSINSTALL) -t -m 444 $(JMC_EXPORT_FILES) $(JMCSRCDIR) endif # # JMC_GEN -- for generating java modules # # Provide default export & install rules when using JMC_GEN # ifneq ($(JMC_GEN),) ifneq ($(JMC),) INCLUDES += -I$(JMC_GEN_DIR) -I. JMC_HEADERS := $(patsubst %,$(JMC_GEN_DIR)/%.h,$(JMC_GEN)) JMC_STUBS := $(patsubst %,$(JMC_GEN_DIR)/%.c,$(JMC_GEN)) JMC_OBJS := $(patsubst %,$(OBJDIR)/%$(OBJ_SUFFIX),$(JMC_GEN)) $(JMC_GEN_DIR)/M%.h: $(JMCSRCDIR)/%.class $(JMC) -d $(JMC_GEN_DIR) -interface $(JMC_GEN_FLAGS) $(?F:.class=) $(JMC_GEN_DIR)/M%.c: $(JMCSRCDIR)/%.class $(JMC) -d $(JMC_GEN_DIR) -module $(JMC_GEN_FLAGS) $(?F:.class=) $(OBJDIR)/M%$(OBJ_SUFFIX): $(JMC_GEN_DIR)/M%.h $(JMC_GEN_DIR)/M%.c @$(MAKE_OBJDIR) $(CC) -o $@ -c $(CFLAGS) $(JMC_GEN_DIR)/M$*.c export:: $(JMC_HEADERS) $(JMC_STUBS) endif endif # # Copy each element of EXPORTS to $(SOURCE_XP_DIR)/public/$(MODULE)/ # PUBLIC_EXPORT_DIR = $(SOURCE_XP_DIR)/public/$(MODULE) ifneq ($(EXPORTS),) $(PUBLIC_EXPORT_DIR):: @if test ! -d $@; then \ echo Creating $@; \ $(NSINSTALL) -D $@; \ fi export:: $(PUBLIC_EXPORT_DIR) export:: $(EXPORTS) $(INSTALL) -m 444 $^ $(PUBLIC_EXPORT_DIR) export:: $(BUILT_SRCS) endif # Duplicate export rule for private exports, with different directories PRIVATE_EXPORT_DIR = $(SOURCE_XP_DIR)/private/$(MODULE) ifneq ($(PRIVATE_EXPORTS),) $(PRIVATE_EXPORT_DIR):: @if test ! -d $@; then \ echo Creating $@; \ $(NSINSTALL) -D $@; \ fi private_export:: $(PRIVATE_EXPORT_DIR) private_export:: $(PRIVATE_EXPORTS) $(INSTALL) -m 444 $^ $(PRIVATE_EXPORT_DIR) else private_export:: @echo There are no private exports.; endif ########################################################################## ### RULES FOR RUNNING REGRESSION SUITE TESTS ### REQUIRES 'REGRESSION_SPEC' TO BE SET TO THE NAME OF A REGRESSION SPECFILE ### AND RESULTS_SUBDIR TO BE SET TO SOMETHING LIKE SECURITY/PKCS5 ########################################################################## TESTS_DIR = $(RESULTS_DIR)/$(RESULTS_SUBDIR)/$(OS_TARGET)$(OS_RELEASE)$(CPU_TAG)$(COMPILER_TAG)$(IMPL_STRATEGY) ifneq ($(REGRESSION_SPEC),) ifneq ($(BUILD_OPT),) REGDATE = $(subst \ ,, $(shell perl $(CORE_DEPTH)/$(MODULE)/scripts/now)) endif tests:: $(REGRESSION_SPEC) cd $(PLATFORM); \ ../$(SOURCE_MD_DIR)/bin/regress$(PROG_SUFFIX) specfile=../$(REGRESSION_SPEC) progress $(EXTRA_REGRESS_OPTIONS); \ if test ! -d $(TESTS_DIR); then \ echo Creating $(TESTS_DIR); \ $(NSINSTALL) -D $(TESTS_DIR); \ fi ifneq ($(BUILD_OPT),) $(NSINSTALL) -m 664 $(PLATFORM)/$(REGDATE).sum $(TESTS_DIR); \ $(NSINSTALL) -m 664 $(PLATFORM)/$(REGDATE).htm $(TESTS_DIR); \ echo "Please now make sure your results files are copied to $(TESTS_DIR), "; \ echo "then run 'reporter specfile=$(RESULTS_DIR)/rptspec'" endif else tests:: @echo Error: you didn't specify REGRESSION_SPEC in your manifest.mn file!; endif # Duplicate export rule for releases, with different directories ifneq ($(EXPORTS),) $(SOURCE_RELEASE_XP_DIR)/include:: @if test ! -d $@; then \ echo Creating $@; \ $(NSINSTALL) -D $@; \ fi release_export:: $(SOURCE_RELEASE_XP_DIR)/include release_export:: $(EXPORTS) $(INSTALL) -m 444 $^ $(SOURCE_RELEASE_XP_DIR)/include endif ################################################################################ -include $(DEPENDENCIES) ifneq (,$(filter-out OpenVMS OS2 WIN%,$(OS_TARGET))) # Can't use sed because of its 4000-char line length limit, so resort to perl .DEFAULT: @perl -e ' \ open(MD, "< $(DEPENDENCIES)"); \ while () { \ if (m@ \.*/*$< @) { \ $$found = 1; \ last; \ } \ } \ if ($$found) { \ print "Removing stale dependency $< from $(DEPENDENCIES)\n"; \ seek(MD, 0, 0); \ $$tmpname = "$(OBJDIR)/fix.md" . $$$$; \ open(TMD, "> " . $$tmpname); \ while () { \ s@ \.*/*$< @ @; \ if (!print TMD "$$_") { \ unlink(($$tmpname)); \ exit(1); \ } \ } \ close(TMD); \ if (!rename($$tmpname, "$(DEPENDENCIES)")) { \ unlink(($$tmpname)); \ } \ } elsif ("$<" ne "$(DEPENDENCIES)") { \ print "$(MAKE): *** No rule to make target $<. Stop.\n"; \ exit(1); \ }' endif ############################################################################# # X dependency system ############################################################################# ifdef MKDEPENDENCIES # For Windows, $(MKDEPENDENCIES) must be -included before including rules.mk $(MKDEPENDENCIES):: @$(MAKE_OBJDIR) touch $(MKDEPENDENCIES) chmod u+w $(MKDEPENDENCIES) #on NT, the preceeding touch command creates a read-only file !?!?! #which is why we have to explicitly chmod it. $(MKDEPEND) -p$(OBJDIR_NAME)/ -o'$(OBJ_SUFFIX)' -f$(MKDEPENDENCIES) \ $(NOMD_CFLAGS) $(YOPT) $(CSRCS) $(CPPSRCS) $(ASFILES) $(MKDEPEND):: $(MKDEPEND_DIR)/*.c $(MKDEPEND_DIR)/*.h cd $(MKDEPEND_DIR); $(MAKE) ifdef OBJS depend:: $(MKDEPEND) $(MKDEPENDENCIES) else depend:: endif +$(LOOP_OVER_DIRS) dependclean:: rm -f $(MKDEPENDENCIES) +$(LOOP_OVER_DIRS) #-include $(NSINSTALL_DIR)/$(OBJDIR)/depend.mk else depend:: endif ################################################################################ # Special gmake rules. ################################################################################ # # Re-define the list of default suffixes, so gmake won't have to churn through # hundreds of built-in suffix rules for stuff we don't need. # .SUFFIXES: .SUFFIXES: .out .a .ln .o .obj .c .cc .C .cpp .y .l .s .S .h .sh .i .pl .class .java .html .asm # # Don't delete these files if we get killed. # .PRECIOUS: .java $(JDK_HEADERS) $(JDK_STUBS) $(JRI_HEADERS) $(JRI_STUBS) $(JMC_HEADERS) $(JMC_STUBS) $(JNI_HEADERS) # # Fake targets. Always run these rules, even if a file/directory with that # name already exists. # .PHONY: all all_platforms alltags boot clean clobber clobber_all export install libs program realclean release $(OBJDIR) $(DIRS)