Add support for dynamic dependencies in ad hoc Buildscript recipes

Specifically, add the new `depdb dyndep` builtin that can be used to extract
dynamic dependencies from a program run or a file. For example:

obje{hello.o}: cxx{hello}
{{
  s = $path($<[0])

  depdb dyndep $cxx.poptions $cc.poptions --what=header --default-prereq-type=h -- $cxx.path $cxx.poptions $cc.poptions $cxx.mode -M -MG $s

  diag c++ ($<[0])

  o = $path($>)
  $cxx.path $cxx.poptions $cc.poptions $cc.coptions $cxx.coptions $cxx.mode -o $o -c $s
}}

Currently only the `make` dependency format is supported.

1 files changed, 70 insertions, 9 deletions

diff --git a/libbuild2/build/script/parser.hxx b/libbuild2/build/script/parser.hxx
index b737a13..da15509 100644
--- a/libbuild2/build/script/parser.hxx
+++ b/libbuild2/build/script/parser.hxx
@@ -8,7 +8,6 @@
 #include <libbuild2/forward.hxx>
 #include <libbuild2/utility.hxx>
 
-#include <libbuild2/depdb.hxx>
 #include <libbuild2/diagnostics.hxx>
 
 #include <libbuild2/script/parser.hxx>
@@ -82,21 +81,51 @@ namespace build2
         // initialize/clean up the environment before/after the script
         // execution.
         //
+        // Note: having both root and base scopes for testing (where we pass
+        // global scope for both).
+        //
         void
         execute_body (const scope& root, const scope& base,
                       environment&, const script&, runner&,
                       bool enter = true, bool leave = true);
 
 
+        // Execute the first or the second (dyndep) half of the depdb
+        // preamble.
+        //
         // Note that it's the caller's responsibility to make sure that the
         // runner's enter() function is called before the first preamble/body
         // command execution and leave() -- after the last command.
         //
         void
-        execute_depdb_preamble (const scope& root, const scope& base,
-                                environment&, const script&, runner&,
-                                depdb&);
+        execute_depdb_preamble (action a, const scope& base, const file& t,
+                                environment& e, const script& s, runner& r,
+                                depdb& dd)
+        {
+          auto b (s.depdb_preamble.begin ());
+          exec_depdb_preamble (
+            a, base, t,
+            e, s, r,
+            b,
+            (s.depdb_dyndep
+             ? b + *s.depdb_dyndep
+             : s.depdb_preamble.end ()),
+            dd);
+        }
 
+        void
+        execute_depdb_preamble_dyndep (
+          action a, const scope& base, file& t,
+          environment& e, const script& s, runner& r,
+          depdb& dd, bool& update, bool& deferred_failure, timestamp mt)
+        {
+          exec_depdb_preamble (
+            a, base, t,
+            e, s, r,
+            s.depdb_preamble.begin () + *s.depdb_dyndep,
+            s.depdb_preamble.end (),
+            dd, &update, &deferred_failure, mt);
+        }
 
         // Parse a special builtin line into names, performing the variable
         // and pattern expansions. If omit_builtin is true, then omit the
@@ -115,12 +144,38 @@ namespace build2
         pre_exec (const scope& root, const scope& base,
                   environment&, const script*, runner*);
 
+        using lines_iterator = lines::const_iterator;
+
+        void
+        exec_lines (lines_iterator, lines_iterator,
+                    const function<exec_cmd_function>&);
+
         void
-        exec_lines (const lines&, const function<exec_cmd_function>&);
+        exec_lines (const lines& l, const function<exec_cmd_function>& c)
+        {
+          exec_lines (l.begin (), l.end (), c);
+        }
 
         names
-        exec_special (token& t, build2::script::token_type& tt,
-                      bool omit_builtin = true);
+        exec_special (token&, build2::script::token_type&, bool skip_first);
+
+        void
+        exec_depdb_preamble (action, const scope& base, const file&,
+                             environment&, const script&, runner&,
+                             lines_iterator begin, lines_iterator end,
+                             depdb&,
+                             bool* update = nullptr,
+                             bool* deferred_failure = nullptr,
+                             optional<timestamp> mt = nullopt);
+
+        void
+        exec_depdb_dyndep (token&, build2::script::token_type&,
+                           size_t line_index, const location&,
+                           action, const scope& base, file&,
+                           depdb&,
+                           bool& update,
+                           bool& deferred_failure,
+                           timestamp);
 
         // Helpers.
         //
@@ -219,8 +274,14 @@ namespace build2
         // depdb env <var-names> - Track the environment variables change as a
         //                         hash.
         //
-        optional<location> depdb_clear_;    // 'depdb clear' location if any.
-        lines              depdb_preamble_; // Note: excludes 'depdb clear'.
+        // depdb dyndep ...      - Extract dynamic dependency information.
+        //                         Can only be the last depdb builtin call
+        //                         in the preamble.
+        //
+        optional<location> depdb_clear_;    // depdb-clear location.
+        optional<pair<location, size_t>>
+                           depdb_dyndep_;   // depdb-dyndep location/position.
+        lines              depdb_preamble_; // Note: excluding depdb-clear.
 
         // If present, the first impure function called in the body of the
         // script that performs update of a file-based target.