build2/0.18.0-a.0.20251118135257.827b5e1d3dc3

This package contains the build2 build system.

build2 is an open source, cross-platform toolchain for building and packaging
C++ code. Its aim is a modern build system and dependency manager for the C++
language that provide a consistent, out of the box interface across multiple
platforms and compilers. For more information see:

https://build2.org/

See the NEWS file for the user-visible changes from the previous release.

See the LICENSE file for the distribution conditions.

See the INSTALL file... More

Version 0.18.0

  * Support for JSON5 and JSON5E.

    The existing JSON support has been extended to additionally cover JSON5[1]
    and JSON5E[2]. Specifically, the $json.parse() and $json.load() functions
    can now be instructed with flags to parse in the JSON5 or JSON5E mode
    (JSON is the default). For example:

    j = $json.load($src_root/test.json5, json5)
    j = $json.parse('{line: 10, column: 20}', json5)
    j = $json.parse('line: 10, column: 20', json5e)

    Additionally, when constructing a JSON value in buildfiles, the input
    text is parsed as JSON5E, not as JSON. For example, before we had to
    write:

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

    Now we can rewrite it as:

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

    Or in the multi-line form (notice the trailing comma which is allowed in
    JSON5):

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

    While JSON5 has a number of extensions compared to JSON (and JSON5E
    adds a few more), the most useful in buildfiles will likely be:

    - Ability to use unquoted object member names.
    - Ability to use hexadecimal numbers.
    - Ability to use single-quoted strings in addition to double-quoted.

    The last one (single-quoted string) can be especially handy if you need to
    perform expansions in the input text and thus need to use double outer
    quotes. For example:

    n = 123
    s = abc
    j = [json] "{number:$n, string:'$s'}"

    Note that the implied top-level object feature of JSON5E is not supported
    in the construction syntax but is supported by $json.parser() and
    $json.load() when parsing in the JSON5E mode.

    [1] https://json5.org
    [2] https://github.com/boris-kolpackov/libpdjson5/blob/master/JSON5E.md

  * Ability to override imported installed library path/name.

    Specifically, the config.import.<proj>.<name>.{lib,liba,libs} variables
    can be used to specify alternative location and/or name for an installed
    library. This, in particular, can be useful when trying to use a library
    installed with a prefix or suffix. For example, if the library was
    installed with the `D` suffix:

    config.import.libfoo.foo.lib=fooD

    For the config.*.lib variable, the valid values are a simple path (which
    is used as a library name base), an absolute directory (which is used as a
    library location), or both. For example:

    config.import.libfoo.foo.lib=/tmp/lib/
    config.import.libfoo.foo.lib=/tmp/lib/fooD

    For the config.*.{liba,libs} variables, the valid values are a simple name
    (which is used as a library name), or an absolute path (which is used as a
    library location and name). For example:

    config.import.libfoo.foo.libs=libfooD.so
    config.import.libfoo.foo.liba=/tmp/lib/libfooD.a

    Note that on Windows, the shared library name/path should refer to the
    import library, not the DLL.

  * Ability to mark an executable as always built for install during the
    update-for-install operation.

    Specifically, it is now possible to set the for_install=true target-
    specific variable on an executable to signal that it should be built for
    install during update-for-install even if it would otherwise be built for
    plain update, which happens if the executable is also executed during the
    build. See GH issue #472 for details and implications.

Version 0.17.0

  * C++20 modules support improvements:

    - Named modules support in Clang, including automatic building of the
      `std` and `std.compat` standard library modules from libc++ with Clang
      18 or later.

    - Named modules support in MSVC, including automatic building of the `std`
      and `std.compat` standard library modules.

      Note: if combining the standard library modules importation with the
      standard library headers inclusion, MSVC 17.10 or later is recommended.

    - Modules support can now be enabled for any std.cxx value greater or
      equal 20 (including `latest`).

    - The "C++ Modules Support" section in the manual has been updated to
      match the current state of the implementation.

  * The `latest` and `experimental` cxx.std values are now mapped to C++26
    from GCC 14 and Clang 18.

  * The 23 and 2x c.std values are now mapped to /std:clatest starting from
    MSVC 17.9. In particular, this option enables C23 typeof support.

  * /Zc:preprocessor is now added for the `experimental` cxx.std value from
    MSVC 17.9.

  * New string_set buildfile value type.

    This exposes the std::set<std::string> type to buildfiles.

    New functions:

      $size(<string-set>)

    Subscript returns true if the value is present and false otherwise (so
    it is mapped to std::set::contains()). For example:

    set = [string_set] a b c

    if ($set[b])
      ...

    Note that append (+=) and prepend (=+) have the same semantics
    (std::set::insert()). For... More