B64: Beispiele und Erklärung

1. 1 + 2 + 3 + 4 + 5 = 15

Die Zahlen 1 bis 5 werden zu 15 addiert. Der Rückgabewert 15 wird als Prozess-Exitcode geprüft.

fn main(): i64 {
    let sum: i64 = 0;
    let i: i64 = 1;
    while i <= 5 {
        sum = sum + i;
        i = i + 1;
    }
    return sum;   // 15
}

Erwarteter Exitcode: 15

PBXB64.exe sum15-b64.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Nativ geprüft mit dem V22-Kandidaten vom 30.09.2026; Prüfung mit dem finalen Compiler noch ausstehend.

2. Typisierte Funktion: 20 + 22

add erhält zwei i64-Parameter und gibt ihre Summe als i64 zurück. main ruft add(20, 22) auf; der Rückgabewert ist 42. Das Ergebnis ist hier der Prozess-Exitcode, keine Konsolenausgabe.

fn add(a: i64, b: i64): i64 {
    return a + b;
}

fn main(): i64 {
    return add(20, 22);
}

Erwarteter Exitcode: 42

PBXB64.exe params.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Kanonischer Testfall mit erwartetem Ergebnis; hier keine neue native V22-Prüfung. Finale Ausführung noch ausstehend.

3. Eine Schleife mit break beenden

i beginnt bei 0 und wird vor der Prüfung erhöht. Bei i = 25 verlässt break die Schleife sofort. Die nominelle Grenze 100 wird daher nicht erreicht; main liefert 25.

fn main(): i64 {
    let i: i64 = 0;
    while i < 100 {
        i = i + 1;
        if i == 25 {
            break;
        }
    }
    return i;
}

Erwarteter Exitcode: 25

PBXB64.exe loop_control.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Kanonischer Testfall mit erwartetem Ergebnis; hier keine neue native V22-Prüfung. Finale Ausführung noch ausstehend.

4. Klammerung und Bitverschiebung

Ablauf Schritt für Schritt

1. Die Addition wird vor der Verschiebung ausgewertet.
2. 1 + 2 ist 3; 3 << 3 verschiebt um drei Bitstellen nach links.
3. main liefert 24 als Exitcode, nicht als Textausgabe.

fn main(): i64 {
    return 1 + 2 << 3;
}

Erwarteter Exitcode: 24

PBXB64.exe b64-precedence.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

5. Eine globale Konstante

Ablauf Schritt für Schritt

1. const legt ANSWER mit dem Typ i64 und dem Wert 42 fest.
2. main liest denselben Namen aus dem globalen Gültigkeitsbereich.
3. Es gibt keine veränderliche globale Variable und keine Konsolenausgabe.

const ANSWER: i64 = 42;

fn main(): i64 {
    return ANSWER;
}

Erwarteter Exitcode: 42

PBXB64.exe b64-global_data.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

6. Adresse und Dereferenzierung

Ablauf Schritt für Schritt

1. g ist eine globale i64-Variable mit dem Wert 5.
2. &g erzeugt ihre Adresse; p hat den passenden Zeigertyp *i64.
3. *p liest den Wert an dieser Adresse und liefert 5.

var g: i64 = 5;

fn main(): i64 {
    let p: *i64 = &g;
    return *p;
}

Erwarteter Exitcode: 5

PBXB64.exe b64-address_of_global.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

7. Zwei Rückgabepfade mit if/else

Ablauf Schritt für Schritt

1. x ist 10, daher ist x > 5 wahr.
2. Der erste Zweig gibt 42 zurück und beendet main sofort.
3. Der alternative Rückgabewert 0 würde nur bei einer falschen Bedingung erreicht.

fn main(): i64 {
    let x: i64 = 10;
    if x > 5 {
        return 42;
    } else {
        return 0;
    }
}

Erwarteter Exitcode: 42

PBXB64.exe b64-if_else.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

8. Fünf Funktionsparameter

Ablauf Schritt für Schritt

1. sum5 benennt fünf getrennte i64-Parameter.
2. Der Aufruf übergibt 1, 2, 3, 4 und 5 in dieser Reihenfolge.
3. Die Summe 15 wird über den Rückgabewert an main und dann an den Prozess weitergegeben.

fn sum5(a: i64, b: i64, c: i64, d: i64, e: i64): i64 {
    return a + b + c + d + e;
}

