ghc-paths.mk 10.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
################################################################################
#
#			    paths.mk
#
# 	This file defines Make variables for standard directories
#	and file lists
#
################################################################################

################################################################################
#
#		Standard variable names
#
################################################################################
# The fptools mk setup defines a set of standard names which are used
# by the standard targets provided by mk. One example of this is the
# use of standard names for specifying what files to compile, their
# intermediate/object code, and the name of the final
# executable. Based on the settings of these variables, the standard
# targets will generate/expand rules that automatically compile and
# link your program.
#
# The general rules:
#
#   SRCS - sources, might be prefixed to indicate what type of source
#          they are.
#   OBJS - object files (possibly prefixed).
#
#   PROG - name of final executable
#
# We attempt to automatically devine the list of sources $(SRCS) to
# compile by looking in the current directory (and possibly other
# directories which may be specified by setting the $(ALL_DIRS)
# variable).  This is complicated by the fact that some files are
# derived from other files: eg. .hsc files give rise to -hsc.c and
# -hsc.h files, .ly files give rise to .hs files, and .hs files give
# rise to .hc files sometimes.

# So we figure out the sources in three stages: first figure out what
# sources we can find (this is $(ALL_SRCS)).  Then figure out all the
# "derived" sources (eg. A.hsc generates A.hs and A_hsc.c), and
# finally put all these together and remove duplicates (GNU make's
# handy sort function does the duplicate removing).

# HS_SRCS:   list of Haskell modules you want to compile.
#             (also use by depend rule).
# HS_OBJS:   list of corresponding object files
# HS_PROG:   program that is ultimately linked.
# HS_IFACES: list of interface files generated
#             (caveat: assuming no funny use of -hisuf and that
#               file name and module name match)

