This page in English

Fehler ​

c0de hat keine Exceptions, keinen try- und keinen catch-Block. Trotzdem verhalten sich Fehler ganz ähnlich wie Exceptions: Eine Funktion, die scheitert, hält an, und ihr Fehler wandert die Aufrufe hinauf, bis ein Aufrufer ihn abfängt. Das Abfangen passiert beim CALL, mit einer Variablen vom Typ ERROR. Fängt ihn niemand ab, stürzt der Prozess ab, und der Auslöserblock zeigt den Fehler.

Was du brauchst

Eine Kreativwelt mit erlaubten Cheats (siehe Tutorials), einen Auslöserblock, einen Schraubenschlüssel, einen Knopf, eine STRING-Variablenkarte mit dem Namen input, eine nicht initialisierte Variablenkarte und für den Exit-Code einen Komparator und eine Redstone-Lampe. Für die Übungen: zwei INTEGER-Variablenkarten mit den Namen total und count.

Das Modell ​

  • Ein ausgelöster Fehler beendet die Funktion. Eine Division durch null, ein fehlender Schlüssel oder ein RAISE beendet die aktuelle Funktion, als hätte sie RETURN mit diesem Fehler ausgeführt.
  • Der Aufrufer entscheidet. Hat sein CALL eine ERROR-Variable hinter dem Funktionsnamen (CALL parseAge problem), kommt der Fehler in diese Variable, und der Aufrufer macht weiter. Sonst wird der Fehler im Aufrufer erneut ausgelöst, der damit auch endet, und so weiter die Aufrufe hinauf.
  • Die Einstiegsfunktion ist die letzte Station. Ein Fehler, der sie erreicht, lässt den Prozess abstürzen: Exit-Code 15, keine Ergebnisse, und alle Karten, die hineingegangen sind, kommen unverändert heraus.
  • Manche Fehler lassen sich nicht abfangen. Fehler im Programm selbst (eine rote Zeile, Codes 100 bis 114) und die Fehler des Cursors (Codes 200 bis 206, z. B. STACK_OVERFLOW, ein fehlender Parameter oder eine unbekannte Funktion) lassen den Prozess sofort abstürzen.

Ein Fehler ist eine vordefinierte Struktur mit vier Elementen:

ElementTypInhalt
codeINTEGER0, wenn es keinen Fehler gab
messageSTRINGder Text des Fehlers
contextSTRINGdie Funktion, in der er ausgelöst wurde
lineINTEGERdie Zeile, in der er ausgelöst wurde

Die Codes der Sprache liegen unter 1000 und haben Namen, die eingebaute Konstanten sind. Das sind die, die ein CALL abfangen kann:

CodeNameWann
300UNKNOWN_NAMEein Name, der nicht im Gültigkeitsbereich ist
301UNKNOWN_STRUCT_ENTITYein Element, das die Struktur nicht hat
302TYPE_MISMATCHein Wert vom falschen Typ
303DIVISION_BY_ZERO/ oder \ durch 0
304NUMERIC_OVERFLOWein INTEGER über 64 Bit hinaus
305INDEX_OUT_OF_BOUNDSeine Position außerhalb eines Arrays oder Strings
306UNKNOWN_KEYein Schlüssel, den der Hash nicht hat
307STRING_TOO_LONGein Wert, der länger ist als die Grenze seines STRINGs
308INVALID_LOOP_STEPeine FOR-Schleife mit der Schrittweite 0
309INVALID_ARGUMENTein Parameterwert, mit dem eine Funktion nichts anfangen kann
310 – 313CHUNK_NOT_LOADED, PERMISSION_DENIED, INVENTORY_FULL, ITEM_MISSINGFehler von c0de/minecraft

Deine eigenen Fehler verwenden Codes ab 1000.

In Python sähe das Programm dieser Lektion so aus:

python
class AgeError(Exception): ...

def parse_age(text: str) -> int:
    number = float(text)               # ValueError für "abc"
    if not number.is_integer():
        raise AgeError(1001, "not a whole number: " + text)
    age = int(number)
    if age < 0 or age > 150:
        raise AgeError(1002, "out of range: " + str(age))
    return age

def signup(input: str) -> str:
    try:
        parse_age(input)
        return "Welcome!"
    except Exception as problem:
        return "Error: " + str(problem)

Das Programm ​

c0de
PROGRAM signup
NOOP
INCLUDE c0de/math
INCLUDE c0de/strings
CONSTANT AGE_NOT_WHOLE INTEGER 1001
CONSTANT AGE_OUT_OF_RANGE INTEGER 1002
NOOP
FUNCTION parseAge
    PARAMETER text STRING
    RESULT age INTEGER
