== SCons ==

* This commit is all of the rewrite work done on the SCons system. For
  documentation see doc/blender-scons.txt and doc/blender-scons-dev.txt.
  Also http://mediawiki.blender.org/index.php/BlenderDev/SconsRefactoring
  contains valuable information, along with what still needs to be done.

    - linux, os x and windows compile now.
    - files are compiled to BF_INSTALLDIR (see config/(platform)-config.py)
        - NOTE: Jean-Luc P will commit sometime during the weekend proper
          appit() for OS X. For now, copy the resulting binary to an
          existing .app bundle.
    - features:
        - cleaner structure for better maintenance
        - cleaner output during compile
        - better handling of build options
        - general overall speed increase
        - see the wiki for more info

  Cygwin, FreeBSD and Solaris systems still need work. For these systems:
    1) copy a config/(platform)-config.py to ie. config/cygwin-config.py
    2) set the proper defaults for your platform
    3) mail me at jesterking at letwory dot net with you configuration. if
       you need any modifications to the system, do send a patch, too.

  I'll be giving first-aid today and tomorrow, after that it'll be all
  regular development work :)

  /Nathan

5 files changed, 1138 insertions, 0 deletions

diff --git a/tools/Blender.py b/tools/Blender.py
new file mode 100644
index 00000000000..0da25350620
--- /dev/null
+++ b/tools/Blender.py
@@ -0,0 +1,323 @@
+#!/usr/bin/env python
+
+"""
+tools.BlenderEnvironment
+
+This environment builds on SCons.Script.SConscript.SConsEnvironment
+
+* library repository
+* custom printout
+* wrapper functions
+
+TODO: clean up and sanitise code - crosscheck with btools and SConstruct
+to kill any code duplication
+"""
+
+import os.path
+import string
+import glob
+import time
+import sys
+
+from SCons.Script.SConscript import SConsEnvironment
+import SCons.Action
+import SCons.Util
+import SCons.Builder
+import SCons.Tool
+import bcolors
+bc = bcolors.bcolors()
+
+Split = SCons.Util.Split
+Action = SCons.Action.Action
+Builder = SCons.Builder.Builder
+GetBuildPath = SConsEnvironment.GetBuildPath
+
+# a few globals
+root_build_dir = ''
+quickie = None # Anything else than None if BF_QUICK has been passed
+quicklist = [] # The list of libraries/programs to compile during a quickie
+program_list = [] # A list holding Nodes to final binaries, used to create installs
+arguments = None
+targets = None
+
+#some internals
+blenderdeps = [] # don't manipulate this one outside this module!
+
+##### LIB STUFF ##########
+
+possible_types = ['core'] # can be set in ie. SConstruct
+libs = {}
+def init_lib_dict():
+    for pt in possible_types:
+        libs[pt] = {}
+
+# helper func for add_lib_to_dict
+def internal_lib_to_dict(dict = None, libtype = None, libname = None, priority = 100):
+    if not libname in dict[libtype]:
+        done = None
+        while not done:
+            if dict[libtype].has_key(priority):
+                priority = priority + 1
+            else:
+                done = True
+        dict[libtype][priority] = libname
+
+# libtype and priority can both be lists, for defining lib in multiple places
+def add_lib_to_dict(dict = None, libtype = None, libname = None, priority = 100):
+    if not dict or not libtype or not libname:
+        print "Passed wrong arg"
+        Exit()
+
+    if type(libtype) is str and type(priority) is int:
+        internal_lib_to_dict(dict, libtype, libname, priority)
+    elif type(libtype) is list and type(priority) is list:
+        if len(libtype)==len(priority):
+            for lt, p in zip(libtype, priority):
+                internal_lib_to_dict(dict, lt, libname, p)
+        else:
+            print "libtype and priority lists are unequal in length"
+            Exit()
+    else:
+        print "Wrong type combinations for libtype and priority. Only str and int or list and list"
+        Exit()
+
+#libs = init_lib_dict(libs)
+
+def create_blender_liblist(lenv = None, libtype = None):
+    if not lenv or not libtype:
+        print "missing arg"
+
+    lst = []
+    if libtype in possible_types:
+        sortlist = []
+        for k,v in libs[libtype].iteritems():
+            sortlist.append(k)
+        sortlist.sort()
+        curlib = libs[libtype]
+        for sk in sortlist:
+            v = curlib[sk]
+        #for k,v in sorted(libs[libtype].iteritems()):
+            lst.append('#' + root_build_dir + 'lib/'+lenv['LIBPREFIX'] + v + lenv['LIBSUFFIX'])
+
+    return lst
+
+## TODO: static linking
+def setup_staticlibs(lenv):
+    statlibs = [
+        #here libs for static linking
+    ]
+    libincs = [
+        '/usr/lib',
+        lenv['BF_PYTHON_LIBPATH'],
+        lenv['BF_OPENGL_LIBPATH'],
+        lenv['BF_SDL_LIBPATH'],
+        lenv['BF_JPEG_LIBPATH'],
+        lenv['BF_TIFF_LIBPATH'],
+        lenv['BF_PNG_LIBPATH'],
+        lenv['BF_GETTEXT_LIBPATH'],
+        lenv['BF_ZLIB_LIBPATH'],
+        lenv['BF_OPENAL_LIBPATH'],
+        lenv['BF_FREETYPE_LIBPATH'],
+#        lenv['BF_QUICKTIME_LIBPATH'],
+        lenv['BF_ICONV_LIBPATH']
+        ]
+    libincs += Split(lenv['BF_OPENEXR_LIBPATH'])
+
+    return statlibs, libincs
+
+def setup_syslibs(lenv):
+    syslibs = [
+        lenv['BF_PYTHON_LIB'],
+        lenv['BF_JPEG_LIB'],
+        lenv['BF_PNG_LIB'],
+        lenv['BF_ZLIB_LIB'],
+        lenv['BF_OPENAL_LIB'],
+        lenv['BF_FREETYPE_LIB'],
+        lenv['BF_GETTEXT_LIB']
+
+        #here libs for linking
+        ]
+    if lenv['OURPLATFORM']=='win32vc':
+            syslibs += Split(lenv['BF_ICONV_LIB'])
+    syslibs += Split(lenv['BF_TIFF_LIB'])
+    syslibs += Split(lenv['BF_OPENEXR_LIB'])
+    syslibs += Split(lenv['BF_SDL_LIB'])
+    syslibs += Split(lenv['BF_OPENGL_LIB'])
+    syslibs += Split(lenv['LLIBS'])
+
+    return syslibs
+
+def propose_priorities():
+    print bc.OKBLUE+"Priorities:"+bc.ENDC
+    for t in possible_types:
+        print bc.OKGREEN+"\t"+t+bc.ENDC
+        new_priority = 0
+        sortlist = []
+        for k,v in libs[t].iteritems():
+            sortlist.append(k)
+        sortlist.sort()
+        curlib = libs[t]
+        for sk in sortlist:
+            v = curlib[sk]
+            #for p,v in sorted(libs[t].iteritems()):
+            print "\t\t",new_priority, v
+            new_priority += 5
+
+## TODO: see if this can be made in an emitter
+def buildinfo(lenv, build_type):
+    """
+    Generate a buildinfo object
+    """
+    build_date = time.strftime ("%Y-%m-%d")
+    build_time = time.strftime ("%H:%M:%S")
+    obj = []
+    if True: #user_options_dict['USE_BUILDINFO'] == 1:
+        if sys.platform=='win32':
+            build_info_file = open("source/creator/winbuildinfo.h", 'w')
+            build_info_file.write("char *build_date=\"%s\";\n"%build_date)
+            build_info_file.write("char *build_time=\"%s\";\n"%build_time)
+            build_info_file.write("char *build_platform=\"win32\";\n")
+            build_info_file.write("char *build_type=\"dynamic\";\n")
+            build_info_file.close()
+            lenv.Append (CPPDEFINES = ['NAN_BUILDINFO', 'BUILD_DATE'])
+        else:
+            lenv.Append (CPPDEFINES = ['BUILD_TIME=\'"%s"\''%(build_time),
+                                        'BUILD_DATE=\'"%s"\''%(build_date),
+                                        'BUILD_TYPE=\'"dynamic"\'',
+                                        'NAN_BUILDINFO',
+                                        'BUILD_PLATFORM=\'"%s"\''%(sys.platform)])
+        obj = [lenv.Object (root_build_dir+'source/creator/%s_buildinfo'%build_type,
+                        [root_build_dir+'source/creator/buildinfo.c'])]
+    return obj
+
+##### END LIB STUFF ############
+
+##### ACTION STUFF #############
+
+def my_compile_print(target, source, env):
+    a = '%s' % (source[0])
+    d, f = os.path.split(a)
+    return bc.OKBLUE+"Compiling"+bc.ENDC +" ==> '"+bc.OKGREEN+"%s" % (f) + "'"+bc.ENDC
+
+def my_moc_print(target, source, env):
+    a = '%s' % (source[0])
+    d, f = os.path.split(a)
+    return bc.OKBLUE+"Creating MOC"+bc.ENDC+ " ==> '"+bc.OKGREEN+"%s" %(f) + "'"+bc.ENDC
+
+def my_linking_print(target, source, env):
+    t = '%s' % (target[0])
+    d, f = os.path.split(t)
+    return bc.OKBLUE+"Linking library"+bc.ENDC +" ==> '"+bc.OKGREEN+"%s" % (f) + "'"+bc.ENDC
+
+def my_program_print(target, source, env):
+    t = '%s' % (target[0])
+    d, f = os.path.split(t)
+    return bc.OKBLUE+"Linking program"+bc.ENDC +" ==> '"+bc.OKGREEN+"%s" % (f) + "'"+bc.ENDC
+
+def msvc_hack(env):
+    static_lib = SCons.Tool.createStaticLibBuilder(env)
+    program = SCons.Tool.createProgBuilder(env)
+    
+    env['BUILDERS']['Library'] = static_lib
+    env['BUILDERS']['StaticLibrary'] = static_lib
+    env['BUILDERS']['Program'] = program
+        
+def set_quiet_output(env):
+    mycaction = Action("$CCCOM", strfunction=my_compile_print)
+    myshcaction = Action("$SHCCCOM", strfunction=my_compile_print)
+    mycppaction = Action("$CXXCOM", strfunction=my_compile_print)
+    myshcppaction = Action("$SHCXXCOM", strfunction=my_compile_print)
+    mylibaction = Action("$ARCOM", strfunction=my_linking_print)
+    mylinkaction = Action("$LINKCOM", strfunction=my_program_print)
+
+    static_ob, shared_ob = SCons.Tool.createObjBuilders(env)
+    static_ob.add_action('.c', mycaction)
+    static_ob.add_action('.cpp', mycppaction)
+    shared_ob.add_action('.c', myshcaction)
+    shared_ob.add_action('.cpp', myshcppaction)
+
+    static_lib = SCons.Builder.Builder(action = mylibaction,
+                                       emitter = '$LIBEMITTER',
+                                       prefix = '$LIBPREFIX',
+                                       suffix = '$LIBSUFFIX',
+                                       src_suffix = '$OBJSUFFIX',
+                                       src_builder = 'StaticObject')
+
+    program = SCons.Builder.Builder(action = mylinkaction,
+                                    emitter = '$PROGEMITTER',
+                                    prefix = '$PROGPREFIX',
+                                    suffix = '$PROGSUFFIX',
+                                    src_suffix = '$OBJSUFFIX',
+                                    src_builder = 'Object',
+                                    target_scanner = SCons.Defaults.ProgScan)
+
+    env['BUILDERS']['Object'] = static_ob
+    env['BUILDERS']['StaticObject'] = static_ob
+    env['BUILDERS']['StaticLibrary'] = static_lib
+    env['BUILDERS']['Library'] = static_lib
+    env['BUILDERS']['Program'] = program
+
+
+#### END ACTION STUFF #########
+
+class BlenderEnvironment(SConsEnvironment):
+
+    def BlenderLib(self=None, libname=None, sources=None, includes=[], defines=[], libtype='common', priority = 100, compileflags=None):
+        if not self or not libname or not sources:
+            print bc.FAIL+'Cannot continue. Missing argument for BuildBlenderLib '+libname+bc.ENDC
+            Exit()
+        if libname in quickie or len(quickie)==0:
+            print bc.HEADER+'Configuring library '+bc.ENDC+bc.OKGREEN+libname+bc.ENDC
+            lenv = self.Copy()
+            lenv.Append(CPPPATH=includes)
+            lenv.Append(CPPDEFINES=defines)
+            if lenv['WITH_BF_GAMEENGINE']:
+                    lenv.Append(CPPDEFINES=['GAMEBLENDER=1'])
+            if lenv['BF_DEBUG']:
+                    lenv.Append(CCFLAGS = lenv['BF_DEBUG_FLAGS'], CXXFLAGS = lenv['BF_DEBUG_FLAGS'])
+            if lenv['BF_PROFILE']:
+                    lenv.Append(CCFLAGS = lenv['BF_PROFILE_FLAGS'], CXXFLAGS = lenv['BF_PROFILE_FLAGS'])
+            if compileflags:
+                lenv.Append(CCFLAGS = compileflags)
+                lenv.Append(CXXFLAGS = compileflags)
+            lib = lenv.Library(target= '#'+root_build_dir+'lib/'+libname, source=sources)
+            SConsEnvironment.Default(self, lib) # we add to default target, because this way we get some kind of progress info during build
+        else:
+            print bc.WARNING+'Not building '+bc.ENDC+bc.OKGREEN+libname+bc.ENDC+' for '+bc.OKBLUE+'BF_QUICK'+bc.ENDC
+        # note: libs is a global
+        add_lib_to_dict(libs, libtype, libname, priority)
+
+    def BlenderProg(self=None, builddir=None, progname=None, sources=None, includes=None, libs=None, libpath=None):
+        print bc.HEADER+'Configuring program '+bc.ENDC+bc.OKGREEN+progname+bc.ENDC
+        lenv = self.Copy()
+        if lenv['OURPLATFORM']=='win32-vc':
+            lenv.Append(LINKFLAGS = Split(lenv['PLATFORM_LINKFLAGS']))
+        if  lenv['OURPLATFORM']=='darwin':
+            lenv.Append(LINKFLAGS = lenv['PLATFORM_LINKFLAGS'])
+            lenv.Append(LINKFLAGS = lenv['BF_PYTHON_LINKFLAGS'])
+            lenv.Append(LINKFLAGS = lenv['BF_OPENGL_LINKFLAGS'])
+        lenv.Append(CPPPATH=includes)
+        lenv.Append(LIBPATH=libpath)
+        lenv.Append(LIBS=libs)
+        if lenv['WITH_BF_QUICKTIME']:
+             lenv.Append(LIBS = lenv['BF_QUICKTIME_LIB'])
+             lenv.Append(LIBPATH = lenv['BF_QUICKTIME_LIBPATH'])
+        prog = lenv.Program(target=builddir+'bin/'+progname, source=sources)
+        SConsEnvironment.Default(self, prog)
+        program_list.append(prog)
+
+## TODO: have register for libs/programs, so that we test only that
+#  which have expressed their need to be tested in their own sconscript
+    def BlenderUnitTest(env, source, **kwargs):
+        test = env.Program(source, **kwargs)
+        env.AddPostAction(test, test[0].abspath)
+        env.Alias('check', test)
+        env.AlwaysBuild(test)
+        return test
+
+    def Glob(lenv, pattern):
+        path = string.replace(GetBuildPath(lenv,'SConscript'),'SConscript', '')
+        files = []
+        for i in glob.glob(path + pattern):
+            files.append(string.replace(i, path, ''))
+        return files
diff --git a/tools/bcolors.py b/tools/bcolors.py
new file mode 100755
index 00000000000..b01bb781524
--- /dev/null
+++ b/tools/bcolors.py
@@ -0,0 +1,16 @@
+class bcolors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+
+    def disable(self):
+        self.HEADER = ''
+        self.OKBLUE = ''
+        self.OKGREEN = ''
+        self.WARNING = ''
+        self.FAIL = ''
+        self.ENDC = ''
+
diff --git a/tools/btools.py b/tools/btools.py
new file mode 100755
index 00000000000..fbfe7885499
--- /dev/null
+++ b/tools/btools.py
@@ -0,0 +1,257 @@
+import sys
+import StringIO
+import SCons.Options
+import SCons.Options.BoolOption
+
+Options = SCons.Options
+BoolOption = SCons.Options.BoolOption
+
+def print_arguments(args, bc):
+    if len(args):
+        for k,v in args.iteritems():
+            print '\t'+bc.OKBLUE+k+bc.ENDC+' = '+bc.OKGREEN + v + bc.ENDC
+    else:
+        print '\t'+bc.WARNING+'No  command-line arguments given'+bc.ENDC
+
+def validate_arguments(args, bc):
+    opts_list = [
+            'BF_PYTHON', 'BF_PYTHON_VERSION', 'BF_PYTHON_INC', 'BF_PYTHON_BINARY', 'BF_PYTHON_LIB', 'BF_PYTHON_LIBPATH', 'BF_PYTHON_LINKFLAGS',
+            'WITH_BF_OPENAL', 'BF_OPENAL', 'BF_OPENAL_INC', 'BF_OPENAL_LIB', 'BF_OPENAL_LIBPATH',
+            'WITH_BF_SDL', 'BF_SDL', 'BF_SDL_INC', 'BF_SDL_LIB', 'BF_SDL_LIBPATH',
+            'WITH_BF_FMOD',
+            'WITH_BF_OPENEXR', 'BF_OPENEXR', 'BF_OPENEXR_INC', 'BF_OPENEXR_LIB', 'BF_OPENEXR_LIBPATH',
+            'WITH_BF_JPEG', 'BF_JPEG', 'BF_JPEG_INC', 'BF_JPEG_LIB', 'BF_JPEG_LIBPATH',
+            'WITH_BF_PNG', 'BF_PNG', 'BF_PNG_INC', 'BF_PNG_LIB', 'BF_PNG_LIBPATH',
+            'WITH_BF_TIFF', 'BF_TIFF', 'BF_TIFF_INC', 'BF_TIFF_LIB', 'BF_TIFF_LIBPATH',
+            'WITH_BF_ZLIB', 'BF_ZLIB', 'BF_ZLIB_INC', 'BF_ZLIB_LIB', 'BF_ZLIB_LIBPATH',
+            'WITH_BF_GETTEXT', 'BF_GETTEXT', 'BF_GETTEXT_INC', 'BF_GETTEXT_LIB', 'BF_GETTEXT_LIBPATH',
+            'WITH_BF_ICONV', 'BF_ICONV', 'BF_ICONV_INC', 'BF_ICONV_LIB', 'BF_ICONV_LIBPATH',
+            'WITH_BF_ODE', 'BF_ODE', 'BF_ODE_INC', 'BF_ODE_LIB',
+            'WITH_BF_GAMEENGINE', 'WITH_BF_BULLET', 'BF_BULLET', 'BF_BULLET_INC', 'BF_BULLET_LIB',
+            'BF_SOLID', 'BF_SOLID_INC',
+            'WITH_BF_FREETYPE', 'BF_FREETYPE', 'BF_FREETYPE_INC', 'BF_FREETYPE_LIB', 'BF_FREETYPE_LIBPATH',
+            'WITH_BF_QUICKTIME', 'BF_QUICKTIME', 'BF_QUICKTIME_INC', 'BF_QUICKTIME_LIB', 'BF_QUICKTIME_LIBPATH',
+            'WITH_BF_OPENGL', 'BF_OPENGL', 'BF_OPENGL_INC', 'BF_OPENGL_LIB', 'BF_OPENGL_LIBPATH', 'BF_OPENGL_LIB_STATIC', 'BF_OPENGL_LINKFLAGS',
+            'WITH_BF_FTGL', 'BF_FTGL', 'BF_FTGL_INC', 'BF_FTGL_LIB',
+            'WITH_BF_PLAYER',
+            'CFLAGS', 'CCFLAGS', 'CPPFLAGS',
+            'REL_CFLAGS', 'REL_CCFLAGS',
+            'C_WARN', 'CC_WARN', 'LLIBS', 'PLATFORM_LINKFLAGS',
+            'BF_PROFILE_FLAGS' ]
+    arg_list = ['BF_DEBUG', 'BF_QUIET', 'BF_CROSS', 'BF_UPDATE',
+            'BF_INSTALLDIR', 'BF_TOOLSET', 'BF_BINNAME',
+            'BF_BUILDDIR', 'BF_FANCY', 'BF_QUICK', 'BF_PROFILE', 'BF_DEBUG',
+            'BF_PRIORITYLIST'
+           ]
+
+    all_list = opts_list + arg_list
+    okdict = {}
+
+    for k,v in args.iteritems():
+        if k in all_list:
+            okdict[k] = v
+        else:
+            print '\t'+bc.WARNING+'Invalid argument: '+bc.ENDC+k+'='+v
+
+    return okdict
+
+def print_targets(targs, bc):
+    if len(targs)>0:
+        for t in targs:
+            print '\t'+bc.OKBLUE+t+bc.ENDC
+    else:
+        print '\t'+bc.WARNING+'No targets given, using '+bc.ENDC+bc.OKGREEN+'default'+bc.ENDC
+
+def validate_targets(targs, bc):
+    valid_list = ['.', 'blender', 'blenderstatic', 'blenderplayer', 'webplugin',
+            'blendernogame', 'blenderstaticnogame', 'release',
+            'everything', 'clean', 'install-bin', 'install']
+    oklist = []
+    for t in targs:
+        if t in valid_list:
+            oklist.append(t)
+        else:
+            print '\t'+bc.WARNING+'Invalid target: '+bc.ENDC+t
+    return oklist
+
+    
+
+class idBuffering:
+    def buffered_spawn( self, sh, escape, cmd, args, env ):
+        stderr = StringIO.StringIO()
+        stdout = StringIO.StringIO()
+        command_string = ''
+        for i in args:
+            if ( len( command_string ) ):
+                command_string += ' '
+            command_string += i
+        try:
+            retval = self.env['PSPAWN']( sh, escape, cmd, args, env, stdout, stderr )
+        except OSError, x:
+            if x.errno != 10:
+                raise x
+            print 'OSError ignored on command: %s' % command_string
+            retval = 0
+        sys.stdout.write( stdout.getvalue() )
+        sys.stderr.write( stderr.getvalue() )
+        return retval
+
+# get a clean error output when running multiple jobs
+def SetupBufferedOutput( env ):
+    buf = idBuffering()
+    buf.env = env
+    env['SPAWN'] = buf.buffered_spawn
+
+
+def read_opts(cfg, args):
+    localopts = Options.Options(cfg, args)
+    localopts.AddOptions(
+        ('BF_PYTHON', 'base path for python', ''),
+        ('BF_PYTHON_VERSION', 'Python version to use', ''),
+        ('BF_PYTHON_INC', 'include path for Python headers', ''),
+        ('BF_PYTHON_BINARY', 'Path to the Python interpreter', ''),
+        ('BF_PYTHON_LIB', 'Python library', ''),
+        ('BF_PYTHON_LIBPATH', 'Library path', ''),
+        ('BF_PYTHON_LINKFLAGS', 'Python link flags', ''),
+
+        (BoolOption('WITH_BF_OPENAL', 'Use OpenAL if true', '')),
+        ('BF_OPENAL', 'base path for OpenAL', ''),
+        ('BF_OPENAL_INC', 'include path for python headers', ''),
+        ('BF_OPENAL_LIB', 'Path to OpenAL library', ''),
+        ('BF_OPENAL_LIBPATH', 'Path to OpenAL library', ''),
+
+        (BoolOption('WITH_BF_SDL', 'Use SDL if true', '')),
+        ('BF_SDL', 'SDL base path', ''),
+        ('BF_SDL_INC', 'SDL include path', ''),     #$(shell $(BF_SDL)/bin/sdl-config --cflags)
+        ('BF_SDL_LIB', 'SDL library', ''),      #$(shell $(BF_SDL)/bin/sdl-config --libs) -lSDL_mixer
+        ('BF_SDL_LIBPATH', 'SDL library path', ''),
+
+        (BoolOption('WITH_BF_FMOD', 'Use FMOD if true', 'false')),
+        #  BF_FMOD = $(LCGDIR)/fmod
+
+        (BoolOption('WITH_BF_OPENEXR', 'Use OPENEXR if true', 'true')),
+        ('BF_OPENEXR', 'OPENEXR base path', ''),
+        ('BF_OPENEXR_INC', 'OPENEXR include path', ''),
+        ('BF_OPENEXR_LIB', 'OPENEXR library', ''),
+        ('BF_OPENEXR_LIBPATH', 'OPENEXR library path', ''),
+
+        (BoolOption('WITH_BF_JPEG', 'Use JPEG if true', 'true')),
+        ('BF_JPEG', 'JPEG base path', ''),
+        ('BF_JPEG_INC', 'JPEG include path', ''),
+        ('BF_JPEG_LIB', 'JPEG library', ''),
+        ('BF_JPEG_LIBPATH', 'JPEG library path', ''),
+
+        (BoolOption('WITH_BF_PNG', 'Use PNG if true', 'true')),
+        ('BF_PNG', 'PNG base path', ''),
+        ('BF_PNG_INC', 'PNG include path', ''),
+        ('BF_PNG_LIB', 'PNG library', ''),
+        ('BF_PNG_LIBPATH', 'PNG library path', ''),
+
+        (BoolOption('WITH_BF_TIFF', 'Use TIFF if true', 'true')),
+        ('BF_TIFF', 'TIFF base path', ''),
+        ('BF_TIFF_INC', 'TIFF include path', ''),
+        ('BF_TIFF_LIB', 'TIFF library', ''),
+        ('BF_TIFF_LIBPATH', 'TIFF library path', ''),
+
+        (BoolOption('WITH_BF_ZLIB', 'Use ZLib if true', 'true')),
+        ('BF_ZLIB', 'ZLib base path', ''),
+        ('BF_ZLIB_INC', 'ZLib include path', ''),
+        ('BF_ZLIB_LIB', 'ZLib library', ''),
+        ('BF_ZLIB_LIBPATH', 'ZLib library path', ''),
+
+        (BoolOption('WITH_BF_GETTEXT', 'Use gettext if true', 'true')),
+        ('BF_GETTEXT', 'gettext base path', ''),
+        ('BF_GETTEXT_INC', 'gettext include path', ''),
+        ('BF_GETTEXT_LIB', 'gettext library', ''),
+        ('BF_GETTEXT_LIBPATH', 'gettext library path', ''),
+        
+        (BoolOption('WITH_BF_ICONV', 'Use iconv if true', 'true')),
+        ('BF_ICONV', 'iconv base path', ''),
+        ('BF_ICONV_INC', 'iconv include path', ''),
+        ('BF_ICONV_LIB', 'iconv library', ''),
+        ('BF_ICONV_LIBPATH', 'iconv library path', ''),
+        
+        (BoolOption('WITH_BF_GAMEENGINE', 'Build with gameengine' , 'true')),
+
+        (BoolOption('WITH_BF_ODE', 'Use ODE if true', 'true')),
+        ('BF_ODE', 'ODE base path', ''),
+        ('BF_ODE_INC', 'ODE include path' , ''),
+        ('BF_ODE_LIB', 'ODE library', ''),
+
+        (BoolOption('WITH_BF_BULLET', 'Use Bullet if true', 'true')),
+        ('BF_BULLET', 'Bullet base dir', ''),
+        ('BF_BULLET_INC', 'Bullet include path', ''),
+        ('BF_BULLET_LIB', 'Bullet library', ''),
+        
+        ('BF_SOLID', 'Solid base dir', '#/extern/solid'),
+        ('BF_SOLID_INC', 'Solid include path', ''),
+##
+##WITH_BF_NSPR = 'true'
+##BF_NSPR = $(LCGDIR)/nspr
+##BF_NSPR_INC = -I$(BF_NSPR)/include -I$(BF_NSPR)/include/nspr
+##BF_NSPR_LIB = 
+### Uncomment the following line to use Mozilla inplace of netscape
+##CPPFLAGS += -DMOZ_NOT_NET
+### Location of MOZILLA/Netscape header files...
+##BF_MOZILLA = $(LCGDIR)/mozilla
+##BF_MOZILLA_INC = -I$(BF_MOZILLA)/include/mozilla/nspr -I$(BF_MOZILLA)/include/mozilla -I$(BF_MOZILLA)/include/mozilla/xpcom -I$(BF_MOZILLA)/include/mozilla/idl
+##BF_MOZILLA_LIB = 
+### Will fall back to look in BF_MOZILLA_INC/nspr and BF_MOZILLA_LIB
+### if this is not set.
+##
+### Be paranoid regarding library creation (do not update archives)
+##BF_PARANOID = 'true'
+##
+### enable freetype2 support for text objects
+        (BoolOption('WITH_BF_FREETYPE', 'Use Freetype if true', 'true')),
+        ('BF_FREETYPE', 'Freetype base path', ''),
+        ('BF_FREETYPE_INC', 'Freetype include path', ''),
+        ('BF_FREETYPE_LIB', 'Freetype library', ''),
+        ('BF_FREETYPE_LIBPATH', 'Freetype library path', ''),
+
+        (BoolOption('WITH_BF_QUICKTIME', 'Use QuickTime if true', 'false')),
+        ('BF_QUICKTIME', 'QuickTime base path', ''),
+        ('BF_QUICKTIME_INC', 'QuickTime include path', ''),
+        ('BF_QUICKTIME_LIB', 'QuickTime library', ''),
+        ('BF_QUICKTIME_LIBPATH', 'QuickTime library path', ''),
+
+        (BoolOption('WITH_BF_OPENGL', 'Use MESA if true', 'true')),
+        ('BF_OPENGL', 'OpenGL base path', ''),
+        ('BF_OPENGL_INC', 'OpenGL include path', ''),
+        ('BF_OPENGL_LIB', 'OpenGL libraries', ''),
+        ('BF_OPENGL_LIBPATH', 'OpenGL library path', ''),
+        ('BF_OPENGL_LIB_STATIC', 'OpenGL static libraries', ''),
+        ('BF_OPENGL_LINKFLAGS', 'OpenGL link flags', ''),
+        
+        (BoolOption('WITH_BF_FTGL', 'Use FTGL if true', 'true')),
+        ('BF_FTGL', 'FTGL base path', ''),
+        ('BF_FTGL_INC', 'FTGL include path', ''),
+        ('BF_FTGL_LIB', 'FTGL libraries', ''),
+
+        (BoolOption('WITH_BF_PLAYER', 'Build blenderplayer if true', 'false')),
+
+        ('CFLAGS', 'C-compiler flags', ''),
+        ('CCFLAGS', 'C++-compiler flags', ''),
+        ('CPPFLAGS', 'Defines', ''),
+        ('REL_CFLAGS', 'C release flags', ''),
+        ('REL_CCFLAGS', 'C++ release flags', ''),
+
+        ('C_WARN', 'C warning flags', ''),
+        ('CC_WARN', 'C++ warning flags', ''),
+
+        ('LLIBS', 'Platform libs', ''),
+        ('PLATFORM_LINKFLAGS', 'Platform linkflags', ''),
+
+        (BoolOption('BF_PROFILE', 'Add profiling information if true', 'false')),
+        ('BF_PROFILE_FLAGS', 'Profiling flags', ''),
+
+        (BoolOption('BF_DEBUG', 'Add debug flags if true', 'false')),
+        ('BF_DEBUG_FLAGS', 'Debug flags', ''),
+        
+        ('BF_BUILDDIR', 'Build dir', ''),
+        ('BF_INSTALLDIR', 'Installation dir', '')
+
+    ) # end of opts.AddOptions()
+
+    return localopts
+
diff --git a/tools/crossmingw.py b/tools/crossmingw.py
new file mode 100755
index 00000000000..1c8924ca7f6
--- /dev/null
+++ b/tools/crossmingw.py
@@ -0,0 +1,189 @@
+#coments are #JB where this file was altered by Jasen Betts
+# email:  'n@tres'.join(['jase','hna.com'])
+
+"""tools.crossmingw
+
+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.
+
+"""
+
+#
+# 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.
+#
+
+__revision__ = "/home/scons/scons/branch.0/branch.96/baseline/src/engine/SCons/Tool/mingw.py 0.96.91.D001 2005/09/08 09:14:36 knight"
+
+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:
+prefixes = SCons.Util.Split("""
+    mingw32-
+    i386-mingw32msvc-
+    i486-mingw32msvc-
+    i586-mingw32msvc-
+    i686-mingw32msvc-
+""")
+
+def find(env):
+    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)
+
+#JB  """ I'm blindly susbstuting lines from the mingw.py
+#JB      file becase these lines cause python errors here. """
+#JB shlib_action = SCons.Action.Action(shlib_generator,generator=1)
+shlib_action = SCons.Action.CommandGenerator(shlib_generator)
+
+res_action = SCons.Action.Action('$RCCOM', '$RCCOMSTR')
+
+#JB """ changed for what was in mingw.py """
+#JB res_builder = SCons.Builder.Builder(action=res_action, suffix='.o',
+#JB                                    source_scanner=SCons.Tool.SourceFileScanner)
+
+res_builder = SCons.Builder.Builder(action='$RCCOM', suffix='.o',
+                                    source_scanner=SCons.Defaults.ObjSourceScan)
+
+#JB  SCons.Tool.SourceFileScanner.add_scanner('.rc', SCons.Defaults.CScan)
+SCons.Defaults.ObjSourceScan.add_scanner('.rc', SCons.Defaults.CScan)
+#JB """ no more changes """
+
+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['AR'] = mingw_prefix + 'ar'
+    env['RANLIB'] = mingw_prefix + 'ranlib'
+    env.Append(SHLIBEMITTER = [shlib_emitter])
+    env['LINK'] = mingw_prefix + 'gcc'
+    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['RCINCFLAGS'] = '$( ${_concat(RCINCPREFIX, CPPPATH, RCINCSUFFIX, __env__, RDirs, TARGET)} $)'
+    env['RCINCPREFIX'] = '--include-dir '
+    env['RCINCSUFFIX'] = ''
+    env['RCCOM'] = '$RC $RCINCFLAGS $RCINCPREFIX $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['LIBPREFIX']      = 'lib'
+    env['LIBSUFFIX']      = '.a'
+    env['SHOBJPREFIX']    = '$OBJPREFIX'
+    env['SHOBJSUFFIX']    = '$OBJSUFFIX'
+    env['PROGPREFIX']     = ''
+    env['PROGSUFFIX']     = '.exe'
+    env['LIBPREFIX']      = ''
+    env['LIBSUFFIX']      = '.lib'
+    env['SHLIBPREFIX']    = ''
+    env['SHLIBSUFFIX']    = '.dll'
+    env['LIBPREFIXES']    = [ '$LIBPREFIX' ]
+    env['LIBSUFFIXES']    = [ '$LIBSUFFIX' ]
+
+def exists(env):
+    return find(env)
diff --git a/tools/mstoolkit.py b/tools/mstoolkit.py
new file mode 100755
index 00000000000..ed649080cab
--- /dev/null
+++ b/tools/mstoolkit.py
@@ -0,0 +1,353 @@
+"""tools.mstoolkit
+
+Tool-specific initialization for Microsoft Visual C/C++ Toolkit Commandline
+
+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.
+
+"""
+
+#
+# Copyright (c) 2004 John Connors
+#
+# 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.path
+import re
+import string
+import types
+
+import SCons.Action
+import SCons.Builder
+import SCons.Errors
+import SCons.Platform.win32
+import SCons.Tool
+import SCons.Util
+import SCons.Warnings
+
+CSuffixes = ['.c', '.C']
+CXXSuffixes = ['.cc', '.cpp', '.cxx', '.c++', '.C++']
+
+def get_msvctoolkit_paths():
+        """Return a 4-tuple of (INCLUDE, LIB, PATH, TOOLKIT) as the values of those
+        three environment variables that should be set in order to execute
+        the MSVC .NET tools properly, if the information wasn't available
+        from the registry."""
+
+        MSToolkitDir = None
+        paths = {}
+        exe_path = ''
+        lib_path = ''
+        include_path = ''
+
+        # First, we get the shell folder for this user:
+        if not SCons.Util.can_read_reg:
+                raise SCons.Errors.InternalError, "No Windows registry module was found"
+
+        # look for toolkit
+        if os.environ.has_key('VCToolkitInstallDir'):
+                MSToolkitDir = os.path.normpath(os.environ['VCToolkitInstallDir'])
+        else:
+                # last resort -- default install location
+                MSToolkitDir = r'C:\Program Files\Microsoft Visual C++ Toolkit 2003'
+
+        # look for platform sdk
+        if os.environ.has_key('MSSdk'):
+                PlatformSDKDir = os.path.normpath(os.environ['MSSdk'])
+        else:
+                try:
+                        PlatformSDKDir = SCons.Util.RegGetValue(SCons.Util.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\MicrosoftSDK\Directories\Install Dir')[0]
+                        PlatformSDKDir = str(PlatformSDKDir)
+                except SCons.Util.RegError:
+                        raise SCons.Errors.InternalError, "The Platform SDK directory was not found in the registry or in the `MSSdk` environment variable."
+
+        # look for DX Sdk (expecting DX9)
+        # dxsdk docs have a directory key, look for it, extract path
+        #dxsdkdocs = ""
+        DXsdkDir = ""
+        #try:
+        #        dxsdkdocs = SCons.Util.RegGetValue(SCons.Util.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\DirectX SDK\DX9SDK Doc Path')
+        #except SCons.Util.RegError:
+        #        raise SCons.Errors.InternalError, "The DXSDK directory was not found in the registry."
+        if os.environ.has_key('DXSDK_DIR'):
+                DXsdkDir = os.path.normpath(os.environ['DXSDK_DIR'])
+
+        #DXsdkDir = os.path.split(dxsdkdocs[0])[0]
+        DXsdkDir = os.path.split(DXsdkDir)[0]
+
+        include_path = r'%s\include;%s\include;%s\include' % (MSToolkitDir, PlatformSDKDir, DXsdkDir)
+        lib_path = r'%s\lib;%s\lib;%s\lib' % (MSToolkitDir, PlatformSDKDir, DXsdkDir)
+        exe_path = r'%s\bin;%s\bin\win95;%s\bin' % (MSToolkitDir, PlatformSDKDir, PlatformSDKDir)
+        return (include_path, lib_path, exe_path, PlatformSDKDir)
+
+def validate_vars(env):
+        """Validate the PDB, PCH, and PCHSTOP construction variables."""
+        if env.has_key('PCH') and env['PCH']:
+                if not env.has_key('PCHSTOP'):
+                        raise SCons.Errors.UserError, "The PCHSTOP construction must be defined if PCH is defined."
+                if not SCons.Util.is_String(env['PCHSTOP']):
+                        raise SCons.Errors.UserError, "The PCHSTOP construction variable must be a string: %r"%env['PCHSTOP']
+
+def pch_emitter(target, source, env):
+        """Sets up the PDB dependencies for a pch file, and adds the object
+        file target."""
+
+        validate_vars(env)
+
+        pch = None
+        obj = None
+
+        for t in target:
+                if SCons.Util.splitext(str(t))[1] == '.pch':
+                        pch = t
+                if SCons.Util.splitext(str(t))[1] == '.obj':
+                        obj = t
+
+        if not obj:
+                obj = SCons.Util.splitext(str(pch))[0]+'.obj'
+
+        target = [pch, obj] # pch must be first, and obj second for the PCHCOM to work
+
+        if env.has_key('PDB') and env['PDB']:
+                env.SideEffect(env['PDB'], target)
+                env.Precious(env['PDB'])
+
+        return (target, source)
+
+def object_emitter(target, source, env, parent_emitter):
+        """Sets up the PDB and PCH dependencies for an object file."""
+
+        validate_vars(env)
+
+        parent_emitter(target, source, env)
+
+        if env.has_key('PDB') and env['PDB']:
+                env.SideEffect(env['PDB'], target)
+                env.Precious(env['PDB'])
+
+        if env.has_key('PCH') and env['PCH']:
+                env.Depends(target, env['PCH'])
+
+        return (target, source)
+
+def static_object_emitter(target, source, env):
+        return object_emitter(target, source, env,
+                                                  SCons.Defaults.StaticObjectEmitter)
+
+def shared_object_emitter(target, source, env):
+        return object_emitter(target, source, env,
+                                                  SCons.Defaults.SharedObjectEmitter)
+
+pch_builder = SCons.Builder.Builder(action='$PCHCOM', suffix='.pch', emitter=pch_emitter)
+res_builder = SCons.Builder.Builder(action='$RCCOM', suffix='.res')
+
+def pdbGenerator(env, target, source, for_signature):
+        if target and env.has_key('PDB') and env['PDB']:
+                return ['/PDB:%s'%target[0].File(env['PDB']).get_string(for_signature),
+                                '/DEBUG']
+
+def win32ShlinkTargets(target, source, env, for_signature):
+        listCmd = []
+        dll = env.FindIxes(target, 'SHLIBPREFIX', 'SHLIBSUFFIX')
+        if dll: listCmd.append("/out:%s"%dll.get_string(for_signature))
+
+        implib = env.FindIxes(target, 'LIBPREFIX', 'LIBSUFFIX')
+        if implib: listCmd.append("/implib:%s"%implib.get_string(for_signature))
+
+        return listCmd
+
+def win32ShlinkSources(target, source, env, for_signature):
+        listCmd = []
+
+        deffile = env.FindIxes(source, "WIN32DEFPREFIX", "WIN32DEFSUFFIX")
+        for src in source:
+                if src == deffile:
+                        # Treat this source as a .def file.
+                        listCmd.append("/def:%s" % src.get_string(for_signature))
+                else:
+                        # Just treat it as a generic source file.
+                        listCmd.append(src)
+        return listCmd
+
+def win32LibEmitter(target, source, env):
+        # SCons.Tool.msvc.validate_vars(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 env.get("WIN32_INSERT_DEF", 0) and \
+           not env.FindIxes(source, "WIN32DEFPREFIX", "WIN32DEFSUFFIX"):
+
+                # append a def file to the list of sources
+                source.append(env.ReplaceIxes(dll,
+                                                                          "SHLIBPREFIX", "SHLIBSUFFIX",
+                                                                          "WIN32DEFPREFIX", "WIN32DEFSUFFIX"))
+
+        if env.has_key('PDB') and env['PDB']:
+                env.SideEffect(env['PDB'], target)
+                env.Precious(env['PDB'])
+
+        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"))
+                # and .exp file is created if there are exports from a DLL
+                target.append(env.ReplaceIxes(dll,
+                                                                          "SHLIBPREFIX", "SHLIBSUFFIX",
+                                                                          "WIN32EXPPREFIX", "WIN32EXPSUFFIX"))
+
+        return (target, source)
+
+def prog_emitter(target, source, env):
+        #SCons.Tool.msvc.validate_vars(env)
+
+        if env.has_key('PDB') and env['PDB']:
+                env.SideEffect(env['PDB'], target)
+                env.Precious(env['PDB'])
+
+        return (target,source)
+
+def RegServerFunc(target, source, env):
+        if env.has_key('register') and env['register']:
+                ret = regServerAction([target[0]], [source[0]], env)
+                if ret:
+                        raise SCons.Errors.UserError, "Unable to register %s" % target[0]
+                else:
+                        print "Registered %s sucessfully" % target[0]
+                return ret
+        return 0
+
+regServerAction = SCons.Action.Action("$REGSVRCOM")
+regServerCheck = SCons.Action.Action(RegServerFunc, None)
+shlibLinkAction = SCons.Action.Action('${TEMPFILE("$SHLINK $SHLINKFLAGS $_SHLINK_TARGETS $( $_LIBDIRFLAGS $) $_LIBFLAGS $_PDB $_SHLINK_SOURCES")}')
+compositeLinkAction = shlibLinkAction + regServerCheck
+
+def generate(env):
+        """Add Builders and construction variables for MSVC++ to an Environment."""
+        static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
+
+        for suffix in CSuffixes:
+                static_obj.add_action(suffix, SCons.Defaults.CAction)
+                shared_obj.add_action(suffix, SCons.Defaults.ShCAction)
+
+        for suffix in CXXSuffixes:
+                static_obj.add_action(suffix, SCons.Defaults.CXXAction)
+                shared_obj.add_action(suffix, SCons.Defaults.ShCXXAction)
+
+        SCons.Tool.createStaticLibBuilder(env)
+        SCons.Tool.createSharedLibBuilder(env)
+        SCons.Tool.createProgBuilder(env)
+
+        env['CCPDBFLAGS'] = SCons.Util.CLVar(['${(PDB and "/Zi /Fd%s"%File(PDB)) or ""}'])
+        env['CCPCHFLAGS'] = SCons.Util.CLVar(['${(PCH and "/Yu%s /Fp%s"%(PCHSTOP or "",File(PCH))) or ""}'])
+        env['CCCOMFLAGS'] = '$CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET $CCPCHFLAGS $CCPDBFLAGS'
+        env['CC']                 = 'cl'
+        env['CCFLAGS']    = SCons.Util.CLVar('/nologo')
+        env['CCCOM']      = '$CC $CCFLAGS $CCCOMFLAGS'
+        env['SHCC']               = '$CC'
+        env['SHCCFLAGS']  = SCons.Util.CLVar('$CCFLAGS')
+        env['SHCCCOM']    = '$SHCC $SHCCFLAGS $CCCOMFLAGS'
+        env['CXX']                = '$CC'
+        env['CXXFLAGS']   = SCons.Util.CLVar('$CCFLAGS $( /TP $)')
+        env['CXXCOM']     = '$CXX $CXXFLAGS $CCCOMFLAGS'
+        env['SHCXX']      = '$CXX'
+        env['SHCXXFLAGS'] = SCons.Util.CLVar('$CXXFLAGS')
+        env['SHCXXCOM']   = '$SHCXX $SHCXXFLAGS $CCCOMFLAGS'
+        env['CPPDEFPREFIX']  = '/D'
+        env['CPPDEFSUFFIX']  = ''
+        env['INCPREFIX']  = '/I'
+        env['INCSUFFIX']  = ''
+        env['OBJEMITTER'] = static_object_emitter
+        env['SHOBJEMITTER'] = shared_object_emitter
+        env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 1
+
+        env['RC'] = 'rc'
+        env['RCFLAGS'] = SCons.Util.CLVar('')
+        env['RCCOM'] = '$RC $_CPPDEFFLAGS $_CPPINCFLAGS $RCFLAGS /fo$TARGET $SOURCES'
+        CScan = env.get_scanner('.c')
+        if CScan:
+                CScan.add_skey('.rc')
+        env['BUILDERS']['RES'] = res_builder
+
+        include_path, lib_path, exe_path, sdk_path = get_msvctoolkit_paths()
+        env.PrependENVPath('INCLUDE', include_path)
+        env.PrependENVPath('LIB', lib_path)
+        env.PrependENVPath('PATH', exe_path)
+
+        env['ENV']['CPU'] = 'i386'
+        env['ENV']['MSSDK'] = sdk_path
+        env['ENV']['BkOffice'] = sdk_path
+        env['ENV']['Basemake'] = sdk_path + "\\Include\\BKOffice.Mak"
+        env['ENV']['INETSDK'] = sdk_path
+        env['ENV']['MSSDK'] = sdk_path
+        env['ENV']['MSTOOLS'] = sdk_path
+        env['ENV']['TARGETOS'] = 'WINNT'
+        env['ENV']['APPVER'] = '5.0'
+
+        env['CFILESUFFIX'] = '.c'
+        env['CXXFILESUFFIX'] = '.cc'
+
+        env['PCHCOM'] = '$CXX $CXXFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS /c $SOURCES /Fo${TARGETS[1]} /Yc$PCHSTOP /Fp${TARGETS[0]} $CCPDBFLAGS'
+        env['BUILDERS']['PCH'] = pch_builder
+
+        env['AR']          = 'lib.exe' #'"' +sdk_path + '\\bin\\Win64\\lib.exe"'
+        env['ARFLAGS']     = SCons.Util.CLVar('/nologo')
+        env['ARCOM']       = "${TEMPFILE('$AR $ARFLAGS /OUT:$TARGET $SOURCES')}"
+
+        env['SHLINK']      = '$LINK'
+        env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS /dll')
+        env['_SHLINK_TARGETS'] = win32ShlinkTargets
+        env['_SHLINK_SOURCES'] = win32ShlinkSources
+        env['SHLINKCOM']   =  compositeLinkAction
+        env['SHLIBEMITTER']= win32LibEmitter
+        env['LINK'] =  'link.exe' #'"' +sdk_path + '\\bin\\Win64\\' + 'link.exe"'
+        env['LINKFLAGS']   = SCons.Util.CLVar('/nologo')
+        env['_PDB'] = pdbGenerator
+        env["TEMPFILE"] = SCons.Platform.win32.TempFileMunge
+        env['LINKCOM'] = '${TEMPFILE("$LINK $LINKFLAGS /OUT:$TARGET $( $_LIBDIRFLAGS $) $_LIBFLAGS $_PDB $SOURCES")}'
+        env['PROGEMITTER'] = prog_emitter
+        env['LIBDIRPREFIX']='/LIBPATH:'
+        env['LIBDIRSUFFIX']=''
+        env['LIBLINKPREFIX']=''
+        env['LIBLINKSUFFIX']='$LIBSUFFIX'
+
+        env['WIN32DEFPREFIX']        = ''
+        env['WIN32DEFSUFFIX']        = '.def'
+        env['WIN32_INSERT_DEF']      = 0
+
+        env['WIN32EXPPREFIX']        = ''
+        env['WIN32EXPSUFFIX']        = '.exp'
+
+        env['REGSVRACTION'] = regServerCheck
+        env['REGSVR'] = os.path.join(SCons.Platform.win32.get_system_root(),'System32','regsvr32')
+        env['REGSVRFLAGS'] = '/s '
+        env['REGSVRCOM'] = '$REGSVR $REGSVRFLAGS $TARGET'
+
+
+def exists(env):
+        return env.Detect('cl')
\ No newline at end of file