X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=mk%2Ftarget.mk;h=c4d77bfad704b17d50eb4929f6378590e1137fb1;hb=74e1368d4688ee16f6decdf2cd3ebe27506b26ba;hp=b8410cd2c96e0d021f1a1f2e26609cc2a24738a7;hpb=2711c31f22cd5f550671724bef59186c5189935a;p=ghc-hetmet.git

diff --git a/mk/target.mk b/mk/target.mk
index b8410cd..37a72bc 100644
--- a/mk/target.mk
+++ b/mk/target.mk
@@ -2,24 +2,24 @@
 #
 #			target.mk
 #
-#		Standard targets for fptools
+#		Standard targets for GHC
 #
 #################################################################################
 
 #
 # This file contain three groups of target rules:
 #
-# 1.  FPtools targets
+# 1.  GHC targets
 #	depend*
 #	runtests*
 #
 # 2.  GNU standard targets
 #	all*
-#	install* uninstall installcheck installdirs
+#	install* installcheck installdirs
+#       install-docs*
 #	clean* distclean* mostlyclean* maintainer-clean*
 #	tags*
-#	info dvi ps
-#	dist binary-dist
+#	dvi ps (no info) GHC adds: pdf rtf html chm HxS
 #	check
 #
 # 3. Some of the above targets have a version that
@@ -33,118 +33,26 @@
 # 
 #
 
-
-##################################################################
-#
-# 		Recursive stuff
-#
-# At the top of the file so that recursive makes happen before
-# makes in the main directory. This is needed for some targets,
-# e.g. when building DLLs in hslibs.
-#
 ##################################################################
+# Pre-compute the list of sources so we don't have to do this 
+# multiple times.  See paths.mk.
 
-# Here are the diabolically clever rules that
-# 
-# (a) for each "recursive target" <t>
-#     propagates "make <t>" to directories in SUBDIRS
-#
-# (b) when SUBDIRS is empty,
-#     for each "multi-way-target" <t>
-#     calls "make -way=w <t>" for each w in $(WAYS)
-#
-#     This has the effect of making the standard target
-#     in each of the specified ways (as well as in the normal way
-
-# Controlling variables
-#	WAYS    = extra (beyond the normal way) ways to build things in
-# 	SUBDIRS = subdirectories to recurse into
-
-# No ways, so iterate over the SUBDIRS
-
-# note about recursively invoking make: we'd like make to drop all the
-# way back to the top level if it fails in any of the
-# sub(sub-...)directories.  This is done by setting the -e flag to the
-# shell during the loop, which causes an immediate failure if any of
-# the shell commands fail.
-
-# One exception: if the user gave the -i or -k flag to make in the
-# first place, we'd like to reverse this behaviour.  So we check for
-# these flags, and set the -e flag appropriately.  NOTE: watch out for
-# the --no-print-directory flag which is passed to recursive
-# invocations of make.
-#
-# NOTE: Truly weird use of exit below to stop the for loop dead in
-# its tracks should any of the sub-makes fail. By my reckoning, 
-#  "cmd || exit $?" should be equivalent to "cmd"
-
-ifneq "$(SUBDIRS)" ""
+PRE_SRCS := $(ALL_SRCS)
 
-all docs runtests boot TAGS clean distclean mostlyclean maintainer-clean install info html ps dvi txt::
-	@echo "------------------------------------------------------------------------"
-	@echo "===fptools== Recursively making \`$@' in $(SUBDIRS) ..."
-	@echo "PWD = $(shell pwd)"
-	@echo "------------------------------------------------------------------------"
-# Don't rely on -e working, instead we check exit return codes from sub-makes.
-	@case '${MFLAGS}' in *-[ik]*) x_on_err=0;; *-r*[ik]*) x_on_err=0;; *) x_on_err=1;; esac; \
-	for i in $(SUBDIRS); do \
-	  echo "------------------------------------------------------------------------"; \
-	  echo "==fptools== $(MAKE) $@ $(MFLAGS);"; \
-	  echo " in $(shell pwd)/$$i"; \
-	  echo "------------------------------------------------------------------------"; \
-	  $(MAKE) --no-print-directory -C $$i $(MFLAGS) $@; \
-	  if [ $$? -eq 0 -o $$x_on_err -eq 0 ] ;  then true; else exit 1; fi; \
-	done
-	@echo "------------------------------------------------------------------------"
-	@echo "===fptools== Finished making \`$@' in $(SUBDIRS) ..."
-	@echo "PWD = $(shell pwd)"
-	@echo "------------------------------------------------------------------------"
-
-dist ::
-# Don't rely on -e working, instead we check exit return codes from sub-makes.
-	@case '${MFLAGS}' in *-[ik]*) x_on_err=0;; *-r*[ik]*) x_on_err=0;; *) x_on_err=1;; esac; \
-	for i in $(SUBDIRS) ; do \
-	  $(MKDIRHIER_PREFIX)mkdirhier $(SRC_DIST_DIR)/$$i; \
-	  $(MAKE) -C $$i $(MFLAGS) $@ SRC_DIST_DIR=$(SRC_DIST_DIR)/$$i; \
-	  if [ $$? -eq 0 ] ;  then true; else exit $$x_on_err; fi; \
-	done
-endif
+##################################################################
+# Include package building machinery
+# NB. needs to be after PRE_SRCS setting above, because otherwise the
+# rule dependencies won't be set correctly.
 
-# The default dist rule:
-#
-# copy/link the contents of $(SRC_DIST_FILES) into the
-# shadow distribution tree. SRC_DIST_FILES contain the
-# build-generated files that you want to include in
-# a source distribution.
-#
-#
-ifneq "$(SRC_DIST_FILES)" ""
-dist::
-	@for i in $(SRC_DIST_FILES); do 		 \
-	  if ( echo "$$i" | grep "~" >/dev/null 2>&1 ); then	 \
-	    echo $(LN_S) `pwd`/`echo $$i | sed -e "s/^\([^~]*\)~.*/\1/g"` $(SRC_DIST_DIR)/`echo $$i | sed -e "s/.*~\(.*\)/\1/g"` ; \
-	    $(LN_S) `pwd`/`echo $$i | sed -e "s/^\([^~]*\)~.*/\1/g"` $(SRC_DIST_DIR)/`echo $$i | sed -e "s/.*~\(.*\)/\1/g"` ; \
-	  else \
-	    if (test -f "$$i"); then 			   \
-	      echo $(LN_S) `pwd`/$$i $(SRC_DIST_DIR)/$$i ; \
-	      $(LN_S) `pwd`/$$i $(SRC_DIST_DIR)/$$i ;	   \
-	     fi;					   \
-	  fi; \
-	done;
-endif
+include $(TOP)/mk/package.mk
 
+###################################################################
+# Suffix rules for Haskell, C and literate 
 