BEGIN
    VARIABLE number FLOAT
    VARIABLE whole BOOLEAN
    CALL c0de/strings/VAL
        PARAMETER text text ;
        RESULT value number
        RESULT isInteger whole
    IF NOT whole ;
    BEGIN
        CALL RAISE
            PARAMETER code AGE_NOT_WHOLE ;
            PARAMETER message "not a whole number: " ⊕ text ;
    END IF
    CALL c0de/math/FIX
        PARAMETER value number ;
        RESULT result age
    IF age < 0 OR age > 150 ;
    BEGIN
        CALL RAISE
            PARAMETER code AGE_OUT_OF_RANGE ;
            PARAMETER message "out of range: " ⊕ age ;
    END IF
END FUNCTION
NOOP
FUNCTION signup
    PARAMETER input STRING
    RESULT message STRING
    RESULT age INTEGER
BEGIN
    VARIABLE problem ERROR
    CALL parseAge problem
        PARAMETER text input ;
        RESULT age age
    IF problem.code = 0 ;
    BEGIN
        ASSIGN message "Welcome!" ;
        RETURN
    END IF
    ASSIGN message "Error " ⊕ problem.code ⊕ ": " ⊕ problem.message ⊕ " (" ⊕ problem.context ⊕ ", line " ⊕ problem.line ⊕ ")" ;
    EXIT 1 ;
END FUNCTION

Starten ​

Stelle den Auslöserblock auf das Programm signup und die Funktion signup ein. Lege die Karte input und eine nicht initialisierte Karte hinein und stelle einen Komparator auf, der den Auslöserblock ausliest, mit einer Lampe dahinter.

inputmessageageExit-Code
"42"Welcome!420
"4.5"Error 1001: not a whole number: 4.5 (parseAge, line 19)01
"200"Error 1002: out of range: 200 (parseAge, line 28)2001
"abc"Error 309: Not a number: abc (c0de/strings/VAL, line 13)01

Bei Exit-Code 1 gibt der Komparator ein Signal der Stärke 1 aus, und die Lampe leuchtet, bis der nächste Prozess startet.

Stelle den Auslöserblock jetzt auf die Funktion parseAge ein und benenne die Karte input in text um, mit dem Wert "200". Niemand fängt den Fehler ab: Der Prozess stürzt mit Exit-Code 15 ab, der Auslöserblock spielt einen tiefen Ton, und sein Dialog zeigt den Code 1002, die Meldung out of range: 200, den Kontext parseAge und die Zeile 28. Die Karte text und die nicht initialisierte kommen unverändert heraus.

So funktioniert es ​

  • Eigene Fehler mit RAISE. CALL RAISE mit einem code ab 1000 und einer message gibt einen Fehler an seinen Aufrufer parseAge. Dieser CALL hat keine ERROR-Variable, also wird der Fehler in parseAge ausgelöst, das sofort endet. RAISE füllt context und line mit der Funktion und der Zeile des CALL. Ein Code unter 1000 löst stattdessen INVALID_ARGUMENT aus.
  • Konstanten für die Codes. Die globalen Konstanten AGE_NOT_WHOLE und AGE_OUT_OF_RANGE geben den Codes Namen, wie die eingebauten Namen der Fehler der Sprache. Ein Aufrufer kann problem.code = AGE_OUT_OF_RANGE ; vergleichen.
  • Fehler von Bibliotheksfunktionen. VAL löst für "abc" INVALID_ARGUMENT aus. parseAge fängt ihn nicht ab, also wandert er weiter zu signup. Er behält seinen context und seine line: Sie beschreiben immer, wo der Fehler zuerst aufgetreten ist, hier die Bibliotheksfunktion c0de/strings/VAL, aufgerufen in Zeile 13.
  • Abfangen. CALL parseAge problem legt den Fehler in problem. Die Variable bekommt den Fehler jedes Aufrufs, mit Code 0, wenn es keinen gab, also ist IF problem.code = 0 ; die Erfolgsprüfung.
  • Ergebnisse überleben. Für "200" ist age 200, obwohl parseAge gescheitert ist: Der Aufrufer bekommt die Werte, die die Ergebnisse hatten, als die Funktion anhielt. Prüfe den Fehler, bevor du sie verwendest.
  • Exit-Codes für Redstone. EXIT 1 ; beendet den Prozess mit Exit-Code 1. Anders als bei einem Absturz werden die Ergebnisse wie gewohnt ins Ausgabeinventar geschrieben. EXIT nimmt 0 bis 15; 15 ist der Code eines Absturzes.

