Effectively duplicates targets that contain rules/actions, therefore enabling...

pylib/gyp/generator/msvs.py

 #!/usr/bin/python
 
 # Copyright (c) 2009 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+from copy import deepcopy
 import ntpath
+import os
 import posixpath
-import os
 import re
 import subprocess
 import sys
+import uuid
 
 import gyp.MSVSNew as MSVSNew
 import gyp.MSVSProject as MSVSProject
 import gyp.MSVSToolFile as MSVSToolFile
 import gyp.MSVSUserFile as MSVSUserFile
 import gyp.MSVSVersion as MSVSVersion
 import gyp.common
 
 
 # Regular expression for validating Visual Studio GUIDs.  If the GUID
@@ skipping 1104 matching lines @@
   # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
   # process), it is also necessary to check PROCESSOR_ARCITEW6432 (which
   # contains the actual word size of the system when running thru WOW64).
   if (os.environ.get('PROCESSOR_ARCHITECTURE', '').find('64') >= 0 or
       os.environ.get('PROCESSOR_ARCHITEW6432', '').find('64') >= 0):
     default_variables['MSVS_OS_BITS'] = 64
   else:
     default_variables['MSVS_OS_BITS'] = 32
 
 
+def _CreatePrebuildTarget(target_dicts, qualified_target):
+  """ Move all rules/actions from qualified_target to a new target.
+
+  Arguments:
+    target_dicts: Dict of target properties keyed on target pair.
+    qualified_target: Target to duplicate.
+  Returns:
+    Name of the new target.
+  """
+  [build_file, target, toolset] = gyp.common.ParseQualifiedTarget(
+      qualified_target)
+  new_target = '%s:%s_prebuild' % (build_file, target)
+  if toolset:
+    new_target += '#%s' % (toolset)
+  if target_dicts.has_key(new_target):
+    raise Exception(
+        'Targets ending in _prebuild not supported in msvs build '
+        '(target %s)' % target)
+  target_dicts[new_target] = deepcopy(target_dicts[qualified_target])
+  target_dicts[new_target]['target_name'] = '%s_prebuild'  % (target)
+  target_dicts[new_target]['original_target_name'] = target
+  target_dicts[new_target]['type'] = 'none'
+  for config_name, c in target_dicts[new_target]['configurations'].iteritems():
+    if not c.has_key('msvs_configuration_attributes'):
+      c['msvs_configuration_attributes'] = dict()
+    c['msvs_configuration_attributes']['IntermediateDirectory'
+        ] = '$(ConfigurationName)\\obj\\%s' % (target)
+
+  # Remove actions and rules from the original target.
+  if target_dicts[qualified_target].has_key('rules'):
+    sources = target_dicts[qualified_target].get('sources', [])
+    for rule in target_dicts[qualified_target]['rules']:
+      trigger_files = _FindRuleTriggerFiles(rule, sources)
+      for tf in trigger_files:
+        inputs, outputs = _RuleInputsAndOutputs(rule, tf)
+        if int(rule.get('process_outputs_as_sources', False)):
+          sources.extend(outputs)
+    target_dicts[qualified_target]['sources'] = sources
+    del target_dicts[qualified_target]['rules']
+  if target_dicts[qualified_target].has_key('actions'):
+    sources = target_dicts[qualified_target].get('sources', [])
+    for action in target_dicts[qualified_target]['actions']:
+      if int(action.get('process_outputs_as_sources', False)):
+        sources.extend(action.get('outputs', []))
+    target_dicts[qualified_target]['sources'] = sources
+    del target_dicts[qualified_target]['actions']
+
+  # Make the original target depend on the new target.
+  if target_dicts[qualified_target].has_key('dependencies'):
+    target_dicts[qualified_target]['dependencies'].append(new_target)
+  else:
+    target_dicts[qualified_target]['dependencies'] = [new_target]
+
+  # Assign a new GUID to the new target.
+  default_config = target_dicts[new_target]['configurations'][
+      target_dicts[new_target]['default_configuration']]
+  default_config['msvs_guid'] = str(uuid.uuid4()).upper()

