## RegisterFileType Rulename : extensions
## Register a rule which is used to compile a filetype into object
## files. The registered rule is called with the name of the
-## sourcefile as argument and should return a list of objectfiles which are
-## created. You should set the grist of the object files by using the
-## DoObjectGrist function.
+## sourcefile as argument (completely gristed and SEARCH is set already).
+## The rule should return the object files created completely gristed and
+## with LOCATE set (use the LocateTarget rule to do this).
rule RegisterFileType
{
local suffix ;
}
## CompileObjects sources [ : options ]
-## Compile a set of sourcefiles into objectfiles (extension: SUFOBJ,
-## usually .o). This rule takes care of setting LOCATE and SEARCH
-## variables to the $(SEARCH_SOURCE) and $(LOCATE_SOURCE) variables.
-## The Application, Plugin and Library rules already use this rule
-## internally. You should only use this rule if you have to avoid the
-## Application, Plugin or Library rules.
+## Compile a set of sourcefiles into objectfiles (usually .o extension).
+## For ungristed sourcefiles $(SEARCH) will be set to $(SEARCH_SOURCE).
+## The function returns the names of the targets being built (gristed and
+## with LOCATE set.
+## Normally you don't have to use this rule. The Application or Library rules
+## are taking care of calling it for you.
rule CompileObjects
{
- local source ;
+ local s ;
+ local sources = [ SearchSource $(<) ] ;
local targets ;
- # Search the source
- SEARCH on $(<) = $(SEARCH_SOURCE) ;
-
- for source in $(<)
+ for s in $(sources)
{
# compile the sourcefile to targetfile
- targets += [ CompileObject $(source) : $(2) ] ;
+ targets += [ CompileObject $(s) : $(2) ] ;
}
-
- # locate the targets
- MakeLocate $(targets) : $(LOCATE_TARGET) ;
return $(targets) ;
}
# private part
# CompileObject sourcefile [ : options ]
-# helper rule: Compiles a source file to an object file. Does header file
-# scanning, sets LOCATE and SEARCH for source and target, grists the files
-# with the current subdir and searches for the correct registered rule.
+# helper rule: Compiles a source file to an object file. The source should be
+# correctly gristed and SEARCH should be set. The function will return the
+# target names gristed and with LOCATE set.
rule CompileObject
{
# handle #includes for source: Jam scans for headers with
# the regexp pattern $(HDRSCAN) and then invokes $(HDRRULE)
# with the scanned file as the target and the found headers
# as the sources. HDRSEARCH is the value of SEARCH used for
- # the found header files. Finally, if jam must deal with
- # header files of the same name in different directories,
- # they can be distinguished with HDRGRIST.
+ # the found header files.
# $(SEARCH_SOURCE:E) is where cc first looks for #include
# "foo.h" files. If the source file is in a distant directory,
# look there. Else, look in "" (the current directory).
if $(HDRRULE_$(<:S))
{
- HDRS on $(<) = [ ConcatDirs $(SUBDIR) $(<:D) ]
- $(SEARCH_SOURCE:E) $(HDRS) $(STDHDRS) ;
- HDRGRIST on $(<) = $(HDRGRIST) ;
+ HDRSEARCH on $(<) = $(SEARCH_SOURCE:E) $(HDRSEARCH) $(STDHDRSEARCH) ;
+ SEARCH_SOURCE on $(<) = $(SEARCH_SOURCE) ;
HDRRULE on $(<) = $(HDRRULE_$(<:S)) ;
HDRSCAN on $(<) = $(HDRPATTERN_$(<:S)) ;
}
local targets ;
# Invoke filetype specific rule
- if $(FILETYPE_$(<:S))
- {
+ if $(FILETYPE_$(<:S)) {
targets = [ $(FILETYPE_$(<:S)) $(<) : $(2) ] ;
- }
- else
- {
- echo "Warning: no rules for filetype $(>:S) defined (at file $(>))." ;
+ } else {
+ echo "Warning: no rules for filetype $(<:S) defined (at file $(<))." ;
}
- if $(targets)
- {
+ if $(targets) {
# construct clean target
Clean clean : $(targets) ;
}
# set SEARCH so Jam can find the headers, but then say we don't
# care if we can't actually find the headers (they may have been
# within ifdefs),
- local s = $(>:G=$(HDRGRIST:E)) ;
-
- Includes $(<) : $(s) ;
- SEARCH on $(s) = $(HDRS) ;
- NoCare $(s) ;
-
- local i ;
- for i in $(s)
- {
- HDRGRIST on $(s) = $(HDRGRIST) ;
- HDRS on $(s) = $(HDRS) ;
- HDRRULE on $(s) = [ on $(<) GetVar HDRRULE ] ;
- HDRSCAN on $(s) = [ on $(<) GetVar HDRPATTERN ] ;
- }
-}
+ local HDRSEARCH = [ on $(<) GetVar HDRSEARCH ] ;
+ local SEARCH_SOURCE = [ on $(<) GetVar SEARCH_SOURCE ] ;
-if $(JAMVERSION) < 2.5
-{
-## XXX XXX XXX a bug in jam 2.4 let's the version above fail. I'll let this
-## non-optimal version in here until jam 2.5 is out.
+ Includes $(<) : $(>) ;
+ SEARCH on $(>) = $(HDRSEARCH) $(SEARCH_SOURCE)/$(<:D) ;
+ NoCare $(>) ;
-rule HeaderRule
-{
- local s = $(>:G=$(HDRGRIST:E)) ;
-
- Includes $(<) : $(s) ;
- SEARCH on $(s) = $(HDRS) ;
- NoCare $(s) ;
-
local i ;
- for i in $(s)
+ for i in $(>)
{
- if $(HDRRULE_$(i:S))
- {
- HDRGRIST on $(s) = $(HDRGRIST) ;
- HDRS on $(s) = $(HDRS) ;
- HDRRULE on $(s) = $(HDRRULE_$(i:S)) ;
- HDRSCAN on $(s) = $(HDRPATTERN_$(i:S)) ;
- }
- else if $(JAM_DEBUG)
- {
- #echo "No Header rule for $(i:S) file $(i) " ;
+
+ SEARCH on $(>) = $(HDRSEARCH) $(SEARCH_SOURCE)/$(<:D) ;
+ if $(i:D) = "" {
+ SEARCH_SOURCE on $(i) = $(SEARCH_SOURCE)/$(<:D) ;
+ } else {
+ SEARCH_SOURCE on $(i) = $(SEARCH_SOURCE) ;
}
+ HDRSEARCH on $(>) = $(HDRSEARCH) ;
+ HDRRULE on $(>) = [ on $(<) GetVar HDRRULE ] ;
+ HDRSCAN on $(>) = [ on $(<) GetVar HDRPATTERN ] ;
}
}
-} # end of if $(JAMVERSION) < 1.5
-
# Dummy rule: .o files are used as is.
rule UseObjectFile
{
{
return ;
}
-RegisterFileType UseHeaderFile : .h .hpp ;
-RegisterHeaderRule HeaderRule : $(HDRPATTERN) : .h .hpp .inc ;
-
-# Generates a grist suitable for output objects based on
-# SUBVARIANT and SUBDIR variable.
-rule DoObjectGrist
+RegisterFileType UseHeaderFile : .h .hpp .inc .inl ;
+RegisterHeaderRule HeaderRule : $(HDRPATTERN) : .h .hpp .inc .inl ;
+
+## SearchSource
+## Sets search path of the sourcefiles to the current SUBDIR and sets a
+## suitable grist on the sources. Ignores source files that already have
+## grist set.
+rule SearchSource
{
- return $(<:G=$(SOURCE_GRIST:E)!$(SUBVARIANT)) ;
+ local sources ;
+
+ for f in $(<) {
+ if $(f:G) {
+ sources += $(f) ;
+ } else {
+ local source = $(f:G=$(SOURCE_GRIST:E)) ;
+ sources += $(source) ;
+ SEARCH on $(source) = $(SEARCH_SOURCE) ;
+ }
+ }
+ return $(sources) ;
}
-# Generates a grist suitable for source files based on SUBDIR variable.
-rule DoSourceGrist
+## LocateTarget
+## Sets LOCATE on the current output directory (depending on builddir,
+## variant and current subdir), sets a suitable grist and makes sure the
+## target directory is created if it doesn't exist.
+rule LocateTarget
{
- return $(<:G=$(SOURCE_GRIST:E)) ;
+ local targetdir ;
+ if $(>) {
+ targetdir = $(>) ;
+ } else {
+ targetdir = $(LOCATE_TARGET) ;
+ }
+
+ local targets = $(<:G=T!$(SOURCE_GRIST:E)!$(SUBVARIANT)) ;
+ MakeLocate $(targets) : $(targetdir) ;
+
+ return $(targets) ;
}
projects / supertux.git / blobdiff