Adding cross-compile ability to the make build

pylib/gyp/input.py

 #!/usr/bin/python
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
 from compiler.ast import Stmt
 import compiler
@@ skipping 55 matching lines @@
   'postbuilds',
   'product_dir',
   'product_extension',
   'product_name',
   'rules',
   'run_as',
   'sources',
   'suppress_wildcard',
   'target_name',
   'test',
+  'toolset',
+  'toolsets',
   'type',
   'variants',
 
   # Sections that can be found inside targets or configurations, but that
   # should not be propagated from targets into their configurations.
   'variables',
 ]
 non_configuration_keys = []
 
 # Controls how the generator want the build file paths.
 absolute_build_file_paths = False
 
+# Controls whether or not the generator supports multiple toolsets.
+multiple_toolsets = False
+
 
 def GetIncludedBuildFiles(build_file_path, aux_data, included=None):
   """Return a list of all build files included into build_file_path.
 
   The returned list will contain build_file_path as well as all other files
   that it included, either directly or indirectly.  Note that the list may
   contain files that were included into a conditional section that evaluated
   to false and was not merged into build_file_path's dict.
 
   aux_data is a dict containing a key for each build file or included build
@@ skipping 152 matching lines @@
 def LoadBuildFileIncludesIntoList(sublist, sublist_path, data, aux_data,
                                   variables, check):
   for item in sublist:
     if item.__class__ == dict:
       LoadBuildFileIncludesIntoDict(item, sublist_path, data, aux_data,
                                     variables, None, check)
     elif item.__class__ == list:
       LoadBuildFileIncludesIntoList(item, sublist_path, data, aux_data,
                                     variables, check)
 
+# Processes toolsets in all the targets. This recurses into condition entries
+# since they can contain toolsets as well.
+def ProcessToolsetsInDict(data):
+  if 'targets' in data:
+    target_list = data['targets']
+    new_target_list = []
+    for target in target_list:
+      global multiple_toolsets
+      if multiple_toolsets:
+        toolsets = target.get('toolsets', ['target'])
+      else:
+        toolsets = ['target']
+      if len(toolsets) > 0:
+        # Optimization: only do copies if more than one toolset is specified.
+        for build in toolsets[1:]:
+          new_target = copy.deepcopy(target)
+          new_target['toolset'] = build
+          new_target_list.append(new_target)
+        target['toolset'] = toolsets[0]
+        new_target_list.append(target)
+    data['targets'] = new_target_list
+  if 'conditions' in data:
+    for condition in data['conditions']:
+      if isinstance(condition, list):
+        for condition_dict in condition[1:]:
+          ProcessToolsetsInDict(condition_dict)
+
 
 # TODO(mark): I don't love this name.  It just means that it's going to load
 # a build file that contains targets and is expected to provide a targets dict
 # that contains the targets...
 def LoadTargetBuildFile(build_file_path, data, aux_data, variables, includes,
                         depth, check):
   global absolute_build_file_paths
 
   # If depth is set, predefine the DEPTH variable to be a relative path from
   # this build file's directory to the directory identified by depth.
   if depth:
     d = gyp.common.RelativePath(depth, os.path.dirname(build_file_path))
     if d == '':
       variables['DEPTH'] = '.'
     else:
       variables['DEPTH'] = d
 
   # If the generator needs absolue paths, then do so.
   if absolute_build_file_paths:
     build_file_path = os.path.abspath(build_file_path)
 
-  if build_file_path in data:
+  if build_file_path in data['target_build_files']:
     # Already loaded.
     return
+  data['target_build_files'].add(build_file_path)
 
   gyp.DebugOutput(gyp.DEBUG_INCLUDES,
                   "Loading Target Build File '%s'" % build_file_path)
 
   build_file_data = LoadOneBuildFile(build_file_path, data, aux_data, variables,
                                      includes, True, check)
 
   # Store DEPTH for later use in generators.
   build_file_data['_DEPTH'] = depth
 
   # Set up the included_files key indicating which .gyp files contributed to
   # this target dict.
   if 'included_files' in build_file_data:
     raise KeyError, build_file_path + ' must not contain included_files key'
 
   included = GetIncludedBuildFiles(build_file_path, aux_data)
   build_file_data['included_files'] = []
   for included_file in included:
     # included_file is relative to the current directory, but it needs to
     # be made relative to build_file_path's directory.
     included_relative = \
         gyp.common.RelativePath(included_file,
                                 os.path.dirname(build_file_path))
     build_file_data['included_files'].append(included_relative)
 
+  ProcessToolsetsInDict(build_file_data)
+
   # Apply "pre"/"early" variable expansions and condition evaluations.
   ProcessVariablesAndConditionsInDict(build_file_data, False, variables.copy(),
                                       build_file_path)
 
   # Look at each project's target_defaults dict, and merge settings into
   # targets.
   if 'target_defaults' in build_file_data:
     index = 0
     if 'targets' in build_file_data:
       while index < len(build_file_data['targets']):
@@ skipping 21 matching lines @@
   # after "pre" conditionals and variable expansion, but before "post" -
   # in other words, you can't put a "dependencies" section inside a "post"
   # conditional within a target.
 
   if 'targets' in build_file_data:
     for target_dict in build_file_data['targets']:
       if 'dependencies' not in target_dict:
         continue
       for dependency in target_dict['dependencies']:
         other_build_file = \
-            gyp.common.BuildFileAndTarget(build_file_path, dependency)[0]
+            gyp.common.ResolveTarget(build_file_path, dependency, None)[0]
         try:
           LoadTargetBuildFile(other_build_file, data, aux_data, variables,
                               includes, depth, check)
         except Exception, e:
           gyp.common.ExceptionAppend(
             e, 'while loading dependencies of %s' % build_file_path)
           raise
 
   return data
 
@@ skipping 517 matching lines @@
   current directory.  Values in |data| are build file contents.  For each
   |data| value with a "targets" key, the value of the "targets" key is taken
   as a list containing target dicts.  Each target's fully-qualified name is
   constructed from the pathname of the build file (|data| key) and its
   "target_name" property.  These fully-qualified names are used as the keys
   in the returned dict.  These keys provide access to the target dicts,
   the dicts in the "targets" lists.
   """
 
   targets = {}
