make generator: refactor shared headers together...

pylib/gyp/generator/make.py

 #!/usr/bin/python
 
 # Copyright (c) 2009 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
@@ skipping 54 matching lines @@
 # This should go into the build tree, but it's easier to keep it here for now.
 SHARED_HEADER = ("""\
 # We borrow heavily from the kernel build setup, though we are simpler since
 # we don't have Kconfig tweaking settings on us.
 
 # The implicit make rules have it looking for RCS files, among other things.
 # We instead explicitly write all the rules we care about.
 # It's even quicker (saves ~200ms) to pass -r on the command line.
 MAKEFLAGS=-r
 
+# The source directory tree.
+srcdir := %(srcdir)s
+
+# The name of the builddir.
+builddir_name ?= %(builddir)s
+
 # The V=1 flag on command line makes us verbosely print command lines.
 ifdef V
   quiet=
 else
   quiet=quiet_
 endif
 
 # Specify BUILDTYPE=Release on the command line for a release build.
-BUILDTYPE ?= __default_configuration__
+BUILDTYPE ?= %(default_configuration)s
 
 # Directory all our build output goes into.
 # Note that this must be two directories beneath src/ for unit tests to pass,
 # as they reach into the src/ directory for data with relative paths.
 builddir ?= $(builddir_name)/$(BUILDTYPE)
 abs_builddir := $(abspath $(builddir))
 depsdir := $(builddir)/.deps
 
 # Object output directory.
 obj := $(builddir)/obj
@@ skipping 115 matching lines @@
 # - cmd_foo is the actual command to run;
 # - quiet_cmd_foo is the brief-output summary of the command.
 
 quiet_cmd_cc = CC($(TOOLSET)) $@
 cmd_cc = $(CC.$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c -o $@ $<
 
 quiet_cmd_cxx = CXX($(TOOLSET)) $@
 cmd_cxx = $(CXX.$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
 
 quiet_cmd_alink = AR($(TOOLSET)) $@
-cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) $(ARFLAGS.$(TOOLSET)) $@ $(filter %.o,$^)
+cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) $(ARFLAGS.$(TOOLSET)) $@ $(filter %%.o,$^)
 
 quiet_cmd_touch = TOUCH $@
 cmd_touch = touch $@
 
 quiet_cmd_copy = COPY $@
 # send stderr to /dev/null to ignore messages when linking directories.
 cmd_copy = ln -f $< $@ 2>/dev/null || cp -af $< $@
 
 # Due to circular dependencies between libraries :(, we wrap the
 # special "figure out circular dependencies" flags around the entire
@@ skipping 15 matching lines @@
 escape_quotes = $(subst ','\'',$(1))
 # This comment is here just to include a ' to unconfuse syntax highlighting.
 # Define an escape_vars function to escape '$' variable syntax.
 # This allows us to read/write command lines with shell variables (e.g.
 # $LD_LIBRARY_PATH), without triggering make substitution.
 escape_vars = $(subst $$,$$$$,$(1))
 # Helper that expands to a shell command to echo a string exactly as it is in
 # make. This uses printf instead of echo because printf's behaviour with respect
 # to escape sequences is more portable than echo's across different shells
 # (e.g., dash, bash).
-exact_echo = printf '%s\n' '$(call escape_quotes,$(1))'
+exact_echo = printf '%%s\n' '$(call escape_quotes,$(1))'
 """
 """
 # Helper to compare the command we're about to run against the command
 # we logged the last time we ran the command.  Produces an empty
 # string (false) when the commands match.
 # Tricky point: Make has no string-equality test function.
 # The kernel uses the following, but it seems like it would have false
 # positives, where one string reordered its arguments.
 #   arg_check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \\
 #                       $(filter-out $(cmd_$@), $(cmd_$(1))))
@@ skipping 143 matching lines @@
 }
 
 SHARED_HEADER_SUFFIX_RULES = (
     SHARED_HEADER_SUFFIX_RULES_COMMENT1 +
     ''.join(SHARED_HEADER_SUFFIX_RULES_SRCDIR.values()) +
     SHARED_HEADER_SUFFIX_RULES_COMMENT2 +
     ''.join(SHARED_HEADER_SUFFIX_RULES_OBJDIR1.values()) +
     ''.join(SHARED_HEADER_SUFFIX_RULES_OBJDIR2.values())
 )
 
-# This gets added to the very beginning of the Makefile.
-SHARED_HEADER_SRCDIR = ("""\
-# The source directory tree.
-srcdir := %s
-
-""")
-
-SHARED_HEADER_BUILDDIR_NAME = ("""\
-# The name of the builddir.
-builddir_name ?= %s
-
-""")
-
 SHARED_FOOTER = """\
 # "all" is a concatenation of the "all" targets from all the included
 # sub-makefiles. This is just here to clarify.
 all:
 
 # Add in dependency-tracking rules.  $(all_deps) is the list of every single
 # target in our tree.  First, only consider targets that already have been
 # built, as unbuilt targets will be built regardless of dependency info:
 all_deps := $(wildcard $(sort $(all_deps)))
 # Of those, only consider the ones with .d (dependency) info:
@@ skipping 846 matching lines @@
   srcdir = '.'
   makefile_name = 'Makefile' + options.suffix
   makefile_path = os.path.join(options.toplevel_dir, makefile_name)
   if options.generator_output:
     global srcdir_prefix
     makefile_path = os.path.join(options.generator_output, makefile_path)
     srcdir = gyp.common.RelativePath(srcdir, options.generator_output)
     srcdir_prefix = '$(srcdir)/'
   ensure_directory_exists(makefile_path)
   root_makefile = open(makefile_path, 'w')
-  root_makefile.write(SHARED_HEADER_SRCDIR % srcdir)
-  root_makefile.write(SHARED_HEADER_BUILDDIR_NAME % builddir_name)
-  root_makefile.write(SHARED_HEADER.replace('__default_configuration__',
-                                            default_configuration))
+  root_makefile.write(SHARED_HEADER % {
+      'srcdir': srcdir,
+      'builddir': builddir_name,
+      'default_configuration': default_configuration
+      })
   for toolset in toolsets:
     root_makefile.write('TOOLSET := %s\n' % toolset)
     root_makefile.write(ROOT_HEADER_SUFFIX_RULES)
 
   # Find the list of targets that derive from the gyp file(s) being built.
   needed_targets = set()
   for build_file in params['build_files']:
     for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
       needed_targets.add(target)
 
@@ skipping 89 matching lines @@
   # Add a check to make sure we tried to process all the .d files.
   all_deps += """
   ifneq ($(word %(last)d,$(d_files)),)
     $(error Found unprocessed dependency files (gyp didn't generate enough rules!))
   endif
 """ % { 'last': ((num_outputs / 1000) + 1) * 1000 + 1 }
 
   root_makefile.write(SHARED_FOOTER % { 'generate_all_deps': all_deps })
 
   root_makefile.close()