Add support for builds manifest value

6 files changed, 737 insertions, 3 deletions

diff --git a/libbpkg/manifest.cxx b/libbpkg/manifest.cxx
index e93f0cb..73d2311 100644
--- a/libbpkg/manifest.cxx
+++ b/libbpkg/manifest.cxx
@@ -17,8 +17,8 @@
 #include <libbutl/url.mxx>
 #include <libbutl/path.mxx>
 #include <libbutl/base64.mxx>
-#include <libbutl/utility.mxx>             // casecmp(), lcase(), alpha(),
-                                           // digit(), xdigit()
+#include <libbutl/utility.mxx>             // casecmp(), lcase(), alnum(),
+                                           // digit(), xdigit(), next_word()
 #include <libbutl/manifest-parser.mxx>
 #include <libbutl/manifest-serializer.mxx>
 #include <libbutl/standard-version.mxx>
@@ -390,7 +390,7 @@ namespace bpkg
         }
       default:
         {
-          if (!digit (c) && !alpha (c))
+          if (!alnum (c))
             bad_arg ("alpha-numeric characters expected in a component");
         }
       }
@@ -889,6 +889,340 @@ namespace bpkg
     return o;
   }
 
+  // build_class_term
+  //
+  build_class_term::
+  ~build_class_term ()
+  {
+    if (simple)
+      name.~string ();
+    else
+      expr.~vector<build_class_term> ();
+  }
+
+  build_class_term::
+  build_class_term (build_class_term&& t)
+      : operation (t.operation),
+        inverted (t.inverted),
+        simple (t.simple)
+  {
+    if (simple)
+      new (&name) string (move (t.name));
+    else
+      new (&expr) vector<build_class_term> (move (t.expr));
+  }
+
+  build_class_term::
+  build_class_term (const build_class_term& t)
+      : operation (t.operation),
+        inverted (t.inverted),
+        simple (t.simple)
+  {
+    if (simple)
+      new (&name) string (t.name);
+    else
+      new (&expr) vector<build_class_term> (t.expr);
+  }
+
+  build_class_term& build_class_term::
+  operator= (build_class_term&& t)
+  {
+    if (this != &t)
+    {
+      this->~build_class_term ();
+
+      // Assume noexcept move-construction.
+      //
+      new (this) build_class_term (move (t));
+    }
+    return *this;
+  }
+
+  build_class_term& build_class_term::
+  operator= (const build_class_term& t)
+  {
+    if (this != &t)
+      *this = build_class_term (t); // Reduce to move-assignment.
+    return *this;
+  }
+
+  bool build_class_term::
+  validate_name (const string& s)
+  {
+    if (s.empty ())
+      throw invalid_argument ("empty class name");
+
+    size_t i (0);
+    char c (s[i++]);
+
+    if (!(alnum (c) || c == '_'))
+      throw invalid_argument (
+        "class name '" + s + "' starts with '" + c + "'");
+
+    for (; i != s.size (); ++i)
+    {
+      if (!(alnum (c = s[i]) || c == '+' || c == '-' || c == '_' || c == '.'))
+        throw invalid_argument (
+          "class name '" + s + "' contains '" + c + "'");
+    }
+
+    return s[0] == '_';
+  }
+
+  // build_class_expr
+  //
+  // Parse the string representation of a space-separated, potentially empty
+  // build class expression.
+  //
+  // Calls itself recursively when a nested expression is encountered. In this
+  // case the second parameter points to the position at which the nested
+  // expression starts (right after the opening parenthesis). Updates the
+  // position to refer the nested expression end (right after the closing
+  // parenthesis).
+  //
+  static vector<build_class_term>
+  parse_build_class_expr (const string& s, size_t* p = nullptr)
+  {
+    vector<build_class_term> r;
+
+    bool root (p == nullptr);
+    size_t e (0);
+
+    if (root)
+      p = &e;
+
+    size_t n;
+    for (size_t b (0); (n = next_word (s, b, *p)); )
+    {
+      string t (s, b, n);
+
+      // Check for the nested expression end.
+      //
+      if (t == ")")
+      {
+        if (root)
+          throw invalid_argument ("class term expected instead of ')'");
+
+        break;
+      }
+
+      // Parse the term.
+      //
+      char op (t[0]); // Can be '\0'.
+
+      if (op != '+')
+      {
+        if (op != '-' && op != '&')
+          throw invalid_argument (
+            "class term '" + t + "' must start with '+', '-', or '&'");
+
+        // Only the root expression may start with a term having the '-' or
+        // '&' operation.
+        //
+        if (r.empty () && !root)
+          throw invalid_argument (
+            "class term '" + t + "' must start with '+'");
+      }
+
+      bool inv (t[1] == '!');     // Can be '\0'.
+      string nm (t, inv ? 2 : 1);
+
+      // Append the compound term.
+      //
+      if (nm == "(")
+        r.emplace_back (parse_build_class_expr (s, p), op, inv);
+
+      // Append the simple term.
+      //
+      else
+      {
+        build_class_term::validate_name (nm);
+        r.emplace_back (move (nm), op, inv);
+      }
+    }
+
+    // Verify that the nested expression is terminated with the closing
+    // parenthesis and is not empty.
+    //
+    if (!root)
+    {
+      // The zero-length of the last term means that we escaped the loop due
+      // to the eos.
+      //
+      if (n == 0)
+        throw invalid_argument (
+          "nested class expression must be closed with ')'");
+
+      if (r.empty ())
+        throw invalid_argument ("empty nested class expression");
+    }
+
+    return r;
+  }
+
+  build_class_expr::
+  build_class_expr (const std::string& s, std::string c)
+      : comment (move (c))
+  {
+    using std::string;
+
+    size_t eb (0); // Start of expression.
+
+    // Parse the underlying classes until the expression term, ':', or eos is
+    // encountered.
+    //
+    for (size_t b (0); next_word (s, b, eb); )
+    {
+      string nm (s, b, eb - b);
+
+      if (nm[0] == '+' || nm[0] == '-' || nm[0] == '&')
+      {
+        // Expression must always be separated with ':' from the underlying
+        // classes.
+        //
+        if (!underlying_classes.empty ())
+          throw invalid_argument ("class expression separator ':' expected");
+
+        eb = b; // Reposition to the term beginning.
+        break;
+      }
+      else if (nm == ":")
+      {
+        // The ':' separator must follow the underlying class set.
+        //
+        if (underlying_classes.empty ())
+          throw invalid_argument ("underlying class set expected");
+
+        break;
+      }
+
+      build_class_term::validate_name (nm);
+      underlying_classes.emplace_back (move (nm));
+    }
+
+    expr = parse_build_class_expr (eb == 0 ? s : string (s, eb));
+
+    // At least one of the expression or underlying class set should be
+    // present in the representation.
+    //
+    if (expr.empty () && underlying_classes.empty ())
+      throw invalid_argument ("empty class expression");
+  }
+
+  build_class_expr::
+  build_class_expr (const strings& cs, char op, std::string c)
+      : comment (move (c))
+  {
+    vector<build_class_term> r;
+
+    for (const std::string& c: cs)
+      r.emplace_back (c, op == '-' ? '-' : '+', false /* inverse */);
+
+    if (op == '&' && !r.empty ())
+    {
+      build_class_term t (move (r), '&', false /* inverse */);
+      r = vector<build_class_term> ({move (t)});
+    }
+
+    expr = move (r);
+  }
+
+  // Return string representation of the build class expression.
+  //
+  static string
+  to_string (const vector<build_class_term>& expr)
+  {
+    string r;
+    for (const build_class_term& t: expr)
+    {
+      if (!r.empty ())
+        r += ' ';
+
+      r += t.operation;
+
+      if (t.inverted)
+        r += '!';
+
+      r += t.simple ? t.name : "( " + to_string (t.expr) + " )";
+    }
+
+    return r;
+  }
+
+  string build_class_expr::
+  string () const
+  {
+    using std::string;
+
+    string r;
+    for (const string& c: underlying_classes)
+    {
+      if (!r.empty ())
+        r += ' ';
+
+      r += c;
+    }
+
+    if (!expr.empty ())
+    {
+      if (!r.empty ())
+        r += " : " + to_string (expr);
+      else
+        r = to_string (expr);
+    }
+
+    return r;
+  }
+
+  // Match build configuration classes against an expression, updating the
+  // result.
+  //
+  static void
+  match_classes (const strings& cs,
+                 const vector<build_class_term>& expr,
+                 bool& r)
+  {
+    for (const build_class_term& t: expr)
+    {
+      // Note that the '+' operation may only invert false and the '-' and '&'
+      // operations may only invert true (see below). So, let's optimize it a
+      // bit.
+      //
+      if ((t.operation == '+') == r)
+        continue;
+
+      bool m;
+
+      // We don't expect the class list to be long, so the linear search should
+      // be fine.
+      //
+      if (t.simple)
+        m = find (cs.begin (), cs.end (), t.name) != cs.end ();
+      else
+      {
+        m = false;
+        match_classes (cs, t.expr, m);
+      }
+
+      if (t.inverted)
+        m = !m;
+
+      switch (t.operation)
+      {
+      case '+': if (m) r = true;  break;
+      case '-': if (m) r = false; break;
+      case '&': r &= m;           break;
+      default:  assert (false);
+      }
+    }
+  }
+
+  void build_class_expr::
+  match (const strings& cs, bool& r) const
+  {
+    match_classes (cs, expr, r);
+  }
+
   // pkg_package_manifest
   //
   static void
