Python 3 compatibility

pylib/gyp/input.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 compiler.ast import Const
-from compiler.ast import Dict
-from compiler.ast import Discard
-from compiler.ast import List
-from compiler.ast import Module
-from compiler.ast import Node
-from compiler.ast import Stmt
-import compiler
+from __future__ import print_function
+
+import ast
 import gyp.common
 import gyp.simple_copy
 import multiprocessing
 import optparse
 import os.path
 import re
 import shlex
 import signal
 import subprocess
 import sys
@@ skipping 152 matching lines @@
 
 def CheckedEval(file_contents):
   """Return the eval of a gyp file.
 
   The gyp file is restricted to dictionaries and lists only, and
   repeated keys are not allowed.
 
   Note that this is slower than eval() is.
   """
 
-  ast = compiler.parse(file_contents)
-  assert isinstance(ast, Module)
-  c1 = ast.getChildren()
-  assert c1[0] is None
-  assert isinstance(c1[1], Stmt)
-  c2 = c1[1].getChildren()
-  assert isinstance(c2[0], Discard)
-  c3 = c2[0].getChildren()
-  assert len(c3) == 1
-  return CheckNode(c3[0], [])
+  syntax_tree = ast.parse(file_contents)
+  assert isinstance(syntax_tree, ast.Module)
+  c1 = syntax_tree.body
+  assert len(c1) == 1
+  c2 = c1[0]
+  assert isinstance(c2, ast.Expr)
+  return CheckNode(c2.value, [])
 
 
 def CheckNode(node, keypath):
-  if isinstance(node, Dict):
-    c = node.getChildren()
+  if isinstance(node, ast.Dict):
     dict = {}
-    for n in range(0, len(c), 2):
-      assert isinstance(c[n], Const)
-      key = c[n].getChildren()[0]
+    for key, value in zip(node.keys, node.values):
+      assert isinstance(key, ast.Str)
+      key = key.s
       if key in dict:
         raise GypError("Key '" + key + "' repeated at level " +
               repr(len(keypath) + 1) + " with key path '" +
               '.'.join(keypath) + "'")
       kp = list(keypath)  # Make a copy of the list for descending this node.
       kp.append(key)
-      dict[key] = CheckNode(c[n + 1], kp)
+      dict[key] = CheckNode(value, kp)
     return dict
-  elif isinstance(node, List):
-    c = node.getChildren()
+  elif isinstance(node, ast.List):
     children = []
-    for index, child in enumerate(c):
+    for index, child in enumerate(node.elts):
       kp = list(keypath)  # Copy list.
       kp.append(repr(index))
       children.append(CheckNode(child, kp))
     return children
-  elif isinstance(node, Const):
-    return node.getChildren()[0]
+  elif isinstance(node, ast.Str):
+    return node.s
   else:
     raise TypeError("Unknown AST node at key path '" + '.'.join(keypath) +
          "': " + repr(node))
 
 
 def LoadOneBuildFile(build_file_path, data, aux_data, includes,
                      is_target, check):
   if build_file_path in data:
     return data[build_file_path]
 
   if os.path.exists(build_file_path):
     build_file_contents = open(build_file_path).read()
   else:
     raise GypError("%s not found (cwd: %s)" % (build_file_path, os.getcwd()))
 
   build_file_data = None
   try:
     if check:
       build_file_data = CheckedEval(build_file_contents)
     else:
       build_file_data = eval(build_file_contents, {'__builtins__': None},
                              None)
-  except SyntaxError, e:
+  except SyntaxError as e:
     e.filename = build_file_path
     raise
-  except Exception, e:
+  except Exception as e:
     gyp.common.ExceptionAppend(e, 'while reading ' + build_file_path)
     raise
 
   if type(build_file_data) is not dict:
     raise GypError("%s does not evaluate to a dictionary." % build_file_path)
 
   data[build_file_path] = build_file_data
   aux_data[build_file_path] = {}
 
   # Scan for includes and merge them in.
   if ('skip_includes' not in build_file_data or
       not build_file_data['skip_includes']):
     try:
       if is_target:
         LoadBuildFileIncludesIntoDict(build_file_data, build_file_path, data,
                                       aux_data, includes, check)
       else:
         LoadBuildFileIncludesIntoDict(build_file_data, build_file_path, data,
                                       aux_data, None, check)
-    except Exception, e:
+    except Exception as e:
       gyp.common.ExceptionAppend(e,
                                  'while reading includes of ' + build_file_path)
       raise
 
   return build_file_data
 
 
 def LoadBuildFileIncludesIntoDict(subdict, subdict_path, data, aux_data,
                                   includes, check):
   includes_list = []