ALL_SRCS    = $(wildcard $(patsubst ./%, %,  \
		   $(patsubst %,%/*.hs,   . $(ALL_DIRS)) \
		   $(patsubst %,%/*.lhs,  . $(ALL_DIRS)) \
		   $(patsubst %,%/*.hs-boot,  . $(ALL_DIRS)) \
		   $(patsubst %,%/*.lhs-boot, . $(ALL_DIRS)) \
		   $(patsubst %,%/*.y,    . $(ALL_DIRS)) \
		   $(patsubst %,%/*.ly,   . $(ALL_DIRS)) \
		   $(patsubst %,%/*.x,    . $(ALL_DIRS)) \
		   $(patsubst %,%/*.c,    . $(ALL_DIRS)) \
		   $(patsubst %,%/*.hc,   . $(ALL_DIRS)) \
		   $(patsubst %,%/*.S,    . $(ALL_DIRS)) \
		   $(patsubst %,%/*.prl,  . $(ALL_DIRS)) \
		   $(patsubst %,%/*.lprl, . $(ALL_DIRS)) \
		   $(patsubst %,%/*.lit,  . $(ALL_DIRS)) \
		   $(patsubst %,%/*.verb, . $(ALL_DIRS)) \
		   $(patsubst %,%/*.hsc,  . $(ALL_DIRS)) \
		   $(patsubst %,%/*.gc,   . $(ALL_DIRS)) \
	       )) $(EXTRA_SRCS)

# ALL_SRCS is computed once and for all into PRE_SRCS at the top of
# target.mk.  Otherwise, we end up re-computing ALL_SRCS every time it
# is expanded (it is used in several variables below, and these
# variables are used in several others, etc.), which can really slow
# down make.

PRE_HS_SRCS  = $(filter %.hs,  $(PRE_SRCS))
PRE_LHS_SRCS = $(filter %.lhs, $(PRE_SRCS))

PRE_HS_BOOT_SRCS = $(filter %.hs-boot,  $(PRE_SRCS)) \
		   $(filter %.lhs-boot, $(PRE_SRCS))

GC_SRCS       = $(filter %.gc,  $(PRE_SRCS))
HSC_SRCS      = $(filter %.hsc, $(PRE_SRCS))
HAPPY_Y_SRCS  = $(filter %.y,   $(PRE_SRCS))
HAPPY_LY_SRCS = $(filter %.ly,   $(PRE_SRCS))
HAPPY_SRCS    = $(HAPPY_Y_SRCS) $(HAPPY_LY_SRCS)
ALEX_SRCS     = $(filter %.x,   $(PRE_SRCS))

DERIVED_GC_SRCS       = $(patsubst %.gc, %.hs, $(GC_SRCS)) \
			$(patsubst %.gc, %_stub_ffi.c, $(GC_SRCS)) \
			$(patsubst %.gc, %_stub_ffi.h, $(GC_SRCS))

DERIVED_HSC_SRCS      = $(patsubst %.hsc, %.hs, $(HSC_SRCS)) \
			$(patsubst %.hsc, %_hsc.c, $(HSC_SRCS)) \
			$(patsubst %.hsc, %_hsc.h, $(HSC_SRCS)) \
			$(patsubst %.hsc, %.hc, $(HSC_SRCS))

DERIVED_HAPPY_SRCS    = $(patsubst %.y,   %.hs, $(HAPPY_Y_SRCS)) \
			$(patsubst %.ly,  %.hs, $(HAPPY_LY_SRCS))

DERIVED_ALEX_SRCS     = $(patsubst %.x,   %.hs, $(ALEX_SRCS))

DERIVED_HC_SRCS       = $(patsubst %.hs,  %.hc, $(PRE_HS_SRCS)) \
			$(patsubst %.lhs, %.hc, $(PRE_LHS_SRCS))

DERIVED_SRCS	      = $(DERIVED_GC_SRCS) \
			$(DERIVED_HSC_SRCS) \
			$(DERIVED_HAPPY_SRCS) \
			$(DERIVED_ALEX_SRCS) \
			$(DERIVED_HC_SRCS)

# EXCLUDED_SRCS can be set in the Makefile, otherwise it defaults to empty.
EXCLUDED_GC_SRCS       = $(filter %.gc,  $(EXCLUDED_SRCS))
EXCLUDED_HSC_SRCS      = $(filter %.hsc, $(EXCLUDED_SRCS))
EXCLUDED_HAPPY_Y_SRCS  = $(filter %.y,   $(EXCLUDED_SRCS))
EXCLUDED_HAPPY_LY_SRCS = $(filter %.ly,  $(EXCLUDED_SRCS))
EXCLUDED_HAPPY_SRCS   = $(EXCLUDED_HAPPY_Y_SRCS) $(EXCLUDED_HAPPY_LY_SRCS)
EXCLUDED_ALEX_SRCS    = $(filter %.x,   $(EXCLUDED_SRCS))
EXCLUDED_HS_SRCS      = $(filter %.hs,  $(EXCLUDED_SRCS))
EXCLUDED_LHS_SRCS     = $(filter %.lhs, $(EXCLUDED_SRCS))
EXCLUDED_DERIVED_SRCS = $(patsubst %.hsc, %.hs, $(EXCLUDED_HSC_SRCS)) \
			$(patsubst %.hsc, %_hsc.h, $(EXCLUDED_HSC_SRCS)) \
			$(patsubst %.hsc, %_hsc.c, $(EXCLUDED_HSC_SRCS)) \
			$(patsubst %.hsc, %.hc, $(EXCLUDED_HSC_SRCS)) \
			$(patsubst %.gc,  %_stub_ffi.c, $(EXCLUDED_GC_SRCS)) \
			$(patsubst %.gc,  %_stub_ffi.h, $(EXCLUDED_GC_SRCS)) \
                        $(patsubst %.y,   %.hs, $(EXCLUDED_HAPPY_Y_SRCS)) \
			$(patsubst %.ly,  %.hs, $(EXCLUDED_HAPPY_LY_SRCS)) \
                        $(patsubst %.x,   %.hs, $(EXCLUDED_ALEX_SRCS)) \
			$(patsubst %.hs,  %.hc, $(EXCLUDED_HS_SRCS)) \
			$(patsubst %.lhs, %.hc, $(EXCLUDED_LHS_SRCS)) \
			$(patsubst %.hs,  %_stub.c, $(EXCLUDED_HS_SRCS)) \
			$(patsubst %.lhs, %_stub.c, $(EXCLUDED_LHS_SRCS))

# Exclude _hsc.c files; they get built as part of the cbits library,
# not part of the main library

CLOSED_EXCLUDED_SRCS  = $(sort $(EXCLUDED_SRCS) $(EXCLUDED_DERIVED_SRCS))

SRCS        = $(filter-out $(CLOSED_EXCLUDED_SRCS), \
	        $(sort $(PRE_SRCS) $(DERIVED_SRCS)))

HS_SRCS	    = $(filter %.lhs %.hs, $(sort $(SRCS) $(BOOT_SRCS)))
HS_OBJS     = $(addsuffix .$(way_)o,$(basename $(HS_SRCS)))
HS_IFACES   = $(addsuffix .$(way_)hi,$(basename $(HS_SRCS)))

HI_BOOTS    = $(patsubst %.hs-boot, %.$(way_)hi-boot, \
	      $(patsubst %.lhs-boot, %.$(way_)hi-boot, $(PRE_HS_BOOT_SRCS)))

O_BOOTS     = $(patsubst %.hs-boot, %.$(way_)o-boot, \
	      $(patsubst %.lhs-boot, %.$(way_)o-boot, $(PRE_HS_BOOT_SRCS)))

GC_C_OBJS   = $(addsuffix _stub_ffi.$(way_)o,$(basename $(filter %.gc,$(SRCS))))
HSC_C_OBJS  = $(addsuffix _hsc.$(way_)o,$(basename $(filter %.hsc,$(SRCS))))

ifeq "$(BootingFromHc)" "NO"
# We don't want to build the _stub.c files ourselves, unless we're
# bootstrapping from .hc files.
EXCLUDED_C_SRCS = $(patsubst %.lhs, %_stub.c, $(HS_SRCS)) \
		  $(patsubst %.hs,  %_stub.c, $(HS_SRCS)) \
		  $(patsubst %.gc, %_stub_ffi.c, $(GC_SRCS)) \
		  $(patsubst %.gc, %_stub_ffi.h, $(GC_SRCS))
endif

# These are droppings from hsc2hs - ignore them if we see them.
EXCLUDED_C_SRCS += $(patsubst %.hsc, %_hsc_make.c, $(HSC_SRCS))

C_SRCS      = $(filter-out $(EXCLUDED_C_SRCS),$(filter %.c %.S,$(SRCS)))
C_OBJS      = $(addsuffix .$(way_)o,$(basename $(C_SRCS)))

# SCRIPT_SRCS:  list of raw script files (in literate form)
# SCRIPT_OBJS:  de-litted scripts
SCRIPT_SRCS = $(filter %.lprl,$(SRCS))
SCRIPT_OBJS = $(addsuffix .prl,$(basename $(SCRIPT_SRCS)))

OBJS        = $(HS_OBJS) $(C_OBJS) $(GC_C_OBJS) 

# The default is for $(LIBOBJS) to be the same as $(OBJS)
LIBOBJS	    = $(OBJS)

#
# Note that as long as you use the standard variables for setting
# which C & Haskell programs you want to work on, you don't have
# to set any of the clean variables - the default should do the Right
# Thing.
#

#------------------------------------------------------------------
#
# make depend defaults
#
# The default set of files for the dependency generators to work on
# is just their source equivalents.
#

ifneq "$(BootingFromHc)" "YES"
MKDEPENDHS_SRCS=$(HS_SRCS)
else
MKDEPENDHS_SRCS=
endif

#------------------------------------------------------------------
#
# make TAGS defaults
#
# The default set of files for the TAGS file generators to work on
# is just their source equivalents.
#
TAGS_HS_SRCS=$(HS_SRCS)
TAGS_C_SRCS=$(C_SRCS)

#------------------------------------------------------------------
# Clean file make-variables.
#
# The following three variables are used to control
# what gets removed when doing `make clean'
#
# MOSTLYCLEAN_FILES   object code etc., but not stuff
#                     that is slow to recompile and/or stable
#
# CLEAN_FILES  all files that are created by running make.
#
# MAINTAINER_CLEAN_FILES also clean out machine-generated files
#                        that may require extra tools to create.
#
#
# NOTE: $(SCRIPT_OBJS) is not in MOSTLY_CLEAN_FILES, because in some
# places in the tree it appears that we have source files in $(SCRIPT_OBJS).
# Specifically glafp-utils/mkdependC/mkdependC.prl and others in driver/ and
# possibly others elsewhere in the tree.  ToDo: fix this properly.
MOSTLY_CLEAN_FILES += $(HS_OBJS) $(C_OBJS) $(HSC_C_OBJS) $(GC_C_OBJS)
CLEAN_FILES        += $(HS_PROG) $(C_PROG) $(SCRIPT_LINK) \
		      $(PROG) $(LIBRARY) a.out \
		      $(DERIVED_HSC_SRCS) \
		      $(DERIVED_GC_SRCS) \
		      $(patsubst %,%/*.$(way_)hi, . $(ALL_DIRS)) \
		      $(HI_BOOTS) $(O_BOOTS)

# we delete *all* the .hi files we can find, rather than just
# $(HS_IFACES), because stale interfaces left around by modules which
# don't exist any more can screw up the build.

# Don't clean the .hc files if we're bootstrapping
ifneq "$(BootingFromHc)" "YES"
CLEAN_FILES += $(DERIVED_HC_SRCS)
endif

DIST_CLEAN_FILES 	+= .depend* *.hp *.prof

MAINTAINER_CLEAN_FILES 	+= $(BOOT_SRCS) $(DERIVED_HAPPY_SRCS) $(DERIVED_ALEX_SRCS)

#
# `Standard' set of files to clean out.
#
MOSTLY_CLEAN_FILES += \
 *.CKP *.ln *.BAK *.bak .*.bak *.o core a.out errs ,* *.a .emacs_*  \
 tags TAGS *.ind *.ilg *.idx *.idx-prev *.aux *.aux-prev *.dvi *.log \
 *.toc *.lot *.lof *.blg *.cb *_stub.c *_stub.h *.raw_s *.a.list

#------------------------------------------------------------------

# Directory in which DLLs are dumped so as not to get picked up by running
# programs (e.g. ghc or hsc) that run in the build tree

DLL_PEN = $(FPTOOLS_TOP)/dll