/contrib/sdk/sources/Mesa/scons/crossmingw.py |
---|
0,0 → 1,191 |
"""SCons.Tool.gcc |
Tool-specific initialization for MinGW (http://www.mingw.org/) |
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. |
See also http://www.scons.org/wiki/CrossCompilingMingw |
""" |
# |
# Copyright (c) 2001, 2002, 2003, 2004 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. |
# |
import os |
import os.path |
import string |
import SCons.Action |
import SCons.Builder |
import SCons.Tool |
import SCons.Util |
# This is what we search for to find mingw: |
prefixes32 = SCons.Util.Split(""" |
mingw32- |
mingw32msvc- |
i386-mingw32- |
i486-mingw32- |
i586-mingw32- |
i686-mingw32- |
i386-mingw32msvc- |
i486-mingw32msvc- |
i586-mingw32msvc- |
i686-mingw32msvc- |
i686-pc-mingw32- |
i686-w64-mingw32- |
""") |
prefixes64 = SCons.Util.Split(""" |
x86_64-w64-mingw32- |
amd64-mingw32- |
amd64-mingw32msvc- |
amd64-pc-mingw32- |
""") |
def find(env): |
if env['machine'] == 'x86_64': |
prefixes = prefixes64 |
else: |
prefixes = prefixes32 |
for prefix in prefixes: |
# First search in the SCons path and then the OS path: |
if env.WhereIs(prefix + 'gcc') or SCons.Util.WhereIs(prefix + 'gcc'): |
return prefix |
return '' |
def shlib_generator(target, source, env, for_signature): |
cmd = SCons.Util.CLVar(['$SHLINK', '$SHLINKFLAGS']) |
dll = env.FindIxes(target, 'SHLIBPREFIX', 'SHLIBSUFFIX') |
if dll: cmd.extend(['-o', dll]) |
cmd.extend(['$SOURCES', '$_LIBDIRFLAGS', '$_LIBFLAGS']) |
implib = env.FindIxes(target, 'LIBPREFIX', 'LIBSUFFIX') |
if implib: cmd.append('-Wl,--out-implib,'+implib.get_string(for_signature)) |
def_target = env.FindIxes(target, 'WIN32DEFPREFIX', 'WIN32DEFSUFFIX') |
if def_target: cmd.append('-Wl,--output-def,'+def_target.get_string(for_signature)) |
return [cmd] |
def shlib_emitter(target, source, env): |
dll = env.FindIxes(target, 'SHLIBPREFIX', 'SHLIBSUFFIX') |
no_import_lib = env.get('no_import_lib', 0) |
if not dll: |
raise SCons.Errors.UserError, "A shared library should have exactly one target with the suffix: %s" % env.subst("$SHLIBSUFFIX") |
if not no_import_lib and \ |
not env.FindIxes(target, 'LIBPREFIX', 'LIBSUFFIX'): |
# Append an import library to the list of targets. |
target.append(env.ReplaceIxes(dll, |
'SHLIBPREFIX', 'SHLIBSUFFIX', |
'LIBPREFIX', 'LIBSUFFIX')) |
# Append a def file target if there isn't already a def file target |
# or a def file source. There is no option to disable def file |
# target emitting, because I can't figure out why someone would ever |
# want to turn it off. |
def_source = env.FindIxes(source, 'WIN32DEFPREFIX', 'WIN32DEFSUFFIX') |
def_target = env.FindIxes(target, 'WIN32DEFPREFIX', 'WIN32DEFSUFFIX') |
if not def_source and not def_target: |
target.append(env.ReplaceIxes(dll, |
'SHLIBPREFIX', 'SHLIBSUFFIX', |
'WIN32DEFPREFIX', 'WIN32DEFSUFFIX')) |
return (target, source) |
shlib_action = SCons.Action.Action(shlib_generator, '$SHLINKCOMSTR', generator=1) |
res_action = SCons.Action.Action('$RCCOM', '$RCCOMSTR') |
res_builder = SCons.Builder.Builder(action=res_action, suffix='.o', |
source_scanner=SCons.Tool.SourceFileScanner) |
SCons.Tool.SourceFileScanner.add_scanner('.rc', SCons.Defaults.CScan) |
def generate(env): |
mingw_prefix = find(env) |
if mingw_prefix: |
dir = os.path.dirname(env.WhereIs(mingw_prefix + 'gcc') or SCons.Util.WhereIs(mingw_prefix + 'gcc')) |
# The mingw bin directory must be added to the path: |
path = env['ENV'].get('PATH', []) |
if not path: |
path = [] |
if SCons.Util.is_String(path): |
path = string.split(path, os.pathsep) |
env['ENV']['PATH'] = string.join([dir] + path, os.pathsep) |
# Most of mingw is the same as gcc and friends... |
gnu_tools = ['gcc', 'g++', 'gnulink', 'ar', 'gas'] |
for tool in gnu_tools: |
SCons.Tool.Tool(tool)(env) |
#... but a few things differ: |
env['CC'] = mingw_prefix + 'gcc' |
env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS') |
env['CXX'] = mingw_prefix + 'g++' |
env['SHCXXFLAGS'] = SCons.Util.CLVar('$CXXFLAGS') |
env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS -shared') |
env['SHLINKCOM'] = shlib_action |
env.Append(SHLIBEMITTER = [shlib_emitter]) |
env['LINK'] = mingw_prefix + 'g++' |
env['AR'] = mingw_prefix + 'ar' |
env['RANLIB'] = mingw_prefix + 'ranlib' |
env['LINK'] = mingw_prefix + 'g++' |
env['AS'] = mingw_prefix + 'as' |
env['WIN32DEFPREFIX'] = '' |
env['WIN32DEFSUFFIX'] = '.def' |
env['SHOBJSUFFIX'] = '.o' |
env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 1 |
env['RC'] = mingw_prefix + 'windres' |
env['RCFLAGS'] = SCons.Util.CLVar('') |
env['RCCOM'] = '$RC $_CPPDEFFLAGS $_CPPINCFLAGS ${INCPREFIX}${SOURCE.dir} $RCFLAGS -i $SOURCE -o $TARGET' |
env['BUILDERS']['RES'] = res_builder |
# Some setting from the platform also have to be overridden: |
env['OBJPREFIX'] = '' |
env['OBJSUFFIX'] = '.o' |
env['SHOBJPREFIX'] = '$OBJPREFIX' |
env['SHOBJSUFFIX'] = '$OBJSUFFIX' |
env['PROGPREFIX'] = '' |
env['PROGSUFFIX'] = '.exe' |
env['LIBPREFIX'] = 'lib' |
env['LIBSUFFIX'] = '.a' |
env['SHLIBPREFIX'] = '' |
env['SHLIBSUFFIX'] = '.dll' |
env['LIBPREFIXES'] = [ 'lib', '' ] |
env['LIBSUFFIXES'] = [ '.a', '.lib' ] |
def exists(env): |
return find(env) |
/contrib/sdk/sources/Mesa/scons/custom.py |
---|
0,0 → 1,315 |
"""custom |
Custom builders and methods. |
""" |
# |
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
# All Rights Reserved. |
# |
# 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, sub license, 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 (including the |
# next paragraph) 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 NON-INFRINGEMENT. |
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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. |
# |
import os |
import os.path |
import re |
import sys |
import subprocess |
import SCons.Action |
import SCons.Builder |
import SCons.Scanner |
import fixes |
import source_list |
def quietCommandLines(env): |
# Quiet command lines |
# See also http://www.scons.org/wiki/HidingCommandLinesInOutput |
env['ASCOMSTR'] = " Assembling $SOURCE ..." |
env['ASPPCOMSTR'] = " Assembling $SOURCE ..." |
env['CCCOMSTR'] = " Compiling $SOURCE ..." |
env['SHCCCOMSTR'] = " Compiling $SOURCE ..." |
env['CXXCOMSTR'] = " Compiling $SOURCE ..." |
env['SHCXXCOMSTR'] = " Compiling $SOURCE ..." |
env['ARCOMSTR'] = " Archiving $TARGET ..." |
env['RANLIBCOMSTR'] = " Indexing $TARGET ..." |
env['LINKCOMSTR'] = " Linking $TARGET ..." |
env['SHLINKCOMSTR'] = " Linking $TARGET ..." |
env['LDMODULECOMSTR'] = " Linking $TARGET ..." |
env['SWIGCOMSTR'] = " Generating $TARGET ..." |
env['LEXCOMSTR'] = " Generating $TARGET ..." |
env['YACCCOMSTR'] = " Generating $TARGET ..." |
env['CODEGENCOMSTR'] = " Generating $TARGET ..." |
env['INSTALLSTR'] = " Installing $TARGET ..." |
def createConvenienceLibBuilder(env): |
"""This is a utility function that creates the ConvenienceLibrary |
Builder in an Environment if it is not there already. |
If it is already there, we return the existing one. |
Based on the stock StaticLibrary and SharedLibrary builders. |
""" |
try: |
convenience_lib = env['BUILDERS']['ConvenienceLibrary'] |
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) |
convenience_lib = SCons.Builder.Builder(action = action_list, |
emitter = '$LIBEMITTER', |
prefix = '$LIBPREFIX', |
suffix = '$LIBSUFFIX', |
src_suffix = '$SHOBJSUFFIX', |
src_builder = 'SharedObject') |
env['BUILDERS']['ConvenienceLibrary'] = convenience_lib |
return convenience_lib |
# TODO: handle import statements with multiple modules |
# TODO: handle from import statements |
import_re = re.compile(r'^\s*import\s+(\S+)\s*$', re.M) |
def python_scan(node, env, path): |
# http://www.scons.org/doc/0.98.5/HTML/scons-user/c2781.html#AEN2789 |
contents = node.get_contents() |
source_dir = node.get_dir() |
imports = import_re.findall(contents) |
results = [] |
for imp in imports: |
for dir in path: |
file = os.path.join(str(dir), imp.replace('.', os.sep) + '.py') |
if os.path.exists(file): |
results.append(env.File(file)) |
break |
file = os.path.join(str(dir), imp.replace('.', os.sep), '__init__.py') |
if os.path.exists(file): |
results.append(env.File(file)) |
break |
#print node, map(str, results) |
return results |
python_scanner = SCons.Scanner.Scanner(function = python_scan, skeys = ['.py']) |
def code_generate(env, script, target, source, command): |
"""Method to simplify code generation via python scripts. |
http://www.scons.org/wiki/UsingCodeGenerators |
http://www.scons.org/doc/0.98.5/HTML/scons-user/c2768.html |
""" |
# We're generating code using Python scripts, so we have to be |
# careful with our scons elements. This entry represents |
# the generator file *in the source directory*. |
script_src = env.File(script).srcnode() |
# This command creates generated code *in the build directory*. |
command = command.replace('$SCRIPT', script_src.path) |
action = SCons.Action.Action(command, "$CODEGENCOMSTR") |
code = env.Command(target, source, action) |
# Explicitly mark that the generated code depends on the generator, |
# and on implicitly imported python modules |
path = (script_src.get_dir(),) |
deps = [script_src] |
deps += script_src.get_implicit_deps(env, python_scanner, path) |
env.Depends(code, deps) |
# Running the Python script causes .pyc files to be generated in the |
# source directory. When we clean up, they should go too. So add side |
# effects for .pyc files |
for dep in deps: |
pyc = env.File(str(dep) + 'c') |
env.SideEffect(pyc, code) |
return code |
def createCodeGenerateMethod(env): |
env.Append(SCANNERS = python_scanner) |
env.AddMethod(code_generate, 'CodeGenerate') |
def _pkg_check_modules(env, name, modules): |
'''Simple wrapper for pkg-config.''' |
env['HAVE_' + name] = False |
# For backwards compatability |
env[name.lower()] = False |
if env['platform'] == 'windows': |
return |
if not env.Detect('pkg-config'): |
return |
if subprocess.call(["pkg-config", "--exists", ' '.join(modules)]) != 0: |
return |
# Strip version expressions from modules |
modules = [module.split(' ', 1)[0] for module in modules] |
# Other flags may affect the compilation of unrelated targets, so store |
# them with a prefix, (e.g., XXX_CFLAGS, XXX_LIBS, etc) |
try: |
flags = env.ParseFlags('!pkg-config --cflags --libs ' + ' '.join(modules)) |
except OSError: |
return |
prefix = name + '_' |
for flag_name, flag_value in flags.iteritems(): |
assert '_' not in flag_name |
env[prefix + flag_name] = flag_value |
env['HAVE_' + name] = True |
def pkg_check_modules(env, name, modules): |
sys.stdout.write('Checking for %s (%s)...' % (name, ' '.join(modules))) |
_pkg_check_modules(env, name, modules) |
result = env['HAVE_' + name] |
sys.stdout.write(' %s\n' % ['no', 'yes'][int(bool(result))]) |
# XXX: For backwards compatability |
env[name.lower()] = result |
def pkg_use_modules(env, names): |
'''Search for all environment flags that match NAME_FOO and append them to |
the FOO environment variable.''' |
names = env.Flatten(names) |
for name in names: |
prefix = name + '_' |
if not 'HAVE_' + name in env: |
raise Exception('Attempt to use unknown module %s' % name) |
if not env['HAVE_' + name]: |
raise Exception('Attempt to use unavailable module %s' % name) |
flags = {} |
for flag_name, flag_value in env.Dictionary().iteritems(): |
if flag_name.startswith(prefix): |
flag_name = flag_name[len(prefix):] |
if '_' not in flag_name: |
flags[flag_name] = flag_value |
if flags: |
env.MergeFlags(flags) |
def createPkgConfigMethods(env): |
env.AddMethod(pkg_check_modules, 'PkgCheckModules') |
env.AddMethod(pkg_use_modules, 'PkgUseModules') |
def parse_source_list(env, filename, names=None): |
# parse the source list file |
parser = source_list.SourceListParser() |
src = env.File(filename).srcnode() |
cur_srcdir = env.Dir('.').srcnode().abspath |
top_srcdir = env.Dir('#').abspath |
top_builddir = os.path.join(top_srcdir, env['build_dir']) |
# Normalize everything to / slashes |
cur_srcdir = cur_srcdir.replace('\\', '/') |
top_srcdir = top_srcdir.replace('\\', '/') |
top_builddir = top_builddir.replace('\\', '/') |
# Populate the symbol table of the Makefile parser. |
parser.add_symbol('top_srcdir', top_srcdir) |
parser.add_symbol('top_builddir', top_builddir) |
sym_table = parser.parse(src.abspath) |
if names: |
if isinstance(names, basestring): |
names = [names] |
symbols = names |
else: |
symbols = sym_table.keys() |
# convert the symbol table to source lists |
src_lists = {} |
for sym in symbols: |
val = sym_table[sym] |
srcs = [] |
for f in val.split(): |
if f: |
# Process source paths |
if f.startswith(top_builddir + '/src'): |
# Automake puts build output on a `src` subdirectory, but |
# SCons does not, so strip it here. |
f = top_builddir + f[len(top_builddir + '/src'):] |
if f.startswith(cur_srcdir + '/'): |
# Prefer relative source paths, as absolute files tend to |
# cause duplicate actions. |
f = f[len(cur_srcdir + '/'):] |
srcs.append(f) |
src_lists[sym] = srcs |
# if names are given, concatenate the lists |
if names: |
srcs = [] |
for name in names: |
srcs.extend(src_lists[name]) |
return srcs |
else: |
return src_lists |
def createParseSourceListMethod(env): |
env.AddMethod(parse_source_list, 'ParseSourceList') |
def generate(env): |
"""Common environment generation code""" |
verbose = env.get('verbose', False) or not env.get('quiet', True) |
if not verbose: |
quietCommandLines(env) |
# Custom builders and methods |
createConvenienceLibBuilder(env) |
createCodeGenerateMethod(env) |
createPkgConfigMethods(env) |
createParseSourceListMethod(env) |
# for debugging |
#print env.Dump() |
def exists(env): |
return 1 |
/contrib/sdk/sources/Mesa/scons/dxsdk.py |
---|
0,0 → 1,73 |
"""dxsdk |
Tool-specific initialization for Microsoft DirectX SDK |
""" |
# |
# Copyright (c) 2009 VMware, Inc. |
# |
# 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. |
# |
import os |
import os.path |
import SCons.Errors |
import SCons.Util |
def get_dxsdk_root(env): |
try: |
return os.environ['DXSDK_DIR'] |
except KeyError: |
return None |
def generate(env): |
dxsdk_root = get_dxsdk_root(env) |
if dxsdk_root is None: |
# DirectX SDK not found |
return |
if env['machine'] in ('generic', 'x86'): |
target_cpu = 'x86' |
elif env['machine'] == 'x86_64': |
target_cpu = 'x64' |
else: |
raise SCons.Errors.InternalError, "Unsupported target machine" |
include_dir = os.path.join(dxsdk_root, 'Include') |
lib_dir = os.path.join(dxsdk_root, 'Lib', target_cpu) |
env.Append(CPPDEFINES = [('HAVE_DXSDK', '1')]) |
gcc = 'gcc' in os.path.basename(env['CC']).split('-') |
if gcc: |
# Make GCC more forgiving towards Microsoft's headers |
env.Prepend(CPPFLAGS = ['-isystem', include_dir]) |
else: |
env.Prepend(CPPPATH = [include_dir]) |
env.Prepend(LIBPATH = [lib_dir]) |
def exists(env): |
return get_dxsdk_root(env) is not None |
# vim:set ts=4 sw=4 et: |
/contrib/sdk/sources/Mesa/scons/fixes.py |
---|
0,0 → 1,27 |
import sys |
# Monkey patch os.spawnve on windows to become thread safe |
if sys.platform == 'win32': |
import os |
import threading |
from os import spawnve as old_spawnve |
spawn_lock = threading.Lock() |
def new_spawnve(mode, file, args, env): |
spawn_lock.acquire() |
try: |
if mode == os.P_WAIT: |
ret = old_spawnve(os.P_NOWAIT, file, args, env) |
else: |
ret = old_spawnve(mode, file, args, env) |
finally: |
spawn_lock.release() |
if mode == os.P_WAIT: |
pid, status = os.waitpid(ret, 0) |
ret = status >> 8 |
return ret |
os.spawnve = new_spawnve |
/contrib/sdk/sources/Mesa/scons/gallium.py |
---|
0,0 → 1,549 |
"""gallium |
Frontend-tool for Gallium3D architecture. |
""" |
# |
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
# All Rights Reserved. |
# |
# 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, sub license, 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 (including the |
# next paragraph) 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 NON-INFRINGEMENT. |
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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. |
# |
import distutils.version |
import os |
import os.path |
import re |
import subprocess |
import platform as _platform |
import SCons.Action |
import SCons.Builder |
import SCons.Scanner |
def symlink(target, source, env): |
target = str(target[0]) |
source = str(source[0]) |
if os.path.islink(target) or os.path.exists(target): |
os.remove(target) |
os.symlink(os.path.basename(source), target) |
def install(env, source, subdir): |
target_dir = os.path.join(env.Dir('#.').srcnode().abspath, env['build_dir'], subdir) |
return env.Install(target_dir, source) |
def install_program(env, source): |
return install(env, source, 'bin') |
def install_shared_library(env, sources, version = ()): |
targets = [] |
install_dir = os.path.join(env.Dir('#.').srcnode().abspath, env['build_dir']) |
version = tuple(map(str, version)) |
if env['SHLIBSUFFIX'] == '.dll': |
dlls = env.FindIxes(sources, 'SHLIBPREFIX', 'SHLIBSUFFIX') |
targets += install(env, dlls, 'bin') |
libs = env.FindIxes(sources, 'LIBPREFIX', 'LIBSUFFIX') |
targets += install(env, libs, 'lib') |
else: |
for source in sources: |
target_dir = os.path.join(install_dir, 'lib') |
target_name = '.'.join((str(source),) + version) |
last = env.InstallAs(os.path.join(target_dir, target_name), source) |
targets += last |
while len(version): |
version = version[:-1] |
target_name = '.'.join((str(source),) + version) |
action = SCons.Action.Action(symlink, " Symlinking $TARGET ...") |
last = env.Command(os.path.join(target_dir, target_name), last, action) |
targets += last |
return targets |
def createInstallMethods(env): |
env.AddMethod(install_program, 'InstallProgram') |
env.AddMethod(install_shared_library, 'InstallSharedLibrary') |
def num_jobs(): |
try: |
return int(os.environ['NUMBER_OF_PROCESSORS']) |
except (ValueError, KeyError): |
pass |
try: |
return os.sysconf('SC_NPROCESSORS_ONLN') |
except (ValueError, OSError, AttributeError): |
pass |
try: |
return int(os.popen2("sysctl -n hw.ncpu")[1].read()) |
except ValueError: |
pass |
return 1 |
def generate(env): |
"""Common environment generation code""" |
# Tell tools which machine to compile for |
env['TARGET_ARCH'] = env['machine'] |
env['MSVS_ARCH'] = env['machine'] |
# Toolchain |
platform = env['platform'] |
env.Tool(env['toolchain']) |
# Allow override compiler and specify additional flags from environment |
if os.environ.has_key('CC'): |
env['CC'] = os.environ['CC'] |
# Update CCVERSION to match |
pipe = SCons.Action._subproc(env, [env['CC'], '--version'], |
stdin = 'devnull', |
stderr = 'devnull', |
stdout = subprocess.PIPE) |
if pipe.wait() == 0: |
line = pipe.stdout.readline() |
match = re.search(r'[0-9]+(\.[0-9]+)+', line) |
if match: |
env['CCVERSION'] = match.group(0) |
if os.environ.has_key('CFLAGS'): |
env['CCFLAGS'] += SCons.Util.CLVar(os.environ['CFLAGS']) |
if os.environ.has_key('CXX'): |
env['CXX'] = os.environ['CXX'] |
if os.environ.has_key('CXXFLAGS'): |
env['CXXFLAGS'] += SCons.Util.CLVar(os.environ['CXXFLAGS']) |
if os.environ.has_key('LDFLAGS'): |
env['LINKFLAGS'] += SCons.Util.CLVar(os.environ['LDFLAGS']) |
env['gcc'] = 'gcc' in os.path.basename(env['CC']).split('-') |
env['msvc'] = env['CC'] == 'cl' |
env['suncc'] = env['platform'] == 'sunos' and os.path.basename(env['CC']) == 'cc' |
env['clang'] = env['CC'] == 'clang' |
env['icc'] = 'icc' == os.path.basename(env['CC']) |
if env['msvc'] and env['toolchain'] == 'default' and env['machine'] == 'x86_64': |
# MSVC x64 support is broken in earlier versions of scons |
env.EnsurePythonVersion(2, 0) |
# shortcuts |
machine = env['machine'] |
platform = env['platform'] |
x86 = env['machine'] == 'x86' |
ppc = env['machine'] == 'ppc' |
gcc_compat = env['gcc'] or env['clang'] |
msvc = env['msvc'] |
suncc = env['suncc'] |
icc = env['icc'] |
# Determine whether we are cross compiling; in particular, whether we need |
# to compile code generators with a different compiler as the target code. |
host_platform = _platform.system().lower() |
if host_platform.startswith('cygwin'): |
host_platform = 'cygwin' |
host_machine = os.environ.get('PROCESSOR_ARCHITEW6432', os.environ.get('PROCESSOR_ARCHITECTURE', _platform.machine())) |
host_machine = { |
'x86': 'x86', |
'i386': 'x86', |
'i486': 'x86', |
'i586': 'x86', |
'i686': 'x86', |
'ppc' : 'ppc', |
'AMD64': 'x86_64', |
'x86_64': 'x86_64', |
}.get(host_machine, 'generic') |
env['crosscompile'] = platform != host_platform |
if machine == 'x86_64' and host_machine != 'x86_64': |
env['crosscompile'] = True |
env['hostonly'] = False |
# Backwards compatability with the debug= profile= options |
if env['build'] == 'debug': |
if not env['debug']: |
print 'scons: warning: debug option is deprecated and will be removed eventually; use instead' |
print ' scons build=release' |
env['build'] = 'release' |
if env['profile']: |
print 'scons: warning: profile option is deprecated and will be removed eventually; use instead' |
print ' scons build=profile' |
env['build'] = 'profile' |
if False: |
# Enforce SConscripts to use the new build variable |
env.popitem('debug') |
env.popitem('profile') |
else: |
# Backwards portability with older sconscripts |
if env['build'] in ('debug', 'checked'): |
env['debug'] = True |
env['profile'] = False |
if env['build'] == 'profile': |
env['debug'] = False |
env['profile'] = True |
if env['build'] == 'release': |
env['debug'] = False |
env['profile'] = False |
# Put build output in a separate dir, which depends on the current |
# configuration. See also http://www.scons.org/wiki/AdvancedBuildExample |
build_topdir = 'build' |
build_subdir = env['platform'] |
if env['embedded']: |
build_subdir = 'embedded-' + build_subdir |
if env['machine'] != 'generic': |
build_subdir += '-' + env['machine'] |
if env['build'] != 'release': |
build_subdir += '-' + env['build'] |
build_dir = os.path.join(build_topdir, build_subdir) |
# Place the .sconsign file in the build dir too, to avoid issues with |
# different scons versions building the same source file |
env['build_dir'] = build_dir |
env.SConsignFile(os.path.join(build_dir, '.sconsign')) |
if 'SCONS_CACHE_DIR' in os.environ: |
print 'scons: Using build cache in %s.' % (os.environ['SCONS_CACHE_DIR'],) |
env.CacheDir(os.environ['SCONS_CACHE_DIR']) |
env['CONFIGUREDIR'] = os.path.join(build_dir, 'conf') |
env['CONFIGURELOG'] = os.path.join(os.path.abspath(build_dir), 'config.log') |
# Parallel build |
if env.GetOption('num_jobs') <= 1: |
env.SetOption('num_jobs', num_jobs()) |
env.Decider('MD5-timestamp') |
env.SetOption('max_drift', 60) |
# C preprocessor options |
cppdefines = [] |
if env['build'] in ('debug', 'checked'): |
cppdefines += ['DEBUG'] |
else: |
cppdefines += ['NDEBUG'] |
if env['build'] == 'profile': |
cppdefines += ['PROFILE'] |
if env['platform'] in ('posix', 'linux', 'freebsd', 'darwin'): |
cppdefines += [ |
'_POSIX_SOURCE', |
('_POSIX_C_SOURCE', '199309L'), |
'_SVID_SOURCE', |
'_BSD_SOURCE', |
'_GNU_SOURCE', |
'HAVE_PTHREAD', |
'HAVE_POSIX_MEMALIGN', |
] |
if env['platform'] == 'darwin': |
cppdefines += [ |
'_DARWIN_C_SOURCE', |
'GLX_USE_APPLEGL', |
'GLX_DIRECT_RENDERING', |
] |
else: |
cppdefines += [ |
'GLX_DIRECT_RENDERING', |
'GLX_INDIRECT_RENDERING', |
] |
if env['platform'] in ('linux', 'freebsd'): |
cppdefines += ['HAVE_ALIAS'] |
else: |
cppdefines += ['GLX_ALIAS_UNSUPPORTED'] |
if platform == 'windows': |
cppdefines += [ |
'WIN32', |
'_WINDOWS', |
#'_UNICODE', |
#'UNICODE', |
# http://msdn.microsoft.com/en-us/library/aa383745.aspx |
('_WIN32_WINNT', '0x0601'), |
('WINVER', '0x0601'), |
] |
if gcc_compat: |
cppdefines += [('__MSVCRT_VERSION__', '0x0700')] |
if msvc: |
cppdefines += [ |
'VC_EXTRALEAN', |
'_USE_MATH_DEFINES', |
'_CRT_SECURE_NO_WARNINGS', |
'_CRT_SECURE_NO_DEPRECATE', |
'_SCL_SECURE_NO_WARNINGS', |
'_SCL_SECURE_NO_DEPRECATE', |
'_ALLOW_KEYWORD_MACROS', |
] |
if env['build'] in ('debug', 'checked'): |
cppdefines += ['_DEBUG'] |
if platform == 'windows': |
cppdefines += ['PIPE_SUBSYSTEM_WINDOWS_USER'] |
if platform == 'haiku': |
cppdefines += ['BEOS_THREADS'] |
if env['embedded']: |
cppdefines += ['PIPE_SUBSYSTEM_EMBEDDED'] |
if env['texture_float']: |
print 'warning: Floating-point textures enabled.' |
print 'warning: Please consult docs/patents.txt with your lawyer before building Mesa.' |
cppdefines += ['TEXTURE_FLOAT_ENABLED'] |
env.Append(CPPDEFINES = cppdefines) |
# C compiler options |
cflags = [] # C |
cxxflags = [] # C++ |
ccflags = [] # C & C++ |
if gcc_compat: |
ccversion = env['CCVERSION'] |
if env['build'] == 'debug': |
ccflags += ['-O0'] |
elif env['gcc'] and ccversion.startswith('4.2.'): |
# gcc 4.2.x optimizer is broken |
print "warning: gcc 4.2.x optimizer is broken -- disabling optimizations" |
ccflags += ['-O0'] |
else: |
ccflags += ['-O3'] |
if env['gcc']: |
# gcc's builtin memcmp is slower than glibc's |
# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43052 |
ccflags += ['-fno-builtin-memcmp'] |
# Work around aliasing bugs - developers should comment this out |
ccflags += ['-fno-strict-aliasing'] |
ccflags += ['-g'] |
if env['build'] in ('checked', 'profile'): |
# See http://code.google.com/p/jrfonseca/wiki/Gprof2Dot#Which_options_should_I_pass_to_gcc_when_compiling_for_profiling? |
ccflags += [ |
'-fno-omit-frame-pointer', |
] |
if env['gcc']: |
ccflags += ['-fno-optimize-sibling-calls'] |
if env['machine'] == 'x86': |
ccflags += [ |
'-m32', |
#'-march=pentium4', |
] |
if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.2') \ |
and (platform != 'windows' or env['build'] == 'debug' or True) \ |
and platform != 'haiku': |
# NOTE: We need to ensure stack is realigned given that we |
# produce shared objects, and have no control over the stack |
# alignment policy of the application. Therefore we need |
# -mstackrealign ore -mincoming-stack-boundary=2. |
# |
# XXX: -O and -mstackrealign causes stack corruption on MinGW |
# |
# XXX: We could have SSE without -mstackrealign if we always used |
# __attribute__((force_align_arg_pointer)), but that's not |
# always the case. |
ccflags += [ |
'-mstackrealign', # ensure stack is aligned |
'-mmmx', '-msse', '-msse2', # enable SIMD intrinsics |
#'-mfpmath=sse', |
] |
if platform in ['windows', 'darwin']: |
# Workaround http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37216 |
ccflags += ['-fno-common'] |
if platform in ['haiku']: |
# Make optimizations compatible with Pentium or higher on Haiku |
ccflags += [ |
'-mstackrealign', # ensure stack is aligned |
'-march=i586', # Haiku target is Pentium |
'-mtune=i686' # use i686 where we can |
] |
if env['machine'] == 'x86_64': |
ccflags += ['-m64'] |
if platform == 'darwin': |
ccflags += ['-fno-common'] |
if env['platform'] not in ('cygwin', 'haiku', 'windows'): |
ccflags += ['-fvisibility=hidden'] |
# See also: |
# - http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html |
ccflags += [ |
'-Wall', |
'-Wno-long-long', |
'-fmessage-length=0', # be nice to Eclipse |
] |
cflags += [ |
'-Wmissing-prototypes', |
'-std=gnu99', |
] |
if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.2'): |
ccflags += [ |
'-Wpointer-arith', |
] |
cflags += [ |
'-Wdeclaration-after-statement', |
] |
if icc: |
cflags += [ |
'-std=gnu99', |
] |
if msvc: |
# See also: |
# - http://msdn.microsoft.com/en-us/library/19z1t1wy.aspx |
# - cl /? |
if env['build'] == 'debug': |
ccflags += [ |
'/Od', # disable optimizations |
'/Oi', # enable intrinsic functions |
] |
else: |
if 'MSVC_VERSION' in env and distutils.version.LooseVersion(env['MSVC_VERSION']) < distutils.version.LooseVersion('11.0'): |
print 'scons: warning: Visual Studio versions prior to 2012 are known to produce incorrect code when optimizations are enabled ( https://bugs.freedesktop.org/show_bug.cgi?id=58718 )' |
ccflags += [ |
'/O2', # optimize for speed |
] |
if env['build'] == 'release': |
ccflags += [ |
'/GL', # enable whole program optimization |
] |
else: |
ccflags += [ |
'/Oy-', # disable frame pointer omission |
'/GL-', # disable whole program optimization |
] |
ccflags += [ |
'/W3', # warning level |
#'/Wp64', # enable 64 bit porting warnings |
'/wd4996', # disable deprecated POSIX name warnings |
] |
if env['machine'] == 'x86': |
ccflags += [ |
#'/arch:SSE2', # use the SSE2 instructions |
] |
if platform == 'windows': |
ccflags += [ |
# TODO |
] |
# Automatic pdb generation |
# See http://scons.tigris.org/issues/show_bug.cgi?id=1656 |
env.EnsureSConsVersion(0, 98, 0) |
env['PDB'] = '${TARGET.base}.pdb' |
env.Append(CCFLAGS = ccflags) |
env.Append(CFLAGS = cflags) |
env.Append(CXXFLAGS = cxxflags) |
if env['platform'] == 'windows' and msvc: |
# Choose the appropriate MSVC CRT |
# http://msdn.microsoft.com/en-us/library/2kzt1wy3.aspx |
if env['build'] in ('debug', 'checked'): |
env.Append(CCFLAGS = ['/MTd']) |
env.Append(SHCCFLAGS = ['/LDd']) |
else: |
env.Append(CCFLAGS = ['/MT']) |
env.Append(SHCCFLAGS = ['/LD']) |
# Assembler options |
if gcc_compat: |
if env['machine'] == 'x86': |
env.Append(ASFLAGS = ['-m32']) |
if env['machine'] == 'x86_64': |
env.Append(ASFLAGS = ['-m64']) |
# Linker options |
linkflags = [] |
shlinkflags = [] |
if gcc_compat: |
if env['machine'] == 'x86': |
linkflags += ['-m32'] |
if env['machine'] == 'x86_64': |
linkflags += ['-m64'] |
if env['platform'] not in ('darwin'): |
shlinkflags += [ |
'-Wl,-Bsymbolic', |
] |
# Handle circular dependencies in the libraries |
if env['platform'] in ('darwin'): |
pass |
else: |
env['_LIBFLAGS'] = '-Wl,--start-group ' + env['_LIBFLAGS'] + ' -Wl,--end-group' |
if env['platform'] == 'windows': |
# Avoid depending on gcc runtime DLLs |
linkflags += ['-static-libgcc'] |
if 'w64' in env['CC'].split('-'): |
linkflags += ['-static-libstdc++'] |
# Handle the @xx symbol munging of DLL exports |
shlinkflags += ['-Wl,--enable-stdcall-fixup'] |
#shlinkflags += ['-Wl,--kill-at'] |
if msvc: |
if env['build'] == 'release': |
# enable Link-time Code Generation |
linkflags += ['/LTCG'] |
env.Append(ARFLAGS = ['/LTCG']) |
if platform == 'windows' and msvc: |
# See also: |
# - http://msdn2.microsoft.com/en-us/library/y0zzbyt4.aspx |
linkflags += [ |
'/fixed:no', |
'/incremental:no', |
] |
env.Append(LINKFLAGS = linkflags) |
env.Append(SHLINKFLAGS = shlinkflags) |
# We have C++ in several libraries, so always link with the C++ compiler |
if gcc_compat: |
env['LINK'] = env['CXX'] |
# Default libs |
libs = [] |
if env['platform'] in ('darwin', 'freebsd', 'linux', 'posix', 'sunos'): |
libs += ['m', 'pthread', 'dl'] |
if env['platform'] in ('linux',): |
libs += ['rt'] |
env.Append(LIBS = libs) |
# OpenMP |
if env['openmp']: |
if env['msvc']: |
env.Append(CCFLAGS = ['/openmp']) |
# When building openmp release VS2008 link.exe crashes with LNK1103 error. |
# Workaround: overwrite PDB flags with empty value as it isn't required anyways |
if env['build'] == 'release': |
env['PDB'] = '' |
if env['gcc']: |
env.Append(CCFLAGS = ['-fopenmp']) |
env.Append(LIBS = ['gomp']) |
# Load tools |
env.Tool('lex') |
env.Tool('yacc') |
if env['llvm']: |
env.Tool('llvm') |
# Custom builders and methods |
env.Tool('custom') |
createInstallMethods(env) |
env.PkgCheckModules('X11', ['x11', 'xext', 'xdamage', 'xfixes']) |
env.PkgCheckModules('XCB', ['x11-xcb', 'xcb-glx >= 1.8.1']) |
env.PkgCheckModules('XF86VIDMODE', ['xxf86vm']) |
env.PkgCheckModules('DRM', ['libdrm >= 2.4.24']) |
env.PkgCheckModules('DRM_INTEL', ['libdrm_intel >= 2.4.30']) |
env.PkgCheckModules('XORG', ['xorg-server >= 1.6.0']) |
env.PkgCheckModules('KMS', ['libkms >= 2.4.24']) |
env.PkgCheckModules('UDEV', ['libudev > 150']) |
env['dri'] = env['x11'] and env['drm'] |
# for debugging |
#print env.Dump() |
def exists(env): |
return 1 |
/contrib/sdk/sources/Mesa/scons/llvm.py |
---|
0,0 → 1,222 |
"""llvm |
Tool-specific initialization for LLVM |
""" |
# |
# Copyright (c) 2009 VMware, Inc. |
# |
# 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. |
# |
import os |
import os.path |
import re |
import sys |
import distutils.version |
import SCons.Errors |
import SCons.Util |
def generate(env): |
env['llvm'] = False |
try: |
llvm_dir = os.environ['LLVM'] |
except KeyError: |
# Do nothing -- use the system headers/libs |
llvm_dir = None |
else: |
if not os.path.isdir(llvm_dir): |
raise SCons.Errors.InternalError, "Specified LLVM directory not found" |
if env['debug']: |
llvm_subdir = 'Debug' |
else: |
llvm_subdir = 'Release' |
llvm_bin_dir = os.path.join(llvm_dir, llvm_subdir, 'bin') |
if not os.path.isdir(llvm_bin_dir): |
llvm_bin_dir = os.path.join(llvm_dir, 'bin') |
if not os.path.isdir(llvm_bin_dir): |
raise SCons.Errors.InternalError, "LLVM binary directory not found" |
env.PrependENVPath('PATH', llvm_bin_dir) |
if env['platform'] == 'windows': |
# XXX: There is no llvm-config on Windows, so assume a standard layout |
if llvm_dir is None: |
print 'scons: LLVM environment variable must be specified when building for windows' |
return |
# Try to determine the LLVM version from llvm/Config/config.h |
llvm_config = os.path.join(llvm_dir, 'include/llvm/Config/config.h') |
if not os.path.exists(llvm_config): |
print 'scons: could not find %s' % llvm_config |
return |
llvm_version_re = re.compile(r'^#define PACKAGE_VERSION "([^"]*)"') |
llvm_version = None |
for line in open(llvm_config, 'rt'): |
mo = llvm_version_re.match(line) |
if mo: |
llvm_version = mo.group(1) |
llvm_version = distutils.version.LooseVersion(llvm_version) |
break |
if llvm_version is None: |
print 'scons: could not determine the LLVM version from %s' % llvm_config |
return |
env.Prepend(CPPPATH = [os.path.join(llvm_dir, 'include')]) |
env.AppendUnique(CPPDEFINES = [ |
'__STDC_LIMIT_MACROS', |
'__STDC_CONSTANT_MACROS', |
'HAVE_STDINT_H', |
]) |
env.Prepend(LIBPATH = [os.path.join(llvm_dir, 'lib')]) |
if llvm_version >= distutils.version.LooseVersion('3.2'): |
# 3.2 |
env.Prepend(LIBS = [ |
'LLVMBitWriter', 'LLVMX86Disassembler', 'LLVMX86AsmParser', |
'LLVMX86CodeGen', 'LLVMX86Desc', 'LLVMSelectionDAG', |
'LLVMAsmPrinter', 'LLVMMCParser', 'LLVMX86AsmPrinter', |
'LLVMX86Utils', 'LLVMX86Info', 'LLVMJIT', |
'LLVMExecutionEngine', 'LLVMCodeGen', 'LLVMScalarOpts', |
'LLVMInstCombine', 'LLVMTransformUtils', 'LLVMipa', |
'LLVMAnalysis', 'LLVMTarget', 'LLVMMC', 'LLVMCore', |
'LLVMSupport', 'LLVMRuntimeDyld', 'LLVMObject' |
]) |
elif llvm_version >= distutils.version.LooseVersion('3.0'): |
# 3.0 |
env.Prepend(LIBS = [ |
'LLVMBitWriter', 'LLVMX86Disassembler', 'LLVMX86AsmParser', |
'LLVMX86CodeGen', 'LLVMX86Desc', 'LLVMSelectionDAG', |
'LLVMAsmPrinter', 'LLVMMCParser', 'LLVMX86AsmPrinter', |
'LLVMX86Utils', 'LLVMX86Info', 'LLVMJIT', |
'LLVMExecutionEngine', 'LLVMCodeGen', 'LLVMScalarOpts', |
'LLVMInstCombine', 'LLVMTransformUtils', 'LLVMipa', |
'LLVMAnalysis', 'LLVMTarget', 'LLVMMC', 'LLVMCore', |
'LLVMSupport' |
]) |
elif llvm_version >= distutils.version.LooseVersion('2.9'): |
# 2.9 |
env.Prepend(LIBS = [ |
'LLVMObject', 'LLVMMCJIT', 'LLVMMCDisassembler', |
'LLVMLinker', 'LLVMipo', 'LLVMInterpreter', |
'LLVMInstrumentation', 'LLVMJIT', 'LLVMExecutionEngine', |
'LLVMBitWriter', 'LLVMX86Disassembler', 'LLVMX86AsmParser', |
'LLVMMCParser', 'LLVMX86AsmPrinter', 'LLVMX86CodeGen', |
'LLVMSelectionDAG', 'LLVMX86Utils', 'LLVMX86Info', 'LLVMAsmPrinter', |
'LLVMCodeGen', 'LLVMScalarOpts', 'LLVMInstCombine', |
'LLVMTransformUtils', 'LLVMipa', 'LLVMAsmParser', |
'LLVMArchive', 'LLVMBitReader', 'LLVMAnalysis', 'LLVMTarget', |
'LLVMCore', 'LLVMMC', 'LLVMSupport', |
]) |
elif llvm_version >= distutils.version.LooseVersion('2.7'): |
# 2.7 |
env.Prepend(LIBS = [ |
'LLVMLinker', 'LLVMipo', 'LLVMInterpreter', |
'LLVMInstrumentation', 'LLVMJIT', 'LLVMExecutionEngine', |
'LLVMBitWriter', 'LLVMX86Disassembler', 'LLVMX86AsmParser', |
'LLVMMCParser', 'LLVMX86AsmPrinter', 'LLVMX86CodeGen', |
'LLVMSelectionDAG', 'LLVMX86Info', 'LLVMAsmPrinter', |
'LLVMCodeGen', 'LLVMScalarOpts', 'LLVMInstCombine', |
'LLVMTransformUtils', 'LLVMipa', 'LLVMAsmParser', |
'LLVMArchive', 'LLVMBitReader', 'LLVMAnalysis', 'LLVMTarget', |
'LLVMMC', 'LLVMCore', 'LLVMSupport', 'LLVMSystem', |
]) |
else: |
# 2.6 |
env.Prepend(LIBS = [ |
'LLVMX86AsmParser', 'LLVMX86AsmPrinter', 'LLVMX86CodeGen', |
'LLVMX86Info', 'LLVMLinker', 'LLVMipo', 'LLVMInterpreter', |
'LLVMInstrumentation', 'LLVMJIT', 'LLVMExecutionEngine', |
'LLVMDebugger', 'LLVMBitWriter', 'LLVMAsmParser', |
'LLVMArchive', 'LLVMBitReader', 'LLVMSelectionDAG', |
'LLVMAsmPrinter', 'LLVMCodeGen', 'LLVMScalarOpts', |
'LLVMTransformUtils', 'LLVMipa', 'LLVMAnalysis', |
'LLVMTarget', 'LLVMMC', 'LLVMCore', 'LLVMSupport', |
'LLVMSystem', |
]) |
env.Append(LIBS = [ |
'imagehlp', |
'psapi', |
'shell32', |
'advapi32' |
]) |
if env['msvc']: |
# Some of the LLVM C headers use the inline keyword without |
# defining it. |
env.Append(CPPDEFINES = [('inline', '__inline')]) |
if env['build'] in ('debug', 'checked'): |
# LLVM libraries are static, build with /MT, and they |
# automatically link agains LIBCMT. When we're doing a |
# debug build we'll be linking against LIBCMTD, so disable |
# that. |
env.Append(LINKFLAGS = ['/nodefaultlib:LIBCMT']) |
else: |
if not env.Detect('llvm-config'): |
print 'scons: llvm-config script not found' |
return |
llvm_version = env.backtick('llvm-config --version').rstrip() |
llvm_version = distutils.version.LooseVersion(llvm_version) |
try: |
# Treat --cppflags specially to prevent NDEBUG from disabling |
# assertion failures in debug builds. |
cppflags = env.ParseFlags('!llvm-config --cppflags') |
try: |
cppflags['CPPDEFINES'].remove('NDEBUG') |
except ValueError: |
pass |
env.MergeFlags(cppflags) |
components = ['engine', 'bitwriter', 'x86asmprinter'] |
if llvm_version >= distutils.version.LooseVersion('3.1'): |
components.append('mcjit') |
if llvm_version >= distutils.version.LooseVersion('3.2'): |
env.Append(CXXFLAGS = ('-fno-rtti',)) |
env.ParseConfig('llvm-config --libs ' + ' '.join(components)) |
env.ParseConfig('llvm-config --ldflags') |
except OSError: |
print 'scons: llvm-config version %s failed' % llvm_version |
return |
assert llvm_version is not None |
env['llvm'] = True |
print 'scons: Found LLVM version %s' % llvm_version |
env['LLVM_VERSION'] = llvm_version |
# Define HAVE_LLVM macro with the major/minor version number (e.g., 0x0206 for 2.6) |
llvm_version_major = int(llvm_version.version[0]) |
llvm_version_minor = int(llvm_version.version[1]) |
llvm_version_hex = '0x%02x%02x' % (llvm_version_major, llvm_version_minor) |
env.Prepend(CPPDEFINES = [('HAVE_LLVM', llvm_version_hex)]) |
def exists(env): |
return True |
# vim:set ts=4 sw=4 et: |
/contrib/sdk/sources/Mesa/scons/source_list.py |
---|
0,0 → 1,130 |
"""Source List Parser |
The syntax of a source list file is a very small subset of GNU Make. These |
features are supported |
operators: =, +=, := |
line continuation |
non-nested variable expansion |
comment |
The goal is to allow Makefile's and SConscript's to share source listing. |
""" |
class SourceListParser(object): |
def __init__(self): |
self.symbol_table = {} |
self._reset() |
def _reset(self, filename=None): |
self.filename = filename |
self.line_no = 1 |
self.line_cont = '' |
def _error(self, msg): |
raise RuntimeError('%s:%d: %s' % (self.filename, self.line_no, msg)) |
def _next_dereference(self, val, cur): |
"""Locate the next $(...) in value.""" |
deref_pos = val.find('$', cur) |
if deref_pos < 0: |
return (-1, -1) |
elif val[deref_pos + 1] != '(': |
self._error('non-variable dereference') |
deref_end = val.find(')', deref_pos + 2) |
if deref_end < 0: |
self._error('unterminated variable dereference') |
return (deref_pos, deref_end + 1) |
def _expand_value(self, val): |
"""Perform variable expansion.""" |
expanded = '' |
cur = 0 |
while True: |
deref_pos, deref_end = self._next_dereference(val, cur) |
if deref_pos < 0: |
expanded += val[cur:] |
break |
sym = val[(deref_pos + 2):(deref_end - 1)] |
expanded += val[cur:deref_pos] + self.symbol_table[sym] |
cur = deref_end |
return expanded |
def _parse_definition(self, line): |
"""Parse a variable definition line.""" |
op_pos = line.find('=') |
op_end = op_pos + 1 |
if op_pos < 0: |
self._error('not a variable definition') |
if op_pos > 0: |
if line[op_pos - 1] in [':', '+', '?']: |
op_pos -= 1 |
else: |
self._error('only =, :=, and += are supported') |
# set op, sym, and val |
op = line[op_pos:op_end] |
sym = line[:op_pos].strip() |
val = self._expand_value(line[op_end:].lstrip()) |
if op in ('=', ':='): |
self.symbol_table[sym] = val |
elif op == '+=': |
self.symbol_table[sym] += ' ' + val |
elif op == '?=': |
if sym not in self.symbol_table: |
self.symbol_table[sym] = val |
def _parse_line(self, line): |
"""Parse a source list line.""" |
# more lines to come |
if line and line[-1] == '\\': |
# spaces around "\\\n" are replaced by a single space |
if self.line_cont: |
self.line_cont += line[:-1].strip() + ' ' |
else: |
self.line_cont = line[:-1].rstrip() + ' ' |
return 0 |
# combine with previous lines |
if self.line_cont: |
line = self.line_cont + line.lstrip() |
self.line_cont = '' |
if line: |
begins_with_tab = (line[0] == '\t') |
line = line.lstrip() |
if line[0] != '#': |
if begins_with_tab: |
self._error('recipe line not supported') |
else: |
self._parse_definition(line) |
return 1 |
def parse(self, filename): |
"""Parse a source list file.""" |
if self.filename != filename: |
fp = open(filename) |
lines = fp.read().splitlines() |
fp.close() |
try: |
self._reset(filename) |
for line in lines: |
self.line_no += self._parse_line(line) |
except: |
self._reset() |
raise |
return self.symbol_table |
def add_symbol(self, name, value): |
self.symbol_table[name] = value |
/contrib/sdk/sources/Mesa/scons/x11.py |
---|
0,0 → 1,52 |
"""x11 |
Tool-specific initialization for X11 |
""" |
# |
# Copyright (c) 2010 VMware, Inc. |
# |
# 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. |
# |
def generate(env): |
env.Append(CPPPATH = ['/usr/X11R6/include']) |
env.Append(LIBPATH = ['/usr/X11R6/lib']) |
env.Append(LIBS = [ |
'X11', |
'Xext', |
'Xxf86vm', |
'Xdamage', |
'Xfixes', |
]) |
def exists(env): |
# TODO: actually detect the presence of the headers |
if env['platform'] in ('linux', 'freebsd', 'darwin'): |
return True |
else: |
return False |
# vim:set ts=4 sw=4 et: |