Python 3 compatibility

pylib/gyp/generator/make.py

 # Copyright (c) 2013 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.
 #
 # The code below generates a separate .mk file for each target, but
 # all are sourced by the top-level Makefile.  This means that all
 # variables in .mk-files clobber one another.  Be careful to use :=
 # where appropriate for immediate evaluation, and similarly to watch
 # that you're not relying on a variable value to last beween different
 # .mk files.
 #
 # TODOs:
 #
 # Global settings and utility functions are currently stuffed in the
 # toplevel Makefile.  It may make sense to generate some .mk files on
 # the side to keep the the files readable.
 
+from __future__ import print_function
+
 import os
 import re
 import sys
 import subprocess
 import gyp
 import gyp.common
 import gyp.xcode_emulation
 from gyp.common import GetEnvironFallback
 from gyp.common import GypError
 
@@ skipping 604 matching lines @@
   for source in all_sources:
     name, ext = os.path.splitext(source)
     is_compiled_file = ext in [
         '.c', '.cc', '.cpp', '.cxx', '.m', '.mm', '.s', '.S']
     if not is_compiled_file:
       continue
     basename = os.path.basename(name)  # Don't include extension.
     basenames.setdefault(basename, []).append(source)
 
   error = ''
-  for basename, files in basenames.iteritems():
+  for basename, files in basenames.items():
     if len(files) > 1:
       error += '  %s: %s\n' % (basename, ' '.join(files))
 
   if error:
     print('static library %s has several files with the same basename:\n' %
           spec['target_name'] + error + 'libtool on OS X will generate' +
           ' warnings for them.')
     raise GypError('Duplicate basenames in sources section, see list above')
 
 
@@ skipping 127 matching lines @@
       if self.flavor == 'mac':
         # libtool on OS X generates warnings for duplicate basenames in the same
         # target.
         _ValidateSourcesForOSX(spec, all_sources)
       self.WriteSources(
           configs, deps, all_sources, extra_outputs,
           extra_link_deps, part_of_all,
           gyp.xcode_emulation.MacPrefixHeader(
               self.xcode_settings, lambda p: Sourceify(self.Absolutify(p)),
               self.Pchify))
-      sources = filter(Compilable, all_sources)
+      sources = [x for x in all_sources if Compilable(x)]
       if sources:
         self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT1)
         extensions = set([os.path.splitext(s)[1] for s in sources])
         for ext in extensions:
           if ext in self.suffix_rules_srcdir:
             self.WriteLn(self.suffix_rules_srcdir[ext])
         self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT2)
         for ext in extensions:
           if ext in self.suffix_rules_objdir1:
             self.WriteLn(self.suffix_rules_objdir1[ext])
@@ skipping 108 matching lines @@
       # actions run on the host, so they should in theory only use host
       # libraries, but until everything is made cross-compile safe, also use
       # target libraries.
       # TODO(piman): when everything is cross-compile safe, remove lib.target
       self.WriteLn('cmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:'
                    '$(builddir)/lib.target:$$LD_LIBRARY_PATH; '
                    'export LD_LIBRARY_PATH; '
                    '%s%s'
                    % (name, cd_action, command))
       self.WriteLn()
-      outputs = map(self.Absolutify, outputs)
+      outputs = [self.Absolutify(o) for o in outputs]
       # The makefile rules are all relative to the top dir, but the gyp actions
       # are defined relative to their containing dir.  This replaces the obj
       # variable for the action rule with an absolute version so that the output
       # goes in the right place.
       # Only write the 'obj' and 'builddir' rules for the "primary" output (:1);
       # it's superfluous for the "extra outputs", and this avoids accidentally
       # writing duplicate dummy rules for those outputs.
       # Same for environment.
       self.WriteLn("%s: obj := $(abs_obj)" % QuoteSpaces(outputs[0]))
       self.WriteLn("%s: builddir := $(abs_builddir)" % QuoteSpaces(outputs[0]))
@@ skipping 69 matching lines @@
           # which is fine in hash-based dependency systems like scons
           # and forge, but not kosher in the make world.  After some
           # discussion, hacking around it here seems like the least
           # amount of pain.
           actions += ['@touch --no-create $@']
 
         # See the comment in WriteCopies about expanding env vars.
         outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]
         inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]
 
