Python 3 compatibility

pylib/gyp/generator/ninja.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.
 
+from __future__ import print_function
+
 import collections
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
 import re
 import signal
 import subprocess
 import sys
 import gyp
 import gyp.common
 from gyp.common import OrderedSet
 import gyp.msvs_emulation
 import gyp.MSVSUtil as MSVSUtil
 import gyp.xcode_emulation
-from cStringIO import StringIO
+try:
+  from cStringIO import StringIO
+except ImportError:
+  from io import StringIO
 
 from gyp.common import GetEnvironFallback
 import gyp.ninja_syntax as ninja_syntax
 
 generator_default_variables = {
   'EXECUTABLE_PREFIX': '',
   'EXECUTABLE_SUFFIX': '',
   'STATIC_LIB_PREFIX': 'lib',
   'STATIC_LIB_SUFFIX': '.a',
   'SHARED_LIB_PREFIX': 'lib',
@@ skipping 308 matching lines @@
       path_basename = self.name + '.' + path_basename
     return os.path.normpath(os.path.join(obj, self.base_dir, path_dir,
                                          path_basename))
 
   def WriteCollapsedDependencies(self, name, targets, order_only=None):
     """Given a list of targets, return a path for a single file
     representing the result of building all the targets or None.
 
     Uses a stamp file if necessary."""
 
-    assert targets == filter(None, targets), targets
+    assert targets == [t for t in targets if t], targets
     if len(targets) == 0:
       assert not order_only
       return None
     if len(targets) > 1 or order_only:
       stamp = self.GypPathToUniqueOutput(name + '.stamp')
       targets = self.ninja.build(stamp, 'stamp', targets, order_only=order_only)
       self.ninja.newline()
     return targets[0]
 
   def _SubninjaNameForArch(self, arch):
@@ skipping 57 matching lines @@
     actions_depends = []
     compile_depends = []
     # TODO(evan): it is rather confusing which things are lists and which
     # are strings.  Fix these.
     if 'dependencies' in spec:
       for dep in spec['dependencies']:
         if dep in self.target_outputs:
           target = self.target_outputs[dep]
           actions_depends.append(target.PreActionInput(self.flavor))
           compile_depends.append(target.PreCompileInput())
-      actions_depends = filter(None, actions_depends)
-      compile_depends = filter(None, compile_depends)
+      actions_depends = [d for d in actions_depends if d]
+      compile_depends = [d for d in compile_depends if d]
       actions_depends = self.WriteCollapsedDependencies('actions_depends',
                                                         actions_depends)
       compile_depends = self.WriteCollapsedDependencies('compile_depends',
                                                         compile_depends)
       self.target.preaction_stamp = actions_depends
       self.target.precompile_stamp = compile_depends
 
     # Write out actions, rules, and copies.  These must happen before we
     # compile any sources, so compute a list of predependencies for sources
     # while we do it.
@@ skipping 31 matching lines @@
             lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang))
       link_deps = self.WriteSources(
           self.ninja, config_name, config, sources, compile_depends_stamp, pch,
           spec)
       # Some actions/rules output 'sources' that are already object files.
       obj_outputs = [f for f in sources if f.endswith(self.obj_ext)]
       if obj_outputs:
         if self.flavor != 'mac' or len(self.archs) == 1:
           link_deps += [self.GypPathToNinja(o) for o in obj_outputs]
         else:
-          print "Warning: Actions/rules writing object files don't work with " \
-                "multiarch targets, dropping. (target %s)" % spec['target_name']
+          print("Warning: Actions/rules writing object files don't work with " \
+                "multiarch targets, dropping. (target %s)" % spec['target_name'])
     elif self.flavor == 'mac' and len(self.archs) > 1:
       link_deps = collections.defaultdict(list)
 
     compile_deps = self.target.actions_stamp or actions_depends
     if self.flavor == 'win' and self.target.type == 'static_library':
       self.target.component_objs = link_deps
       self.target.compile_deps = compile_deps
 
     # Write out a link step, if needed.
     output = None
