env = Environment(CCCOM="my_compiler $_CPPINCFLAGS -c -o $TARGET $SOURCE")
.EE
+.IP CPPSUFFIXES
+The list of suffixes of files that will be scanned
+for C preprocessor implicit dependencies
+(#include lines).
+The default list is:
+
+.ES
+[".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
+ ".h", ".H", ".hxx", ".hpp", ".hh",
+ ".F", ".fpp", ".FPP",
+ ".S", ".spp", ".SPP"]
+.EE
+
.IP CVS
The CVS executable.
A function that converts a file name into a Dir instance relative to the
target being built.
+.IP DSUFFIXES
+The list of suffixes of files that will be scanned
+for imported D package files.
+The default list is:
+
+.ES
+['.d']
+.EE
+
.IP DVIPDF
The TeX DVI file to PDF file converter.
Any options specified in the $F77FLAGS and $CPPFLAGS construction variables
are included on this command line.
+.IP FORTRANSUFFIXES
+The list of suffixes of files that will be scanned
+for Fortran implicit dependencies
+(INCLUDE lines).
+The default list is:
+
+.ES
+[".f", ".F", ".for", ".FOR"]
+.EE
+
.IP File
A function that converts a file name into a File instance relative to the
target being built.
.IP GSCOM
The Ghostscript command line used to convert PostScript to PDF files.
+.IP IDLSUFFIXES
+The list of suffixes of files that will be scanned
+for IDL implicit dependencies
+(#include or import lines).
+The default list is:
+
+.ES
+[".idl", ".IDL"]
+.EE
+
.IP INCPREFIX
The prefix used to specify an include directory on the C compiler command
line.
path, you must make it absolute yourself.
.IP SCANNERS
-A list of the available implicit dependency scanners. [CScan] by default.
+A list of the available implicit dependency scanners.
.IP SCCS
The SCCS executable.
determine which scanner should be used for
a given Node.
In the usual case of scanning for file names,
-this array will be a list of suffixes
+this argument will be a list of suffixes
for the different file types that this
Scanner knows how to scan.
+If the argument is a string,
+then it will be expanded
+into a list by the current environment.
.IP path_function
A Python function that takes
- Enhance the Task.make_ready() method to create a list of the
out-of-date Nodes for the task for use by the wrapping interface.
+ - Allow Scanners to pull the list of suffixes from the construction
+ environment when the "skeys" keyword argument is a string containing
+ a construction variable to be expanded.
+
+ - Support new $CPPSUFFIXES, $DSUFFIXES $FORTRANSUFFIXES, and
+ $IDLSUFFIXES. construction variables that contain the default list
+ of suffixes to be scanned by a given type of scanner, allowing these
+ suffix lists to be easily added to or overridden.
+
From Gary Oberbrunner:
- Add a --debug=presub option to print actions prior to substitution.
Please note the following important changes since release 0.95:
+ - The internal Scanner.add_skey() method longer works for the default
+ scanners, which now use construction variables to hold their lists
+ of suffixes. If you had a custom Tool specification that was
+ reaching into the internals in this way to add a suffix to one of
+ the following scanner, you must now add the suffix to a construction
+ environment through which you plan to call the scanner, as follows:
+
+
+ CScan.add_skey('.x') => env.Append(CPPSUFFIXES = ['.x'])
+ DScan.add_skey('.x') => env.Append(DSUFFIXES = ['.x'])
+ FortranScan.add_skey('.x') => env.Append(FORTRANSUFFIXES = ['.x'])
+
- The behavior of the env.Append() and env.Prepend() methods has
changed when appending a string value to a UserList, or vice versa.
They now behave like normal Python addition of a string to
SharedCheck = SCons.Action.Action(SharedFlagChecker, None)
-# Scanners and actions for common language(s).
+# Scanners and suffixes for common languages.
CScan = SCons.Scanner.C.CScan()
+
+CSuffixes = [".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
+ ".h", ".H", ".hxx", ".hpp", ".hh",
+ ".F", ".fpp", ".FPP",
+ ".S", ".spp", ".SPP"]
+
DScan = SCons.Scanner.D.DScan()
+DSuffixes = ['.d']
+
FortranScan = SCons.Scanner.Fortran.FortranScan()
+FortranSuffixes = [".f", ".F", ".for", ".FOR"]
+
+IDLSuffixes = [".idl", ".IDL"]
+
+# Actions for common languages.
CAction = SCons.Action.Action("$CCCOM")
DAction = SCons.Action.Action("$DCOM")
ShCAction = SCons.Action.Action("$SHCCCOM")
ConstructionEnvironment = {
'BUILDERS' : {},
'SCANNERS' : [CScan, FortranScan, DScan],
+ 'CPPSUFFIXES': CSuffixes,
+ 'DSUFFIXES' : DSuffixes,
+ 'FORTRANSUFFIXES': FortranSuffixes,
+ 'IDLSUFFIXES': IDLSuffixes,
'PDFPREFIX' : '',
'PDFSUFFIX' : '.pdf',
'PSPREFIX' : '',
def get_scanner(self, skey):
"""Find the appropriate scanner given a key (usually a file suffix).
- Does a linear search. Could be sped up by creating a dictionary if
- this proves too slow.
"""
- if self._dict['SCANNERS']:
- for scanner in self._dict['SCANNERS']:
- if skey in scanner.skeys:
- return scanner
- return None
+ try:
+ sm = self.scanner_map
+ except AttributeError:
+ try:
+ scanners = self._dict['SCANNERS']
+ except KeyError:
+ return None
+ else:
+ self.scanner_map = sm = {}
+ # Reverse the scanner list so that, if multiple scanners
+ # claim they can scan the same suffix, earlier scanners
+ # in the list will overwrite later scanners, so that
+ # the result looks like a "first match" to the user.
+ scanners.reverse()
+ for scanner in scanners:
+ for k in scanner.get_skeys(self):
+ sm[k] = scanner
+ try:
+ return sm[skey]
+ except KeyError:
+ return None
def subst(self, string, raw=0, target=None, source=None, dict=None, conv=None):
"""Recursively interpolates construction variables from the
"""Return a prototype Scanner instance for scanning source files
that use the C pre-processor"""
cs = SCons.Scanner.ClassicCPP("CScan",
- [".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
- ".h", ".H", ".hxx", ".hpp", ".hh",
- ".F", ".fpp", ".FPP",
- ".S", ".spp", ".SPP"],
+ "$CPPSUFFIXES",
"CPPPATH",
'^[ \t]*#[ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")',
fs = fs)
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
-import TestCmd
-import SCons.Scanner.C
-import unittest
-import sys
import os
import os.path
+import sys
+import TestCmd
+import unittest
+import UserDict
+
import SCons.Node.FS
import SCons.Warnings
+import SCons.Scanner.C
+
test = TestCmd.TestCmd(workdir = '')
os.chdir(test.workpath(''))
# define some helpers:
-class DummyEnvironment:
- def __init__(self, listCppPath):
- self.path = listCppPath
-
+class DummyEnvironment(UserDict.UserDict):
+ def __init__(self, **kw):
+ UserDict.UserDict.__init__(self)
+ self.data.update(kw)
+
def Dictionary(self, *args):
- if not args:
- return { 'CPPPATH': self.path }
- elif len(args) == 1 and args[0] == 'CPPPATH':
- return self.path
- else:
- raise KeyError, "Dummy environment only has CPPPATH attribute."
+ return self.data
+
+ def subst(self, strSubst):
+ if strSubst[0] == '$':
+ return self.data[strSubst[1:]]
+ return strSubst
- def subst(self, arg):
- return arg
+ def subst_list(self, strSubst):
+ if strSubst[0] == '$':
+ return [self.data[strSubst[1:]]]
+ return [[strSubst]]
def subst_path(self, path):
if type(path) != type([]):
path = [path]
return map(self.subst, path)
- def has_key(self, key):
- return self.Dictionary().has_key(key)
-
- def __getitem__(self,key):
- return self.Dictionary()[key]
-
- def __setitem__(self,key,value):
- self.Dictionary()[key] = value
-
- def __delitem__(self,key):
- del self.Dictionary()[key]
-
if os.path.normcase('foo') == os.path.normcase('FOO'):
my_normpath = os.path.normcase
else:
class CScannerTestCase1(unittest.TestCase):
def runTest(self):
- env = DummyEnvironment([])
+ env = DummyEnvironment(CPPPATH=[])
s = SCons.Scanner.C.CScan()
path = s.path(env)
deps = s(make_node('f1.cpp'), env, path)
class CScannerTestCase2(unittest.TestCase):
def runTest(self):
- env = DummyEnvironment([test.workpath("d1")])
+ env = DummyEnvironment(CPPPATH=[test.workpath("d1")])
s = SCons.Scanner.C.CScan()
path = s.path(env)
deps = s(make_node('f1.cpp'), env, path)
class CScannerTestCase3(unittest.TestCase):
def runTest(self):
- env = DummyEnvironment([test.workpath("d1")])
+ env = DummyEnvironment(CPPPATH=[test.workpath("d1")])
s = SCons.Scanner.C.CScan()
path = s.path(env)
deps = s(make_node('f2.cpp'), env, path)
class CScannerTestCase4(unittest.TestCase):
def runTest(self):
- env = DummyEnvironment([test.workpath("d1"), test.workpath("d1/d2")])
+ env = DummyEnvironment(CPPPATH=[test.workpath("d1"), test.workpath("d1/d2")])
s = SCons.Scanner.C.CScan()
path = s.path(env)
deps = s(make_node('f2.cpp'), env, path)
class CScannerTestCase5(unittest.TestCase):
def runTest(self):
- env = DummyEnvironment([])
+ env = DummyEnvironment(CPPPATH=[])
s = SCons.Scanner.C.CScan()
path = s.path(env)
class CScannerTestCase6(unittest.TestCase):
def runTest(self):
- env1 = DummyEnvironment([test.workpath("d1")])
- env2 = DummyEnvironment([test.workpath("d1/d2")])
+ env1 = DummyEnvironment(CPPPATH=[test.workpath("d1")])
+ env2 = DummyEnvironment(CPPPATH=[test.workpath("d1/d2")])
s = SCons.Scanner.C.CScan()
path1 = s.path(env1)
path2 = s.path(env2)
class CScannerTestCase8(unittest.TestCase):
def runTest(self):
fs = SCons.Node.FS.FS(test.workpath(''))
- env = DummyEnvironment(["include"])
+ env = DummyEnvironment(CPPPATH=["include"])
s = SCons.Scanner.C.CScan(fs = fs)
path = s.path(env)
deps1 = s(fs.File('fa.cpp'), env, path)
SCons.Warnings._warningOut = to
test.write('fa.h','\n')
fs = SCons.Node.FS.FS(test.workpath(''))
- env = DummyEnvironment([])
+ env = DummyEnvironment(CPPPATH=[])
s = SCons.Scanner.C.CScan(fs=fs)
path = s.path(env)
deps = s(fs.File('fa.cpp'), env, path)
def runTest(self):
fs = SCons.Node.FS.FS(test.workpath(''))
fs.chdir(fs.Dir('include'))
- env = DummyEnvironment([])
+ env = DummyEnvironment(CPPPATH=[])
s = SCons.Scanner.C.CScan(fs=fs)
path = s.path(env)
test.write('include/fa.cpp', test.read('fa.cpp'))
# This was a bug at one time.
f1=fs.File('include2/jjj.h')
f1.builder=1
- env = DummyEnvironment(['include', 'include2'])
+ env = DummyEnvironment(CPPPATH=['include', 'include2'])
s = SCons.Scanner.C.CScan(fs=fs)
path = s.path(env)
deps = s(fs.File('src/fff.c'), env, path)
fs.BuildDir('build1', 'src', 1)
fs.BuildDir('build2', 'src', 0)
fs.Repository(test.workpath('repository'))
- env = DummyEnvironment([])
+ env = DummyEnvironment(CPPPATH=[])
s = SCons.Scanner.C.CScan(fs = fs)
path = s.path(env)
deps1 = s(fs.File('build1/aaa.c'), env, path)
class SubstEnvironment(DummyEnvironment):
def subst(self, arg, test=test):
return test.workpath("d1")
- env = SubstEnvironment(["blah"])
+ env = SubstEnvironment(CPPPATH=["blah"])
s = SCons.Scanner.C.CScan()
path = s.path(env)
deps = s(make_node('f1.cpp'), env, path)
class CScannerTestCase14(unittest.TestCase):
def runTest(self):
- env = DummyEnvironment([])
+ env = DummyEnvironment(CPPPATH=[])
s = SCons.Scanner.C.CScan()
path = s.path(env)
deps = s(make_node('f5.c'), env, path)
class CScannerTestCase15(unittest.TestCase):
def runTest(self):
- env = DummyEnvironment([])
- s = SCons.Scanner.C.CScan()
suffixes = [".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
".h", ".H", ".hxx", ".hpp", ".hh",
".F", ".fpp", ".FPP",
".S", ".spp", ".SPP"]
+ env = DummyEnvironment(CPPSUFFIXES = suffixes)
+ s = SCons.Scanner.C.CScan()
for suffix in suffixes:
- assert suffix in s.skeys, "%s not in skeys" % suffix
+ assert suffix in s.get_skeys(env), "%s not in skeys" % suffix
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+import string
+
import SCons.Scanner
def DScan(fs = SCons.Node.FS.default_fs):
"""Return a prototype Scanner instance for scanning D source files"""
ds = DScanner(name = "DScan",
- suffixes = ['.d'],
+ suffixes = '$DSUFFIXES',
path_variable = 'DPATH',
regex = 'import\s+([^\;]*)\;',
fs = fs)
class DScanner(SCons.Scanner.Classic):
def find_include(self, include, source_dir, path):
# translate dots (package separators) to slashes
- inc = include.replace('.', '/')
+ inc = string.replace(include, '.', '/')
i = SCons.Node.FS.find_file(inc + '.d',
(source_dir,) + path,
"""Return a prototype Scanner instance for scanning source files
for Fortran INCLUDE statements"""
scanner = SCons.Scanner.Classic("FortranScan",
- [".f", ".F", ".for", ".FOR"],
+ "$FORTRANSUFFIXES",
"F77PATH",
"(?i)INCLUDE[ \t]+'([\\w./\\\\]+)'",
fs = fs)
def IDLScan(fs = SCons.Node.FS.default_fs):
"""Return a prototype Scanner instance for scanning IDL source files"""
cs = SCons.Scanner.ClassicCPP("IDLScan",
- [".idl", ".IDL"],
+ "$IDLSUFFIXES",
"CPPPATH",
'^[ \t]*(?:#[ \t]*include|[ \t]*import)[ \t]+(<|")([^>"]+)(>|")',
fs = fs)
UserDict.UserDict.__init__(self, dict)
self.data.update(kw)
def subst(self, strSubst):
+ if strSubst[0] == '$':
+ return self.data[strSubst[1:]]
return strSubst
+ def subst_list(self, strSubst):
+ if strSubst[0] == '$':
+ return [self.data[strSubst[1:]]]
+ return [[strSubst]]
def subst_path(self, path):
if type(path) != type([]):
path = [path]
self.failUnless(s.recursive == 1,
"did not set recursive flag to 1")
+ def test_get_skeys(self):
+ """Test the Scanner.Base get_skeys() method"""
+ s = SCons.Scanner.Base(function = self.func)
+ sk = s.get_skeys()
+ self.failUnless(sk == [],
+ "did not initialize to expected []")
+
+ s = SCons.Scanner.Base(function = self.func, skeys = ['.1', '.2'])
+ sk = s.get_skeys()
+ self.failUnless(sk == ['.1', '.2'],
+ "sk was %s, not ['.1', '.2']")
+
+ s = SCons.Scanner.Base(function = self.func, skeys = '$LIST')
+ env = DummyEnvironment(LIST = ['.3', '.4'])
+ sk = s.get_skeys(env)
+ self.failUnless(sk == ['.3', '.4'],
+ "sk was %s, not ['.3', '.4']")
+
class CurrentTestCase(unittest.TestCase):
def test_class(self):
"""Test the Scanner.Current class"""
"""Add a skey to the list of skeys"""
self.skeys.append(skey)
+ def get_skeys(self, env=None):
+ if SCons.Util.is_String(self.skeys):
+ return env.subst_list(self.skeys)[0]
+ return self.skeys
+
+
class Current(Base):
"""
A class for scanning files that are source files (have no builder)
env['RCINCPREFIX'] = '--include-dir '
env['RCINCSUFFIX'] = ''
env['RCCOM'] = '$RC $RCINCFLAGS $RCFLAGS -i $SOURCE -o $TARGET'
- CScan = env.get_scanner('.c')
- if CScan:
- CScan.add_skey('.rc')
+ env.Append(CPPSUFFIXES = ['.rc'])
env['BUILDERS']['RES'] = res_builder
# Some setting from the platform also have to be overridden:
env['RC'] = 'rc'
env['RCFLAGS'] = SCons.Util.CLVar('')
env['RCCOM'] = '$RC $_CPPDEFFLAGS $_CPPINCFLAGS $RCFLAGS /fo$TARGET $SOURCES'
- CScan = env.get_scanner('.c')
- if CScan:
- CScan.add_skey('.rc')
+ env.Append(CPPSUFFIXES = ['.rc'])
env['BUILDERS']['RES'] = res_builder
try:
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Test that we can add filesuffixes to $CPPSUFFIXES.
+"""
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+env = Environment(CPPPATH = ['.'])
+env.Append(CPPSUFFIXES = ['.x'])
+env.InstallAs('foo_c', 'foo.c')
+env.InstallAs('foo_x', 'foo.x')
+""")
+
+test.write('foo.c', """\
+#include <foo.h>
+""")
+
+test.write('foo.x', """\
+#include <foo.h>
+""")
+
+test.write('foo.h', "foo.h 1\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.c" as "foo_c"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.write('foo.h', "foo.h 2\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.c" as "foo_c"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Test that we can add filesuffixes to $DSUFFIXES.
+"""
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+env = Environment(DPATH=['.'])
+env.Append(DSUFFIXES = ['.x'])
+env.InstallAs('foo_d', 'foo.d')
+env.InstallAs('foo_x', 'foo.x')
+""")
+
+test.write('foo.d', """\
+import inc;
+""")
+
+test.write('foo.x', """\
+import inc;
+""")
+
+test.write('inc.d', "inc.d 1\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.d" as "foo_d"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.write('inc.d', "inc 2\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.d" as "foo_d"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Test that we can add filesuffixes to $FORTRANSUFFIXES.
+"""
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+env = Environment()
+env.Append(FORTRANSUFFIXES = ['.x'])
+env.InstallAs('foo_f', 'foo.f')
+env.InstallAs('foo_x', 'foo.x')
+""")
+
+test.write('foo.f', """\
+INCLUDE 'foo.h'
+""")
+
+test.write('foo.x', """\
+INCLUDE 'foo.h'
+""")
+
+test.write('foo.h', "foo.h 1\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.f" as "foo_f"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.write('foo.h', "foo.h 2\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.f" as "foo_f"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Test that we can add filesuffixes to $IDLSUFFIXES.
+"""
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+import SCons.Scanner.IDL
+env = Environment(CPPPATH=['.'])
+env.Append(SCANNERS = [ SCons.Scanner.IDL.IDLScan() ],
+ IDLSUFFIXES = ['.x'])
+env.InstallAs('foo_idl', 'foo.idl')
+env.InstallAs('foo_x', 'foo.x')
+""")
+
+test.write('foo.idl', """\
+import <foo.h>
+""")
+
+test.write('foo.x', """\
+#include <foo.h>
+""")
+
+test.write('foo.h', "foo.h 1\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.idl" as "foo_idl"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.write('foo.h', "foo.h 2\n")
+
+test.run(arguments='.', stdout=test.wrap_stdout("""\
+Install file: "foo.idl" as "foo_idl"
+Install file: "foo.x" as "foo_x"
+"""))
+
+test.up_to_date(arguments='.')
+
+test.pass_test()
projects / scons.git / commitdiff