Make dependencies standalone. Doesn't actually work because of autogenerated...

pylib/gyp/generator/make.py

 #!/usr/bin/python
 
 # 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.
 #
 # The code below generates a separate .mk file for each target, but
 # all are sourced by the top-level Makefile.  This means that all
@@ skipping 76 matching lines @@
 # C++ apps need to be linked with g++.  Not sure what's appropriate.
 LD := $(CXX)
 RANLIB ?= ranlib
 
 # Flags to make gcc output dependency info.  Note that you need to be
 # careful here to use the flags that ccache and distcc can understand.
 # We write to a temporary dep file first and then rename at the end
 # so we can't end up with a broken dep file.
 depfile = $@.d
 DEPFLAGS = -MMD -MF $(depfile).tmp
+DEPFLAGS2 = -MM
 
 # We have to fixup the deps output in a few ways.
 # First, the file output should to mention the proper .o file.
 # ccache or distcc lose the path to the target, so we convert a rule of
 # the form:
 #   foobar.o: DEP1 DEP2
 # into
 #   path/to/foobar.o: DEP1 DEP2
 # Additionally, we want to make missing files not cause us to needlessly
 # rebuild.  We want to rewrite
 #   foobar.o: DEP1 DEP2 \
 #               DEP3
 # to
 #   DEP1 DEP2:
 #   DEP3:
 # so if the files are missing, they're just considered phony rules.
 # We have to do some pretty insane escaping to get those backslashes
 # and dollar signs past Python, make, the shell, and sed at the same time."""
 r"""
 define fixup_dep
 sed -i -e "s|^$(notdir $@)|$@|" $(depfile).tmp
+sed -i -e "s|^$@:|$@ $(depfile):|" $(depfile).tmp
 sed -e "s|^[^:]*: *||" -e "s| *\\\\$$||" -e 's|^ *||' \
     -e "/./s|$$|:|" $(depfile).tmp >> $(depfile).tmp
 mv $(depfile).tmp $(depfile)
 endef
+
+define fixup_dep2
+echo 1 = $(1)
+sed -i -e "s|^$(notdir $(1))|$(1)|" $@.tmp
+sed -i -e "s|^$(1):|$(1) $@:|" $@.tmp
+sed -e "s|^[^:]*: *||" -e "s| *\\\\$$||" -e 's|^ *||' \
+    -e "/./s|$$|:|" $@.tmp >> $@.tmp
+mv $@.tmp $@
+endef
 """
 """
 # Command definitions:
 # - cmd_foo is the actual command to run;
 # - quiet_cmd_foo is the brief-output summary of the command.
 
 quiet_cmd_cc = CC $@
 cmd_cc = $(CC) $(CFLAGS) $(DEPFLAGS) -c -o $@ $<
 
+quiet_cmd_cc_deps = CC_DEPS $@
+cmd_cc_deps = $(CC) $(CFLAGS) $(DEPFLAGS2) -E $< > $@.tmp
+
 quiet_cmd_cxx = CXX $@
 cmd_cxx = $(CXX) $(CXXFLAGS) $(DEPFLAGS) -c -o $@ $<
 
+quiet_cmd_cxx_deps = CXX_DEPS $@
+cmd_cxx_deps = $(CXX) $(CXXFLAGS) $(DEPFLAGS2) -E $< > $@.tmp
+
 quiet_cmd_ar = AR $@
 cmd_ar = $(AR) rc $@ $(filter %.o,$^)
 
 quiet_cmd_ranlib = RANLIB $@
 cmd_ranlib = $(RANLIB) $@
 
 quiet_cmd_touch = TOUCH $@
 cmd_touch = touch $@
 
 quiet_cmd_copy = COPY $@
@@ skipping 38 matching lines @@
         $(call do_cmd,cxx)
         @$(fixup_dep)
 
 # Try building from generated source, too.
 $(obj)/%.o: $(obj)/%.cc
         $(call do_cmd,cxx)
         @$(fixup_dep)
 $(obj)/%.o: $(obj)/%.cpp
         $(call do_cmd,cxx)
         @$(fixup_dep)
+
+# Build dependencies
+$(obj)/%.o.d: %.c
+        $(call do_cmd,cc_deps)
+        $(call fixup_dep2,$(patsubst %.d,%,$@))
+
+$(obj)/%.o.d: %.cc
+        $(call do_cmd,cxx_deps)
+        $(call fixup_dep2,$(patsubst %.d,%,$@))
+
 """)
 
 # This gets added to the very beginning of the Makefile, setting the root
 # directory as computed by gyp.
 SHARED_HEADER_ROOTDIR = ("""\
 # The root of the project.
 rootdir ?= %s
 
 """)
 
 SHARED_FOOTER = """\
 # Add in dependency-tracking rules.  $(all_targets) is all targets in
 # our tree.  First, only consider targets that already have been
 # built, as unbuilt targets will be built regardless of dependency
 # info:
-all_targets := $(wildcard $(sort $(all_targets)))
+# *** THIS IS A BAD IDEA - GENERATED DEPENDENCIES WILL NOT BE BUILT IF
+# YOU DO THIS ***
+#all_targets := $(wildcard $(sort $(all_targets)))
+
+# A target to make dependencies
+deps: $(all_deps)
+
 # Of those, only consider the ones with .d (dependency) info:
 d_files := $(wildcard $(foreach f,$(all_targets),$(f).d))
 ifneq ($(d_files),)
   include $(d_files)
 endif
 """
 
 header = """\
 # This file is generated by gyp; do not edit.
 
@@ skipping 217 matching lines @@
       self.WriteLn("# Flags passed to only C++ (and not C) files.");
       self.WriteList(config.get('cflags_cc'), 'CFLAGS_CC_%s' % configname)
       includes = config.get('include_dirs')
       if includes:
         includes = map(self.Absolutify, includes)
       self.WriteList(includes, 'INCS_%s' % configname, prefix='-I')
 
     sources = filter(Compilable, sources)
     objs = map(Objectify, map(self.Absolutify, map(Target, sources)))
     self.WriteList(objs, 'OBJS')
+    self.WriteLn('DEPS := $(foreach o,$(OBJS),$(o).d)')
+    self.WriteLn();
 
     self.WriteLn('# Add to the list of files we specially track '
                  'dependencies for.')
     self.WriteLn('all_targets += $(OBJS)')
+    self.WriteLn('all_deps += $(DEPS)');
     self.WriteLn()
 
     # Make sure our dependencies are built first.
     if deps:
       self.WriteMakeRule(['$(OBJS)'], deps,
                          comment = 'Make sure our dependencies are built '
                                    'before any of us.',
                          order_only = True)
 
     # Make sure the actions and rules run first.
     # If they generate any extra headers etc., the per-.o file dep tracking
     # will catch the proper rebuilds, so order only is still ok here.
     if extra_outputs:
       self.WriteMakeRule(['$(OBJS)'], extra_outputs,
                          comment = 'Make sure our actions/rules run '
                                    'before any of us.',
                          order_only = True)
 
     if objs:
       extra_link_deps.append('$(OBJS)')
       self.WriteLn("""\
 # CFLAGS et al overrides must be target-local.
 # See "Target-specific Variable Values" in the GNU Make manual.""")
       self.WriteLn("$(OBJS): CFLAGS := $(CFLAGS_$(BUILDTYPE)) "
                    "$(CFLAGS_C_$(BUILDTYPE)) "
                    "$(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))")
       self.WriteLn("$(OBJS): CXXFLAGS := $(CFLAGS_$(BUILDTYPE)) "
                    "$(CFLAGS_CC_$(BUILDTYPE)) "
                    "$(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))")
+      self.WriteLn("$(DEPS): CFLAGS := $(CFLAGS_$(BUILDTYPE)) "
+                   "$(CFLAGS_C_$(BUILDTYPE)) "
+                   "$(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))")
+      self.WriteLn("$(DEPS): CXXFLAGS := $(CFLAGS_$(BUILDTYPE)) "
+                   "$(CFLAGS_CC_$(BUILDTYPE)) "
+                   "$(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))")
 
     self.WriteLn()
 
 
   def ComputeOutput(self, spec):
     output = None
     target = spec['target_name']
     if self.type == 'static_library':
       target = 'lib%s.a' % target
     elif self.type in ('loadable_module', 'shared_library'):
@@ skipping 141 matching lines @@
     spec = target_dicts[qualified_target]
     configs = spec['configurations']
 
     writer = MakefileWriter()
     writer.Write(qualified_target, output_file, options.depth, spec, configs)
     root_makefile.write('include ' + output_file + "\n")
 
   root_makefile.write(SHARED_FOOTER)
 
   root_makefile.close()