Fixing make generator handling of multiple actions in a dependent target.

pylib/gyp/generator/make.py

 # Copyright (c) 2012 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.
 
 # Notes:
 #
 # This is all roughly based on the Makefile system used by the Linux
 # kernel, but is a non-recursive make -- we put the entire dependency
 # graph in front of make and let it figure it out.
 #
@@ skipping 1370 matching lines @@
     part_of_all: flag indicating this target is part of 'all'
     """
 
     self.WriteLn('### Rules for final target.')
 
     if extra_outputs:
       self.WriteDependencyOnExtraOutputs(self.output_binary, extra_outputs)
       self.WriteMakeRule(extra_outputs, deps,
                          comment=('Preserve order dependency of '
                                   'special output on deps.'),
-                         order_only = True,
-                         multiple_output_trick = False)
+                         order_only = True)
 
     target_postbuilds = {}
     if self.type != 'none':
       for configname in sorted(configs.keys()):
         config = configs[configname]
         if self.flavor == 'mac':
           ldflags = self.xcode_settings.GetLdflags(configname,
               generator_default_variables['PRODUCT_DIR'],
               lambda p: Sourceify(self.Absolutify(p)))
 
@@ skipping 219 matching lines @@
                        force = True)
     # Add our outputs to the list of targets we read depfiles from.
     # all_deps is only used for deps file reading, and for deps files we replace
     # spaces with ? because escaping doesn't work with make's $(sort) and
     # other functions.
     outputs = [QuoteSpaces(o, SPACE_REPLACEMENT) for o in outputs]
     self.WriteLn('all_deps += %s' % ' '.join(outputs))
 
 
   def WriteMakeRule(self, outputs, inputs, actions=None, comment=None,
-                    order_only=False, force=False, phony=False,
-                    multiple_output_trick=True):
+                    order_only=False, force=False, phony=False):
     """Write a Makefile rule, with some extra tricks.
 
     outputs: a list of outputs for the rule (note: this is not directly
              supported by make; see comments below)
     inputs: a list of inputs for the rule
     actions: a list of shell commands to run for the rule
     comment: a comment to put in the Makefile above the rule (also useful
              for making this Python script's code self-documenting)
     order_only: if true, makes the dependency order-only
     force: if true, include FORCE_DO_CMD as an order-only dep
     phony: if true, the rule does not actually generate the named output, the
            output is just a name to run the rule
-    multiple_output_trick: if true (the default), perform tricks such as dummy
-           rules to avoid problems with multiple outputs.
     """
     outputs = map(QuoteSpaces, outputs)
     inputs = map(QuoteSpaces, inputs)
 
     if comment:
       self.WriteLn('# ' + comment)
     if phony:
       self.WriteLn('.PHONY: ' + ' '.join(outputs))
     # TODO(evanm): just make order_only a list of deps instead of these hacks.
     if order_only:
       order_insert = '| '
+      pick_output = ' '.join(outputs)
     else:
       order_insert = ''
+      pick_output = outputs[0]
     if force:
       force_append = ' FORCE_DO_CMD'
     else:
       force_append = ''
     if actions:
       self.WriteLn("%s: TOOLSET := $(TOOLSET)" % outputs[0])
-    self.WriteLn('%s: %s%s%s' % (outputs[0], order_insert, ' '.join(inputs),
+    self.WriteLn('%s: %s%s%s' % (pick_output, order_insert, ' '.join(inputs),
                                  force_append))
     if actions:
       for action in actions:
         self.WriteLn('\t%s' % action)
-    if multiple_output_trick and len(outputs) > 1:
+    if not order_only and len(outputs) > 1:
       # If we have more than one output, a rule like
       #   foo bar: baz
       # that for *each* output we must run the action, potentially
       # in parallel.  That is not what we're trying to write -- what
       # we want is that we run the action once and it generates all
       # the files.
       # http://www.gnu.org/software/hello/manual/automake/Multiple-Outputs.html
       # discusses this problem and has this solution:
       # 1) Write the naive rule that would produce parallel runs of
       # the action.
@@ skipping 447 matching lines @@
     root_makefile.write("  include " + include_file + "\n")
     root_makefile.write("endif\n")
   root_makefile.write('\n')
 
   if generator_flags.get('auto_regeneration', True):
     WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)
 
   root_makefile.write(SHARED_FOOTER)
 
   root_makefile.close()