Add experimental support for JSON value types

New types:

  json
  json_array
  json_object

New functions:

  $json.value_type(<json>)
  $json.value_size(<json>)
  $json.member_{name,value}(<json-member>)
  $json.object_names(<json-object>)
  $json.array_size(<json-array>)
  $json.array_find(<json-array>, <json>)
  $json.array_find_index(<json-array>, <json>)
  $json.load(<path>)
  $json.parse(<text>)
  $json.serialize(<json>[, <indentation>])

For example, to load a JSON value from a file:

j = $json.load($src_base/board.json)

Or to construct it in a buildfile:

j = [json] one@1 two@([json] 2 3 4) three@([json] x@1 y@-1)

This can also be done incrementally with append/prepend:

j = [json_object]
j += one@1
j += two@([json] 2 3 4)
j += three@([json] x@1 y@-1)

Instead of using this JSON-like syntax, one can also specify valid JSON
input text:

j = [json] '{"one":1, "two":[2, 3, 4], "three":{"x":1, "y":-1}'

Besides the above set of functions, other handy ways to access components
in a JSON value are iteration and subscript. For example:

for m: $j
  print $member_name($m) $member_value($m)

print ($j[three])

A subscript can be nested:

print ($j[two][1])
print ($j[three][x])

While a JSON value can be printed directly like any other value, the
representation will not be pretty-printed. As a result, for complex
JSON values, printing a serialized representation might be a more
readable option:

info $serialize($j)

1 files changed, 107 insertions, 0 deletions

diff --git a/libbuild2/variable.ixx b/libbuild2/variable.ixx
index 51c35fd..b8f80e3 100644
--- a/libbuild2/variable.ixx
+++ b/libbuild2/variable.ixx
@@ -906,6 +906,113 @@ namespace build2
       new (&v.data_) map<K, V> (move (x));
   }
 
+  // json
+  //
+  inline bool value_traits<json_value>::
+  empty (const json_value& v)
+  {
+    // Note: should be consistent with $json.size().
+    //
+    switch (v.type)
+    {
+    case json_type::null:               return true;
+    case json_type::boolean:
+    case json_type::signed_number:
+    case json_type::unsigned_number:
+    case json_type::hexadecimal_number:
+    case json_type::string:             break;
+    case json_type::array:              return v.array.empty ();
+    case json_type::object:             return v.object.empty ();
+    }
+
+    return false;
+  }
+
+  inline void value_traits<json_value>::
+  assign (value& v, json_value&& x)
+  {
+    if (v)
+      v.as<json_value> () = move (x);
+    else
+      new (&v.data_) json_value (move (x));
+  }
+
+  inline void value_traits<json_value>::
+  append (value& v, json_value&& x)
+  {
+    if (v)
+      v.as<json_value> ().append (move (x));
+    else
+      new (&v.data_) json_value (move (x));
+  }
+
+  inline void value_traits<json_value>::
+  prepend (value& v, json_value&& x)
+  {
+    if (v)
+      v.as<json_value> ().prepend (move (x));
+    else
+      new (&v.data_) json_value (move (x));
+  }
+
+  // json_array
+  //
+  inline void value_traits<json_array>::
+  assign (value& v, json_array&& x)
+  {
+    if (v)
+      v.as<json_array> () = move (x);
+    else
+      new (&v.data_) json_array (move (x));
+  }
+
+  inline void value_traits<json_array>::
+  append (value& v, json_value&& x)
+  {
+    if (!v)
+      new (&v.data_) json_array ();
+
+    v.as<json_array> ().append (move (x));
+  }
+
+  inline void value_traits<json_array>::
+  prepend (value& v, json_value&& x)
+  {
+    if (!v)
+      new (&v.data_) json_array ();
+
+    v.as<json_array> ().prepend (move (x));
+  }
+
+  // json_object
+  //
+  inline void value_traits<json_object>::
+  assign (value& v, json_object&& x)
+  {
+    if (v)
+      v.as<json_object> () = move (x);
+    else
+      new (&v.data_) json_object (move (x));
+  }
+
+  inline void value_traits<json_object>::
+  append (value& v, json_value&& x)
+  {
+    if (!v)
+      new (&v.data_) json_object ();
+
+    v.as<json_object> ().append (move (x));
+  }
+
+  inline void value_traits<json_object>::
+  prepend (value& v, json_value&& x)
+  {
+    if (!v)
+      new (&v.data_) json_object ();
+
+    v.as<json_object> ().prepend (move (x));
+  }
+
   // variable_pool
   //
   inline const variable* variable_pool::