Lyx – Fehlerbehandlung

Lyx kennt kein try/catch/throw. Das ist eine bewusste Designentscheidung: Exceptions erzeugen nicht-linearen Kontrollfluss, der zur Compile-Zeit schwer nachzuverfolgen ist, WCET-Analysen erschwert und in sicherheitskritischen Systemen verboten ist.

Stattdessen setzt Lyx auf explizite Fehlerbehandlung: Fehler sind normale Rückgabewerte. Sie werden dort behandelt, wo sie auftreten — nicht irgendwo im Call-Stack. Das macht Fehlerbehandlung sichtbar, testbar und zertifizierbar.

Lyx bietet vier Mechanismen, je nach Kontext:

Die leichtgewichtigste Form der Fehlerbehandlung: Eine Funktion gibt ihr Ergebnis zusammen mit einem bool zurück, der Erfolg oder Misserfolg signalisiert. Kein Import, kein Overhead, direkt lesbar.

fn Divide(a: int64, b: int64): (int64, bool) {
    if (b = 0) {
        return (0, false);   // Fehlerfall: Division durch null
    }
    return (a / b, true);    // Erfolg
}

fn ParsePort(s: int64): (int64, bool) {
    var port: int64 := StrToInt(s);
    if (port < 1 | port > 65535) {
        return (0, false);
    }
    return (port, true);
}

fn main(): int64 {
    var (result, ok): (int64, bool) := Divide(10, 3);
    if (!ok) {
        PrintStr("Fehler: Division durch null\n");
        return 1;
    }
    PrintStr("Ergebnis: ");
    PrintInt(result);
    PrintStr("\n");

    var (port, valid): (int64, bool) := ParsePort("8080");
    if (valid) {
        PrintStr("Port: ");
        PrintInt(port);
        PrintStr("\n");
    }

    return 0;
}

Das Tuple-Pattern eignet sich für einfache, lokale Fehler. Wenn mehr Kontext über die Art des Fehlers gebraucht wird — z.B. warum etwas fehlschlug — ist der Result-Typ die bessere Wahl.

std.result stellt konkrete Result-Strukturen bereit — nach dem Vorbild von Rusts Result<T, E>. Jeder Result-Typ enthält ein success-Flag, einen Wert und einen Fehlercode.

std.result definiert eine Menge standardisierter Fehlercodes:

import std.result;
import std.io;

fn SafeSqrt(x: f64): (f64, int64) {
    if (x < 0.0) {
        return (0.0, ERR_INVALID_INPUT);
    }
    return (math.Sqrt(x), ERR_NONE);
}

fn ReadSensorValue(port: int64): ResultInt64 {
    if (port < 0 | port > 255) {
        return ErrInt64(ERR_INVALID_INPUT);
    }
    var raw: int64 := MemRead32(port);
    if (raw = 0xFFFFFFFF) {
        return ErrInt64(ERR_IO);   // Sensor antwortet nicht
    }
    return OkInt64(raw);
}

fn main(): int64 {
    var r: ResultInt64 := ReadSensorValue(0x40);

    if (ResultInt64IsOk(r)) {
        PrintStr("Wert: ");
        PrintInt(ResultInt64Unwrap(r));
        PrintStr("\n");
    } else {
        PrintStr("Fehler: ");
        PrintStr(ErrorCodeToString(ResultInt64Error(r)));
        PrintStr("\n");
    }

    return 0;
}

Statt immer ein if (IsOk) zu schreiben gibt es mehrere Auspack-Varianten:

import std.result;

fn main(): int64 {
    var r: ResultInt64 := ReadSensorValue(0x40);

    // Unwrap: gibt Wert zurück oder bricht mit panic() ab
    var val1: int64 := ResultInt64Unwrap(r);

    // UnwrapOr: gibt Wert zurück oder Fallback bei Fehler
    var val2: int64 := ResultInt64UnwrapOr(r, 0);

    // Expect: wie Unwrap, aber mit eigener Fehlermeldung
    var val3: int64 := ResultInt64Expect(r, "Sensor konnte nicht gelesen werden");

    return 0;
}

ResultInt64AndThen ermöglicht das Verketten von Operationen: Wenn der vorherige Schritt erfolgreich war, wird die nächste Operation ausgeführt. Bei Fehler wird der Fehler durchgereicht.

import std.result;

fn ValidateRange(v: int64): ResultInt64 {
    if (v < 0 | v > 1000) { return ErrInt64(ERR_OUT_OF_BOUNDS); }
    return OkInt64(v);
}

fn ScaleValue(v: int64): ResultInt64 {
    return OkInt64(v * 10);
}

