This CL adds support for extension in GYP.

pylib/gyp/generator/ninja.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.
 
 import collections
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
 import re
 import signal
 import subprocess
 import sys
 import gyp
 import gyp.common
 import gyp.msvs_emulation
 import gyp.MSVSUtil as MSVSUtil
 import gyp.xcode_emulation
 from cStringIO import StringIO
 
 from gyp.common import GetEnvironFallback
 import gyp.ninja_syntax as ninja_syntax
 
 generator_default_variables = {
   'EXECUTABLE_PREFIX': '',
   'EXECUTABLE_SUFFIX': '',
+  'EXTENSION_PREFIX': '',
+  'EXTENSION_SUFFIX': '',
   'STATIC_LIB_PREFIX': 'lib',
   'STATIC_LIB_SUFFIX': '.a',
   'SHARED_LIB_PREFIX': 'lib',
 
   # Gyp expects the following variables to be expandable by the build
   # system to the appropriate locations.  Ninja prefers paths to be
   # known at gyp time.  To resolve this, introduce special
   # variables starting with $! and $| (which begin with a $ so gyp knows it
   # should be treated specially, but is otherwise an invalid
   # ninja/shell variable) that are passed to gyp here but expanded
@@ skipping 952 matching lines @@
       if not self.is_mac_bundle:
         self.AppendPostbuildVariable(extra_bindings, spec, output, output)
       self.ninja.build(output, 'lipo', inputs, variables=extra_bindings)
       return output
 
   def WriteLinkForArch(self, ninja_file, spec, config_name, config,
                        link_deps, arch=None):
     """Write out a link step. Fills out target.binary. """
     command = {
       'executable':      'link',
+      'extension':       'link',
       'loadable_module': 'solink_module',
       'shared_library':  'solink',
     }[spec['type']]
     command_suffix = ''
 
     implicit_deps = set()
     solibs = set()
 
     if 'dependencies' in spec:
       # Two kinds of dependencies:
@@ skipping 29 matching lines @@
           implicit_deps.add(final_output)
 
     extra_bindings = []
     if self.uses_cpp and self.flavor != 'win':
       extra_bindings.append(('ld', '$ldxx'))
 
     output = self.ComputeOutput(spec, arch)
     if arch is None and not self.is_mac_bundle:
       self.AppendPostbuildVariable(extra_bindings, spec, output, output)
 
-    is_executable = spec['type'] == 'executable'
+    is_executable = (spec['type'] == 'executable' or
+        spec['type'] == 'extension')

[pkl (ping after 24h if needed), 2014/07/09 08:07:50]

how about this:
  spec['type'] in ('executable', 'extension')

[olivierrobin, 2014/07/09 12:46:27]

Done.

     # The ldflags config key is not used on mac or win. On those platforms
     # linker flags are set via xcode_settings and msvs_settings, respectively.
     env_ldflags = os.environ.get('LDFLAGS', '').split()
     if self.flavor == 'mac':
       ldflags = self.xcode_settings.GetLdflags(config_name,
           self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
           self.GypPathToNinja, arch)
       ldflags = env_ldflags + ldflags
     elif self.flavor == 'win':
       manifest_base_name = self.GypPathToUniqueOutput(
@@ skipping 273 matching lines @@
     default_variables = copy.copy(generator_default_variables)
     CalculateVariables(default_variables, {'flavor': self.flavor})
 
     # Compute filename prefix: the product prefix, or a default for
     # the product type.
     DEFAULT_PREFIX = {
       'loadable_module': default_variables['SHARED_LIB_PREFIX'],
       'shared_library': default_variables['SHARED_LIB_PREFIX'],
       'static_library': default_variables['STATIC_LIB_PREFIX'],
       'executable': default_variables['EXECUTABLE_PREFIX'],
+      'extension': default_variables['EXTENSION_PREFIX'],
       }
     prefix = spec.get('product_prefix', DEFAULT_PREFIX.get(type, ''))
 
     # Compute filename extension: the product extension, or a default
     # for the product type.
     DEFAULT_EXTENSION = {
         'loadable_module': default_variables['SHARED_LIB_SUFFIX'],
         'shared_library': default_variables['SHARED_LIB_SUFFIX'],
         'static_library': default_variables['STATIC_LIB_SUFFIX'],
         'executable': default_variables['EXECUTABLE_SUFFIX'],
+        'extension': default_variables['EXTENSION_SUFFIX'],
       }
     extension = spec.get('product_extension')
     if extension:
       extension = '.' + extension
     else:
       extension = DEFAULT_EXTENSION.get(type, '')
 
     if 'product_name' in spec:
       # If we were given an explicit name, use that.
       target = spec['product_name']
     else:
       # Otherwise, derive a name from the target name.
       target = spec['target_name']
       if prefix == 'lib':
         # Snip out an extra 'lib' from libs if appropriate.
         target = StripPrefix(target, 'lib')
 
     if type in ('static_library', 'loadable_module', 'shared_library',
-                        'executable'):
+                        'executable', 'extension'):
       return '%s%s%s' % (prefix, target, extension)
     elif type == 'none':
       return '%s.stamp' % target
     else:
       raise Exception('Unhandled output type %s' % type)
 
   def ComputeOutput(self, spec, arch=None):
     """Compute the path for the final output of the spec."""
     type = spec['type']
 
     if self.flavor == 'win':
       override = self.msvs_settings.GetOutputName(self.config_name,
                                                   self.ExpandSpecial)
       if override:
         return override
 
     if arch is None and self.flavor == 'mac' and type in (
-        'static_library', 'executable', 'shared_library', 'loadable_module'):
+        'static_library',
+        'executable',
+        'extension',
+        'shared_library',
+        'loadable_module'):
       filename = self.xcode_settings.GetExecutablePath()
     else:
       filename = self.ComputeOutputFileName(spec, type)
 
     if arch is None and 'product_dir' in spec:
       path = os.path.join(spec['product_dir'], filename)
       return self.ExpandSpecial(path)
 
     # Some products go into the output root, libraries go into shared library
     # dir, and everything else goes into the normal place.
-    type_in_output_root = ['executable', 'loadable_module']
+    type_in_output_root = ['executable', 'extension', 'loadable_module']
     if self.flavor == 'mac' and self.toolset == 'target':
       type_in_output_root += ['shared_library', 'static_library']
     elif self.flavor == 'win' and self.toolset == 'target':
       type_in_output_root += ['shared_library']
 
     if arch is not None:
       # Make sure partial executables don't end up in a bundle or the regular
       # output directory.
       archdir = 'arch'
       if self.toolset != 'target':
@@ skipping 809 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)