Add support for building targets directly from gyp.

pylib/gyp/MSVSVersion.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.
 
 """Handle version information related to Visual Stuio."""
 
 import errno
 import os
 import re
 import subprocess
 import sys
+import gyp
 
 
 class VisualStudioVersion(object):
   """Information regarding a version of Visual Studio."""
 
   def __init__(self, short_name, description,
                solution_version, project_version, flat_sln, uses_vcxproj,
                path, sdk_based, default_toolset=None):
     self.short_name = short_name
     self.description = description
@@ skipping 164 matching lines @@
   return True
 
 
 def _CreateVersion(name, path, sdk_based=False):
   """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.
   """
+  if path:
+    path = os.path.normpath(path)
   versions = {
       '2012': VisualStudioVersion('2012',
                                   'Visual Studio 2012',
                                   solution_version='12.00',
                                   project_version='4.0',
                                   flat_sln=False,
                                   uses_vcxproj=True,
                                   path=path,
                                   sdk_based=sdk_based,
                                   default_toolset='v110'),
@@ skipping 51 matching lines @@
                                    solution_version='9.00',
                                    project_version='8.00',
                                    flat_sln=True,
                                    uses_vcxproj=False,
                                    path=path,
                                    sdk_based=sdk_based),
   }
   return versions[str(name)]
 
 
+def _ConvertToCygpath(path):
+  """Convert to cygwin path if we are using cygwin."""
+  if sys.platform == 'cygwin':
+    p = subprocess.Popen(["cygpath", path], stdout=subprocess.PIPE)

[bradn, 2012/09/18 00:22:39]

Use '' like the rest of the file.

[Sam Clegg, 2012/09/18 00:47:17]

Done.

+    path = p.communicate()[0].strip()
+  return path
+
+
 def _DetectVisualStudioVersions(versions_to_check, force_express):
   """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)
@@ skipping 10 matching lines @@
     # We don't use the 2010-encouraged-way because we also want to get the
     # path to the binaries, which it doesn't offer.
     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
+      path = _ConvertToCygpath(path)
       # Check for full.
       full_path = os.path.join(path, 'devenv.exe')
       express_path = os.path.join(path, 'vcexpress.exe')
       if not force_express and os.path.exists(full_path):
         # Add this one.
         versions.append(_CreateVersion(version_to_year[version],
             os.path.join(path, '..', '..')))
       # Check for express.
       elif os.path.exists(express_path):
         # Add this one.
         versions.append(_CreateVersion(version_to_year[version] + 'e',
             os.path.join(path, '..', '..')))
 
     # The old method above does not work when only SDK is installed.
     keys = [r'HKLM\Software\Microsoft\VisualStudio\SxS\VC7',
             r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VC7']
     for index in range(len(keys)):
       path = _RegistryGetValue(keys[index], version)
       if not path:
         continue
+      path = _ConvertToCygpath(path)
       versions.append(_CreateVersion(version_to_year[version] + 'e',
           os.path.join(path, '..'), sdk_based=True))
 
   return versions
 
 
 def SelectVisualStudioVersion(version='auto'):
   """Select which version of Visual Studio projects to generate.
 
   Arguments:
@@ skipping 17 matching lines @@
   }
   version = str(version)
   versions = _DetectVisualStudioVersions(version_map[version], 'e' in version)
   if not versions:
     if version == 'auto':
       # Default to 2005 if we couldn't find anything
       return _CreateVersion('2005', None)
     else:
       return _CreateVersion(version, None)
   return versions[0]