fn main(): int64 {
    // Kurzform: Schritt für Schritt, Fehler wird automatisch weitergereicht
    var r: ResultInt64 := ReadSensorValue(0x40);
    r := ResultInt64AndThen(r, ValidateRange as int64);
    r := ResultInt64AndThen(r, ScaleValue as int64);

    if (ResultInt64IsOk(r)) {
        PrintStr("Skalierter Wert: ");
        PrintInt(ResultInt64Unwrap(r));
        PrintStr("\n");
    } else {
        PrintStr("Fehlgeschlagen: ");
        PrintStr(ErrorCodeToString(ResultInt64Error(r)));
        PrintStr("\n");
    }

    return 0;
}

Während Result einen Fehlergrund trägt, kodiert OptionInt64 nur das Vorhandensein oder Fehlen eines Wertes — ohne Fehlercode. Einsatz: Suchen, optionale Konfigurationswerte, nullable Rückgaben.

import std.result;
import std.io;

fn FindFirst(arr: int64, n: int64, target: int64): OptionInt64 {
    var i: int64 := 0;
    while (i < n) limit(65536) {
        var elem: int64 := (arr + i * 8) as int64;
        if (elem = target) {
            return SomeInt64(i);   // Gefunden: Index zurückgeben
        }
        i := i + 1;
    }
    return NoneInt64();            // Nicht gefunden
}

fn main(): int64 {
    var data: [6]int64 := [10, 20, 30, 40, 50, 60];

    var result: OptionInt64 := FindFirst(data as int64, 6, 30);

    if (OptionInt64IsSome(result)) {
        PrintStr("Gefunden an Index: ");
        PrintInt(OptionInt64Unwrap(result));
        PrintStr("\n");
    } else {
        PrintStr("Nicht gefunden\n");
    }

    // UnwrapOr: Fallback wenn nicht gefunden
    var idx: int64 := OptionInt64UnwrapOr(result, -1);

    return 0;
}

std.result enthält Varianten der Grundrechenarten, die Über- und Unterläufe sowie Division durch null als ResultInt64 zurückgeben — statt undefiniertes Verhalten zu produzieren.

import std.result;
import std.io;

fn main(): int64 {
    // Division mit Null-Prüfung
    var r_div: ResultInt64 := SafeDiv(100, 0);
    if (ResultInt64IsErr(r_div)) {
        PrintStr("Fehler: ");
        PrintStr(ErrorCodeToString(ResultInt64Error(r_div)));
        PrintStr("\n");
        // Ausgabe: "Division durch null"
    }

    // Multiplikation mit Überlaufprüfung
    var r_mul: ResultInt64 := SafeMul(9223372036854775807, 2);
    if (ResultInt64IsErr(r_mul)) {
        PrintStr("Überlauf erkannt\n");
    }

    // Sicherer Array-Zugriff mit Grenzprüfung
    var arr: int64[5] := [1, 2, 3, 4, 5];
    var r_get: ResultInt64 := SafeArrayGet(arr as int64, 5, 10);  // Index 10 → Out of Bounds
    if (ResultInt64IsErr(r_get)) {
        PrintStr("Zugriff außerhalb der Grenzen\n");
    }

    // SafeArraySet
    var r_set: ResultBool := SafeArraySet(arr as int64, 5, 2, 99);
    if (ResultBoolIsOk(r_set)) {
        PrintStr("arr[2] gesetzt\n");
    }

    return 0;
}

Für systemnahen Code — Dateisystem, Netzwerk, Prozesse — liefert std.error die vollständigen POSIX-errno-Codes und Hilfsfunktionen zur Fehlerauswertung.

Syscalls in Lyx geben bei Fehler negative Werte zurück (Konvention: -(errno)). CheckSyscallError prüft, ob ein Rückgabewert einen Fehler signalisiert, GetSyscallErrorMessage liefert den lesbaren Text.

import std.error;
import std.io;
import std.fs;

fn ReadFile(path: int64): (int64, int64) {
    var fd: int64 := SysOpen(path, 0, 0);
    if (CheckSyscallError(fd)) {
        return (0, GetSyscallErrorCode(fd));
    }

    var buf: uint8[4096];
    var n: int64 := SysRead(fd, buf as int64, 4096);
    SysClose(fd);

    if (CheckSyscallError(n)) {
        return (0, GetSyscallErrorCode(n));
    }

    return (n, 0);
}

