Add "standalone_static_library" flag

pylib/gyp/generator/ninja.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.
 
 import copy
 import hashlib
 import os.path
 import re
 import subprocess
 import sys
@@ skipping 142 matching lines @@
     # that compose a .lib (rather than the .lib itself). That list is stored
     # here.
     self.component_objs = None
     # Windows only. The import .lib is the output of a build step, but
     # because dependents only link against the lib (not both the lib and the
     # dll) we keep track of the import library here.
     self.import_lib = None
 
   def Linkable(self):
     """Return true if this is a target that can be linked against."""
-    return self.type in ('static_library', 'shared_library')
+    return self.type in ('static_library', 'shared_library',
+                         'standalone_static_library')
 
   def UsesToc(self, flavor):
     """Return true if the target should produce a restat rule based on a TOC
     file."""
     # For bundles, the .TOC should be produced for the binary, not for
     # FinalOutput(). But the naive approach would put the TOC file into the
     # bundle, so don't do this for bundles for now.
     if flavor == 'win' or self.bundle:
       return False
     return self.type in ('shared_library', 'loadable_module')
@@ skipping 253 matching lines @@
         pch = gyp.xcode_emulation.MacPrefixHeader(
             self.xcode_settings, self.GypPathToNinja,
             lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang))
       link_deps = self.WriteSources(
           config_name, config, sources, compile_depends_stamp, pch,
           case_sensitive_filesystem)
       # Some actions/rules output 'sources' that are already object files.
       link_deps += [self.GypPathToNinja(f)
           for f in sources if f.endswith(self.obj_ext)]
 
-    if self.flavor == 'win' and self.target.type == 'static_library':
+    if self.flavor == 'win' and self.target.type in ('static_library',
+        'standalone_static_library'):
       self.target.component_objs = link_deps
 
     # Write out a link step, if needed.
     output = None
     if link_deps or self.target.actions_stamp or actions_depends:
       output = self.WriteTarget(spec, config_name, config, link_deps,
                                 self.target.actions_stamp or actions_depends)
       if self.is_mac_bundle:
         mac_bundle_depends.append(output)
 
@@ skipping 499 matching lines @@
       variables = []
       postbuild = self.GetPostbuildCommand(
           spec, self.target.binary, self.target.binary)
       if postbuild:
         variables.append(('postbuilds', postbuild))
       if self.xcode_settings:
         variables.append(('libtool_flags',
                           self.xcode_settings.GetLibtoolflags(config_name)))
       self.ninja.build(self.target.binary, 'alink', link_deps,
                        order_only=compile_deps, variables=variables)
+    elif spec['type'] == 'standalone_static_library':
+      self.target.binary = self.ComputeOutput(spec)
+      variables = []
+      postbuild = self.GetPostbuildCommand(
+          spec, self.target.binary, self.target.binary)
+      if postbuild:
+        variables.append(('postbuilds', postbuild))
+      if self.xcode_settings:
+        variables.append(('libtool_flags',
+                          self.xcode_settings.GetLibtoolflags(config_name)))
+      if self.flavor != 'mac' and self.flavor != 'win':
+        self.ninja.rule(
+          'alink',
+          description='AR $out',
+          command='rm -f $out && $ar rcs $out $in')
+      self.ninja.build(self.target.binary, 'alink', link_deps,
+                       order_only=compile_deps, variables=variables)
     else:
       self.WriteLink(spec, config_name, config, link_deps)
     return self.target.binary
 
   def WriteMacBundle(self, spec, mac_bundle_depends):
     assert self.is_mac_bundle
     package_framework = spec['type'] in ('shared_library', 'loadable_module')
     output = self.ComputeMacBundleOutput()
     postbuild = self.GetPostbuildCommand(spec, output, self.target.binary,
                                          is_command_start=not package_framework)
@@ skipping 96 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'],
+      'standalone_static_library': default_variables['STATIC_LIB_PREFIX'],
       'executable': default_variables['EXECUTABLE_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'],
+        'standalone_static_library': default_variables['STATIC_LIB_SUFFIX'],
         'executable': default_variables['EXECUTABLE_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'):
+    if type in ('executable', 'loadable_module', 'shared_library',
+                'static_library', 'standalone_static_library'):
       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, type=None):
     """Compute the path for the final output of the spec."""
     assert not self.is_mac_bundle or type
 
     if not type:
       type = spec['type']
 
     if self.flavor == 'win':
       override = self.msvs_settings.GetOutputName(self.config_name,
                                                   self.ExpandSpecial)
       if override:
         return override
 
     if self.flavor == 'mac' and type in (
-        'static_library', 'executable', 'shared_library', 'loadable_module'):
+        'executable', 'loadable_module', 'shared_library', 'static_library',
+        'standalone_static_library'):
       filename = self.xcode_settings.GetExecutablePath()
     else:
       filename = self.ComputeOutputFileName(spec, type)
 
     if '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', 'loadable_module',
+                           'standalone_static_library']
     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 type in type_in_output_root:
       return filename
     elif type == 'shared_library':
       libdir = 'lib'
       if self.toolset != 'target':
@@ skipping 589 matching lines @@
 
   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)