Python 3 compatibility

pylib/gyp/generator/msvs.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 collections
 import copy
 import ntpath
 import os
 import posixpath
 import re
 import subprocess
 import sys
 
 import gyp.common
 import gyp.easy_xml as easy_xml
 import gyp.generator.ninja as ninja_generator
 import gyp.MSVSNew as MSVSNew
 import gyp.MSVSProject as MSVSProject
 import gyp.MSVSSettings as MSVSSettings
 import gyp.MSVSToolFile as MSVSToolFile
 import gyp.MSVSUserFile as MSVSUserFile
 import gyp.MSVSUtil as MSVSUtil
 import gyp.MSVSVersion as MSVSVersion
 from gyp.common import GypError
 from gyp.common import OrderedSet
 
-# TODO: Remove once bots are on 2.7, http://crbug.com/241769
-def _import_OrderedDict():
-  import collections
-  try:
-    return collections.OrderedDict
-  except AttributeError:
-    import gyp.ordered_dict
-    return gyp.ordered_dict.OrderedDict
-OrderedDict = _import_OrderedDict()
-
 
 # Regular expression for validating Visual Studio GUIDs.  If the GUID
 # contains lowercase hex letters, MSVS will be fine. However,
 # IncrediBuild BuildConsole will parse the solution file, but then
 # silently skip building the target causing hard to track down errors.
 # Note that this only happens with the BuildConsole, and does not occur
 # if IncrediBuild is executed from inside Visual Studio.  This regex
 # validates that the string looks like a GUID with all uppercase hex
 # letters.
 VALID_MSVS_GUID_CHARS = re.compile(r'^[A-F0-9\-]+$')
@@ skipping 147 matching lines @@
     For example:
     _ConvertSourcesToFilterHierarchy([['a', 'bob1.c'], ['b', 'bob2.c']],
                                      prefix=['joe'])
     -->
     [MSVSProject.Filter('a', contents=['joe\\a\\bob1.c']),
      MSVSProject.Filter('b', contents=['joe\\b\\bob2.c'])]
   """
   if not prefix: prefix = []
   result = []
   excluded_result = []
-  folders = OrderedDict()
+  folders = collections.OrderedDict()
   # Gather files into the final result, excluded, or folders.
   for s in sources:
     if len(s) == 1:
       filename = _NormalizedSource('\\'.join(prefix + s))
       if filename in excluded:
         excluded_result.append(filename)
       else:
         result.append(filename)
     elif msvs_version and not msvs_version.UsesVcxproj():
       # For MSVS 2008 and earlier, we need to process all files before walking
@@ skipping 213 matching lines @@
   inputs = _FixPaths(inputs)
   outputs = _FixPaths(outputs)
   tool = MSVSProject.Tool(
       'VCCustomBuildTool',
       {'Description': description,
        'AdditionalDependencies': ';'.join(inputs),
        'Outputs': ';'.join(outputs),
        'CommandLine': cmd,
       })
   # Add to the properties of primary input for each config.
-  for config_name, c_data in spec['configurations'].iteritems():
+  for config_name, c_data in spec['configurations'].items():
     p.AddFileConfig(_FixPath(primary_input),
                     _ConfigFullName(config_name, c_data), tools=[tool])
 
 
 def _AddAccumulatedActionsToMSVS(p, spec, actions_dict):
   """Add actions accumulated into an actions_dict, merging as needed.
 
   Arguments:
     p: the target project
     spec: the target project dict
@@ skipping 285 matching lines @@
   # Concatenate back into a single string
   s = '"'.join(segments)
   if len(segments) % 2 == 0:
     # String ends while still quoted according to VCProj's convention. This
     # means the delimiter and the next list item that follow this one in the
     # .vcproj file will be misinterpreted as part of this item. There is nothing
     # we can do about this. Adding an extra quote would correct the problem in
     # the VCProj but cause the same problem on the final command-line. Moving
     # the item to the end of the list does works, but that's only possible if
     # there's only one such item. Let's just warn the user.