[Mark Mentovai, 2010/07/07 17:45:28]

I’d prefer if these were deterministic so that they don’t change for no reason
when projects are regenerated.

+
+  return new_target
+
+
 def GenerateOutput(target_list, target_dicts, data, params):
   """Generate .sln and .vcproj files.
 
   This is the entry point for this generator.
   Arguments:
     target_list: List of target pairs: 'base/base.gyp:base'.
     target_dicts: Dict of target properties keyed on target pair.
     data: Dictionary containing per .gyp data.
   """
   global fixpath_prefix
 
   options = params['options']
   generator_flags = params.get('generator_flags', {})
 
   # Get the project file format version back out of where we stashed it in
   # GeneratorCalculatedVariables.
   msvs_version = params['msvs_version']
 
   # Prepare the set of configurations.
   configs = set()
   for qualified_target in target_list:
     build_file = gyp.common.BuildFile(qualified_target)
     spec = target_dicts[qualified_target]
     for config_name, c in spec['configurations'].iteritems():
       configs.add(_ConfigFullName(config_name, c))
   configs = list(configs)
 
+  # MSVS has some "issues" with checking dependencies for the "Compile
+  # sources" step with any source files/headers generated by actions/rules.
+  # To work around this, if a target is building anything directly (not
+  # type "none"), then a second target as used to run the GYP actions/rules
+  # and is made a dependency of this target.  This way the work is done
+  # before the dependency checks for what should be recompiled.
+  new_target_list = []
+  for qualified_target in target_list:
+    # Check whether the target has rules or actions with the
+    # process_outputs_as_sources flag set.

[Mark Mentovai, 2010/07/14 17:34:55]

When we split the targets up this way on the Mac, we didn’t consider
process_outputs_as_sources. I don’t think we should consider
process_outputs_as_sources here, either. There may be other subtle dependencies
that don’t rely on process_outputs_as_sources—this may be as simple as a target
that lists the generated sources instead of declaring
process_outputs_as_sources, or it may be more complex, involving a step that
only generates .h files.

For reference, the logic used in the Xcode generator is in
pylib/gyp/generator/xcode.py at line 661; the condition used is:

    if type != 'none' and (spec_actions or spec_rules):

spec_actions and spec_rules are defined exactly as they are here. type is
spec['type'].

+    spec = target_dicts[qualified_target]
+    spec_actions = spec.get('actions', [])
+    spec_rules = spec.get('rules', [])
+    process_outputs_as_sources = False
+    for action in spec_actions:
+      if int(action.get('process_outputs_as_sources', False)):
+        process_outputs_as_sources = True
+    for rule in spec_rules:
+      if int(rule.get('process_outputs_as_sources', False)):
+        process_outputs_as_sources = True
+
+    if spec['type'] != 'none' and process_outputs_as_sources:
+      # Create a new target as copy of the current target.
+      new_target = _CreatePrebuildTarget(target_dicts, qualified_target)
+      new_target_list.append(new_target)
+
+    # Save the current target in the list of targets.
+    new_target_list.append(qualified_target)
+
+  target_list = new_target_list
+
   # Generate each project.
   projects = {}
   for qualified_target in target_list:
     build_file = gyp.common.BuildFile(qualified_target)
     spec = target_dicts[qualified_target]
     if spec['toolset'] != 'target':
       raise Exception(
           'Multiple toolsets not supported in msvs build (target %s)' %
           qualified_target)
     default_config = spec['configurations'][spec['default_configuration']]
@@ skipping 33 matching lines @@
     # Create folder hierarchy.
     root_entries = _GatherSolutionFolders(
         project_objs, flat=msvs_version.FlatSolution())
     # Create solution.
     sln = MSVSNew.MSVSSolution(sln_path,
                                entries=root_entries,
                                variants=configs,
                                websiteProperties=False,
                                version=msvs_version)
     sln.Write()