Fix eclipse generator when running on Windows.

pylib/gyp/generator/eclipse.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.
 
 """GYP backend that generates Eclipse CDT settings files.
 
 This backend DOES NOT generate Eclipse CDT projects. Instead, it generates XML
 files that can be imported into an Eclipse CDT project. The XML file contains a
 list of include paths and symbols (i.e. defines).
 
 Because a full .cproject definition is not created by this generator, it's not
 possible to properly define the include dirs and symbols for each file
 individually.  Instead, one set of includes/symbols is generated for the entire
 project.  This works fairly well (and is a vast improvement in general), but may
 still result in a few indexer issues here and there.
 
 This generator has no automated tests, so expect it to be broken.
 """
 
 from xml.sax.saxutils import escape
 import os.path
 import subprocess
 import gyp
 import gyp.common
+import gyp.msvs_emulation
 import shlex
 
 generator_wants_static_library_dependencies_adjusted = False
 
 generator_default_variables = {
 }
 
 for dirname in ['INTERMEDIATE_DIR', 'PRODUCT_DIR', 'LIB_DIR', 'SHARED_LIB_DIR']:
   # Some gyp steps fail if these are empty(!).
   generator_default_variables[dirname] = 'dir'
@@ skipping 10 matching lines @@
 # part of the path when dealing with generated headers.  This value will be
 # replaced dynamically for each configuration.
 generator_default_variables['SHARED_INTERMEDIATE_DIR'] = \
     '$SHARED_INTERMEDIATE_DIR'
 
 
 def CalculateVariables(default_variables, params):
   generator_flags = params.get('generator_flags', {})
   for key, val in generator_flags.items():
     default_variables.setdefault(key, val)
-  default_variables.setdefault('OS', gyp.common.GetFlavor(params))
+  flavor = gyp.common.GetFlavor(params)
+  default_variables.setdefault('OS', flavor)
+  if flavor == 'win':
+    # Copy additional generator configuration data from VS, which is shared
+    # by the Eclipse generator.
+    import gyp.generator.msvs as msvs_generator
+    generator_additional_non_configuration_keys = getattr(msvs_generator,
+        'generator_additional_non_configuration_keys', [])
+    generator_additional_path_sections = getattr(msvs_generator,
+        'generator_additional_path_sections', [])
+
+    # Set a variable so conditions can be based on msvs_version.
+    msvs_version = gyp.msvs_emulation.GetVSVersion(generator_flags)
+    default_variables['MSVS_VERSION'] = msvs_version.ShortName()
+
+    # To determine processor word size on Windows, in addition to checking
+    # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
+    # process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
+    # contains the actual word size of the system when running thru WOW64).
+    if ('64' in os.environ.get('PROCESSOR_ARCHITECTURE', '') or
+        '64' in os.environ.get('PROCESSOR_ARCHITEW6432', '')):
+      default_variables['MSVS_OS_BITS'] = 64
+    else:
+      default_variables['MSVS_OS_BITS'] = 32
 
 
 def CalculateGeneratorInputInfo(params):
   """Calculate the generator specific info that gets fed to input (called by
   gyp)."""
   generator_flags = params.get('generator_flags', {})
   if generator_flags.get('adjust_static_libraries', False):
     global generator_wants_static_library_dependencies_adjusted
     generator_wants_static_library_dependencies_adjusted = True
 
 
 def GetAllIncludeDirectories(target_list, target_dicts,
-                             shared_intermediate_dirs, config_name):
+                             shared_intermediate_dirs, config_name, params):
   """Calculate the set of include directories to be used.
 
   Returns:
     A list including all the include_dir's specified for every target followed
     by any include directories that were added as cflag compiler options.
   """
 
   gyp_includes_set = set()
   compiler_includes_list = []
 
+  flavor = gyp.common.GetFlavor(params)
+  if flavor == 'win':
+    generator_flags = params.get('generator_flags', {})
   for target_name in target_list:
     target = target_dicts[target_name]
     if config_name in target['configurations']:
       config = target['configurations'][config_name]
 
       # Look for any include dirs that were explicitly added via cflags. This
       # may be done in gyp files to force certain includes to come at the end.
       # TODO(jgreenwald): Change the gyp files to not abuse cflags for this, and
       # remove this.