-    print >> sys.stderr, ('Warning: MSVS may misinterpret the odd number of ' +
-                          'quotes in ' + s)
+    print(('Warning: MSVS may misinterpret the odd number of ' +
+                          'quotes in ' + s), file=sys.stderr)
   return s
 
 
 def _EscapeCppDefineForMSVS(s):
   """Escapes a CPP define so that it will reach the compiler unaltered."""
   s = _EscapeEnvironmentVariableExpansion(s)
   s = _EscapeCommandLineArgumentForMSVS(s)
   s = _EscapeVCProjCommandLineArgListItem(s)
   # cl.exe replaces literal # characters with = in preprocesor definitions for
   # some reason. Octal-encode to work around that.
@@ skipping 192 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' %
           spec['target_name'] + error + 'MSVC08 cannot handle that.')
     raise GypError('Duplicate basenames in sources section, see list above')
 
 
 def _GenerateMSVSProject(project, options, version, generator_flags):
@@ skipping 11 matching lines @@
   platforms = _GetUniquePlatforms(spec)
   p = MSVSProject.Writer(project.path, version, spec['target_name'],
                          project.guid, platforms)
 
   # Get directory project file is in.
   project_dir = os.path.split(project.path)[0]
   gyp_path = _NormalizedSource(project.build_file)
   relative_path_of_gyp_file = gyp.common.RelativePath(gyp_path, project_dir)
 
   config_type = _GetMSVSConfigurationType(spec, project.build_file)
-  for config_name, config in spec['configurations'].iteritems():
+  for config_name, config in spec['configurations'].items():
     _AddConfigurationToMSVSProject(p, spec, config_type, config_name, config)
 
   # MSVC08 and prior version cannot handle duplicate basenames in the same
   # target.
   # TODO: Take excluded sources into consideration if possible.
   _ValidateSourcesForMSVSProject(spec, version)
 
   # Prepare list of sources and excluded sources.
   gyp_file = os.path.split(project.build_file)[1]
   sources, excluded_sources = _PrepareListOfSources(spec, generator_flags,
@@ skipping 345 matching lines @@
 
 def _ConvertToolsToExpectedForm(tools):
   """Convert tools to a form expected by Visual Studio.
 
   Arguments:
     tools: A dictionary of settings; the tool name is the key.
   Returns:
     A list of Tool objects.
   """
   tool_list = []
-  for tool, settings in tools.iteritems():
+  for tool, settings in tools.items():
     # Collapse settings with lists.
     settings_fixed = {}
-    for setting, value in settings.iteritems():
+    for setting, value in settings.items():
       if type(value) == list:
         if ((tool == 'VCLinkerTool' and
              setting == 'AdditionalDependencies') or
             setting == 'AdditionalOptions'):
           settings_fixed[setting] = ' '.join(value)
         else:
           settings_fixed[setting] = ';'.join(value)
       else:
         settings_fixed[setting] = value
     # Add in this tool.
@@ skipping 154 matching lines @@
   if using_idl:
     excluded_idl = [i for i in sources if i.endswith('.idl')]
   else:
     excluded_idl = []
   return excluded_idl
 
 
 def _GetPrecompileRelatedFiles(spec):
   # Gather a list of precompiled header related sources.
   precompiled_related = []
-  for _, config in spec['configurations'].iteritems():
+  for _, config in spec['configurations'].items():
     for k in precomp_keys:
       f = config.get(k)
       if f:
         precompiled_related.append(_FixPath(f))
   return precompiled_related
 
 
 def _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_idl,
                                 list_excluded):
   exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
-  for file_name, excluded_configs in exclusions.iteritems():
+  for file_name, excluded_configs in exclusions.items():
     if (not list_excluded and
             len(excluded_configs) == len(spec['configurations'])):
       # If we're not listing excluded files, then they won't appear in the
       # project, so don't try to configure them to be excluded.
       pass
     else:
       for config_name, config in excluded_configs:
         p.AddFileConfig(file_name, _ConfigFullName(config_name, config),
                         {'ExcludedFromBuild': 'true'})
 
 
 def _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl):
   exclusions = {}
   # Exclude excluded sources from being built.
   for f in excluded_sources:
     excluded_configs = []
