X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=mk%2Ftarget.mk;h=37a72bcc0c5243ea24035e699e072891191d3da0;hp=51fdbe5cf78249a9d505ee08690b39810f43ee71;hb=74e1368d4688ee16f6decdf2cd3ebe27506b26ba;hpb=aa6ee0a8e05fa52c45160ee3292de8f9f4fca70c diff --git a/mk/target.mk b/mk/target.mk index 51fdbe5..37a72bc 100644 --- a/mk/target.mk +++ b/mk/target.mk @@ -2,23 +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* -# dvi ps (no info) FPTOOLS adds: pdf rtf html +# dvi ps (no info) GHC adds: pdf rtf html chm HxS # check # # 3. Some of the above targets have a version that @@ -32,93 +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" -# propagates "make " to directories in SUBDIRS -# -# (b) when SUBDIRS is empty, -# for each "multi-way-target" -# calls "make way=w " 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" +PRE_SRCS := $(ALL_SRCS) -ifneq "$(SUBDIRS)" "" +################################################################## +# Include package building machinery +# NB. needs to be after PRE_SRCS setting above, because otherwise the +# rule dependencies won't be set correctly. -# we override the boot & all targets in the top level Makefile -ifneq "$(NO_ALL_TARGETS)" "YES" -ALL_TARGET = all -BOOT_TARGET = boot -INSTALL_TARGET = install -endif +include $(TOP)/mk/package.mk -$(ALL_TARGET) docs runtests $(BOOT_TARGET) TAGS clean distclean mostlyclean maintainer-clean $(INSTALL_TARGET) 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 "------------------------------------------------------------------------" +################################################################### +# Suffix rules for Haskell, C and literate -endif - -# -# Selectively building subdirectories. -# -# -ifneq "$(SUBDIRS)" "" -$(SUBDIRS) :: - $(MAKE) -C $@ $(MFLAGS) -endif +include $(TOP)/mk/suffix.mk ################################################################## -# FPtools standard targets +# GHC standard targets # # depend: # @@ -145,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)" "" @@ -155,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),-osuf $(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 @@ -165,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 @@ -194,11 +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. # -# `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 @@ -238,7 +181,7 @@ boot :: depend # `TAGS' # Update a tags table for this program. # -# `dvi' `ps' `pdf' `html' `pdf' +# `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. @@ -262,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) @@ -280,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 @@ -294,29 +236,15 @@ ifneq "$(HS_PROG)" "" all :: $(HS_PROG) ifneq "$(BootingFromHc)" "YES" -$(HS_PROG) :: $(HS_OBJS) - $(HC) -o $@ $(HC_OPTS) $(LD_OPTS) $(HS_OBJS) +$(HS_PROG) :: $(OBJS) + $(HC) -o $@ $(HC_OPTS) $(LD_OPTS) $(OBJS) else -# see bootstrp.mk -$(HS_PROG) :: $(HS_OBJS) - $(CC) -o $@ $(HC_BOOT_CC_OPTS) $(HC_BOOT_LD_OPTS) $(HS_OBJS) $(HC_BOOT_LIBS) +# see bootstrap.mk +$(HS_PROG) :: $(OBJS) + $(CC) -o $@ $(HC_BOOT_CC_OPTS) $(HC_BOOT_LD_OPTS) $(OBJS) $(HC_BOOT_LIBS) endif endif -# 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 - -# add syslib dependencies and current package name -SRC_HC_OPTS += $(patsubst %, -package %, $(PACKAGE_DEPS)) -ifneq "$(PACKAGE)" "" -SRC_HC_OPTS += -package-name $(PACKAGE) -else -# No library, we are actually building the tools -SRC_HC_OPTS += $(FptoolsHcOpts) -endif - #---------------------------------------- # C programs @@ -327,65 +255,10 @@ $(C_PROG) :: $(C_OBJS) $(CC) -o $@ $(CC_OPTS) $(LD_OPTS) $(C_OBJS) $(LIBS) endif - -#---------------------------------------- -# Building HsLibs libraries. -# -# Inputs: -# $(PACKAGE) is the name of the library to build -# $(IS_CBITS_LIB) should be "YES" for a "cbits" library -# -# Outputs: -# $(LIBRARY) the name of the library.a -# $(GHIC_LIBRARY) the name of the library.o (for GHCi) -# $(LIBOBJS) objects to put in library -# $(STUBOBJS) more objects to put in library -# -# $(LIBOBJS) is set to $(HS_OBJS) or $(C_OBJS) depending -# on whether or not it's a "cbits" library. But you can -# override this by setting $(LIBOBJS) yourself - -ifneq "$(PACKAGE)" "" - -ifeq "$(IS_CBITS_LIB)" "YES" -_cbits := _cbits -STUBOBJS += $(HSC_C_OBJS) -# Add _hsc.c files to the cbits library -SRCS += $(wildcard ../*_hsc.c) -# Make .hsc.h include files from the directory above visible -SRC_CC_OPTS += -I.. -endif - -LIBRARY = libHS$(PACKAGE)$(_cbits)$(_way).a -GHCI_LIBRARY = HS$(PACKAGE)$(_cbits)$(_way).o - -ifneq "$(IS_CBITS_LIB)" "YES" -WAYS=$(GhcLibWays) -endif - -ifeq "$(LIBOBJS)" "" - ifeq "$(IS_CBITS_LIB)" "YES" - LIBOBJS = $(C_OBJS) - else - LIBOBJS = $(HS_OBJS) - endif -endif - -SRC_CC_OPTS += -I$(GHC_INCLUDE_DIR) -I$(GHC_RUNTIME_DIR) - -ifeq "$(IS_CBITS_LIB)" "YES" -override datadir:=$(libdir)/includes -INSTALL_DATAS += Hs$(shell perl -e 'print ucfirst "$(PACKAGE)"').h -else -SRC_CC_OPTS += -Icbits -endif - -endif # PACKAGE - #---------------------------------------- # Libraries/archives # -# Build $(LIBRARY) from $(LIBOJBS)+$(STUBOBJS) +# Build $(LIBRARY) from $(LIBOBJS)+$(STUBOBJS) # # Inputs: # $(LIBOBJS) @@ -397,11 +270,18 @@ endif # PACKAGE 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 @@ -410,33 +290,39 @@ 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" -# can't split objs in way 'u', so we disable it here -ifneq "$(way)" "u" - SRC_HC_OPTS += -split-objs -define BUILD_LIB -$(RM) $@ -(echo $(STUBOBJS); $(FIND) $(patsubst %.$(way_)o,%,$(LIBOBJS)) -name '*.$(way_)o') | 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 - -# Extra stuff for compiling Haskell files with $(SplitObjs): - -HC_SPLIT_PRE = \ - $(RM) $@; if [ ! -d $(basename $@) ]; then mkdir $(basename $@); else \ - $(FIND) $(basename $@) -name '*.$(way_)o' | xargs $(RM) __rm_food; fi -ifeq "$(GhcWithInterpreter)" "YES" -HC_SPLIT_POST = ld -r -x -o $@ $(basename $@)/*.$(way_)o else -HC_SPLIT_POST = touch $@ -endif # GhcWithInterpreter == YES +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 -SRC_HC_PRE_OPTS += $(HC_SPLIT_PRE); -SRC_HC_POST_OPTS += $(HC_SPLIT_POST); +# Extra stuff for compiling Haskell files with $(SplitObjs): # # If (Haskell) object files are split, cleaning up @@ -445,10 +331,9 @@ 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 # $(way) == u endif # $(SplitObjs) endif # $(HS_SRCS) @@ -459,124 +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 $@ + $(LD) -r $(LD_X) -o $@.tmp $@; $(MV) $@.tmp $@ endif # SplitObjs endif # StripLibraries -$(LIBRARY) :: $(STUBOBJS) $(LIBOBJS) - $(BUILD_LIB) -endif # LIBRARY = "" - -#-------------------------------------------------------------- -# Build dynamically-linkable libraries for GHCi -# -# Build $(GHCI_LIBRARY) from $(LIBOBJS)+$(STUBOBJS) -# -# Why? GHCi can only link .o files (at the moment), not .a files -# so we have to build libFoo.o as well as libFoo.a -# -# Furthermore, GHCi currently never loads -# profiling libraries (or other non-std ways) -# -# Inputs: -# $(GHCI_LIBRARY) -# -# Outputs: -# Rule to build $(GHCI_LIBRARY) - - -ifneq "$(GHCI_LIBRARY)" "" -ifeq "$(way)" "" -ifeq "$(GhcWithInterpreter)" "YES" - - -INSTALL_LIBS += $(GHCI_LIBRARY) -CLEAN_FILES += $(GHCI_LIBRARY) - -all :: $(GHCI_LIBRARY) - -ifneq "$(GHCI_LIBRARY)" "HSstd.o" -# An annoying gotcha is that the Prelude is a bit special, -# for reasons described in ghc/lib/std/Makefile. -# So we only put in this standard rule for packages other than std -# The rule for the Prelude is in ghc/lib/std/Makefile -# We check for GHCI_LIBRARY being HSstd.o rather than -# PACKAGE being std, because we want to still use the boilerplate rule -# for cbits. -$(GHCI_LIBRARY) :: $(LIBOBJS) - ld -r -x -o $@ $(LIBOBJS) $(STUBOBJS) -endif - -endif # GhcWithInterpreter -endif # way -endif # GHCI_LIBRARY - +# 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 # +$(LIBRARY): $(LIBOBJS) $(LIBRARY).o $(LIB_DEPS) + $(HC) -shared -dynamic -o $@ $(STUBOBJS) $(LIBOBJS) $(LIBRARY).o $(LIB_LD_OPTS) -ifeq "$(DLLized)" "YES" +DLLTOOL=dlltool -ifneq "$(PACKAGE)" "" +$(LIBRARY).def: $(LIBOBJS) + $(DLLTOOL) -D $(LIBRARY) --output-def $@ --export-all $(LIBOBJS) -SRC_BLD_DLL_OPTS += --export-all --output-def=HS$(PACKAGE)$(_cbits)$(_way).def DllVersionInfo.$(way_)o +$(LIBRARY).o: + $(DLLTOOL) -D $(LIBRARY) --output-exp $(LIBRARY).o $(LIBOBJS) -ifneq "$(PACKAGE) $(IS_CBITS_LIB)" "std YES" -ifneq "$(PACKAGE)" "rts" -SRC_BLD_DLL_OPTS += -lHSstd_cbits_imp -L$(GHC_LIB_DIR)/std/cbits -SRC_BLD_DLL_OPTS += -lHSrts_$(way_)imp -L$(GHC_RUNTIME_DIR) -ifneq "$(PACKAGE)" "std" - ifeq "$(IS_CBITS_LIB)" "" - SRC_BLD_DLL_OPTS += -lHSstd_$(way_)imp -L$(GHC_LIB_DIR)/std - endif -endif -endif -endif - -SRC_BLD_DLL_OPTS += -lgmp -L. -L$(GHC_RUNTIME_DIR)/gmp -ifeq "$(IS_CBITS_LIB)" "" -SRC_BLD_DLL_OPTS += $(patsubst %,-lHS%_$(way_)imp, $(PACKAGE_DEPS)) -SRC_BLD_DLL_OPTS += $(patsubst %,-L../%, $(PACKAGE_DEPS)) -endif -ifneq "$(HAS_CBITS)" "" -SRC_BLD_DLL_OPTS += -lHS$(PACKAGE)_cbits_imp -Lcbits -endif -SRC_BLD_DLL_OPTS += -lwsock32 -lwinmm - -endif # PACKAGE != "" - -SplitObjs = NO - -ifneq "$(LIBRARY)" "" - -all :: DllVersionInfo.$(way_)o - -ifeq "$(DLL_NAME)" "" -DLL_NAME = $(patsubst %.a,%.dll,$(subst lib,,$(LIBRARY))) -endif - -ifneq "$(DLL_NAME)" "" -DLL_NAME := $(DLL_PEN)/$(DLL_NAME) -endif - -all :: $(DLL_NAME) - -ifeq "$(DLL_IMPLIB_NAME)" "" -DLL_IMPLIB_NAME = $(patsubst %.a,%_imp.a,$(LIBRARY)) -endif - -$(DLL_NAME) :: $(LIBRARY) - $(BLD_DLL) --output-lib $(DLL_IMPLIB_NAME) -o $(DLL_NAME) $(LIBRARY) $(BLD_DLL_OPTS) -endif # LIBRARY != "" - -endif # DLLized +# 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. @@ -645,341 +454,22 @@ DllVersionInfo.$(way_)rc ExeVersionInfo.$(way_)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) - -$(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 -ifneq "$(SCRIPT_SUBST)" "" - @eval $(SCRIPT_SUBST) -endif - @cat $(SCRIPT_OBJS) >> $@ - @chmod a+x $@ - @echo Done. -endif - -# --------------------------------------------------------------------------- -# Symbolic links - -# links to programs: we sometimes install a program as -# - with a link from to the real program. - -ifneq "$(LINK)" "" - -all :: $(LINK) - -CLEAN_FILES += $(LINK) - -ifeq "$(LINK_TARGET)" "" -ifneq "$(SCRIPT_PROG)" "" -LINK_TARGET = $(SCRIPT_PROG) -else -ifneq "$(HS_PROG)" "" -LINK_TARGET = $(HS_PROG) -else -ifneq "$(C_PROG)" "" -LINK_TARGET = $(C_PROG) -else -LINK_TARGET = dunno -endif -endif -endif -endif - -# -# Don't want to overwrite $(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. -# -$(LINK) : $(LINK_TARGET) - @if ( $(PERL) -e '$$fn="$(LINK)"; exit ((! -f $$fn || -l $$fn) ? 0 : 1);' ); then \ - echo "Creating a symbolic link from $(LINK_TARGET) to $(LINK)"; \ - $(RM) $(LINK); \ - $(LN_S) $(LINK_TARGET) $(LINK); \ - else \ - echo "Creating a symbolic link from $(LINK_TARGET) to $(LINK) failed: \`$(LINK)' already exists"; \ - echo "Perhaps remove \`$(LINK)' manually?"; \ - exit 1; \ - fi; - - -# -# install links to script drivers. -# -install :: - @$(INSTALL_DIR) $(bindir) - @if ( $(PERL) -e '$$fn="$(bindir)/$(LINK)"; exit ((! -f $$fn || -l $$fn) ? 0 : 1);' ); then \ - echo "Creating a symbol link from $(LINK_TARGET) to $(LINK) in $(bindir)"; \ - $(RM) $(bindir)/$(LINK); \ - $(LN_S) $(LINK_TARGET) $(bindir)/$(LINK); \ - else \ - echo "Creating a symbol link from $(LINK_TARGET) to $(LINK) in $(bindir) failed: \`$(bindir)/$(LINK)' already exists"; \ - echo "Perhaps remove \`$(bindir)/$(LINK)' manually?"; \ - exit 1; \ - fi; - -endif # LINK - - -########################################### -# -# 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 - -# Install libraries automatically -ifneq "$(LIBRARY)" "" -INSTALL_LIBS += $(LIBRARY) -ifeq "$(DLLized)" "YES" -INSTALL_PROGS += $(DLL_NAME) -INSTALL_LIBS += $(patsubst %.a,%_imp.a, $(LIBRARY)) -endif -INSTALL_DATAS += $(HS_IFACES) -endif - -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 +# Regular static library +$(LIBRARY): $(LIBOBJS) + $(BUILD_STATIC_LIB) +endif # %.dll +endif # %.dylib +endif # %.so +endif # LIBRARY = "" -# -# install-strip is from the GNU Makefile standard. -# -ifneq "$(way)" "" -install-strip:: - @$(MAKE) EXTRA_INSTALL_OPTS='-s' install -endif +include $(TOP)/mk/install.mk -########################################### +############################################################################## # # Targets: check tags show # -########################################### +############################################################################## #------------------------------------------------------------ # Check @@ -1003,68 +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 +################################################################################ # +# DocBook XML Documentation +# +################################################################################ -show: - @echo '$(VALUE)=$($(VALUE))' +.PHONY: html html-no-chunks chm HxS fo dvi ps pdf -#-------------------------------------------------------------------------- -# SGML Documentation -# -.PHONY: dvi ps html pdf rtf +ifneq "$(XML_DOC)" "" -ifneq "$(SGML_DOC)" "" +all :: $(XMLDocWays) -# multi-file SGML document: main document name is specified in $(SGML_DOC), -# sub-documents (.sgml files) listed in $(SGML_SRCS). +# multi-file XML document: main document name is specified in $(XML_DOC), +# sub-documents (.xml files) listed in $(XML_SRCS). -ifeq "$(SGML_SRCS)" "" -SGML_SRCS = $(wildcard *.sgml) +ifeq "$(XML_SRCS)" "" +XML_SRCS = $(wildcard *.xml) endif -SGML_TEX = $(addsuffix .tex,$(SGML_DOC)) -SGML_DVI = $(addsuffix .dvi,$(SGML_DOC)) -SGML_PS = $(addsuffix .ps,$(SGML_DOC)) -SGML_PDF = $(addsuffix .pdf,$(SGML_DOC)) -SGML_RTF = $(addsuffix .rtf,$(SGML_DOC)) -SGML_HTML = $(addsuffix .html,$(SGML_DOC)) -# HTML output goes in a subdirectory on its own. -SGML_TEXT = $(addsuffix .txt,$(SGML_DOC)) +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_HTML) $(SGML_TEXT) $(SGML_PDF) :: $(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 +CLEAN_FILES += $(XML_HTML_NO_CHUNKS) $(XML_FO) $(XML_DVI) $(XML_PS) $(XML_PDF) extraclean :: - $(RM) -rf DBTOHTML_OUTPUT_* - $(RM) -rf *.junk/ - $(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 @@ -1089,11 +577,11 @@ maintainer-clean:: extraclean @echo 'deletes files that may need special tools to rebuild.' 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. @@ -1103,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. @@ -1128,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 @@ -1146,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 @@ -1156,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) +