fn main(): int64 {
    var (bytes_read, err): (int64, int64) := ReadFile("/etc/hostname");

    if (err != 0) {
        PrintStr("Fehler beim Lesen: ");
        PrintStr(GetErrorMessage(err));
        PrintStr("\n");
        return 1;
    }

    PrintStr("Gelesen: ");
    PrintInt(bytes_read);
    PrintStr(" Bytes\n");
    return 0;
}

Häufige POSIX-Fehlercodes:

panic() ist kein Exception-Mechanismus — es gibt keinen catch. Ein panic() beendet das Programm sofort mit einer Fehlermeldung und einem Stack-Trace. Es ist für Zustände, die nicht auftreten dürfen und auf einen Programmierfehler oder Hardwaredefekt hinweisen.

fn GetElement(arr: int64, len: int64, index: int64): int64 {
    if (index < 0 || index >= len) {
        panic("GetElement: Index außerhalb der Grenzen");
        // Kein return nötig — panic() kehrt nie zurück
    }
    return (arr + index * 8) as int64;
}

fn ConnectToDatabase(): int64 {
    var fd: int64 := OpenTCPSocket("localhost", 5432);
    if (fd < 0) {
        // Datenbank ist Pflichtinfrastruktur — ohne sie kann das Programm nicht laufen
        panic("Datenbankverbindung fehlgeschlagen — Programm kann nicht fortfahren");
    }
    return fd;
}

panic() ist sinnvoll für:

• Verletzung von Invarianten, die nie auftreten dürfen (Buffer Overflow, falscher Typ)
• Programmierfehler, die im Test hätten erkannt werden sollen
• Initialisierungsfehler, nach denen kein sicherer Betrieb möglich ist

panic() ist nicht sinnvoll für:

• Erwartbare Fehler wie „Datei nicht gefunden“ oder „Netzwerk nicht erreichbar“
• Benutzereingabe-Fehler
• Jeden Fehler in sicherheitskritischem Code — dort Result-Typen verwenden

Im Safety-Umfeld (DO-178C DAL-A/B) muss dokumentiert sein, unter welchen Bedingungen panic() erreichbar ist. Der Compiler-Flag –static-analysis prüft, ob panic()-Pfade existieren und markiert sie im Report.

Für DO-178C-zertifizierten Code gelten klare Regeln:

import std.result;
import std.error;
import std.io;

con SENSOR_PORT:  int64 := 0x40;
con MIN_VALUE:    int64 := 100;
con MAX_VALUE:    int64 := 900;

// Schritt 1: Rohwert lesen
fn ReadRaw(port: int64): ResultInt64 {
    if (port < 0 || port > 255) {
        return ErrInt64(ERR_INVALID_INPUT);
    }
    var raw: int64 := MemRead32(port);
    if (raw < 0) {
        return ErrInt64(ERR_IO);
    }
    return OkInt64(raw);
}

// Schritt 2: Wertebereich prüfen
fn ValidateRange(value: int64): ResultInt64 {
    if (value < MIN_VALUE || value > MAX_VALUE) {
        return ErrInt64(ERR_OUT_OF_BOUNDS);
    }
    return OkInt64(value);
}

// Schritt 3: Einheit umrechnen (Rohwert → Millibar)
fn ConvertToMillibar(raw: int64): ResultInt64 {
    var (scaled, err): (int64, int64) := SafeDiv(raw * 1013, 900) |> unwrap_tuple;
    if (err != 0) {
        return ErrInt64(ERR_OVERFLOW);
    }
    return OkInt64(scaled);
}

@flight_crit
@stack_limit(512)
fn ReadPressure(): ResultInt64 {
    var r: ResultInt64 := ReadRaw(SENSOR_PORT);
    r := ResultInt64AndThen(r, ValidateRange as int64);
    r := ResultInt64AndThen(r, ConvertToMillibar as int64);
    return r;
}

fn main(): int64 {
    var r: ResultInt64 := ReadPressure();

    if (ResultInt64IsOk(r)) {
        PrintStr("Druck: ");
        PrintInt(ResultInt64Unwrap(r));
        PrintStr(" mbar\n");
    } else {
        PrintStr("Sensor-Fehler: ");
        PrintStr(ErrorCodeToString(ResultInt64Error(r)));
        PrintStr("\n");
        return 1;
    }

    return 0;
}

Jeder Schritt der Pipeline gibt ResultInt64 zurück. AndThen reicht einen Fehler automatisch durch — der nächste Schritt wird nur ausgeführt, wenn der vorherige erfolgreich war. Der Kontrollfluss bleibt vollständig linear und WCET-berechenbar.

→ std.result — Vollständige Funktionsreferenz
→ std.error — POSIX-Fehlercodes und Hilfsfunktionen