-    for config_name, config in spec['configurations'].iteritems():
+    for config_name, config in spec['configurations'].items():
       precomped = [_FixPath(config.get(i, '')) for i in precomp_keys]
       # Don't do this for ones that are precompiled header related.
       if f not in precomped:
         excluded_configs.append((config_name, config))
     exclusions[f] = excluded_configs
   # If any non-native rules use 'idl' as an extension exclude idl files.
   # Exclude them now.
   for f in excluded_idl:
     excluded_configs = []
-    for config_name, config in spec['configurations'].iteritems():
+    for config_name, config in spec['configurations'].items():
       excluded_configs.append((config_name, config))
     exclusions[f] = excluded_configs
   return exclusions
 
 
 def _AddToolFilesToMSVS(p, spec):
   # Add in tool files (rules).
   tool_files = OrderedSet()
-  for _, config in spec['configurations'].iteritems():
+  for _, config in spec['configurations'].items():
     for f in config.get('msvs_tool_files', []):
       tool_files.add(f)
   for f in tool_files:
     p.AddToolFile(f)
 
 
 def _HandlePreCompiledHeaders(p, sources, spec):
   # Pre-compiled header source stubs need a different compiler flag
   # (generate precompiled header) and any source file not of the same
   # kind (i.e. C vs. C++) as the precompiled header source stub needs
   # to have use of precompiled headers disabled.
   extensions_excluded_from_precompile = []
-  for config_name, config in spec['configurations'].iteritems():
+  for config_name, config in spec['configurations'].items():
     source = config.get('msvs_precompiled_source')
     if source:
       source = _FixPath(source)
       # UsePrecompiledHeader=1 for if using precompiled headers.
       tool = MSVSProject.Tool('VCCLCompilerTool',
                               {'UsePrecompiledHeader': '1'})
       p.AddFileConfig(source, _ConfigFullName(config_name, config),
                       {}, tools=[tool])
       basename, extension = os.path.splitext(source)
       if extension == '.c':
         extensions_excluded_from_precompile = ['.cc', '.cpp', '.cxx']
       else:
         extensions_excluded_from_precompile = ['.c']
   def DisableForSourceTree(source_tree):
     for source in source_tree:
       if isinstance(source, MSVSProject.Filter):
         DisableForSourceTree(source.contents)
       else:
         basename, extension = os.path.splitext(source)
         if extension in extensions_excluded_from_precompile:
-          for config_name, config in spec['configurations'].iteritems():
+          for config_name, config in spec['configurations'].items():
             tool = MSVSProject.Tool('VCCLCompilerTool',
                                     {'UsePrecompiledHeader': '0',
                                      'ForcedIncludeFiles': '$(NOINHERIT)'})
             p.AddFileConfig(_FixPath(source),
                             _ConfigFullName(config_name, config),
                             {}, tools=[tool])
   # Do nothing if there was no precompiled source.
   if extensions_excluded_from_precompile:
     DisableForSourceTree(sources)
 
@@ skipping 30 matching lines @@
     environment = run_as.get('environment', [])
     working_directory = run_as.get('working_directory', '.')
   elif int(spec.get('test', 0)):
     action = ['$(TargetPath)', '--gtest_print_time']
     environment = []
     working_directory = '.'
   else:
     return  # Nothing to add
   # Write out the user file.
   user_file = _CreateMSVSUserFile(project_path, version, spec)