@@ skipping 16 matching lines @@
       aux_data[subdict_path]['included'] = []
     aux_data[subdict_path]['included'].append(include)
 
     gyp.DebugOutput(gyp.DEBUG_INCLUDES, "Loading Included File: '%s'", include)
 
     MergeDicts(subdict,
                LoadOneBuildFile(include, data, aux_data, None, False, check),
                subdict_path, include)
 
   # Recurse into subdictionaries.
-  for k, v in subdict.iteritems():
+  for k, v in subdict.items():
     if type(v) is dict:
       LoadBuildFileIncludesIntoDict(v, subdict_path, data, aux_data,
                                     None, check)
     elif type(v) is list:
       LoadBuildFileIncludesIntoList(v, subdict_path, data, aux_data,
                                     check)
 
 
 # This recurses into lists so that it can look for dicts.
 def LoadBuildFileIncludesIntoList(sublist, sublist_path, data, aux_data, check):
@@ skipping 144 matching lines @@
         continue
       for dependency in target_dict['dependencies']:
         dependencies.append(
             gyp.common.ResolveTarget(build_file_path, dependency, None)[0])
 
   if load_dependencies:
     for dependency in dependencies:
       try:
         LoadTargetBuildFile(dependency, data, aux_data, variables,
                             includes, depth, check, load_dependencies)
-      except Exception, e:
+      except Exception as e:
         gyp.common.ExceptionAppend(
           e, 'while loading dependencies of %s' % build_file_path)
         raise
   else:
     return (build_file_path, dependencies)
 
 def CallLoadTargetBuildFile(global_flags,
                             build_file_path, variables,
                             includes, depth, check,
                             generator_input_info):
   """Wrapper around LoadTargetBuildFile for parallel processing.
 
      This wrapper is used when LoadTargetBuildFile is executed in
      a worker process.
   """
 
   try:
     signal.signal(signal.SIGINT, signal.SIG_IGN)
 
     # Apply globals so that the worker process behaves the same.
-    for key, value in global_flags.iteritems():
+    for key, value in global_flags.items():
       globals()[key] = value
 
     SetGeneratorGlobals(generator_input_info)
     result = LoadTargetBuildFile(build_file_path, per_process_data,
                                  per_process_aux_data, variables,
                                  includes, depth, check, False)
     if not result:
       return result
 
     (build_file_path, dependencies) = result
 
     # We can safely pop the build_file_data from per_process_data because it
     # will never be referenced by this process again, so we don't need to keep
     # it in the cache.
     build_file_data = per_process_data.pop(build_file_path)
 
     # This gets serialized and sent back to the main process via a pipe.
     # It's handled in LoadTargetBuildFileCallback.
     return (build_file_path,
             build_file_data,
             dependencies)
-  except GypError, e:
+  except GypError as e:
     sys.stderr.write("gyp: %s\n" % e)
     return None
