Mesa (gallium-0.2): scons: Build progs.

Alan Hourihane alanh at kemper.freedesktop.org
Mon Dec 15 03:30:35 PST 2008


Module: Mesa
Branch: gallium-0.2
Commit: 500b304463bcc57af2cb01bb2f196c9c7dbbfa1d
URL:    http://cgit.freedesktop.org/mesa/mesa/commit/?id=500b304463bcc57af2cb01bb2f196c9c7dbbfa1d

Author: José Fonseca <jrfonseca at tungstengraphics.com>
Date:   Fri Dec 12 12:37:21 2008 +0900

scons: Build progs.

Just demos and trivial dirs for starters.

Conflicts:

	.gitignore

---

 .gitignore               |   14 ++-
 progs/SConscript         |    4 +
 progs/SConstruct         |   43 ++++
 progs/demos/SConscript   |   71 ++++++
 progs/trivial/SConscript |  163 ++++++++++++++
 scons/generic.py         |  531 ++++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 825 insertions(+), 1 deletions(-)

diff --git a/.gitignore b/.gitignore
index 5c91295..1c3d446 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,11 @@
 *.a
+*.dll
+*.exe
+*.ilk
 *.o
+*.obj
+*.pc
+*.pdb
 *.pyc
 *.pyo
 *.so
@@ -9,6 +15,12 @@ depend
 depend.bak
 lib
 lib64
-.sconsign*
+configure
+autom4te.cache
+aclocal.m4
+config.log
+config.status
+cscope*
+.scon*
 config.py
 build