-  for build_file in data:
+  for build_file in data['target_build_files']:
     for target in data[build_file].get('targets', []):
       target_name = gyp.common.QualifiedTarget(build_file,
-                                               target['target_name'])
+                                               target['target_name'],
+                                               target['toolset'])
       if target_name in targets:
         raise KeyError, 'Duplicate target definitions for ' + target_name
       targets[target_name] = target
 
   return targets
 
 
 def QualifyDependencies(targets):
   """Make dependency links fully-qualified relative to the current directory.
 
   |targets| is a dict mapping fully-qualified target names to their target
   dicts.  For each target in this dict, keys known to contain dependency
   links are examined, and any dependencies referenced will be rewritten
   so that they are fully-qualified and relative to the current directory.
   All rewritten dependencies are suitable for use as keys to |targets| or a
   similar dict.
   """
 
   for target, target_dict in targets.iteritems():
-    target_build_file = gyp.common.BuildFileAndTarget('', target)[0]
+    target_build_file = gyp.common.BuildFile(target)
+    toolset = target_dict['toolset']
     for dependency_key in dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
       for index in xrange(0, len(dependencies)):
-        dependency = gyp.common.QualifiedTarget(target_build_file,
-                                                dependencies[index])
+        dep_file, dep_target, dep_toolset = gyp.common.ResolveTarget(
+            target_build_file, dependencies[index], toolset)
+        global multiple_toolsets
+        if not multiple_toolsets:
+          # Ignore toolset specification in the dependency if it is specified.
+          dep_toolset = toolset
+        dependency = gyp.common.QualifiedTarget(dep_file,
+                                                dep_target,
+                                                dep_toolset)
         dependencies[index] = dependency
 
         # Make sure anything appearing in a list other than "dependencies" also
         # appears in the "dependencies" list.
         if dependency_key != 'dependencies' and \
            dependency not in target_dict['dependencies']:
           raise KeyError, 'Found ' + dependency + ' in ' + dependency_key + \
                           ' of ' + target + ', but not in dependencies'
 
 
 def ExpandWildcardDependencies(targets, data):
   """Expands dependencies specified as build_file:*.
 
   For each target in |targets|, examines sections containing links to other
   targets.  If any such section contains a link of the form build_file:*, it
   is taken as a wildcard link, and is expanded to list each target in
   build_file.  The |data| dict provides access to build file dicts.
 
   Any target that does not wish to be included by wildcard can provide an
   optional "suppress_wildcard" key in its target dict.  When present and
   true, a wildcard dependency link will not include such targets.
 
   All dependency names, including the keys to |targets| and the values in each
   dependency list, must be qualified when this function is called.
   """
 
   for target, target_dict in targets.iteritems():
