root/branches/Carsten_PtrWork/Source/SConscript

#!python
import os, os.path
pj = os.path.join
from LibraryUtils import *
import SCons

Import('*')

import SCons

common_lib_env = build_env.Copy()

if verbose_build:
   print "Setting up build for libraries: ",

# On windows we do not want to remove all default libraries from the list of libraries
# it searches when resolving external references.
if GetPlatform() == "win32":
   common_lib_env.Append(LINKFLAGS = SCons.Util.CLVar('/nodefaultlib'))

for (lib_name, library) in lib_map.iteritems():
   if verbose_build:
      print "Library: ", lib_name, "  tests:", library.test_files, "  unittests:", library.unittest_files
   else:
      print "%s"%lib_name,
   
   # ---- Setup and Build library --- #
   # - Setup environment for build: library deps, custom options
   # - Set builder for the library
   # - Install headers if in first pass
   lib_env = common_lib_env.Copy()
   full_lib_name = lib_name + shared_lib_suffix

   # Use ConfigInfo to find build flags for building with/against this library and it's dependencies
   # - We have to pull our library name off the list (slight hack)   
   default_lib_settings = LibraryInfo()
   config_info = ConfigInfoAdapter(lib_name, lib_map, default_lib_settings,
                                   osg_lib_suffix=shared_lib_suffix)

   dep_libs = [l for l in config_info.getLibs() if l != full_lib_name]
   lib_env.Append(CPPPATH=config_info.getIncPath(),
                  LIBPATH=[inst_paths["lib_inst_combo"]] + config_info.getLibPath(),
                  LIBS=dep_libs,
                  FRAMEWORKPATH=config_info.getFrameworkPath(),
                  FRAMEWORKS=config_info.getFrameworks())

   # Define OSG_DEBUG if needed 
   if combo["type"] in ["debug","hybrid"]: 
      lib_env.Append(CPPDEFINES=["OSG_DEBUG",])

   # XXX: Apply custom options
   #
   # Add the define needed for declspec to know what library we are building
   compile_define = "OSG_COMPILE%sLIB"%lib_name[3:].upper()
   lib_env.Append(CPPDEFINES=[compile_define])

   if GetPlatform() == "win32":

      lib_env.Append(LIBS = ["MSVCPRT$DEBUG_CHAR", "MSVCRT$DEBUG_CHAR"])

      if "debug" == combo["type"] or "hybrid" == combo["type"]: 
         lib_env["DEBUG_CHAR"]='D'
      else:
         lib_env["DEBUG_CHAR"]=''

   shared_lib = lib_env.SharedLibrary(full_lib_name, library.source_files)
   shared_lib_inst = lib_env.Install(inst_paths['lib_inst_combo'], shared_lib)
      
   # If default combo type, then make links from lib dir
   if default_combo_type == combo["type"] and (GetPlatform() != "win32"):
      lib_env.Install(inst_paths["lib"], shared_lib_inst)      
   
   # Install headers (but only do it once during variant_pass 0 )
   if variant_pass == 0:      
      lib_env.Install(pj(inst_paths["include"],"OpenSG"), library.header_files)
   
   # ---- Build Tests ---- #   
   # Verify we have all the deps for the tests
   #   todo: How do we verify the "other test libs"
   have_test_deps = True
   for n in library.osg_test_libs:
      if not lib_map.has_key(n):
         have_test_deps = False
         print "   missing test dep library:", n
   
   if have_test_deps:
      # Use ConfigInfo to find build flags for building applications against this library
      config_info = ConfigInfoAdapter([lib_name] + library.osg_test_libs, 
                                       lib_map,
                                      osg_lib_suffix=shared_lib_suffix)   
      test_env = build_env.Copy()
      test_env.Append(CPPPATH=library.test_cpppath + config_info.getIncPath(),
                      LIBPATH=library.test_libpath + [inst_paths["lib_inst_combo"]] + config_info.getLibPath(),
                      LIBS=config_info.getLibs() + library.other_test_libs,
                      FRAMEWORKPATH=config_info.getFrameworkPath(),
                      FRAMEWORKS=config_info.getFrameworks())

      if GetPlatform() == "win32":

        test_env.Append(LIBS = ["MSVCPRT$DEBUG_CHAR", "MSVCRT$DEBUG_CHAR"])

        if "debug" == combo["type"] or "hybrid" == combo["type"]: 
            test_env["DEBUG_CHAR"]='D'
        else:
            test_env["DEBUG_CHAR"]=''
   
      # - Build them all in the local 'test' subdir
      for s in library.test_files:
         test_env.Program(target= pj("..","test",os.path.splitext(os.path.basename(s))[0]),
                          source=s)
   
      # ---- Build Unit Tests ---- #   
      # - Build them all in the unittest directory
      if build_env["enable_unittests"] and (len(library.unittest_files) > 0):         
         unittest_env = test_env.Copy()
         unittest_env.Append(CPPPATH=unittest_inc,
                             LIBPATH=unittest_libpath,
                             LIBS=unittest_lib)

         if GetPlatform() == "win32":

            unittest_env.Append(LIBS = ["MSVCPRT$DEBUG_CHAR", "MSVCRT$DEBUG_CHAR"])

            if "debug" == combo["type"] or "hybrid" == combo["type"]: 
                unittest_env["DEBUG_CHAR"]='D'
                unittest_env["UTDBGDIR"]='dbg'
            else:
                unittest_env["DEBUG_CHAR"]=''
                unittest_env["UTDBGDIR"]='opt'

         runner_obj = unittest_env.Object(target=pj("..","unittest","run"+lib_name), source=unittest_runner)
         runner = unittest_env.Program(pj("..","unittest","run"+lib_name), 
                                       library.unittest_files + [str(runner_obj[0])])

         # Run the Test once the program is built
         def runTest(target, source, env):
            path = ""
            for i in env["LIBPATH"]:
                path += i + os.pathsep
            path = path[:-1]
            
            ev = os.environ
            if GetPlatform() == "win32":
                key = "PATH"
            elif GetPlatform() == "darwin":
                key = "DYLD_LIBRARY_PATH"
            else:
                key = "LD_LIBRARY_PATH"
                
            if ev.has_key(key):
                ev[key] = path + os.pathsep + ev[key]
            else:
                ev[key] = path
            
            print "TEST SUITE: [%s]"%(target[0],)
            prog = str(target[0])
            exit_code = os.spawnle(os.P_WAIT, prog, prog, ev)
            
            if exit_code != 0:
                Exit(exit_code)

         AddPostAction(runner, runTest)

      
   # Done   
if not verbose_build:
   print ""