build2/0.18.0-a.0.20251021110806.6fbd3e79e502

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

  * 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 example:

    set = [string_set] a b
    set += c b              # a b c
    set =+ d b              # a b c d

    Example of iteration:

    set = [string_set] a b c
    for k: $set
      ...

  * New string_map buildfile value type.

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

    New functions:

      $size(<string-map>)
      $keys(<string-map>)

    Subscript can be used to look up a value by key. The result is [null] if
    there is no value associated with the specified key. For example:

    map = [string_map] a@1 b@2 c@3

    b = ($map[b])  # 2

    if ($map[z] == [null])
      ...

    Note that append (+=) is overriding (like std::map::insert_or_assign())
    while prepend (=+) is not (like std::map::insert()). In a sense, whatever
    appears last (from left to right) is kept, which is consistent with what
    we expect to happen when specifying the same key repeatedly in a literal
    representation. For example:

    map = [string_map] a@0 b@2 a@1  # a@1 b@2
    map += b@0 c@3                  # a@1 b@0 c@3
    map =+ b@1 d@4                  # a@1 b@0 c@3 d@4

    Example of iteration:

    map = [string_map] a@1 b@2 c@3
    for p: $map
    {
      k = $first($p)
      v = $second($p)
    }

    While the subscript is mapped to key lookup only, index-based access can
    be implemented (with a bit of overhead) using the $keys() function:

    map = [string_map] a@1 b@2 c@3
    keys = $keys($m)
    for i: $integer_sequence(0, $size($keys))
    {
      k = ($keys[$i])
      v = ($map[$k])
    }

  * New JSON buildfile 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>)... More