Python 3 compatibility

pylib/gyp/xcode_emulation.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.
 
 """
 This module contains classes that help to emulate xcodebuild behavior on top of
 other build systems, such as make and ninja.
 """
 
+from __future__ import print_function
+
 import copy
 import gyp.common
 import os
 import os.path
 import re
 import shlex
 import subprocess
 import sys
 import tempfile
 from gyp.common import GypError
@@ skipping 46 matching lines @@
     expanded_archs = []
     for arch in archs:
       if self.variable_pattern.match(arch):
         variable = arch
         try:
           variable_expansion = variable_mapping[variable]
           for arch in variable_expansion:
             if arch not in expanded_archs:
               expanded_archs.append(arch)
         except KeyError as e:
-          print 'Warning: Ignoring unsupported variable "%s".' % variable
+          print('Warning: Ignoring unsupported variable "%s".' % variable)
       elif arch not in expanded_archs:
         expanded_archs.append(arch)
     return expanded_archs
 
   def ActiveArchs(self, archs, valid_archs, sdkroot):
     """Expands variables references in ARCHS, and filter by VALID_ARCHS if it
     is defined (if not set, Xcode accept any value in ARCHS, otherwise, only
     values present in VALID_ARCHS are kept)."""
     expanded_archs = self._ExpandArchs(archs or self._default, sdkroot or '')
     if valid_archs:
@@ skipping 77 matching lines @@
     self.isIOS = False
     self.mac_toolchain_dir = None
     self.header_map_path = None
 
     # Per-target 'xcode_settings' are pushed down into configs earlier by gyp.
     # This means self.xcode_settings[config] always contains all settings
     # for that config -- the per-target settings as well. Settings that are
     # the same for all configs are implicitly per-target settings.
     self.xcode_settings = {}
     configs = spec['configurations']
-    for configname, config in configs.iteritems():
+    for configname, config in configs.items():
       self.xcode_settings[configname] = config.get('xcode_settings', {})
       self._ConvertConditionalKeys(configname)
       if self.xcode_settings[configname].get('IPHONEOS_DEPLOYMENT_TARGET',
                                              None):
         self.isIOS = True
 
     # This is only non-None temporarily during the execution of some methods.
     self.configname = None
 
     # Used by _AdjustLibrary to match .a and .dylib entries in libraries.
     self.library_re = re.compile(r'^lib([^/]+)\.(a|dylib)$')
 
   def _ConvertConditionalKeys(self, configname):
     """Converts or warns on conditional keys.  Xcode supports conditional keys,
     such as CODE_SIGN_IDENTITY[sdk=iphoneos*].  This is a partial implementation
     with some keys converted while the rest force a warning."""
     settings = self.xcode_settings[configname]
     conditional_keys = [key for key in settings if key.endswith(']')]
     for key in conditional_keys:
       # If you need more, speak up at http://crbug.com/122592
       if key.endswith("[sdk=iphoneos*]"):
         if configname.endswith("iphoneos"):
           new_key = key.split("[")[0]
           settings[new_key] = settings[key]
       else:
-        print 'Warning: Conditional keys not implemented, ignoring:', \
-              ' '.join(conditional_keys)
+        print('Warning: Conditional keys not implemented, ignoring:', \
+              ' '.join(conditional_keys))
       del settings[key]
 
   def _Settings(self):
     assert self.configname
     return self.xcode_settings[self.configname]
 
   def _Test(self, test_key, cond_key, default):
     return self._Settings().get(test_key, default) == cond_key
 
   def _Appendf(self, lst, test_key, format_str, default=None):
     if test_key in self._Settings():
       lst.append(format_str % str(self._Settings()[test_key]))
     elif default:
       lst.append(format_str % str(default))
 
   def _WarnUnimplemented(self, test_key):
     if test_key in self._Settings():
-      print 'Warning: Ignoring not yet implemented key "%s".' % test_key
+      print('Warning: Ignoring not yet implemented key "%s".' % test_key)
 
   def IsBinaryOutputFormat(self, configname):
     default = "binary" if self.isIOS else "xml"
     format = self.xcode_settings[configname].get('INFOPLIST_OUTPUT_FORMAT',
                                                  default)
     return format == "binary"
 
   def IsIosFramework(self):
     return self.spec['type'] == 'shared_library' and self._IsBundle() and \
         self.isIOS
