Python 3 compatibility

pylib/gyp/generator/xcode.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.
 
+from __future__ import print_function
+
 import filecmp
 import gyp.common
 import gyp.xcodeproj_file
 import gyp.xcode_ninja
 import errno
 import os
 import sys
 import posixpath
 import re
 import shutil
@@ skipping 106 matching lines @@
         gyp.xcodeproj_file.XCProjectFile({'rootObject': self.project})
     self.build_file_dict = build_file_dict
 
     # TODO(mark): add destructor that cleans up self.path if created_dir is
     # True and things didn't complete successfully.  Or do something even
     # better with "try"?
     self.created_dir = False
     try:
       os.makedirs(self.path)
       self.created_dir = True
-    except OSError, e:
+    except OSError as e:
       if e.errno != errno.EEXIST:
         raise
 
   def Finalize1(self, xcode_targets, serialize_all_tests):
     # Collect a list of all of the build configuration names used by the
     # various targets in the file.  It is very heavily advised to keep each
     # target in an entire project (even across multiple project files) using
     # the same set of configuration names.
     configurations = []
     for xct in self.project.GetProperty('targets'):
@@ skipping 33 matching lines @@
 
     # Set user-specified project-wide build settings and config files.  This
     # is intended to be used very sparingly.  Really, almost everything should
     # go into target-specific build settings sections.  The project-wide
     # settings are only intended to be used in cases where Xcode attempts to
     # resolve variable references in a project context as opposed to a target
     # context, such as when resolving sourceTree references while building up
     # the tree tree view for UI display.
     # Any values set globally are applied to all configurations, then any
     # per-configuration values are applied.
-    for xck, xcv in self.build_file_dict.get('xcode_settings', {}).iteritems():
+    for xck, xcv in self.build_file_dict.get('xcode_settings', {}).items():
       xccl.SetBuildSetting(xck, xcv)
     if 'xcode_config_file' in self.build_file_dict:
       config_ref = self.project.AddOrGetFileInRootGroup(
           self.build_file_dict['xcode_config_file'])
       xccl.SetBaseConfiguration(config_ref)
     build_file_configurations = self.build_file_dict.get('configurations', {})
     if build_file_configurations:
       for config_name in configurations:
         build_file_configuration_named = \
             build_file_configurations.get(config_name, {})
         if build_file_configuration_named:
           xcc = xccl.ConfigurationNamed(config_name)
           for xck, xcv in build_file_configuration_named.get('xcode_settings',
-                                                             {}).iteritems():
+                                                             {}).items():
             xcc.SetBuildSetting(xck, xcv)
           if 'xcode_config_file' in build_file_configuration_named:
             config_ref = self.project.AddOrGetFileInRootGroup(
                 build_file_configurations[config_name]['xcode_config_file'])
             xcc.SetBaseConfiguration(config_ref)
 
     # Sort the targets based on how they appeared in the input.
     # TODO(mark): Like a lot of other things here, this assumes internal
     # knowledge of PBXProject - in this case, of its "targets" property.
 
@@ skipping 55 matching lines @@
         script = ''
         if command.get('working_directory'):
           script = script + 'cd "%s"\n' % \
                    gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
                        command.get('working_directory'))
 
         if command.get('environment'):
           script = script + "\n".join(
             ['export %s="%s"' %
              (key, gyp.xcodeproj_file.ConvertVariablesToShellSyntax(val))
-             for (key, val) in command.get('environment').iteritems()]) + "\n"
+             for (key, val) in command.get('environment').items()]) + "\n"
 
         # Some test end up using sockets, files on disk, etc. and can get
         # confused if more then one test runs at a time.  The generator
         # flag 'xcode_serialize_all_test_runs' controls the forcing of all
         # tests serially.  It defaults to True.  To get serial runs this
         # little bit of python does the same as the linux flock utility to
         # make sure only one runs at a time.
         command_prefix = ''
         if serialize_all_tests:
           command_prefix = \
@@ skipping 150 matching lines @@
     # the new project file is simply deleted.  Xcode properly detects a file
     # being renamed over an open project file as a change and so it remains
     # able to present the "project file changed" sheet under this system.
     # Writing to a temporary file first also avoids the possible problem of
     # Xcode rereading an incomplete project file.
     (output_fd, new_pbxproj_path) = \
         tempfile.mkstemp(suffix='.tmp', prefix='project.pbxproj.gyp.',
                          dir=self.path)
 
     try:
-      output_file = os.fdopen(output_fd, 'wb')
+      output_file = os.fdopen(output_fd, 'w')
 
       self.project_file.Print(output_file)
       output_file.close()
 
       pbxproj_path = os.path.join(self.path, 'project.pbxproj')
 
       same = False
       try:
         same = filecmp.cmp(pbxproj_path, new_pbxproj_path, False)
