Add "standalone_static_library" flag

pylib/gyp/generator/make.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.
 
 # Notes:
 #
 # This is all roughly based on the Makefile system used by the Linux
 # kernel, but is a non-recursive make -- we put the entire dependency
 # graph in front of make and let it figure it out.
 #
@@ skipping 700 matching lines @@
     extra_mac_bundle_resources = []
     mac_bundle_deps = []
 
     if self.is_mac_bundle:
       self.output = self.ComputeMacBundleOutput(spec)
       self.output_binary = self.ComputeMacBundleBinaryOutput(spec)
     else:
       self.output = self.output_binary = self.ComputeOutput(spec)
 
     self._INSTALLABLE_TARGETS = ('executable', 'loadable_module',
-                                 'shared_library')
+                                 'shared_library', 'standalone_static_library')
     if self.type in self._INSTALLABLE_TARGETS:
       self.alias = os.path.basename(self.output)
       install_path = self._InstallableTargetInstallPath()
     else:
       self.alias = self.output
       install_path = self.output
 
     self.WriteLn("TOOLSET := " + self.toolset)
     self.WriteLn("TARGET := " + self.target)
 
@@ skipping 46 matching lines @@
         if self.is_mac_bundle:
           mac_bundle_deps.append(self.output_binary)
 
     self.WriteTarget(spec, configs, deps, extra_link_deps + link_deps,
                      mac_bundle_deps, extra_outputs, part_of_all)
 
     # Update global list of target outputs, used in dependency tracking.
     target_outputs[qualified_target] = install_path
 
     # Update global list of link dependencies.
-    if self.type in ('static_library', 'shared_library'):
+    if self.type in ('static_library', 'standalone_static_library',
+                     'shared_library'):
       target_link_deps[qualified_target] = self.output_binary
 
     # Currently any versions have the same effect, but in future the behavior
     # could be different.
     if self.generator_flags.get('android_ndk_version', None):
       self.WriteAndroidNdkModuleRule(self.target, all_sources, link_deps)
 
     self.fp.close()
 
 
@@ skipping 481 matching lines @@
 
   def ComputeOutputBasename(self, spec):
     """Return the 'output basename' of a gyp spec.
 
     E.g., the loadable module 'foobar' in directory 'baz' will produce
       'libfoobar.so'
     """
     assert not self.is_mac_bundle
 
     if self.flavor == 'mac' and self.type in (
-        'static_library', 'executable', 'shared_library', 'loadable_module'):
+        'static_library', 'executable', 'shared_library', 'loadable_module',
+        'standalone_static_library'):
       return self.xcode_settings.GetExecutablePath()
 
     target = spec['target_name']
     target_prefix = ''
     target_ext = ''
-    if self.type == 'static_library':
+    if self.type in ('static_library', 'standalone_static_library'):
       if target[:3] == 'lib':
         target = target[3:]
       target_prefix = 'lib'
       target_ext = '.a'
     elif self.type in ('loadable_module', 'shared_library'):
       if target[:3] == 'lib':
         target = target[3:]
       target_prefix = 'lib'
       target_ext = '.so'
     elif self.type == 'none':
       target = '%s.stamp' % target
     elif self.type != 'executable':
       print ("ERROR: What output file should be generated?",
              "type", self.type, "target", target)
 
     target_prefix = spec.get('product_prefix', target_prefix)
     target = spec.get('product_name', target)
     product_ext = spec.get('product_extension')
     if product_ext:
       target_ext = '.' + product_ext
 
     return target_prefix + target + target_ext
 
 
   def _InstallImmediately(self):
     return self.toolset == 'target' and self.flavor == 'mac' and self.type in (
-          'static_library', 'executable', 'shared_library', 'loadable_module')
+          'static_library', 'standalone_static_library','executable',
+          'shared_library', 'loadable_module')
 
 
   def ComputeOutput(self, spec):
     """Return the 'output' (full output path) of a gyp spec.
 
     E.g., the loadable module 'foobar' in directory 'baz' will produce
       '$(obj)/baz/libfoobar.so'
     """
     assert not self.is_mac_bundle
 
@@ skipping 193 matching lines @@
       else:
         self.WriteDoCmd([self.output_binary], link_deps, 'link', part_of_all,
                         postbuilds=postbuilds)
 
     elif self.type == 'static_library':
       for link_dep in link_deps:
         assert ' ' not in link_dep, (
             "Spaces in alink input filenames not supported (%s)"  % link_dep)
       self.WriteDoCmd([self.output_binary], link_deps, 'alink', part_of_all,
                       postbuilds=postbuilds)