@@ skipping 669 matching lines @@
   def GetPerTargetSettings(self):
     """Gets a list of all the per-target settings. This will only fetch keys
     whose values are the same across all configurations."""
     first_pass = True
     result = {}
     for configname in sorted(self.xcode_settings.keys()):
       if first_pass:
         result = dict(self.xcode_settings[configname])
         first_pass = False
       else:
-        for key, value in self.xcode_settings[configname].iteritems():
+        for key, value in self.xcode_settings[configname].items():
           if key not in result:
             continue
           elif result[key] != value:
             del result[key]
     return result
 
   def GetPerConfigSetting(self, setting, configname, default=None):
     if configname in self.xcode_settings:
       return self.xcode_settings[configname].get(setting, default)
     else:
@@ skipping 90 matching lines @@
 
     settings = self.xcode_settings[configname]
     key = self._GetIOSCodeSignIdentityKey(settings)
     if not key:
       return []
 
     # Warn for any unimplemented signing xcode keys.
     unimpl = ['OTHER_CODE_SIGN_FLAGS']
     unimpl = set(unimpl) & set(self.xcode_settings[configname].keys())
     if unimpl:
-      print 'Warning: Some codesign keys not implemented, ignoring: %s' % (
-          ', '.join(sorted(unimpl)))
+      print('Warning: Some codesign keys not implemented, ignoring: %s' % (
+          ', '.join(sorted(unimpl))))
 
     return ['%s code-sign-bundle "%s" "%s" "%s"' % (
         os.path.join('${TARGET_BUILD_DIR}', 'gyp-mac-tool'), key,
         settings.get('CODE_SIGN_ENTITLEMENTS', ''),
         settings.get('PROVISIONING_PROFILE', ''))
     ]
 
   def _GetIOSCodeSignIdentityKey(self, settings):
     identity = settings.get('CODE_SIGN_IDENTITY')
     if not identity:
@@ skipping 582 matching lines @@
       assert '${' not in dependee, 'Nested variables not supported: ' + dependee
     return matches
 
   try:
     # Topologically sort, and then reverse, because we used an edge definition
     # that's inverted from the expected result of this function (see comment
     # above).
     order = gyp.common.TopologicallySorted(env.keys(), GetEdges)
     order.reverse()
     return order
-  except gyp.common.CycleError, e:
+  except gyp.common.CycleError as e:
     raise GypError(
         'Xcode environment variables are cyclically dependent: ' + str(e.nodes))
 
 
 def GetSortedXcodeEnv(xcode_settings, built_products_dir, srcroot,
                       configuration, additional_settings=None):
   env = _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
                     additional_settings)
   return [(key, env[key]) for key in _TopologicallySortedEnvVarKeys(env)]
 
@@ skipping 16 matching lines @@
   for target_dict in targets.values():
     for config in target_dict['configurations'].values():
       if config.get('xcode_settings', {}).get('IPHONEOS_DEPLOYMENT_TARGET'):
         return True
   return False
 
 
 def _AddIOSDeviceConfigurations(targets):
   """Clone all targets and append -iphoneos to the name. Configure these targets
   to build for iOS devices and use correct architectures for those builds."""
-  for target_dict in targets.itervalues():
+  for target_dict in targets.values():
     toolset = target_dict['toolset']
     configs = target_dict['configurations']
-    for config_name, config_dict in dict(configs).iteritems():
+    for config_name, config_dict in dict(configs).items():
       iphoneos_config_dict = copy.deepcopy(config_dict)
       configs[config_name + '-iphoneos'] = iphoneos_config_dict
       configs[config_name + '-iphonesimulator'] = config_dict
       if toolset == 'target':
         iphoneos_config_dict['xcode_settings']['SDKROOT'] = 'iphoneos'
   return targets
 
 def CloneConfigurationForDeviceAndEmulator(target_dicts):
   """If |target_dicts| contains any iOS targets, automatically create -iphoneos
   targets for iOS device builds."""
   if _HasIOSTarget(target_dicts):
     return _AddIOSDeviceConfigurations(target_dicts)
   return target_dicts