Add limited support for Mac to CMake generator.

pylib/gyp/generator/cmake.py

 # Copyright (c) 2013 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.
 
 """cmake output module
 
 This module is under development and should be considered experimental.
 
 This module produces cmake (2.8.8+) input as its output. One CMakeLists.txt is
 created for each configuration.
@@ skipping 16 matching lines @@
 not be able to find the header file directories described in the generated
 CMakeLists.txt file.
 """
 
 import multiprocessing
 import os
 import signal
 import string
 import subprocess
 import gyp.common
+import gyp.xcode_emulation
 
 generator_default_variables = {
   'EXECUTABLE_PREFIX': '',
   'EXECUTABLE_SUFFIX': '',
   'STATIC_LIB_PREFIX': 'lib',
   'STATIC_LIB_SUFFIX': '.a',
   'SHARED_LIB_PREFIX': 'lib',
   'SHARED_LIB_SUFFIX': '.so',
   'SHARED_LIB_DIR': '${builddir}/lib.${TOOLSET}',
   'LIB_DIR': '${obj}.${TOOLSET}',
@@ skipping 554 matching lines @@
         self.cmake_target_base_names_conficting.add(cmake_target_base_name)
 
   def CreateCMakeTargetName(self, qualified_target):
     base_name = CreateCMakeTargetBaseName(qualified_target)
     if base_name in self.cmake_target_base_names_conficting:
       return CreateCMakeTargetFullName(qualified_target)
     return base_name
 
 
 def WriteTarget(namer, qualified_target, target_dicts, build_dir, config_to_use,
-                options, generator_flags, all_qualified_targets, output):
-
+                options, generator_flags, all_qualified_targets, flavor,
+                output):
   # The make generator does this always.
   # TODO: It would be nice to be able to tell CMake all dependencies.
   circular_libs = generator_flags.get('circular', True)
 
   if not generator_flags.get('standalone', False):
     output.write('\n#')
     output.write(qualified_target)
     output.write('\n')
 
   gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
   rel_gyp_file = gyp.common.RelativePath(gyp_file, options.toplevel_dir)
   rel_gyp_dir = os.path.dirname(rel_gyp_file)
 
   # Relative path from build dir to top dir.
   build_to_top = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
   # Relative path from build dir to gyp dir.
   build_to_gyp = os.path.join(build_to_top, rel_gyp_dir)
 
   path_from_cmakelists_to_gyp = build_to_gyp
 
   spec = target_dicts.get(qualified_target, {})
   config = spec.get('configurations', {}).get(config_to_use, {})
 
+  xcode_settings = None
+  if flavor == 'mac':
+    xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
+
   target_name = spec.get('target_name', '<missing target name>')
   target_type = spec.get('type', '<missing target type>')
   target_toolset = spec.get('toolset')
 
   cmake_target_type = cmake_target_type_from_gyp_target_type.get(target_type)
   if cmake_target_type is None:
     print ('Target %s has unknown target type %s, skipping.' %
           (        target_name,               target_type  ) )
     return
 
@@ skipping 251 matching lines @@
       output.write('set_property(TARGET ')
       output.write(cmake_target_name)
       output.write(' APPEND PROPERTY INCLUDE_DIRECTORIES ')
       WriteVariable(output, includes_name, '')
       output.write(')\n')
 
     # Defines
     defines = config.get('defines')
     if defines is not None:
       SetTargetProperty(output,
-                          cmake_target_name,
-                          'COMPILE_DEFINITIONS',
-                          defines,
-                          ';')
+                        cmake_target_name,
+                        'COMPILE_DEFINITIONS',
+                        defines,
+                        ';')
 
     # Compile Flags - http://www.cmake.org/Bug/view.php?id=6493
     # CMake currently does not have target C and CXX flags.
     # So, instead of doing...
 
     # cflags_c = config.get('cflags_c')
     # if cflags_c is not None:
     #   SetTargetProperty(output, cmake_target_name,
     #                       'C_COMPILE_FLAGS', cflags_c, ' ')
 
     # cflags_cc = config.get('cflags_cc')
     # if cflags_cc is not None:
     #   SetTargetProperty(output, cmake_target_name,
     #                       'CXX_COMPILE_FLAGS', cflags_cc, ' ')
 
     # Instead we must...
     cflags = config.get('cflags', [])
     cflags_c = config.get('cflags_c', [])
     cflags_cxx = config.get('cflags_cc', [])
+    if xcode_settings:
+      cflags = xcode_settings.GetCflags(config_to_use)
+      cflags_c = xcode_settings.GetCflagsC(config_to_use)
+      cflags_cxx = xcode_settings.GetCflagsCC(config_to_use)
+      #cflags_objc = xcode_settings.GetCflagsObjC(config_to_use)
+      #cflags_objcc = xcode_settings.GetCflagsObjCC(config_to_use)
+
     if (not cflags_c or not c_sources) and (not cflags_cxx or not cxx_sources):
       SetTargetProperty(output, cmake_target_name, 'COMPILE_FLAGS', cflags, ' ')
 
     elif c_sources and not (s_sources or cxx_sources):
       flags = []
       flags.extend(cflags)
       flags.extend(cflags_c)
       SetTargetProperty(output, cmake_target_name, 'COMPILE_FLAGS', flags, ' ')
 
     elif cxx_sources and not (s_sources or c_sources):