-#
-# Selectively building subdirectories.
-#
-#
-ifneq "$(SUBDIRS)" ""
-$(SUBDIRS) ::
-	  $(MAKE) -C $@ $(MFLAGS)
-endif
+include $(TOP)/mk/suffix.mk
 
 ##################################################################
-# 		FPtools standard targets
+# 		GHC standard targets
 #
 # depend:
 #
@@ -171,7 +79,17 @@ endif
 # Compiler produced files that are targets of the source's imports.
 MKDEPENDHS_OBJ_SUFFICES=o
 
-depend :: $(MKDEPENDHS_SRCS) $(MKDEPENDC_SRCS)
+ifneq "$(BootingFromHc)" "YES"
+PKGCONF_DEP = $(STAMP_PKG_CONF)
+endif
+
+ifeq "$(USE_NEW_MKDEPEND_FLAGS)" "YES"
+MKDEPENDHS_FLAGS = -dep-makefile .depend $(foreach way,$(WAYS),-dep-suffix $(way))
+else
+MKDEPENDHS_FLAGS = -optdep-f -optdep.depend $(foreach way,$(WAYS),-optdep-s -optdep$(way))
+endif
+
+depend :: $(MKDEPENDHS_SRCS) $(MKDEPENDC_SRCS) $(PKGCONF_DEP)
 	@$(RM) .depend
 	@touch .depend
 ifneq "$(DOC_SRCS)" ""
@@ -181,7 +99,7 @@ ifneq "$(MKDEPENDC_SRCS)" ""
 	$(MKDEPENDC) -f .depend $(MKDEPENDC_OPTS) $(foreach way,$(WAYS),-s $(way)) -- $(CC_OPTS) -- $(MKDEPENDC_SRCS) 
 endif
 ifneq "$(MKDEPENDHS_SRCS)" ""
-	$(MKDEPENDHS) -M -optdep-f -optdep.depend $(foreach way,$(WAYS),-optdep-s -optdep$(way)) $(foreach obj,$(MKDEPENDHS_OBJ_SUFFICES),-optdep-o -optdep$(obj)) $(MKDEPENDHS_OPTS) $(HC_OPTS) $(MKDEPENDHS_SRCS)
+	$(MKDEPENDHS) -M $(MKDEPENDHS_FLAGS) $(foreach obj,$(MKDEPENDHS_OBJ_SUFFICES),-osuf $(obj)) $(MKDEPENDHS_OPTS) $(filter-out -split-objs, $(HC_OPTS)) $(MKDEPENDHS_SRCS)
 endif
 
 
@@ -191,8 +109,12 @@ endif
 #  The boot target, at a minimum generates dependency information
 
 .PHONY: boot
-boot :: depend
 
+ifeq "$(NO_BOOT_TARGET)" "YES"
+boot ::
+else
+boot :: depend
+endif
 
 ##################################################################
 # 		GNU Standard targets
@@ -201,9 +123,7 @@ boot :: depend
 # 
 # `all'
 #      Compile the entire program. This should be the default target.
-#      This target need not rebuild any documentation files; Info files
-#      should normally be included in the distribution, and DVI files
-#      should be made only when explicitly asked for.
+#      This target need not rebuild any documentation files
 # 
 # `install'
 #      Compile the program and copy the executables, libraries, and so on
@@ -222,32 +142,6 @@ boot :: depend
 #      will ignore any errors.  This is in case there are systems that
 #      don't have the Unix man page documentation system installed.
 # 
-#      The way to install Info files is to copy them into `$(infodir)'
-#      with $(INSTALL_DATA) (see Command Variables), and then run the
-#      install-info program if it is present.  install-info is a script
-#      that edits the Info `dir' file to add or update the menu entry for
-#      the given Info file; it will be part of the Texinfo package. Here
-#      is a sample rule to install an Info file:
-# 
-# 	     $(infodir)/foo.info: foo.info # There may be a newer info
-# 	     file in . than in srcdir.
-# 		     -if test -f foo.info; then d=.; \
-# 		      else d=$(srcdir); fi; \ $(INSTALL_DATA)
-# 		     $$d/foo.info $@; \ # Run install-info only if it
-# 	     exists.  # Use `if' instead of just prepending `-' to the
-# 	     # line so we notice real errors from install-info.  # We
-# 	     use `$(SHELL) -c' because some shells do not # fail
-# 	     gracefully when there is an unknown command.
-# 		     if $(SHELL) -c 'install-info --version' \
-# 			>/dev/null 2>&1; then \ install-info
-# 		       --infodir=$(infodir) $$d/foo.info; \ else true;
-# 		     fi
-# 
-# `uninstall'
-#      Delete all the installed files that the `install' target would
-#      create (but not the noninstalled files such as `make all' would
-#      create).
-# 
 # `clean'
 # 
 #      Delete all files from the current directory that are normally
@@ -276,7 +170,7 @@ boot :: depend
 #      Delete everything from the current directory that can be
 #      reconstructed with this Makefile.  This typically includes
 #      everything deleted by distclean , plus more: C source files
-#      produced by Bison, tags tables, Info files, and so on.
+#      produced by Bison, tags tables, and so on.
 # 
 #      One exception, however: `make maintainer-clean' should not delete
 #      `configure' even if `configure' can be remade using a rule in the
@@ -287,53 +181,11 @@ boot :: depend
 # `TAGS'
 #      Update a tags table for this program.
 # 
-# `info'
-#      Generate any Info files needed. The best way to write the rules is
-#      as follows:
-# 
-# 	     info: foo.info
-# 
-# 	     foo.info: foo.texi chap1.texi chap2.texi
-# 		     $(MAKEINFO) $(srcdir)/foo.texi
-# 
-#      You must define the variable MAKEINFO in the Makefile. It should
-#      run the makeinfo program, which is part of the Texinfo
-#      distribution.
-# 
-# `dvi' `ps'
-#      Generate DVI files for all TeXinfo documentation. For example:
-# 
-# 	     dvi: foo.dvi
-# 
-# 	     foo.dvi: foo.texi chap1.texi chap2.texi
-# 		     $(TEXI2DVI) $(srcdir)/foo.texi
-# 
-#      You must define the variable TEXI2DVI in the Makefile. It should
-#      run the program texi2dvi , which is part of the Texinfo
-#      distribution. Alternatively, write just the dependencies, and
-#      allow GNU Make to provide the command.
+# `dvi' `ps' `pdf' `html' `chm' `HxS' `rtf' 
+#      Generate DVI/PS/PDF files for LaTeX/DocBook docs. Not everything is
+#      supported everywhere, but the intention is to standardise on DocBook
+#      producing all formats.
 #