fn main(): i64 {
    return sum5(1, 2, 3, 4, 5);
}

Erwarteter Exitcode: 15

PBXB64.exe b64-five_args.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

9. Division und Rest gemeinsam prüfen

Ablauf Schritt für Schritt

1. 81 / 3 liefert 27; die Prozentoperatoren ergeben 0, 2 und 2.
2. && verlangt, dass alle vier Einzelprüfungen zutreffen.
3. Nur dann liefert main 27; andernfalls liefert es 0.

fn main(): i64 {
    let q: i64 = 81 / 3;
    let r1: i64 = 100 % 5;
    let r2: i64 = 100 % 7;
    let r3: i64 = 17 % 5;
    if (q == 27 && r1 == 0 && r2 == 2 && r3 == 2) {
        return 27;
    }
    return 0;
}

Erwarteter Exitcode: 27

PBXB64.exe b64-div_rem.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

10. Ein benannter Arraytyp

Ablauf Schritt für Schritt

1. Triple ist ein Array aus drei i64-Werten; Again ist ein Alias desselben Typs.
2. Die Initialisierung speichert 10, 11 und 21 an den Indizes 0, 1 und 2.
3. sizeof(Again) wird auf 24 Byte geprüft; die Elemente ergeben zusammen 42.

typedef [3]i64 Triple;
typedef Triple Again;

fn main(): i64 {
    let x: Again = [10, 11, 21];
    if (sizeof(Again) == 24) {
        return x[0] + x[1] + x[2];
    }
    return 0;
}

Erwarteter Exitcode: 42

PBXB64.exe b64-array_typedef_shape.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

11. Gleitkommawert in einer Struktur

Ablauf Schritt für Schritt

1. FloatBox besitzt ein f64-Feld namens value.
2. Sowohl x als auch box.value werden mit dem Zahlenwert 21 initialisiert.
3. Die beiden Vergleiche mit 21.0 müssen wahr sein, damit main 42 liefert.

struct FloatBox { value: f64 }

fn main(): i64 {
    let x: f64 = 21;
    let box: FloatBox = FloatBox { value: 21 };
    if (x == 21.0 && box.value == 21.0) {
        return 42;
    }
    return 0;
}

Erwarteter Exitcode: 42

PBXB64.exe b64-scalar_struct_float_init.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

12. Ein Name in zwei Gültigkeitsbereichen

Ablauf Schritt für Schritt

1. Die äußere Variable value enthält 40.
2. Der innere Block legt eine eigene gleichnamige Variable mit dem Wert 2 an und prüft sie.
3. Nach dem Block bezeichnet value wieder die äußere Variable: 40 + 2 ergibt 42.

fn main(): i64 {
    let value: i64 = 40;
    {
        let value: i64 = 2;
        if value != 2 {
            return 100;
        }
    }
    return value + 2;
}

Erwarteter Exitcode: 42

PBXB64.exe b64-b64_types_shadowing.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

Großes Beispiel: Operatoren, Literale und Funktionsaufruf

Ablauf Schritt für Schritt

1. Die Änderungsoperatoren führen 0 über 10, 8, 24, 12 und 5; die beiden Verschiebungen führen wieder zu 5.
2. 'A' liefert 65, 0xFF liefert 255 und ~15 ist beim vorzeichenbehafteten Wert -16.
3. helper hat keinen Rückgabewert. Der wahre Zweig gibt 5 + 65 + 255 - 16 = 309 zurück.

// B64 lexer-coverage fixture: exercises keywords, operators, literals and comments.
typedef i64 MyInt;

fn helper(v: i64): void {
    return;
}

fn main(): i64 {
    let mut_a: i64 = 0;
    mut_a += 10;
    mut_a -= 2;
    mut_a *= 3;
    mut_a /= 2;
    mut_a %= 7;
    mut_a <<= 1;
    mut_a >>= 1;
    let b: bool = true;
    let c: i64 = 'A';
    let hex: i64 = 0xFF;
    let neg: i64 = ~15;
    let not_b: bool = !b;
    helper(c);
    /* block comment */
    if (b || not_b) {
        return mut_a + c + hex + neg;
    }
    return 0;
}

Erwarteter Exitcode: 309

PBXB64.exe b64-lexer_coverage.b64 -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.