Fix make and ninja backends to sensibly handle duplicate target names in different directories

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 580 matching lines @@
 def QuoteIfNecessary(string):
   """TODO: Should this ideally be replaced with one or more of the above
      functions?"""
   if '"' in string:
     string = '"' + string.replace('"', '\\"') + '"'
   return string
 
 
 def StringToMakefileVariable(string):
   """Convert a string to a value that is acceptable as a make variable name."""
-  # TODO: replace other metacharacters that we encounter.
-  return re.sub('[ {}$]', '_', string)
+  return re.sub('[^a-zA-Z0-9_]', '_', string)
 
 
 srcdir_prefix = ''
 def Sourceify(path):
   """Convert a path to its source directory form."""
   if '$(' in path:
     return path
   if os.path.isabs(path):
     return path
   return srcdir_prefix + path
@@ skipping 71 matching lines @@
       output_filename: output .mk file name to write
       spec, configs: gyp info
       part_of_all: flag indicating this target is part of 'all'
     """
     ensure_directory_exists(output_filename)
 
     self.fp = open(output_filename, 'w')
 
     self.fp.write(header)
 
+    self.qualified_target = qualified_target
     self.path = base_path
     self.target = spec['target_name']
     self.type = spec['type']
     self.toolset = spec['toolset']
 
     self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
     if self.flavor == 'mac':
       self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
     else:
       self.xcode_settings = None
@@ skipping 126 matching lines @@
     """Write Makefile code for any 'actions' from the gyp input.
 
     extra_sources: a list that will be filled in with newly generated source
                    files, if any
     extra_outputs: a list that will be filled in with any outputs of these
                    actions (used to make other pieces dependent on these
                    actions)
     part_of_all: flag indicating this target is part of 'all'
     """
     for action in actions:
-      name = self.target + '_' + StringToMakefileVariable(action['action_name'])
+      name = StringToMakefileVariable('%s_%s' % (self.qualified_target,
+                                                 action['action_name']))
       self.WriteLn('### Rules for action "%s":' % action['action_name'])
       inputs = action['inputs']
       outputs = action['outputs']
 
       # Build up a list of outputs.
       # Collect the output dirs we'll need.
       dirs = set()
       for out in outputs:
         dir = os.path.split(out)[0]
         if dir:
@@ skipping 73 matching lines @@
                  extra_mac_bundle_resources, part_of_all):
     """Write Makefile code for any 'rules' from the gyp input.
 
     extra_sources: a list that will be filled in with newly generated source
                    files, if any
     extra_outputs: a list that will be filled in with any outputs of these
                    rules (used to make other pieces dependent on these rules)
     part_of_all: flag indicating this target is part of 'all'
     """
     for rule in rules:
-      name = self.target + '_' + StringToMakefileVariable(rule['rule_name'])
+      name = StringToMakefileVariable('%s_%s' % (self.qualified_target,
+                                                 rule['rule_name']))
       count = 0
       self.WriteLn('### Generated for rule %s:' % name)
 
       all_outputs = []
 
       for rule_source in rule.get('rule_sources', []):
         dirs = set()
         (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)
         (rule_source_root, rule_source_ext) = \
             os.path.splitext(rule_source_basename)
@@ skipping 94 matching lines @@
 
   def WriteCopies(self, copies, extra_outputs, part_of_all):
     """Write Makefile code for any 'copies' from the gyp input.
 
     extra_outputs: a list that will be filled in with any outputs of this action
                    (used to make other pieces dependent on this action)
     part_of_all: flag indicating this target is part of 'all'
     """
     self.WriteLn('### Generated for copy rule.')
 
-    variable = self.target + '_copies'
+    name = StringToMakefileVariable(self.qualified_target + '_copies')
     outputs = []
     for copy in copies:
       for path in copy['files']:
         # Absolutify() calls normpath, stripping trailing slashes.
         path = Sourceify(self.Absolutify(path))
         filename = os.path.split(path)[1]
         output = Sourceify(self.Absolutify(os.path.join(copy['destination'],
                                                         filename)))
 
         # If the output path has variables in it, which happens in practice for
@@ skipping 1070 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()