-#      ps is a FPtools addition for Postscript files
-# 
-# `dist' `binary-dist'
-#      Create a distribution tar file for this program. The tar file
-#      should be set up so that the file names in the tar file start with
-#      a subdirectory name which is the name of the package it is a
-#      distribution for. This name can include the version number.
-# 
-#      For example, the distribution tar file of GCC version 1.40 unpacks
-#      into a subdirectory named `gcc-1.40'.
-# 
-#      The easiest way to do this is to create a subdirectory
-#      appropriately named, use ln or cp to install the proper files in
-#      it, and then tar that subdirectory.
-# 
-#      The dist target should explicitly depend on all non-source files
-#      that are in the distribution, to make sure they are up to date in
-#      the distribution. See Making Releases.
-#
-#	binary-dist is an FPtools addition for binary distributions
-# 
 # `check'
 #      Perform self-tests (if any). The user must build the program
 #      before running the tests, but need not install the program; you
@@ -353,7 +205,7 @@ boot :: depend
 #      directories where files are installed, and their parent
 #      directories. There is a script called `mkinstalldirs' which is
 #      convenient for this; find it in the Texinfo package.
-#      (FPTOOLS: we use a close relative of the suggested script, situated
+#      (GHC: we use a close relative of the suggested script, situated
 #       in glafp-utils/mkdirhier -- SOF)
 
 
@@ -371,7 +223,6 @@ boot :: depend
 #	HS_PROG		Haskell program
 #	C_PROG		C program
 #	LIBRARY		Library
-#	SCRIPT_PROG	Script (e.g. Perl script)
 #
 # For details of exactly what rule is generated, see the
 # relevant section below
@@ -384,8 +235,14 @@ boot :: depend
 ifneq "$(HS_PROG)" ""
 all :: $(HS_PROG)
 
-$(HS_PROG) :: $(HS_OBJS)
-	$(HC) -o $@ $(HC_OPTS) $(LD_OPTS) $(HS_OBJS) $(LIBS)
+ifneq "$(BootingFromHc)" "YES"
+$(HS_PROG) :: $(OBJS)
+	$(HC) -o $@ $(HC_OPTS) $(LD_OPTS) $(OBJS)
+else
+# see bootstrap.mk
+$(HS_PROG) :: $(OBJS)
+	$(CC) -o $@ $(HC_BOOT_CC_OPTS) $(HC_BOOT_LD_OPTS) $(OBJS) $(HC_BOOT_LIBS)
+endif
 endif
 
 #----------------------------------------
@@ -398,19 +255,33 @@ $(C_PROG) :: $(C_OBJS)
 	$(CC) -o $@ $(CC_OPTS) $(LD_OPTS) $(C_OBJS) $(LIBS)
 endif
 
-
 #----------------------------------------
 #	Libraries/archives
+#
+# Build $(LIBRARY) from $(LIBOBJS)+$(STUBOBJS)
+#
+# Inputs:
+#   $(LIBOBJS)
+#   $(STUBOBJS)
+#
+# Outputs:
+#   Rule to build $(LIBRARY)
 
 ifneq "$(LIBRARY)" ""
 all :: $(LIBRARY)
 
-
-define BUILD_LIB
+ifneq "$(way)" "i"
+define BUILD_STATIC_LIB
 $(RM) $@
 $(AR) $(AR_OPTS) $@ $(STUBOBJS) $(LIBOBJS)
 $(RANLIB) $@
 endef
+else
+define BUILD_STATIC_LIB
+$(RM) $@
+al -out:$@ $(STUBOBJS) $(LIBOBJS)
+endef
+endif
 
 #
 # For Haskell object files, we might have chosen to split
@@ -419,27 +290,40 @@ endef
 # whether HS_SRCS is empty or not.
 #
 
+# can't split objs in way 'u', so we disable it here
+ifeq "$(way)" "u"
+SplitObjs = NO
+endif
+
 ifneq "$(HS_SRCS)" ""
 ifeq "$(SplitObjs)" "YES"
 
 SRC_HC_OPTS += -split-objs
 
-define BUILD_LIB
-$(RM) $@
-TMPDIR=$(TMPDIR); export TMPDIR; ( echo $(STUBOBJS) ; $(FIND) $(patsubst %.$(way_)o,%,$(LIBOBJS)) -name '*.$(way_)o' -print ) | xargs ar q $@
+# We generate the archive into a temporary file libfoo.a.tmp, then
+# rename it at the end.  This avoids the problem that ar may sometimes
+# fail, leaving a partially built archive behind.
+ifeq "$(ArSupportsInput)" ""
+define BUILD_STATIC_LIB
+$(RM) $@ $@.tmp
+(echo $(STUBOBJS) $(C_OBJS) $(GC_C_OBJS); $(FIND) $(patsubst %.$(way_)o,%_split,$(HS_OBJS)) -name '*.$(way_)o' -print) | xargs $(AR) $@
 $(RANLIB) $@
 endef
+else
+define BUILD_STATIC_LIB
+$(RM) $@ $@.tmp
+echo $(STUBOBJS) > $@.list
+echo $(C_OBJS) >> $@.list
+echo $(GC_C_OBJS) >> $@.list
+$(FIND) $(patsubst %.$(way_)o,%_split,$(HS_OBJS)) -name '*.$(way_)o' -print >> $@.list
+$(AR) $(AR_OPTS) $@ $(ArSupportsInput) $@.list
+$(RM) $@.list
+$(RANLIB) $@
+endef
+endif
 
 # Extra stuff for compiling Haskell files with $(SplitObjs):
 
-HC_SPLIT_PRE= \
-if [ ! -d $(basename $@) ]; then mkdir $(basename $@); else \
- $(FIND) $(basename $@) -name '*.$(way_)o' -print | xargs $(RM) __rm_food ; fi
-HC_SPLIT_POST  = touch $@
-
-SRC_HC_PRE_OPTS  += $(HC_SPLIT_PRE) ;
-SRC_HC_POST_OPTS += $(HC_SPLIT_POST) ;
-
 #
 # If (Haskell) object files are split, cleaning up 
 # consist of descending into the directories where
@@ -447,8 +331,8 @@ SRC_HC_POST_OPTS += $(HC_SPLIT_POST) ;
 #
 
 extraclean ::
-	$(FIND) $(patsubst %.$(way_)o,%,$(HS_OBJS)) -name '*.$(way_)o' -print | xargs $(RM) __rm_food
-	-rmdir $(patsubst %.$(way_)o,%,$(HS_OBJS)) > /dev/null 2>&1
+	$(FIND) $(patsubst %.$(way_)o,%_split,$(HS_OBJS)) -name '*.$(way_)o' -print -o -name ld.script -print | xargs $(RM) __rm_food
+	-rmdir $(patsubst %.$(way_)o,%_split,$(HS_OBJS)) > /dev/null 2>&1
 
 endif # $(SplitObjs)
 endif # $(HS_SRCS)
