Implement in module

Given test.in containing something along these lines:

foo = $foo$

Now we can do:

using in

file{test}: in{test.in}
file{test}: foo = FOO

The alternative variable substitution symbol can be specified with the
in.symbol variable and lax (instead of the default strict) mode with
in.substitution. For example:

file{test}: in.symbol = '@'
file{test}: in.substitution = lax

2 files changed, 12 insertions, 28 deletions

diff --git a/build2/version/init.cxx b/build2/version/init.cxx
index dbbb7d9..d2df772 100644
--- a/build2/version/init.cxx
+++ b/build2/version/init.cxx
@@ -254,6 +254,11 @@ namespace build2
       if (!first)
         fail (l) << "multiple version module initializations";
 
+      // Load in.base (in.* varibales, in{} target type).
+      //
+      if (!cast_false<bool> (rs["in.base.loaded"]))
+        load_module (rs, rs, "in.base", l);
+
       module& m (static_cast<module&> (*mod));
       const standard_version& v (m.version);
 
@@ -293,33 +298,8 @@ namespace build2
       // Enter variables.
       //
       {
-        auto& vp (var_pool.rw (rs));
-
-        // @@ Note: these should be moved to the 'in' module once we have it.
-        //
-
-        // Alternative variable substitution symbol.
-        //
-        m.in_symbol = &vp.insert<string> ("in.symbol");
-
-        // Substitution mode. Valid values are 'strict' (default) and 'lax'.
-        // In the strict mode every substitution symbol is expected to start a
-        // substitution with the double symbol (e.g., $$) serving as an
-        // escape sequence.
-        //
-        // In the lax mode a pair of substitution symbols is only treated as a
-        // substitution if what's between them looks like a build2 variable
-        // name (i.e., doesn't contain spaces, etc). Everything else,
-        // including unterminated substitution symbols is copied as is. Note
-        // also that in this mode the double symbol is not treated as an
-        // escape sequence.
-        //
-        // The lax mode is mostly useful when trying to reuse existing .in
-        // files, for example from autoconf. Note, however, that the lax mode
-        // is still stricter than the autoconf's semantics which also leaves
-        // unknown substitutions as is.
-        //
-        m.in_substitution = &vp.insert<string> ("in.substitution");
+        m.in_symbol       = var_pool.find ("in.symbol");       // in.base
+        m.in_substitution = var_pool.find ("in.substitution"); // in.base
       }
 
       // Register rules.
diff --git a/build2/version/rule.cxx b/build2/version/rule.cxx
index 91b8c75..0250a15 100644
--- a/build2/version/rule.cxx
+++ b/build2/version/rule.cxx
@@ -13,6 +13,8 @@
 #include <build2/filesystem.hxx>
 #include <build2/diagnostics.hxx>
 
+#include <build2/in/target.hxx>
+
 #include <build2/version/module.hxx>
 #include <build2/version/utility.hxx>
 
@@ -23,6 +25,8 @@ namespace build2
 {
   namespace version
   {
+    using in::in;
+
     // Return true if this prerequisite is a project's manifest file. To be
     // sure we would need to search it into target but that we can't do in
     // match().
@@ -403,7 +407,7 @@ namespace build2
       };
 
       if (verb >= 2)
-        text << "ver -o " << tp << ' ' << ip;
+        text << "ver " << ip << " >" << tp;
       else if (verb)
         text << "ver " << ip;