-  for config_name, c_data in spec['configurations'].iteritems():
+  for config_name, c_data in spec['configurations'].items():
     user_file.AddDebugSettings(_ConfigFullName(config_name, c_data),
                                action, environment, working_directory)
   user_file.WriteIfChanged()
 
 
 def _AddCopies(actions_to_add, spec):
   copies = _GetCopies(spec)
   for inputs, outputs, cmd, description in copies:
     _AddActionStep(actions_to_add, inputs=inputs, outputs=outputs,
                    description=description, command=cmd)
@@ skipping 30 matching lines @@
   parent, folder = os.path.split(path)
   parent_dict = _GetPathDict(root, parent)
   if folder not in parent_dict:
     parent_dict[folder] = dict()
   return parent_dict[folder]
 
 
 def _DictsToFolders(base_path, bucket, flat):
   # Convert to folders recursively.
   children = []
-  for folder, contents in bucket.iteritems():
+  for folder, contents in bucket.items():
     if type(contents) == dict:
       folder_children = _DictsToFolders(os.path.join(base_path, folder),
                                         contents, flat)
       if flat:
         children += folder_children
       else:
         folder_children = MSVSNew.MSVSFolder(os.path.join(base_path, folder),
                                              name='(' + folder + ')',
                                              entries=folder_children)
         children.append(folder_children)
     else:
       children.append(contents)
   return children
 
 
 def _CollapseSingles(parent, node):
   # Recursively explorer the tree of dicts looking for projects which are
   # the sole item in a folder which has the same name as the project. Bring
   # such projects up one level.
   if (type(node) == dict and
       len(node) == 1 and
-      node.keys()[0] == parent + '.vcproj'):
-    return node[node.keys()[0]]
+      next(iter(node)) == parent + '.vcproj'):
+    return node[next(iter(node))]
   if type(node) != dict:
     return node
   for child in node:
     node[child] = _CollapseSingles(child, node[child])
   return node
 
 
 def _GatherSolutionFolders(sln_projects, project_objects, flat):
   root = {}
   # Convert into a tree of dicts on path.
   for p in sln_projects:
     gyp_file, target = gyp.common.ParseQualifiedTarget(p)[0:2]
     gyp_dir = os.path.dirname(gyp_file)
     path_dict = _GetPathDict(root, gyp_dir)
     path_dict[target + '.vcproj'] = project_objects[p]
   # Walk down from the top until we hit a folder that has more than one entry.
   # In practice, this strips the top-level "src/" dir from the hierarchy in
   # the solution.
-  while len(root) == 1 and type(root[root.keys()[0]]) == dict:
-    root = root[root.keys()[0]]
+  while len(root) == 1 and type(root[next(iter(root))]) == dict:
+    root = root[next(iter(root))]
   # Collapse singles.
   root = _CollapseSingles('', root)
   # Merge buckets until everything is a root entry.
   return _DictsToFolders('', root, flat)
 
 
 def _GetPathOfProject(qualified_target, spec, options, msvs_version):
   default_config = _GetDefaultConfiguration(spec)
   proj_filename = default_config.get('msvs_existing_vcproj')
   if not proj_filename:
     proj_filename = (spec['target_name'] + options.suffix +
                      msvs_version.ProjectExtension())
 
   build_file = gyp.common.BuildFile(qualified_target)
   proj_path = os.path.join(os.path.dirname(build_file), proj_filename)
   fix_prefix = None
   if options.generator_output:
     project_dir_path = os.path.dirname(os.path.abspath(proj_path))
     proj_path = os.path.join(options.generator_output, proj_path)
     fix_prefix = gyp.common.RelativePath(project_dir_path,
                                          os.path.dirname(proj_path))
   return proj_path, fix_prefix
 
 
 def _GetPlatformOverridesOfProject(spec):
   # Prepare a dict indicating which project configurations are used for which
   # solution configurations for this target.
   config_platform_overrides = {}