-        outputs = map(self.Absolutify, outputs)
+        outputs = [self.Absolutify(o) for o in outputs]
         all_outputs += outputs
         # Only write the 'obj' and 'builddir' rules for the "primary" output
         # (:1); it's superfluous for the "extra outputs", and this avoids
         # accidentally writing duplicate dummy rules for those outputs.
         self.WriteLn('%s: obj := $(abs_obj)' % outputs[0])
         self.WriteLn('%s: builddir := $(abs_builddir)' % outputs[0])
         self.WriteMakeRule(outputs, inputs, actions,
                            command="%s_%d" % (name, count))
         # Spaces in rule filenames are not supported, but rule variables have
         # spaces in them (e.g. RULE_INPUT_PATH expands to '$(abspath $<)').
@@ skipping 177 matching lines @@
       self.WriteList(cflags_c, 'CFLAGS_C_%s' % configname)
       self.WriteLn("# Flags passed to only C++ files.");
       self.WriteList(cflags_cc, 'CFLAGS_CC_%s' % configname)
       if self.flavor == 'mac':
         self.WriteLn("# Flags passed to only ObjC files.");
         self.WriteList(cflags_objc, 'CFLAGS_OBJC_%s' % configname)
         self.WriteLn("# Flags passed to only ObjC++ files.");
         self.WriteList(cflags_objcc, 'CFLAGS_OBJCC_%s' % configname)
       includes = config.get('include_dirs')
       if includes:
-        includes = map(Sourceify, map(self.Absolutify, includes))
+        includes = [Sourceify(self.Absolutify(include)) for include in includes]
       self.WriteList(includes, 'INCS_%s' % configname, prefix='-I')
 
     compilable = filter(Compilable, sources)
-    objs = map(self.Objectify, map(self.Absolutify, map(Target, compilable)))
+    objs = [self.Objectify(self.Absolutify(Target(x))) for x in compilable]
     self.WriteList(objs, 'OBJS')
 
     for obj in objs:
       assert ' ' not in obj, (
           "Spaces in object filenames not supported (%s)"  % obj)
     self.WriteLn('# Add to the list of files we specially track '
                  'dependencies for.')
     self.WriteLn('all_deps += $(OBJS)')
     self.WriteLn()
 
@@ skipping 51 matching lines @@
                      "$(INCS_$(BUILDTYPE)) "
                      "%s " % precompiled_header.GetInclude('mm') +
                      "$(CFLAGS_$(BUILDTYPE)) "
                      "$(CFLAGS_CC_$(BUILDTYPE)) "
                      "$(CFLAGS_OBJCC_$(BUILDTYPE))")
 
     self.WritePchTargets(precompiled_header.GetPchBuildCommands())
 
     # If there are any object files in our input file list, link them into our
     # output.
