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

diff --git a/libbuild2/variable.hxx b/libbuild2/variable.hxx
index 9d7b001..6b0b30e 100644
--- a/libbuild2/variable.hxx
+++ b/libbuild2/variable.hxx
@@ -15,6 +15,8 @@
 #include <libbuild2/forward.hxx>
 #include <libbuild2/utility.hxx>
 
+#include <libbuild2/json.hxx>
+
 #include <libbuild2/context.hxx>
 #include <libbuild2/target-type.hxx>
 #include <libbuild2/diagnostics.hxx>
@@ -1201,6 +1203,65 @@ namespace build2
     static const map_value_type<K, V> value_type;
   };
 
+  // json
+  //
+  // Note that we do not expose json_member as a value type instead
+  // representing it as an object with one member. While we could expose
+  // member (and reverse it as a pair since there is no valid JSON
+  // representation for a standalone member), this doesn't seem to buy us much
+  // but will cause complications (for example, in supporting append/prepend).
+  // On the other hand, representing a member as an object only requires a bit
+  // of what looks like harmless looseness in a few contexts (such as the
+  // $json.member_*() functions).
+  //
+  template <>
+  struct LIBBUILD2_SYMEXPORT value_traits<json_value>
+  {
+    static_assert (sizeof (json_value) <= value::size_, "insufficient space");
+
+    static json_value convert (names&&);
+    static void assign (value&, json_value&&);
+    static void append (value&, json_value&&);
+    static void prepend (value&, json_value&&);
+    static bool empty (const json_value&); // null or empty array/object
+
+    static const json_value empty_instance; // null
+    static const char* const type_name;
+    static const build2::value_type value_type;
+  };
+
+  template <>
+  struct LIBBUILD2_SYMEXPORT value_traits<json_array>
+  {
+    static_assert (sizeof (json_array) <= value::size_, "insufficient space");
+
+    static json_array convert (names&&);
+    static void assign (value&, json_array&&);
+    static void append (value&, json_value&&); // Note: value, not array.
+    static void prepend (value&, json_value&&);
+    static bool empty (const json_array& v) {return v.array.empty ();}
+
+    static const json_array empty_instance; // empty array
+    static const char* const type_name;
+    static const build2::value_type value_type;
+  };
+
+  template <>
+  struct LIBBUILD2_SYMEXPORT value_traits<json_object>
+  {
+    static_assert (sizeof (json_object) <= value::size_, "insufficient space");
+
+    static json_object convert (names&&);
+    static void assign (value&, json_object&&);
+    static void append (value&, json_value&&); // Note: value, not object.
+    static void prepend (value&, json_value&&);
+    static bool empty (const json_object& v) {return v.object.empty ();}
+
+    static const json_object empty_instance; // empty object
+    static const char* const type_name;
+    static const build2::value_type value_type;
+  };
+
   // Canned command line to be re-lexed (used in {Build,Test}scripts).
   //
   // Note that because the executable can be specific as a target or as