-  for config_name, c in spec['configurations'].iteritems():
+  for config_name, c in spec['configurations'].items():
     config_fullname = _ConfigFullName(config_name, c)
     platform = c.get('msvs_target_platform', _ConfigPlatform(c))
     fixed_config_fullname = '%s|%s' % (
         _ConfigBaseName(config_name, _ConfigPlatform(c)), platform)
     config_platform_overrides[config_fullname] = fixed_config_fullname
   return config_platform_overrides
 
 
 def _CreateProjectObjects(target_list, target_dicts, options, msvs_version):
   """Create a MSVSProject object for the targets found in target list.
@@ skipping 118 matching lines @@
 
   if gyp.common.GetFlavor(params) == 'ninja':
     default_variables['SHARED_INTERMEDIATE_DIR'] = '$(OutDir)gen'
 
 
 def PerformBuild(data, configurations, params):
   options = params['options']
   msvs_version = params['msvs_version']
   devenv = os.path.join(msvs_version.path, 'Common7', 'IDE', 'devenv.com')
 
-  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
     sln_path = build_file_root + options.suffix + '.sln'
     if options.generator_output:
       sln_path = os.path.join(options.generator_output, sln_path)
 
   for config in configurations:
     arguments = [devenv, sln_path, '/Build', config]
-    print 'Building [%s]: %s' % (config, arguments)
+    print('Building [%s]: %s' % (config, arguments))
     rtn = subprocess.check_call(arguments)
 
 
 def CalculateGeneratorInputInfo(params):
   if params.get('flavor') == 'ninja':
     toplevel = params['options'].toplevel_dir
     qualified_out_dir = os.path.normpath(os.path.join(
         toplevel, ninja_generator.ComputeOutputDir(params),
         'gypfiles-msvs-ninja'))
 
@@ skipping 31 matching lines @@
         target_list, target_dicts, generator_default_variables)
 
   # Optionally configure each spec to use ninja as the external builder.
   if params.get('flavor') == 'ninja':
     _InitNinjaFlavor(params, target_list, target_dicts)
 
   # Prepare the set of configurations.
   configs = set()
   for qualified_target in target_list:
     spec = target_dicts[qualified_target]
-    for config_name, config in spec['configurations'].iteritems():
+    for config_name, config in spec['configurations'].items():
       configs.add(_ConfigFullName(config_name, config))
   configs = list(configs)
 
   # Figure out all the projects that will be generated and their guids
   project_objects = _CreateProjectObjects(target_list, target_dicts, options,
                                           msvs_version)
 
   # Generate each project.
   missing_sources = []
   for project in project_objects.values():
@@ skipping 22 matching lines @@
                                websiteProperties=False,
                                version=msvs_version)
     sln.Write()
 
   if missing_sources:
     error_message = "Missing input files:\n" + \
                     '\n'.join(set(missing_sources))
     if generator_flags.get('msvs_error_on_missing_sources', False):
       raise GypError(error_message)
     else:
-      print >> sys.stdout, "Warning: " + error_message
+      print("Warning: " + error_message, file=sys.stdout)
 
 
 def _GenerateMSBuildFiltersFile(filters_path, source_files,
                                 rule_dependencies, extension_to_rule_name):
   """Generate the filters file.
 
   This file is used by Visual Studio to organize the presentation of source
   files into folders.
 
   Arguments:
@@ skipping 576 matching lines @@
   return (configuration, platform)
 
 
 def _GetConfigurationCondition(name, settings):
   return (r"'$(Configuration)|$(Platform)'=='%s|%s'" %
           _GetConfigurationAndPlatform(name, settings))
 
 
 def _GetMSBuildProjectConfigurations(configurations):
   group = ['ItemGroup', {'Label': 'ProjectConfigurations'}]
-  for (name, settings) in sorted(configurations.iteritems()):
+  for (name, settings) in sorted(configurations.items()):
     configuration, platform = _GetConfigurationAndPlatform(name, settings)
     designation = '%s|%s' % (configuration, platform)
     group.append(
         ['ProjectConfiguration', {'Include': designation},
          ['Configuration', configuration],
          ['Platform', platform]])
   return [group]
 
 
 def _GetMSBuildGlobalProperties(spec, guid, gyp_file_name):