-      cflags = config['cflags']
+      if flavor == 'win':
+        msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
+        cflags = msvs_settings.GetCflags(config_name)
+      else:
+        cflags = config['cflags']
       for cflag in cflags:
         include_dir = ''
         if cflag.startswith('-I'):
           include_dir = cflag[2:]
         if include_dir and not include_dir in compiler_includes_list:
           compiler_includes_list.append(include_dir)
 
       # Find standard gyp include dirs.
       if config.has_key('include_dirs'):
         include_dirs = config['include_dirs']
@@ skipping 40 matching lines @@
 
   # Check to see if the compiler was specified as an environment variable.
   for key in ['CC_target', 'CC', 'CXX']:
     compiler = os.environ.get(key)
     if compiler:
       return compiler
 
   return 'gcc'
 
 
-def GetAllDefines(target_list, target_dicts, data, config_name):
+def GetAllDefines(target_list, target_dicts, data, config_name, params):
   """Calculate the defines for a project.
 
   Returns:
     A dict that includes explict defines declared in gyp files along with all of
     the default defines that the compiler uses.
   """
 
   # Get defines declared in the gyp files.
   all_defines = {}
+  flavor = gyp.common.GetFlavor(params)
+  if flavor == 'win':
+    generator_flags = params.get('generator_flags', {})
   for target_name in target_list:
     target = target_dicts[target_name]
 
+    if flavor == 'win':
+      msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
+      extra_defines = msvs_settings.GetComputedDefines(config_name)
+    else:
+      extra_defines = []
     if config_name in target['configurations']:
       config = target['configurations'][config_name]
-      for define in config['defines']:
-        split_define = define.split('=', 1)
-        if len(split_define) == 1:
-          split_define.append('1')
-        if split_define[0].strip() in all_defines:
-          # Already defined
-          continue
-
-        all_defines[split_define[0].strip()] = split_define[1].strip()
-
+      target_defines = config['defines']
+    else:
+      target_defines = []
+    for define in target_defines + extra_defines:
+      split_define = define.split('=', 1)
+      if len(split_define) == 1:
+        split_define.append('1')
+      if split_define[0].strip() in all_defines:
+        # Already defined
+        continue
+      all_defines[split_define[0].strip()] = split_define[1].strip()
   # Get default compiler defines (if possible).
+  if flavor == 'win':
+    return all_defines  # Default defines already processed in the loop above.
   cc_target = GetCompilerPath(target_list, target_dicts, data)
   if cc_target:
     command = shlex.split(cc_target)
     command.extend(['-E', '-dM', '-'])
     cpp_proc = subprocess.Popen(args=command, cwd='.',
                                 stdin=subprocess.PIPE, stdout=subprocess.PIPE)
     cpp_output = cpp_proc.communicate()[0]
     cpp_lines = cpp_output.split('\n')
     for cpp_line in cpp_lines:
       if not cpp_line.strip():
@@ skipping 58 matching lines @@
   if not os.path.exists(toplevel_build):
     os.makedirs(toplevel_build)
   out = open(os.path.join(toplevel_build, 'eclipse-cdt-settings.xml'), 'w')
 
   out.write('<?xml version="1.0" encoding="UTF-8"?>\n')
   out.write('<cdtprojectproperties>\n')
 
   eclipse_langs = ['C++ Source File', 'C Source File', 'Assembly Source File',
                    'GNU C++', 'GNU C', 'Assembly']
   include_dirs = GetAllIncludeDirectories(target_list, target_dicts,
-                                          shared_intermediate_dirs, config_name)
+                                          shared_intermediate_dirs, config_name,
+                                          params)
   WriteIncludePaths(out, eclipse_langs, include_dirs)
-  defines = GetAllDefines(target_list, target_dicts, data, config_name)
+  defines = GetAllDefines(target_list, target_dicts, data, config_name, params)
   WriteMacros(out, eclipse_langs, defines)
 
   out.write('</cdtprojectproperties>\n')
   out.close()
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   """Generate an XML settings file that can be imported into a CDT project."""
 
   if params['options'].generator_output:
     raise NotImplementedError, "--generator_output not implemented for eclipse"
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)