(see the next section).
The generator function
-takes 3 arguments:
+takes four arguments:
.I source
- a list of source nodes,
.I target
- a list of target nodes,
.I env
-- the construction environment. Example:
+- the construction environment.
+.I for_signature
+- a Boolean value that specifies
+whether the generator is being called
+for generating a build signature
+(as opposed to actually executing the command).
+Example:
.ES
-def g(source, target, env):
+def g(source, target, env, for_signature):
return [["gcc", "-c", "-o"] + target + source]
b = Builder(name="Object", generator=g)
- Fix for relative CPPPATH directories in subsidiary SConscript files
(broken in 0.06).
+ - Add a for_signature argument to command generators, so that
+ generators that need to can return distinct values for the
+ command signature and for executing the command.
+
From Alex Jacques:
- Create a better scons.bat file from a py2bat.py script on the Python
is an optional SCons.Node.FS.FS object. You will need to update
the interfaces of any local Scanner functions you have defined.
+ - Command generator functions now take a fourth argument,
+ for_signature. You will need to add this argument to any
+ generator functions you have defined.
+
Please note the following important changes since release 0.05:
- Python functions as Builder actions now take Node objects, not
def __init__(self, generator):
self.generator = generator
- def __generate(self, kw):
+ def __generate(self, kw, for_signature):
import SCons.Util
# Wrap the environment dictionary in an EnvDictProxy
# object to make variable interpolation easier for the
# client.
args = copy.copy(kw)
+ args['for_signature'] = for_signature
if args.has_key("env") and not isinstance(args["env"], EnvDictProxy):
args["env"] = EnvDictProxy(args["env"])
return gen_cmd
def execute(self, **kw):
- return apply(self.__generate(kw).execute, (), kw)
+ return apply(self.__generate(kw, 0).execute, (), kw)
def get_contents(self, **kw):
"""Return the signature contents of this action's command line.
This strips $(-$) and everything in between the string,
since those parts don't affect signatures.
"""
- return apply(self.__generate(kw).get_contents, (), kw)
+ return apply(self.__generate(kw, 1).get_contents, (), kw)
class LazyCmdGenerator:
"""This is a simple callable class that acts as a command generator.
"""Test executing a command generator Action
"""
- def f(dummy, env, self=self):
+ def f(dummy, env, for_signature, self=self):
self.dummy = dummy
assert env.subst("$FOO $( bar $) baz") == 'foo baz\nbar ack bar baz', env.subst("$FOO $( bar $) baz")
assert env.subst("$FOO $( bar $) baz", raw=1) == 'foo baz\nbar ack $( bar $) baz', env.subst("$FOO $( bar $) baz", raw=1)
assert env.subst_list([ '$foo', '$(', 'bar', '$)' ],
raw=1) == [[ 'bar', '$(', 'bar', '$)' ]], env.subst_list([ '$foo', '$(', 'bar', '$)' ], raw=1)
self.dummy=dummy
- def f2(dummy, env, f=func_action):
+ def f2(dummy, env, for_signature, f=func_action):
return f
def ch(cmd, args, env, self=self):
self.cmd.append(cmd)
def test_get_contents(self):
"""Test fetching the contents of a command generator Action
"""
- def f(target, source, foo, bar):
+ def f(target, source, foo, bar, for_signature):
+ assert for_signature, for_signature
return [["guux", foo, "$(", "ignore", "$)", bar]]
a = SCons.Action.CommandGeneratorAction(f)
self.action_static = static
self.action_shared = shared
- def __call__(self, target, source, env, shared=0):
+ def __call__(self, target, source, env, shared=0, for_signature=0):
for src in source:
try:
if src.attributes.shared != shared:
src_suffix = static_obj.src_suffixes(),
src_builder = [CFile, CXXFile])
-def win32TempFileMunge(env, cmd_list):
+def win32TempFileMunge(env, cmd_list, for_signature):
"""Given a list of command line arguments, see if it is too
long to pass to the win32 command line interpreter. If so,
create a temp file, then pass "@tempfile" as the sole argument
to the supplied command (which is the first element of cmd_list).
Otherwise, just return [cmd_list]."""
cmd = env.subst_list(cmd_list)[0]
- cmdlen = reduce(lambda x, y: x + len(y), cmd, 0) + len(cmd)
- if cmdlen <= 2048:
+ if for_signature or \
+ (reduce(lambda x, y: x + len(y), cmd, 0) + len(cmd)) <= 2048:
return [cmd_list]
else:
import tempfile
return [ [cmd[0], '@' + tmp],
['del', tmp] ]
-def win32LinkGenerator(env, target, source, **kw):
+def win32LinkGenerator(env, target, source, for_signature, **kw):
args = [ '$LINK', '$LINKFLAGS', '/OUT:%s' % target[0],
'$(', '$_LIBDIRFLAGS', '$)', '$_LIBFLAGS' ]
args.extend(map(SCons.Util.to_String, source))
- return win32TempFileMunge(env, args)
+ return win32TempFileMunge(env, args, for_signature)
Program = SCons.Builder.Builder(name='Program',
action='$LINKCOM',
return self.shared_affix
return self.static_affix
-def win32LibGenerator(target, source, env, shared=1):
+def win32LibGenerator(target, source, env, for_signature, shared=1):
listCmd = [ "$SHLINK", "$SHLINKFLAGS" ]
for tgt in target:
else:
# Just treat it as a generic source file.
listCmd.append(str(src))
- return win32TempFileMunge(env, listCmd)
+ return win32TempFileMunge(env, listCmd, for_signature)
def win32LibEmitter(target, source, env, shared=0):
if shared:
""")
test.write('SConstruct', """
-def g(source, target, env):
+def g(source, target, for_signature, env):
import sys
python = sys.executable
return [[python, "build.py", "$TEMPFILE"] + source,
if sys.platform == 'win32':
lib_=''
_dll = '.dll'
+ _export = '__declspec(dllexport) '
linkflag = '/LIBPATH:' + test.workpath()
else:
lib_='lib'
_dll='.so'
+ _export=''
linkflag = '-L' + test.workpath()
test.write('SConstruct', """
""" % (linkflag, linkflag))
test.write('foo.c', r"""
+%svoid foo() { }
+
int
main(int argc, char *argv[])
{
printf("foo.c\n");
exit (0);
}
-""")
+""" % _export)
test.run(arguments = '.')
+test.up_to_date(arguments = '.')
+
test.run(program = test.workpath('foo'), stdout = "foo.c\n")
test.fail_test(not os.path.exists(lib_+'bar'+_dll))
projects / scons.git / commitdiff