From: stevenknight Date: Thu, 18 Dec 2003 05:30:09 +0000 (+0000) Subject: Add support for a toolpath for Environments. X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=ed2e9a3a69670abb714b50503dfdf8f62de33743;p=scons.git Add support for a toolpath for Environments. git-svn-id: http://scons.tigris.org/svn/scons/trunk@863 fdb21ef1-2011-0410-befe-b5e4ea1792b1 --- diff --git a/doc/man/scons.1 b/doc/man/scons.1 index 4dcf3b9e..7014cf3c 100644 --- a/doc/man/scons.1 +++ b/doc/man/scons.1 @@ -873,6 +873,19 @@ may specified as an optional keyword argument: env = Environment(tools = ['msvc', 'lex']) .EE +Non-built-in tools may be specified using the toolpath argument: + +.ES +env = Environment(tools = ['foo'], toolpath = ['tools']) +.EE + +This looks for a tool specification in tools/foo.py. foo.py should +have two functions: generate(env) and exists(env). generate() +modifies the passed in environment and exists() should return a true +value if the tool is available. Tools in the toolpath are used before +any of the built-in ones. For example, adding gcc.py to the toolpath +would override the built-in gcc tool. + The elements of the tools list may also be functions or callable objects, in which case the Environment() method @@ -2293,8 +2306,8 @@ env2 = env.Copy() env3 = env.Copy(CCFLAGS = '-g') .EE .IP -Additionally, a list of tools may be specified, as in the Environment -constructor: +Additionally, a list of tools and a toolpath may be specified, as in +the Environment constructor: .ES def MyTool(env): env['FOO'] = 'bar' @@ -3498,7 +3511,7 @@ The default is "build". '\""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" .TP -.RI Tool( string ) +.RI Tool( string, toolpath=[] ) Returns a callable object that can be used to initialize a construction environment using the @@ -3518,15 +3531,18 @@ env = Environment(tools = [ Tool('msvc') ]) env = Environment() t = Tool('msvc') t(env) # adds 'msvc' to the TOOLS variable +u = Tool('opengl', toolpath = ['tools']) +u(env) # adds 'opengl' to the TOOLS variable .EE .TP -.RI env.Tool( string ) +.RI env.Tool( string [, toolpath] ) Applies the callable object for the specified tool .I string to the environment through which the method was called. .ES env.Tool('gcc') +env.Tool('opengl', toolpath = ['build/tools']) .EE '\""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" diff --git a/src/CHANGES.txt b/src/CHANGES.txt index 1043b500..2b598aed 100644 --- a/src/CHANGES.txt +++ b/src/CHANGES.txt @@ -25,6 +25,9 @@ RELEASE 0.95 - XXX - Fix a problem with the msvc tool with Python versions prior to 2.3. + - Add support for a "toolpath" Tool() and Environment keyword that + allows Tool modules to be found in specified local directories. + From Chris Burghart: - Fix the ability to save/restore a PackageOption to a file. diff --git a/src/engine/SCons/Environment.py b/src/engine/SCons/Environment.py index 26be4833..6afa69f4 100644 --- a/src/engine/SCons/Environment.py +++ b/src/engine/SCons/Environment.py @@ -109,12 +109,13 @@ def our_deepcopy(x): copy = x return copy -def apply_tools(env, tools): +def apply_tools(env, tools, toolpath): if tools: for tool in tools: if SCons.Util.is_String(tool): - tool = SCons.Tool.Tool(tool) - tool(env) + env.Tool(tool, toolpath) + else: + tool(env) class BuilderWrapper: """Wrapper class that associates an environment with a Builder at @@ -207,6 +208,7 @@ class Base: def __init__(self, platform=None, tools=None, + toolpath=[], options=None, **kw): self.fs = SCons.Node.FS.default_fs @@ -238,7 +240,7 @@ class Base: tools = self._dict.get('TOOLS', None) if tools is None: tools = ['default'] - apply_tools(self, tools) + apply_tools(self, tools, toolpath) # Reapply the passed in variables after calling the tools, # since they should overide anything set by the tools: @@ -461,7 +463,7 @@ class Base: self._dict[envname][name] = nv - def Copy(self, tools=None, **kw): + def Copy(self, tools=None, toolpath=[], **kw): """Return a copy of a construction Environment. The copy is like a Python "deep copy"--that is, independent copies are made recursively of each objects--except that @@ -477,7 +479,7 @@ class Base: except KeyError: pass - apply_tools(clone, tools) + apply_tools(clone, tools, toolpath) # Apply passed-in variables after the new tools. apply(clone.Replace, (), kw) @@ -666,9 +668,9 @@ class Base: name = name[:-len(old_suffix)] return os.path.join(dir, new_prefix+name+new_suffix) - def Tool(self, tool): + def Tool(self, tool, toolpath=[]): tool = self.subst(tool) - return SCons.Tool.Tool(tool)(self) + return SCons.Tool.Tool(tool, map(self.subst, toolpath))(self) def WhereIs(self, prog, path=None, pathext=None): """Find prog in the path. diff --git a/src/engine/SCons/EnvironmentTests.py b/src/engine/SCons/EnvironmentTests.py index e6fd5c96..5fee3dd2 100644 --- a/src/engine/SCons/EnvironmentTests.py +++ b/src/engine/SCons/EnvironmentTests.py @@ -1162,7 +1162,9 @@ class EnvironmentTestCase(unittest.TestCase): exc_caught = 1 assert exc_caught, "did not catch expected UserError" - env.Tool('cc') + # Use a non-existent toolpath directory just to make sure we + # can call Tool() with the keyword argument. + env.Tool('cc', toolpath=['/no/such/directory']) assert env['CC'] == 'cc', env['CC'] env.Tool('$LINK') diff --git a/src/engine/SCons/Tool/__init__.py b/src/engine/SCons/Tool/__init__.py index a58ac6d0..34e9e0d8 100644 --- a/src/engine/SCons/Tool/__init__.py +++ b/src/engine/SCons/Tool/__init__.py @@ -55,9 +55,23 @@ class ToolSpec: def __str__(self): return self.name -def Tool(name): - """Select a canned Tool specification. - """ +def Tool(name, toolpath=[]): + "Select a canned Tool specification, optionally searching in toolpath." + + try: + file, path, desc = imp.find_module(name, toolpath) + try: + module = imp.load_module(name, file, path, desc) + spec = ToolSpec(name) + spec.generate = module.generate + spec.exists = module.exists + return spec + finally: + if file: + file.close() + except ImportError, e: + pass + full_name = 'SCons.Tool.' + name if not sys.modules.has_key(full_name): try: diff --git a/test/toolpath.py b/test/toolpath.py new file mode 100644 index 00000000..da9f585a --- /dev/null +++ b/test/toolpath.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python +# +# __COPYRIGHT__ +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# + +__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +import os.path +import sys +import time +import TestSCons + +test = TestSCons.TestSCons() + +test.write('SConstruct', """ +def foo(env): + env['TOOL_FOO'] = 1 + +env1 = Environment(tools=[foo, 'bar'], toolpath=['tools']) +print "env1['TOOL_FOO'] =", env1.get('TOOL_FOO') +print "env1['TOOL_BAR'] =", env1.get('TOOL_BAR') + +# pick a built-in tool with pretty simple behavior +env2 = Environment(tools=['SCCS']) +print "env2['SCCS'] =", env2.get('SCCS') +print "env2['TOOL_SCCS1'] =", env2.get('TOOL_SCCS1') +print "env2['TOOL_SCCS2'] =", env2.get('TOOL_SCCS2') + +env3 = Environment(tools=['SCCS'], toolpath=['.']) +print "env3['SCCS'] =", env3.get('SCCS') +print "env3['TOOL_SCCS1'] =", env3.get('TOOL_SCCS1') +print "env3['TOOL_SCCS2'] =", env3.get('TOOL_SCCS2') + +env4 = Environment(tools=['SCCS'], toolpath=['tools']) +print "env4['SCCS'] =", env4.get('SCCS') +print "env4['TOOL_SCCS1'] =", env4.get('TOOL_SCCS1') +print "env4['TOOL_SCCS2'] =", env4.get('TOOL_SCCS2') + +env5 = Environment(tools=['SCCS'], toolpath=['tools', '.']) +print "env5['SCCS'] =", env5.get('SCCS') +print "env5['TOOL_SCCS1'] =", env5.get('TOOL_SCCS1') +print "env5['TOOL_SCCS2'] =", env5.get('TOOL_SCCS2') + +env6 = Environment(tools=['SCCS'], toolpath=['.', 'tools']) +print "env6['SCCS'] =", env6.get('SCCS') +print "env6['TOOL_SCCS1'] =", env6.get('TOOL_SCCS1') +print "env6['TOOL_SCCS2'] =", env6.get('TOOL_SCCS2') + +env7 = Environment(TOOLPATH="tools", tools=['SCCS'], toolpath=['$TOOLPATH']) +print "env7['SCCS'] =", env7.get('SCCS') +print "env7['TOOL_SCCS1'] =", env7.get('TOOL_SCCS1') +print "env7['TOOL_SCCS2'] =", env7.get('TOOL_SCCS2') + +env8 = Environment(tools=[]) +env8.Tool('SCCS', toolpath=['tools']) +print "env8['SCCS'] =", env8.get('SCCS') +print "env8['TOOL_SCCS1'] =", env8.get('TOOL_SCCS1') +print "env8['TOOL_SCCS2'] =", env8.get('TOOL_SCCS2') + +env9 = Environment(tools=[]) +Tool('SCCS', toolpath=['tools'])(env9) +print "env9['SCCS'] =", env9.get('SCCS') +print "env9['TOOL_SCCS1'] =", env9.get('TOOL_SCCS1') +print "env9['TOOL_SCCS2'] =", env9.get('TOOL_SCCS2') + +env0 = Environment(TOOLPATH='tools', tools=[]) +env0.Tool('SCCS', toolpath=['$TOOLPATH']) +print "env0['SCCS'] =", env0.get('SCCS') +print "env0['TOOL_SCCS1'] =", env0.get('TOOL_SCCS1') +print "env0['TOOL_SCCS2'] =", env0.get('TOOL_SCCS2') +""") + +test.write('SCCS.py', r"""\ +def generate(env): + env['TOOL_SCCS1'] = 1 +def exists(env): + return 1 +""") + +test.subdir('tools') + +test.write(['tools', 'SCCS.py'], r"""\ +def generate(env): + env['TOOL_SCCS2'] = 1 +def exists(env): + return 1 +""") + +test.write(['tools', 'bar.py'], r"""\ +def generate(env): + env['TOOL_BAR'] = 1 +def exists(env): + return 1 +""") + +test.run(arguments = '.', stdout = """\ +scons: Reading SConscript files ... +env1['TOOL_FOO'] = 1 +env1['TOOL_BAR'] = 1 +env2['SCCS'] = sccs +env2['TOOL_SCCS1'] = None +env2['TOOL_SCCS2'] = None +env3['SCCS'] = None +env3['TOOL_SCCS1'] = 1 +env3['TOOL_SCCS2'] = None +env4['SCCS'] = None +env4['TOOL_SCCS1'] = None +env4['TOOL_SCCS2'] = 1 +env5['SCCS'] = None +env5['TOOL_SCCS1'] = None +env5['TOOL_SCCS2'] = 1 +env6['SCCS'] = None +env6['TOOL_SCCS1'] = 1 +env6['TOOL_SCCS2'] = None +env7['SCCS'] = None +env7['TOOL_SCCS1'] = None +env7['TOOL_SCCS2'] = 1 +env8['SCCS'] = None +env8['TOOL_SCCS1'] = None +env8['TOOL_SCCS2'] = 1 +env9['SCCS'] = None +env9['TOOL_SCCS1'] = None +env9['TOOL_SCCS2'] = 1 +env0['SCCS'] = None +env0['TOOL_SCCS1'] = None +env0['TOOL_SCCS2'] = 1 +scons: done reading SConscript files. +scons: Building targets ... +scons: `.' is up to date. +scons: done building targets. +""") + +test.pass_test()