-  except Exception, e:
-    print >>sys.stderr, 'Exception:', e
-    print >>sys.stderr, traceback.format_exc()
+  except Exception as e:
+    print('Exception:', e, file=sys.stderr)
+    print(traceback.format_exc(), file=sys.stderr)
     return None
 
 
 class ParallelProcessingError(Exception):
   pass
 
 
 class ParallelState(object):
   """Class to keep track of state when processing input files in parallel.
 
@@ skipping 69 matching lines @@
         'non_configuration_keys': globals()['non_configuration_keys'],
         'multiple_toolsets': globals()['multiple_toolsets']}
 
       if not parallel_state.pool:
         parallel_state.pool = multiprocessing.Pool(multiprocessing.cpu_count())
       parallel_state.pool.apply_async(
           CallLoadTargetBuildFile,
           args = (global_flags, dependency,
                   variables, includes, depth, check, generator_input_info),
           callback = parallel_state.LoadTargetBuildFileCallback)
-  except KeyboardInterrupt, e:
+  except KeyboardInterrupt as e:
     parallel_state.pool.terminate()
     raise e
 
   parallel_state.condition.release()
 
   parallel_state.pool.close()
   parallel_state.pool.join()
   parallel_state.pool = None
 
   if parallel_state.error:
@@ skipping 278 matching lines @@
           raise GypError("Unknown command string '%s' in '%s'." %
                          (command_string, contents))
         else:
           # Fix up command with platform specific workarounds.
           contents = FixupPlatformCommand(contents)
           try:
             p = subprocess.Popen(contents, shell=use_shell,
                                  stdout=subprocess.PIPE,
                                  stderr=subprocess.PIPE,
                                  stdin=subprocess.PIPE,
-                                 cwd=build_file_dir)
-          except Exception, e:
+                                 cwd=build_file_dir,
+                                 universal_newlines=True)
+          except Exception as e:
             raise GypError("%s while executing command '%s' in %s" %
                            (e, contents, build_file))
 
           p_stdout, p_stderr = p.communicate('')
 
           if p.wait() != 0 or p_stderr:
             sys.stderr.write(p_stderr)
             # Simulate check_call behavior, since check_call only exists
             # in python 2.5 and later.
             raise GypError("Call to '%s' returned exit status %d while in %s." %
@@ skipping 93 matching lines @@
         new_output = []
         for item in output:
           new_output.append(
               ExpandVariables(item, phase, variables, build_file))
         output = new_output
     else:
       output = ExpandVariables(output, phase, variables, build_file)
 
   # Convert all strings that are canonically-represented integers into integers.
   if type(output) is list:
-    for index in xrange(0, len(output)):
-      if IsStrCanonicalInt(output[index]):
-        output[index] = int(output[index])
+    for index, outstr in enumerate(output):
+      if IsStrCanonicalInt(outstr):
+        output[index] = int(outstr)
   elif IsStrCanonicalInt(output):
     output = int(output)
 
   return output
 
 # The same condition is often evaluated over and over again so it
 # makes sense to cache as much as possible between evaluations.
 cached_conditions_asts = {}
 
 def EvalCondition(condition, conditions_key, phase, variables, build_file):
@@ skipping 48 matching lines @@
 
   try:
     if cond_expr_expanded in cached_conditions_asts:
       ast_code = cached_conditions_asts[cond_expr_expanded]
     else:
       ast_code = compile(cond_expr_expanded, '<string>', 'eval')
       cached_conditions_asts[cond_expr_expanded] = ast_code
     if eval(ast_code, {'__builtins__': None}, variables):
       return true_dict
     return false_dict
-  except SyntaxError, e:
+  except SyntaxError as e:
     syntax_error = SyntaxError('%s while evaluating condition \'%s\' in %s '
                                'at character %d.' %
                                (str(e.args[0]), e.text, build_file, e.offset),
                                e.filename, e.lineno, e.offset, e.text)
     raise syntax_error
-  except NameError, e:
+  except NameError as e:
     gyp.common.ExceptionAppend(e, 'while evaluating condition \'%s\' in %s' %
                                (cond_expr_expanded, build_file))
     raise GypError(e)
 
 
 def ProcessConditionsInDict(the_dict, phase, variables, build_file):
   # Process a 'conditions' or 'target_conditions' section in the_dict,
   # depending on phase.
   # early -> conditions
   # late -> target_conditions
@@ skipping 34 matching lines @@
       # merging it.
       ProcessVariablesAndConditionsInDict(merge_dict, phase,
                                           variables, build_file)
 
       MergeDicts(the_dict, merge_dict, build_file, build_file)
 
 
 def LoadAutomaticVariablesFromDict(variables, the_dict):
   # Any keys with plain string values in the_dict become automatic variables.
   # The variable name is the key name with a "_" character prepended.
-  for key, value in the_dict.iteritems():
+  for key, value in the_dict.items():
     if type(value) in (str, int, list):
       variables['_' + key] = value
 
 
 def LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key):
   # Any keys in the_dict's "variables" dict, if it has one, becomes a
   # variable.  The variable name is the key name in the "variables" dict.
   # Variables that end with the % character are set only if they are unset in
   # the variables dict.  the_dict_key is the name of the key that accesses
   # the_dict in the_dict's parent dict.  If the_dict's parent is not a dict
   # (it could be a list or it could be parentless because it is a root dict),
   # the_dict_key will be None.
-  for key, value in the_dict.get('variables', {}).iteritems():
+  for key, value in the_dict.get('variables', {}).items():
     if type(value) not in (str, int, list):
       continue
 
     if key.endswith('%'):
       variable_name = key[:-1]
       if variable_name in variables:
         # If the variable is already set, don't set it.
         continue
       if the_dict_key is 'variables' and variable_name in the_dict:
         # If the variable is set without a % in the_dict, and the_dict is a
@@ skipping 18 matching lines @@
   # Make a copy of the variables_in dict that can be modified during the
   # loading of automatics and the loading of the variables dict.
   variables = variables_in.copy()
   LoadAutomaticVariablesFromDict(variables, the_dict)
 
   if 'variables' in the_dict:
     # Make sure all the local variables are added to the variables
     # list before we process them so that you can reference one
     # variable from another.  They will be fully expanded by recursion
     # in ExpandVariables.
-    for key, value in the_dict['variables'].iteritems():
+    for key, value in the_dict['variables'].items():
       variables[key] = value
 
     # Handle the associated variables dict first, so that any variable
     # references within can be resolved prior to using them as variables.
     # Pass a copy of the variables dict to avoid having it be tainted.
     # Otherwise, it would have extra automatics added for everything that
     # should just be an ordinary variable in this scope.
     ProcessVariablesAndConditionsInDict(the_dict['variables'], phase,
                                         variables, build_file, 'variables')
 
   LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
 
-  for key, value in the_dict.iteritems():
+  for key, value in the_dict.items():

[Nico, 2016/07/29 22:22:06]

Did you measure if this change makes gyp slower when running with 2.7?

[AWhetter, 2016/11/05 23:59:50]

Just with a few runs of all of the tests, I got the same run time of 2m50s for
both with and without the changes. My guess is the dictionaries are small enough
for the switch from list to generator to not make a big difference.

     # Skip "variables", which was already processed if present.
     if key != 'variables' and type(value) is str:
       expanded = ExpandVariables(value, phase, variables, build_file)
       if type(expanded) not in (str, int):
         raise ValueError(
               'Variable expansion in this context permits str and int ' + \
               'only, found ' + expanded.__class__.__name__ + ' for ' + key)
       the_dict[key] = expanded
 
   # Variable expansion may have resulted in changes to automatics.  Reload.
@@ skipping 37 matching lines @@
   ProcessConditionsInDict(the_dict, phase, variables, build_file)
 
   # Conditional processing may have resulted in changes to automatics or the
   # variables dict.  Reload.
   variables = variables_in.copy()
   LoadAutomaticVariablesFromDict(variables, the_dict)
   LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
 
   # Recurse into child dicts, or process child lists which may result in
   # further recursion into descendant dicts.
-  for key, value in the_dict.iteritems():
+  for key, value in the_dict.items():
     # Skip "variables" and string values, which were already processed if
     # present.
     if key == 'variables' or type(value) is str:
       continue
     if type(value) is dict:
       # Pass a copy of the variables dict so that subdicts can't influence
       # parents.
       ProcessVariablesAndConditionsInDict(value, phase, variables,
                                           build_file, key)
     elif type(value) is list:
@@ skipping 76 matching lines @@
   links are examined, and any dependencies referenced will be rewritten
   so that they are fully-qualified and relative to the current directory.
   All rewritten dependencies are suitable for use as keys to |targets| or a
   similar dict.
   """
 
   all_dependency_sections = [dep + op
                              for dep in dependency_sections
                              for op in ('', '!', '/')]
 