-    target_build_file = gyp.common.BuildFileAndTarget('', target)[0]
+    toolset = target_dict['toolset']
+    target_build_file = gyp.common.BuildFile(target)
     for dependency_key in dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
 
       # Loop this way instead of "for dependency in" or "for index in xrange"
       # because the dependencies list will be modified within the loop body.
       index = 0
       while index < len(dependencies):
-        (dependency_build_file, dependency_target) = \
-            gyp.common.BuildFileAndTarget('', dependencies[index])[0:2]
-        if dependency_target != '*':
+        (dependency_build_file, dependency_target, dependency_toolset) = \
+            gyp.common.ParseQualifiedTarget(dependencies[index])
+        if dependency_target != '*' and dependency_toolset != '*':
           # Not a wildcard.  Keep it moving.
           index = index + 1
           continue
 
         if dependency_build_file == target_build_file:
           # It's an error for a target to depend on all other targets in
           # the same file, because a target cannot depend on itself.
           raise KeyError, 'Found wildcard in ' + dependency_key + ' of ' + \
                           target + ' referring to same build file'
 
         # Take the wildcard out and adjust the index so that the next
         # dependency in the list will be processed the next time through the
         # loop.
         del dependencies[index]
         index = index - 1
 
         # Loop through the targets in the other build file, adding them to
         # this target's list of dependencies in place of the removed
         # wildcard.
         dependency_target_dicts = data[dependency_build_file]['targets']
         for dependency_target_dict in dependency_target_dicts:
           if dependency_target_dict.get('suppress_wildcard', False):
             continue
           dependency_target_name = dependency_target_dict['target_name']