-      except OSError, e:
+      except OSError as e:
         if e.errno != errno.ENOENT:
           raise
 
       if same:
         # The new file is identical to the old one, just get rid of the new
         # one.
         os.unlink(new_pbxproj_path)
       else:
         # The new file is different from the old one, or there is no old one.
         # Rename the new file to the permanent name.
         #
         # tempfile.mkstemp uses an overly restrictive mode, resulting in a
         # file that can only be read by the owner, regardless of the umask.
         # There's no reason to not respect the umask here, which means that
         # an extra hoop is required to fetch it and reset the new file's mode.
         #
         # No way to get the umask without setting a new one?  Set a safe one
         # and then set it back to the old value.
-        umask = os.umask(077)
+        umask = os.umask(0o77)
         os.umask(umask)
 
-        os.chmod(new_pbxproj_path, 0666 & ~umask)
+        os.chmod(new_pbxproj_path, 0o666 & ~umask)
         os.rename(new_pbxproj_path, pbxproj_path)
 
     except Exception:
       # Don't leave turds behind.  In fact, if this code was responsible for
       # creating the xcodeproj directory, get rid of that too.
       os.unlink(new_pbxproj_path)
       if self.created_dir:
         shutil.rmtree(self.path, True)
       raise
 
@@ skipping 69 matching lines @@
   """We must escape the defines that we give to XCode so that it knows not to
      split on spaces and to respect backslash and quote literals. However, we
      must not quote the define, or Xcode will incorrectly intepret variables
      especially $(inherited)."""
   return re.sub(_xcode_define_re, r'\\\1', s)
 
 
 def PerformBuild(data, configurations, params):
   options = params['options']
 
-  for build_file, build_file_dict in data.iteritems():
+  for build_file, build_file_dict in data.items():
     (build_file_root, build_file_ext) = os.path.splitext(build_file)
     if build_file_ext != '.gyp':
       continue
     xcodeproj_path = build_file_root + options.suffix + '.xcodeproj'
     if options.generator_output:
       xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
 
   for config in configurations:
     arguments = ['xcodebuild', '-project', xcodeproj_path]
     arguments += ['-configuration', config]
