Next level of changes to get more of Chrome building

pylib/gyp/MSVSVersion.py

 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Handle version information related to Visual Stuio."""
 
 import errno
 import os
 import re
 import subprocess
 import sys
 
 
 class VisualStudioVersion(object):
   """Information regarding a version of Visual Studio."""
 
   def __init__(self, short_name, description,
-               solution_version, project_version, flat_sln, uses_vcxproj):
+               solution_version, project_version, flat_sln, uses_vcxproj,
+               path):
     self.short_name = short_name
     self.description = description
     self.solution_version = solution_version
     self.project_version = project_version
     self.flat_sln = flat_sln
     self.uses_vcxproj = uses_vcxproj
+    self.path = path
 
   def ShortName(self):
     return self.short_name
 
   def Description(self):
     """Get the full description of the version."""
     return self.description
 
   def SolutionVersion(self):
     """Get the version number of the sln files."""
     return self.solution_version
 
   def ProjectVersion(self):
     """Get the version number of the vcproj or vcxproj files."""
     return self.project_version
 
   def FlatSolution(self):
     return self.flat_sln
 
   def UsesVcxproj(self):
     """Returns true if this version uses a vcxproj file."""
     return self.uses_vcxproj
 
   def ProjectExtension(self):
     """Returns the file extension for the project."""
     return self.uses_vcxproj and '.vcxproj' or '.vcproj'
 
+  def Path(self):
+    """Returns the path to Visual Studio installation."""
+    return self.path
+
 def _RegistryQueryBase(sysdir, key, value):
   """Use reg.exe to read a particular key.
 
   While ideally we might use the win32 module, we would like gyp to be
   python neutral, so for instance cygwin python lacks this module.
 
   Arguments:
     sysdir: The system subdirectory to attempt to launch reg.exe from.
     key: The registry key to read from.
     value: The particular value to read.
