Adding in new software construction toolkit version.

site_scons/site_tools/component_setup.py

 #!/usr/bin/python2.4
 # Copyright 2008, Google Inc.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 45 matching lines @@
     Return code from SCons Node link function.
   """
 
   # Use link function for Install() and InstallAs(), since it's much much
   # faster than copying.  This is ok for the way we build clients, where we're
   # installing to a build output directory and not to a permanent location such
   # as /usr/bin.
   # Need to force the target and source to be lists of nodes
   return SCons.Node.FS.LinkFunc([env.Entry(target)], [env.Entry(source)], env)
 
+
+def PreEvaluateVariables(env):
+  """Deferred function to pre-evaluate SCons varables for each build mode.
+
+  Args:
+    env: Environment for the current build mode.
+  """
+  # Convert directory variables to strings
+  for var in env.SubstList2('PRE_EVALUATE_DIRS'):
+    env[var] = str(env.Dir('$' + var))
+
+
 #------------------------------------------------------------------------------
 
 
 def generate(env):
   # NOTE: SCons requires the use of this name, which fails gpylint.
   """SCons entry point for this tool."""
 
   # Use MD5 to tell when files differ, if the timestamps differ.  This is
   # better than pure MD5 (since if the timestamps are the same, we don't need
   # to rescan the file), and also better than pure timestamp (since if a file
@@ skipping 25 matching lines @@
   # alias as the program name itself.  This conflict manifests itself as a
   # python exception if you try to build a program in multiple modes on linux,
   # for example:
   #      hammer --mode=dbg,opt port_test
   new_lookup_list = []
   for func in env.lookup_list:
     if func.im_class != SCons.Node.Alias.AliasNameSpace:
       new_lookup_list.append(func)
   env.lookup_list = new_lookup_list
 
-  # Add other default tools from our toolkit
-  for t in component_setup_tools:
-    env.Tool(t)
-
   # Cover part of the environment
   env.Replace(
       # Add a reference to our python executable, so subprocesses can find and
       # invoke python.
       PYTHON = env.File(sys.executable),
 
       # Get the absolute path to the directory containing main.scons (or
       # SConstruct).  This should be used in place of the SCons variable '#',
       # since '#' is not always replaced (for example, when being used to set
       # an environment variable).
       MAIN_DIR = env.Dir('#').abspath,
       # Supply deprecated SCONSTRUCT_DIR for legacy suport
       # TODO(rspangler): remove legacy support once everyone has switched over.
       SCONSTRUCT_DIR = env.Dir('#').abspath,
 
       # Use install function above, which uses links in preference to copying.
       INSTALL = InstallUsingLink,
+  )
 
+  # Specify defaults for variables where we don't need to force replacement
+  env.SetDefault(
       # Environments are in the 'all' group by default
       BUILD_GROUPS=['all'],
 
+      # Directories
       DESTINATION_ROOT='$MAIN_DIR/scons-out$HOST_PLATFORM_SUFFIX',
       TARGET_ROOT='$DESTINATION_ROOT/$BUILD_TYPE',
       OBJ_ROOT='$TARGET_ROOT/obj',
       ARTIFACTS_DIR='$TARGET_ROOT/artifacts',
-      CPPDEFINES=[],
   )
 
+  # Add default list of variables we should pre-evaluate for each build mode
+  env.Append(PRE_EVALUATE_DIRS = [
+      'ARTIFACTS_DIR',
+      'DESTINATION_ROOT',
+      'OBJ_ROOT',
+      'SOURCE_ROOT',
+      'TARGET_ROOT',
+      'TOOL_ROOT',
+  ])
+
   # If a host platform was specified, need to put the SCons output in its own
   # destination directory.  Different host platforms compile the same files
   # different ways, so need their own .sconsign files.
   force_host_platform = SCons.Script.GetOption('host_platform')
   if force_host_platform:
     env['HOST_PLATFORM_SUFFIX'] = '-' + force_host_platform
 
-  # The following environment replacements use env.Dir() to force immediate
-  # evaluation/substitution of SCons variables.  They can't be part of the
-  # preceding env.Replace() since they they may rely indirectly on variables
-  # defined there, and the env.Dir() calls would be evaluated before the
-  # env.Replace().
-
-  # Set default SOURCE_ROOT if there is none, assuming we're in a local
-  # site_scons directory for the project.
-  source_root_relative = os.path.normpath(
-      os.path.join(os.path.dirname(__file__), '../..'))
-  source_root = env.get('SOURCE_ROOT', source_root_relative)
-  env['SOURCE_ROOT'] = env.Dir(source_root)
-
-  # Make tool root separate from source root so it can be overridden when we
-  # have a common location for tools outside of the current clientspec.  Need
-  # to check if it's defined already, so it can be set prior to this tool
-  # being included.
-  tool_root = env.get('TOOL_ROOT', '$SOURCE_ROOT')
-  env['TOOL_ROOT'] = env.Dir(tool_root)
-
   # Put the .sconsign.dblite file in our destination root directory, so that we
   # don't pollute the source tree. Use the '_' + sys.platform suffix to prevent
   # the .sconsign.dblite from being shared between host platforms, even in the
   # case where the --host_platform option is not used (for instance when the
   # project has platform suffixes on all the build types).
   # This will prevent host platforms from mistakenly using each others .sconsign
   # databases and will allow two host platform builds to occur in the same
   # shared tree simulataneously.
   sconsign_dir = env.Dir('$DESTINATION_ROOT').abspath
   sconsign_filename = '$DESTINATION_ROOT/.sconsign_%s' % sys.platform
   sconsign_file = env.File(sconsign_filename).abspath
   # TODO(sgk): SConsignFile() doesn't seem to like it if the destination
   # directory doesn't already exists, so make sure it exists.
   if not os.path.isdir(sconsign_dir):
     os.makedirs(sconsign_dir)
   SCons.Script.SConsignFile(sconsign_file)
 
   # Build all by default
   # TODO(rspangler): This would be more nicely done by creating an 'all'
   # alias and mapping that to $DESTINATION_ROOT (or the accumulation of all
   # $TARGET_ROOT's for the environments which apply to the current host
   # platform).  Ideally, that would be done in site_init.py and not here.  But
   # since we can't do that, just set the default to be DESTINATION_ROOT here.
   # Note that this currently forces projects which want to override the
   # default to do so after including the component_setup tool.
   env.Default('$DESTINATION_ROOT')
+
+  # Add other default tools from our toolkit
+  # TODO(rspangler): Currently this needs to be before SOURCE_ROOT in case a
+  # tool needs to redefine it.  Need a better way to handle order-dependency
+  # in tool setup.
+  for t in component_setup_tools:
+    env.Tool(t)
+
+  # The following environment replacements use env.Dir() to force immediate
+  # evaluation/substitution of SCons variables.  They can't be part of the
+  # preceding env.Replace() since they they may rely indirectly on variables
+  # defined there, and the env.Dir() calls would be evaluated before the
+  # env.Replace().
+
+  # Set default SOURCE_ROOT if there is none, assuming we're in a local
+  # site_scons directory for the project.
+  source_root_relative = os.path.normpath(
+      os.path.join(os.path.dirname(__file__), '../..'))
+  source_root = env.get('SOURCE_ROOT', source_root_relative)
+  env['SOURCE_ROOT'] = env.Dir(source_root).abspath
+
+  # Make tool root separate from source root so it can be overridden when we
+  # have a common location for tools outside of the current clientspec.  Need
+  # to check if it's defined already, so it can be set prior to this tool
+  # being included.
+  tool_root = env.get('TOOL_ROOT', '$SOURCE_ROOT')
+  env['TOOL_ROOT'] = env.Dir(tool_root).abspath
+
+  # Defer pre-evaluating some environment variables, but do before building
+  # SConscripts.
+  env.Defer(PreEvaluateVariables)
+  env.Defer('BuildEnvironmentSConscripts', after=PreEvaluateVariables)