Unterschiede, über die du stolpern wirst ​

  • Es gibt keinen try-Block. Um einen Fehler abzufangen, muss der Code, der scheitern kann, in einer eigenen Funktion stehen, die mit einer ERROR-Variablen aufgerufen wird.
  • Ein CALL ohne ERROR-Variable reicht jeden Fehler weiter. Eine vergessene Variable, und der ganze Prozess stürzt ab.
  • Fehler haben keine Typen. Unterscheide sie am code, nicht an einer Klasse.
  • Ergebnisse werden auch zugewiesen, wenn die Funktion gescheitert ist. Vertraue ihnen nicht, bevor du code geprüft hast.
  • RAISE füllt context und line aus; eine ERROR-Variable, die du selbst füllst und mit RETURN problem zurückgibst, lässt sie leer, wenn du sie nicht setzt.
  • Syntaxfehler, STACK_OVERFLOW, ein fehlender Parameter und die anderen Fehler mit Codes unter 300 lassen sich nicht abfangen.
  • Ein Absturz verliert alle Ergebnisse. Wenn Redstone auf ein behandeltes Problem reagieren soll, verwende EXIT mit einem Code von 1 bis 14.

Probier es selbst ​

  1. Ersetze das RAISE der Bereichsprüfung in parseAge durch eine ERROR-Variable und RETURN. Wie sieht die Meldung für "200" jetzt aus?
Lösung
c0de
PROGRAM signup
NOOP
INCLUDE c0de/math
INCLUDE c0de/strings
CONSTANT AGE_NOT_WHOLE INTEGER 1001
CONSTANT AGE_OUT_OF_RANGE INTEGER 1002
NOOP
FUNCTION parseAge
    PARAMETER text STRING
    RESULT age INTEGER
BEGIN
    VARIABLE number FLOAT
    VARIABLE whole BOOLEAN
    CALL c0de/strings/VAL
        PARAMETER text text ;
        RESULT value number
        RESULT isInteger whole
    IF NOT whole ;
    BEGIN
        CALL RAISE
            PARAMETER code AGE_NOT_WHOLE ;
            PARAMETER message "not a whole number: " ⊕ text ;
    END IF
    CALL c0de/math/FIX
        PARAMETER value number ;
        RESULT result age
    IF age < 0 OR age > 150 ;
    BEGIN
        VARIABLE problem ERROR
        ASSIGN problem.code AGE_OUT_OF_RANGE ;
        ASSIGN problem.message "out of range: " ⊕ age ;
        RETURN problem
    END IF
END FUNCTION
NOOP
FUNCTION signup
    PARAMETER input STRING
    RESULT message STRING
    RESULT age INTEGER
BEGIN
    VARIABLE problem ERROR
    CALL parseAge problem
        PARAMETER text input ;
        RESULT age age
    IF problem.code = 0 ;
    BEGIN
        ASSIGN message "Welcome!" ;
        RETURN
    END IF
    ASSIGN message "Error " ⊕ problem.code ⊕ ": " ⊕ problem.message ⊕ " (" ⊕ problem.context ⊕ ", line " ⊕ problem.line ⊕ ")" ;
    EXIT 1 ;
END FUNCTION

Die Meldung ist Error 1002: out of range: 200 (, line 0): Ein Fehler, den du selbst baust, hat einen leeren context und die Zeile 0, wenn du sie nicht zuweist. RAISE füllt sie für dich aus.

  1. Schreibe eine Funktion report mit den Parametern total und count, die den Text average: … zurückgibt oder no values yet, wenn count 0 ist. Lass die Division scheitern und fange DIVISION_BY_ZERO ab.
Lösung
c0de
PROGRAM averages
NOOP
NOOP
FUNCTION average
    PARAMETER total INTEGER
    PARAMETER count INTEGER
    RESULT result FLOAT
BEGIN
    ASSIGN result total / count ;
END FUNCTION
NOOP
FUNCTION report
    PARAMETER total INTEGER
    PARAMETER count INTEGER
    RESULT text STRING
BEGIN
    VARIABLE problem ERROR
    VARIABLE mean FLOAT
    CALL average problem
        PARAMETER total total ;
        PARAMETER count count ;
        RESULT result mean
    IF problem.code = DIVISION_BY_ZERO ;
    BEGIN
        ASSIGN text "no values yet" ;
    END
    ELSE
    BEGIN
        ASSIGN text "average: " ⊕ mean ;
    END IF
END FUNCTION

Mit total = 7 und count = 2 ist der Text average: 3.5; mit count = 0 ist er no values yet. Die Division braucht eine eigene Funktion, weil nur ein CALL einen Fehler abfangen kann.

Mehr dazu ​