env = Environment(platform = my_platform)
.EE
+Additionally, a specific set of tools
+with which to initialize the environment
+may specified as an optional keyword argument:
+
+.ES
+env = Environment(tools = ['msvc', 'lex'])
+.EE
+
+The elements of the tools list may also
+be functions or callable objects,
+in which case the Environment() method
+will call the specified elements
+to update the new construction environment:
+
+.ES
+def my_tool(env):
+ env['XYZZY'] = 'xyzzy'
+
+env = Environment(tools = [my_tool])
+.EE
+
+SCons supports the following tool specifications
+out of the box on
+.B cygwin
+and
+.B posix
+platforms:
+
+.ES
+ar
+dvipdf
+dvips
+g++
+g77
+gcc
+gnulink
+latex
+lex
+pdflatex
+pdftex
+tex
+yacc
+.EE
+
+and supports the following tool specifications out of the box on
+.B win32
+platforms:
+
+.ES
+dvipdf
+dvips
+g77
+latex
+lex
+lib
+mslink
+msvc
+pdflatex
+pdftex
+tex
+yacc
+.EE
+
.SS Builder Methods
Build rules are specified by calling a construction
.TP
.RI SConscriptChdir( value )
-When a non-negative
+When a non-zero
.I value
is specified,
this instructs
or by using a similar function such as the
string.split() function in the Python library.
+.TP
+.RI Tool( string )
+Returns a callable object
+that can be used to initialize
+a construction environment using the
+tools keyword of the Environment() method.
+
+.ES
+env = Environment(tools = [ Tool('msvc') ])
+.EE
+
.TP
.RI WhereIs( program ", [" path ", [" pathext ]])
/usr/lib/scons/SCons/Sig/__init__.pyc
/usr/lib/scons/SCons/Taskmaster.py
/usr/lib/scons/SCons/Taskmaster.pyc
+/usr/lib/scons/SCons/Tool/__init__.py
+/usr/lib/scons/SCons/Tool/__init__.pyc
+/usr/lib/scons/SCons/Tool/ar.py
+/usr/lib/scons/SCons/Tool/ar.pyc
+/usr/lib/scons/SCons/Tool/dvipdf.py
+/usr/lib/scons/SCons/Tool/dvipdf.pyc
+/usr/lib/scons/SCons/Tool/dvips.py
+/usr/lib/scons/SCons/Tool/dvips.pyc
+/usr/lib/scons/SCons/Tool/g++.py
+/usr/lib/scons/SCons/Tool/g++.pyc
+/usr/lib/scons/SCons/Tool/g77.py
+/usr/lib/scons/SCons/Tool/g77.pyc
+/usr/lib/scons/SCons/Tool/gcc.py
+/usr/lib/scons/SCons/Tool/gcc.pyc
+/usr/lib/scons/SCons/Tool/gnulink.py
+/usr/lib/scons/SCons/Tool/gnulink.pyc
+/usr/lib/scons/SCons/Tool/latex.py
+/usr/lib/scons/SCons/Tool/latex.pyc
+/usr/lib/scons/SCons/Tool/lex.py
+/usr/lib/scons/SCons/Tool/lex.pyc
+/usr/lib/scons/SCons/Tool/lib.py
+/usr/lib/scons/SCons/Tool/lib.pyc
+/usr/lib/scons/SCons/Tool/mslink.py
+/usr/lib/scons/SCons/Tool/mslink.pyc
+/usr/lib/scons/SCons/Tool/msvc.py
+/usr/lib/scons/SCons/Tool/msvc.pyc
+/usr/lib/scons/SCons/Tool/pdflatex.py
+/usr/lib/scons/SCons/Tool/pdflatex.pyc
+/usr/lib/scons/SCons/Tool/pdftex.py
+/usr/lib/scons/SCons/Tool/pdftex.pyc
+/usr/lib/scons/SCons/Tool/tex.py
+/usr/lib/scons/SCons/Tool/tex.pyc
+/usr/lib/scons/SCons/Tool/yacc.py
+/usr/lib/scons/SCons/Tool/yacc.pyc
/usr/lib/scons/SCons/Util.py
/usr/lib/scons/SCons/Util.pyc
/usr/lib/scons/SCons/Warnings.py
- Removed support for the prefix, suffix and src_suffix arguments
to Builder() to be callable functions.
+ From Charles Crain and Steven Knight:
+
+ - Add a "tools=" keyword argument to Environment instantiation,
+ and a separate Tools() method, for more flexible specification
+ of tool-specific environment changes.
+
From Steven Knight:
- Add a "platform=" keyword argument to Environment instantiation,
SCons/Sig/MD5.py
SCons/Sig/TimeStamp.py
SCons/Taskmaster.py
+SCons/Tool/__init__.py
+SCons/Tool/ar.py
+SCons/Tool/dvipdf.py
+SCons/Tool/dvips.py
+SCons/Tool/g++.py
+SCons/Tool/g77.py
+SCons/Tool/gcc.py
+SCons/Tool/gnulink.py
+SCons/Tool/latex.py
+SCons/Tool/lex.py
+SCons/Tool/lib.py
+SCons/Tool/mslink.py
+SCons/Tool/msvc.py
+SCons/Tool/pdflatex.py
+SCons/Tool/pdftex.py
+SCons/Tool/tex.py
+SCons/Tool/yacc.py
SCons/Util.py
SCons/Warnings.py
"""SCons.Builder
-XXX
+Builder object subsystem.
+
+A Builder object is a callable that encapsulates information about how
+to execute actions to create a Node (file) from other Nodes (files), and
+how to create those dependencies for tracking.
+
+The main entry point here is the Builder() factory method. This
+provides a procedural interface that creates the right underlying
+Builder object based on the keyword arguments supplied and the types of
+the arguments.
+
+The goal is for this external interface to be simple enough that the
+vast majority of users can create new Builders as necessary to support
+building new types of files in their configurations, without having to
+dive any deeper into this subsystem.
"""
def src_suffixes(self):
return self.action_dict.keys()
+ def add_action(self, suffix, action):
+ """Add a suffix-action pair to the mapping.
+ """
+ self.action_dict[suffix] = action
+
def __call__(self, source, target, env, **kw):
ext = None
for src in map(str, source):
return self.action_dict[ext]
except KeyError:
raise UserError("Don't know how to build a file with suffix %s." % ext)
+ def __cmp__(self, other):
+ return cmp(self.action_dict, other.action_dict)
def Builder(**kw):
"""A factory for builder objects."""
+ composite = None
if kw.has_key('name'):
SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
"The use of the 'name' parameter to Builder() is deprecated.")
kw['action'] = SCons.Action.CommandGenerator(kw['generator'])
del kw['generator']
elif kw.has_key('action') and SCons.Util.is_Dict(kw['action']):
- action_dict = kw['action']
- kw['action'] = SCons.Action.CommandGenerator(DictCmdGenerator(action_dict))
- kw['src_suffix'] = action_dict.keys()
+ composite = DictCmdGenerator(kw['action'])
+ kw['action'] = SCons.Action.CommandGenerator(composite)
+ kw['src_suffix'] = composite.src_suffixes()
if kw.has_key('emitter') and \
SCons.Util.is_String(kw['emitter']):
kw['emitter'] = EmitterProxy(var)
if kw.has_key('src_builder'):
- return apply(MultiStepBuilder, (), kw)
+ ret = apply(MultiStepBuilder, (), kw)
else:
- return apply(BuilderBase, (), kw)
+ ret = apply(BuilderBase, (), kw)
+
+ if composite:
+ ret = CompositeBuilder(ret, composite)
+
+ return ret
def _init_nodes(builder, env, args, tlist, slist):
"""Initialize lists of target and source nodes with all of
t.add_source(slist)
if builder.scanner:
t.target_scanner = builder.scanner
-
-class _callable_adaptor:
- """When crteating a Builder, you can pass a string OR
- a callable in for prefix, suffix, or src_suffix.
- src_suffix even takes a list!
-
- If a string or list is passed, we use this class to
- adapt it to a callable."""
- def __init__(self, static):
- self.static = static
-
- def __call__(self, **kw):
- return self.static
-
- def __cmp__(self, other):
- if isinstance(other, _callable_adaptor):
- return cmp(self.static, other.static)
- return -1
-
+
def _adjust_suffix(suff):
if suff and not suff[0] in [ '.', '$' ]:
return '.' + suff
def __call__(self, target, source, env, **kw):
emitter = self.var
- # Recursively substitue the variable.
+ # Recursively substitute the variable.
# We can't use env.subst() because it deals only
# in strings. Maybe we should change that?
while SCons.Util.is_String(emitter) and \
args.update(kw)
return apply(emitter, (), args)
+ def __cmp__(self, other):
+ return cmp(self.var, other.var)
+
class BuilderBase:
"""Base class for Builders, objects that create output
nodes (files) from input nodes (files).
self.prefix = prefix
self.suffix = suffix
- if SCons.Util.is_String(src_suffix):
- self.src_suffix = [ src_suffix ]
- else:
- self.src_suffix = src_suffix
+ self.set_src_suffix(src_suffix)
self.target_factory = target_factory or node_factory
self.source_factory = source_factory or node_factory
ret.append(f)
return ret
- pre = self.get_prefix(env, args)
- suf = self.get_suffix(env, args)
- src_suf = self.get_src_suffix(env, args)
+ pre = self.get_prefix(env)
+ suf = self.get_suffix(env)
+ src_suf = self.get_src_suffix(env)
if self.emitter:
# pass the targets and sources to the emitter as strings
# rather than nodes since str(node) doesn't work
return tlist
-
def execute(self, **kw):
"""Execute a builder's action to create an output object.
"""
"""
return apply(self.action.get_contents, (), kw)
- def src_suffixes(self, env, args):
+ def src_suffixes(self, env):
return map(lambda x, e=env: e.subst(_adjust_suffix(x)),
self.src_suffix)
- def get_src_suffix(self, env, args):
+ def set_src_suffix(self, src_suffix):
+ if not src_suffix:
+ src_suffix = []
+ elif not SCons.Util.is_List(src_suffix):
+ src_suffix = [ src_suffix ]
+ self.src_suffix = src_suffix
+
+ def get_src_suffix(self, env):
"""Get the first src_suffix in the list of src_suffixes."""
- if not self.src_suffix:
+ ret = self.src_suffixes(env)
+ if not ret:
return ''
- else:
- return self.src_suffix[0]
+ return ret[0]
- def get_suffix(self, env, args):
+ def get_suffix(self, env):
return env.subst(_adjust_suffix(self.suffix))
- def get_prefix(self, env, args):
+ def get_prefix(self, env):
return env.subst(self.prefix)
def targets(self, node):
"""
return [ node ]
-class ListBuilder:
- """This is technically not a Builder object, but a wrapper
- around another Builder object. This is designed to look
- like a Builder object, though, for purposes of building an
- array of targets from a single Action execution.
+class ListBuilder(SCons.Util.Proxy):
+ """A Proxy to support building an array of targets (for example,
+ foo.o and foo.h from foo.y) from a single Action execution.
"""
def __init__(self, builder, env, tlist):
+ SCons.Util.Proxy.__init__(self, builder)
self.builder = builder
+ self.scanner = builder.scanner
+ self.env = env
self.tlist = tlist
- self.name = "ListBuilder(%s)"%builder.get_name(env)
-
- def get_name(self, env):
- return self.name
+ self.multi = builder.multi
+ self.name = "ListBuilder(%s)"%builder.name
def execute(self, **kw):
if hasattr(self, 'status'):
return self.tlist
def __cmp__(self, other):
- return cmp(self.__dict__, other.__dict__)
+ return cmp(self.__dict__, other.__dict__)
- def __getattr__(self, name):
- return getattr(self.builder, name)
+ def get_name(self, env):
+ """Attempts to get the name of the Builder.
+
+ If the Builder's name attribute is None, then we will look at
+ the BUILDERS variable of env, expecting it to be a dictionary
+ containing this Builder, and we will return the key of the
+ dictionary."""
+
+ return "ListBuilder(%s)" % self.builder.get_name(env)
class MultiStepBuilder(BuilderBase):
"""This is a builder subclass that can build targets in
sdict = {}
self.sdict[r] = sdict
for bld in self.src_builder:
- for suf in bld.src_suffixes(env, kw):
+ if SCons.Util.is_String(bld):
+ try:
+ bld = env['BUILDERS'][bld]
+ except KeyError:
+ continue
+ for suf in bld.src_suffixes(env):
sdict[suf] = bld
for snode in slist:
# Only supply the builder with sources it is capable
# of building.
tgt = filter(lambda x,
- suf=self.src_suffixes(env, kw):
+ suf=self.src_suffixes(env):
os.path.splitext(SCons.Util.to_String(x))[1] in \
suf, tgt)
final_sources.extend(tgt)
return apply(BuilderBase.__call__,
(self, env), dictKwArgs)
- def src_suffixes(self, env, args):
- return BuilderBase.src_suffixes(self, env, args) + \
- reduce(lambda x, y: x + y,
- map(lambda b, e=env, args=args: b.src_suffixes(e, args),
- self.src_builder),
- [])
+ def get_src_builders(self, env):
+ """Return all the src_builders for this Builder.
+
+ This is essentially a recursive descent of the src_builder "tree."
+ """
+ ret = []
+ for bld in self.src_builder:
+ if SCons.Util.is_String(bld):
+ # All Environments should have a BUILDERS
+ # variable, so no need to check for it.
+ try:
+ bld = env['BUILDERS'][bld]
+ except KeyError:
+ continue
+ ret.append(bld)
+ return ret
+
+ def src_suffixes(self, env):
+ """Return a list of the src_suffix attributes for all
+ src_builders of this Builder.
+ """
+ suffixes = BuilderBase.src_suffixes(self, env)
+ for builder in self.get_src_builders(env):
+ suffixes.extend(builder.src_suffixes(env))
+ return suffixes
+
+class CompositeBuilder(SCons.Util.Proxy):
+ """A Builder Proxy whose main purpose is to always have
+ a DictCmdGenerator as its action, and to provide access
+ to the DictCmdGenerator's add_action() method.
+ """
+
+ def __init__(self, builder, cmdgen):
+ SCons.Util.Proxy.__init__(self, builder)
+
+ # cmdgen should always be an instance of DictCmdGenerator.
+ self.cmdgen = cmdgen
+ self.builder = builder
+
+ def add_action(self, suffix, action):
+ self.cmdgen.add_action(suffix, action)
+ self.set_src_suffix(self.cmdgen.src_suffixes())
+
+ def __cmp__(self, other):
+ return cmp(self.__dict__, other.__dict__)
for k, v in kw.items():
self.d[k] = v
def subst(self, s):
+ if not SCons.Util.is_String(s):
+ return s
try:
if s[0] == '$':
return self.d.get(s[1:], '')
Make sure that there is no '.' separator appended.
"""
builder = SCons.Builder.Builder(name = "builder", prefix = 'lib.')
- assert builder.get_prefix(env,{}) == 'lib.'
+ assert builder.get_prefix(env) == 'lib.'
builder = SCons.Builder.Builder(name = "builder", prefix = 'lib')
- assert builder.get_prefix(env,{}) == 'lib'
+ assert builder.get_prefix(env) == 'lib'
tgt = builder(env, target = 'tgt1', source = 'src1')
assert tgt.path == 'libtgt1', \
"Target has unexpected name: %s" % tgt.path
env = Environment(XSUFFIX = '.x', YSUFFIX = '.y')
b1 = SCons.Builder.Builder(name = "builder", src_suffix = '.c')
- assert b1.src_suffixes(env,{}) == ['.c'], b1.src_suffixes(env,{})
+ assert b1.src_suffixes(env) == ['.c'], b1.src_suffixes(env)
tgt = b1(env, target = 'tgt2', source = 'src2')
assert tgt.sources[0].path == 'src2.c', \
b2 = SCons.Builder.Builder(name = "b2",
src_suffix = '.2',
src_builder = b1)
- assert b2.src_suffixes(env,{}) == ['.2', '.c'], b2.src_suffixes(env,{})
+ assert b2.src_suffixes(env) == ['.2', '.c'], b2.src_suffixes(env)
b3 = SCons.Builder.Builder(name = "b3",
action = {'.3a' : '', '.3b' : ''})
- s = b3.src_suffixes(env,{})
+ s = b3.src_suffixes(env)
s.sort()
assert s == ['.3a', '.3b'], s
b4 = SCons.Builder.Builder(name = "b4", src_suffix = '$XSUFFIX')
- assert b4.src_suffixes(env,{}) == ['.x'], b4.src_suffixes(env,{})
+ assert b4.src_suffixes(env) == ['.x'], b4.src_suffixes(env)
- b5 = SCons.Builder.Builder(name = "b5", action = {'$YSUFFIX' : ''})
- assert b5.src_suffixes(env,{}) == ['.y'], b5.src_suffixes(env,{})
+ b5 = SCons.Builder.Builder(name = "b5", action = { '.y' : ''})
+ assert b5.src_suffixes(env) == ['.y'], b5.src_suffixes(env)
def test_suffix(self):
"""Test Builder creation with a specified target suffix
beginning if it isn't already present.
"""
builder = SCons.Builder.Builder(name = "builder", suffix = '.o')
- assert builder.get_suffix(env,{}) == '.o', builder.get_suffix(env,{})
+ assert builder.get_suffix(env) == '.o', builder.get_suffix(env)
builder = SCons.Builder.Builder(name = "builder", suffix = 'o')
- assert builder.get_suffix(env,{}) == '.o', builder.get_suffix(env,{})
+ assert builder.get_suffix(env) == '.o', builder.get_suffix(env)
tgt = builder(env, target = 'tgt3', source = 'src3')
assert tgt.path == 'tgt3.o', \
"Target has unexpected name: %s" % tgt.path
str(tgt.sources[0].sources[0])
assert str(tgt.sources[1]) == 'test2.foo', str(tgt.sources[1])
assert str(tgt.sources[2]) == 'test3.txt', str(tgt.sources[2])
+
+ builder3 = SCons.Builder.MultiStepBuilder(name = "builder3",
+ action = 'foo',
+ src_builder = 'xyzzy',
+ src_suffix = '.xyzzy')
+ assert builder3.get_src_builders(Environment()) == []
def test_CompositeBuilder(self):
"""Testing CompositeBuilder class."""
action={ '.foo' : func_action,
'.bar' : func_action })
- assert isinstance(builder, SCons.Builder.BuilderBase)
+ assert isinstance(builder, SCons.Builder.CompositeBuilder)
assert isinstance(builder.action, SCons.Action.CommandGeneratorAction)
tgt = builder(env, target='test1', source='test1.foo')
assert isinstance(tgt.builder, SCons.Builder.BuilderBase)
- assert isinstance(tgt.builder.action.generator, SCons.Builder.DictCmdGenerator)
+ assert tgt.builder.action is builder.action
+ tgt = builder(env, target='test2', source='test1.bar')
+ assert isinstance(tgt.builder, SCons.Builder.BuilderBase)
+ assert tgt.builder.action is builder.action
flag = 0
- tgt = builder(env, target='test2', source=['test2.bar', 'test1.foo'])
+ tgt = builder(env, target='test3', source=['test2.bar', 'test1.foo'])
try:
tgt.build()
except SCons.Errors.UserError:
action = { '.foo' : 'foo',
'.bar' : 'bar' },
src_builder = foo_bld)
- assert isinstance(builder, SCons.Builder.MultiStepBuilder)
+ assert isinstance(builder, SCons.Builder.CompositeBuilder)
assert isinstance(builder.action, SCons.Action.CommandGeneratorAction)
tgt = builder(env, target='t1', source='t1a.ina t1b.ina')
suffix = '.bar')
assert isinstance(bar_bld, SCons.Builder.BuilderBase)
builder = SCons.Builder.Builder(name = "builder",
- action = { '.foo' : 'foo',
- '.bar' : 'bar' },
+ action = { '.foo' : 'foo'},
src_builder = [foo_bld, bar_bld])
- assert isinstance(builder, SCons.Builder.MultiStepBuilder)
+ assert isinstance(builder, SCons.Builder.CompositeBuilder)
assert isinstance(builder.action, SCons.Action.CommandGeneratorAction)
+ builder.add_action('.bar', 'bar')
+
tgt = builder(env, target='t3-foo', source='t3a.foo t3b.ina')
assert isinstance(tgt.builder, SCons.Builder.MultiStepBuilder)
assert 'baz' in map(str, tgt.sources), map(str, tgt.sources)
assert 'bar' in map(str, tgt.sources), map(str, tgt.sources)
+ builder2a=SCons.Builder.Builder(name="builder2", action='foo',
+ emitter="$FOO")
+ assert builder2 == builder2a, repr(builder2.__dict__) + "\n" + repr(builder2a.__dict__)
+
if __name__ == "__main__":
suite = unittest.makeSuite(BuilderTestCase, 'test_')
if not unittest.TextTestRunner().run(suite).wasSuccessful():
import SCons.Action
import SCons.Builder
-import SCons.Errors
import SCons.Node.Alias
import SCons.Node.FS
-import SCons.Platform
import SCons.Scanner.C
import SCons.Scanner.Fortran
import SCons.Scanner.Prog
-import SCons.Util
+
+def alias_builder(env, target, source):
+ pass
+
+Alias = SCons.Builder.Builder(action = alias_builder,
+ target_factory = SCons.Node.Alias.default_ans.Alias,
+ source_factory = SCons.Node.FS.default_fs.Entry,
+ multi = 1)
+
+CScan = SCons.Scanner.C.CScan()
+
+FortranScan = SCons.Scanner.Fortran.FortranScan()
def yaccEmitter(target, source, env, **kw):
# Yacc can be configured to emit a .h file as well
'.h')
return (target, source)
-CFile = SCons.Builder.Builder(action = { '.l' : '$LEXCOM',
- '.y' : '$YACCCOM',
- },
- emitter = yaccEmitter,
- suffix = '$CFILESUFFIX')
+def CFile():
+ """Common function to generate a C file Builder."""
+ return SCons.Builder.Builder(action = {},
+ emitter = yaccEmitter,
+ suffix = '$CFILESUFFIX')
-CXXFile = SCons.Builder.Builder(action = { '.ll' : '$LEXCOM',
- '.yy' : '$YACCCOM',
- },
- emitter = yaccEmitter,
- suffix = '$CXXFILESUFFIX')
+def CXXFile():
+ """Common function to generate a C++ file Builder."""
+ return SCons.Builder.Builder(action = {},
+ emitter = yaccEmitter,
+ suffix = '$CXXFILESUFFIX')
class SharedFlagChecker:
"""This is a callable class that is used as
F77PPAction = SCons.Action.Action([ StaticCheck, "$F77PPCOM" ])
ShF77PPAction = SCons.Action.Action([ SharedCheck, "$SHF77PPCOM" ])
-if os.path.normcase('.c') == os.path.normcase('.C'):
- # We're on a case-insensitive system, so .[CF] (upper case)
- # files should be treated like .[cf] (lower case) files.
- C_static = CAction
- C_shared = ShCAction
- F_static = F77Action
- F_shared = ShF77Action
-else:
- # We're on a case-sensitive system, so .C (upper case) files
- # are C++, and .F (upper case) files get run through the C
- # preprocessor.
- C_static = CXXAction
- C_shared = ShCXXAction
- F_static = F77PPAction
- F_shared = ShF77PPAction
-
-StaticObject = SCons.Builder.Builder(action = { ".C" : C_static,
- ".cc" : CXXAction,
- ".cpp" : CXXAction,
- ".cxx" : CXXAction,
- ".c++" : CXXAction,
- ".C++" : CXXAction,
- ".c" : CAction,
- ".f" : F77Action,
- ".for" : F77Action,
- ".F" : F_static,
- ".FOR" : F77Action,
- ".fpp" : F77PPAction,
- ".FPP" : F77PPAction },
- prefix = '$OBJPREFIX',
- suffix = '$OBJSUFFIX',
- src_builder = [CFile, CXXFile])
-
-SharedObject = SCons.Builder.Builder(action = { ".C" : C_shared,
- ".cc" : ShCXXAction,
- ".cpp" : ShCXXAction,
- ".cxx" : ShCXXAction,
- ".c++" : ShCXXAction,
- ".C++" : ShCXXAction,
- ".c" : ShCAction,
- ".f" : ShF77Action,
- ".for" : ShF77Action,
- ".FOR" : ShF77Action,
- ".F" : F_shared,
- ".fpp" : ShF77PPAction,
- ".FPP" : ShF77PPAction },
- prefix = '$OBJPREFIX',
- suffix = '$OBJSUFFIX',
- src_builder = [CFile, CXXFile])
-
-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]
- if for_signature or \
- (reduce(lambda x, y: x + len(y), cmd, 0) + len(cmd)) <= 2048:
- return [cmd_list]
- else:
- import tempfile
- # We do a normpath because mktemp() has what appears to be
- # a bug in Win32 that will use a forward slash as a path
- # delimiter. Win32's link mistakes that for a command line
- # switch and barfs.
- tmp = os.path.normpath(tempfile.mktemp())
- args = map(SCons.Util.quote_spaces, cmd[1:])
- open(tmp, 'w').write(string.join(args, " ") + "\n")
- return [ [cmd[0], '@' + tmp],
- ['del', tmp] ]
-
-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, for_signature)
-ProgScan = SCons.Scanner.Prog.ProgScan()
+def StaticObject():
+ """A function for generating the static object Builder."""
+ return SCons.Builder.Builder(action = {},
+ prefix = '$OBJPREFIX',
+ suffix = '$OBJSUFFIX',
+ src_builder = ['CFile', 'CXXFile'])
-Program = SCons.Builder.Builder(action=[ StaticCheck, '$LINKCOM' ],
- prefix='$PROGPREFIX',
- suffix='$PROGSUFFIX',
- src_suffix='$OBJSUFFIX',
- src_builder=StaticObject,
- scanner = ProgScan)
+def SharedObject():
+ """A function for generating the shared object Builder."""
+ return SCons.Builder.Builder(action = {},
+ prefix = '$OBJPREFIX',
+ suffix = '$OBJSUFFIX',
+ src_builder = ['CFile', 'CXXFile'])
-def win32LibGenerator(target, source, env, for_signature, no_import_lib=0):
- listCmd = [ "$SHLINK", "$SHLINKFLAGS" ]
-
- for tgt in target:
- ext = os.path.splitext(str(tgt))[1]
- if ext == env.subst("$LIBSUFFIX"):
- # Put it on the command line as an import library.
- if no_import_lib:
- raise SCons.Errors.UserError, "%s: You cannot specify a .lib file as a target of a shared library build if no_import_library is nonzero." % tgt
- listCmd.append("${WIN32IMPLIBPREFIX}%s" % tgt)
- else:
- listCmd.append("${WIN32DLLPREFIX}%s" % tgt)
-
- listCmd.extend([ '$_LIBDIRFLAGS', '$_LIBFLAGS' ])
- for src in source:
- ext = os.path.splitext(str(src))[1]
- if ext == env.subst("$WIN32DEFSUFFIX"):
- # Treat this source as a .def file.
- listCmd.append("${WIN32DEFPREFIX}%s" % src)
- else:
- # Just treat it as a generic source file.
- listCmd.append(str(src))
- return win32TempFileMunge(env, listCmd, for_signature)
-
-def win32LibEmitter(target, source, env, no_import_lib=0):
- dll = None
- for tgt in target:
- ext = os.path.splitext(str(tgt))[1]
- if ext == env.subst("$SHLIBSUFFIX"):
- dll = tgt
- break
- if not dll:
- raise SCons.Errors.UserError, "A shared library should have exactly one target with the suffix: %s" % env.subst("$SHLIBSUFFIX")
-
- if env.has_key("WIN32_INSERT_DEF") and \
- env["WIN32_INSERT_DEF"] and \
- not '.def' in map(lambda x: os.path.split(str(x))[1],
- source):
-
- # append a def file to the list of sources
- source.append("%s%s" % (os.path.splitext(str(dll))[0],
- env.subst("$WIN32DEFSUFFIX")))
- if not no_import_lib and \
- not env.subst("$LIBSUFFIX") in \
- map(lambda x: os.path.split(str(x))[1], target):
- # Append an import library to the list of targets.
- target.append("%s%s%s" % (env.subst("$LIBPREFIX"),
- os.path.splitext(str(dll))[0],
- env.subst("$LIBSUFFIX")))
- return (target, source)
+ProgScan = SCons.Scanner.Prog.ProgScan()
StaticLibrary = SCons.Builder.Builder(action=[ StaticCheck, "$ARCOM" ],
prefix = '$LIBPREFIX',
suffix = '$LIBSUFFIX',
src_suffix = '$OBJSUFFIX',
- src_builder = StaticObject)
+ src_builder = 'Object')
SharedLibrary = SCons.Builder.Builder(action=[ SharedCheck, "$SHLINKCOM" ],
- emitter="$LIBEMITTER",
+ emitter="$SHLIBEMITTER",
prefix = '$SHLIBPREFIX',
suffix = '$SHLIBSUFFIX',
scanner = ProgScan,
src_suffix = '$OBJSUFFIX',
- src_builder = SharedObject)
-
-LaTeXAction = SCons.Action.Action('$LATEXCOM')
-
-DVI = SCons.Builder.Builder(action = { '.tex' : '$TEXCOM',
- '.ltx' : LaTeXAction,
- '.latex' : LaTeXAction,
- },
- # The suffix is not configurable via a
- # construction variable like $DVISUFFIX
- # because the output file name is
- # hard-coded within TeX.
- suffix = '.dvi')
-
-PDFLaTeXAction = SCons.Action.Action('$PDFLATEXCOM')
-
-PDF = SCons.Builder.Builder(action = { '.dvi' : '$PDFCOM',
- '.tex' : '$PDFTEXCOM',
- '.ltx' : PDFLaTeXAction,
- '.latex' : PDFLaTeXAction,
- },
- prefix = '$PDFPREFIX',
- suffix = '$PDFSUFFIX')
-
-PostScript = SCons.Builder.Builder(action = '$PSCOM',
- prefix = '$PSPREFIX',
- suffix = '$PSSUFFIX',
- src_suffix = '.dvi',
- src_builder = DVI)
-
-CScan = SCons.Scanner.C.CScan()
-
-FortranScan = SCons.Scanner.Fortran.FortranScan()
+ src_builder = 'SharedObject')
+
+def DVI():
+ """Common function to generate a DVI file Builder."""
+ return SCons.Builder.Builder(action = {},
+ # The suffix is not configurable via a
+ # construction variable like $DVISUFFIX
+ # because the output file name is
+ # hard-coded within TeX.
+ suffix = '.dvi')
+
+def PDF():
+ """A function for generating the PDF Builder."""
+ return SCons.Builder.Builder(action = { },
+ prefix = '$PDFPREFIX',
+ suffix = '$PDFSUFFIX')
-def alias_builder(env, target, source):
- pass
-
-Alias = SCons.Builder.Builder(action = alias_builder,
- target_factory = SCons.Node.Alias.default_ans.Alias,
- source_factory = SCons.Node.FS.default_fs.Entry,
- multi = 1)
+Program = SCons.Builder.Builder(action=[ StaticCheck, '$LINKCOM' ],
+ prefix='$PROGPREFIX',
+ suffix='$PROGSUFFIX',
+ src_suffix='$OBJSUFFIX',
+ src_builder='Object',
+ scanner = ProgScan)
-def get_devstudio_versions ():
- """
- Get list of devstudio versions from the Windows registry. Return a
- list of strings containing version numbers; an exception will be raised
- if we were unable to access the registry (eg. couldn't import
- a registry-access module) or the appropriate registry keys weren't
- found.
- """
-
- if not SCons.Util.can_read_reg:
- raise SCons.Errors.InternalError, "No Windows registry module was found"
-
- K = 'Software\\Microsoft\\Devstudio'
- L = []
- for base in (SCons.Util.HKEY_CLASSES_ROOT,
- SCons.Util.HKEY_LOCAL_MACHINE,
- SCons.Util.HKEY_CURRENT_USER,
- SCons.Util.HKEY_USERS):
- try:
- k = SCons.Util.RegOpenKeyEx(base,K)
- i = 0
- while 1:
- try:
- p = SCons.Util.RegEnumKey(k,i)
- if p[0] in '123456789' and p not in L:
- L.append(p)
- except SCons.Util.RegError:
- break
- i = i + 1
- except SCons.Util.RegError:
- pass
-
- if not L:
- raise SCons.Errors.InternalError, "DevStudio was not found."
-
- L.sort()
- L.reverse()
- return L
-
-def get_msvc_path (path, version, platform='x86'):
- """
- Get a list of devstudio directories (include, lib or path). Return
- a string delimited by ';'. An exception will be raised if unable to
- access the registry or appropriate registry keys not found.
- """
-
- if not SCons.Util.can_read_reg:
- raise SCons.Errors.InternalError, "No Windows registry module was found"
-
- if path=='lib':
- path= 'Library'
- path = string.upper(path + ' Dirs')
- K = ('Software\\Microsoft\\Devstudio\\%s\\' +
- 'Build System\\Components\\Platforms\\Win32 (%s)\\Directories') % \
- (version,platform)
- for base in (SCons.Util.HKEY_CLASSES_ROOT,
- SCons.Util.HKEY_LOCAL_MACHINE,
- SCons.Util.HKEY_CURRENT_USER,
- SCons.Util.HKEY_USERS):
- try:
- k = SCons.Util.RegOpenKeyEx(base,K)
- i = 0
- while 1:
- try:
- (p,v,t) = SCons.Util.RegEnumValue(k,i)
- if string.upper(p) == path:
- return v
- i = i + 1
- except SCons.Util.RegError:
- break
- except SCons.Util.RegError:
- pass
-
- # if we got here, then we didn't find the registry entries:
- raise SCons.Errors.InternalError, "%s was not found in the registry."%path
-
-def get_msdev_dir(version):
- """Returns the root directory of the MSDev installation from the
- registry if it can be found, otherwise we guess."""
- if SCons.Util.can_read_reg:
- K = ('Software\\Microsoft\\Devstudio\\%s\\' +
- 'Products\\Microsoft Visual C++') % \
- version
- for base in (SCons.Util.HKEY_LOCAL_MACHINE,
- SCons.Util.HKEY_CURRENT_USER):
- try:
- k = SCons.Util.RegOpenKeyEx(base,K)
- val, tok = SCons.Util.RegQueryValueEx(k, 'ProductDir')
- return os.path.split(val)[0]
- except SCons.Util.RegError:
- pass
-
-def make_win32_env_from_paths(include, lib, path):
- """
- Build a dictionary of construction variables for a win32 platform.
- include - include path
- lib - library path
- path - executable path
- """
- return {
- 'CC' : 'cl',
- 'CCFLAGS' : '/nologo',
- 'CCCOM' : '$CC $CCFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET',
- 'SHCC' : '$CC',
- 'SHCCFLAGS' : '$CCFLAGS',
- 'SHCCCOM' : '$SHCC $SHCCFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET',
- 'CFILESUFFIX' : '.c',
- 'CXX' : '$CC',
- 'CXXFLAGS' : '$CCFLAGS',
- 'CXXCOM' : '$CXX $CXXFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET',
- 'SHCXX' : '$CXX',
- 'SHCXXFLAGS' : '$CXXFLAGS',
- 'SHCXXCOM' : '$SHCXX $SHCXXFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET',
- 'CXXFILESUFFIX' : '.cc',
- 'F77' : 'g77',
- 'F77FLAGS' : '',
- 'F77COM' : '$F77 $F77FLAGS $_F77INCFLAGS /c $SOURCES /Fo$TARGET',
- 'F77PPCOM' : '$F77 $F77FLAGS $CPPFLAGS $_F77INCFLAGS /c $SOURCES /Fo$TARGET',
- 'SHF77' : '$F77',
- 'SHF77FLAGS' : '$F77FLAGS',
- 'SHF77COM' : '$SHF77 $SHF77FLAGS $_F77INCFLAGS /c $SOURCES /Fo$TARGET',
- 'SHF77PPCOM' : '$SHF77 $SHF77FLAGS $CPPFLAGS $_F77INCFLAGS /c $SOURCES /Fo$TARGET',
- 'LINK' : 'link',
- 'LINKFLAGS' : '/nologo',
- 'LINKCOM' : SCons.Action.CommandGenerator(win32LinkGenerator),
- 'SHLINK' : '$LINK',
- 'SHLINKFLAGS': '$LINKFLAGS /dll',
- 'SHLINKCOM' : SCons.Action.CommandGenerator(win32LibGenerator),
- 'AR' : 'lib',
- 'ARFLAGS' : '/nologo',
- 'ARCOM' : '$AR $ARFLAGS /OUT:$TARGET $SOURCES',
- 'LEX' : 'lex',
- 'LEXFLAGS' : '',
- 'LEXCOM' : '$LEX $LEXFLAGS -t $SOURCES > $TARGET',
- 'YACC' : 'yacc',
- 'YACCFLAGS' : '',
- 'YACCCOM' : '$YACC $YACCFLAGS -o $TARGET $SOURCES',
- 'TEX' : 'tex',
- 'TEXFLAGS' : '',
- 'TEXCOM' : '$TEX $TEXFLAGS $SOURCES',
- 'LATEX' : 'latex',
- 'LATEXFLAGS' : '',
- 'LATEXCOM' : '$LATEX $LATEXFLAGS $SOURCES',
- 'DVIPDF' : 'dvipdf',
- 'DVIPDFFLAGS' : '',
- 'PDFCOM' : '$DVIPDF $DVIPDFFLAGS $SOURCES $TARGET',
- 'PDFPREFIX' : '',
- 'PDFSUFFIX' : '.pdf',
- 'PDFTEX' : 'pdftex',
- 'PDFTEXFLAGS' : '',
- 'PDFTEXCOM' : '$PDFTEX $PDFTEXFLAGS $SOURCES $TARGET',
- 'PDFLATEX' : 'pdflatex',
- 'PDFLATEXFLAGS' : '',
- 'PDFLATEXCOM' : '$PDFLATEX $PDFLATEXFLAGS $SOURCES $TARGET',
- 'DVIPS' : 'dvips',
- 'DVIPSFLAGS' : '',
- 'PSCOM' : '$DVIPS $DVIPSFLAGS -o $TARGET $SOURCES',
- 'PSPREFIX' : '',
- 'PSSUFFIX' : '.ps',
- 'BUILDERS' : { 'Alias' : Alias,
- 'CFile' : CFile,
- 'CXXFile' : CXXFile,
- 'DVI' : DVI,
- 'Library' : StaticLibrary,
- 'StaticLibrary' : StaticLibrary,
- 'SharedLibrary' : SharedLibrary,
- 'Object' : StaticObject,
- 'StaticObject' : StaticObject,
- 'SharedObject' : SharedObject,
- 'PDF' : PDF,
- 'PostScript' : PostScript,
- 'Program' : Program },
- 'SCANNERS' : [CScan, FortranScan],
- 'LIBDIRPREFIX' : '/LIBPATH:',
- 'LIBDIRSUFFIX' : '',
- 'LIBLINKPREFIX' : '',
- 'LIBLINKSUFFIX' : '$LIBSUFFIX',
- 'LIBEMITTER' : win32LibEmitter,
- 'INCPREFIX' : '/I',
- 'INCSUFFIX' : '',
- 'WIN32DEFPREFIX' : '/def:',
- 'WIN32DEFSUFFIX' : '.def',
- 'WIN32DLLPREFIX' : '/out:',
- 'WIN32IMPLIBPREFIX' : '/implib:',
- 'WIN32_INSERT_DEF' : 0,
- 'ENV' : {
- 'INCLUDE' : include,
- 'LIB' : lib,
- 'PATH' : path,
- },
- }
-
-def make_win32_env(version):
- """
- Build a dictionary of construction variables for a win32 platform.
- ver - the version string of DevStudio to use (e.g. "6.0")
- """
- return make_win32_env_from_paths(get_msvc_path("include", version),
- get_msvc_path("lib", version),
- get_msvc_path("path", version)
- + ";" + os.environ['PATH'])
-
-
-if os.name == 'posix':
- arcom = '$AR $ARFLAGS $TARGET $SOURCES'
- ranlib = 'ranlib'
- if SCons.Util.WhereIs(ranlib):
- arcom = arcom + '\n$RANLIB $RANLIBFLAGS $TARGET'
-
- ConstructionEnvironment = {
- 'CC' : 'cc',
- 'CCFLAGS' : '',
- 'CCCOM' : '$CC $CCFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES',
- 'SHCC' : '$CC',
- 'SHCCFLAGS' : '$CCFLAGS -fPIC',
- 'SHCCCOM' : '$SHCC $SHCCFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES',
- 'CFILESUFFIX' : '.c',
- 'CXX' : 'c++',
- 'CXXFLAGS' : '$CCFLAGS',
- 'CXXCOM' : '$CXX $CXXFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES',
- 'CXXFILESUFFIX' : '.cc',
- 'SHCXX' : '$CXX',
- 'SHCXXFLAGS' : '$CXXFLAGS -fPIC',
- 'SHCXXCOM' : '$SHCXX $SHCXXFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES',
- 'F77' : 'g77',
- 'F77FLAGS' : '',
- 'F77COM' : '$F77 $F77FLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES',
- 'F77PPCOM' : '$F77 $F77FLAGS $CPPFLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES',
- 'SHF77FLAGS' : '$F77FLAGS -fPIC',
- 'SHF77COM' : '$F77 $SHF77FLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES',
- 'SHF77PPCOM' : '$F77 $SHF77FLAGS $CPPFLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES',
- 'SHF77' : '$F77',
- 'SHF77FLAGS' : '$F77FLAGS -fPIC',
- 'SHF77COM' : '$SHF77 $SHF77FLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES',
- 'SHF77PPCOM' : '$SHF77 $SHF77FLAGS $CPPFLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES',
- 'LINK' : '$CXX',
- 'LINKFLAGS' : '',
- 'LINKCOM' : '$LINK $LINKFLAGS -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS',
- 'SHLINK' : '$LINK',
- 'SHLINKFLAGS': '$LINKFLAGS -shared',
- 'SHLINKCOM' : '$SHLINK $SHLINKFLAGS -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS',
- 'AR' : 'ar',
- 'ARFLAGS' : 'r',
- 'RANLIB' : ranlib,
- 'RANLIBFLAGS' : '',
- 'ARCOM' : arcom,
- 'LEX' : 'lex',
- 'LEXFLAGS' : '',
- 'LEXCOM' : '$LEX $LEXFLAGS -t $SOURCES > $TARGET',
- 'YACC' : 'yacc',
- 'YACCFLAGS' : '',
- 'YACCCOM' : '$YACC $YACCFLAGS -o $TARGET $SOURCES',
- 'TEX' : 'tex',
- 'TEXFLAGS' : '',
- 'TEXCOM' : '$TEX $TEXFLAGS $SOURCES',
- 'LATEX' : 'latex',
- 'LATEXFLAGS' : '',
- 'LATEXCOM' : '$LATEX $LATEXFLAGS $SOURCES',
- 'DVIPDF' : 'dvipdf',
- 'PDFCOM' : '$DVIPDF $DVIPDFFLAGS $SOURCES $TARGET',
- 'PDFPREFIX' : '',
- 'PDFSUFFIX' : '.pdf',
- 'PDFTEX' : 'pdftex',
- 'PDFTEXFLAGS' : '',
- 'PDFTEXCOM' : '$PDFTEX $PDFTEXFLAGS $SOURCES $TARGET',
- 'PDFLATEX' : 'pdflatex',
- 'PDFLATEXFLAGS' : '',
- 'PDFLATEXCOM' : '$PDFLATEX $PDFLATEXFLAGS $SOURCES $TARGET',
- 'DVIPS' : 'dvips',
- 'PSCOM' : '$DVIPS $DVIPSFLAGS -o $TARGET $SOURCES',
- 'PSPREFIX' : '',
- 'PSSUFFIX' : '.ps',
- 'BUILDERS' : { 'Alias' : Alias,
- 'CFile' : CFile,
- 'CXXFile' : CXXFile,
- 'DVI' : DVI,
- 'Library' : StaticLibrary,
- 'StaticLibrary' : StaticLibrary,
- 'SharedLibrary' : SharedLibrary,
- 'Object' : StaticObject,
- 'StaticObject' : StaticObject,
- 'SharedObject' : SharedObject,
- 'PDF' : PDF,
- 'PostScript' : PostScript,
- 'Program' : Program },
- 'SCANNERS' : [CScan, FortranScan],
- 'LIBDIRPREFIX' : '-L',
- 'LIBDIRSUFFIX' : '',
- 'LIBLINKPREFIX' : '-l',
- 'LIBLINKSUFFIX' : '',
- 'INCPREFIX' : '-I',
- 'INCSUFFIX' : '',
+ConstructionEnvironment = {
+ 'BUILDERS' : { 'SharedLibrary' : SharedLibrary,
+ 'Library' : StaticLibrary,
+ 'StaticLibrary' : StaticLibrary,
+ 'Alias' : Alias,
+ 'Program' : Program },
+ 'SCANNERS' : [CScan, FortranScan],
+ 'PDFPREFIX' : '',
+ 'PDFSUFFIX' : '.pdf',
+ 'PSPREFIX' : '',
+ 'PSSUFFIX' : '.ps',
+ 'ENV' : {},
}
-
-elif os.name == 'nt':
- versions = None
- try:
- versions = get_devstudio_versions()
- ConstructionEnvironment = make_win32_env(versions[0]) #use highest version
- except (SCons.Util.RegError, SCons.Errors.InternalError):
- # Could not get the configured directories from the registry.
- # However, the configured directories only appear if the user
- # changes them from the default. Therefore, we'll see if
- # we can get the path to the MSDev base installation from
- # the registry and deduce the default directories.
- MVSdir = None
- if versions:
- MVSdir = get_msdev_dir(versions[0])
- if MVSdir:
- MVSVCdir = r'%s\VC98' % MVSdir
- MVSCommondir = r'%s\Common' % MVSdir
- try:
- extra_path = os.pathsep + os.environ['PATH']
- except KeyError:
- extra_path = ''
- ConstructionEnvironment = make_win32_env_from_paths(
- r'%s\atl\include;%s\mfc\include;%s\include' % (MVSVCdir, MVSVCdir, MVSVCdir),
- r'%s\mfc\lib;%s\lib' % (MVSVCdir, MVSVCdir),
- (r'%s\MSDev98\Bin;%s\Bin' % (MVSCommondir, MVSVCdir)) + extra_path)
- else:
- # The DevStudio environment variables don't exist,
- # so just use the variables from the source environment.
- MVSdir = r'C:\Program Files\Microsoft Visual Studio'
- MVSVCdir = r'%s\VC98' % MVSdir
- MVSCommondir = r'%s\Common' % MVSdir
- try:
- include_path = os.environ['INCLUDE']
- except KeyError:
- include_path = ''
- try:
- lib_path = os.environ['LIB']
- except KeyError:
- lib_path = ''
- try:
- exe_path = os.environ['PATH']
- except KeyError:
- exe_path = ''
- ConstructionEnvironment = make_win32_env_from_paths(
- include_path,
- lib_path,
- exe_path)
import SCons.Util
import SCons.Warnings
from UserDict import UserDict
+import SCons.Platform
+import SCons.Tool
def installFunc(env, target, source):
try:
Environment.
"""
- def __init__(self, platform=SCons.Platform.Platform(), **kw):
+ def __init__(self,
+ platform=SCons.Platform.Platform(),
+ tools=SCons.Platform.DefaultToolList(),
+ **kw):
self.fs = SCons.Node.FS.default_fs
self._dict = our_deepcopy(SCons.Defaults.ConstructionEnvironment)
if SCons.Util.is_String(platform):
platform = SCons.Platform.Platform(platform)
platform(self)
+ for tool in tools:
+ if SCons.Util.is_String(tool):
+ tool = SCons.Tool.Tool(tool)
+ tool(self, platform)
apply(self.Replace, (), kw)
#
for name, builder in bd.items():
setattr(self, name, BuilderWrapper(self, builder))
else:
- SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
- "The use of the BUILDERS Environment variable as a list or Builder instance is deprecated. BUILDERS should be a dictionary of name->Builder instead.")
-
- if not SCons.Util.is_List(self._dict['BUILDERS']):
- self._dict['BUILDERS'] = [self._dict['BUILDERS']]
- for b in self._dict['BUILDERS']:
- setattr(self, b.name, BuilderWrapper(self, b))
-
+ raise UserError, "The use of the BUILDERS Environment variable as a list or Builder instance is deprecated. BUILDERS should be a dictionary of name->Builder instead."
for s in self._dict['SCANNERS']:
setattr(self, s.name, s)
interp.instance(dir, fs).generate(dict, self._dict)
return dict
+ def get_builder(self, name):
+ """Fetch the builder with the specified name from the environment.
+ """
+ try:
+ return self._dict['BUILDERS'][name]
+ except KeyError:
+ return None
+
class VarInterpolator:
def __init__(self, dest, src, prefix, suffix):
self.dest = dest
from SCons.Environment import *
import SCons.Warnings
+def diff_env(env1, env2):
+ s1 = "env1 = {\n"
+ s2 = "env2 = {\n"
+ d = {}
+ for k in env1._dict.keys() + env2._dict.keys():
+ d[k] = None
+ keys = d.keys()
+ keys.sort()
+ for k in keys:
+ if env1.has_key(k):
+ if env2.has_key(k):
+ if env1[k] != env2[k]:
+ s1 = s1 + " " + repr(k) + " : " + repr(env1[k]) + "\n"
+ s2 = s2 + " " + repr(k) + " : " + repr(env2[k]) + "\n"
+ else:
+ s1 = s1 + " " + repr(k) + " : " + repr(env1[k]) + "\n"
+ elif env2.has_key(k):
+ s2 = s2 + " " + repr(k) + " : " + repr(env2[k]) + "\n"
+ s1 = s1 + "}\n"
+ s2 = s2 + "}\n"
+ return s1 + s2
built_it = {}
"""
global built_it
- b1 = Builder(name = 'builder1')
- b2 = Builder(name = 'builder2')
-
- # BUILDERS as a list or instance, now deprecated...
- built_it = {}
- env1 = Environment(BUILDERS = b1)
- env1.builder1.execute(target = 'out1')
- assert built_it['out1']
-
- built_it = {}
- env2 = Environment(BUILDERS = [b1])
- env1.builder1.execute(target = 'out1')
- assert built_it['out1']
+ b1 = Builder()
+ b2 = Builder()
built_it = {}
env3 = Environment()
- env3.Replace(BUILDERS = [b1, b2])
+ env3.Replace(BUILDERS = { 'builder1' : b1,
+ 'builder2' : b2 })
env3.builder1.execute(target = 'out1')
env3.builder2.execute(target = 'out2')
env3.builder1.execute(target = 'out3')
assert built_it['out1']
assert built_it['out2']
- # Now test deprecated warning for BUILDERS as a list
- # or instance.
-
- SCons.Warnings.enableWarningClass(SCons.Warnings.DeprecatedWarning)
- SCons.Warnings.warningAsException(1)
- try:
- try:
- env=Environment(BUILDERS=b1)
- except SCons.Warnings.DeprecatedWarning:
- pass
- else:
- assert 0
-
- try:
- env=Environment(BUILDERS=[b1, b2])
- except SCons.Warnings.DeprecatedWarning:
- pass
- else:
- assert 0
- finally:
- SCons.Warnings.suppressWarningClass(SCons.Warnings.DeprecatedWarning)
- SCons.Warnings.warningAsException(0)
-
def test_Scanners(self):
"""Test Scanner execution through different environments
"""
env1 = Environment(XXX = 'x', YYY = 'y')
env2 = Environment(XXX = 'x', YYY = 'y')
- assert env1 == env2
+ assert env1 == env2, diff_env(env1, env2)
def test_Install(self):
"""Test Install and InstallAs methods"""
env1 = Environment(AAA = 'a', BBB = 'b')
env1.Replace(BBB = 'bbb', CCC = 'ccc')
env2 = Environment(AAA = 'a', BBB = 'bbb', CCC = 'ccc')
- assert env1 == env2
+ assert env1 == env2, diff_env(env1, env2)
def test_Append(self):
"""Test appending to construction variables in an Environment
GGG = ['g', 'G'], HHH = UL(['h', 'H']),
III = UL(['i']), JJJ = UL(['j', 'J']),
KKK = UL(['k', 'K']), LLL = UL(['l', 'L']))
- assert env1 == env2, env1._dict
+ assert env1 == env2, diff_env(env1, env2)
env3 = Environment(X = {'x' : 7})
try:
env = Environment(platform = p)
assert env['XYZZY'] == 777, env
-
+ def test_tools(self):
+ """Test specifying a tool callable when instantiating."""
+ def t1(env, platform):
+ env['TOOL1'] = 111
+ def t2(env, platform):
+ env['TOOL2'] = 222
+ env = Environment(tools = [t1, t2])
+ assert env['TOOL1'] == 111, env['TOOL1']
+ assert env['TOOL2'] == 222, env
if __name__ == "__main__":
suite = unittest.makeSuite(EnvironmentTestCase, 'test_')
return 'posix'
return None
-class PlatformSpec:
- def __init__(self, name):
- self.name = name
-
- def __str__(self):
- return self.name
-
-def Platform(name = platform_default()):
- """Select a canned Platform specification.
+def platform_module(name = platform_default()):
+ """Return the imported module for the platform.
This looks for a module name that matches the specified argument.
If the name is unspecified, we fetch the appropriate default for
raise SCons.Errors.UserError, "No platform named '%s'" % name
if file:
file.close()
+ return sys.modules[full_name]
+
+def DefaultToolList(name = platform_default()):
+ """Select a default tool list for the specified platform.
+ """
+ module = platform_module(name)
+ return module.tool_list()
+
+class PlatformSpec:
+ def __init__(self, name):
+ self.name = name
+
+ def __str__(self):
+ return self.name
+
+def Platform(name = platform_default()):
+ """Select a canned Platform specification.
+ """
+ module = platform_module(name)
spec = PlatformSpec(name)
- spec.__call__ = sys.modules[full_name].generate
+ spec.__call__ = module.generate
return spec
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+def tool_list():
+ return ['ar', 'dvipdf', 'dvips', 'g++', 'g77', 'gcc', 'latex', 'lex',
+ 'pdflatex', 'pdftex', 'tex', 'yacc', 'gnulink' ]
+
def generate(env):
if not env.has_key('ENV'):
env['ENV'] = {}
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+def tool_list():
+ return ['ar', 'dvipdf', 'dvips', 'g++', 'g77', 'gcc', 'latex', 'lex',
+ 'pdflatex', 'pdftex', 'tex', 'yacc', 'gnulink' ]
+
def generate(env):
if not env.has_key('ENV'):
env['ENV'] = {}
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+def tool_list():
+ return ['dvipdf', 'latex', 'dvips', 'g77', 'lex', 'lib', 'msvc',
+ 'pdflatex', 'pdftex', 'tex', 'yacc', 'mslink' ]
+
def generate(env):
if not env.has_key('ENV'):
env['ENV'] = {}
import SCons.Node
import SCons.Node.FS
import SCons.Platform
+import SCons.Tool
import SCons.Util
import os
globals['SConscriptChdir'] = SConscriptChdir
globals['SetCommandHandler'] = SCons.Action.SetCommandHandler
globals['Split'] = SCons.Util.Split
+ globals['Tool'] = SCons.Tool.Tool
globals['WhereIs'] = SCons.Util.WhereIs
return globals
# We aren't being called out of a user frame, so
# don't try to walk the stack, just print the error.
sys.stderr.write("\nSCons error: %s\n" % e)
+ raise
except:
sys.stderr.write("scons: *** %s\n" % sys.exc_value)
raise
SCons.Sig.write()
def main():
+ global exit_status
+
try:
_main()
except SystemExit:
--- /dev/null
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import sys
+import unittest
+
+import SCons.Errors
+import SCons.Tool
+
+class ToolTestCase(unittest.TestCase):
+ def test_Tool(self):
+ """Test the Tool() function"""
+ t = SCons.Tool.Tool('g++')
+ env= { 'BUILDERS' : {}, 'ENV' : {} }
+ t(env, 'foo')
+ assert env['CXX'] == 'c++', env['CXX']
+ assert env['CXXFLAGS'] == '$CCFLAGS', env['CXXFLAGS']
+ assert env['INCPREFIX'] == '-I', env['INCPREFIX']
+
+ try:
+ SCons.Tool.Tool()
+ except TypeError:
+ pass
+ else:
+ raise
+
+ try:
+ p = SCons.Tool.Tool('_does_not_exist_')
+ except SCons.Errors.UserError:
+ pass
+ else:
+ raise
+
+
+if __name__ == "__main__":
+ suite = unittest.makeSuite(ToolTestCase, 'test_')
+ if not unittest.TextTestRunner().run(suite).wasSuccessful():
+ sys.exit(1)
--- /dev/null
+"""SCons.Tool
+
+SCons tool selection.
+
+This looks for modules that define a callable object that can modify
+a construction environment as appropriate for a given tool (or tool
+chain).
+
+Note that because this subsysem just *selects* a callable that can
+modify a construction environment, it's possible for people to define
+their own "tool specification" in an arbitrary callable function. No
+one needs to use or tie in to this subsystem in order to roll their own
+tool definition.
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import imp
+import os
+import sys
+
+import SCons.Errors
+import SCons.Defaults
+
+class ToolSpec:
+ def __init__(self, name):
+ self.name = name
+
+ def __str__(self):
+ return self.name
+
+def Tool(name, platform = None):
+ """Select a canned Tool specification.
+ """
+ full_name = 'SCons.Tool.' + name
+ if not sys.modules.has_key(full_name):
+ try:
+ file, path, desc = imp.find_module(name,
+ sys.modules['SCons.Tool'].__path__)
+ imp.load_module(full_name, file, path, desc)
+ except ImportError:
+ raise SCons.Errors.UserError, "No tool named '%s'" % name
+ if file:
+ file.close()
+ spec = ToolSpec(name)
+ spec.__call__ = sys.modules[full_name].generate
+ return spec
+
+def createObjBuilders(env):
+ """This is a utility function that creates the Object
+ and SharedObject Builders in an Environment if they
+ are not there already.
+
+ If they are there already, we return the existing ones.
+
+ This is a separate function because soooo many Tools
+ use this functionality.
+
+ The return is a 2-tuple of (StaticObject, SharedObject)
+ """
+
+ try:
+ static_obj = env['BUILDERS']['Object']
+ except KeyError:
+ static_obj = SCons.Defaults.StaticObject()
+ env['BUILDERS']['Object'] = static_obj
+ env['BUILDERS']['StaticObject'] = static_obj
+
+ try:
+ shared_obj = env['BUILDERS']['SharedObject']
+ except KeyError:
+ shared_obj = SCons.Defaults.SharedObject()
+ env['BUILDERS']['SharedObject'] = shared_obj
+
+ return (static_obj, shared_obj)
+
+def createCFileBuilders(env):
+ """This is a utility function that creates the CFile/CXXFile
+ Builders in an Environment if they
+ are not there already.
+
+ If they are there already, we return the existing ones.
+
+ This is a separate function because soooo many Tools
+ use this functionality.
+
+ The return is a 2-tuple of (CFile, CXXFile)
+ """
+
+ try:
+ c_file = env['BUILDERS']['CFile']
+ except KeyError:
+ c_file = SCons.Defaults.CFile()
+ env['BUILDERS']['CFile'] = c_file
+
+ try:
+ cxx_file = env['BUILDERS']['CXXFile']
+ except KeyError:
+ cxx_file = SCons.Defaults.CXXFile()
+ env['BUILDERS']['CXXFile'] = cxx_file
+
+ return (c_file, cxx_file)
--- /dev/null
+"""SCons.Tool.ar
+
+Tool-specific initialization for ar (library archive).
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Defaults
+import SCons.Util
+
+def generate(env, platform):
+ """Add Builders and construction variables for ar to an Environment."""
+ bld = SCons.Defaults.StaticLibrary
+ env['BUILDERS']['Library'] = bld
+ env['BUILDERS']['StaticLibrary'] = bld
+
+ arcom = '$AR $ARFLAGS $TARGET $SOURCES'
+ ranlib = 'ranlib'
+ if SCons.Util.WhereIs(ranlib):
+ arcom = arcom + '\n$RANLIB $RANLIBFLAGS $TARGET'
+
+ env['AR'] = 'ar'
+ env['ARFLAGS'] = 'r'
+ env['RANLIB'] = ranlib
+ env['RANLIBFLAGS'] = ''
+ env['ARCOM'] = arcom
+ env['SHLINK'] = '$LINK'
+ env['SHLINKFLAGS'] = '$LINKFLAGS -shared'
+ env['SHLINKCOM'] = '$SHLINK $SHLINKFLAGS -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
+
+
--- /dev/null
+"""SCons.Tool.dvipdf
+
+Tool-specific initialization for dvipdf.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Defaults
+
+def generate(env, platform):
+ """Add Builders and construction variables for dvipdf to an Environment."""
+ try:
+ bld = env['BUILDERS']['PDF']
+ except KeyError:
+ bld = SCons.Defaults.PDF()
+ env['BUILDERS']['PDF'] = bld
+ bld.add_action('.dvi', '$PDFCOM')
+
+ env['DVIPDF'] = 'dvipdf'
+ env['DVIPDFFLAGS'] = ''
+ env['PDFCOM'] = '$DVIPDF $DVIPDFFLAGS $SOURCES $TARGET'
--- /dev/null
+"""SCons.Tool.dvips
+
+Tool-specific initialization for dvips.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Action
+import SCons.Defaults
+
+PostScript = SCons.Builder.Builder(action = '$PSCOM',
+ prefix = '$PSPREFIX',
+ suffix = '$PSSUFFIX',
+ src_suffix = '.dvi',
+ src_builder = 'DVI')
+
+def generate(env, platform):
+ """Add Builders and construction variables for dvips to an Environment."""
+ env['BUILDERS']['PostScript'] = PostScript
+
+ env['DVIPS'] = 'dvips'
+ env['DVIPSFLAGS'] = ''
+ env['PSCOM'] = '$DVIPS $DVIPSFLAGS -o $TARGET $SOURCES'
--- /dev/null
+"""SCons.Tool.g++
+
+Tool-specific initialization for g++.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import os.path
+
+import SCons.Defaults
+import SCons.Tool
+
+CXXSuffixes = ['.cc', '.cpp', '.cxx', '.c++', '.C++']
+if os.path.normcase('.c') != os.path.normcase('.C'):
+ CXXSuffixes.append('.C')
+
+def generate(env, platform):
+ """Add Builders and construction variables for g++ to an Environment."""
+ static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
+
+ for suffix in CXXSuffixes:
+ static_obj.add_action(suffix, SCons.Defaults.CXXAction)
+ shared_obj.add_action(suffix, SCons.Defaults.ShCXXAction)
+
+ env['CXX'] = 'c++'
+ env['CXXFLAGS'] = '$CCFLAGS'
+ env['CXXCOM'] = '$CXX $CXXFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
+ env['SHCXX'] = '$CXX'
+ env['SHCXXFLAGS'] = '$CXXFLAGS -fPIC'
+ env['SHCXXCOM'] = '$SHCXX $SHCXXFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
+ env['INCPREFIX'] = '-I'
+ env['INCSUFFIX'] = ''
+
+ env['CXXFILESUFFIX'] = '.cc'
--- /dev/null
+"""engine.SCons.Tool.g77
+
+Tool-specific initialization for g77.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import os.path
+
+import SCons.Defaults
+import SCons.Tool
+
+F77Suffixes = ['.f', '.for', '.FOR']
+F77PPSuffixes = ['.fpp', '.FPP']
+if os.path.normcase('.f') == os.path.normcase('.F'):
+ F77Suffixes.append('.F')
+else:
+ F77PPSuffixes.append('.F')
+
+def generate(env, platform):
+ """Add Builders and construction variables for g77 to an Environment."""
+ static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
+
+ for suffix in F77Suffixes:
+ static_obj.add_action(suffix, SCons.Defaults.F77Action)
+ shared_obj.add_action(suffix, SCons.Defaults.ShF77Action)
+
+ for suffix in F77PPSuffixes:
+ static_obj.add_action(suffix, SCons.Defaults.F77PPAction)
+ shared_obj.add_action(suffix, SCons.Defaults.ShF77PPAction)
+
+ env['F77'] = 'g77'
+ env['F77FLAGS'] = ''
+ env['F77COM'] = '$F77 $F77FLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES'
+ env['F77PPCOM'] = '$F77 $F77FLAGS $CPPFLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES'
+ env['SHF77'] = '$F77'
+ env['SHF77FLAGS'] = '$F77FLAGS -fPIC'
+ env['SHF77COM'] = '$SHF77 $SHF77FLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES'
+ env['SHF77PPCOM'] = '$SHF77 $SHF77FLAGS $CPPFLAGS $_F77INCFLAGS -c -o $TARGET $SOURCES'
--- /dev/null
+"""SCons.Tool.gcc
+
+Tool-specific initialization for gcc.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import os.path
+
+import SCons.Tool
+import SCons.Defaults
+
+CSuffixes = ['.c']
+if os.path.normcase('.c') == os.path.normcase('.C'):
+ CSuffixes.append('.C')
+
+def generate(env, platform):
+ """Add Builders and construction variables for gcc to an Environment."""
+ static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
+
+ for suffix in CSuffixes:
+ static_obj.add_action(suffix, SCons.Defaults.CAction)
+ shared_obj.add_action(suffix, SCons.Defaults.ShCAction)
+
+ env['CC'] = 'gcc'
+ env['CCFLAGS'] = ''
+ env['CCCOM'] = '$CC $CCFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
+ env['SHCC'] = '$CC'
+ env['SHCCFLAGS'] = '$CCFLAGS -fPIC'
+ env['SHCCCOM'] = '$SHCC $SHCCFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
+
+ env['INCPREFIX'] = '-I'
+ env['INCSUFFIX'] = ''
+
+ env['CFILESUFFIX'] = '.c'
--- /dev/null
+"""SCons.Tool.gnulink
+
+Tool-specific initialization for the gnu linker.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Defaults
+import SCons.Util
+
+def generate(env, platform):
+ """Add Builders and construction variables for ar to an Environment."""
+ env['BUILDERS']['SharedLibrary'] = SCons.Defaults.SharedLibrary
+ env['BUILDERS']['Program'] = SCons.Defaults.Program
+
+ env['SHLINK'] = '$LINK'
+ env['SHLINKFLAGS'] = '$LINKFLAGS -shared'
+ env['SHLINKCOM'] = '$SHLINK $SHLINKFLAGS -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
+ env['SHLIBEMITTER']= None
+ env['LINK'] = 'c++'
+ env['LINKFLAGS'] = ''
+ env['LINKCOM'] = '$LINK $LINKFLAGS -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
+ env['LIBDIRPREFIX']='-L'
+ env['LIBDIRSUFFIX']=''
+ env['LIBLINKPREFIX']='-l'
+ env['LIBLINKSUFFIX']=''
--- /dev/null
+"""SCons.Tool.latex
+
+Tool-specific initialization for LaTeX.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Action
+import SCons.Defaults
+
+LaTeXAction = SCons.Action.Action('$LATEXCOM')
+
+def generate(env, platform):
+ """Add Builders and construction variables for LaTeX to an Environment."""
+
+ try:
+ bld = env['BUILDERS']['DVI']
+ except KeyError:
+ bld = SCons.Defaults.DVI()
+ env['BUILDERS']['DVI'] = bld
+
+ bld.add_action('.ltx', LaTeXAction)
+ bld.add_action('.latex', LaTeXAction)
+
+ env['LATEX'] = 'latex'
+ env['LATEXFLAGS'] = ''
+ env['LATEXCOM'] = '$LATEX $LATEXFLAGS $SOURCES'
--- /dev/null
+"""SCons.Tool.lex
+
+Tool-specific initialization for lex.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Defaults
+import SCons.Tool
+
+def generate(env, platform):
+ """Add Builders and construction variables for lex to an Environment."""
+ c_file, cxx_file = SCons.Tool.createCFileBuilders(env)
+
+ c_file.add_action('.l', '$LEXCOM')
+ cxx_file.add_action('.ll', '$LEXCOM')
+
+ env['LEX'] = 'lex'
+ env['LEXFLAGS'] = ''
+ env['LEXCOM'] = '$LEX $LEXFLAGS -t $SOURCES > $TARGET'
--- /dev/null
+"""SCons.Tool.lib
+
+Tool-specific initialization for lib (MicroSoft library archiver).
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Defaults
+
+def generate(env, platform):
+ """Add Builders and construction variables for lib to an Environment."""
+ env['BUILDERS']['Library'] = SCons.Defaults.StaticLibrary
+ env['BUILDERS']['StaticLibrary'] = SCons.Defaults.StaticLibrary
+
+ env['AR'] = 'lib'
+ env['ARFLAGS'] = '/nologo'
+ env['ARCOM'] = '$AR $ARFLAGS /OUT:$TARGET $SOURCES'
+
--- /dev/null
+"""SCons.Tool.mslink
+
+Tool-specific initialization for the Microsoft linker.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import os.path
+
+import SCons.Defaults
+import SCons.Errors
+import SCons.Action
+
+from SCons.Tool.msvc import get_msdev_paths
+
+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]
+ if for_signature or \
+ (reduce(lambda x, y: x + len(y), cmd, 0) + len(cmd)) <= 2048:
+ return [cmd_list]
+ else:
+ import tempfile
+ # We do a normpath because mktemp() has what appears to be
+ # a bug in Win32 that will use a forward slash as a path
+ # delimiter. Win32's link mistakes that for a command line
+ # switch and barfs.
+ tmp = os.path.normpath(tempfile.mktemp())
+ args = map(SCons.Util.quote_spaces, cmd[1:])
+ open(tmp, 'w').write(string.join(args, " ") + "\n")
+ return [ [cmd[0], '@' + tmp],
+ ['del', tmp] ]
+
+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, for_signature)
+
+def win32LibGenerator(target, source, env, for_signature, no_import_lib=0):
+ listCmd = [ "$SHLINK", "$SHLINKFLAGS" ]
+
+ for tgt in target:
+ ext = os.path.splitext(str(tgt))[1]
+ if ext == env.subst("$LIBSUFFIX"):
+ # Put it on the command line as an import library.
+ if no_import_lib:
+ raise SCons.Errors.UserError, "%s: You cannot specify a .lib file as a target of a shared library build if no_import_library is nonzero." % tgt
+ listCmd.append("${WIN32IMPLIBPREFIX}%s" % tgt)
+ else:
+ listCmd.append("${WIN32DLLPREFIX}%s" % tgt)
+
+ listCmd.extend([ '$_LIBDIRFLAGS', '$_LIBFLAGS' ])
+ for src in source:
+ ext = os.path.splitext(str(src))[1]
+ if ext == env.subst("$WIN32DEFSUFFIX"):
+ # Treat this source as a .def file.
+ listCmd.append("${WIN32DEFPREFIX}%s" % src)
+ else:
+ # Just treat it as a generic source file.
+ listCmd.append(str(src))
+ return win32TempFileMunge(env, listCmd, for_signature)
+
+def win32LibEmitter(target, source, env, no_import_lib=0):
+ dll = None
+ for tgt in target:
+ ext = os.path.splitext(str(tgt))[1]
+ if ext == env.subst("$SHLIBSUFFIX"):
+ dll = tgt
+ break
+ if not dll:
+ raise SCons.Errors.UserError, "A shared library should have exactly one target with the suffix: %s" % env.subst("$SHLIBSUFFIX")
+
+ if env.has_key("WIN32_INSERT_DEF") and \
+ env["WIN32_INSERT_DEF"] and \
+ not '.def' in map(lambda x: os.path.split(str(x))[1],
+ source):
+
+ # append a def file to the list of sources
+ source.append("%s%s" % (os.path.splitext(str(dll))[0],
+ env.subst("$WIN32DEFSUFFIX")))
+ if not no_import_lib and \
+ not env.subst("$LIBSUFFIX") in \
+ map(lambda x: os.path.split(str(x))[1], target):
+ # Append an import library to the list of targets.
+ target.append("%s%s%s" % (env.subst("$LIBPREFIX"),
+ os.path.splitext(str(dll))[0],
+ env.subst("$LIBSUFFIX")))
+ return (target, source)
+
+ShLibAction = SCons.Action.CommandGenerator(win32LibGenerator)
+LinkAction = SCons.Action.CommandGenerator(win32LinkGenerator)
+
+def generate(env, platform):
+ """Add Builders and construction variables for ar to an Environment."""
+ env['BUILDERS']['SharedLibrary'] = SCons.Defaults.SharedLibrary
+ env['BUILDERS']['Program'] = SCons.Defaults.Program
+
+ env['SHLINK'] = '$LINK'
+ env['SHLINKFLAGS'] = '$LINKFLAGS /dll'
+ env['SHLINKCOM'] = ShLibAction
+ env['SHLIBEMITTER']= win32LibEmitter
+ env['LINK'] = 'link'
+ env['LINKFLAGS'] = '/nologo'
+ env['LINKCOM'] = LinkAction
+ env['LIBDIRPREFIX']='/LIBPATH:'
+ env['LIBDIRSUFFIX']=''
+ env['LIBLINKPREFIX']=''
+ env['LIBLINKSUFFIX']='$LIBSUFFIX'
+
+ env['WIN32DEFPREFIX'] = '/def:'
+ env['WIN32DEFSUFFIX'] = '.def'
+ env['WIN32DLLPREFIX'] = '/out:'
+ env['WIN32IMPLIBPREFIX'] = '/implib:'
+ env['WIN32_INSERT_DEF'] = 0
+
+ include_path, lib_path, exe_path = get_msdev_paths()
+ env['ENV']['LIB'] = lib_path
+ env['ENV']['PATH'] = exe_path
--- /dev/null
+"""engine.SCons.Tool.msvc
+
+Tool-specific initialization for Microsoft Visual C/C++.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import os.path
+import string
+
+import SCons.Action
+import SCons.Tool
+import SCons.Errors
+
+CSuffixes = ['.c', '.C']
+CXXSuffixes = ['.cc', '.cpp', '.cxx', '.c++', '.C++']
+
+def get_devstudio_versions():
+ """
+ Get list of devstudio versions from the Windows registry. Return a
+ list of strings containing version numbers; an exception will be raised
+ if we were unable to access the registry (eg. couldn't import
+ a registry-access module) or the appropriate registry keys weren't
+ found.
+ """
+
+ if not SCons.Util.can_read_reg:
+ raise SCons.Errors.InternalError, "No Windows registry module was found"
+
+ K = 'Software\\Microsoft\\Devstudio'
+ L = []
+ for base in (SCons.Util.HKEY_CLASSES_ROOT,
+ SCons.Util.HKEY_LOCAL_MACHINE,
+ SCons.Util.HKEY_CURRENT_USER,
+ SCons.Util.HKEY_USERS):
+ try:
+ k = SCons.Util.RegOpenKeyEx(base,K)
+ i = 0
+ while 1:
+ try:
+ p = SCons.Util.RegEnumKey(k,i)
+ if p[0] in '123456789' and p not in L:
+ L.append(p)
+ except SCons.Util.RegError:
+ break
+ i = i + 1
+ except SCons.Util.RegError:
+ pass
+
+ if not L:
+ raise SCons.Errors.InternalError, "DevStudio was not found."
+
+ L.sort()
+ L.reverse()
+ return L
+
+def get_msvc_path (path, version, platform='x86'):
+ """
+ Get a list of devstudio directories (include, lib or path). Return
+ a string delimited by ';'. An exception will be raised if unable to
+ access the registry or appropriate registry keys not found.
+ """
+
+ if not SCons.Util.can_read_reg:
+ raise SCons.Errors.InternalError, "No Windows registry module was found"
+
+ if path=='lib':
+ path= 'Library'
+ path = string.upper(path + ' Dirs')
+ K = ('Software\\Microsoft\\Devstudio\\%s\\' +
+ 'Build System\\Components\\Platforms\\Win32 (%s)\\Directories') % \
+ (version,platform)
+ for base in (SCons.Util.HKEY_CLASSES_ROOT,
+ SCons.Util.HKEY_LOCAL_MACHINE,
+ SCons.Util.HKEY_CURRENT_USER,
+ SCons.Util.HKEY_USERS):
+ try:
+ k = SCons.Util.RegOpenKeyEx(base,K)
+ i = 0
+ while 1:
+ try:
+ (p,v,t) = SCons.Util.RegEnumValue(k,i)
+ if string.upper(p) == path:
+ return v
+ i = i + 1
+ except SCons.Util.RegError:
+ break
+ except SCons.Util.RegError:
+ pass
+
+ # if we got here, then we didn't find the registry entries:
+ raise SCons.Errors.InternalError, "%s was not found in the registry."%path
+
+def get_msdev_dir(version):
+ """Returns the root directory of the MSDev installation from the
+ registry if it can be found, otherwise we guess."""
+ if SCons.Util.can_read_reg:
+ K = ('Software\\Microsoft\\Devstudio\\%s\\' +
+ 'Products\\Microsoft Visual C++') % \
+ version
+ for base in (SCons.Util.HKEY_LOCAL_MACHINE,
+ SCons.Util.HKEY_CURRENT_USER):
+ try:
+ k = SCons.Util.RegOpenKeyEx(base,K)
+ val, tok = SCons.Util.RegQueryValueEx(k, 'ProductDir')
+ return os.path.split(val)[0]
+ except SCons.Util.RegError:
+ pass
+
+def get_msdev_paths(version=None):
+ """Return a 3-tuple of (INCLUDE, LIB, PATH) as the values
+ of those three environment variables that should be set
+ in order to execute the MSVC tools properly."""
+ exe_path = ''
+ lib_path = ''
+ include_path = ''
+ try:
+ if not version:
+ version = get_devstudio_versions()[0] #use highest version
+ include_path = get_msvc_path("include", version)
+ lib_path = get_msvc_path("lib", version)
+ exe_path = get_msvc_path("path", version) + ";" + os.environ['PATH']
+ except (SCons.Util.RegError, SCons.Errors.InternalError):
+ # Could not get the configured directories from the registry.
+ # However, the configured directories only appear if the user
+ # changes them from the default. Therefore, we'll see if
+ # we can get the path to the MSDev base installation from
+ # the registry and deduce the default directories.
+ MVSdir = None
+ if version:
+ MVSdir = get_msdev_dir(version)
+ if MVSdir:
+ MVSVCdir = r'%s\VC98' % MVSdir
+ MVSCommondir = r'%s\Common' % MVSdir
+ include_path = r'%s\atl\include;%s\mfc\include;%s\include' % (MVSVCdir, MVSVCdir, MVSVCdir)
+ lib_path = r'%s\mfc\lib;%s\lib' % (MVSVCdir, MVSVCdir)
+ try:
+ extra_path = os.pathsep + os.environ['PATH']
+ except KeyError:
+ extra_path = ''
+ exe_path = (r'%s\MSDev98\Bin;%s\Bin' % (MVSCommondir, MVSVCdir)) + extra_path
+ else:
+ # The DevStudio environment variables don't exist,
+ # so just use the variables from the source environment.
+ MVSdir = r'C:\Program Files\Microsoft Visual Studio'
+ MVSVCdir = r'%s\VC98' % MVSdir
+ MVSCommondir = r'%s\Common' % MVSdir
+ try:
+ include_path = os.environ['INCLUDE']
+ except KeyError:
+ include_path = ''
+ try:
+ lib_path = os.environ['LIB']
+ except KeyError:
+ lib_path = ''
+ try:
+ exe_path = os.environ['PATH']
+ except KeyError:
+ exe_path = ''
+ return (include_path, lib_path, exe_path)
+
+def generate(env, platform):
+ """Add Builders and construction variables for MSVC++ to an Environment."""
+ static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
+
+ for suffix in CSuffixes:
+ static_obj.add_action(suffix, SCons.Defaults.CAction)
+ shared_obj.add_action(suffix, SCons.Defaults.ShCAction)
+
+ for suffix in CXXSuffixes:
+ static_obj.add_action(suffix, SCons.Defaults.CXXAction)
+ shared_obj.add_action(suffix, SCons.Defaults.ShCXXAction)
+
+ env['CC'] = 'cl'
+ env['CCFLAGS'] = '/nologo'
+ env['CCCOM'] = '$CC $CCFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET'
+ env['SHCC'] = '$CC'
+ env['SHCCFLAGS'] = '$CCFLAGS'
+ env['SHCCCOM'] = '$SHCC $SHCCFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET'
+ env['CXX'] = '$CC'
+ env['CXXFLAGS'] = '$CCFLAGS'
+ env['CXXCOM'] = '$CXX $CXXFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET'
+ env['SHCXX'] = '$CXX'
+ env['SHCXXFLAGS'] = '$CXXFLAGS'
+ env['SHCXXCOM'] = '$SHCXX $SHCXXFLAGS $CPPFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET'
+ env['INCPREFIX'] = '/I'
+ env['INCSUFFIX'] = ''
+
+ include_path, lib_path, exe_path = get_msdev_paths()
+ env['ENV']['INCLUDE'] = include_path
+ env['ENV']['PATH'] = exe_path
+
+ env['CFILESUFFIX'] = '.c'
+ env['CXXFILESUFFIX'] = '.cc'
+
--- /dev/null
+"""SCons.Tool.pdflatex
+
+Tool-specific initialization for pdflatex.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Action
+import SCons.Defaults
+
+PDFLaTeXAction = SCons.Action.Action('$PDFLATEXCOM')
+
+def generate(env, platform):
+ """Add Builders and construction variables for pdflatex to an Environment."""
+ try:
+ bld = env['BUILDERS']['PDF']
+ except KeyError:
+ bld = SCons.Defaults.PDF()
+ env['BUILDERS']['PDF'] = bld
+
+ bld.add_action('.ltx', PDFLaTeXAction)
+ bld.add_action('.latex', PDFLaTeXAction)
+
+ env['PDFLATEX'] = 'pdflatex'
+ env['PDFLATEXFLAGS'] = ''
+ env['PDFLATEXCOM'] = '$PDFLATEX $PDFLATEXFLAGS $SOURCES $TARGET'
--- /dev/null
+"""SCons.Tool.pdftex
+
+Tool-specific initialization for pdftex.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Defaults
+
+def generate(env, platform):
+ """Add Builders and construction variables for pdftex to an Environment."""
+ try:
+ bld = env['BUILDERS']['PDF']
+ except KeyError:
+ bld = SCons.Defaults.PDF()
+ env['BUILDERS']['PDF'] = bld
+
+ bld.add_action('.tex', '$PDFTEXCOM')
+
+ env['PDFTEX'] = 'pdftex'
+ env['PDFTEXFLAGS'] = ''
+ env['PDFTEXCOM'] = '$PDFTEX $PDFTEXFLAGS $SOURCES $TARGET'
--- /dev/null
+"""SCons.Tool.tex
+
+Tool-specific initialization for TeX.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Defaults
+
+def generate(env, platform):
+ """Add Builders and construction variables for TeX to an Environment."""
+ try:
+ bld = env['BUILDERS']['DVI']
+ except KeyError:
+ bld = SCons.Defaults.DVI()
+ env['BUILDERS']['DVI'] = bld
+
+ bld.add_action('.tex', '$TEXCOM')
+
+ env['TEX'] = 'tex'
+ env['TEXFLAGS'] = ''
+ env['TEXCOM'] = '$TEX $TEXFLAGS $SOURCES'
--- /dev/null
+"""SCons.Tool.yacc
+
+Tool-specific initialization for yacc.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+"""
+
+#
+# Copyright (c) 2001, 2002 Steven Knight
+#
+# 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__"
+
+import SCons.Tool
+
+def generate(env, platform):
+ """Add Builders and construction variables for yacc to an Environment."""
+ c_file, cxx_file = SCons.Tool.createCFileBuilders(env)
+
+ c_file.add_action('.y', '$YACCCOM')
+ cxx_file.add_action('.yy', '$YACCCOM')
+
+ env['YACC'] = 'yacc'
+ env['YACCFLAGS'] = ''
+ env['YACCCOM'] = '$YACC $YACCFLAGS -o $TARGET $SOURCES'
def is_String(e):
return type(e) is types.StringType or isinstance(e, UserString)
+class Proxy:
+ """A simple generic Proxy class, forwarding all calls to
+ subject. Inherit from this class to create a Proxy."""
+ def __init__(self, subject):
+ self.__subject = subject
+
+ def __getattr__(self, name):
+ return getattr(self.__subject, name)
+
# attempt to load the windows registry module:
can_read_reg = 0
try:
assert get_environment_var("$BAR ") == None, get_environment_var("$BAR ")
assert get_environment_var("FOO$BAR") == None, get_environment_var("FOO$BAR")
+ def test_Proxy(self):
+ """Test generic Proxy class."""
+ class Subject:
+ def foo(self):
+ return 1
+ def bar(self):
+ return 2
+
+ s=Subject()
+ s.baz = 3
+
+ class ProxyTest(Proxy):
+ def bar(self):
+ return 4
+
+ p=ProxyTest(s)
+
+ assert p.foo() == 1, p.foo()
+ assert p.bar() == 4, p.bar()
+ assert p.baz == 3, p.baz
+
+ p.baz = 5
+ s.baz = 6
+
+ assert p.baz == 5, p.baz
+
if __name__ == "__main__":
suite = unittest.makeSuite(UtilTestCase, 'test_')
if not unittest.TextTestRunner().run(suite).wasSuccessful():
"SCons.Node",
"SCons.Platform",
"SCons.Scanner",
+ "SCons.Script",
"SCons.Sig",
- "SCons.Script"],
+ "SCons.Tool"],
'package_dir' : {'' : 'engine'},
'scripts' : ["script/scons"],
'cmdclass' : {'install_lib' : my_install_lib}
test.write('SConstructFoo2', """
env=Environment()
-obj = env.SharedObject('foo', 'foo.c')
+obj = env.SharedObject('bar', 'foo.c')
Default(env.Library(target = 'foo', source = obj))
""")
)
test.run(arguments = '-f SConstructFoo2', status=2, stderr='''
-SCons error: Source file: foo\..* is shared and is not compatible with static target: .*
+SCons error: Source file: bar\..* is shared and is not compatible with static target: .*
'''
)
projects / scons.git / commitdiff