Python 3 compatibility

pylib/gyp/generator/cmake.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.
 
 """cmake output module
 
 This module is under development and should be considered experimental.
 
 This module produces cmake (2.8.8+) input as its output. One CMakeLists.txt is
 created for each configuration.
@@ skipping 10 matching lines @@
 there is a mismatch between gyp and cmake with regard to linking. All attempts
 are made to work around this, but CMake sometimes sees -Wl,--start-group as a
 library and incorrectly repeats it. As a result the output of this generator
 should not be relied on for building.
 
 When using with kdevelop, use version 4.4+. Previous versions of kdevelop will
 not be able to find the header file directories described in the generated
 CMakeLists.txt file.
 """
 
+from __future__ import print_function
+
 import multiprocessing
 import os
 import signal
 import string
 import subprocess
 import gyp.common
 import gyp.xcode_emulation
 
+try:
+  string.maketrans
+except NameError:
+  # maketrans was moved to str in python 3
+  string.maketrans = str.maketrans
+
 generator_default_variables = {
   'EXECUTABLE_PREFIX': '',
   'EXECUTABLE_SUFFIX': '',
   'STATIC_LIB_PREFIX': 'lib',
   'STATIC_LIB_SUFFIX': '.a',
   'SHARED_LIB_PREFIX': 'lib',
   'SHARED_LIB_SUFFIX': '.so',
   'SHARED_LIB_DIR': '${builddir}/lib.${TOOLSET}',
   'LIB_DIR': '${obj}.${TOOLSET}',
   'INTERMEDIATE_DIR': '${obj}.${TOOLSET}/${TARGET}/geni',
@@ skipping 812 matching lines @@
       default_product_ext = generator_default_variables['STATIC_LIB_SUFFIX']
 
     elif target_type in ('loadable_module', 'shared_library'):
       shared_library_prefix = generator_default_variables['SHARED_LIB_PREFIX']
       default_product_name = RemovePrefix(default_product_name,
                                           shared_library_prefix)
       default_product_prefix = shared_library_prefix
       default_product_ext = generator_default_variables['SHARED_LIB_SUFFIX']
 
     elif target_type != 'executable':
-      print ('ERROR: What output file should be generated?',
-              'type', target_type, 'target', target_name)
+      print(('ERROR: What output file should be generated?',
+              'type', target_type, 'target', target_name))
 
     product_prefix = spec.get('product_prefix', default_product_prefix)
     product_name = spec.get('product_name', default_product_name)
     product_ext = spec.get('product_extension')
     if product_ext:
       product_ext = '.' + product_ext
     else:
       product_ext = default_product_ext
 
     SetTargetProperty(output, cmake_target_name, 'PREFIX', product_prefix)
@@ skipping 317 matching lines @@
   # output_dir: relative path from generator_dir to the build directory.
   output_dir = generator_flags.get('output_dir', 'out')
 
   for config_name in configurations:
     # build_dir: relative path from source root to our output files.
     # e.g. "out/Debug"
     build_dir = os.path.normpath(os.path.join(generator_dir,
                                               output_dir,
                                               config_name))
     arguments = ['cmake', '-G', 'Ninja']
-    print 'Generating [%s]: %s' % (config_name, arguments)
+    print('Generating [%s]: %s' % (config_name, arguments))
     subprocess.check_call(arguments, cwd=build_dir)
 
     arguments = ['ninja', '-C', build_dir]
-    print 'Building [%s]: %s' % (config_name, arguments)
+    print('Building [%s]: %s' % (config_name, 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):
   user_config = params.get('generator_flags', {}).get('config', None)
   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)