@@ skipping 33 matching lines @@
                               target_platform_version])
     if spec.get('msvs_enable_winphone'):
       properties[0].append(['ApplicationType', 'Windows Phone'])
     else:
       properties[0].append(['ApplicationType', 'Windows Store'])
 
   return properties
 
 def _GetMSBuildConfigurationDetails(spec, build_file):
   properties = {}
-  for name, settings in spec['configurations'].iteritems():
+  for name, settings in spec['configurations'].items():
     msbuild_attributes = _GetMSBuildAttributes(spec, settings, build_file)
     condition = _GetConfigurationCondition(name, settings)
     character_set = msbuild_attributes.get('CharacterSet')
     _AddConditionalProperty(properties, condition, 'ConfigurationType',
                             msbuild_attributes['ConfigurationType'])
     if character_set:
       if 'msvs_enable_winrt' not in spec :
         _AddConditionalProperty(properties, condition, 'CharacterSet',
                                 character_set)
   return _GetMSBuildPropertyGroup(spec, 'Configuration', properties)
 
 
 def _GetMSBuildLocalProperties(msbuild_toolset):
   # Currently the only local property we support is PlatformToolset
   properties = {}
   if msbuild_toolset:
     properties = [
         ['PropertyGroup', {'Label': 'Locals'},
           ['PlatformToolset', msbuild_toolset],
         ]
       ]
   return properties
 
 
 def _GetMSBuildPropertySheets(configurations):
   user_props = r'$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props'
   additional_props = {}
   props_specified = False
-  for name, settings in sorted(configurations.iteritems()):
+  for name, settings in sorted(configurations.items()):
     configuration = _GetConfigurationCondition(name, settings)
-    if settings.has_key('msbuild_props'):
+    if 'msbuild_props' in settings:
       additional_props[configuration] = _FixPaths(settings['msbuild_props'])
       props_specified = True
     else:
      additional_props[configuration] = ''
 
   if not props_specified:
     return [
         ['ImportGroup',
          {'Label': 'PropertySheets'},
          ['Import',
           {'Project': user_props,
            'Condition': "exists('%s')" % user_props,
            'Label': 'LocalAppDataPlatform'
           }
          ]
         ]
     ]
   else:
     sheets = []
