tddlog 0.1.0__tar.gz

tddlog-0.1.0/.github/CONTRIBUTING.md

@@ -0,0 +1,80 @@
+# Contributing
+
+## Checks
+
+```sh
+cargo fmt --check
+cargo test --profile quick
+cargo clippy --all-targets -- -D warnings
+RUSTDOCFLAGS="-D warnings" cargo doc --no-deps
+python3 -m unittest discover -s tests -p 'test_*.py'
+python3 .github/scripts/check_release.py
+```
+
+`cargo test` runs `tests/it/`, the differential tests against ProbLog's
+answers and exact sums, and the crate's doctests. `--profile quick`
+builds without link-time optimization and gives release's answers, as CI
+runs it; a plain `cargo test` builds without optimization and takes about
+an hour. CI also checks that Rust 1.88 builds the crate. The
+Python tests check the scripts and need numpy; `check_release.py` checks
+that the crate and the bindings declare one version.
+
+## Every answer is checkable
+
+Every probability tddlog prints must be checkable against ProbLog. A change
+that adds a construct, a rewrite or a vtree strategy lands with a test in
+`tests/it/` against ProbLog's answer (ProbLog 2.3.0, `-k sdd`, one query at
+a time) or against a sum worked out by hand. `tests/compare.py` runs a
+program through tddlog and ProbLog and diffs the probabilities, and
+`tests/fuzz_problog.py` does it for random programs in the supported
+fragment; both need ProbLog (`pip install problog`).
+
+An option that does not apply to a program, or a combination that asks for
+nothing, is an error: tddlog never ignores an option silently. The library
+is single-threaded; the caller decides on parallelism.
+
+## Examples and the guide
+
+`examples/*.pl` are small programs with known answers, and
+`tests/it/examples.rs` checks each under several strategies. The programs
+the playground offers are listed in `bindings/wasm/examples.js` with
+ProbLog's answers to 12 significant digits and P(e), which
+`bindings/wasm/tests/examples.cjs` checks the built module against. The
+guide (`bindings/wasm/guide/index.html`) quotes the programs and outputs of
+the examples it walks through; a change to one of them changes the guide
+too.
+
+## Bindings and the site
+
+- Python: `bindings/python/README.md` builds the extension with maturin;
+  `pytest bindings/python/tests` tests it.
+- C: `python bindings/c/check.py` checks the committed header against
+  cbindgen's, builds and tests the library with CMake, and builds the
+  example against the installed package; after a change to
+  `bindings/c/src/lib.rs`, `python bindings/c/check.py --write-header`
+  regenerates the header.
+- WebAssembly and the site: `bindings/wasm/README.md` builds the module and
+  the site and runs its tests, the last in a headless Chromium.
+
+Each binding is a crate of its own, which CI formats with `cargo fmt
+--check` and lints with `cargo clippy -- -D warnings`.
+
+## Documentation
+
+`docs/design.md` describes the code as it is, and changes with it. The
+README's results, `docs/benchmarks.md` (on the baselines branch) and the results page's data
+(`bindings/wasm/results/*.json`) are generated from the records of a
+release run, and are not edited by hand. Documentation and commit messages
+are plain prose: technical facts, without flourish.
+
+## Releasing
+
+A release sets one version in `Cargo.toml`, the three bindings'
+`Cargo.toml` and `CITATION.cff`, and
+`python3 .github/scripts/check_release.py --release-tag v<version>`
+checks them before the tag is made. Publishing a GitHub release of that
+tag builds and tests the wheels and uploads them to PyPI through trusted
+publishing (`wheels.yml`), and attaches the C archives and their
+checksums to the release (`c-bindings.yml`). Neither replaces what it
+published: a PyPI version can be yanked but not uploaded again, and an
+attached archive stays as it is.

