diff options
| author | Leitwolf | 2026-11-16 14:49:23 +0300 |
|---|---|---|
| committer | GitHub | 2026-11-16 14:49:23 +0300 |
| commit | 324048967d1fb198e3489b1722ca1ff317338550 (patch) | |
| tree | e270ad6dc86200cc79cbdccfa1ef6de1da8aff0d /content | |
| parent | 45c1bb14326cbee8fe57c6f639550e8eadd81f0a (diff) | |
| parent | 4ee77681379619b3fab7b8b33446a67164216cc8 (diff) | |
| download | tazel.net-main.tar.gz | |
Rewrite the site for the Tazel of C, C++, Objective-C, Objective-C++ and Zig
Diffstat (limited to 'content')
37 files changed, 2740 insertions, 1703 deletions
diff --git a/content/de-DE/docs/1.getting-started/1.installation.md b/content/de-DE/docs/1.getting-started/1.installation.md index ee52ffc..d13ed88 100644 --- a/content/de-DE/docs/1.getting-started/1.installation.md +++ b/content/de-DE/docs/1.getting-started/1.installation.md @@ -1,42 +1,50 @@ --- title: Installation -description: Tazel und die Tala-Werkzeuge installieren, die es startet. +description: Tazel aus dem Quellcode bauen und die Compiler und Werkzeuge installieren, die es aufruft. --- <!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> --> <!-- SPDX-License-Identifier: AGPL-3.0-or-later --> -Tazel ist ein Kotlin-Programm für die JVM, ein Rechner braucht also eine Java-Laufzeit 25 oder neuer. Es kompiliert -selbst nichts: `check`, `build`, `run` und `test` starten Talac, `fmt` startet talafmt und `lint` startet talalint. +Tazel ist ein Kotlin-Programm für die JVM. Es kompiliert selbst nichts: Es ruft die Compiler und Werkzeuge auf, die +es im `PATH` findet. Noch ist keine Version veröffentlicht, daher wird Tazel aus seinem Quellcode gebaut. -## Tazel bauen +## Was ein Rechner braucht + +| Wofür | Installieren | +| --- | --- | +| Tazel selbst | ein JDK 25, etwa Eclipse Temurin 25 | +| Ziele in C, C++, Objective-C und Objective-C++ | Clang oder GCC; Clang baut auch für andere Triples | +| Zig-Ziele und `zig cc` als C-Compiler | Zig | +| `tazel fmt` | clang-format für die C-Familie, `zig fmt` (Teil von Zig) für Zig | +| `tazel lint` | clang-tidy | -Tazel wird aus seinem Quellcode mit dem Gradle-Wrapper gebaut, der ein JDK 25 braucht. `installDist` schreibt die -Starter, `tazel` und `tazel.bat`, nach `build/install/tazel/bin`. Nehmen Sie diesen Ordner in `PATH` auf. +Jedes Werkzeug wird nur für die Befehle und Ziele gebraucht, die es verwenden: Ein Modul nur aus C++ braucht kein Zig. -```bash [Linux und macOS] +## Tazel bauen + +```bash git clone https://github.com/Progmasoft/tazel.git cd tazel ./gradlew installDist ``` -```powershell [Windows] -git clone https://github.com/Progmasoft/tazel.git -cd tazel -.\gradlew.bat installDist -``` +Unter Windows führen Sie in PowerShell `gradlew.bat installDist` aus. Das Programm liegt in `build/install/tazel`: +Legen Sie sein Verzeichnis `bin` in den `PATH` und prüfen Sie es: -`tazel version` gibt die installierte Version aus. +```bash +tazel version +``` -## Die Tala-Werkzeuge +```text +tazel 0.1.0 +``` -Tazel findet jedes Werkzeug über `TAZEL_TALAC`, `TAZEL_TALAFMT` oder `TAZEL_TALALINT`, dann in seiner eigenen -Installation, dann über `PATH`. Jedes Werkzeug hat eigene Releases: +## Wo Tazel Werkzeuge sucht -| Werkzeug | Verwendet von | Quellcode | -| -------- | ------------------------------- | ------------------------------------------------------------- | -| Talac | `check`, `build`, `run`, `test` | [Progmasoft/tala](https://github.com/Progmasoft/tala) | -| talafmt | `fmt` | [Progmasoft/talafmt](https://github.com/Progmasoft/talafmt) | -| talalint | `lint` | [Progmasoft/talalint](https://github.com/Progmasoft/talalint) | +Tazel nimmt `clang`, `gcc`, `zig`, `clang-format` und `clang-tidy` aus dem `PATH`. Ein Ziel kann seinen Compiler mit +`compiler = Compiler.CLANG`, `Compiler.GCC` oder `Compiler.ZIG_CC` nennen; ohne Angabe nimmt Tazel den ersten +gefundenen, der für das Triple des Ziels baut. Jedes Werkzeug liest seine eigene Konfiguration, etwa `.clang-format` +und `.clang-tidy`. -Weiter: [ein erstes Projekt](/docs/getting-started/first-project). +Weiter: [Ihr erstes Projekt](/docs/getting-started/first-project). diff --git a/content/de-DE/docs/1.getting-started/2.first-project.md b/content/de-DE/docs/1.getting-started/2.first-project.md index 72f1fc0..feafa55 100644 --- a/content/de-DE/docs/1.getting-started/2.first-project.md +++ b/content/de-DE/docs/1.getting-started/2.first-project.md @@ -1,60 +1,162 @@ --- -title: Ein erstes Projekt -description: Ein Tala-Projekt in wenigen Zeilen schreiben, dann bauen, starten, formatieren und prüfen. +title: Ihr erstes Projekt +description: Ein Modul mit einer C-Bibliothek, einem C++-Programm und einem Test, gebaut, gestartet und getestet mit Tazel. --- <!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> --> <!-- SPDX-License-Identifier: AGPL-3.0-or-later --> -Ein Projekt ist ein Ordner mit einer Projektdatei. Seine Quellen sind die `.tala`-Dateien unter `Sources/`, und `entry` -nennt die Klasse, deren `public static void Main()` das Programm startet. +Ein Modul ist ein Verzeichnis mit einem `MODULE.kts` an seiner Wurzel. Jedes Verzeichnis darunter mit einem +`BUILD.kts` ist ein Paket, und jedes Ziel eines Pakets hat ein Label: `//app/:greeter` ist das Ziel `greeter` von +`app/BUILD.kts`. -```kotlin [BUILD.kts] -project { - name = "Example" +```text +greeter/ +├── MODULE.kts +├── core/ +│ ├── BUILD.kts +│ ├── include/core/greet.h +│ └── src/greet.c +├── app/ +│ ├── BUILD.kts +│ └── src/main.cpp +└── tests/ + ├── BUILD.kts + └── greet_test.cpp +``` + +## Das Modul + +```kotlin +// MODULE.kts +module { + name = "greeter" + version = "0.1.0" } +``` + +## Eine C-Bibliothek + +```kotlin +// core/BUILD.kts +isPublic = true + +c.staticlib("core") { + sources(glob("src/*.c")) + headers("include") + standard = CStandard.C17 +} +``` -sources { - executable { - entry = "Example.Program" - } +`isPublic = true` erlaubt den anderen Paketen des Moduls, von den Zielen dieser Datei abzuhängen. `headers("include")` +lässt `#include <core/greet.h>` in `core` und in jedem Ziel wirken, das davon abhängt. + +```c +// core/include/core/greet.h +#pragma once +const char *greeting(void); +``` + +```c +// core/src/greet.c +#include <core/greet.h> +const char *greeting(void) { return "Hello"; } +``` + +## Ein C++-Programm + +```kotlin +// app/BUILD.kts +cpp.bin("greeter") { + sources(glob("src/*.cpp")) + depends("//core/:core") + standard = CppStandard.CPP20 } ``` -```tala [Sources/Main.tala] -namespace Example; +```cpp +// app/src/main.cpp +#include <cstdio> +extern "C" { +#include <core/greet.h> +} -public class Program { - public static void Main() { - Console.Println("Hello from Tala!"); - } +int main(int argc, char **argv) +{ + std::printf("%s, %s!\n", greeting(), argc > 1 ? argv[1] : "world"); } ``` ## Bauen und starten -```bash [terminal] -tazel build -tazel run -- first second +```bash +tazel build //app/:greeter ``` -`tazel build` schreibt `build/debug/Example`, unter Windows `Example.exe`. `tazel run` baut das Programm und startet -es; was nach `--` folgt, geht ungelesen an das Programm. Ein zweites `tazel build` ohne Änderung meldet das Ziel als -aktuell und startet keinen Compiler. +```text + Compiling //core/:core src/greet.c + Archiving //core/:core + Compiling //app/:greeter src/main.cpp + Linking //app/:greeter + Built 2 target(s) for x86_64-unknown-linux-gnu, debug; 4 command(s) run +``` -## Formatieren und prüfen +Ein zweiter Build führt nichts aus, weil sich keine Eingabe geändert hat: -```bash [terminal] -tazel fmt -- --check -tazel lint -- --fix +```text + Built 2 target(s) for x86_64-unknown-linux-gnu, debug; 0 command(s) run ``` -Optionen nach `--` gehen an talafmt und talalint, also meldet `tazel fmt -- --check` nur, und `tazel lint -- --fix` -wendet die Korrekturen an, die es kann. +`tazel run` baut ein Programm und startet es; was nach `--` folgt, geht an das Programm: + +```bash +tazel run //app/:greeter -- Ada +``` + +```text +Hello, Ada! +``` + +Die Ergebnisse liegen in `.tazel/out/<triple>/<mode>`, hier `.tazel/out/x86_64-unknown-linux-gnu/debug`. `--release` +baut im Release-Modus. + +## Ein Test + +```kotlin +// tests/BUILD.kts +cpp.test("greet") { + sources("greet_test.cpp") + depends("//core/:core") +} +``` + +```cpp +// tests/greet_test.cpp +#include <cstring> +extern "C" { +#include <core/greet.h> +} + +int main() { return std::strcmp(greeting(), "Hello") == 0 ? 0 : 1; } +``` + +Ein Test besteht, wenn sein Programm mit 0 endet. `//tests/...` nimmt jedes Ziel in `tests/` und darunter: + +```bash +tazel test //tests/... +``` + +```text + Compiling //tests/:greet greet_test.cpp + Linking //tests/:greet + Built 2 target(s) for x86_64-unknown-linux-gnu, debug; 2 command(s) run + PASSED //tests/:greet in 0.0s + Tested 1 test(s): 1 passed, 0 failed +``` ::note -ViGet liefert keine Tala-Pakete aus. Ein Projekt, das eine Abhängigkeit des Builds deklariert, Bibliotheksziele und die -Erstellung von `.vipkg` werden mit Namen und Exit-Code 1 abgelehnt. +Ohne Label nehmen `build`, `run` und `test` das Paket des aktuellen Verzeichnisses. `//...` nimmt das ganze Modul. :: -Weiter: jeder Block der [Projektdatei](/docs/reference/project-file) und jeder [Befehl](/docs/reference/commands). +Weiter: [die Befehle](/docs/reference/commands) und jede Einstellung von [MODULE.kts](/docs/reference/module-file) +und [BUILD.kts](/docs/reference/build-file). diff --git a/content/de-DE/docs/1.getting-started/3.releases.md b/content/de-DE/docs/1.getting-started/3.releases.md index a003c7c..f09a874 100644 --- a/content/de-DE/docs/1.getting-started/3.releases.md +++ b/content/de-DE/docs/1.getting-started/3.releases.md @@ -1,30 +1,32 @@ --- -title: Releases und Unterstützung -description: Wie Tazel nummeriert wird und wie lange Rolling-, LTS- und ELTS-Releases unterstützt werden. +title: Versionen +description: Wie Tazel seine Versionen nummeriert und wie lange jede Art von Version unterstützt wird. --- <!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> --> <!-- SPDX-License-Identifier: AGPL-3.0-or-later --> -Eine Version von Tazel hat vier Zahlen: `MAJOR.SEMIMAJOR.MINOR.PATCH`, etwa `0.4.0.3`. Jedes Release hat ein Tag -`tazel-<version>` und Versionshinweise auf [GitHub](https://github.com/Progmasoft/tazel/releases). +Noch ist keine Version von Tazel veröffentlicht; die erste wird 0.1.0 sein. Was sie bisher enthält, steht im +[Abschnitt Unreleased des Changelogs](https://github.com/Progmasoft/tazel/blob/main/CHANGELOG.md#unreleased). -## Drei Arten von Releases +## Versionsnummern -| Art | Unterstützt für | Welche Releases | -| --- | --- | --- | -| Rolling | 6 Monate | jedes Release, das weder LTS noch ELTS ist, und jedes Release vor `1.0.0.0` | -| LTS (Long-Term Support) | 5 Jahre | die Linie `A.0` jeder `MAJOR` ab `1.0.0.0` | -| ELTS (Extended Long-Term Support) | 12 Jahre | die LTS-Linie der `MAJOR` 1, 4, 7 und jeder dritten danach | +Versionen folgen [Semantic Versioning](https://semver.org): `MAJOR.MINOR.PATCH`. Eine Patch-Version behebt Fehler, +eine Minor-Version fügt hinzu, und eine Major-Version darf ändern, was vorher funktionierte. Tags heißen +`tazel-0.1.0`, und ein veröffentlichter Tag wird nie verschoben. + +## Arten von Versionen -Die Zeit zählt ab dem ersten Release der Linie. Eine unterstützte Linie erhält Korrekturen von Fehlern und -Sicherheitsproblemen als neue `MINOR`- und `PATCH`-Releases; neue Funktionen erhält sie nicht, die kommen in den -Rolling-Releases. +| Art | Unterstützt für | Welche Versionen | +| --- | --- | --- | +| Rolling | 6 Monate | jede Version vor 1.0.0 und jede Version außerhalb einer LTS- oder ELTS-Linie | +| LTS | 5 Jahre | die Linie MAJOR.0 der übrigen Major-Versionen: 2.0.x, 3.0.x, 5.0.x, 6.0.x und weiter | +| ELTS | 12 Jahre | die Linie MAJOR.0 der Major-Versionen 1, 4, 7 und jeder dritten danach: 1.0.x, 4.0.x, 7.0.x | -## Welche passt +Eine unterstützte Linie erhält nur Fehlerbehebungen, als ihre Patch-Versionen. -- **Rolling** bringt jede Funktion zuerst. Nehmen Sie das neueste Release; das davor bleibt 6 Monate unterstützt. -- **LTS** bleibt 5 Jahre auf einer Linie, für Projekte, die gelegentlich aktualisieren. -- **ELTS** bleibt 12 Jahre auf einer Linie, für Produkte, die Tala-Programme lange ausliefern. +## Das frühere Tazel -Jedes Release von Tazel vor `1.0.0.0` ist Rolling. +Ein früheres Programm gleichen Namens, Versionen 0.1.0 bis 0.4.0.3, ist als +[Progmasoft/tazel-legacy](https://github.com/Progmasoft/tazel-legacy) archiviert. Seine Versionen sind nicht die +Versionen dieses Tazel, das wieder bei 0.1.0 beginnt. diff --git a/content/de-DE/docs/2.reference/1.commands.md b/content/de-DE/docs/2.reference/1.commands.md new file mode 100644 index 0000000..cc6b653 --- /dev/null +++ b/content/de-DE/docs/2.reference/1.commands.md @@ -0,0 +1,119 @@ +--- +title: Befehle +description: Jeder Befehl von tazel, seine Optionen und die Labels, die er nimmt. +--- + +<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> --> +<!-- SPDX-License-Identifier: AGPL-3.0-or-later --> + +```text +tazel <command> [options] [labels] +``` + +| Befehl | Was er tut | +| --- | --- | +| `build` | baut Ziele, etwa `tazel build //app/:greeter` oder `tazel build //...` | +| `run` | baut ein `bin`-Ziel und startet es; was nach `--` folgt, geht an das Programm | +| `test` | baut Testziele und führt sie aus; was nach `--` folgt, geht an jeden Test | +| `fmt` | formatiert Quellen und Header von Zielen mit clang-format und `zig fmt`; `--check` meldet stattdessen | +| `lint` | prüft die C-Quellen von Zielen mit clang-tidy; `--fix` wendet seine Korrekturen an | +| `custom` | führt einen Befehl aus `tazel_custom.txt` aus oder listet sie auf | +| `version` | gibt die Version von Tazel aus | +| `help` | gibt die Hilfe aus | + +Ein vertippter Befehl bekommt einen Vorschlag für den nächstliegenden. + +## Labels + +| Label | Bedeutet | +| --- | --- | +| `//:x` | das Ziel `x` des `BUILD.kts` an der Wurzel | +| `//dir/:x` | das Ziel `x` von `dir/BUILD.kts` | +| `:x` | das Ziel `x` desselben `BUILD.kts`, in einer Projektdatei | +| `@name//:x` | das Ziel `x` der Abhängigkeit `name`: ihr Name, ihr Alias oder der Name ihres lokalen Blocks | +| `//dir/...` | jedes Ziel von `dir/BUILD.kts` und der Pakete darunter | +| `//...` | jedes Ziel des Moduls | + +Ohne Label nehmen `build`, `run` und `test` das Paket des aktuellen Verzeichnisses. Ein Muster nimmt keinen Test mit +dem Tag `MANUAL`; ein solcher Test läuft nur, wenn er genannt wird. + +## build, run und test + +| Option | Wirkung | +| --- | --- | +| `--release` | baut im Release-Modus; ohne sie im Debug-Modus | +| `--triple <triple>` | baut für dieses LLVM-Target-Triple, etwa `aarch64-unknown-linux-gnu`; ohne sie für dieses Gerät | + +Jedes Ziel wird für jedes Triple gebaut, das es nennt und das der Befehl verlangt, im Build-Modus des Befehls. Die +Ergebnisse gehen nach `.tazel/out/<triple>/<mode>`. Jedes Kompilieren, Archivieren, Linken und jeder Zig-Build läuft +nur erneut, wenn sich seine Befehlszeile, seine Umgebung oder der Inhalt einer gelesenen Datei geändert hat oder eine +geschriebene Ausgabe fehlt oder verändert ist. + +`tazel test` führt jeden Test in seinem Ausgabeverzeichnis aus, neben seinen Daten, mit seinen `args` und `env`. Ein +Test besteht, wenn er mit 0 endet. Tests laufen nebeneinander, außer denen mit dem Tag `EXCLUSIVE`, die allein laufen. +Ein Test wird bei seinem Zeitlimit gestoppt, bei `flaky = true` bis zu dreimal wiederholt und mit `TEST_TOTAL_SHARDS` +und `TEST_SHARD_INDEX` in `shards` aufgeteilt. Ein bestandener Test läuft nicht erneut, solange Programm, Daten, +Argumente und Umgebung gleich sind, außer er hat den Tag `NO_CACHE`. + +## fmt und lint + +```bash +tazel fmt //... +tazel fmt --check //... +tazel lint //... +tazel lint --fix //app/... +``` + +`fmt` formatiert die Quellen, Header-Verzeichnisse und textuellen Header der gewählten Ziele mit clang-format (C, C++, +Objective-C, Objective-C++) und `zig fmt` (Zig); `--check` meldet, was nicht formatiert ist, und ändert nichts. + +`lint` schreibt die Kompilierdatenbank der gewählten Ziele und ihrer Bibliotheken nach +`.tazel/out/<triple>/<mode>/compile_commands.json`, kopiert sie für Editoren nach `.tazel/compile_commands.json` und +führt clang-tidy auf jeder C-Übersetzungseinheit aus. `--fix` wendet die Korrekturen an, eine Einheit nach der +anderen. Zig-Ziele werden übersprungen. + +Bei beiden geht, was nach `--` folgt, an das Werkzeug. Jedes Werkzeug liest seine eigene Konfiguration, etwa +`.clang-format` und `.clang-tidy`. + +## custom + +`tazel custom` führt die Befehle aus `tazel_custom.txt` an der Wurzel des Moduls aus; `tazel custom` allein listet sie. + +```text +# tazel_custom.txt +format-check: ("tazel" "fmt" "--check" "//..."); + +all: + ("tazel" "build" "//...") + ("tazel" "test" "//..."); + +hello: s("echo hello from the shell"); + +build with: ("tazel" "build" <1> <2>); +``` + +- Ein Befehl ist ein Name, `:`, ein oder mehrere Schritte und `;`. Ein Name kann mehrere Wörter haben: + `tazel custom build with`. +- Ein Schritt `("program" "argument" ...)` führt das Programm mit diesen Argumenten aus. Zeichenketten stehen in + `"..."`, `'...'` oder `` `...` ``; es gibt keine Escape-Zeichen. +- Ein Schritt `s("...")` gibt eine Befehlszeile an die Shell: `sh` unter Linux und macOS, `cmd` unter Windows. +- `<1>`, `<2>` und weiter geben die Argumente der Befehlszeile nach Position weiter; `<*>` gibt alle weiter. `s(...)` + nimmt keine. `tazel custom first -- second` gibt `second` an `first`, wenn es einen Befehl `first second` gibt. +- `#` beginnt einen Kommentar bis zum Zeilenende; `<# ... #>` ist ein Kommentar über mehrere Zeilen. + +`tazel_options.txt` an der Wurzel des Moduls hält die Optionen von Tazel selbst: + +```text +sandboxing-with-microvm: false; +``` + +Mit `sandboxing-with-microvm: true` sollen eigene Befehle in einer MicroVM laufen, die diese Version nicht startet, +also brechen sie mit einem Fehler ab. `microvm-network`, `microvm-memory` und `microvm-cpus` stellen diese MicroVM +ein. + +## version und help + +```bash +tazel version +tazel help +``` diff --git a/content/de-DE/docs/2.reference/2.module-file.md b/content/de-DE/docs/2.reference/2.module-file.md new file mode 100644 index 0000000..d15571a --- /dev/null +++ b/content/de-DE/docs/2.reference/2.module-file.md @@ -0,0 +1,112 @@ +--- +title: MODULE.kts +description: Die Datei an der Wurzel eines Moduls: sein Name, seine Abhängigkeiten und wie es gebaut wird. +--- + +<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> --> +<!-- SPDX-License-Identifier: AGPL-3.0-or-later --> + +Ein Modul hat ein `MODULE.kts` an seiner Wurzel. Es ist ein Kotlin-Skript; `module { }` ist der einzige Block, den es +haben muss. + +```kotlin +module { + name = "greeter" + version = "1.2.0" + description = "Greets people." + authors("Ada Lovelace", "Alan Turing") + license = "MIT" +} + +dependencies { + implementation("Publisher") { + name = "toml" + version = "1.0.0" + } + testImplementation("Progmasoft") { + name = "catch3" + version = "0.4.0" + } + localImplementation { + name = "libs" + include(glob("libs/*.vipkg")) + } +} + +execution { + jobs = 8 + keepGoing = false +} +``` + +## module + +| Einstellung | Wert | +| --- | --- | +| `name` | der Name des Moduls; Pflicht | +| `version` | eine Semantic Version, etwa `1.2.0` | +| `description` | ein Satz über das Modul | +| `authors(...)` | seine Autorinnen und Autoren | +| `license` | ein SPDX-Lizenzausdruck, etwa `MIT` oder `Apache-2.0 OR MIT` | + +## dependencies + +| Block | Gibt | +| --- | --- | +| `implementation("Publisher") { name; version; alias }` | ein Paket aus ViGet, von dem jedes Ziel abhängen kann | +| `testImplementation("Publisher") { ... }` | dasselbe, nur für Testziele | +| `localImplementation { name; include(...) }` | Pakete aus `.vipkg`-Dateien des Moduls | +| `localTestImplementation { ... }` | dasselbe, nur für Testziele | + +Der Herausgeber ist ein [Progmasoft Account](https://progmasoft.com). Ein Ziel nennt ein Ziel einer Abhängigkeit mit +`@name//:x`, wobei `name` der `name` der Abhängigkeit, ihr `alias` oder der `name` eines lokalen Blocks ist. Ein lokaler +Block, dessen `include` mehrere Pakete nimmt, gibt ihnen einen Namen; derselbe Zielname in zweien davon ist ein Fehler. + +::note +Diese Version von Tazel liest die Abhängigkeiten und prüft die Labels, die sie nennen; sie lädt keine Pakete aus ViGet +herunter. Die Versionen, die ein Modul auflöst, werden in `LOCK.sqlite3` an seiner Wurzel festgehalten, der Lockdatei +von Tazel, die diese Version nicht schreibt. +:: + +## viget + +```kotlin +viget { + push = true + pushTarget("//core/:core", "//app/:greeter") + exclude(glob("docs/**")) +} +``` + +`pushTarget` nennt die Ziele, die ein Paket des Moduls enthält; ihr `BUILD.kts` muss `isPublic = true` haben. +`exclude` lässt Dateien aus dem Paket heraus. `push` ist standardmäßig `false`. + +## cache + +```kotlin +cache { + local = true + keep = 8 + remote("https://cache.example.com") { + read = true + write = false + token = env("TAZEL_CACHE_TOKEN") + } +} +``` + +`local` (Standard `true`) und `keep` (behaltene Ergebnisse je Ziel, Standard `8`) beschreiben den lokalen Cache; +`remote(...)` fügt einen geteilten hinzu, mit `read` (Standard `true`), `write` (Standard `false`), `token`, +`publicKey` und `signingKey`. `env("NAME")` liest eine Variable der Umgebung, damit kein Geheimnis in der Datei steht. + +## execution + +| Einstellung | Standard | Wirkung | +| --- | --- | --- | +| `jobs` | die Zahl der Prozessoren | wie viele Befehle gleichzeitig laufen | +| `memory` | keine Grenze | eine Grenze wie `16.gigabytes` | +| `keepGoing` | `false` | nach einem Fehler die Befehle starten, die nicht davon abhängen | +| `remote(url) { token }` | keiner | ein Rechner, der die Befehle ausführt | + +Diese Version von Tazel wirkt auf `jobs` und `keepGoing`; die übrigen Einstellungen von `cache` und `execution` werden +gelesen und geprüft. diff --git a/content/de-DE/docs/2.reference/3.build-file.md b/content/de-DE/docs/2.reference/3.build-file.md new file mode 100644 index 0000000..c9ef224 --- /dev/null +++ b/content/de-DE/docs/2.reference/3.build-file.md @@ -0,0 +1,143 @@ +--- +title: BUILD.kts +description: Die Ziele eines Pakets und jede Einstellung, die ein Ziel haben kann. +--- + +<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> --> +<!-- SPDX-License-Identifier: AGPL-3.0-or-later --> + +Jedes Paket hat ein `BUILD.kts`, ein Kotlin-Skript, das seine Ziele deklariert. Eine Einstellung, die eine Sprache +oder Zielart nicht hat, ist ein Kompilierfehler der Datei, also zeigt ein Editor sie, bevor Tazel läuft. + +## Ziele + +| Sprache | Quellen | Arten | +| --- | --- | --- | +| `c` | `.c` | `bin`, `staticlib`, `sharedlib`, `test` | +| `cpp` | `.cpp`, `.cc`, `.cxx` | dieselben | +| `objc` | `.m` | dieselben | +| `objcpp` | `.mm` | dieselben | +| `zig` | die Wurzeldatei `.zig` | dieselben | + +```kotlin +c.staticlib("core") { ... } // //core/:core +cpp.bin("greeter") { ... } // a program +zig.test("tool") { ... } // a test +``` + +Ein Ziel hat eine Sprache. Ziele verschiedener Sprachen verbinden sich über `depends`: Ein C++-Programm kann von einer +C-Bibliothek und von einer Zig-Bibliothek abhängen, die einen C-Header anbietet. + +## Sichtbarkeit + +`isPublic` oben in der Datei ist standardmäßig `false`: Nur die Ziele derselben Datei dürfen von ihren Zielen +abhängen. `isPublic = true` öffnet sie für die anderen Pakete des Moduls und für die Module, die davon abhängen. + +## Jedes Ziel + +| Einstellung | Wirkung | +| --- | --- | +| `sources(...)` | die Quelldateien: Pfade oder `glob("src/**/*.c")` | +| `depends(...)` | Labels der Ziele, die es verwendet | +| `targetTriple(...)` | die LLVM-Target-Triples, für die es gebaut wird; Standard: das dieses Geräts | +| `data(...)` | Dateien, die für `run` und `test` neben das Programm kopiert werden | +| `outputName` | der Dateiname der Ausgabe; Standard: der Zielname | + +## Triples, Build-Modi und Bedingungen + +Der Block eines Ziels läuft einmal für jedes Triple und jeden Build-Modus. `OS` und `ARCH` kommen aus dem Triple, +`BUILD_MODE` aus dem Befehl, also ist eine Bedingung schlichtes Kotlin: + +```kotlin +cpp.bin("greeter") { + sources(glob("src/**/*.cpp")) + targetTriple("x86_64-unknown-linux-gnu", "aarch64-apple-darwin", "x86_64-pc-windows-msvc") + + when (BUILD_MODE) { + BuildMode.DEBUG -> sanitize(Sanitizer.ADDRESS, Sanitizer.UNDEFINED) + BuildMode.RELEASE -> { + optimize = Optimize.SPEED + lto = Lto.THIN + strip = true + } + } + when (OS) { + Os.WINDOWS -> links("ws2_32") + Os.LINUX -> links("dl") + Os.MACOS -> frameworks("CoreFoundation") + else -> {} + } +} +``` + +## Ziele in C, C++, Objective-C und Objective-C++ + +| Einstellung | Werte und Standard | +| --- | --- | +| `exclude(...)` | Quellen, die ausgelassen werden | +| `headers(...)` | Header-Verzeichnisse, die hier und von abhängigen Zielen gesehen werden | +| `privateHeaders(...)` | Header-Verzeichnisse, die nur hier gesehen werden | +| `textualHeaders(...)` | Header, die eingebunden, aber nie allein kompiliert werden | +| `includePrefix`, `stripIncludePrefix` | ändern den Pfad, unter dem abhängige Ziele Header einbinden | +| `compiler` | `Compiler.CLANG`, `GCC`, `ZIG_CC`, `MSVC`, `CLANG_CL`; Standard: der erste gefundene, der für das Triple baut. Diese Version baut mit Clang, GCC und `zig cc`; `MSVC` und `CLANG_CL` brechen den Build mit einem Fehler ab | +| `standard` | C: `CStandard.C89` bis `C23`; C++ und Objective-C++: `CppStandard.CPP11` bis `CPP26`; Standard: der neueste, den der Compiler kann | +| `gnuExtensions` | standardmäßig `false` | +| `defines(...)`, `privateDefines(...)` | Makros für hier und abhängige Ziele oder nur für hier | +| `flags(...)` | weitere Compiler-Flags | +| `warnings` | `Warnings.ALL`, `DEFAULT`, `NONE`; Standard `DEFAULT` | +| `warningsAsErrors` | standardmäßig `false` | +| `precompiledHeader` | ein Header, der einmal kompiliert wird | +| `debugInfo` | `DebugInfo.NONE`, `FULL`, `SPLIT`; Standard: `FULL` in Debug, `NONE` in Release | +| `optimize` | `Optimize.NONE`, `SIZE`, `SPEED`; Standard: `NONE` in Debug, `SPEED` in Release | +| `lto` | `Lto.NONE`, `THIN`, `FULL`; Standard `NONE` | +| `strip` | standardmäßig `false` | +| `sanitize(...)` | `Sanitizer.ADDRESS`, `UNDEFINED`, `THREAD`, `MEMORY`, `LEAK` | +| `links(...)`, `linkFlags(...)` | Bibliotheken und Flags für den Linker | +| `frameworks(...)` | Apple-Frameworks | +| `arc` | nur Objective-C und Objective-C++; standardmäßig `true` | + +### Nach Art + +| Einstellung | Arten | Wirkung | +| --- | --- | --- | +| `args(...)`, `env(...)` | `bin`, `test` | was `run` und `test` an das Programm geben | +| `rpath(...)`, `linkerScript`, `resources(...)` | `bin`, `sharedlib`, `test` | Link |