Python 3 compatibility

pylib/gyp/__init__.py

 #!/usr/bin/env python
 
 # 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 copy
 import gyp.input
 import optparse
 import os.path
 import re
 import shlex
 import sys
 import traceback
 from gyp.common import GypError
 
+try:
+  basestring = basestring
+except NameError:
+  basestring = str
+
 # Default debug modes for GYP
 debug = {}
 
 # List of "official" debug modes, but you can use anything you like.
 DEBUG_GENERAL = 'general'
 DEBUG_VARIABLES = 'variables'
 DEBUG_INCLUDES = 'includes'
 
-
 def DebugOutput(mode, message, *args):
   if 'all' in gyp.debug or mode in gyp.debug:
     ctx = ('unknown', 0, 'unknown')
     try:
       f = traceback.extract_stack(limit=2)
       if f:
         ctx = f[0][:3]
     except:
       pass
     if args:
       message %= args
-    print '%s:%s:%d:%s %s' % (mode.upper(), os.path.basename(ctx[0]),
-                              ctx[1], ctx[2], message)
+    print('%s:%s:%d:%s %s' % (mode.upper(), os.path.basename(ctx[0]),
+                              ctx[1], ctx[2], message))
 
 def FindBuildFiles():
   extension = '.gyp'
   files = os.listdir(os.getcwd())
   build_files = []
   for file in files:
     if file.endswith(extension):
       build_files.append(file)
   return build_files
 
@@ skipping 151 matching lines @@
     if not path:
       return os.path.curdir
     return path
 
   def Noop(value):
     return value
 
   # We always want to ignore the environment when regenerating, to avoid
   # duplicate or changed flags in the environment at the time of regeneration.
   flags = ['--ignore-environment']
-  for name, metadata in options._regeneration_metadata.iteritems():
+  for name, metadata in options._regeneration_metadata.items():
     opt = metadata['opt']
     value = getattr(options, name)
     value_predicate = metadata['type'] == 'path' and FixPath or Noop
     action = metadata['action']
     env_name = metadata['env_name']
     if action == 'append':
       flags.extend(RegenerateAppendFlag(opt, value, value_predicate,
                                         env_name, options))
     elif action in ('store', None):  # None is a synonym for 'store'.
       if value:
         flags.append(FormatOpt(opt, value_predicate(value)))
       elif options.use_environment and env_name and os.environ.get(env_name):
         flags.append(FormatOpt(opt, value_predicate(os.environ.get(env_name))))
     elif action in ('store_true', 'store_false'):
       if ((action == 'store_true' and value) or
           (action == 'store_false' and not value)):
         flags.append(opt)
       elif options.use_environment and env_name:
-        print >>sys.stderr, ('Warning: environment regeneration unimplemented '
+        print(('Warning: environment regeneration unimplemented '
                              'for %s flag %r env_name %r' % (action, opt,
-                                                             env_name))
+                                                             env_name)),
+                                                             file=sys.stderr)
     else:
-      print >>sys.stderr, ('Warning: regeneration unimplemented for action %r '
-                           'flag %r' % (action, opt))
+      print(('Warning: regeneration unimplemented for action %r '
+                           'flag %r' % (action, opt)), file=sys.stderr)
 
   return flags
 
 class RegeneratableOptionParser(optparse.OptionParser):
   def __init__(self):
     self.__regeneratable_options = {}
     optparse.OptionParser.__init__(self)
 
   def add_option(self, *args, **kw):
     """Add an option to the parser.
@@ skipping 179 matching lines @@
   # TODO(mark): Chromium-specific hack!
   # For Chromium, the gyp "depth" variable should always be a relative path
   # to Chromium's top-level "src" directory.  If no depth variable was set
   # on the command line, try to find a "src" directory by looking at the
   # absolute path to each build file's directory.  The first "src" component
   # found will be treated as though it were the path used for --depth.
   if not options.depth:
     for build_file in build_files:
       build_file_dir = os.path.abspath(os.path.dirname(build_file))
       build_file_dir_components = build_file_dir.split(os.path.sep)
-      components_len = len(build_file_dir_components)
-      for index in xrange(components_len - 1, -1, -1):
-        if build_file_dir_components[index] == 'src':
+      for component in reversed(build_file_dir_components):
+        if component == 'src':
           options.depth = os.path.sep.join(build_file_dir_components)
           break
-        del build_file_dir_components[index]
+        del build_file_dir_components[-1]
 
       # If the inner loop found something, break without advancing to another
       # build file.
       if options.depth:
         break
 
     if not options.depth:
       raise GypError('Could not automatically locate src directory.  This is'
                      'a temporary Chromium feature that will be removed.  Use'
                      '--depth as a workaround.')
@@ skipping 18 matching lines @@
                 "cmdline_default_variables: %s", cmdline_default_variables)
 
   # Set up includes.
   includes = []
 
   # If ~/.gyp/include.gypi exists, it'll be forcibly included into every
   # .gyp file that's loaded, before anything else is included.
   if home_dot_gyp != None:
     default_include = os.path.join(home_dot_gyp, 'include.gypi')
     if os.path.exists(default_include):
-      print 'Using overrides found in ' + default_include
+      print('Using overrides found in ' + default_include)
       includes.append(default_include)
 
   # Command-line --include files come after the default include.
   if options.includes:
     includes.extend(options.includes)
 
   # Generator flags should be prefixed with the target generator since they
   # are global across all generator runs.
   gen_flags = []
   if options.use_environment:
     gen_flags += ShlexEnv('GYP_GENERATOR_FLAGS')
   if options.generator_flags:
     gen_flags += options.generator_flags
   generator_flags = NameValueListToDict(gen_flags)
-  if DEBUG_GENERAL in gyp.debug.keys():
+  if DEBUG_GENERAL in gyp.debug:
     DebugOutput(DEBUG_GENERAL, "generator_flags: %s", generator_flags)
 
   # Generate all requested formats (use a set in case we got one format request
   # twice)
   for format in set(options.formats):
     params = {'options': options,
               'build_files': build_files,
               'generator_flags': generator_flags,
               'cwd': os.getcwd(),
               'build_files_arg': build_files_arg,
@@ skipping 12 matching lines @@
     # TODO(mark): Pass |data| for now because the generator needs a list of
     # build files that came in.  In the future, maybe it should just accept
     # a list, and not the whole data dict.
     # NOTE: flat_list is the flattened dependency graph specifying the order
     # that targets may be built.  Build systems that operate serially or that
     # need to have dependencies defined before dependents reference them should
     # generate targets in the order specified in flat_list.
     generator.GenerateOutput(flat_list, targets, data, params)
 
     if options.configs:
-      valid_configs = targets[flat_list[0]]['configurations'].keys()
+      valid_configs = targets[flat_list[0]]['configurations']
       for conf in options.configs:
         if conf not in valid_configs:
           raise GypError('Invalid config specified via --build: %s' % conf)
       generator.PerformBuild(data, options.configs, params)
 
   # Done
   return 0
 
 
 def main(args):
   try:
     return gyp_main(args)
-  except GypError, e:
+  except GypError as e:
     sys.stderr.write("gyp: %s\n" % e)
     return 1
 
 # NOTE: setuptools generated console_scripts calls function with no arguments
 def script_main():
   return main(sys.argv[1:])
 
 if __name__ == '__main__':
   sys.exit(script_main())