-    print "Building [%s]: %s" % (config, arguments)
+    print("Building [%s]: %s" % (config, arguments))
     subprocess.check_call(arguments)
 
 
 def CalculateGeneratorInputInfo(params):
   toplevel = params['options'].toplevel_dir
   if params.get('flavor') == 'ninja':
     generator_dir = os.path.relpath(params['options'].generator_output or '.')
     output_dir = params.get('generator_flags', {}).get('output_dir', 'out')
     output_dir = os.path.normpath(os.path.join(generator_dir, output_dir))
     qualified_out_dir = os.path.normpath(os.path.join(
@@ skipping 27 matching lines @@
 
   # Format upgrade_check_project_version with leading zeros as needed.
   if upgrade_check_project_version:
     upgrade_check_project_version = str(upgrade_check_project_version)
     while len(upgrade_check_project_version) < 4:
       upgrade_check_project_version = '0' + upgrade_check_project_version
 
   skip_excluded_files = \
       not generator_flags.get('xcode_list_excluded_files', True)
   xcode_projects = {}
-  for build_file, build_file_dict in data.iteritems():
+  for build_file, build_file_dict in data.items():
     (build_file_root, build_file_ext) = os.path.splitext(build_file)
     if build_file_ext != '.gyp':
       continue
     xcodeproj_path = build_file_root + options.suffix + '.xcodeproj'
     if options.generator_output:
       xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
     xcp = XcodeProject(build_file, xcodeproj_path, build_file_dict)
     xcode_projects[build_file] = xcp
     pbxp = xcp.project
 
@@ skipping 91 matching lines @@
       elif is_watch_app:
         assert is_bundle, ('ios_watch_app flag requires mac_bundle '
             '(target %s)' % target_name)
         type_bundle_key += '+watch+bundle'
       elif is_bundle:
         type_bundle_key += '+bundle'
 
       xctarget_type = gyp.xcodeproj_file.PBXNativeTarget
       try:
         target_properties['productType'] = _types[type_bundle_key]
-      except KeyError, e:
+      except KeyError as e:
         gyp.common.ExceptionAppend(e, "-- unknown product type while "
                                    "writing target %s" % target_name)
         raise
     else:
       xctarget_type = gyp.xcodeproj_file.PBXAggregateTarget
       assert not is_bundle, (
           'mac_bundle targets cannot have type none (target "%s")' %
           target_name)
       assert not is_xctest, (
           'mac_xctest_bundle targets cannot have type none (target "%s")' %
@@ skipping 248 matching lines @@
 
       if len(concrete_outputs_all) > 0:
         # TODO(mark): There's a possibilty for collision here.  Consider
         # target "t" rule "A_r" and target "t_A" rule "r".
         makefile_name = '%s.make' % re.sub(
             '[^a-zA-Z0-9_]', '_' , '%s_%s' % (target_name, rule['rule_name']))
         makefile_path = os.path.join(xcode_projects[build_file].path,
                                      makefile_name)
         # TODO(mark): try/close?  Write to a temporary file and swap it only
         # if it's got changes?
-        makefile = open(makefile_path, 'wb')
+        makefile = open(makefile_path, 'w')
 
         # make will build the first target in the makefile by default.  By
         # convention, it's called "all".  List all (or at least one)
         # concrete output for each rule source as a prerequisite of the "all"
         # target.
         makefile.write('all: \\\n')
-        for concrete_output_index in \
-            xrange(0, len(concrete_outputs_by_rule_source)):
+        for concrete_output_index, concrete_output_by_rule_source in \
+            enumerate(concrete_outputs_by_rule_source):
           # Only list the first (index [0]) concrete output of each input
           # in the "all" target.  Otherwise, a parallel make (-j > 1) would
           # attempt to process each input multiple times simultaneously.
           # Otherwise, "all" could just contain the entire list of
           # concrete_outputs_all.
-          concrete_output = \
-              concrete_outputs_by_rule_source[concrete_output_index][0]
+          concrete_output = concrete_output_by_rule_source[0]
           if concrete_output_index == len(concrete_outputs_by_rule_source) - 1:
             eol = ''
           else:
             eol = ' \\'
           makefile.write('    %s%s\n' % (concrete_output, eol))
 
         for (rule_source, concrete_outputs, message, action) in \
             zip(rule['rule_sources'], concrete_outputs_by_rule_source,
                 messages, actions):
           makefile.write('\n')
 
           # Add a rule that declares it can build each concrete output of a
           # rule source.  Collect the names of the directories that are
           # required.
           concrete_output_dirs = []
-          for concrete_output_index in xrange(0, len(concrete_outputs)):
-            concrete_output = concrete_outputs[concrete_output_index]
+          for concrete_output_index, concrete_output in \
+              enumerate(concrete_outputs):
             if concrete_output_index == 0:
               bol = ''
             else:
               bol = '    '
             makefile.write('%s%s \\\n' % (bol, concrete_output))
 
             concrete_output_dir = posixpath.dirname(concrete_output)
             if (concrete_output_dir and
                 concrete_output_dir not in concrete_output_dirs):
               concrete_output_dirs.append(concrete_output_dir)
 
           makefile.write('    : \\\n')
 
           # The prerequisites for this rule are the rule source itself and
           # the set of additional rule inputs, if any.
           prerequisites = [rule_source]
           prerequisites.extend(rule.get('inputs', []))
-          for prerequisite_index in xrange(0, len(prerequisites)):
-            prerequisite = prerequisites[prerequisite_index]
+          for prerequisite_index, prerequisite in enumerate(prerequisites):
             if prerequisite_index == len(prerequisites) - 1:
               eol = ''
             else:
               eol = ' \\'
             makefile.write('    %s%s\n' % (prerequisite, eol))
 
           # Make sure that output directories exist before executing the rule
           # action.
           if len(concrete_output_dirs) > 0:
             makefile.write('\t@mkdir -p "%s"\n' %
@@ skipping 200 matching lines @@
         if library_dir not in xcode_standard_library_dirs and (
             not xcbc.HasBuildSetting(_library_search_paths_var) or
             library_dir not in xcbc.GetBuildSetting(_library_search_paths_var)):
           xcbc.AppendBuildSetting(_library_search_paths_var, library_dir)
 
       if 'defines' in configuration:
         for define in configuration['defines']:
           set_define = EscapeXcodeDefine(define)
           xcbc.AppendBuildSetting('GCC_PREPROCESSOR_DEFINITIONS', set_define)
       if 'xcode_settings' in configuration:
-        for xck, xcv in configuration['xcode_settings'].iteritems():
+        for xck, xcv in configuration['xcode_settings'].items():
           xcbc.SetBuildSetting(xck, xcv)
       if 'xcode_config_file' in configuration:
         config_ref = pbxp.AddOrGetFileInRootGroup(
             configuration['xcode_config_file'])
         xcbc.SetBaseConfiguration(config_ref)
 
   build_files = []
-  for build_file, build_file_dict in data.iteritems():
+  for build_file, build_file_dict in data.items():
     if build_file.endswith('.gyp'):
       build_files.append(build_file)
 
   for build_file in build_files:
     xcode_projects[build_file].Finalize1(xcode_targets, serialize_all_tests)
 
   for build_file in build_files:
     xcode_projects[build_file].Finalize2(xcode_targets,
                                          xcode_target_to_target_dict)
 
   for build_file in build_files:
     xcode_projects[build_file].Write()