-  for target, target_dict in targets.iteritems():
+  for target, target_dict in targets.items():
     target_build_file = gyp.common.BuildFile(target)
     toolset = target_dict['toolset']
     for dependency_key in all_dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
-      for index in xrange(0, len(dependencies)):
+      for index, dep in enumerate(dependencies):
         dep_file, dep_target, dep_toolset = gyp.common.ResolveTarget(
-            target_build_file, dependencies[index], toolset)
+            target_build_file, dep, toolset)
         if not multiple_toolsets:
           # Ignore toolset specification in the dependency if it is specified.
           dep_toolset = toolset
         dependency = gyp.common.QualifiedTarget(dep_file,
                                                 dep_target,
                                                 dep_toolset)
         dependencies[index] = dependency
 
         # Make sure anything appearing in a list other than "dependencies" also
         # appears in the "dependencies" list.
@@ skipping 12 matching lines @@
   build_file.  The |data| dict provides access to build file dicts.
 
   Any target that does not wish to be included by wildcard can provide an
   optional "suppress_wildcard" key in its target dict.  When present and
   true, a wildcard dependency link will not include such targets.
 
   All dependency names, including the keys to |targets| and the values in each
   dependency list, must be qualified when this function is called.
   """
 
-  for target, target_dict in targets.iteritems():
+  for target, target_dict in targets.items():
     toolset = target_dict['toolset']
     target_build_file = gyp.common.BuildFile(target)
     for dependency_key in dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
 
       # Loop this way instead of "for dependency in" or "for index in xrange"
       # because the dependencies list will be modified within the loop body.
       index = 0
       while index < len(dependencies):
         (dependency_build_file, dependency_target, dependency_toolset) = \
@@ skipping 41 matching lines @@
 
 def Unify(l):
   """Removes duplicate elements from l, keeping the first element."""
   seen = {}
   return [seen.setdefault(e, e) for e in l if e not in seen]
 
 
 def RemoveDuplicateDependencies(targets):
   """Makes sure every dependency appears only once in all targets's dependency
   lists."""
-  for target_name, target_dict in targets.iteritems():
+  for target_name, target_dict in targets.items():
     for dependency_key in dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
       if dependencies:
         target_dict[dependency_key] = Unify(dependencies)
 
 
 def Filter(l, item):
   """Removes item from l."""
   res = {}
   return [res.setdefault(e, e) for e in l if e != item]
 
 
 def RemoveSelfDependencies(targets):
   """Remove self dependencies from targets that have the prune_self_dependency
   variable set."""
-  for target_name, target_dict in targets.iteritems():
+  for target_name, target_dict in targets.items():
     for dependency_key in dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
       if dependencies:
         for t in dependencies:
           if t == target_name:
             if targets[t].get('variables', {}).get('prune_self_dependency', 0):
               target_dict[dependency_key] = Filter(dependencies, target_name)
 
 
 def RemoveLinkDependenciesFromNoneTargets(targets):
   """Remove dependencies having the 'link_dependency' attribute from the 'none'
   targets."""
-  for target_name, target_dict in targets.iteritems():
+  for target_name, target_dict in targets.items():
     for dependency_key in dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
       if dependencies:
         for t in dependencies:
           if target_dict.get('type', None) == 'none':
             if targets[t].get('variables', {}).get('link_dependency', 0):
               target_dict[dependency_key] = \
                   Filter(target_dict[dependency_key], t)
 
 
@@ skipping 270 matching lines @@
     """
     Returns a list of dependency targets that are linked into this target.
     """
     return self._LinkDependenciesInternal(targets, True)
 
 
 def BuildDependencyList(targets):
   # Create a DependencyGraphNode for each target.  Put it into a dict for easy
   # access.
   dependency_nodes = {}
-  for target, spec in targets.iteritems():
+  for target, spec in targets.items():
     if target not in dependency_nodes:
       dependency_nodes[target] = DependencyGraphNode(target)
 
   # Set up the dependency links.  Targets that have no dependencies are treated
   # as dependent on root_node.
   root_node = DependencyGraphNode(None)
-  for target, spec in targets.iteritems():
+  for target, spec in targets.items():
     target_node = dependency_nodes[target]
     target_build_file = gyp.common.BuildFile(target)
     dependencies = spec.get('dependencies')
     if not dependencies:
       target_node.dependencies = [root_node]
       root_node.dependents.append(target_node)
     else:
       for dependency in dependencies:
         dependency_node = dependency_nodes.get(dependency)
         if not dependency_node:
           raise GypError("Dependency '%s' not found while "
                          "trying to load target %s" % (dependency, target))
         target_node.dependencies.append(dependency_node)
         dependency_node.dependents.append(target_node)
 
   flat_list = root_node.FlattenToList()
 
   # If there's anything left unvisited, there must be a circular dependency
   # (cycle).
   if len(flat_list) != len(targets):
     if not root_node.dependents:
       # If all targets have dependencies, add the first target as a dependent
       # of root_node so that the cycle can be discovered from root_node.
-      target = targets.keys()[0]
+      target = next(iter(targets))
       target_node = dependency_nodes[target]
       target_node.dependencies.append(root_node)
       root_node.dependents.append(target_node)
 
     cycles = []
     for cycle in root_node.FindCycles():
       paths = [node.ref for node in cycle]
       cycles.append('Cycle: %s' % ' -> '.join(paths))
     raise DependencyGraphNode.CircularException(
         'Cycles in dependency graph detected:\n' + '\n'.join(cycles))
 
   return [dependency_nodes, flat_list]
 
 
 def VerifyNoGYPFileCircularDependencies(targets):
   # Create a DependencyGraphNode for each gyp file containing a target.  Put
   # it into a dict for easy access.
   dependency_nodes = {}
-  for target in targets.iterkeys():
+  for target in targets.keys():
     build_file = gyp.common.BuildFile(target)
     if not build_file in dependency_nodes:
       dependency_nodes[build_file] = DependencyGraphNode(build_file)
 
   # Set up the dependency links.
-  for target, spec in targets.iteritems():
+  for target, spec in targets.items():
     build_file = gyp.common.BuildFile(target)
     build_file_node = dependency_nodes[build_file]
     target_dependencies = spec.get('dependencies', [])
     for dependency in target_dependencies:
       try:
         dependency_build_file = gyp.common.BuildFile(dependency)
-      except GypError, e:
+      except GypError as e:
         gyp.common.ExceptionAppend(
             e, 'while computing dependencies of .gyp file %s' % build_file)
         raise
 
       if dependency_build_file == build_file:
         # A .gyp file is allowed to refer back to itself.
         continue
       dependency_node = dependency_nodes.get(dependency_build_file)
       if not dependency_node:
         raise GypError("Dependancy '%s' not found" % dependency_build_file)
       if dependency_node not in build_file_node.dependencies:
         build_file_node.dependencies.append(dependency_node)
         dependency_node.dependents.append(build_file_node)
 
 
   # Files that have no dependencies are treated as dependent on root_node.
   root_node = DependencyGraphNode(None)
-  for build_file_node in dependency_nodes.itervalues():
+  for build_file_node in dependency_nodes.values():
     if len(build_file_node.dependencies) == 0:
       build_file_node.dependencies.append(root_node)
       root_node.dependents.append(build_file_node)
 
   flat_list = root_node.FlattenToList()
 
   # If there's anything left unvisited, there must be a circular dependency
   # (cycle).
   if len(flat_list) != len(dependency_nodes):
     if not root_node.dependents:
       # If all files have dependencies, add the first file as a dependent
       # of root_node so that the cycle can be discovered from root_node.
-      file_node = dependency_nodes.values()[0]
+      file_node = next(iter(dependency_nodes.values()))
       file_node.dependencies.append(root_node)
       root_node.dependents.append(file_node)
     cycles = []
     for cycle in root_node.FindCycles():
       paths = [node.ref for node in cycle]
       cycles.append('Cycle: %s' % ' -> '.join(paths))
     raise DependencyGraphNode.CircularException(
         'Cycles in .gyp file dependency graph detected:\n' + '\n'.join(cycles))
 
 
@@ skipping 206 matching lines @@
       # items to the list in reverse order, which would be an unwelcome
       # surprise.
       to.insert(prepend_index, to_item)
       if is_hashable(to_item):
         hashable_to_set.add(to_item)
       prepend_index = prepend_index + 1
 
 
 def MergeDicts(to, fro, to_file, fro_file):
   # I wanted to name the parameter "from" but it's a Python keyword...
-  for k, v in fro.iteritems():
+  for k, v in fro.items():
     # It would be nice to do "if not k in to: to[k] = v" but that wouldn't give
     # copy semantics.  Something else may want to merge from the |fro| dict
     # later, and having the same dict ref pointed to twice in the tree isn't
     # what anyone wants considering that the dicts may subsequently be
     # modified.
     if k in to:
       bad_merge = False
       if type(v) in (str, int):
         if type(to[k]) not in (str, int):
           bad_merge = True
@@ skipping 114 matching lines @@
   key_suffixes = ['=', '+', '?', '!', '/']
 
   build_file = gyp.common.BuildFile(target)
 
   # Provide a single configuration by default if none exists.
   # TODO(mark): Signal an error if default_configurations exists but
   # configurations does not.
   if not 'configurations' in target_dict:
     target_dict['configurations'] = {'Default': {}}
   if not 'default_configuration' in target_dict:
-    concrete = [i for (i, config) in target_dict['configurations'].iteritems()
+    concrete = [i for (i, config) in target_dict['configurations'].items()
                 if not config.get('abstract')]
     target_dict['default_configuration'] = sorted(concrete)[0]
 
   merged_configurations = {}
   configs = target_dict['configurations']
-  for (configuration, old_configuration_dict) in configs.iteritems():
+  for (configuration, old_configuration_dict) in configs.items():
     # Skip abstract configurations (saves work only).
     if old_configuration_dict.get('abstract'):
       continue
     # Configurations inherit (most) settings from the enclosing target scope.
     # Get the inheritance relationship right by making a copy of the target
     # dict.
     new_configuration_dict = {}
-    for (key, target_val) in target_dict.iteritems():
+    for (key, target_val) in target_dict.items():
       key_ext = key[-1:]
       if key_ext in key_suffixes:
         key_base = key[:-1]
       else:
         key_base = key
       if not key_base in non_configuration_keys:
         new_configuration_dict[key] = gyp.simple_copy.deepcopy(target_val)
 
     # Merge in configuration (with all its parents first).
     MergeConfigWithInheritance(new_configuration_dict, build_file,
                                target_dict, configuration, [])
 
     merged_configurations[configuration] = new_configuration_dict
 
   # Put the new configurations back into the target dict as a configuration.
   for configuration in merged_configurations.keys():
     target_dict['configurations'][configuration] = (
         merged_configurations[configuration])
 
   # Now drop all the abstract ones.
-  for configuration in target_dict['configurations'].keys():
-    old_configuration_dict = target_dict['configurations'][configuration]
-    if old_configuration_dict.get('abstract'):
-      del target_dict['configurations'][configuration]
+  configs = target_dict['configurations']
+  target_dict['configurations'] = \
+      {k: v for k, v in configs.items() if not v.get('abstract')}
 
   # Now that all of the target's configurations have been built, go through
   # the target dict's keys and remove everything that's been moved into a
   # "configurations" section.
   delete_keys = []
   for key in target_dict:
     key_ext = key[-1:]
     if key_ext in key_suffixes:
       key_base = key[:-1]
     else:
@@ skipping 39 matching lines @@
   # Look through the dictionary for any lists whose keys end in "!" or "/".
   # These are lists that will be treated as exclude lists and regular
   # expression-based exclude/include lists.  Collect the lists that are
   # needed first, looking for the lists that they operate on, and assemble
   # then into |lists|.  This is done in a separate loop up front, because
   # the _included and _excluded keys need to be added to the_dict, and that
   # can't be done while iterating through it.
 
   lists = []
   del_lists = []
-  for key, value in the_dict.iteritems():
+  for key, value in the_dict.items():
     operation = key[-1]
     if operation != '!' and operation != '/':
       continue
 
     if type(value) is not list:
       raise ValueError(name + ' key ' + key + ' must be list, not ' + \
                        value.__class__.__name__)
 
     list_key = key[:-1]
     if list_key not in the_dict:
@@ skipping 27 matching lines @@
     # no exclusion or inclusion has been applied (yet) have value -1, items
     # excluded have value 0, and items included have value 1.  Includes and
     # excludes override previous actions.  All items in list_actions are
     # initialized to -1 because no excludes or includes have been processed
     # yet.
     list_actions = list((-1,) * len(the_list))
 
     exclude_key = list_key + '!'
     if exclude_key in the_dict:
       for exclude_item in the_dict[exclude_key]:
-        for index in xrange(0, len(the_list)):
-          if exclude_item == the_list[index]:
+        for index, list_item in enumerate(the_list):
+          if exclude_item == list_item:
             # This item matches the exclude_item, so set its action to 0
             # (exclude).
             list_actions[index] = 0
 
       # The "whatever!" list is no longer needed, dump it.
       del the_dict[exclude_key]
 
     regex_key = list_key + '/'
     if regex_key in the_dict:
       for regex_item in the_dict[regex_key]:
         [action, pattern] = regex_item
         pattern_re = re.compile(pattern)
 
         if action == 'exclude':
           # This item matches an exclude regex, so set its value to 0 (exclude).
           action_value = 0
         elif action == 'include':
           # This item matches an include regex, so set its value to 1 (include).
           action_value = 1
         else:
           # This is an action that doesn't make any sense.
           raise ValueError('Unrecognized action ' + action + ' in ' + name + \
                            ' key ' + regex_key)
 
-        for index in xrange(0, len(the_list)):
-          list_item = the_list[index]
+        for index, list_item in enumerate(the_list):
           if list_actions[index] == action_value:
             # Even if the regex matches, nothing will change so continue (regex
             # searches are expensive).
             continue
           if pattern_re.search(list_item):
             # Regular expression match.
             list_actions[index] = action_value
 
       # The "whatever/" list is no longer needed, dump it.
       del the_dict[regex_key]
 
     # Add excluded items to the excluded list.
     #
     # Note that exclude_key ("sources!") is different from excluded_key
     # ("sources_excluded").  The exclude_key list is input and it was already
     # processed and deleted; the excluded_key list is output and it's about
     # to be created.
     excluded_key = list_key + '_excluded'
     if excluded_key in the_dict:
       raise GypError(name + ' key ' + excluded_key +
                      ' must not be present prior '
                      ' to applying exclusion/regex filters for ' + list_key)
 
     excluded_list = []
 
     # Go backwards through the list_actions list so that as items are deleted,
     # the indices of items that haven't been seen yet don't shift.  That means
     # that things need to be prepended to excluded_list to maintain them in the
     # same order that they existed in the_list.
-    for index in xrange(len(list_actions) - 1, -1, -1):
+    for index in range(len(list_actions) - 1, -1, -1):
       if list_actions[index] == 0:
         # Dump anything with action 0 (exclude).  Keep anything with action 1
         # (include) or -1 (no include or exclude seen for the item).
         excluded_list.insert(0, the_list[index])
         del the_list[index]
 
     # If anything was excluded, put the excluded list into the_dict at
     # excluded_key.
     if len(excluded_list) > 0:
       the_dict[excluded_key] = excluded_list
 
   # Now recurse into subdicts and lists that may contain dicts.
-  for key, value in the_dict.iteritems():
+  for key, value in the_dict.items():
     if type(value) is dict:
       ProcessListFiltersInDict(key, value)
     elif type(value) is list:
       ProcessListFiltersInList(key, value)
 
 
 def ProcessListFiltersInList(name, the_list):
   for item in the_list:
     if type(item) is dict:
       ProcessListFiltersInDict(name, item)
@@ skipping 36 matching lines @@
   for source in sources:
     name, ext = os.path.splitext(source)
     is_compiled_file = ext in [
         '.c', '.cc', '.cpp', '.cxx', '.m', '.mm', '.s', '.S']
     if not is_compiled_file:
       continue
     basename = os.path.basename(name)  # Don't include extension.
     basenames.setdefault(basename, []).append(source)
 
   error = ''
-  for basename, files in basenames.iteritems():
+  for basename, files in basenames.items():
     if len(files) > 1:
       error += '  %s: %s\n' % (basename, ' '.join(files))
 
   if error:
     print('static library %s has several files with the same basename:\n' %
           target + error + 'libtool on Mac cannot handle that. Use '
           '--no-duplicate-basename-check to disable this validation.')
     raise GypError('Duplicate basenames in sources section, see list above')
 
 
@@ skipping 118 matching lines @@
       TurnIntIntoStrInList(v)
 
     if type(k) is int:
       del the_dict[k]
       the_dict[str(k)] = v
 
 
 def TurnIntIntoStrInList(the_list):
   """Given list the_list, recursively converts all integers into strings.
   """
-  for index in xrange(0, len(the_list)):
-    item = the_list[index]
+  for index, item in enumerate(the_list):
     if type(item) is int:
       the_list[index] = str(item)
     elif type(item) is dict:
       TurnIntIntoStrInDict(item)
     elif type(item) is list:
       TurnIntIntoStrInList(item)
 
 
 def PruneUnwantedTargets(targets, flat_list, dependency_nodes, root_targets,
                          data):
@@ skipping 96 matching lines @@
   build_files = set(map(os.path.normpath, build_files))
   if parallel:
     LoadTargetBuildFilesParallel(build_files, data, variables, includes, depth,
                                  check, generator_input_info)
   else:
     aux_data = {}
     for build_file in build_files:
       try:
         LoadTargetBuildFile(build_file, data, aux_data,
                             variables, includes, depth, check, True)
-      except Exception, e:
+      except Exception as e:
         gyp.common.ExceptionAppend(e, 'while trying to load %s' % build_file)
         raise
 
   # Build a dict to access each target's subdict by qualified name.
   targets = BuildTargetsDict(data)
 
   # Fully qualify all dependency links.
   QualifyDependencies(targets)
 
   # Remove self-dependencies from targets that have 'prune_self_dependencies'
   # set to 1.
   RemoveSelfDependencies(targets)
 
   # Expand dependencies specified as build_file:*.
   ExpandWildcardDependencies(targets, data)
 
   # Remove all dependencies marked as 'link_dependency' from the targets of
   # type 'none'.
   RemoveLinkDependenciesFromNoneTargets(targets)
 
   # Apply exclude (!) and regex (/) list filters only for dependency_sections.
-  for target_name, target_dict in targets.iteritems():
+  for target_name, target_dict in targets.items():
     tmp_dict = {}
     for key_base in dependency_sections:
       for op in ('', '!', '/'):
         key = key_base + op
         if key in target_dict:
           tmp_dict[key] = target_dict[key]
           del target_dict[key]
     ProcessListFiltersInDict(target_name, tmp_dict)
     # Write the results back to |target_dict|.
     for key in tmp_dict:
@@ skipping 76 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |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.
   return [flat_list, targets, data]