postscript => Fehlerbehandlung

Syntax

{ -code- } gestoppt { -error- } { -no-error- } ifelse% Fehler beim Abrufen des Frames
$ error / errorname get% stackunderflow typecheck rangecheck etc
$ error / newerror% bool erhalten. setze false um den Fehler zu deaktivieren
$ error / ostack get% Kopie des Operanden-Stacks zum Zeitpunkt des Fehlers
errordict / stackoverflow { -additional-code- / stackoverflow signalerror} put
% führt zusätzlichen Code für Fehlerarten aus (hier den / stackoverflow-Fehler).

Bemerkungen

Die Fehlerbehandlung in Postscript umfasst zwei Ebenen. Diese Zweiteilung bezieht sich sowohl auf die Art und Weise, wie der Interpreter mit Fehlern umgeht, als auch auf die Mittel, die dem Benutzer (Programmierer) zur Verfügung stehen, um die Handhabung zu steuern.

Die untere Ebene ist eine ungewöhnliche Steuerungsstruktur, stop ... stopped . stopped , ähnlich wie bei einem Looping in verhält sich konstruieren , dass sie eine Markierung auf dem Ausführungsstapel legt , die gesprungen werden, wenn der exit Operator (eine Schleife) oder stop - Operator (nach einem stopped -Kontext) aufgerufen wird. Im Gegensatz zu einem Schleifenkonstrukt, stopped ergibt eine Boolsche auf dem Stapel anzeigt , ob stop (andernfalls die Prozedur aufgerufen wurde weitergegeben stopped ist bekannt, zur Vollständigkeit ausgeführt worden.

Wenn ein Postscript - Fehler auftritt, wie stackunderflow vielleicht sucht der Interpreter der Fehler Namen in bis errordict , die lebt systemdict . Wenn der Benutzer die Prozedur nicht in errordict , erstellt die Standardfehlerprozedur Momentaufnahmen des gesamten Stapels und platziert sie in $error , einem anderen Wörterbuch in systemdict . Schließlich ruft die Standardprozedur stop wodurch das Benutzerprogramm aus dem Exec-Stack gezogen wird und die Fehlerdruckprozedur des Interpreters, die als handleerror errordict .

Wenn Sie all dieses Wissen verwenden, können Sie Fehler abfangen , indem Sie einen Codeabschnitt in { ... } stopped . Sie können durch den Aufruf eines Fehler erneut auslösen stop . Sie können feststellen, welche Art von Fehler mit $error /errorname get .

Sie können das Standardverhalten für einen bestimmten Fehlertyp auch ändern, indem Sie die Prozedur durch diesen Namen in errordict . Oder ändern Sie das Format für das Drucken des Fehlerberichts, indem Sie /handleerror im errordict Format errordict .

Gibt es einen aktuellen Punkt?

Ausbeute true auf dem Stapel , wenn currentpoint erfolgreich ausgeführt wird , oder false , wenn es einen signalisiert /nocurrentpoint Fehler.

{currentpoint pop pop} stopped not  % bool

Folge von Ereignissen, wenn ein Fehler gemeldet wird

Die Reihenfolge für einen Fehler lautet normalerweise:

Fehler wird ausgelöst, indem der errordict in errordict und diese Prozedur ausgeführt wird.
Die errordict ruft den signalerror und übergibt ihm den signalerror .
signalerror Momentaufnahmen der Stapel, speichert die Momentaufnahmen in $error und ruft dann die Aufrufe stop .
stop öffnet den Exec-Stack, bis der nächstliegende umschließende gestoppte Kontext vom gestoppten Operator festgelegt wird.
Wenn das Programm keinen eigenen angehaltenen Kontext zum Abfangen des Fehlers erstellt hat, wird es von einem äußeren stopped { errordict /handleerror get exec } if der vom stopped { errordict /handleerror get exec } if das gesamte Benutzerprogramm stopped { errordict /handleerror get exec } if .
handleerror verwendet die Informationen in $error , um einen Fehlerbericht zu drucken.

Fehler melden

Die meisten Werkzeuge sind standardisiert, mit Ausnahme des Namens des Bedieners, der einen Fehler auslöst. In Adobe-Interpreten wird dies als .error . In Ghostscript wird es signalerror . Mit dieser Zeile können Sie den signalerror in Postscript-Code für Adobe-Interpreter oder Ghostscript oder xpost verwenden.

/.error where {pop /signalerror /.error load def} if

Befehlsname Fehlername Signalfehler -
Machen Sie Momentaufnahmen des Stapels in $error und stop dann.

Z.B.

% my proc only accepts integer
/proc {
    dup type /integertype ne {
        /proc cvx /typecheck signalerror
    } if
    % ... rest of proc ...
} def

Fehler abfangen

Da die letzte Aktion des Standardfehlerhandlers der Aufruf von stop , können Sie Fehler von Operatoren abfangen, indem Sie Code in ein { ... } stopped stop Konstrukt einschließen.

{
    0 array
    1 get
} stopped {
    $error /errorname get =
} if

gibt " rangecheck " aus, der Fehler wird durch get rangecheck , wenn der Index außerhalb des zulässigen Bereichs für dieses Array liegt.

Fehler erneut werfen

Dieses Snippet implementiert eine Prozedur, die sich wie ein PostScript-Schleifenoperator verhält. Wenn der Benutzer proc das exit aufruft, wird der Fehler invalidexit abgefangen, um den Dictstack am end zu beheben. Alle anderen Fehler außer invalidexit durch Aufruf von stop erneut ausgelöst.

% array n proc  .  -
% Like `forall` but delivers length=n subsequences produced by getinterval
/fortuple { 4 dict begin
    0 {offset proc n arr} {exch def} forall
    /arr load length n idiv
    {
        {
            /arr load offset n getinterval
            [ /proc load currentdict end /begin cvx ] cvx exec
            /offset offset n add def
        } stopped {
            $error /errorname get /invalidexit eq
            { 1 dict begin exit }{ stop } ifelse
        } if
    } repeat
end
} def

%[ 0 1 10 {} for ] 3 {} fortuple pstack clear ()=

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

postscript
Fehlerbehandlung

Suche…