-    for condition, props in additional_props.iteritems():
+    for condition, props in additional_props.items():
       import_group = [
         'ImportGroup',
         {'Label': 'PropertySheets',
          'Condition': condition
         },
         ['Import',
          {'Project': user_props,
           'Condition': "exists('%s')" % user_props,
           'Label': 'LocalAppDataPlatform'
          }
@@ skipping 12 matching lines @@
     if a in ['IntermediateDirectory', 'OutputDirectory']:
       directory = MSVSSettings.ConvertVCMacrosToMSBuild(msvs_attributes[a])
       if not directory.endswith('\\'):
         directory += '\\'
       msbuild_attributes[a] = directory
     elif a == 'CharacterSet':
       msbuild_attributes[a] = _ConvertMSVSCharacterSet(msvs_attributes[a])
     elif a == 'ConfigurationType':
       msbuild_attributes[a] = _ConvertMSVSConfigurationType(msvs_attributes[a])
     else:
-      print 'Warning: Do not know how to convert MSVS attribute ' + a
+      print('Warning: Do not know how to convert MSVS attribute ' + a)
   return msbuild_attributes
 
 
 def _ConvertMSVSCharacterSet(char_set):
   if char_set.isdigit():
     char_set = {
         '0': 'MultiByte',
         '1': 'Unicode',
         '2': 'MultiByte',
     }[char_set]
@@ skipping 70 matching lines @@
     cyg_path = '$(MSBuildProjectDirectory)\\%s\\bin\\' % _FixPath(cygwin_dirs)
     new_paths.append(cyg_path)
     # TODO(jeanluc) Change the convention to have both a cygwin_dir and a
     # python_dir.
     python_path = cyg_path.replace('cygwin\\bin', 'python_26')
     new_paths.append(python_path)
     if new_paths:
       new_paths = '$(ExecutablePath);' + ';'.join(new_paths)
 
   properties = {}
-  for (name, configuration) in sorted(configurations.iteritems()):
+  for (name, configuration) in sorted(configurations.items()):
     condition = _GetConfigurationCondition(name, configuration)
     attributes = _GetMSBuildAttributes(spec, configuration, build_file)
     msbuild_settings = configuration['finalized_msbuild_settings']
     _AddConditionalProperty(properties, condition, 'IntDir',
                             attributes['IntermediateDirectory'])
     _AddConditionalProperty(properties, condition, 'OutDir',
                             attributes['OutputDirectory'])
     _AddConditionalProperty(properties, condition, 'TargetName',
                             attributes['TargetName'])
 
     if attributes.get('TargetPath'):
       _AddConditionalProperty(properties, condition, 'TargetPath',
                               attributes['TargetPath'])
     if attributes.get('TargetExt'):
       _AddConditionalProperty(properties, condition, 'TargetExt',
                               attributes['TargetExt'])
 
     if new_paths:
       _AddConditionalProperty(properties, condition, 'ExecutablePath',
                               new_paths)
     tool_settings = msbuild_settings.get('', {})
-    for name, value in sorted(tool_settings.iteritems()):
+    for name, value in sorted(tool_settings.items()):
       formatted_value = _GetValueFormattedForMSBuild('', name, value)
       _AddConditionalProperty(properties, condition, name, formatted_value)
   return _GetMSBuildPropertyGroup(spec, None, properties)
 
 
 def _AddConditionalProperty(properties, condition, name, value):
   """Adds a property / conditional value pair to a dictionary.
 
   Arguments:
     properties: The dictionary to be modified.  The key is the name of the
@@ skipping 48 matching lines @@
                         if v in properties and v != node]))
     return edges
   properties_ordered = gyp.common.TopologicallySorted(
       properties.keys(), GetEdges)
   # Walk properties in the reverse of a topological sort on
   # user_of_variable -> used_variable as this ensures variables are
   # defined before they are used.
   # NOTE: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))
   for name in reversed(properties_ordered):
     values = properties[name]
-    for value, conditions in sorted(values.iteritems()):
+    for value, conditions in sorted(values.items()):
       if len(conditions) == num_configurations:
         # If the value is the same all configurations,
         # just add one unconditional entry.
         group.append([name, value])
       else:
         for condition in conditions:
           group.append([name, {'Condition': condition}, value])
   return [group]
 
 
 def _GetMSBuildToolSettingsSections(spec, configurations):
   groups = []
-  for (name, configuration) in sorted(configurations.iteritems()):
+  for (name, configuration) in sorted(configurations.items()):
     msbuild_settings = configuration['finalized_msbuild_settings']
     group = ['ItemDefinitionGroup',
              {'Condition': _GetConfigurationCondition(name, configuration)}
             ]
-    for tool_name, tool_settings in sorted(msbuild_settings.iteritems()):
+    for tool_name, tool_settings in sorted(msbuild_settings.items()):
       # Skip the tool named '' which is a holder of global settings handled
       # by _GetMSBuildConfigurationGlobalProperties.
       if tool_name:
         if tool_settings:
           tool = [tool_name]
-          for name, value in sorted(tool_settings.iteritems()):
+          for name, value in sorted(tool_settings.items()):
             formatted_value = _GetValueFormattedForMSBuild(tool_name, name,
                                                            value)
             tool.append([name, formatted_value])
           group.append(tool)
     groups.append(group)
   return groups
 
 
 def _FinalizeMSBuildSettings(spec, configuration):
   if 'msbuild_settings' in configuration:
@@ skipping 179 matching lines @@
         excluded_configurations = exclusions.get(source, [])
         if len(excluded_configurations) == len(spec['configurations']):
           detail.append(['ExcludedFromBuild', 'true'])
         else:
           for config_name, configuration in sorted(excluded_configurations):
             condition = _GetConfigurationCondition(config_name, configuration)
             detail.append(['ExcludedFromBuild',
                            {'Condition': condition},
                            'true'])
         # Add precompile if needed
-        for config_name, configuration in spec['configurations'].iteritems():
+        for config_name, configuration in spec['configurations'].items():
           precompiled_source = configuration.get('msvs_precompiled_source', '')
           if precompiled_source != '':
             precompiled_source = _FixPath(precompiled_source)
             if not extensions_excluded_from_precompile:
               # If the precompiled header is generated by a C source, we must
               # not try to use it for C++ sources, and vice versa.
               basename, extension = os.path.splitext(precompiled_source)
               if extension == '.c':
                 extensions_excluded_from_precompile = ['.cc', '.cpp', '.cxx']
               else:
@@ skipping 25 matching lines @@
     group = ['ItemGroup']
     for dependency in project.dependencies:
       guid = dependency.guid
       project_dir = os.path.split(project.path)[0]
       relative_path = gyp.common.RelativePath(dependency.path, project_dir)
       project_ref = ['ProjectReference',
           {'Include': relative_path},
           ['Project', guid],
           ['ReferenceOutputAssembly', 'false']
           ]
-      for config in dependency.spec.get('configurations', {}).itervalues():
+      for config in dependency.spec.get('configurations', {}).values():
         # If it's disabled in any config, turn it off in the reference.
         if config.get('msvs_2010_disable_uldi_when_referenced', 0):
           project_ref.append(['UseLibraryDependencyInputs', 'false'])
           break
       group.append(project_ref)
     references.append(group)
   return references
 
 
 def _GenerateMSBuildProject(project, options, version, generator_flags):
@@ skipping 45 matching lines @@
 
   exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
   actions_spec, sources_handled_by_action = _GenerateActionsForMSBuild(
       spec, actions_to_add)
 
   _GenerateMSBuildFiltersFile(project.path + '.filters', sources,
                               rule_dependencies,
                               extension_to_rule_name)
   missing_sources = _VerifySourcesExist(sources, project_dir)
 
-  for configuration in configurations.itervalues():
+  for configuration in configurations.values():
     _FinalizeMSBuildSettings(spec, configuration)
 
   # Add attributes to root element
 
   import_default_section = [
       ['Import', {'Project': r'$(VCTargetsPath)\Microsoft.Cpp.Default.props'}]]
   import_cpp_props_section = [
       ['Import', {'Project': r'$(VCTargetsPath)\Microsoft.Cpp.props'}]]
   import_cpp_targets_section = [
       ['Import', {'Project': r'$(VCTargetsPath)\Microsoft.Cpp.targets'}]]
@@ skipping 104 matching lines @@
   Arguments:
     spec: the target project dict
     actions_to_add: dictionary keyed on input name, which maps to a list of
         dicts describing the actions attached to that input file.
 
   Returns:
     A pair of (action specification, the sources handled by this action).
   """
   sources_handled_by_action = OrderedSet()
   actions_spec = []
-  for primary_input, actions in actions_to_add.iteritems():
+  for primary_input, actions in actions_to_add.items():
     inputs = OrderedSet()
     outputs = OrderedSet()
     descriptions = []
     commands = []
     for action in actions:
       inputs.update(OrderedSet(action['inputs']))
       outputs.update(OrderedSet(action['outputs']))
       descriptions.append(action['description'])
       cmd = action['command']
       # For most actions, add 'call' so that actions that invoke batch files
@@ skipping 37 matching lines @@
   action_spec.extend(
       # TODO(jeanluc) 'Document' for all or just if as_sources?
       [['FileType', 'Document'],
        ['Command', command],
        ['Message', description],
        ['Outputs', outputs]
       ])
   if additional_inputs:
     action_spec.append(['AdditionalInputs', additional_inputs])
   actions_spec.append(action_spec)