@@ skipping 18 matching lines @@
         flags = []
         flags.extend(cflags)
         flags.extend(cflags_cxx)
         SetFilesProperty(output, cxx_sources_name, 'COMPILE_FLAGS', flags, ' ')
 
     # Linker flags
     ldflags = config.get('ldflags')
     if ldflags is not None:
       SetTargetProperty(output, cmake_target_name, 'LINK_FLAGS', ldflags, ' ')
 
+    # XCode settings
+    xcode_settings = config.get('xcode_settings', {})
+    for xcode_setting, xcode_value in xcode_settings.viewitems():
+      SetTargetProperty(output, cmake_target_name,
+                        "XCODE_ATTRIBUTE_%s" % xcode_setting, xcode_value,
+                        '' if isinstance(xcode_value, str) else ' ')
+
   # Note on Dependencies and Libraries:
   # CMake wants to handle link order, resolving the link line up front.
   # Gyp does not retain or enforce specifying enough information to do so.
   # So do as other gyp generators and use --start-group and --end-group.
   # Give CMake as little information as possible so that it doesn't mess it up.
 
   # Dependencies
   rawDeps = spec.get('dependencies', [])
 
   static_deps = []
@@ skipping 44 matching lines @@
     output.write(')\n')
 
   # Libraries
   if linkable:
     external_libs = [lib for lib in spec.get('libraries', []) if len(lib) > 0]
     if external_libs or static_deps or shared_deps:
       output.write('target_link_libraries(')
       output.write(cmake_target_name)
       output.write('\n')
       if static_deps:
-        write_group = circular_libs and len(static_deps) > 1
+        write_group = circular_libs and len(static_deps) > 1 and flavor != 'mac'
         if write_group:
           output.write('-Wl,--start-group\n')
         for dep in gyp.common.uniquer(static_deps):
           output.write('  ')
           output.write(dep)
           output.write('\n')
         if write_group:
           output.write('-Wl,--end-group\n')
       if shared_deps:
         for dep in gyp.common.uniquer(shared_deps):
           output.write('  ')
           output.write(dep)
           output.write('\n')
       if external_libs:
         for lib in gyp.common.uniquer(external_libs):
-          output.write('  ')
-          output.write(lib)
-          output.write('\n')
+          output.write('  "')
+          output.write(RemovePrefix(lib, "$(SDKROOT)"))
+          output.write('"\n')
 
       output.write(')\n')
 
   UnsetVariable(output, 'TOOLSET')
   UnsetVariable(output, 'TARGET')
 
 
 def GenerateOutputForConfig(target_list, target_dicts, data,
                             params, config_to_use):
   options = params['options']
   generator_flags = params['generator_flags']
+  flavor = gyp.common.GetFlavor(params)
 
   # generator_dir: relative path from pwd to where make puts build files.
   # Makes migrating from make to cmake easier, cmake doesn't put anything here.
   # Each Gyp configuration creates a different CMakeLists.txt file
   # to avoid incompatibilities between Gyp and CMake configurations.
   generator_dir = os.path.relpath(options.generator_output or '.')
 
   # output_dir: relative path from generator_dir to the build directory.
   output_dir = generator_flags.get('output_dir', 'out')
 
@@ skipping 62 matching lines @@
   # CMake by default names the object resulting from foo.c to be foo.c.o.
   # Gyp traditionally names the object resulting from foo.c foo.o.
   # This should be irrelevant, but some targets extract .o files from .a
   # and depend on the name of the extracted .o files.
   output.write('set(CMAKE_C_OUTPUT_EXTENSION_REPLACE 1)\n')
   output.write('set(CMAKE_CXX_OUTPUT_EXTENSION_REPLACE 1)\n')
   output.write('\n')
 
   # Force ninja to use rsp files. Otherwise link and ar lines can get too long,
   # resulting in 'Argument list too long' errors.
-  output.write('set(CMAKE_NINJA_FORCE_RESPONSE_FILE 1)\n')
+  # However, rsp files don't work correctly on Mac.
+  if flavor != 'mac':
+    output.write('set(CMAKE_NINJA_FORCE_RESPONSE_FILE 1)\n')
   output.write('\n')
 
   namer = CMakeNamer(target_list)
 
   # The list of targets upon which the 'all' target should depend.
   # CMake has it's own implicit 'all' target, one is not created explicitly.
   all_qualified_targets = set()
   for build_file in params['build_files']:
     for qualified_target in gyp.common.AllTargets(target_list,
                                                   target_dicts,
                                                   os.path.normpath(build_file)):
       all_qualified_targets.add(qualified_target)
 
   for qualified_target in target_list:
+    if flavor == 'mac':
+      gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
+      spec = target_dicts[qualified_target]
+      gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[gyp_file], spec)
+
     WriteTarget(namer, qualified_target, target_dicts, build_dir, config_to_use,
-                options, generator_flags, all_qualified_targets, output)
+                options, generator_flags, all_qualified_targets, flavor, output)
 
   output.close()
 
 
 def PerformBuild(data, configurations, params):
   options = params['options']
   generator_flags = params['generator_flags']
 
   # generator_dir: relative path from pwd to where make puts build files.
   # Makes migrating from make to cmake easier, cmake doesn't put anything here.
@@ skipping 41 matching lines @@
           arglists.append((target_list, target_dicts, data,
                            params, config_name))
           pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data,
                                 params, config_name)