Dropping in software construction toolkit.

site_scons/site_init.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.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Software construction toolkit site_scons configuration.
+
+This module sets up SCons for use with this toolkit.  This should contain setup
+which occurs outside of environments.  If a method operates within the context
+of an environment, it should instead go in a tool in site_tools and be invoked
+for the target environment.
+"""
+
+import __builtin__
+import sys
+import SCons
+
+
+# List of target groups for printing help; modified by AddTargetGroup(); used
+# by BuildComponents().
+__target_groups = {}
+
+
+def _HostPlatform():
+  """Returns the current host platform.
+
+  That is, the platform we're actually running SCons on.  You shouldn't use
+  this inside your SConscript files; instead, include the appropriate
+  target_platform tool for your environments.  When you call BuildComponents(),
+  only environments with the current host platform will be built.
+
+  Returns:
+    The host platform name - one of ('WINDOWS', 'LINUX', 'MAC').
+  """
+
+  platform_map = {
+      'win32': 'WINDOWS',
+      'cygwin': 'WINDOWS',
+      'linux': 'LINUX',
+      'linux2': 'LINUX',
+      'darwin': 'MAC',
+  }
+
+  if sys.platform not in platform_map:
+    print ('site_init.py warning: platform "%s" is not in platfom map.' %
+           sys.platform)
+
+  return platform_map.get(sys.platform, sys.platform)
+
+
+#------------------------------------------------------------------------------
+
+
+def _CheckBuildModes(build_modes, environments, host_platform):
+  """Checks the build modes for the environments.
+
+  Args:
+    build_modes: List of build mode strings.
+    environments: List of SCons environments.
+    host_platform: Host platform string.
+
+  Raises:
+    ValueError: build groups and/or types invalid.
+  """
+  # Make sure the list of environments for the current host platform have
+  # unique BUILD_TYPE.  This ensures they won't overwrite each others' build
+  # output.  (It is ok for build types in different host platforms to overlap;
+  # that is, WINDOWS and MAC can both have a 'dbg' build type.)
+  all_build_types = []
+  all_build_groups = {}
+  build_desc = {}
+  for e in environments:
+    if not e.Overlap(e['HOST_PLATFORMS'], [host_platform, '*']):
+      continue
+    if e['BUILD_TYPE'] in all_build_types:
+      raise ValueError('Multiple environments have the same BUILD_TYPE=%s' %
+                       e['BUILD_TYPE'])
+    else:
+      all_build_types.append(e['BUILD_TYPE'])
+      build_desc[e['BUILD_TYPE']] = e.get('BUILD_TYPE_DESCRIPTION')
+
+    # Keep track of build groups and the build types which belong to them
+    for g in e['BUILD_GROUPS']:
+      if g not in all_build_groups:
+        all_build_groups[g] = []
+        # Don't allow build types and groups to share names
+        if g in all_build_types:
+          raise ValueError('Build group %s also specified as BUILD_TYPE.' % g)
+        else:
+          all_build_types.append(g)
+      all_build_groups[g].append(e['BUILD_TYPE'])
+
+  # Add help for build types
+  xml_help = SCons.Script.GetOption('xml_help')
+  if xml_help:
+    help_mode_format = '  <build_mode name="%s"><![CDATA[%s]]></build_mode>\n'
+    help_text = '<mode_list>\n'
+  else:
+    help_text = '''
+Use --mode=type to specify the type of build to perform.  The following types
+may be specified:
+'''
+    help_mode_format = '    %-16s %s\n'
+
+  for build_type in all_build_types:
+    if build_type not in all_build_groups:
+      help_text += help_mode_format % (
+          build_type, build_desc.get(build_type, ''))
+
+  if xml_help:
+    help_group_format = ('  <build_group name="%s"><![CDATA[%s]]>'
+                         '</build_group>\n')
+    help_text += '</mode_list>\n<group_list>\n'
+  else:
+    help_group_format = '    %-16s %s\n'
+    help_text += '''
+The following build groups may also be specified via --mode.  Build groups
+build one or more of the other build types.  The available build groups are:
+'''
+
+  groups_sorted = all_build_groups.keys()
+  groups_sorted.sort()
+  for g in groups_sorted:
+    help_text += help_group_format % (g, ','.join(all_build_groups[g]))
+
+  if xml_help:
+    help_text += '</group_list>\n'
+  else:
+    help_text += '''
+Multiple modes may be specified, separated by commas: --mode=mode1,mode2.  If
+no mode is specified, the default group will be built.  This is equivalent to
+specifying --mode=default.
+  '''
+  SCons.Script.Help(help_text)
+
+  # Make sure all build modes specified by the user are ones which apply to
+  # the current environment.
+  for mode in build_modes:
+    if mode not in all_build_types and mode not in all_build_groups:
+      print ('Warning: Ignoring build mode "%s", which is not defined on this '
+             'platform.' % mode)
+
+
+def _AddTargetHelp():
+  """Adds help for the target groups from the global __target_groups."""
+  xml_help = SCons.Script.GetOption('xml_help')
+  help_text = ''
+
+  for alias, description in __target_groups.items():
+    items = map(str, SCons.Script.Alias(alias)[0].sources)
+    # Remove duplicates from multiple environments
+    items = list(set(items))
+
+    if items:
+      colwidth = max(map(len, items)) + 2
+      cols = 77 / colwidth
+      rows = (len(items) + cols - 1) / cols
+      items.sort()
+      if xml_help:
+        help_text += '<target_group name="%s">\n' % alias
+        for i in items:
+          help_text += '  <build_target name="%s"/>\n' % i
+        help_text += '</target_group>\n'
+      else:
+        help_text += '\nThe following %s:' % description
+        for row in range(0, rows):
+          help_text += '\n  '
+          for i in range(row, len(items), rows):
+            help_text += '%-*s' % (colwidth, items[i])
+        help_text += '\n  %s (do all of the above)\n' % alias
+
+  SCons.Script.Help(help_text)
+
+#------------------------------------------------------------------------------
+
+
+def BuildComponents(environments):
+  """Build a collection of components under a collection of environments.
+
+  Only environments with HOST_PLATFORMS containing the platform specified by
+  --host-platform (or the native host platform, if --host-platform was not
+  specified) will be matched.
+
+  Each matching environment is checked against the modes passed to the --mode
+  command line argument (or 'default', if no mode(s) were specified).  If any
+  of the modes match the environment's BUILD_TYPE or any of the environment's
+  BUILD_GROUPS, all the BUILD_COMPONENTS and BUILD_SCONSCRIPTS in that
+  environment will be built.
+
+  Args:
+    environments: List of SCons environments.
+  """
+  # Get options
+  xml_help = SCons.Script.GetOption('xml_help')
+  build_modes = SCons.Script.GetOption('build_mode')
+  # TODO(rspangler): Remove support legacy MODE= argument, once everyone has
+  # transitioned to --mode.
+  legacy_mode_option = SCons.Script.ARGUMENTS.get('MODE')
+  if legacy_mode_option:
+    build_modes = legacy_mode_option
+  build_modes = build_modes.split(',')
+
+  host_platform = SCons.Script.GetOption('host_platform')
+  if not host_platform:
+    host_platform = _HostPlatform()
+
+  # Check build modes
+  _CheckBuildModes(build_modes, environments, host_platform)
+
+  if xml_help:
+    SCons.Script.Help('<help_from_sconscripts>\n<![CDATA[\n')
+
+  for e in environments:
+    if not e.Overlap(e['HOST_PLATFORMS'], [host_platform, '*']):
+      continue      # Environment requires a host platform which isn't us
+
+    if e.Overlap([e['BUILD_TYPE'], e['BUILD_GROUPS']], build_modes):
+      # Set up for deferred functions and published resources
+      e._InitializeComponentBuilders()
+      e._InitializeDefer()
+      e._InitializePublish()
+
+      # Read SConscript for each component
+      # TODO(rspangler): Remove BUILD_COMPONENTS once all projects have
+      # transitioned to the BUILD_SCONSCRIPTS nomenclature.
+      for c in e.get('BUILD_COMPONENTS', []) + e.get('BUILD_SCONSCRIPTS', []):
+        # Clone the environment so components can't interfere with each other
+        ec = e.Clone()
+
+        if ec.Entry(c).isdir():
+          # The component is a directory, so assume it contains a SConscript
+          # file.
+          c_dir = ec.Dir(c)
+
+          # Use 'build.scons' as the default filename, but if that doesn't
+          # exist, fall back to 'SConscript'.
+          c_script = c_dir.File('build.scons')
+          if not c_script.exists():
+            c_script = c_dir.File('SConscript')
+        else:
+          # The component is a SConscript file.
+          c_script = ec.File(c)
+          c_dir = c_script.dir
+
+        ec.SConscript(c_script,
+                      build_dir='$OBJ_ROOT/' + str(c_dir),
+                      exports={'env': ec},
+                      duplicate=0)
+
+      # Execute deferred functions
+      e._ExecuteDefer()
+
+  if xml_help:
+    SCons.Script.Help(']]>\n</help_from_sconscripts>\n')
+
+  _AddTargetHelp()
+
+  # End final help tag
+  if xml_help:
+    SCons.Script.Help('</help>\n')
+
+
+#------------------------------------------------------------------------------
+
+
+def _ToolExists():
+  """Replacement for SCons tool module exists() function, if one isn't present.
+
+  Returns:
+    True.  This enables modules which always exist not to need to include a
+        dummy exists() function.
+  """
+  return True
+
+
+def _ToolModule(self):
+  """Thunk for SCons.Tool.Tool._tool_module to patch in exists() function.
+
+  Returns:
+    The module from the original SCons.Tool.Tool._tool_module call, with an
+        exists() method added if it wasn't present.
+  """
+  module = self._tool_module_orig()
+  if not hasattr(module, 'exists'):
+    module.exists = _ToolExists
+
+  return module
+
+#------------------------------------------------------------------------------
+
+
+def AddSiteDir(site_dir):
+  """Adds a site directory, as if passed to the --site-dir option.
+
+  Args:
+    site_dir: Site directory path to add, relative to the location of the
+        SConstruct file.
+
+  This may be called from the SConscript file to add a local site scons
+  directory for a project.  This does the following:
+     * Adds site_dir/site_scons to sys.path.
+     * Imports site_dir/site_init.py.
+     * Adds site_dir/site_scons to the SCons tools path.
+  """
+  # Call the same function that SCons does for the --site-dir option.
+  SCons.Script.Main._load_site_scons_dir(
+      SCons.Node.FS.get_default_fs().SConstruct_dir, site_dir)
+
+
+def AddTargetGroup(target_group, description):
+  """Adds a target group, used for printing help.
+
+  Args:
+    target_group: Name of target group.  This should be the name of an alias
+        which points to other aliases for the specific targets.
+    description: Description of the target group.
+  """
+
+  __target_groups[target_group] = description
+
+#------------------------------------------------------------------------------
+
+
+_new_options_help = '''
+Additional options for SCons:
+
+  --mode=MODE                 Specify build mode (see below).
+  --host-platform=PLATFORM    Force SCons to use PLATFORM as the host platform,
+                              instead of the actual platform on which SCons is
+                              run.  Useful for examining the dependency tree
+                              which would be created, but not useful for
+                              actually running the build because it'll attempt
+                              to use the wrong tools for your actual platform.
+  --site-path=DIRLIST         Comma-separated list of additional site
+                              directory paths; each is processed as if passed
+                              to --site-dir.
+  --xml-help                  Print help in XML format.
+'''
+
+def SiteInitMain():
+  """Main code executed in site_init."""
+
+  # Let people use new global methods directly.
+  __builtin__.AddSiteDir = AddSiteDir
+  __builtin__.BuildComponents = BuildComponents
+  __builtin__.AddTargetGroup = AddTargetGroup
+
+  # Set list of default tools for component_setup
+  __builtin__.component_setup_tools = [
+      'command_output',
+      'component_bits',
+      'component_builders',
+      'concat_source',
+      'defer',
+      'environment_tools',
+      'publish',
+      'replicate',
+  ]
+
+  # Patch Tool._tool_module method to fill in an exists() method for the
+  # module if it isn't present.
+  # TODO(sgk): This functionality should be patched into SCons itself by
+  # changing Tool.__init__().
+  SCons.Tool.Tool._tool_module_orig = SCons.Tool.Tool._tool_module
+  SCons.Tool.Tool._tool_module = _ToolModule
+
+  # Add our options
+  SCons.Script.AddOption(
+      '--mode', '--build-mode',
+      dest='build_mode',
+      nargs=1, type='string',
+      action='store',
+      metavar='MODE',
+      default='default',
+      help='build mode(s)')
+  SCons.Script.AddOption(
+      '--host-platform',
+      dest='host_platform',
+      nargs=1, type='string',
+      action='store',
+      metavar='PLATFORM',
+      help='build mode(s)')
+  SCons.Script.AddOption(
+      '--site-path',
+      dest='site_path',
+      nargs=1, type='string',
+      action='store',
+      metavar='PATH',
+      help='comma-separated list of site directories')
+  SCons.Script.AddOption(
+      '--xml-help',
+      dest='xml_help',
+      action='store_true',
+      help='print help in XML format')
+
+  if SCons.Script.GetOption('xml_help'):
+    SCons.Script.Help('<?xml version="1.0" encoding="UTF-8" ?>\n<help>\n')
+  else:
+    SCons.Script.Help(_new_options_help)
+
+  # Check for site path.  This is a list of site directories which each are
+  # processed as if they were passed to --site-dir.
+  site_path = SCons.Script.GetOption('site_path')
+  if site_path:
+    for site_dir in site_path.split(','):
+      AddSiteDir(site_dir)
+
+  # Since our site dir was specified on the SCons command line, SCons will
+  # normally only look at our site dir.  Add back checking for project-local
+  # site_scons directories.
+  if not SCons.Script.GetOption('no_site_dir'):
+    SCons.Script.Main._load_site_scons_dir(
+        SCons.Node.FS.get_default_fs().SConstruct_dir, None)
+
+# Run main code
+SiteInitMain()