@@ -460,38 +344,48 @@ endif # $(HS_SRCS)
 ifeq "$(StripLibraries)" "YES"
 ifeq "$(SplitObjs)" "YES"
 SRC_HC_POST_OPTS += \
-  for i in $(basename $@)/*; do \
-	ld -r -x -o $$i.tmp $$i; \
+  for i in $(basename $@)_split/*.$(way_)o; do \
+	$(LD) -r $(LD_X) -o $$i.tmp $$i; \
 	$(MV) $$i.tmp $$i; \
   done
 else
 SRC_HC_POST_OPTS += \
-  ld -r -x -o $@.tmp $@; $(MV) $@.tmp $@
-endif
-endif
+  $(LD) -r $(LD_X) -o $@.tmp $@; $(MV) $@.tmp $@
+endif # SplitObjs
+endif # StripLibraries
 
-$(LIBRARY) :: $(STUBOBJS) $(LIBOBJS)
-	$(BUILD_LIB)
-endif
+# Note: $(STUBOBJS) isn't depended on here, but included when building the lib.
+#       (i.e., the assumption is that $(STUBOBJS) are created as a side-effect
+#       of building $(LIBOBJS)).
 
+ifeq "$(LIBRARY:%.so=YES)" "YES"
+# ELF styled DSO
+$(LIBRARY): $(LIBOBJS) $(LIB_DEPS)
+	$(RM) $@
+	$(HC) -shared -dynamic -o $@ $(STUBOBJS) $(LIBOBJS) $(LIB_LD_OPTS)
+else
+ifeq "$(LIBRARY:%.dylib=YES)" "YES"
+$(LIBRARY): $(LIBOBJS) $(LIB_DEPS)
+	$(HC) -shared -dynamic -o $@ $(STUBOBJS) $(LIBOBJS) $(LIB_LD_OPTS)
+else
+ifeq "$(LIBRARY:%.dll=YES)" "YES"
 #----------------------------------------
 #	Building Win32 DLLs
 #
-ifeq "$(way)" "dll"
+$(LIBRARY): $(LIBOBJS) $(LIBRARY).o $(LIB_DEPS)
+	$(HC) -shared -dynamic -o $@ $(STUBOBJS) $(LIBOBJS) $(LIBRARY).o $(LIB_LD_OPTS)
 
-ifeq "$(DLL_NAME)" ""
-DLL_NAME = $(patsubst %.a, %.dll, $(subst lib,,$(LIBRARY)))
-endif
+DLLTOOL=dlltool
 
-all :: $(DLL_NAME)
+$(LIBRARY).def: $(LIBOBJS)
+	$(DLLTOOL) -D $(LIBRARY) --output-def $@ --export-all $(LIBOBJS)
 
-ifeq "$(DLL_IMPLIB_NAME)" ""
-DLL_IMPLIB_NAME = $(patsubst %.a, %_imp.a, $(LIBRARY))
-endif
+$(LIBRARY).o:
+	$(DLLTOOL) -D $(LIBRARY) --output-exp $(LIBRARY).o $(LIBOBJS)
 
-$(DLL_NAME) :: $(LIBRARY)
-	$(BLD_DLL) --output-lib $(DLL_IMPLIB_NAME) -o $(DLL_NAME) $(LIBRARY) $(BLD_DLL_OPTS)
-endif
+# Generates library.dll.a; by MinGW conventions, this is the dll's import library
+$(LIBRARY).a: $(LIBOBJS) $(LIBRARY).def
+	$(DLLTOOL) -D $(LIBRARY) --def $(LIBRARY).def --output-lib $@
 
 #
 # Version information is baked into a DLL by having the DLL include DllVersionInfo.o.
@@ -499,7 +393,7 @@ endif
 # (both are given sensible defaults though.)
 #
 # Note: this will not work as expected with Cygwin B20.1; you need a more recent
-#       snapshot of binutils (to pick up windres bugfixes.)
+#       version of binutils (to pick up windres bugfixes.)
 
 ifndef DLL_VERSION
 DLL_VERSION=$(ProjectVersion)
@@ -529,14 +423,14 @@ endif
 # Little bit of lo-fi mangling to get at the right set of settings depending
 # on whether we're generating the VERSIONINFO for a DLL or EXE
 # 
-DLL_OR_EXE=$(subst VersionInfo.rc,,$@)
+DLL_OR_EXE=$(subst VersionInfo.$(way_)rc,,$@)
 VERSION_FT=$(subst Dll, 0x2L, $(subst Exe, 0x1L, $(DLL_OR_EXE)))
 VERSION_RES_NAME=$(subst Exe,$(EXE_VERSION_NAME), $(subst Dll, $(DLL_VERSION_NAME),$(DLL_OR_EXE)))
 VERSION_RES=$(subst Exe,$(EXE_VERSION), $(subst Dll, $(DLL_VERSION),$(DLL_OR_EXE)))
 VERSION_DESC=$(subst Exe,$(EXE_DESCRIPTION), $(subst Dll, $(DLL_DESCRIPTION),$(DLL_OR_EXE)))
 
-DllVersionInfo.rc ExeVersionInfo.rc:
-	$(RM) DllVersionInfo.rc
+DllVersionInfo.$(way_)rc ExeVersionInfo.$(way_)rc:
+	$(RM) DllVersionInfo.$(way_)rc
 	echo "1 VERSIONINFO"  		    > $@
 	echo "FILEVERSION 1,0,0,1"         >> $@
 	echo "PRODUCTVERSION 1,0,0,1"      >> $@
@@ -560,393 +454,22 @@ DllVersionInfo.rc ExeVersionInfo.rc:
 	echo "  VALUE \"Translation\", 0x0409, 1200" >> $@
 	echo " END" >> $@
 	echo "END" >> $@
-
-#----------------------------------------
-#	Script programs
-
-ifneq "$(SCRIPT_PROG)" ""
-
-# To produce a fully functional script, you may
-# have to add some configuration variables at the top of 
-# the script, i.e., the compiler driver needs to know
-# the path to various utils in the build tree for instance.
-#
-# To have the build rule for the script automatically do this
-# for you, set the variable SCRIPT_SUBST_VARS to the list of
-# variables you need to put in.
-
-#
-# SCRIPT_SUBST creates a string of echo commands that
-# will when evaluated append the (perl)variable name and its value 
-# to the target it is used for, i.e.,
-#
-#    A=foo
-#    B=bar
-#    SCRIPT_SUBST_VARS = A B
-#    SCRIPT_SUBST=echo "$""A=\"foo\";" >> $@; echo "$""B=\"bar\";" >> $@
-#
-#    so if you have a rule like the following
-#    
-#     foo:
-#         @(RM) $@
-#         @(TOUCH) $@
-#         @eval $(SCRIPT_SUBST)
-#
-#    `make foo' would create a file `foo' containing the following
-#
-#    % cat foo
-#    $A=foo;
-#    $B=bar;
-#    %
-#
-# ToDo: make this work for shell scripts (drop the initial $).
-#
-ifeq "$(INTERP)" "$(SHELL)"
-SCRIPT_SUBST=$(foreach val,$(SCRIPT_SUBST_VARS),"echo \"$(val)=\\\"$($(val))\\\";\" >> $@;")
-else
-SCRIPT_SUBST=$(foreach val,$(SCRIPT_SUBST_VARS),"echo \"$$\"\"$(val)=\\\"$($(val))\\\";\" >> $@;")
-endif
-
-all :: $(SCRIPT_PROG)
-
-#
-# #! support under cygwin32 is not quite there yet, 
-# so we rely on the eval `trick' instead. On all other
-# platforms, we prepend #!$(INTERP)  -- SOF 6/97
-# 
-
-$(SCRIPT_PROG) :: $(SCRIPT_OBJS)
-	$(RM) $@
-	@echo Creating $@...
-ifeq "$(INTERP)" "perl"
-	echo "#! "$(PERL) > $@
 else
-ifneq "$(INTERP)" ""
-	@echo "#!"$(INTERP) > $@
-else
-	@touch $@
-endif
-endif
-ifneq "$(SCRIPT_PREFIX_FILES)" ""
-	@cat $(SCRIPT_PREFIX_FILES) >> $@
-endif
-	@eval $(SCRIPT_SUBST) 
-	@cat $(SCRIPT_OBJS) >> $@
-	@chmod a+x $@
-	@echo Done.
-endif
-
-# links to script programs: we sometimes install a script as
-# <name>-<version> with a link from <name> to the real script.
+# Regular static library
+$(LIBRARY): $(LIBOBJS)
+	$(BUILD_STATIC_LIB)
+endif # %.dll
+endif # %.dylib
+endif # %.so
+endif # LIBRARY = ""
 
-ifneq "$(SCRIPT_LINK)" ""
-all :: $(SCRIPT_LINK)
+include $(TOP)/mk/install.mk
 
+##############################################################################
 #
-# Don't want to overwrite $(SCRIPT_LINK)s that aren't symbolic
-# links. Testing for symbolic links is problematic to do in
-# a portable fashion using a /bin/sh test, so we simply rely
-# on perl.
+#	Targets: check tags show
 #
-$(SCRIPT_LINK) : $(SCRIPT_PROG)
-	@if ( $(PERL) -e '$$fn="$(SCRIPT_LINK)"; exit ((! -f $$fn || -l $$fn) ? 0 : 1);' ); then \
-	   echo "Creating a symbolic link from $(SCRIPT_PROG) to $(SCRIPT_LINK)"; \
-	   $(RM) $(SCRIPT_LINK); \
-	   $(LN_S) $(SCRIPT_PROG) $(SCRIPT_LINK); \
-	 else \
-	   echo "Creating a symbolic link from $(SCRIPT_PROG) to $(SCRIPT_LINK) failed: \`$(SCRIPT_LINK)' already exists"; \
-	   echo "Perhaps remove \`$(SCRIPT_LINK)' manually?"; \
-	   exit 1; \
-	 fi;
-endif
-
-
-
-###########################################
-#
-#	Targets: install install-strip uninstall
-#
-###########################################
-
-# For each of these variables that is defined, you
-# get one install rule
-#
-#	INSTALL_PROGS 	     executable programs in $(bindir)
-#	INSTALL_SCRIPTS	     executable scripts in $(bindir)
-#	INSTALL_LIBS	     platform-dependent libraries in $(libdir) (ranlib'ed)
-#	INSTALL_LIB_SCRIPTS  platform-dependent scripts   in $(libdir)
-#	INSTALL_LIBEXECS     platform-dependent execs in $(libdir)
-#	INSTALL_DATAS	     platform-independent files in $(datadir)
-#
-# If the installation directory variable is undefined, the install rule simply
-# emits a suitable error message.
-#
-# Remember, too, that the installation directory variables ($(bindir) and
-# friends can be overridden from their original settings in mk/config.mk.in
-# || mk/build.mk
-#
-.PHONY: install installdirs install-strip install-dirs uninstall install-docs show-install
-
-show-install :
-	@echo "bindir = $(bindir)"
-	@echo "libdir = $(libdir)"
-	@echo "libexecdir = $(libexecdir)  # by default, same as libdir"
-	@echo "datadir = $(datadir)  # unused for ghc project"
-
-#
-# Sometimes useful to separate out the creation of install directories 
-# from the installation itself.
-#
-install-dirs ::
-	@$(INSTALL_DIR) $(bindir)
-	@$(INSTALL_DIR) $(libdir)
-	@$(INSTALL_DIR) $(libexecdir)
-	@$(INSTALL_DIR) $(datadir)
-
-# Better do this first...
-# but we won't for the moment, do it on-demand from
-# within the various install targets instead.
-#install:: install-dirs
-
-ifneq "$(INSTALL_PROGS)" ""
-
-#
-# Here's an interesting one - when using the win32 version
-# of install (provided via the cygwin toolkit), we have to
-# supply the .exe suffix, *if* there's no other suffix.
-#
-# The rule below does this by ferreting out the suffix of each
-# entry in the INSTALL_PROGS list. If there's no suffix, use
-# $(exeext).
-# 
-# This is bit of a pain to express since GNU make doesn't have
-# something like $(if ...), but possible using $(subst ..)
-# [Aside: I added support for $(if ..) to my local copy of GNU
-# make at one stage, perhaps I should propagate the patch to
-# the GNU make maintainers..] 
-#
-INSTALL_PROGS := $(foreach p, $(INSTALL_PROGS), $(addsuffix $(subst _,,$(subst __,$(exeext),_$(suffix $(p))_)), $(basename $(p))))
-
-install:: $(INSTALL_PROGS)
-	@$(INSTALL_DIR) $(bindir)
-	@for i in $(INSTALL_PROGS); do \
-		    echo $(INSTALL_PROGRAM) $(INSTALL_BIN_OPTS) $$i $(bindir); \
-		    $(INSTALL_PROGRAM) $(INSTALL_BIN_OPTS) $$i $(bindir) ;  \
-	done
-endif
-
-#
-# Just like INSTALL_PROGS, but prefix with install sites bin/lib/data and
-# install without stripping.
-#
-ifneq "$(INSTALL_SCRIPTS)" ""
-install:: $(INSTALL_SCRIPTS)
-	@$(INSTALL_DIR) $(bindir)
-	for i in $(INSTALL_SCRIPTS); do \
-		$(INSTALL_SCRIPT) $(INSTALL_OPTS) $$i $(bindir); \
-	done
-endif
-
-ifneq "$(INSTALL_LIB_SCRIPTS)" ""
-install:: $(INSTALL_LIB_SCRIPTS)
-	@$(INSTALL_DIR) $(libdir)
-	for i in $(INSTALL_LIB_SCRIPTS); do \
-		$(INSTALL_SCRIPT) $(INSTALL_OPTS) $$i $(libdir); \
-	done
-endif
-
-ifneq "$(INSTALL_LIBEXEC_SCRIPTS)" ""
-install:: $(INSTALL_LIBEXEC_SCRIPTS)
-	@$(INSTALL_DIR) $(libexecdir)
-	for i in $(INSTALL_LIBEXEC_SCRIPTS); do \
-		$(INSTALL_SCRIPT) $(INSTALL_OPTS) $$i $(libexecdir); \
-	done
-endif
-
-ifneq "$(INSTALL_LIBS)" ""
-install:: $(INSTALL_LIBS)
-	@$(INSTALL_DIR) $(libdir)
-	for i in $(INSTALL_LIBS); do \
-		case $$i in \
-		  *.a) \
-		    $(INSTALL_DATA) $(INSTALL_OPTS) $$i $(libdir); \
-		    $(RANLIB) $(libdir)/`basename $$i` ;; \
-		  *.dll) \
-		    $(INSTALL_DATA) -s $(INSTALL_OPTS) $$i $(libdir) ;; \
-		  *) \
-		    $(INSTALL_DATA) $(INSTALL_OPTS) $$i $(libdir); \
-		esac; \
-	done
-endif
-
-ifneq "$(INSTALL_LIBEXECS)" ""
-#
-# See above comment next to defn of INSTALL_PROGS for what
-# the purpose of this one-liner is.
-# 
-INSTALL_LIBEXECS := $(foreach p, $(INSTALL_LIBEXECS), $(addsuffix $(subst _,,$(subst __,$(exeext),_$(suffix $(p))_)), $(basename $(p))))
-
-install:: $(INSTALL_LIBEXECS)
-	@$(INSTALL_DIR) $(libexecdir)
-	-for i in $(INSTALL_LIBEXECS); do \
-		$(INSTALL_PROGRAM) $(INSTALL_BIN_OPTS) $$i $(libexecdir); \
-	done
-endif
-
-ifneq "$(INSTALL_DATAS)" ""
-install:: $(INSTALL_DATAS)
-	@$(INSTALL_DIR) $(datadir)
-	for i in $(INSTALL_DATAS); do \
-		$(INSTALL_DATA) $(INSTALL_OPTS) $$i $(datadir); \
-	done
-endif
-
-ifneq "$(INSTALL_INCLUDES)" ""
-install:: $(INSTALL_INCLUDES)
-	@$(INSTALL_DIR) $(includedir)
-	for i in $(INSTALL_INCLUDES); do \
-		$(INSTALL_DATA) $(INSTALL_OPTS) $$i $(includedir); \
-	done
-endif
-
-#
-# Use with care..
-#
-uninstall:: 
-	@for i in $(INSTALL_PROGS) "" ; do			\
-	  if test "$$i"; then 					\
-		echo rm -f $(bindir)/`basename $$i`;		\
-		rm -f $(bindir)/`basename $$i`;			\
-	  fi; 							\
-	done
-	@for i in $(INSTALL_LIBS) ""; do			\
-	  if test "$$i"; then 					\
-		echo rm -f $(libdir)/`basename $$i`;		\
-		rm -f $(libdir)/`basename $$i`;			\
-	  fi;							\
-	done
-	@for i in $(INSTALL_LIBEXECS) ""; do			\
-	  if test "$$i"; then 					\
-		echo rm -f $(libexecdir)/`basename $$i`;	\
-		rm -f $(libexecdir)/`basename $$i`;		\
-	  fi;							\
-	done
-	@for i in $(INSTALL_DATAS) ""; do			\
-	  if test "$$i"; then 					\
-		echo rm -f $(datadir)/`basename $$i`;		\
-		rm -f $(datadir)/`basename $$i`;		\
-	  fi;							\
-	done
-
-#
-# install-strip is from the GNU Makefile standard.
-#
-ifneq "$(way)" ""
-install-strip::
-	@$(MAKE) EXTRA_INSTALL_OPTS='-s' install                                	
-endif
-
-#
-# install links to script drivers.
-#
-ifneq "$(SCRIPT_LINK)" ""
-install ::
-	@if ( $(PERL) -e '$$fn="$(bindir)/$(SCRIPT_LINK)"; exit ((! -f $$fn || -l $$fn) ? 0 : 1);' ); then \
-	   echo "Creating a symbol link from $(SCRIPT_PROG) to $(SCRIPT_LINK) in $(bindir)"; \
-	   $(RM) $(bindir)/$(SCRIPT_LINK); \
-	   $(LN_S) $(SCRIPT_PROG) $(bindir)/$(SCRIPT_LINK); \
-	 else \
-	   echo "Creating a symbol link from $(SCRIPT_PROG) to $(SCRIPT_LINK) in $(bindir) failed: \`$(bindir)/$(SCRIPT_LINK)' already exists"; \
-	   echo "Perhaps remove \`$(bindir)/$(SCRIPT_LINK)' manually?"; \
-	   exit 1; \
-	 fi;
-
-endif
-
-###########################################
-#
-#	Targets: dist binary-dist
-#
-###########################################
-
-
-#
-# dist-pre is a canned rule the toplevel of your source tree
-# would use as follows, 
-#
-#  dist :: dist-pre
-#
-# it performs two tasks, first creating the distribution directory
-# tree and it then decorates the new tree with symbolic links pointing
-# to the symbolic links in the build tree.
-#
-# The dist-pre relies on (at least) the `find' in GNU findutils
-# (only tested with version 4.1). All non-GNU `find's I have
-# laid on my hands locally, has a restrictive treatment of {} in
-# -exec commands, i.e.,
-#
-#   find . -print echo a{} \;
-#   
-# does not expand the {}, it has to be a separate argument (i.e. `a {}').
-# GNU find is (IMHO) more sensible here, expanding any {} it comes across
-# inside an -exec, whether it is a separate arg or part of a word:
-#
-#  $ touch yes
-#  $ find --version
-#    GNU find version 4.1
-#  $ find yes -exec echo oh,{}! \;
-#    oh,yes!
-#
-# Of course, the above is not impossible to achieve with other finds,
-# just that GNU find does the Patently Right Thing here :)
-#
-# ====> if you're using these dist rules, get hold of GNU findutils.
-#
-#  --SOF 2/97
-#
-.PHONY: dist dist-pre dist-post
-
-#
-# The dist rules leaves out CVS, SRC (from mkshadowdir) and tests
-# directories when creating shadow source distrib tree
-#
-dist-pre::
-	-rm -rf $(SRC_DIST_DIR)
-	-rm -f $(SRC_DIST_NAME).tar.gz
-	(cd $(FPTOOLS_TOP_ABS); $(FIND) $(SRC_DIST_DIRS) -type d \( -name CVS -prune -o -name SRC -prune -o -name tests -prune -o -exec $(MKDIRHIER) $(SRC_DIST_DIR)/{} \; \) ; )
-	(cd $(FPTOOLS_TOP_ABS); $(FIND) $(SRC_DIST_DIRS) -name CVS -prune -o -name SRC -prune -o -name tests -prune -o -name "*~" -prune -o -name ".cvsignore" -prune -o -name "\#*" -prune -o -name ".\#*" -prune -o -type l -exec $(LN_S) $(FPTOOLS_TOP_ABS)/{} $(SRC_DIST_DIR)/{} \; )
-
-#
-# After having created a shadow distribution tree and copied/linked
-# all the necessary files to it, `dist-post' makes sure the permissions
-# are set right and then package up the tree. Empty directories are also removed.
-#
-# For now, we make the packaging a separate rule, so as to allow
-# the inspection of the dist tree before eventually packaging it up.
-#
-dist-post::
-	@echo Deleting the following empty directories..
-	( cd $(SRC_DIST_DIR) ; cd .. ; $(FIND) $(SRC_DIST_NAME) -type d -exec sh -c 'test x`ls $$0 | wc -l | sed -e "s/ //g"` = x0' {} \; -print -exec rm -rf {} \; -prune )
-	( cd $(SRC_DIST_DIR) ; cd .. ; chmod -R a+rw $(SRC_DIST_NAME) ) 
-
-# Automatic generation of a MANIFEST file for a source distribution
-# tree that is ready to go.
-dist-manifest ::
-	cd $(SRC_DIST_DIR); $(FIND) . \( -type l -o -type f \) -exec ls -lLG {} \; | sed -e 's/\.\///' > /tmp/MANIFEST ; mv /tmp/MANIFEST MANIFEST
-
-dist-package:: dist-package-tar-gz
-
-dist-package-tar-gz ::
-	cd $(SRC_DIST_DIR); cd ..; $(TAR) chzf $(SRC_DIST_NAME).tar.gz $(SRC_DIST_NAME)
-
-dist-package-zip ::
-	cd $(SRC_DIST_DIR); cd ..; $(ZIP) $(ZIP_OPTS) -r $(SRC_DIST_NAME).zip $(SRC_DIST_NAME)
-
-###########################################
-#
-#	Targets: check tags show info
-#
-###########################################
+##############################################################################
 
 #------------------------------------------------------------
 # 			Check
@@ -970,76 +493,66 @@ tags TAGS:: $(TAGS_HS_SRCS) $(TAGS_C_SRCS)
 	@$(RM) TAGS
 	@touch TAGS
 ifneq "$(TAGS_HS_SRCS)" ""
-	$(HSTAGS) $(HSTAGS_OPTS) -- $(TAGS_HS_SRCS)
+	$(HSTAGS) $(HSTAGS_OPTS) $(TAGS_HS_SRCS)
 endif
 ifneq "$(TAGS_C_SRCS)" ""
 	etags -a $(TAGS_C_SRCS)
 endif
 	@( DEREFFED=`ls -l Makefile | sed -e 's/.*-> \(.*\)/\1/g'` && $(RM) `dirname $$DEREFFED`/TAGS && $(CP) TAGS `dirname $$DEREFFED` ) 2>/dev/null || echo TAGS file generated, perhaps copy over to source tree?
 
-#------------------------------------------------------------
-# 			Makefile debugging
-# to see the effective value used for a Makefile variable, do
-#  make show VALUE=MY_VALUE
+################################################################################
 #
-
-show:
-	@echo '$(VALUE)=$($(VALUE))'
-
-#--------------------------------------------------------------------------
-# SGML Documentation
+#			DocBook XML Documentation
 #
-.PHONY: dvi ps html pdf rtf
+################################################################################
 
-ifneq "$(SGML_DOC)" ""
+.PHONY: html html-no-chunks chm HxS fo dvi ps pdf
 
-# multi-file SGML document: main document name is specified in $(SGML_DOC),
-# sub-documents (.sgml files) listed in $(SGML_SRCS).
+ifneq "$(XML_DOC)" ""
 
-ifeq "$(VSGML_SRCS)" ""
-VSGML_SRCS = $(wildcard *.vsgml)
-endif
+all :: $(XMLDocWays)
 
-ifeq "$(SGML_SRCS)" ""
-ifneq "$(VSGML_SRCS)" ""
-SGML_SRCS = $(patsubst %.vsgml, %.sgml, $(VSGML_SRCS))
-else
-SGML_SRCS = $(wildcard *.sgml)
-endif
+# multi-file XML document: main document name is specified in $(XML_DOC),
+# sub-documents (.xml files) listed in $(XML_SRCS).
+
+ifeq "$(XML_SRCS)" ""
+XML_SRCS = $(wildcard *.xml)
 endif
 
-SGML_TEX  = $(SGML_DOC).tex
-SGML_DVI  = $(SGML_DOC).dvi
-SGML_PS   = $(SGML_DOC).ps
-SGML_PDF  = $(SGML_DOC).pdf
-SGML_RTF  = $(SGML_DOC).rtf
-SGML_HTML = $(SGML_DOC).html
-# HTML output goes in a subdirectory on its own.
-SGML_TEXT = $(SGML_DOC).txt
+XML_HTML           = $(addsuffix /index.html,$(basename $(XML_DOC)))
+XML_HTML_NO_CHUNKS = $(addsuffix .html,$(XML_DOC))
+XML_CHM            = $(addsuffix .chm,$(XML_DOC))
+XML_HxS            = $(addsuffix .HxS,$(XML_DOC))
+XML_FO             = $(addsuffix .fo,$(XML_DOC))
+XML_DVI            = $(addsuffix .dvi,$(XML_DOC))
+XML_PS             = $(addsuffix .ps,$(XML_DOC))
+XML_PDF            = $(addsuffix .pdf,$(XML_DOC))
 
-$(SGML_DVI) $(SGML_PS) $(SGML_INFO) $(SGML_HTML) $(SGML_TEXT) :: $(SGML_SRCS)
+$(XML_HTML) $(XML_NO_CHUNKS_HTML) $(XML_FO) $(XML_DVI) $(XML_PS) $(XML_PDF) :: $(XML_SRCS)
 
-dvi  :: $(SGML_DVI)
-ps   :: $(SGML_PS)
-pdf  :: $(SGML_PDF)
-rtf  :: $(SGML_RTF)
-html :: $(SGML_HTML)
-txt  :: $(SGML_TEXT)
+html           :: $(XML_HTML)
+html-no-chunks :: $(XML_HTML_NO_CHUNKS)
+chm            :: $(XML_CHM)
+HxS            :: $(XML_HxS)
+fo             :: $(XML_FO)
+dvi            :: $(XML_DVI)
+ps             :: $(XML_PS)
+pdf            :: $(XML_PDF)
 
-CLEAN_FILES += $(SGML_TEXT) $(SGML_TEX) $(SGML_PS) $(SGML_DVI) $(SGML_PDF) $(SGML_RTF) $(SGML_HTML) $(SGML_DOC)-*.html
-# can't use $(SGML_SRCS) here, it was maybe used elsewhere
-MOSTLY_CLEAN_FILES += $(patsubst %.vsgml, %.sgml, $(VSGML_SRCS))
+CLEAN_FILES += $(XML_HTML_NO_CHUNKS) $(XML_FO) $(XML_DVI) $(XML_PS) $(XML_PDF)
 
 extraclean ::
-	$(RM) -rf $(SGML_DOC)
+	$(RM) -rf $(XML_DOC).out $(FPTOOLS_CSS) $(basename $(XML_DOC)) $(basename $(XML_DOC))-htmlhelp
 
+validate ::
+	$(XMLLINT) --valid --noout $(XMLLINT_OPTS) $(XML_DOC).xml
 endif
 
-###########################################
+##############################################################################
 #
 #	Targets: clean
 #
-###########################################
+##############################################################################
 
 # we have to be careful about recursion here; since all the clean
 # targets are recursive, we don't want to make eg. distclean depend on
@@ -1062,13 +575,13 @@ distclean:: extraclean
 maintainer-clean:: extraclean
 	@echo 'This command is intended for maintainers to use; it'
 	@echo 'deletes files that may need special tools to rebuild.'
-	rm -f $(MOSTLY_CLEAN_FILES) $(CLEAN_FILES) $(MAINTAINER_CLEAN_FILES)
+	rm -f $(MOSTLY_CLEAN_FILES) $(CLEAN_FILES) $(DIST_CLEAN_FILES) $(MAINTAINER_CLEAN_FILES)
 
-#################################################################################
+################################################################################
 #
 #			Way management
 #
-#################################################################################
+################################################################################
 
 # Here is the ingenious jiggery pokery that allows you to build multiple versions
 # of a program in a single build tree.
@@ -1078,6 +591,11 @@ maintainer-clean:: extraclean
 # Expects:	$(WAYS)			the possible "way" strings to one of 
 #					which $(way) will be set
 
+ifneq "$(way)" ""
+ifeq "$(findstring $(way), $(WAYS))" ""
+$(error Unknown way $(way) of $(WAYS))
+endif
+endif
 
 # So how does $(way) ever get set to anything?  Answer, we recursively
 # invoke make, setting $(way) on the command line.
@@ -1103,7 +621,8 @@ ifeq "$(way)" ""
 FPTOOLS_SUFFIXES := o hi hc
 
 WAY_TARGETS     = $(foreach way,$(WAYS),$(foreach suffix, $(FPTOOLS_SUFFIXES), %.$(way)_$(suffix)))
-LIB_WAY_TARGETS = $(foreach way,$(WAYS),%_$(way).a %_$(way))
+LIB_WAY_TARGETS = $(foreach way,$(filter-out %dyn,$(WAYS)), %_$(way).a)
+LIB_WAY_TARGETS_DYN =  $(foreach way,$(filter %dyn,$(WAYS)), %$(subst dyn,-ghc$(ProjectVersion),$(subst _dyn,dyn,$(way)))$(soext))
 
 # $@ will be something like Foo.p_o
 # $(suffix $@)     returns .p_o
@@ -1121,9 +640,22 @@ $(WAY_TARGETS) :
 $(LIB_WAY_TARGETS) :
 	$(MAKE) $(MFLAGS) $@ way=$(subst .,,$(suffix $(subst _,.,$(basename $@))))
 
+$(LIB_WAY_TARGETS_DYN) :
+	$(MAKE) $(MFLAGS) $@ way=$(patsubst _dyn,dyn,$(subst .,,$(suffix $(subst _,.,$(basename $(subst -ghc$(ProjectVersion),,$@)))))_dyn)
+
 endif	# if way
 
-ifneq "$(WAYS)" ""
+# -------------------------------------------------------------------------
+# Object and interface files have suffixes tagged with their ways
+
+ifneq "$(way)" ""
+SRC_HC_OPTS += -hisuf $(way_)hi -hcsuf $(way_)hc -osuf $(way_)o
+endif
+
+# -------------------------------------------------------------------------
+# Rules to invoke the current target recursively for each way
+
+ifneq "$(strip $(WAYS))" ""
 ifeq "$(way)" ""
 
 # NB: the targets exclude 
@@ -1131,23 +663,39 @@ ifeq "$(way)" ""
 # since these are way-independent
 all docs TAGS clean distclean mostlyclean maintainer-clean install ::
 	@echo "------------------------------------------------------------------------"
-	@echo "===fptools== Recursively making \`$@' for ways: $(WAYS) ..."
+	@echo "== Recursively making \`$@' for ways: $(WAYS) ..."
 	@echo "PWD = $(shell pwd)"
 	@echo "------------------------------------------------------------------------"
 # Don't rely on -e working, instead we check exit return codes from sub-makes.
-	@case '${MFLAGS}' in *-[ik]*) x_on_err=0;; *-r*[ik]*) x_on_err=0;; *) x_on_err=1;; esac; \
+	case '${MFLAGS}' in *-[ik]*) x_on_err=0;; *-r*[ik]*) x_on_err=0;; *) x_on_err=1;; esac; \
 	for i in $(WAYS) ; do \
 	  echo "------------------------------------------------------------------------"; \
-	  echo "==fptools== $(MAKE) way=$$i $@;"; \
+	  echo "== $(MAKE) way=$$i $@;"; \
 	  echo "PWD = $(shell pwd)"; \
 	  echo "------------------------------------------------------------------------"; \
 	  $(MAKE) way=$$i --no-print-directory $(MFLAGS) $@ ; \
 	  if [ $$? -eq 0 ] ; then true; else exit $$x_on_err; fi; \
 	done
 	@echo "------------------------------------------------------------------------"
-	@echo "===fptools== Finished recursively making \`$@' for ways: $(WAYS) ..."
+	@echo "== Finished recursively making \`$@' for ways: $(WAYS) ..."
 	@echo "PWD = $(shell pwd)"
 	@echo "------------------------------------------------------------------------"
 
 endif
 endif
+
+include $(TOP)/mk/recurse.mk
+
+# -----------------------------------------------------------------------------
+# Further cleaning
+
+# Sometimes we want to clean things only after the recursve cleaning
+# has heppened (eg. if the files we're about to remove would affect
+# the recursive traversal).
+
+distclean::
+	rm -f $(LATE_DIST_CLEAN_FILES)
+
+maintainer-clean::
+	rm -f $(LATE_DIST_CLEAN_FILES)
+