build2/0.18.1

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 `while`-loop in the Buildfile language.

    See the "Buildfile Language" section in the manual for details.

  * Support for `continue` and `break` in loops in the Buildfile and scripting
    languages.

  * `ifn` and `ife` shortcuts in the Buildfile and scripting languages.

    These flow control shortcuts allow more succinct expression of is/is-not
    \c{null} and empty checks. They are equivalent to the following more
    verbose expressions:

    ifn ...     ~  if $null(...)
    ife ...     ~  if $empty(...)

    ifn! ...    ~  if! $null(...)
    ife! ...    ~  if! $empty(...)

    elifn ...   ~  elif $null(...)
    elife ...   ~  elif $empty(...)

    elifn! ...  ~  elif! $null(...)
    elife! ...  ~  elif! $empty(...)

  * New Buildfile and scripting language functions:

    - $front(), $back() and $json.array_front(), $json.array_back()

      Return first/last element in a sequence.

    - $sha256sum(), $xxh64sum()

      Compute SHA256 and XXH64 checksums of a string.

    - $builtin.generate_uuid()

      Generate UUID.

    - $string.{compare,filter,filter_out}()

      Compare or filter/filter out strings.

      There is now also support for the `contains`, `contains_once`,
      `starts_with`, and `ends_with` flags in $string.{find,find_index}().

    - $process.search()

      Search in PATH to determine absolute executable path.

  * New scripting languages builtins:

    - sha256sum

      Compute SHA256 checksum of a file or stdin.

    - xxh64sum

      Compute XXH64 checksum of a file or stdin.

    Also, the `ln` builtin now supports creating hard links in addition to
    symbolic.

  * New json{} builtin target type.

    It represents a JSON text file and has the .json default extension.

  * Shell script and task runner executable.

    The portable scripting language that is used for buildfile recipes
    (Buildscript) and test scripts (Testscript) has been generalized to also
    provide a general-purpose shell scripting flavor (Shellscript). Such shell
    scripts can be executed with the `bx` executable which is now provided
    alongside the build system driver (`b`). See the bx(1) man page for
    details.

  * Buildscript/Testscript/Shellscript syntax version 2.

    The version 2 is an improved syntax that should be used in new projects.
    Existing projects should also be eventually migrated to the new syntax.

    The syntax changes in version 2 compared to version 1 are:

    - Flow-control constructs (`if`, `for`, etc) are no longer terminated with
      the `end` line. Instead, the commands inside need to be enclosed into
      curly braces, which can be omitted for a single command. For example,
      syntax 1:

        if true
          echo one
          echo two
        end

        if true
          echo one
        end

      Syntax 2:

        if true
        {
          echo one
          echo two
        }

        if true
          echo one

    - Testscript groups are now enclosed into double curly braces ({{ }}).
      For example, syntax 1:

        : basics
        :
        {
          : test1
          :
          $* test1

          : test2
          :
          $* test2
        }

      Syntax 2:

        : basics
        :
        {{
          : test1
          :
          $* test1

          : test2
          :
          $* test2
        }}

    - Testscript commands in explicit test scopes are no longer separated with
      semicolons. For example, syntax 1:

      : test1
      :
      {
        $* pre;
        $* test1;
        $* post
      }

      Syntax 2:

      : test1
      :
      {
        $* pre
        $* test1
        $* post
      }

    The syntax version is selected based on the project's build2 version
    constraint in the manifest (`depends: build2 >= X.Y.Z`). Specifically, if
    the required version is equal to or great than 0.18.0, then syntax 2 is
    automatically selected. Otherwise, version 1 is used for backwards
    compatibility.

    The desired syntax can also be specified explicitly, both at the buildfile
    and script levels, with the {shellscript,buildscript,testscript}.syntax
    variables. For example:

    # root.build
    #
    testscript.syntax = 1

  * Support for JSON compilation database generation and maintenance.

    See the "Compilation Database" section in the "cc Module" chapter of
    the manual for details.

  * Support for specifying compile options on exe/lib{} targets

    It is now possible to specify compile option (*.poptions and *.coptions)
    on the exe/lib{} targets (we call them "binary-specific compile
    options"). Such options are propagated to obj/bmi{} targets that are
    synthesized for source prerequisites of the binary. Note that this
    propagation does not apply to explicit (non-synthesized) obj/bmi{}
    prerequisites. For example:

    exe{foo}: cxx{foo} obj{common}
    {
      cxx.poptions += -DFOO
    }

    exe{bar}: cxx{bar} obj{common}... More