@@ skipping 71 matching lines @@
   Args:
     key: The registry key to check.
   Return:
     True if the key exists
   """
   if not _RegistryQuery(key):
     return False
   return True
 
 
-def _CreateVersion(name):
+def _CreateVersion(name, path):
   """Sets up MSVS project generation.
 
   Setup is based off the GYP_MSVS_VERSION environment variable or whatever is
   autodetected if GYP_MSVS_VERSION is not explicitly specified. If a version is
   passed in that doesn't match a value in versions python will throw a error.
   """
   versions = {
       '2010': VisualStudioVersion('2010',
                                   'Visual Studio 2010',
                                   solution_version='11.00',
                                   project_version='4.0',
                                   flat_sln=False,
-                                  uses_vcxproj=True),
+                                  uses_vcxproj=True,
+                                  path=path),
       '2010e': VisualStudioVersion('2010e',
                                    'Visual Studio 2010',
                                    solution_version='11.00',
                                    project_version='4.0',
                                    flat_sln=True,
-                                   uses_vcxproj=True),
+                                   uses_vcxproj=True,
+                                   path=path),
       '2008': VisualStudioVersion('2008',
                                   'Visual Studio 2008',
                                   solution_version='10.00',
                                   project_version='9.00',
                                   flat_sln=False,
-                                  uses_vcxproj=False),
+                                  uses_vcxproj=False,
+                                  path=path),
       '2008e': VisualStudioVersion('2008e',
                                    'Visual Studio 2008',
                                    solution_version='10.00',
                                    project_version='9.00',
                                    flat_sln=True,
-                                   uses_vcxproj=False),
+                                   uses_vcxproj=False,
+                                   path=path),
       '2005': VisualStudioVersion('2005',
                                   'Visual Studio 2005',
                                   solution_version='9.00',
                                   project_version='8.00',
                                   flat_sln=False,
-                                  uses_vcxproj=False),
+                                  uses_vcxproj=False,
+                                  path=path),
       '2005e': VisualStudioVersion('2005e',
                                    'Visual Studio 2005',
                                    solution_version='9.00',
                                    project_version='8.00',
                                    flat_sln=True,
-                                   uses_vcxproj=False),
+                                   uses_vcxproj=False,
+                                   path=path),
   }
   return versions[str(name)]
 
 
 def _DetectVisualStudioVersions():
   """Collect the list of installed visual studio versions.
 
   Returns:
     A list of visual studio versions installed in descending order of
     usage preference.
     Base this on the registry and a quick check if devenv.exe exists.
     Only versions 8-10 are considered.
     Possibilities are:
       2005(e) - Visual Studio 2005 (8)
       2008(e) - Visual Studio 2008 (9)
       2010(e) - Visual Studio 2010 (10)
     Where (e) is e for express editions of MSVS and blank otherwise.
   """
   version_to_year = {'8.0': '2005', '9.0': '2008', '10.0': '2010'}
   versions = []
   # For now, prefer versions before VS2010
   for version in ('9.0', '8.0', '10.0'):
+
+    '''
     # Check if VS2010 and later is installed as specified by
     # http://msdn.microsoft.com/en-us/library/bb164659.aspx
     keys = [r'HKLM\SOFTWARE\Microsoft\DevDiv\VS\Servicing\%s' % version,
             r'HKLM\SOFTWARE\Wow6432Node\Microsoft\DevDiv\VS\Servicing\%s' % (
               version)]
     for index in range(len(keys)):
       if not _RegistryKeyExists(keys[index]):
         continue
       # Check for express
       if _RegistryKeyExists(keys[index] + '\\expbsln'):
         # Add this one
-        versions.append(_CreateVersion(version_to_year[version] + 'e'))
+        versions.append(_CreateVersion(version_to_year[version] + 'e', "TODO!"))
       else:
         # Add this one
-        versions.append(_CreateVersion(version_to_year[version]))
+        versions.append(_CreateVersion(version_to_year[version], "TODO!"))
+    '''
 
     # Old (pre-VS2010) method of searching for which VS version is installed
     keys = [r'HKLM\Software\Microsoft\VisualStudio\%s' % version,
             r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\%s' % version,
             r'HKLM\Software\Microsoft\VCExpress\%s' % version,
             r'HKLM\Software\Wow6432Node\Microsoft\VCExpress\%s' % version]
     for index in range(len(keys)):
       path = _RegistryGetValue(keys[index], 'InstallDir')
       if not path:
         continue
       # Check for full.
-      if os.path.exists(os.path.join(path, 'devenv.exe')):
+      full_path = os.path.join(path, 'devenv.exe')
+      express_path = os.path.join(path, 'vcexpress.exe')
+      if os.path.exists(full_path):
         # Add this one.
-        versions.append(_CreateVersion(version_to_year[version]))
+        versions.append(_CreateVersion(version_to_year[version],
+            os.path.join(path, '../..')))
       # Check for express.
-      elif os.path.exists(os.path.join(path, 'vcexpress.exe')):
+      elif os.path.exists(express_path):
         # Add this one.
-        versions.append(_CreateVersion(version_to_year[version] + 'e'))
+        versions.append(_CreateVersion(version_to_year[version] + 'e',
+            os.path.join(path, '../..')))
   return versions
 
 
 def SelectVisualStudioVersion(version='auto'):
   """Select which version of Visual Studio projects to generate.
 
   Arguments:
     version: Hook to allow caller to force a particular version (vs auto).
   Returns:
     An object representing a visual studio project format version.
   """
   # In auto mode, check environment variable for override.
   if version == 'auto':
     version = os.environ.get('GYP_MSVS_VERSION', 'auto')
   # In auto mode, pick the most preferred version present.
   if version == 'auto':
     versions = _DetectVisualStudioVersions()
     if not versions:
       # Default to 2005.
       return _CreateVersion('2005')
     return versions[0]
   # Convert version string into a version object.
   return _CreateVersion(version)