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, 55 insertions, 0 deletions

diff --git a/libbuild2/filesystem.cxx b/libbuild2/filesystem.cxx
index fbe145c..2e3309d 100644
--- a/libbuild2/filesystem.cxx
+++ b/libbuild2/filesystem.cxx
@@ -323,4 +323,59 @@ namespace build2
       fail << "unable to set path " << p << " permissions: " << e;
     }
   }
+
+  void
+  normalize_external (path& f, const char* what)
+  {
+    // The main motivating case for this logic are C/C++ headers.
+    //
+    // Interestingly, on most paltforms and with most compilers (Clang on
+    // Linux being a notable exception) most system/compiler headers are
+    // already normalized.
+    //
+    path_abnormality a (f.abnormalities ());
+    if (a != path_abnormality::none)
+    {
+      // While we can reasonably expect this path to exit, things do go south
+      // from time to time (like compiling under wine with file wlantypes.h
+      // included as WlanTypes.h).
+      //
+      try
+      {
+        // If we have any parent components, then we have to verify the
+        // normalized path matches realized.
+        //
+        path r;
+        if ((a & path_abnormality::parent) == path_abnormality::parent)
+        {
+          r = f;
+          r.realize ();
+        }
+
+        try
+        {
+          f.normalize ();
+
+          // Note that we might still need to resolve symlinks in the
+          // normalized path.
+          //
+          if (!r.empty () && f != r && path (f).realize () != r)
+            f = move (r);
+        }
+        catch (const invalid_path&)
+        {
+          assert (!r.empty ()); // Shouldn't have failed if no `..`.
+          f = move (r);         // Fallback to realize.
+        }
+      }
+      catch (const invalid_path&)
+      {
+        fail << "invalid " << what << " path '" << f.string () << "'";
+      }
+      catch (const system_error& e)
+      {
+        fail << "invalid " << what << " path '" << f.string () << "': " << e;
+      }
+    }
+  }
 }