diff --git a/progs/SConscript b/progs/SConscript
new file mode 100644
index 0000000..245fc26
--- /dev/null
+++ b/progs/SConscript
@@ -0,0 +1,4 @@
+SConscript([
+    'demos/SConscript',
+    'trivial/SConscript',
+])
diff --git a/progs/SConstruct b/progs/SConstruct
new file mode 100644
index 0000000..ac5314f
--- /dev/null
+++ b/progs/SConstruct
@@ -0,0 +1,43 @@
+import os
+import os.path
+import sys
+
+env = Environment(
+    tools = ['generic'],
+    toolpath = ['../scons'],
+    ENV = os.environ,
+)
+
+
+# Use Mesa's headers and libs
+if 0:
+    env.Append(CPPPATH = ['#../include'])
+    env.Append(LIBPATH = ['#../lib'])
+
+
+conf = Configure(env)
+
+# OpenGL
+if env['platform'] == 'windows':
+    env.Prepend(LIBS = ['glu32', 'opengl32'])
+else:
+    env.Prepend(LIBS = ['GLU', 'GL'])
+
+# Glut
+env['GLUT'] = False
+if conf.CheckCHeader('GL/glut.h'):
+    if env['platform'] == 'windows':
+        env['GLUT_LIB'] = 'glut32'
+    else:
+        env['GLUT_LIB'] = 'glut'
+    env['GLUT'] = True
+
+conf.Finish()
+
+
+Export('env')
+
+SConscript(
+    'SConscript',
+    duplicate = 0 # http://www.scons.org/doc/0.97/HTML/scons-user/x2261.html
+)
diff --git a/progs/demos/SConscript b/progs/demos/SConscript
new file mode 100644
index 0000000..112da7b
--- /dev/null
+++ b/progs/demos/SConscript
@@ -0,0 +1,71 @@
+Import('env')
+
+if not env['GLUT']:
+    Return()
+
+env = env.Clone()
+
+env.Prepend(LIBS = ['$GLUT_LIB'])
+
+progs = [
+	'arbfplight',
+	'arbfslight',
+	'arbocclude',
+	'bounce',
+	'clearspd',
+	'copypix',
+	'cubemap',
+	'drawpix',
+	'engine',
+	'fbo_firecube',
+	'fire',
+	'fogcoord',
+	'fplight',
+	'fslight',
+	'gamma',
+	'gearbox',
+	'gears',
+	'geartrain',
+	'glinfo',
+	'gloss',
+	'glslnoise',
+	'gltestperf',
+	'glutfx',
+	'isosurf',
+	'ipers',
+	'lodbias',
+	'morph3d',
+	'multiarb',
+	'paltex',
+	'pointblast',
+	'rain',
+	'ray',
+	'readpix',
+	'reflect',
+	'renormal',
+	'shadowtex',
+	'singlebuffer',
+	'streaming_rect',
+	'spectex',
+	'spriteblast',
+	'stex3d',
+	'teapot',
+	'terrain',
+	'tessdemo',
+	'texcyl',
+	'texdown',
+	'texenv',
+	'texobj',
+	'textures',
+	'trispd',
+	'tunnel',
+	'tunnel2',
+	'vao_demo',
+	'winpos',
+]
+
+for prog in progs:
+    prog = env.Program(
+        target = prog,
+        source = prog + '.c',
+    )
diff --git a/progs/trivial/SConscript b/progs/trivial/SConscript
new file mode 100644
index 0000000..edb8386
--- /dev/null
+++ b/progs/trivial/SConscript
@@ -0,0 +1,163 @@
+Import('env')
+
+if not env['GLUT']:
+    Return()
+
+env = env.Clone()
+
+env.Prepend(LIBS = ['$GLUT_LIB'])
+
+progs = [
+    'clear-fbo-tex',
+	'clear-fbo',
+	'clear-scissor',
+	'clear-undefined',
+	'clear-repeat',
+	'clear',
+	'dlist-dangling',
+	'dlist-edgeflag-dangling',
+	'dlist-edgeflag',
+	'dlist-degenerate',
+	'drawarrays',
+	'drawelements',
+	'drawrange',
+	'flat-clip',
+	'fs-tri',
+	'line-clip',
+	'line-cull',
+	'line-smooth',
+	'line-stipple-wide',
+	'line-userclip-clip',
+	'line-userclip-nop-clip',
+	'line-userclip-nop',
+	'line-userclip',
+	'line-wide',
+	'line',
+	'lineloop-clip',
+	'lineloop-elts',
+	'lineloop',
+	'linestrip-flat-stipple',
+	'linestrip-stipple-wide',
+	'linestrip-stipple',
+	'linestrip',
+	'long-fixed-func',
+	'pgon-mode',
+	'point-clip',
+	'point-param',
+	'point-sprite',
+	'point-wide',
+	'point-wide-smooth',
+	'point',
+	'poly-flat',
+	'poly-flat-clip',
+	'poly-flat-unfilled-clip',
+	'poly-unfilled',
+	'poly',
+	'quad-clip-all-vertices',
+	'quad-clip-nearplane',
+	'quad-clip',
+	'quad-degenerate',
+	'quad-flat',
+	'quad-offset-factor',
+	'quad-offset-unfilled',
+	'quad-offset-units',
+	'quad-tex-2d',
+	'quad-tex-3d',
+	'quad-tex-alpha',
+	'quad-tex-pbo',
+	'quad-unfilled-clip',
+	'quad-unfilled-stipple',
+	'quad-unfilled',
+	'quad',
+	'quads',
+	'quadstrip-cont',
+	'quadstrip-flat',
+	'quadstrip',
+	'tri-alpha',
+	'tri-blend-color',
+	'tri-blend-max',
+	'tri-blend-min',
+	'tri-blend-revsub',
+	'tri-blend-sub',
+	'tri-blend',
+	'tri-clip',
+	'tri-cull-both',
+	'tri-cull',
+	'tri-dlist',
+	'tri-edgeflag',
+	'tri-fbo-tex',
+	'tri-fbo',
+	'tri-flat-clip',
+	'tri-flat',
+	'tri-fog',
+	'tri-fp',
+	'tri-fp-const-imm',
+	'tri-lit',
+	'tri-mask-tri',
+	'tri-orig',
+	'tri-query',
+	'tri-repeat',
+	'tri-scissor-tri',
+	'tri-stencil',
+	'tri-tex',
+	'tri-tex-3d',
+	'tri-tri',
+	'tri-unfilled-edgeflag',
+	'tri-unfilled-clip',
+	'tri-unfilled-smooth',
+	'tri-unfilled-tri',
+	'tri-unfilled-tri-lit',
+	'tri-unfilled-userclip-stip',
+	'tri-unfilled-userclip',
+	'tri-unfilled',
+	'tri-userclip',
+	'tri-z-eq',
+	'tri-z',
+	'tri',
+	'trifan-flat',
+	'trifan-flat-clip',
+	'trifan-flat-unfilled-clip',
+	'trifan-unfilled',
+	'trifan',
+	'tristrip-clip',
+	'tristrip-flat',
+	'tristrip',
+	'vbo-drawarrays',
+	'vbo-drawelements',
+	'vbo-drawrange',
+	'vp-array',
+	'vp-array-int',
+	'vp-clip',
+	'vp-line-clip',
+	'vp-tri',
+	'vp-tri-swap',
+	'vp-tri-tex',
+	'vp-tri-imm',
+	'vp-tri-cb',
+	'vp-tri-cb-pos',
+	'vp-tri-cb-tex',
+	'vp-unfilled',
+]
+
+for prog in progs:
+    prog = env.Program(
+        target = prog,
+        source = prog + '.c',
+    )
+
+# auto code generation
+#getprocaddress: getprocaddress.c getproclist.h
+
+#getproclist.h: $(TOP)/src/mesa/glapi/gl_API.xml getprocaddress.c getprocaddress.py
+#	python getprocaddress.py > getproclist.h
+
+
+#readtex.h: $(TOP)/progs/util/readtex.h
+#	ln -s $(TOP)/progs/util/readtex.h .
+
+#readtex.c: $(TOP)/progs/util/readtex.c
+#	ln -s $(TOP)/progs/util/readtex.c .
+
+
+#extfuncs.h:  $(TOP)/progs/util/extfuncs.h
+#	cp $< .
diff --git a/scons/generic.py b/scons/generic.py
new file mode 100644
index 0000000..f0bb3de
--- /dev/null
+++ b/scons/generic.py
@@ -0,0 +1,531 @@
+"""generic
+
+Generic tool that provides a commmon ground for all platforms.
+
+"""
+
+#
+# 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 platform as _platform
+import sys
+
+import SCons.Action
+import SCons.Builder
+import SCons.Scanner
+
+
+def quietCommandLines(env):
+    # Quiet command lines
+    # See also http://www.scons.org/wiki/HidingCommandLinesInOutput
+    env['CCCOMSTR'] = "Compiling $SOURCE ..."
+    env['CXXCOMSTR'] = "Compiling $SOURCE ..."
+    env['ARCOMSTR'] = "Archiving $TARGET ..."
+    env['RANLIBCOMSTR'] = ""
+    env['LINKCOMSTR'] = "Linking $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'^import\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
+    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)
+    code = env.Command(target, source, command)
+
+    # 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 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_shared_library(env, source, version = ()):
+    source = str(source[0])
+    version = tuple(map(str, version))
+    target_dir =  os.path.join(env.Dir('#.').srcnode().abspath, env['build'], 'lib')
+    target_name = '.'.join((str(source),) + version)
+    last = env.InstallAs(os.path.join(target_dir, target_name), source)
+    while len(version):
+        version = version[:-1]
+        target_name = '.'.join((str(source),) + version)
+        action = SCons.Action.Action(symlink, "$TARGET -> $SOURCE")
+        last = env.Command(os.path.join(target_dir, target_name), last, action) 
+
+def createInstallMethods(env):
+    env.AddMethod(install_shared_library, 'InstallSharedLibrary')
+
+
+_platform_map = {
+    'linux2': 'linux',
+    'win32': 'windows',
+}
+
+
+_machine_map = {
+	'x86': 'x86',
+	'i386': 'x86',
+	'i486': 'x86',
+	'i586': 'x86',
+	'i686': 'x86',
+	'ppc': 'ppc',
+	'x86_64': 'x86_64',
+}
+
+
+_toolchain_map = {
+    'winddk': 'winddk',
+    'wince': 'wcesdk',
+}
+
+
+_bool_map = {
+    'y': 1, 
+    'yes': 1,
+    't': 1, 
+    'true': 1, 
+    '1': 1,
+    'on': 1,
+    'all': 1, 
+    'n': 0, 
+    'no': 0, 
+    'f': 0, 
+    'false': 0, 
+    '0': 0,
+    'off': 0,
+    'none': 0,
+}
+
+
+def generate(env):
+    """Common environment generation code"""
+
+    from SCons.Script import ARGUMENTS
+
+    # FIXME: this is already too late
+    #if env.get('quiet', False):
+    #    quietCommandLines(env)
+
+
+    # Platform
+    try:
+        env['platform'] = ARGUMENTS['platform']
+    except KeyError:
+        env['platform'] = _platform_map.get(sys.platform, sys.platform)
+
+    # Machine
+    try:
+        env['machine'] = ARGUMENTS['machine']
+    except KeyError:
+        env['machine'] = _machine_map.get(os.environ.get('PROCESSOR_ARCHITECTURE', _platform.machine()), 'generic')
+
+    # Toolchain
+    try:
+        env['toolchain'] = ARGUMENTS['toolchain']
+    except KeyError:
+        if env['platform'] in ('windows', 'winddk', 'wince') and sys.platform != 'win32':
+            env['toolchain'] = 'crossmingw'
+        else:
+            env['toolchain'] = _toolchain_map.get(env['platform'], 'default')
+    if env['toolchain'] == 'crossmingw' and env['machine'] not in ('generic', 'x86'):
+            env['machine'] = 'x86'
+
+    # Build type
+    env['debug'] = _bool_map[ARGUMENTS.get('debug', 'no')]
+    env['profile'] = _bool_map[ARGUMENTS.get('profile', 'no')]
+
+    # Put build output in a separate dir, which depends on the current
+    # configuration. See also http://www.scons.org/wiki/AdvancedBuildExample
+    try:
+        env['variant_dir'] = ARGUMENTS['variant_dir']
+    except KeyError:
+        build_topdir = 'build'
+        build_subdir = env['platform']
+        if env['machine'] != 'generic':
+            build_subdir += '-' + env['machine']
+        if env['debug']:
+            build_subdir += "-debug"
+        if env['profile']:
+            build_subdir += "-profile"
+        env['variant_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.VariantDir(env['variant_dir']
+    #env.SConsignFile(os.path.join(env['variant_dir'], '.sconsign'))
+
+    # Summary
+    print
+    print '  platform=%s' % env['platform']
+    print '  machine=%s' % env['machine']
+    print '  toolchain=%s' % env['toolchain']
+    print '  debug=%s' % ['no', 'yes'][env['debug']]
+    print '  profile=%s' % ['no', 'yes'][env['profile']]
+    #print '  variant_dir=%s' % env['variant_dir']
+    print
+
+    # Load tool chain
+    env.Tool(env['toolchain'])
+
+    # shortcuts
+    debug = env['debug']
+    machine = env['machine']
+    platform = env['platform']
+    x86 = env['machine'] == 'x86'
+    ppc = env['machine'] == 'ppc'
+    gcc = env['platform'] in ('linux', 'freebsd', 'darwin') or env['toolchain'] == 'crossmingw'
+    msvc = env['platform'] in ('windows', 'winddk', 'wince') and env['toolchain'] != 'crossmingw'
+
+    # C preprocessor options
+    cppdefines = []
+    if debug:
+        cppdefines += ['DEBUG']
+    else:
+        cppdefines += ['NDEBUG']
+    if env['profile']:
+        cppdefines += ['PROFILE']
+    if platform == 'windows':
+        cppdefines += [
+            'WIN32',
+            '_WINDOWS',
+            #'_UNICODE',
+            #'UNICODE',
+            # http://msdn2.microsoft.com/en-us/library/6dwk3a1z.aspx,
+            'WIN32_LEAN_AND_MEAN',
+            'VC_EXTRALEAN',
+            '_CRT_SECURE_NO_DEPRECATE',
+        ]
+        if debug:
+            cppdefines += ['_DEBUG']
+    if platform == 'winddk':
+        # Mimic WINDDK's builtin flags. See also:
+        # - WINDDK's bin/makefile.new i386mk.inc for more info.
+        # - buildchk_wxp_x86.log files, generated by the WINDDK's build
+        # - http://alter.org.ua/docs/nt_kernel/vc8_proj/
+        cppdefines += [
+            ('_X86_', '1'),
+            ('i386', '1'),
+            'STD_CALL',
+            ('CONDITION_HANDLING', '1'),
+            ('NT_INST', '0'),
+            ('WIN32', '100'),
+            ('_NT1X_', '100'),
+            ('WINNT', '1'),
+            ('_WIN32_WINNT', '0x0501'), # minimum required OS version
+            ('WINVER', '0x0501'),
+            ('_WIN32_IE', '0x0603'),
+            ('WIN32_LEAN_AND_MEAN', '1'),
+            ('DEVL', '1'),
+            ('__BUILDMACHINE__', 'WinDDK'),
+            ('FPO', '0'),
+        ]
+        if debug:
+            cppdefines += [('DBG', 1)]
+    if platform == 'wince':
+        cppdefines += [
+            '_CRT_SECURE_NO_DEPRECATE',
+            '_USE_32BIT_TIME_T',
+            'UNICODE',
+            '_UNICODE',
+            ('UNDER_CE', '600'),
+            ('_WIN32_WCE', '0x600'),
+            'WINCEOEM',
+            'WINCEINTERNAL',
+            'WIN32',
+            'STRICT',
+            'x86',
+            '_X86_',
+            'INTERNATIONAL',
+            ('INTLMSG_CODEPAGE', '1252'),
+        ]
+    env.Append(CPPDEFINES = cppdefines)
+
+    # C preprocessor includes
+    if platform == 'winddk':
+        env.Append(CPPPATH = [
+            env['SDK_INC_PATH'],
+            env['DDK_INC_PATH'],
+            env['WDM_INC_PATH'],
+            env['CRT_INC_PATH'],
+        ])
+
+    # C compiler options
+    cflags = []
+    if gcc:
+        if debug:
+            cflags += ['-O0', '-g3']
+        else:
+            cflags += ['-O3', '-g0']
+        if env['profile']:
+            cflags += ['-pg']
+        if env['machine'] == 'x86':
+            cflags += [
+                '-m32',
+                #'-march=pentium4',
+                '-mmmx', '-msse', '-msse2', # enable SIMD intrinsics
+                #'-mfpmath=sse',
+            ]
+        if env['machine'] == 'x86_64':
+            cflags += ['-m64']
+        cflags += [
+            '-Wall',
+            '-Wmissing-prototypes',
+            '-Wno-long-long',
+            '-ffast-math',
+            '-pedantic',
+            '-fmessage-length=0', # be nice to Eclipse
+        ]
+    if msvc:
+        # See also:
+        # - http://msdn.microsoft.com/en-us/library/19z1t1wy.aspx
+        # - cl /?
+        if debug:
+            cflags += [
+              '/Od', # disable optimizations
+              '/Oi', # enable intrinsic functions
+              '/Oy-', # disable frame pointer omission
+            ]
+        else:
+            cflags += [
+              '/Ox', # maximum optimizations
+              '/Oi', # enable intrinsic functions
+              '/Ot', # favor code speed
+              #'/fp:fast', # fast floating point 
+            ]
+        if env['profile']:
+            cflags += [
+                '/Gh', # enable _penter hook function
+                '/GH', # enable _pexit hook function
+            ]
+        cflags += [
+            '/W3', # warning level
+            #'/Wp64', # enable 64 bit porting warnings
+        ]
+        if env['machine'] == 'x86':
+            cflags += [
+                #'/QIfist', # Suppress _ftol
+                #'/arch:SSE2', # use the SSE2 instructions
+            ]
+        if platform == 'windows':
+            cflags += [
+                # TODO
+            ]
+        if platform == 'winddk':
+            cflags += [
+                '/Zl', # omit default library name in .OBJ
+                '/Zp8', # 8bytes struct member alignment
+                '/Gy', # separate functions for linker
+                '/Gm-', # disable minimal rebuild
+                '/WX', # treat warnings as errors
+                '/Gz', # __stdcall Calling convention
+                '/GX-', # disable C++ EH
+                '/GR-', # disable C++ RTTI
+                '/GF', # enable read-only string pooling
+                '/G6', # optimize for PPro, P-II, P-III
+                '/Ze', # enable extensions
+                '/Gi-', # disable incremental compilation
+                '/QIfdiv-', # disable Pentium FDIV fix
+                '/hotpatch', # prepares an image for hotpatching.
+                #'/Z7', #enable old-style debug info
+            ]
+        if platform == 'wince':
+            # See also C:\WINCE600\public\common\oak\misc\makefile.def
+            cflags += [
+                '/Zl', # omit default library name in .OBJ
+                '/GF', # enable read-only string pooling
+                '/GR-', # disable C++ RTTI
+                '/GS', # enable security checks
+                # Allow disabling language conformance to maintain backward compat
+                #'/Zc:wchar_t-', # don't force wchar_t as native type, instead of typedef
+                #'/Zc:forScope-', # don't enforce Standard C++ for scoping rules
+                #'/wd4867',
+                #'/wd4430',
+                #'/MT',
+                #'/U_MT',
+            ]
+        # 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(CFLAGS = cflags)
+    env.Append(CXXFLAGS = cflags)
+
+    # Assembler options
+    if gcc:
+        if env['machine'] == 'x86':
+            env.Append(ASFLAGS = ['-m32'])
+        if env['machine'] == 'x86_64':
+            env.Append(ASFLAGS = ['-m64'])
+
+    # Linker options
+    linkflags = []
+    if gcc:
+        if env['machine'] == 'x86':
+            linkflags += ['-m32']
+        if env['machine'] == 'x86_64':
+            linkflags += ['-m64']
+    if platform == 'winddk':
+        # See also:
+        # - http://msdn2.microsoft.com/en-us/library/y0zzbyt4.aspx
+        linkflags += [
+            '/merge:_PAGE=PAGE',
+            '/merge:_TEXT=.text',
+            '/section:INIT,d',
+            '/opt:ref',
+            '/opt:icf',
+            '/ignore:4198,4010,4037,4039,4065,4070,4078,4087,4089,4221',
+            '/incremental:no',
+            '/fullbuild',
+            '/release',
+            '/nodefaultlib',
+            '/wx',
+            '/debug',
+            '/debugtype:cv',
+            '/version:5.1',
+            '/osversion:5.1',
+            '/functionpadmin:5',
+            '/safeseh',
+            '/pdbcompress',
+            '/stack:0x40000,0x1000',
+            '/driver',
+            '/align:0x80',
+            '/subsystem:native,5.01',
+            '/base:0x10000',
+
+            '/entry:DrvEnableDriver',
+        ]
+        if env['profile']:
+            linkflags += [
+                '/MAP', # http://msdn.microsoft.com/en-us/library/k7xkk3e2.aspx
+            ]
+    if platform == 'wince':
+        linkflags += [
+            '/nodefaultlib',
+            #'/incremental:no',
+            #'/fullbuild',
+            '/entry:_DllMainCRTStartup',
+        ]
+    env.Append(LINKFLAGS = linkflags)
+
+    # Default libs
+    env.Append(LIBS = [])
+
+    # Custom builders and methods
+    createConvenienceLibBuilder(env)
+    createCodeGenerateMethod(env)
+    createInstallMethods(env)
+
+    # for debugging
+    #print env.Dump()
+
+
+def exists(env):
+    return 1



More information about the mesa-commit mailing list