+    elif self.type == 'standalone_static_library':
+      self.WriteLn(
+          'cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)')
+      for link_dep in link_deps:
+        assert ' ' not in link_dep, (
+            "Spaces in alink input filenames not supported (%s)"  % link_dep)
+      self.WriteDoCmd([self.output_binary], link_deps, 'alink', part_of_all,
+                      postbuilds=postbuilds)

[borenet, 2012/10/01 21:27:48]

What should be the behavior when a standalone_static_library depends on a
static_library or another standalone_static_library?  I would think that the
symbols from the dependency should get included in the
standalone_static_library.

     elif self.type == 'shared_library':
       self.WriteLn('%s: LD_INPUTS := %s' % (
             QuoteSpaces(self.output_binary),
             ' '.join(map(QuoteSpaces, link_deps))))
       self.WriteDoCmd([self.output_binary], link_deps, 'solink', part_of_all,
                       postbuilds=postbuilds)
     elif self.type == 'loadable_module':
       for link_dep in link_deps:
         assert ' ' not in link_dep, (
             "Spaces in module input filenames not supported (%s)"  % link_dep)
@@ skipping 22 matching lines @@
                            comment = 'Add target alias to "all" target.',
                            phony = True)
 
     # Add special-case rules for our installable targets.
     # 1) They need to install to the build dir or "product" dir.
     # 2) They get shortcuts for building (e.g. "make chrome").
     # 3) They are part of "make all".
     if self.type in self._INSTALLABLE_TARGETS:
       if self.type == 'shared_library':
         file_desc = 'shared library'
+      elif self.type == 'standalone_static_library':
+        file_desc = 'static library'
       else:
         file_desc = 'executable'
       install_path = self._InstallableTargetInstallPath()
       installable_deps = [self.output]
       if (self.flavor == 'mac' and not 'product_dir' in spec and
           self.toolset == 'target'):
         # On mac, products are created in install_path immediately.
         assert install_path == self.output, '%s != %s' % (
             install_path, self.output)
 
@@ skipping 123 matching lines @@
     These variable definitions will be used by Android NDK but do nothing for
     non-Android applications.
 
     Arguments:
       module_name: Android NDK module name, which must be unique among all
           module names.
       all_sources: A list of source files (will be filtered by Compilable).
       link_deps: A list of link dependencies, which must be sorted in
           the order from dependencies to dependents.
     """
-    if self.type not in ('executable', 'shared_library', 'static_library'):
+    if self.type not in ('executable', 'shared_library', 'static_library',
+                         'standalone_static_library'):
       return
 
     self.WriteLn('# Variable definitions for Android applications')
     self.WriteLn('include $(CLEAR_VARS)')
     self.WriteLn('LOCAL_MODULE := ' + module_name)
     self.WriteLn('LOCAL_CFLAGS := $(CFLAGS_$(BUILDTYPE)) '
                  '$(DEFS_$(BUILDTYPE)) '
                  # LOCAL_CFLAGS is applied to both of C and C++.  There is
                  # no way to specify $(CFLAGS_C_$(BUILDTYPE)) only for C
                  # sources.
@@ skipping 44 matching lines @@
     self.WriteList(
         DepsToModules(link_deps,
                       generator_default_variables['STATIC_LIB_PREFIX'],
                       generator_default_variables['STATIC_LIB_SUFFIX']),
         'LOCAL_STATIC_LIBRARIES')
 
     if self.type == 'executable':
       self.WriteLn('include $(BUILD_EXECUTABLE)')
     elif self.type == 'shared_library':
       self.WriteLn('include $(BUILD_SHARED_LIBRARY)')
-    elif self.type == 'static_library':
+    elif self.type in ('static_library', 'standalone_static_library'):
       self.WriteLn('include $(BUILD_STATIC_LIBRARY)')
     self.WriteLn()
 
 
   def WriteLn(self, text=''):
     self.fp.write(text + '\n')
 
 
   def GetSortedXcodeEnv(self, additional_settings=None):
     return gyp.xcode_emulation.GetSortedXcodeEnv(
@@ skipping 329 matching lines @@
     root_makefile.write("endif\n")
   root_makefile.write('\n')
 
   if (not generator_flags.get('standalone')
       and generator_flags.get('auto_regeneration', True)):
     WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)
 
   root_makefile.write(SHARED_FOOTER)
 
   root_makefile.close()