@@ -1229,6 +1563,26 @@ namespace bpkg
 
         m.requirements.push_back (move (ra));
       }
+      else if (n == "builds")
+      {
+        try
+        {
+          auto vc (parser::split_comment (v));
+          build_class_expr expr (vc.first, move (vc.second));
+
+          // Underlying build configuration class set may appear only in the
+          // first builds value.
+          //
+          if (!expr.underlying_classes.empty () && !m.builds.empty ())
+            throw invalid_argument ("unexpected underlying class set");
+
+          m.builds.emplace_back (move (expr));
+        }
+        catch (const invalid_argument& e)
+        {
+          bad_value (string ("invalid package builds: ") + e.what ());
+        }
+      }
       else if (n == "build-include")
       {
         add_build_constraint (false, v);
@@ -1541,6 +1895,9 @@ namespace bpkg
                  : (r.buildtime ? "* " : "")) +
                 serializer::merge_comment (concatenate (r, " | "), r.comment));
 
+      for (const build_class_expr& e: m.builds)
+        s.next ("builds", serializer::merge_comment (e.string (), e.comment));
+
       for (const auto& c: m.build_constraints)
         s.next (c.exclusion ? "build-exclude" : "build-include",
                 serializer::merge_comment (!c.target
diff --git a/libbpkg/manifest.hxx b/libbpkg/manifest.hxx
index 20c9caf..55e9d15 100644
--- a/libbpkg/manifest.hxx
+++ b/libbpkg/manifest.hxx
@@ -430,6 +430,127 @@ namespace bpkg
     return x |= y;
   }
 
+  // Build configuration class term.
+  //
+  class LIBBPKG_EXPORT build_class_term
+  {
+  public:
+    char operation; // '+', '-' or '&'
+    bool inverted;  // Operation is followed by '!'.
+    bool simple;    // Name if true, expr otherwise.
+    union
+    {
+      std::string                   name; // Class name.
+      std::vector<build_class_term> expr; // Parenthesized expression.
+    };
+
+    // Create the simple term object (class name).
+    //
+    build_class_term (std::string n, char o, bool i)
+        : operation (o), inverted (i), simple (true), name (std::move (n)) {}
+
+    // Create the compound term object (parenthesized expression).
+    //
+    build_class_term (std::vector<build_class_term> e, char o, bool i)
+        : operation (o), inverted (i), simple (false), expr (std::move (e)) {}
+
+    // Required by VC for some reason.
+    //
+    build_class_term ()
+        : operation ('\0'), inverted (false), simple (true), name () {}
+
+    build_class_term (build_class_term&&);
+    build_class_term (const build_class_term&);
+    build_class_term& operator= (build_class_term&&);
+    build_class_term& operator= (const build_class_term&);
+
+    ~build_class_term ();
+
+    // Check that the specified string is a valid class name, that is
+    // non-empty, containing only alpha-numeric characters, '_', '+', '-', '.'
+    // (except as the first character for the last three). Return true if the
+    // name is reserved (starts with '_'). Throw std::invalid_argument if
+    // invalid.
+    //
+    static bool
+    validate_name (const std::string&);
+  };
+
+  // Build configuration class expression. Includes comment and optional
+  // underlying set.
+  //
+  class LIBBPKG_EXPORT build_class_expr
+  {
+  public:
+    std::string comment;
+    strings underlying_classes;
+    std::vector<build_class_term> expr;
+
+  public:
+    build_class_expr () = default;
+
+    // Parse the string representation of a space-separated build class
+    // expression, potentially prepended with a space-separated underlying
+    // build class set, in which case the expression can be empty. If both,
+    // underlying class set and expression are present, then they should be
+    // separated with the semicolon. Throw std::invalid_argument if the
+    // representation is invalid. Some expression examples:
+    //
+    // +gcc
+    // -msvc -clang
+    // default leagacy
+    // default leagacy :
+    // default leagacy : -msvc
+    // default leagacy : &gcc
+    //
+    build_class_expr (const std::string&, std::string comment);
+
+    // Create the expression object from a class list (c1, c2, ...) using the
+    // specified operation (+/-/&) according to the following rules:
+    //
+    // +  ->  +c1 +c2 ...
+    // -  ->  -c1 -c2 ...
+    // &  ->  &( +c1 +c2 ... )
+    //
+    // An empty class list results in an empty expression.
+    //
+    // Note: it is assumed that the class names are valid.
+    //
+    build_class_expr (const strings& classes,
+                      char operation,
+                      std::string comment);
+
+    // Return the string representation of the build class expression,
+    // potentially prepended with the underlying class set.
+    //
+    std::string
+    string () const;
+
+    // Match a build configuration that belongs to the specified list of
+    // classes against the expression. Either return or update the result (the
+    // latter allows to sequentially matching against a list of expressions).
+    //
+    // Note: the underlying class set doesn't affect the match in any way (it
+    // should have been used to pre-filter the set of build configurations).
+    //
+    void
+    match (const strings&, bool& result) const;
+
+    bool
+    match (const strings& cs) const
+    {
+      bool r (false);
+      match (cs, r);
+      return r;
+    }
+  };
+
+  inline std::ostream&
+  operator<< (std::ostream& os, const build_class_expr& bce)
+  {
+    return os << bce.string ();
+  }
+
   class LIBBPKG_EXPORT package_manifest
   {
   public:
@@ -458,6 +579,7 @@ namespace bpkg
     butl::optional<email_type> build_error_email;
     std::vector<dependency_alternatives> dependencies;
     std::vector<requirement_alternatives> requirements;
+    std::vector<build_class_expr> builds;
     std::vector<build_constraint> build_constraints;
 
     // The following values are only valid in the manifest list (and only for
diff --git a/tests/build-class-expr/buildfile b/tests/build-class-expr/buildfile
new file mode 100644
index 0000000..8d63d65
--- /dev/null
+++ b/tests/build-class-expr/buildfile
@@ -0,0 +1,8 @@
+# file      : tests/build-class-expr/buildfile
+# copyright : Copyright (c) 2014-2018 Code Synthesis Ltd
+# license   : MIT; see accompanying LICENSE file
+
+import libs  = libbutl%lib{butl}
+import libs += libbpkg%lib{bpkg}
+
+exe{driver}: {hxx cxx}{*} $libs testscript
diff --git a/tests/build-class-expr/driver.cxx b/tests/build-class-expr/driver.cxx
new file mode 100644
index 0000000..343c3b5
--- /dev/null
+++ b/tests/build-class-expr/driver.cxx
@@ -0,0 +1,101 @@
+// file      : tests/build-class-expr/driver.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2018 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <ios>
+#include <string>
+#include <iostream>
+
+#include <libbutl/utility.mxx>  // eof(), operator<<(ostream, exception)
+#include <libbutl/optional.mxx>
+
+#include <libbpkg/manifest.hxx>
+
+// Usages:
+//
+// argv[0] -p
+// argv[0] [<classes>]
+//
+// Parse stdin lines as build configuration class expressions and print them
+// or evaluate.
+//
+// In the first form print expressions to stdout, one per line.
+//
+// In the second form sequentially match the configuration classes passed as
+// arguments against the expressions, updating the match result. If the first
+// expression has an underlying class set specified, then transform the
+// combined expression, making the underlying class set a starting set for the
+// original expression and a restricting set, simultaneously.
+//
+// On error print the exception description to stderr and exit with the two
+// status. Otherwise, if the combined expression doesn't match then exit with
+// the one status. Otherwise, exit with zero status.
+//
+int
+main (int argc, char* argv[])
+{
+  using namespace std;
+  using namespace butl;
+  using namespace bpkg;
+
+  using butl::optional;
+
+  bool print (argc != 1 && argv[1] == string ("-p"));
+
+  assert (!print || argc == 2);
+
+  cin.exceptions (ios::badbit);
+
+  strings cs;
+
+  if (print)
+    cout.exceptions (ios::failbit | ios::badbit);
+  else
+  {
+    for (int i (1); i != argc; ++i)
+      cs.push_back (argv[i]);
+  }
+
+  try
+  {
+    string s;
+    bool r (false);
+    optional<strings> underlying_cls;
+
+    while (!eof (getline (cin, s)))
+    {
+      build_class_expr expr (s, "" /* comment */);
+
+      if (print)
+        cout << expr << endl;
+      else
+      {
+        if (!underlying_cls)
+        {
+          underlying_cls = move (expr.underlying_classes);
+
+          if (!underlying_cls->empty ())
+          {
+            build_class_expr expr (*underlying_cls, '+', "" /* comment */);
+            expr.match (cs, r);
+          }
+        }
+
+        expr.match (cs, r);
+      }
+    }
+
+    if (underlying_cls && !underlying_cls->empty ())
+    {
+      build_class_expr expr (*underlying_cls, '&', "" /* comment */);
+      expr.match (cs, r);
+    }
+
+    return print || r ? 0 : 1;
+  }
+  catch (const exception& e)
+  {
+    cerr << e << endl;
+    return 2;
+  }
+}
diff --git a/tests/build-class-expr/testscript b/tests/build-class-expr/testscript
new file mode 100644
index 0000000..cfa1400
--- /dev/null
+++ b/tests/build-class-expr/testscript
@@ -0,0 +1,125 @@
+# file      : tests/build-class-expr/testscript
+# copyright : Copyright (c) 2014-2018 Code Synthesis Ltd
+# license   : MIT; see accompanying LICENSE file
+
+: valid
+:
+{
+  test.options += -p
+
+  : roundtrip
+  :
+  $* <<EOF >>EOF
+    a
+    a b
+    a : -b
+    a : -b +c
+    +g
+    +gcc
+    +gcc-libc++
+    +!gcc
+    +gcc -windows
+    +gcc &linux
+    +gcc &linux +( +msvc +windows &!optimized )
+    +!windows &( +gcc +clang ) +( +windows &msvc )
+    -windows
+    EOF
+
+   $* <'a :' >'a' : no-expr
+}
+
+: invalid
+:
+{
+  test.options += -p
+
+  $* <''          2>"empty class expression"                          != 0 : empty1
+  $* <'+( )'      2>"empty nested class expression"                   != 0 : empty2
+  $* <':'         2>"underlying class set expected"                   != 0 : und-exprected1
+  $* <': a'       2>"underlying class set expected"                   != 0 : und-exprected2
+  $* <'~a'        2>"class name '~a' starts with '~'"                 != 0 : invalid-und
+  $* <'x : a'     2>"class term 'a' must start with '+', '-', or '&'" != 0 : no-op
+  $* <'+'         2>"empty class name"                                != 0 : no-name1
+  $* <'+!'        2>"empty class name"                                != 0 : no-name2
+  $* <'+a=b'      2>"class name 'a=b' contains '='"                   != 0 : invalid-char1
+  $* <'+-a'       2>"class name '-a' starts with '-'"                 != 0 : invalid-char2
+  $* <'+( +a'     2>"nested class expression must be closed with ')'" != 0 : not-closed
+  $* <'+a )'      2>"class term expected instead of ')'"              != 0 : expected-name1
+  $* <'+( +b ) )' 2>"class term expected instead of ')'"              != 0 : expected-name2
+  $* <'+( -a )'   2>"class term '-a' must start with '+'"             != 0 : first-subtract
+}
+
+: match
+:
+{
+  : non-empty-class-list
+  :
+  {
+    test.arguments += a b c
+
+    $* <'+a'
+    $* <'+!x'
+    $* <'+a +x'
+    $* <'+a +!x'
+    $* <'+a -x'
+    $* <'+a -!b'
+    $* <'+a -b +c'
+    $* <'+a &b'
+    $* <'+a &!y'
+
+    $* <'+a +( +b )'
+    $* <'+a +( +x )'
+    $* <'+a +!( +b )'
+    $* <'+a +!( +x )'
+    $* <'+a &( +b )'
+    $* <'+a &!( +x )'
+    $* <'+a -( +x )'
+    $* <'+a -!( +b )'
+    $* <'+( +b -c +a )'
+    $* <'+a &( +b -c +a )'
+    $* <'+a &( +b -c +( +a -b ) +c )'
+
+    $* <'a : +c'
+    $* <'a : -x'
+  }
+
+  : empty-class-list
+  :
+  {
+    $* <'+!x'
+  }
+}
+
+: mismatch
+:
+{
+  : non-empty-class-list
+  :
+  {
+    test.arguments += a b c
+
+    $* <'+!a'    == 1
+    $* <'+a -b'  == 1
+    $* <'+a -!x' == 1
+    $* <'+a &x'  == 1
+    $* <'+a &!b' == 1
+
+    $* <'+a -( +b )'                  == 1
+    $* <'+a -!( +x )'                 == 1
+    $* <'+a &( +x )'                  == 1
+    $* <'+a &!( +b )'                 == 1
+    $* <'+a -c +( +x )'               == 1
+    $* <'+a -c +!( +b )'              == 1
+    $* <'+a -( +x +b )'               == 1
+    $* <'+a &( +b -c +( +a +b ) &x )' == 1
+
+    $* <'x : +a' == 1
+    $* <'a : -c' == 1
+  }
+
+  : empty-class-list
+  :
+  {
+    $* <'+a' == 1
+  }
+}
diff --git a/tests/manifest/testscript b/tests/manifest/testscript
index 4f9a9a9..b77740f 100644
--- a/tests/manifest/testscript
+++ b/tests/manifest/testscript
@@ -127,6 +127,7 @@
       requires: ? ; libc++ standard library if using Clang on Mac OS X.
       requires: zlib; Most Linux/UNIX systems already have one; or get it at\
        www.zlib.net.
+      builds: +!windows &( +gcc +clang ) +( +windows &msvc )
       build-include: linux*
       build-include: freebsd*
       build-exclude: *; Only supports Linux and FreeBSD.
@@ -142,6 +143,8 @@
       email: libbar-users@example.org
       build-email:
       depends: libbaz (1- 2-) | libbaz [3 4-) | libbaz (5 6] | libbaz [7 8]
+      builds: default legacy; Default and legacy.
+      builds: -windows; Not on Windows.
       build-exclude: *-msvc_14*/i?86-*; Linker crash.
       location: bar/libbar-3.4A.5+6.tbz
       sha256sum: d4b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
@@ -153,6 +156,7 @@
       url: http://www.example.org/projects/libbar/
       email: libbaz-users@example.org
       build-error-email: libbaz-issues@example.org; Email for libbaz issues.
+      builds: default experimental
       location: libbaz/libbaz-+2-3.4A.5+3.tar.gz
       sha256sum: b5b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
       EOF
@@ -204,6 +208,23 @@
       fragment: ca602c2d46b0dca7a9ebc856871767b0ba6b74f3
       EOF
   }
+
+  : builds
+  :
+  {
+    : invalid
+    :
+    {
+      : empty
+      :
+      $* -pp <<EOI 2>"stdin:4:9: error: invalid package builds: class expression separator ':' expected" != 0
+        : 1
+        sha256sum: a2b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+        :
+        builds: default -gcc
+        EOI
+    }
+  }
 }
 
 : repositories