-    extra_link_deps += filter(Linkable, sources)
+    extra_link_deps += [source for source in sources if Linkable(source)]
 
     self.WriteLn()
 
   def WritePchTargets(self, pch_commands):
     """Writes make rules to compile prefix headers."""
     if not pch_commands:
       return
 
     for gch, lang_flag, lang, input in pch_commands:
       extra_flags = {
@@ skipping 44 matching lines @@
       target_prefix = 'lib'
       target_ext = '.a'
     elif self.type in ('loadable_module', 'shared_library'):
       if target[:3] == 'lib':
         target = target[3:]
       target_prefix = 'lib'
       target_ext = '.so'
     elif self.type == 'none':
       target = '%s.stamp' % target
     elif self.type != 'executable':
-      print ("ERROR: What output file should be generated?",
-             "type", self.type, "target", target)
+      print(("ERROR: What output file should be generated?",
+             "type", self.type, "target", target))
 
     target_prefix = spec.get('product_prefix', target_prefix)
     target = spec.get('product_name', target)
     product_ext = spec.get('product_extension')
     if product_ext:
       target_ext = '.' + product_ext
 
     return target_prefix + target + target_ext
 
 
@@ skipping 143 matching lines @@
 
       for configname in target_postbuilds:
         self.WriteLn('%s: TARGET_POSTBUILDS_%s := %s' %
             (QuoteSpaces(self.output),
              configname,
              gyp.common.EncodePOSIXShellList(target_postbuilds[configname])))
 
       # Postbuilds expect to be run in the gyp file's directory, so insert an
       # implicit postbuild to cd to there.
       postbuilds.insert(0, gyp.common.EncodePOSIXShellList(['cd', self.path]))
-      for i in xrange(len(postbuilds)):
-        if not postbuilds[i].startswith('$'):
-          postbuilds[i] = EscapeShellArgument(postbuilds[i])
+      for i, postbuild in enumerate(postbuilds):
+        if not postbuild.startswith('$'):
+          postbuilds[i] = EscapeShellArgument(postbuild)
       self.WriteLn('%s: builddir := $(abs_builddir)' % QuoteSpaces(self.output))
       self.WriteLn('%s: POSTBUILDS := %s' % (
           QuoteSpaces(self.output), ' '.join(postbuilds)))
 
     # A bundle directory depends on its dependencies such as bundle resources
     # and bundle binary. When all dependencies have been built, the bundle
     # needs to be packaged.
     if self.is_mac_bundle:
       # If the framework doesn't contain a binary, then nothing depends
       # on the actions -- make the framework depend on them directly too.
@@ skipping 69 matching lines @@
                         part_of_all, postbuilds=postbuilds)
       else:
         self.WriteDoCmd(
             [self.output_binary], link_deps, 'solink_module', part_of_all,
             postbuilds=postbuilds)
     elif self.type == 'none':
       # Write a stamp line.
       self.WriteDoCmd([self.output_binary], deps, 'touch', part_of_all,
                       postbuilds=postbuilds)
     else:
-      print "WARNING: no output for", self.type, target
+      print("WARNING: no output for", self.type, target)
 
     # Add an alias for each target (if there are any outputs).
     # Installable target aliases are created below.
     if ((self.output and self.output != self.target) and
         (self.type not in self._INSTALLABLE_TARGETS)):
       self.WriteMakeRule([self.target], [self.output],
                          comment='Add target alias', phony = True)
       if part_of_all:
         self.WriteMakeRule(['all'], [self.target],
                            comment = 'Add target alias to "all" target.',
@@ skipping 86 matching lines @@
     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
     command: (optional) command name to generate unambiguous labels
     """
-    outputs = map(QuoteSpaces, outputs)
+    outputs = [QuoteSpaces(o) for o in outputs]
     inputs = map(QuoteSpaces, inputs)
 
     if comment:
       self.WriteLn('# ' + comment)
     if phony:
       self.WriteLn('.PHONY: ' + ' '.join(outputs))
     if actions:
       self.WriteLn("%s: TOOLSET := $(TOOLSET)" % outputs[0])
     force_append = ' FORCE_DO_CMD' if force else ''
 
@@ skipping 221 matching lines @@
                      build_files_args)})
 
 
 def PerformBuild(data, configurations, params):
   options = params['options']
   for config in configurations:
     arguments = ['make']
     if options.toplevel_dir and options.toplevel_dir != '.':
       arguments += '-C', options.toplevel_dir
     arguments.append('BUILDTYPE=' + config)
-    print 'Building [%s]: %s' % (config, arguments)
+    print('Building [%s]: %s' % (config, arguments))
     subprocess.check_call(arguments)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   options = params['options']
   flavor = gyp.common.GetFlavor(params)
   generator_flags = params.get('generator_flags', {})
   builddir_name = generator_flags.get('output_dir', 'out')
   android_ndk_version = generator_flags.get('android_ndk_version', None)
   default_target = generator_flags.get('default_target', 'all')
@@ skipping 238 matching lines @@
     root_makefile.write("endif\n")
   root_makefile.write('\n')
 
   if (not generator_flags.get('standalone')
       and generator_flags.get('auto_regeneration', True)):
     WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)
 
   root_makefile.write(SHARED_FOOTER)
 
   root_makefile.close()