tddlog-0.1.0/.github/scripts/check_release.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Check that the crate, its bindings and the release metadata declare one
+version, and that a release tag, where given, names it.
+
+    python3 .github/scripts/check_release.py [--release-tag vX.Y.Z]
+
+A tag whose version had not been bumped would build wheels labelled with
+the previous release and publish them to PyPI, where a version can be
+yanked but never replaced.
+"""
+
+import argparse
+from pathlib import Path
+import re
+
+# The crate and its three bindings, each a package of its own.
+MANIFESTS = ("Cargo.toml", "bindings/python/Cargo.toml", "bindings/c/Cargo.toml",
+             "bindings/wasm/Cargo.toml")
+
+
+def one(text, pattern, source):
+    matches = re.findall(pattern, text, re.M)
+    if len(matches) != 1:
+        raise ValueError(f"{source}: expected one version declaration, found {len(matches)}")
+    return matches[0]
+
+
+def check(root, tag=""):
+    """The version every file declares; ValueError where one differs."""
+    read = lambda relative: (root / relative).read_text(encoding="utf-8")
+    version = one(read("Cargo.toml"), r'^version = "([^"]+)"$', "Cargo.toml")
+    if tag and tag != f"v{version}":
+        raise ValueError(f"release tag {tag} differs from v{version}")
+    for relative in MANIFESTS[1:]:
+        found = one(read(relative), r'^version = "([^"]+)"$', relative)
+        if found != version:
+            raise ValueError(f"{relative}: version {found}, expected {version}")
+    locked = [one(package, r'^version = "([^"]+)"$', "Cargo.lock")
+              for package in read("Cargo.lock").split("[[package]]")[1:]
+              if re.search(r'^name = "tddlog"$', package, re.M)]
+    if locked != [version]:
+        raise ValueError(f"Cargo.lock: tddlog is {', '.join(locked) or 'missing'}, expected {version}")
+    citation = one(read("CITATION.cff"), r'^version:\s*["\']?([^"\'\s]+)["\']?\s*$', "CITATION.cff")
+    if citation != version:
+        raise ValueError(f"CITATION.cff: version {citation}, expected {version}")
+    # The README's BibTeX entry, where it names a version.
+    for found in re.findall(r'\bversion (\d+\.\d+\.\d+[^\s}]*)\}', read("README.md")):
+        if found != version:
+            raise ValueError(f"README.md: citation names version {found}, expected {version}")
+    # maturin and CMake take the version from the bindings' Cargo manifests.
+    pyproject = read("bindings/python/pyproject.toml")
+    if not re.search(r'^dynamic = \["version"\]$', pyproject, re.M) or re.search(r'^version\s*=', pyproject, re.M):
+        raise ValueError("bindings/python/pyproject.toml: the version must come from bindings/python/Cargo.toml")
+    cmake = one(read("bindings/c/CMakeLists.txt"), r'^project\(tddlog_c VERSION (\S+)', "bindings/c/CMakeLists.txt")
+    if cmake != "${TDDLOG_VERSION}":
+        raise ValueError("bindings/c/CMakeLists.txt: the version must come from bindings/c/Cargo.toml")
+    return version
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--release-tag", default="", help="the tag about to be released, such as v0.1.0")
+    args = parser.parse_args()
+    try:
+        print(f"release metadata agrees: {check(Path(__file__).resolve().parents[2], args.release_tag)}")
+    except ValueError as error:
+        parser.exit(1, f"{error}\n")

tddlog-0.1.0/.github/workflows/binaries.yml

@@ -0,0 +1,260 @@
+name: Binaries
+
+# Builds the `tddlog` command line for Linux (x86-64, ARM64), macOS (ARM64,
+# x86-64) and Windows x86-64, packs each with the license, the notices and
+# the example programs, and checks every archive on a runner other than the
+# one that built it, as a user would: the checksum, `--help`, `--version` and
+# the README's first example. When a GitHub release is published it attaches
+# the archives to it. A run by hand builds and checks them, and with a tag
+# builds that tag and attaches what its release lacks.
+
+on:
+  release:
+    types: [published]
+  pull_request:
+    paths:
+      - ".github/workflows/binaries.yml"
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Existing release tag to build the binaries for and attach them to
+        required: false
+        type: string
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  # As in the C bindings: the archive tag, and one version across the crate
+  # and the bindings, which a release tag must name. "dev" stands in for
+  # anything that is not a release tag. The dispatch input reaches the script
+  # through the environment rather than `${{ }}`, which would paste it into
+  # the shell.
+  versions:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
+      is-release: ${{ steps.tag.outputs.is-release }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ inputs.tag || '' }}
+      - name: Determine the archive tag
+        id: tag
+        env:
+          INPUT_TAG: ${{ inputs.tag }}
+        run: |
+          if [ -n "$INPUT_TAG" ]; then
+            tag="$INPUT_TAG"; is_release=true
+          elif [[ "$GITHUB_REF" == refs/tags/* ]]; then
+            tag="$GITHUB_REF_NAME"; is_release=true
+          else
+            tag=dev; is_release=false
+          fi
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "is-release=$is_release" >> "$GITHUB_OUTPUT"
+      - name: Check the release metadata
+        env:
+          TAG: ${{ steps.tag.outputs.is-release == 'true' && steps.tag.outputs.tag || '' }}
+        run: python3 .github/scripts/check_release.py --release-tag "$TAG"
+
+  build:
+    needs: versions
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # The manylinux image, as for the wheels, fixes the oldest glibc
+          # the binary needs (2.28: RHEL 8, Debian 10, Ubuntu 18.10 and
+          # later) and carries a C++20 gcc for goatd's vendored solvers.
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            container: quay.io/pypa/manylinux_2_28_x86_64
+          # jemalloc is built for the largest page it may meet, 64 KiB:
+          # built for the runner's 4 KiB pages it aborts at start on the
+          # 16 KiB and 64 KiB kernels of some ARM64 machines.
+          - os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+            container: quay.io/pypa/manylinux_2_28_aarch64
+            lg-page: "16"
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: macos-15-intel
+            target: x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+    runs-on: ${{ matrix.os }}
+    container: ${{ matrix.container }}
+    env:
+      NAME: tddlog-${{ needs.versions.outputs.tag }}-${{ matrix.target }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ inputs.tag || '' }}
+
+      - name: Install Rust in the container
+        if: matrix.container != ''
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \
+            | sh -s -- -y --profile minimal --default-toolchain stable
+          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
+
+      - uses: dtolnay/rust-toolchain@stable
+        if: matrix.container == ''
+
+      # The release profile, without the line tables it keeps for profiling,
+      # which would make the binary several times larger and not faster. On
+      # Windows the C runtime is linked in, Rust's and the vendored C++'s, so
+      # the binary runs without the Visual C++ redistributable.
+      - name: Build
+        env:
+          CARGO_PROFILE_RELEASE_DEBUG: "0"
+          LG_PAGE: ${{ matrix.lg-page }}
+        run: |
+          set -eux
+          if [ -n "$LG_PAGE" ]; then export JEMALLOC_SYS_WITH_LG_PAGE="$LG_PAGE"; fi
+          if [ "$RUNNER_OS" = Windows ]; then export RUSTFLAGS="-C target-feature=+crt-static"; fi
+          cargo build --release --locked --bin tddlog
+
+      # The newest glibc and libstdc++ symbol versions the binary asks for,
+      # which no newer system lacks.
+      - name: Check the libraries the binary needs (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          set -eux
+          objdump -p target/release/tddlog | grep NEEDED
+          glibc=$(objdump -T target/release/tddlog | grep -o 'GLIBC_[0-9.]*' | sort -uV | tail -n 1)
+          glibcxx=$(objdump -T target/release/tddlog | grep -o 'GLIBCXX_[0-9.]*' | sort -uV | tail -n 1)
+          echo "needs $glibc and $glibcxx"
+          test "$(printf '%s\n' "$glibc" GLIBC_2.28 | sort -V | tail -n 1)" = GLIBC_2.28
+
+      # The x86-64 binary, built for macOS 10.12, names it in the older load
+      # command.
+      - name: Show the oldest macOS the binary runs on
+        if: runner.os == 'macOS'
+        run: otool -l target/release/tddlog | grep -A 4 -E "LC_BUILD_VERSION|LC_VERSION_MIN_MACOSX"
+
+      # The binary beside LICENSE, NOTICE and THIRD-PARTY.md (goatd's vendored
+      # solvers are BSD-2-Clause and MIT, and their notices travel with the
+      # binary they are compiled into), and examples/, so that the README's
+      # commands run in the unpacked directory. A zip on Windows, which opens
+      # it without extra tools.
+      - name: Package the archive
+        run: |
+          set -eux
+          mkdir "$NAME"
+          cp LICENSE NOTICE THIRD-PARTY.md "$NAME"
+          cp -R examples "$NAME"
+          if [ "$RUNNER_OS" = Windows ]; then
+            cp target/release/tddlog.exe "$NAME"
+            7z a "$NAME.zip" "$NAME"
+            sha256sum "$NAME.zip" > "$NAME.zip.sha256"
+          else
+            cp target/release/tddlog "$NAME"
+            tar czf "$NAME.tar.gz" "$NAME"
+            if command -v sha256sum; then
+              sha256sum "$NAME.tar.gz" > "$NAME.tar.gz.sha256"
+            else
+              shasum -a 256 "$NAME.tar.gz" > "$NAME.tar.gz.sha256"
+            fi
+          fi
+          ls -l "$NAME".*
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: tddlog-${{ matrix.target }}
+          path: |
+            tddlog-*.tar.gz*
+            tddlog-*.zip*
+
+  # Each archive on a runner without the build's toolchain or container, the
+  # Linux ones on the oldest Ubuntu image and the ARM64 macOS one on the
+  # oldest macOS image there are, then attached to the release.
+  check:
+    needs: [versions, build]
+    permissions:
+      contents: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - os: ubuntu-22.04-arm
+            target: aarch64-unknown-linux-gnu
+          - os: macos-15
+            target: aarch64-apple-darwin
+          - os: macos-15-intel
+            target: x86_64-apple-darwin
+          - os: windows-2022
+            target: x86_64-pc-windows-msvc
+    runs-on: ${{ matrix.os }}
+    env:
+      TAG: ${{ needs.versions.outputs.tag }}
+      IS_RELEASE: ${{ needs.versions.outputs.is-release }}
+      NAME: tddlog-${{ needs.versions.outputs.tag }}-${{ matrix.target }}
+      ARCHIVE: tddlog-${{ needs.versions.outputs.tag }}-${{ matrix.target }}.${{ matrix.target == 'x86_64-pc-windows-msvc' && 'zip' || 'tar.gz' }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: tddlog-${{ matrix.target }}
+
+      # The README's first example, whose answers it prints, read from the
+      # unpacked directory; nothing on standard error. Each answer is
+      # `atom:<tab>probability`, as ProbLog prints it; carriage returns are
+      # dropped before the comparison.
+      - name: Verify, unpack and run
+        run: |
+          set -eux
+          if command -v sha256sum; then
+            sha256sum -c "$ARCHIVE.sha256"
+          else
+            shasum -a 256 -c "$ARCHIVE.sha256"
+          fi
+          mkdir unpacked
+          if [ "$RUNNER_OS" = Windows ]; then
+            7z x -ounpacked "$ARCHIVE"
+          else
+            tar xzf "$ARCHIVE" -C unpacked
+          fi
+          cd "unpacked/$NAME"
+          ls -l
+          ./tddlog --help > help.txt
+          head -n 3 help.txt
+          ./tddlog --version | tee version.txt
+          if [ "$IS_RELEASE" = true ]; then
+            test "$(tr -d '\r' < version.txt)" = "tddlog ${TAG#v}"
+          fi
+          ./tddlog examples/alarm.pl > answers.txt 2> errors.txt
+          cat answers.txt errors.txt
+          printf 'burglary:\t0.357143\nearthquake:\t0.714286\ncalls(mary):\t0.400000\n' > expected.txt
+          tr -d '\r' < answers.txt | diff expected.txt -
+          test ! -s errors.txt
+
+      # An archive attached to a published release, and the checksum people
+      # verify it against, are never replaced: a pair already there is kept,
+      # and one half of a pair is an error. To rebuild an archive, delete
+      # both from the release and run this workflow with the tag.
+      - name: Attach to the release
+        if: env.IS_RELEASE == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+        run: |
+          set -eu
+          assets=$(gh release view "$TAG" --json assets --jq '.assets[].name')
+          have() { grep -qxF "$1" <<< "$assets"; }
+          if have "$ARCHIVE" && have "$ARCHIVE.sha256"; then
+            echo "$ARCHIVE and its checksum are already attached; kept"
+          elif have "$ARCHIVE" || have "$ARCHIVE.sha256"; then
+            echo "only one of $ARCHIVE and $ARCHIVE.sha256 is attached: delete it and run again"
+            exit 1
+          else
+            gh release upload "$TAG" "$ARCHIVE" "$ARCHIVE.sha256"
+          fi

tddlog-0.1.0/.github/workflows/c-bindings.yml

@@ -0,0 +1,251 @@
+name: C bindings
+
+# Builds the C library in bindings/c on Linux (x86-64, ARM64), macOS (ARM64,
+# x86-64) and Windows x86-64, checks the committed header, runs the C tests,
+# builds and runs the example against the installed CMake and pkg-config
+# package and against the static library, and packages the header, both
+# libraries and the notices into an archive. On Windows the CMake package and
+# the pkg-config file are not built or tested (see the step that skips them),
+# and the example and the tests are compiled with cl.exe directly.
+# When a GitHub release is published it attaches the archives to it. The
+# packaging runs on every trigger, so it is proven working before a release
+# needs it.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Existing release tag to build the archives for and attach them to
+        required: false
+        type: string
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  # Before anything is built: the archive tag, and one version across the
+  # crate and the bindings, which a release tag must name. A pull request's
+  # ref name has a slash in it, which breaks a directory name below, so
+  # "dev" stands in for anything that is not a release tag. The dispatch
+  # input reaches the script through the environment rather than `${{ }}`,
+  # which would paste it into the shell.
+  versions:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
+      is-release: ${{ steps.tag.outputs.is-release }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ inputs.tag || '' }}
+      - name: Determine the archive tag
+        id: tag
+        env:
+          INPUT_TAG: ${{ inputs.tag }}
+        run: |
+          if [ -n "$INPUT_TAG" ]; then
+            tag="$INPUT_TAG"; is_release=true
+          elif [[ "$GITHUB_REF" == refs/tags/* ]]; then
+            tag="$GITHUB_REF_NAME"; is_release=true
+          else
+            tag=dev; is_release=false
+          fi
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "is-release=$is_release" >> "$GITHUB_OUTPUT"
+      - name: Check the release metadata
+        env:
+          TAG: ${{ steps.tag.outputs.is-release == 'true' && steps.tag.outputs.tag || '' }}
+        run: python3 .github/scripts/check_release.py --release-tag "$TAG"
+
+  c-bindings:
+    needs: versions
+    permissions:
+      contents: write
+    strategy:
+      fail-fast: false
+      matrix:
+        # `target` is not passed to cargo, since the runner's default
+        # toolchain already builds for it; it only names the archive.
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+          - os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: macos-15-intel
+            target: x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+    runs-on: ${{ matrix.os }}
+    env:
+      TAG: ${{ needs.versions.outputs.tag }}
+      IS_RELEASE: ${{ needs.versions.outputs.is-release }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      # A tag input checks out that tag, so a run by hand builds and attaches
+      # the archives a published release lacks.
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ inputs.tag || '' }}
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      # check.py needs CMake and pkg-config, which the ARM64 image may lack.
+      - name: Install CMake and pkg-config
+        if: runner.os == 'Linux'
+        run: |
+          if ! command -v cmake || ! command -v pkg-config; then
+            sudo apt-get update && sudo apt-get install -y cmake pkg-config
+          fi
+
+      # The header against cbindgen's, the CMake build and its tests (the
+      # answers of a dozen ProbLog system tests, and the example), the
+      # installation, and the example built against the installed package
+      # through CMake and pkg-config.
+      #
+      # Not on Windows: the CMake package links `m`, names no import library
+      # for the DLL and installs the DLL beside the others in lib, and
+      # pkg-config is not installed there. The steps below build, run and
+      # package the Windows library without CMake.
+      - name: Build, test and install
+        if: runner.os != 'Windows'
+        run: python3 bindings/c/check.py
+
+      # Builds the static library as well, and prints the system libraries a
+      # static link has to name, the C++ runtime of goatd's vendored solvers
+      # among them. The example's static link uses that list rather than a
+      # guess per platform.
+      - name: Build the libraries
+        working-directory: bindings/c
+        env:
+          # The note below is read by sed, and colour escapes would hide it.
+          CARGO_TERM_COLOR: never
+        run: |
+          set -o pipefail
+          cargo rustc --release -- --print native-static-libs 2>&1 \
+            | tee "$RUNNER_TEMP/build.log"
+          libs=$(sed -n 's/^note: native-static-libs: //p' "$RUNNER_TEMP/build.log" | head -n 1)
+          test -n "$libs" || { echo "rustc printed no native-static-libs note"; exit 1; }
+          echo "NATIVE_STATIC_LIBS=$libs" >> "$GITHUB_ENV"
+
+      - name: Build and run the example against the static library
+        if: runner.os != 'Windows'
+        run: |
+          set -eux
+          # The list of libraries is split into words on purpose.
+          # shellcheck disable=SC2086
+          cc -std=c11 -Wall -Wextra -Werror -Ibindings/c/include \
+             bindings/c/examples/alarm.c bindings/c/target/release/libtddlog_c.a \
+             $NATIVE_STATIC_LIBS -lm -o alarm-static
+          ./alarm-static
+
+      # cl.exe is not on PATH until vcvars has run, and vswhere finds the
+      # installation without naming the Visual Studio edition. /MD is the
+      # dynamic C runtime that Rust and the vendored C++ are built against.
+      # The tests take the same programs as the CMake test `answers`
+      # (bindings/c/CMakeLists.txt). `-D_CRT_SECURE_NO_WARNINGS` silences
+      # MSVC's notes on fopen, which the tests use.
+      - name: Build and run the example and the tests (Windows)
+        if: runner.os == 'Windows'
+        shell: cmd
+        run: |
+          for /f "usebackq tokens=*" %%i in (`"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe" -latest -products * -property installationPath`) do set "VSPATH=%%i"
+          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat" || exit /b 1
+          set OUT=bindings\c\target\release
+          copy %OUT%\tddlog_c.dll . || exit /b 1
+
+          cl /nologo /std:c11 /MD /W3 /D_CRT_SECURE_NO_WARNINGS /Ibindings\c\include ^
+             bindings\c\examples\alarm.c /Fe:alarm-shared.exe /link %OUT%\tddlog_c.dll.lib || exit /b 1
+          alarm-shared.exe || exit /b 1
+
+          cl /nologo /std:c11 /MD /W3 /D_CRT_SECURE_NO_WARNINGS /Ibindings\c\include ^
+             bindings\c\examples\alarm.c /Fe:alarm-static.exe /link %OUT%\tddlog_c.lib %NATIVE_STATIC_LIBS% || exit /b 1
+          alarm-static.exe || exit /b 1
+
+          cl /nologo /std:c11 /MD /W3 /D_CRT_SECURE_NO_WARNINGS /Ibindings\c\include ^
+             bindings\c\tests\answers.c /Fe:answers.exe /link %OUT%\tddlog_c.dll.lib || exit /b 1
+          set P=tests/problog
+          answers.exe %P%/00_trivial_and.pl %P%/00_trivial_not.pl %P%/00_trivial_or.pl %P%/10_cards.pl ^
+             %P%/11_ads_numerical.pl %P%/3_tossing_coin.pl %P%/4_bayesian_net.pl ^
+             %P%/7_probabilistic_graph.pl %P%/8_smokers_network.pl %P%/add.pl %P%/negation.pl ^
+             %P%/negative_query.pl %P%/smokers_or.pl %P%/tc_3.pl || exit /b 1
+
+      - name: Check formatting
+        if: ${{ !cancelled() && runner.os == 'Linux' }}
+        working-directory: bindings/c
+        run: cargo fmt --check
+
+      - name: Lint
+        if: ${{ !cancelled() && runner.os == 'Linux' }}
+        working-directory: bindings/c
+        run: cargo clippy --release -- -D warnings
+
+      # The archive is the installation check.py tested from another prefix:
+      # the header in include/, the shared library, the CMake package and the
+      # pkg-config file in lib/, and LICENSE, NOTICE and THIRD-PARTY.md in
+      # share/licenses/tddlog (goatd's vendored solvers are BSD-2-Clause and
+      # MIT, and their notices have to accompany the libraries they are
+      # compiled into). The static library goes beside the shared one, and
+      # NATIVE-STATIC-LIBS.txt records the system libraries it needs at link
+      # time, which differ per platform.
+      - name: Package the archive (Linux, macOS)
+        if: runner.os != 'Windows'
+        run: |
+          set -eux
+          name="tddlog-c-$TAG-${{ matrix.target }}"
+          cp -R bindings/c/build/package "$name"
+          cp bindings/c/target/release/libtddlog_c.a "$name/lib/"
+          {
+            echo "System libraries needed when linking libtddlog_c.a statically,"
+            echo "from 'cargo rustc --release -- --print native-static-libs':"
+            echo "$NATIVE_STATIC_LIBS"
+          } > "$name/NATIVE-STATIC-LIBS.txt"
+          tar czf "$name.tar.gz" "$name"
+          shasum -a 256 "$name.tar.gz" > "$name.tar.gz.sha256"
+          tar tzf "$name.tar.gz"
+
+      # MSVC names the DLL's import library tddlog_c.dll.lib, and the static
+      # archive tddlog_c.lib. A zip, which Windows opens without extra tools.
+      - name: Package the archive (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          set -eux
+          out=bindings/c/target/release
+          name="tddlog-c-$TAG-${{ matrix.target }}"
+          mkdir "$name"
+          cp bindings/c/include/tddlog.h LICENSE NOTICE THIRD-PARTY.md "$name"
+          cp "$out/tddlog_c.dll" "$out/tddlog_c.dll.lib" "$out/tddlog_c.lib" "$name"
+          {
+            echo "System libraries needed when linking tddlog_c.lib statically,"
+            echo "from 'cargo rustc --release -- --print native-static-libs':"
+            echo "$NATIVE_STATIC_LIBS"
+          } > "$name/NATIVE-STATIC-LIBS.txt"
+          7z a "$name.zip" "$name"
+          sha256sum "$name.zip" > "$name.zip.sha256"
+          7z l "$name.zip"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: tddlog-c-${{ matrix.target }}
+          path: |
+            tddlog-c-*.tar.gz*
+            tddlog-c-*.zip*
+
+      # No --clobber: an archive attached to a published release, and the
+      # checksum people verify it against, are never replaced. To rebuild one,
+      # delete it from the release and run this workflow with the tag.
+      - name: Attach to the release
+        if: env.IS_RELEASE == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh release upload "$TAG" tddlog-c-"$TAG"-${{ matrix.target }}.*