+          if (dependency_target != '*' and
+              dependency_target != dependency_target_name):
+            continue
+          dependency_target_toolset = dependency_target_dict['toolset']
+          if (dependency_toolset != '*' and
+              dependency_toolset != dependency_target_toolset):
+            continue
           dependency = gyp.common.QualifiedTarget(dependency_build_file,
-                                                  dependency_target_name)
+                                                  dependency_target_name,
+                                                  dependency_target_toolset)
           index = index + 1
           dependencies.insert(index, dependency)
 
         index = index + 1
 
 
 class DependencyGraphNode(object):
   """
 
   Attributes:
@@ skipping 198 matching lines @@
   dependency_nodes = {}
   for target, spec in targets.iteritems():
     if not target in dependency_nodes:
       dependency_nodes[target] = DependencyGraphNode(target)
 
   # Set up the dependency links.  Targets that have no dependencies are treated
   # as dependent on root_node.
   root_node = DependencyGraphNode(None)
   for target, spec in targets.iteritems():
     target_node = dependency_nodes[target]
-    target_build_file = gyp.common.BuildFileAndTarget('', target)[0]
+    target_build_file = gyp.common.BuildFile(target)
     if not 'dependencies' in spec or len(spec['dependencies']) == 0:
       target_node.dependencies = [root_node]
       root_node.dependents.append(target_node)
     else:
       dependencies = spec['dependencies']
       for index in xrange(0, len(dependencies)):
         try:
           dependency = dependencies[index]
           dependency_node = dependency_nodes[dependency]
           target_node.dependencies.append(dependency_node)
@@ skipping 14 matching lines @@
 
   return [dependency_nodes, flat_list]
 
 
 def DoDependentSettings(key, flat_list, targets, dependency_nodes):
   # key should be one of all_dependent_settings, direct_dependent_settings,
   # or link_settings.
 
   for target in flat_list:
     target_dict = targets[target]
-    build_file = gyp.common.BuildFileAndTarget('', target)[0]
+    build_file = gyp.common.BuildFile(target)
 
     if key == 'all_dependent_settings':
       dependencies = dependency_nodes[target].DeepDependencies()
     elif key == 'direct_dependent_settings':
       dependencies = \
           dependency_nodes[target].DirectAndImportedDependencies(targets)
     elif key == 'link_settings':
       dependencies = dependency_nodes[target].LinkDependencies(targets)
     else:
       raise KeyError, "DoDependentSettings doesn't know how to determine " + \
                       'dependencies for ' + key
 
     for dependency in dependencies:
       dependency_dict = targets[dependency]
       if not key in dependency_dict:
         continue
-      dependency_build_file = gyp.common.BuildFileAndTarget('', dependency)[0]
+      dependency_build_file = gyp.common.BuildFile(dependency)
       MergeDicts(target_dict, dependency_dict[key],
                  build_file, dependency_build_file)
 
 
 def AdjustStaticLibraryDependencies(flat_list, targets, dependency_nodes):
   # Recompute target "dependencies" properties.  For each static library
   # target, remove "dependencies" entries referring to other static libraries,
   # unless the dependency has the "hard_dependency" attribute set.  For each
   # linkable target, add a "dependencies" entry referring to all of the
   # target's computed list of link dependencies (including static libraries
@@ skipping 233 matching lines @@
 
 
 def SetUpConfigurations(target, target_dict):
   global non_configuration_keys
   # key_suffixes is a list of key suffixes that might appear on key names.
   # These suffixes are handled in conditional evaluations (for =, +, and ?)
   # and rules/exclude processing (for ! and /).  Keys with these suffixes
   # should be treated the same as keys without.
   key_suffixes = ['=', '+', '?', '!', '/']
 
-  build_file = gyp.common.BuildFileAndTarget('', target)[0]
+  build_file = gyp.common.BuildFile(target)
 
   # Provide a single configuration by default if none exists.
   # TODO(mark): Signal an error if default_configurations exists but
   # configurations does not.
   if not 'configurations' in target_dict:
     target_dict['configurations'] = {'Default': {}}
   if not 'default_configuration' in target_dict:
     target_dict['default_configuration'] = \
         sorted(target_dict['configurations'].keys())[0]
 
@@ skipping 351 matching lines @@
   non_configuration_keys.extend(generator_input_info['non_configuration_keys'])
 
   # TODO(mark) handle variants if the generator doesn't want them directly.
   generator_handles_variants = \
       generator_input_info['generator_handles_variants']
 
   global absolute_build_file_paths
   absolute_build_file_paths = \
       generator_input_info['generator_wants_absolute_build_file_paths']
 
+  global multiple_toolsets
+  multiple_toolsets = generator_input_info[
+      'generator_supports_multiple_toolsets']
+
   # A generator can have other lists (in addition to sources) be processed
   # for rules.
   extra_sources_for_rules = generator_input_info['extra_sources_for_rules']
 
   # Load build files.  This loads every target-containing build file into
   # the |data| dictionary such that the keys to |data| are build file names,
   # and the values are the entire build file contents after "early" or "pre"
   # processing has been done and includes have been resolved.
-  data = {}
+  # NOTE: data contains both "target" files (.gyp) and "includes" (.gypi), as
+  # well as meta-data (e.g. 'included_files' key). 'target_build_files' keeps
+  # track of the keys corresponding to "target" files.
+  data = {'target_build_files': set()}
   aux_data = {}
   for build_file in build_files:
     # Normalize paths everywhere.  This is important because paths will be
     # used as keys to the data dict and for references between input files.
     build_file = os.path.normpath(build_file)
     try:
       LoadTargetBuildFile(build_file, data, aux_data, variables, includes,
                           depth, check)
     except Exception, e:
       gyp.common.ExceptionAppend(e, 'while trying to load %s' % build_file)
@@ skipping 23 matching lines @@
         del targets[target][settings_type]
 
   # Make sure static libraries don't declare dependencies on other static
   # libraries, but that linkables depend on all unlinked static libraries
   # that they need so that their link steps will be correct.
   AdjustStaticLibraryDependencies(flat_list, targets, dependency_nodes)
 
   # Apply "post"/"late"/"target" variable expansions and condition evaluations.
   for target in flat_list:
     target_dict = targets[target]
-    build_file = gyp.common.BuildFileAndTarget('', target)[0]
+    build_file = gyp.common.BuildFile(target)
     ProcessVariablesAndConditionsInDict(target_dict, True, variables,
                                         build_file)
 
   # Move everything that can go into a "configurations" section into one.
   for target in flat_list:
     target_dict = targets[target]
     SetUpConfigurations(target, target_dict)
 
   # Apply exclude (!) and regex (/) list filters.
   for target in flat_list:
     target_dict = targets[target]
     ProcessListFiltersInDict(target, target_dict)
 
   # Make sure that the rules make sense, and build up rule_sources lists as
   # needed.  Not all generators will need to use the rule_sources lists, but
   # some may, and it seems best to build the list in a common spot.
   # Also validate actions and run_as elements in targets.
   for target in flat_list:
     target_dict = targets[target]
-    build_file = gyp.common.BuildFileAndTarget('', target)[0]
+    build_file = gyp.common.BuildFile(target)
     ValidateRulesInTarget(target, target_dict, extra_sources_for_rules)
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]