| /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: |