@@ skipping 331 matching lines @@
     at each invocation of ninja."""
     if not xcassets:
       return
 
     extra_arguments = {}
     settings_to_arg = {
         'XCASSETS_APP_ICON': 'app-icon',
         'XCASSETS_LAUNCH_IMAGE': 'launch-image',
     }
     settings = self.xcode_settings.xcode_settings[self.config_name]
-    for settings_key, arg_name in settings_to_arg.iteritems():
+    for settings_key, arg_name in settings_to_arg.items():
       value = settings.get(settings_key)
       if value:
         extra_arguments[arg_name] = value
 
     partial_info_plist = None
     if extra_arguments:
       partial_info_plist = self.GypPathToUniqueOutput(
           'assetcatalog_generated_info.plist')
       extra_arguments['output-partial-info-plist'] = partial_info_plist
 
@@ skipping 909 matching lines @@
         ("ullAvailVirtual", ctypes.c_ulonglong),
         ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
       ]
 
     stat = MEMORYSTATUSEX()
     stat.dwLength = ctypes.sizeof(stat)
     ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
 
     # VS 2015 uses 20% more working set than VS 2013 and can consume all RAM
     # on a 64 GB machine.
-    mem_limit = max(1, stat.ullTotalPhys / (5 * (2 ** 30)))  # total / 5GB
+    mem_limit = max(1, stat.ullTotalPhys // (5 * (2 ** 30)))  # total / 5GB
     hard_cap = max(1, int(os.environ.get('GYP_LINK_CONCURRENCY_MAX', 2**32)))
     return min(mem_limit, hard_cap)
   elif sys.platform.startswith('linux'):
     if os.path.exists("/proc/meminfo"):
       with open("/proc/meminfo") as meminfo:
         memtotal_re = re.compile(r'^MemTotal:\s*(\d*)\s*kB')
         for line in meminfo:
           match = memtotal_re.match(line)
           if not match:
             continue
           # Allow 8Gb per link on Linux because Gold is quite memory hungry
-          return max(1, int(match.group(1)) / (8 * (2 ** 20)))
+          return max(1, int(match.group(1)) // (8 * (2 ** 20)))
     return 1
   elif sys.platform == 'darwin':
     try:
       avail_bytes = int(subprocess.check_output(['sysctl', '-n', 'hw.memsize']))
       # A static library debug build of Chromium's unit_tests takes ~2.7GB, so
       # 4GB per ld process allows for some more bloat.
-      return max(1, avail_bytes / (4 * (2 ** 30)))  # total / 4GB
+      return max(1, avail_bytes // (4 * (2 ** 30)))  # total / 4GB
     except:
       return 1
   else:
     # TODO(scottmg): Implement this for other platforms.
     return 1
 
 
 def _GetWinLinkRuleNameSuffix(embed_manifest):
   """Returns the suffix used to select an appropriate linking rule depending on
   whether the manifest embedding is enabled."""
@@ skipping 134 matching lines @@
     if key == 'NM.host':
       nm_host = os.path.join(build_to_root, value)
     if key == 'READELF':
       readelf = os.path.join(build_to_root, value)
     if key == 'READELF.host':
       readelf_host = os.path.join(build_to_root, value)
     if key.endswith('_wrapper'):
       wrappers[key[:-len('_wrapper')]] = os.path.join(build_to_root, value)
 
   # Support wrappers from environment variables too.
-  for key, value in os.environ.iteritems():
+  for key, value in os.environ.items():
     if key.lower().endswith('_wrapper'):
       key_prefix = key[:-len('_wrapper')]
       key_prefix = re.sub(r'\.HOST$', '.host', key_prefix)
       wrappers[key_prefix] = os.path.join(build_to_root, value)
 
   mac_toolchain_dir = generator_flags.get('mac_toolchain_dir', None)
   if mac_toolchain_dir:
     wrappers['LINK'] = "export DEVELOPER_DIR='%s' &&" % mac_toolchain_dir
 
   if flavor == 'win':
     configs = [target_dicts[qualified_target]['configurations'][config_name]
                for qualified_target in target_list]
     shared_system_includes = None
     if not generator_flags.get('ninja_use_custom_environment_files', 0):
       shared_system_includes = \
           gyp.msvs_emulation.ExtractSharedMSVSSystemIncludes(
               configs, generator_flags)
     cl_paths = gyp.msvs_emulation.GenerateEnvironmentFiles(
         toplevel_build, generator_flags, shared_system_includes, OpenOutput)
-    for arch, path in sorted(cl_paths.iteritems()):
+    for arch, path in sorted(cl_paths.items()):
       if clang_cl:
         # If we have selected clang-cl, use that instead.
         path = clang_cl
       command = CommandWithWrapper('CC', wrappers,
           QuoteShellArgument(path, 'win'))
       if clang_cl:
         # Use clang-cl to cross-compile for x86 or x86_64.
         command += (' -m32' if arch == 'x86' else ' -m64')
       master_ninja.variable('cl_' + arch, command)
 
@@ skipping 387 matching lines @@
       gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
 
     # If build_file is a symlink, we must not follow it because there's a chance
     # it could point to a path above toplevel_dir, and we cannot correctly deal
     # with that case at the moment.
     build_file = gyp.common.RelativePath(build_file, options.toplevel_dir,
                                          False)
 
     qualified_target_for_hash = gyp.common.QualifiedTarget(build_file, name,
                                                            toolset)
+    qualified_target_for_hash = qualified_target_for_hash.encode('utf-8')
     hash_for_rules = hashlib.md5(qualified_target_for_hash).hexdigest()
 
     base_path = os.path.dirname(build_file)
     obj = 'obj'
     if toolset != 'target':
       obj += '.' + toolset
     output_file = os.path.join(obj, base_path, name + '.ninja')
 
     ninja_output = StringIO()
     writer = NinjaWriter(hash_for_rules, target_outputs, base_path, build_dir,
@@ skipping 46 matching lines @@
     master_ninja.default(generator_flags.get('default_target', 'all'))
 
   master_ninja_file.close()
 
 
 def PerformBuild(data, configurations, params):
   options = params['options']
   for config in configurations:
     builddir = os.path.join(options.toplevel_dir, 'out', config)
     arguments = ['ninja', '-C', builddir]
-    print 'Building [%s]: %s' % (config, arguments)
+    print('Building [%s]: %s' % (config, arguments))
     subprocess.check_call(arguments)
 
 
 def CallGenerateOutputForConfig(arglist):
   # Ignore the interrupt signal so that the parent process catches it and
   # kills all multiprocessing children.
   signal.signal(signal.SIGINT, signal.SIG_IGN)
 
   (target_list, target_dicts, data, params, config_name) = arglist
   GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   # Update target_dicts for iOS device builds.
   target_dicts = gyp.xcode_emulation.CloneConfigurationForDeviceAndEmulator(
       target_dicts)
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if gyp.common.GetFlavor(params) == 'win':
     target_list, target_dicts = MSVSUtil.ShardTargets(target_list, target_dicts)
     target_list, target_dicts = MSVSUtil.InsertLargePdbShims(
         target_list, target_dicts, generator_default_variables)
 
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
-    config_names = target_dicts[target_list[0]]['configurations'].keys()
+    config_names = target_dicts[target_list[0]]['configurations']
     if params['parallel']:
       try:
         pool = multiprocessing.Pool(len(config_names))
         arglists = []
         for config_name in config_names:
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
-      except KeyboardInterrupt, e:
+      except KeyboardInterrupt as e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)