458 lines
17 KiB
Python
458 lines
17 KiB
Python
"""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 subsystem 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, 2003, 2004, 2005, 2006, 2007 The SCons Foundation
|
|
#
|
|
# 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__ = "/home/scons/scons/branch.0/baseline/src/engine/SCons/Tool/__init__.py 0.97.D001 2007/05/17 11:35:19 knight"
|
|
|
|
import imp
|
|
import sys
|
|
|
|
import SCons.Builder
|
|
import SCons.Errors
|
|
import SCons.Scanner
|
|
import SCons.Scanner.C
|
|
import SCons.Scanner.D
|
|
import SCons.Scanner.LaTeX
|
|
import SCons.Scanner.Prog
|
|
|
|
DefaultToolpath=[]
|
|
|
|
CScanner = SCons.Scanner.C.CScanner()
|
|
DScanner = SCons.Scanner.D.DScanner()
|
|
LaTeXScanner = SCons.Scanner.LaTeX.LaTeXScanner()
|
|
ProgramScanner = SCons.Scanner.Prog.ProgramScanner()
|
|
SourceFileScanner = SCons.Scanner.Base({}, name='SourceFileScanner')
|
|
|
|
CSuffixes = [".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
|
|
".h", ".H", ".hxx", ".hpp", ".hh",
|
|
".F", ".fpp", ".FPP",
|
|
".m", ".mm",
|
|
".S", ".spp", ".SPP"]
|
|
|
|
DSuffixes = ['.d']
|
|
|
|
IDLSuffixes = [".idl", ".IDL"]
|
|
|
|
LaTeXSuffixes = [".tex", ".ltx", ".latex"]
|
|
|
|
for suffix in CSuffixes:
|
|
SourceFileScanner.add_scanner(suffix, CScanner)
|
|
|
|
for suffix in DSuffixes:
|
|
SourceFileScanner.add_scanner(suffix, DScanner)
|
|
|
|
for suffix in LaTeXSuffixes:
|
|
SourceFileScanner.add_scanner(suffix, LaTeXScanner)
|
|
|
|
class Tool:
|
|
def __init__(self, name, toolpath=[], **kw):
|
|
self.name = name
|
|
self.toolpath = toolpath + DefaultToolpath
|
|
# remember these so we can merge them into the call
|
|
self.init_kw = kw
|
|
|
|
module = self._tool_module()
|
|
self.generate = module.generate
|
|
self.exists = module.exists
|
|
|
|
def _tool_module(self):
|
|
oldpythonpath = sys.path
|
|
sys.path = self.toolpath + sys.path
|
|
|
|
try:
|
|
try:
|
|
file, path, desc = imp.find_module(self.name, self.toolpath)
|
|
try:
|
|
return imp.load_module(self.name, file, path, desc)
|
|
finally:
|
|
if file:
|
|
file.close()
|
|
except ImportError, e:
|
|
try:
|
|
import zipimport
|
|
except ImportError:
|
|
pass
|
|
else:
|
|
for aPath in self.toolpath:
|
|
try:
|
|
importer = zipimport.zipimporter(aPath)
|
|
return importer.load_module(self.name)
|
|
except ImportError, e:
|
|
pass
|
|
finally:
|
|
sys.path = oldpythonpath
|
|
|
|
full_name = 'SCons.Tool.' + self.name
|
|
try:
|
|
return sys.modules[full_name]
|
|
except KeyError:
|
|
try:
|
|
smpath = sys.modules['SCons.Tool'].__path__
|
|
try:
|
|
file, path, desc = imp.find_module(self.name, smpath)
|
|
module = imp.load_module(full_name, file, path, desc)
|
|
setattr(SCons.Tool, self.name, module)
|
|
if file:
|
|
file.close()
|
|
return module
|
|
except ImportError, e:
|
|
try:
|
|
import zipimport
|
|
importer = zipimport.zipimporter( sys.modules['SCons.Tool'].__path__[0] )
|
|
module = importer.load_module(full_name)
|
|
setattr(SCons.Tool, self.name, module)
|
|
return module
|
|
except ImportError, e:
|
|
m = "No tool named '%s': %s" % (self.name, e)
|
|
raise SCons.Errors.UserError, m
|
|
except ImportError, e:
|
|
m = "No tool named '%s': %s" % (self.name, e)
|
|
raise SCons.Errors.UserError, m
|
|
|
|
def __call__(self, env, *args, **kw):
|
|
if self.init_kw is not None:
|
|
# Merge call kws into init kws;
|
|
# but don't bash self.init_kw.
|
|
if kw is not None:
|
|
call_kw = kw
|
|
kw = self.init_kw.copy()
|
|
kw.update(call_kw)
|
|
else:
|
|
kw = self.init_kw
|
|
env.Append(TOOLS = [ self.name ])
|
|
apply(self.generate, ( env, ) + args, kw)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
def createProgBuilder(env):
|
|
"""This is a utility function that creates the Program
|
|
Builder in an Environment if it is not there already.
|
|
|
|
If it is already there, we return the existing one.
|
|
"""
|
|
|
|
try:
|
|
program = env['BUILDERS']['Program']
|
|
except KeyError:
|
|
import SCons.Defaults
|
|
program = SCons.Builder.Builder(action = SCons.Defaults.LinkAction,
|
|
emitter = '$PROGEMITTER',
|
|
prefix = '$PROGPREFIX',
|
|
suffix = '$PROGSUFFIX',
|
|
src_suffix = '$OBJSUFFIX',
|
|
src_builder = 'Object',
|
|
target_scanner = ProgramScanner)
|
|
env['BUILDERS']['Program'] = program
|
|
|
|
return program
|
|
|
|
def createStaticLibBuilder(env):
|
|
"""This is a utility function that creates the StaticLibrary
|
|
Builder in an Environment if it is not there already.
|
|
|
|
If it is already there, we return the existing one.
|
|
"""
|
|
|
|
try:
|
|
static_lib = env['BUILDERS']['StaticLibrary']
|
|
except KeyError:
|
|
action_list = [ SCons.Action.Action("$ARCOM", "$ARCOMSTR") ]
|
|
if env.Detect('ranlib'):
|
|
ranlib_action = SCons.Action.Action("$RANLIBCOM", "$RANLIBCOMSTR")
|
|
action_list.append(ranlib_action)
|
|
|
|
static_lib = SCons.Builder.Builder(action = action_list,
|
|
emitter = '$LIBEMITTER',
|
|
prefix = '$LIBPREFIX',
|
|
suffix = '$LIBSUFFIX',
|
|
src_suffix = '$OBJSUFFIX',
|
|
src_builder = 'StaticObject')
|
|
env['BUILDERS']['StaticLibrary'] = static_lib
|
|
env['BUILDERS']['Library'] = static_lib
|
|
|
|
return static_lib
|
|
|
|
def createSharedLibBuilder(env):
|
|
"""This is a utility function that creates the SharedLibrary
|
|
Builder in an Environment if it is not there already.
|
|
|
|
If it is already there, we return the existing one.
|
|
"""
|
|
|
|
try:
|
|
shared_lib = env['BUILDERS']['SharedLibrary']
|
|
except KeyError:
|
|
import SCons.Defaults
|
|
action_list = [ SCons.Defaults.SharedCheck,
|
|
SCons.Defaults.ShLinkAction ]
|
|
shared_lib = SCons.Builder.Builder(action = action_list,
|
|
emitter = "$SHLIBEMITTER",
|
|
prefix = '$SHLIBPREFIX',
|
|
suffix = '$SHLIBSUFFIX',
|
|
target_scanner = ProgramScanner,
|
|
src_suffix = '$SHOBJSUFFIX',
|
|
src_builder = 'SharedObject')
|
|
env['BUILDERS']['SharedLibrary'] = shared_lib
|
|
|
|
return shared_lib
|
|
|
|
def createLoadableModuleBuilder(env):
|
|
"""This is a utility function that creates the LoadableModule
|
|
Builder in an Environment if it is not there already.
|
|
|
|
If it is already there, we return the existing one.
|
|
"""
|
|
|
|
try:
|
|
ld_module = env['BUILDERS']['LoadableModule']
|
|
except KeyError:
|
|
import SCons.Defaults
|
|
action_list = [ SCons.Defaults.SharedCheck,
|
|
SCons.Defaults.LdModuleLinkAction ]
|
|
ld_module = SCons.Builder.Builder(action = action_list,
|
|
emitter = "$SHLIBEMITTER",
|
|
prefix = '$LDMODULEPREFIX',
|
|
suffix = '$LDMODULESUFFIX',
|
|
target_scanner = ProgramScanner,
|
|
src_suffix = '$SHOBJSUFFIX',
|
|
src_builder = 'SharedObject')
|
|
env['BUILDERS']['LoadableModule'] = ld_module
|
|
|
|
return ld_module
|
|
|
|
def createObjBuilders(env):
|
|
"""This is a utility function that creates the StaticObject
|
|
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']['StaticObject']
|
|
except KeyError:
|
|
static_obj = SCons.Builder.Builder(action = {},
|
|
emitter = {},
|
|
prefix = '$OBJPREFIX',
|
|
suffix = '$OBJSUFFIX',
|
|
src_builder = ['CFile', 'CXXFile'],
|
|
source_scanner = SourceFileScanner,
|
|
single_source = 1)
|
|
env['BUILDERS']['StaticObject'] = static_obj
|
|
env['BUILDERS']['Object'] = static_obj
|
|
|
|
try:
|
|
shared_obj = env['BUILDERS']['SharedObject']
|
|
except KeyError:
|
|
shared_obj = SCons.Builder.Builder(action = {},
|
|
emitter = {},
|
|
prefix = '$SHOBJPREFIX',
|
|
suffix = '$SHOBJSUFFIX',
|
|
src_builder = ['CFile', 'CXXFile'],
|
|
source_scanner = SourceFileScanner,
|
|
single_source = 1)
|
|
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.Builder.Builder(action = {},
|
|
emitter = {},
|
|
suffix = {None:'$CFILESUFFIX'})
|
|
env['BUILDERS']['CFile'] = c_file
|
|
env['CFILESUFFIX'] = '.c'
|
|
|
|
try:
|
|
cxx_file = env['BUILDERS']['CXXFile']
|
|
except KeyError:
|
|
cxx_file = SCons.Builder.Builder(action = {},
|
|
emitter = {},
|
|
suffix = {None:'$CXXFILESUFFIX'})
|
|
env['BUILDERS']['CXXFile'] = cxx_file
|
|
env['CXXFILESUFFIX'] = '.cc'
|
|
|
|
return (c_file, cxx_file)
|
|
|
|
def FindTool(tools, env):
|
|
for tool in tools:
|
|
t = Tool(tool)
|
|
if t.exists(env):
|
|
return tool
|
|
return None
|
|
|
|
def FindAllTools(tools, env):
|
|
def ToolExists(tool, env=env):
|
|
return Tool(tool).exists(env)
|
|
return filter (ToolExists, tools)
|
|
|
|
def tool_list(platform, env):
|
|
|
|
# XXX this logic about what tool to prefer on which platform
|
|
# should be moved into either the platform files or
|
|
# the tool files themselves.
|
|
# The search orders here are described in the man page. If you
|
|
# change these search orders, update the man page as well.
|
|
if str(platform) == 'win32':
|
|
"prefer Microsoft tools on Windows"
|
|
linkers = ['mslink', 'gnulink', 'ilink', 'linkloc', 'ilink32' ]
|
|
c_compilers = ['msvc', 'mingw', 'gcc', 'intelc', 'icl', 'icc', 'cc', 'bcc32' ]
|
|
cxx_compilers = ['msvc', 'intelc', 'icc', 'g++', 'c++', 'bcc32' ]
|
|
assemblers = ['masm', 'nasm', 'gas', '386asm' ]
|
|
fortran_compilers = ['g77', 'ifl', 'cvf', 'f95', 'f90', 'fortran']
|
|
ars = ['mslib', 'ar', 'tlib']
|
|
elif str(platform) == 'os2':
|
|
"prefer IBM tools on OS/2"
|
|
linkers = ['ilink', 'gnulink', 'mslink']
|
|
c_compilers = ['icc', 'gcc', 'msvc', 'cc']
|
|
cxx_compilers = ['icc', 'g++', 'msvc', 'c++']
|
|
assemblers = ['nasm', 'masm', 'gas']
|
|
fortran_compilers = ['ifl', 'g77']
|
|
ars = ['ar', 'mslib']
|
|
elif str(platform) == 'irix':
|
|
"prefer MIPSPro on IRIX"
|
|
linkers = ['sgilink', 'gnulink']
|
|
c_compilers = ['sgicc', 'gcc', 'cc']
|
|
cxx_compilers = ['sgic++', 'g++', 'c++']
|
|
assemblers = ['as', 'gas']
|
|
fortran_compilers = ['f95', 'f90', 'f77', 'g77', 'fortran']
|
|
ars = ['sgiar']
|
|
elif str(platform) == 'sunos':
|
|
"prefer Forte tools on SunOS"
|
|
linkers = ['sunlink', 'gnulink']
|
|
c_compilers = ['suncc', 'gcc', 'cc']
|
|
cxx_compilers = ['sunc++', 'g++', 'c++']
|
|
assemblers = ['as', 'gas']
|
|
fortran_compilers = ['f95', 'f90', 'f77', 'g77', 'fortran']
|
|
ars = ['sunar']
|
|
elif str(platform) == 'hpux':
|
|
"prefer aCC tools on HP-UX"
|
|
linkers = ['hplink', 'gnulink']
|
|
c_compilers = ['hpcc', 'gcc', 'cc']
|
|
cxx_compilers = ['hpc++', 'g++', 'c++']
|
|
assemblers = ['as', 'gas']
|
|
fortran_compilers = ['f95', 'f90', 'f77', 'g77', 'fortran']
|
|
ars = ['ar']
|
|
elif str(platform) == 'aix':
|
|
"prefer AIX Visual Age tools on AIX"
|
|
linkers = ['aixlink', 'gnulink']
|
|
c_compilers = ['aixcc', 'gcc', 'cc']
|
|
cxx_compilers = ['aixc++', 'g++', 'c++']
|
|
assemblers = ['as', 'gas']
|
|
fortran_compilers = ['f95', 'f90', 'aixf77', 'g77', 'fortran']
|
|
ars = ['ar']
|
|
elif str(platform) == 'darwin':
|
|
"prefer GNU tools on Mac OS X, except for some linkers and IBM tools"
|
|
linkers = ['applelink', 'gnulink']
|
|
c_compilers = ['gcc', 'cc']
|
|
cxx_compilers = ['g++', 'c++']
|
|
assemblers = ['as']
|
|
fortran_compilers = ['f95', 'f90', 'g77']
|
|
ars = ['ar']
|
|
else:
|
|
"prefer GNU tools on all other platforms"
|
|
linkers = ['gnulink', 'mslink', 'ilink']
|
|
c_compilers = ['gcc', 'msvc', 'intelc', 'icc', 'cc']
|
|
cxx_compilers = ['g++', 'msvc', 'intelc', 'icc', 'c++']
|
|
assemblers = ['gas', 'nasm', 'masm']
|
|
fortran_compilers = ['f95', 'f90', 'g77', 'ifort', 'ifl', 'fortran']
|
|
ars = ['ar', 'mslib']
|
|
|
|
c_compiler = FindTool(c_compilers, env) or c_compilers[0]
|
|
|
|
# XXX this logic about what tool provides what should somehow be
|
|
# moved into the tool files themselves.
|
|
if c_compiler and c_compiler == 'mingw':
|
|
# MinGW contains a linker, C compiler, C++ compiler,
|
|
# Fortran compiler, archiver and assembler:
|
|
cxx_compiler = None
|
|
linker = None
|
|
assembler = None
|
|
fortran_compiler = None
|
|
ar = None
|
|
else:
|
|
# Don't use g++ if the C compiler has built-in C++ support:
|
|
if c_compiler in ('msvc', 'intelc', 'icc'):
|
|
cxx_compiler = None
|
|
else:
|
|
cxx_compiler = FindTool(cxx_compilers, env) or cxx_compilers[0]
|
|
linker = FindTool(linkers, env) or linkers[0]
|
|
assembler = FindTool(assemblers, env) or assemblers[0]
|
|
fortran_compiler = FindTool(fortran_compilers, env) or fortran_compilers[0]
|
|
ar = FindTool(ars, env) or ars[0]
|
|
|
|
other_tools = FindAllTools(['BitKeeper', 'CVS',
|
|
'dmd',
|
|
'dvipdf', 'dvips', 'gs',
|
|
'jar', 'javac', 'javah',
|
|
'latex', 'lex',
|
|
'm4', 'midl', 'msvs',
|
|
'pdflatex', 'pdftex', 'Perforce',
|
|
'RCS', 'rmic', 'rpcgen',
|
|
'SCCS',
|
|
# 'Subversion',
|
|
'swig',
|
|
'tar', 'tex',
|
|
'yacc', 'zip'],
|
|
env)
|
|
|
|
tools = ([linker, c_compiler, cxx_compiler,
|
|
fortran_compiler, assembler, ar]
|
|
+ other_tools)
|
|
|
|
return filter(lambda x: x, tools)
|