Die Form Machine
I. Formen
Eine Form ist eine geordnete Menge von Regeln.
F = {R1, ...,Rn}
Die erste Regel (R1) ist die Regel mit der höchsten Priorität; die letzte Regel (Rn) ist die Regel mit der niedrigsten Priorität.
Die Form Machine erhält als Eingabe: 1) eine Liste von Adressen und Längen, die den/die Eingabestrom/-ströme begrenzen; 2) eine Liste von Adressen und Längen, die den/die Ausgabebereich(e) begrenzen; 3) einen Zeiger auf eine Liste von Form(en); 4) einen Zeiger auf die Startposition des Eingabestroms; und 5) einen Zeiger auf die Startposition des Ausgabebereichs. Die Form Machine wendet eine Form auf die Eingabezeichenkette an und gibt eine Ausgabezeichenkette im Ausgabebereich aus. Die Form wird auf folgende Weise angewendet:
Schritt 1: R1 wird zur aktuellen Regel gemacht.
Schritt 2: Die aktuelle Regel wird auf die Eingabedaten angewendet.
Schritt 3: a) Wenn die Regel fehlschlägt, wird die Regel mit der um eins niedrigeren Priorität zur aktuellen gemacht.
b) Wenn die Regel erfolgreich ist, wird die Regel mit der höchsten Priorität zur aktuellen gemacht
c) Wenn die Regel mit der niedrigsten Priorität fehlschlägt, schlägt die Form fehl und die Anwendung der Form auf die Eingabedaten endet.
Schritt 4: Weiter mit Schritt 2.
Darüber hinaus gilt: Wenn während Schritt 2 der Rest der Eingabezeichenkette nicht ausreicht, um eine Regel zu erfüllen, dann schlägt diese Regel fehl und Teilresultate werden nicht ausgegeben. Wenn eine Regel die Ausgabezeichenkette füllt, wird die Anwendung der Form beendet.
II. Regeln
Eine Regel ist eine Ersetzungsoperation der Form:
left-hand-side -> right-hand-side
Beide Seiten einer Regel bestehen aus einer Folge von null oder mehr Termen (siehe unten), die durch Kommas getrennt sind.
Die linke Seite der Regel wird an der aktuellen Position als Mustervergleichsoperation auf die Eingabezeichenkette angewendet. Wenn sie die Eingabe exakt beschreibt, wird 1) der Zeiger der aktuellen Eingabeposition über die übereinstimmende Eingabe vorgerückt, 2) gibt die rechte Seite Daten an der aktuellen Position in der Ausgabezeichenkette aus, und 3) wird der Zeiger der aktuellen Ausgabeposition über die ausgegebenen Daten vorgerückt.
III. Terme
Ein Term ist eine Variable, die die abzugleichende Eingabezeichenkette oder die auszugebende Ausgabezeichenkette beschreibt. Ein Term hat drei Formate.
Termformat 1
+---------------------------------------------------------------------+
| |
| name ( data replication . value : length ) |
| type expression expression expression |
| |
|_____________________________________________________________________|
Jedes der Felder kann fehlen.
Der Name ist ein symbolischer Name des Terms im üblichen Sinn einer Programmiersprache. Er ist ein einzelnes alphabetisches Kleinbuchstabenzeichen, das innerhalb einer Regel eindeutig ist.
Der Datentyp beschreibt die Art der Daten, die der Term repräsentiert. Er ist ein Mitglied der Menge:
{D, O, X, A, E, B}
Datentypen haben die folgenden Bedeutungen und implizierten Einheitslängen:
Char. Meaning Length
----- -------- -------
D decimal number 1 bit
O octal number 3 bits
X hexadecimal number 4 bits
A ASCII character 8 bits
E EBCDIC character 8 bits
B binary number 1 bit
Der Replikationsausdruck ist ein Multiplikator des Wertausdrucks. Ein Replikationsausdruck hat die Formate.
- einen arithmetischen Ausdruck der Mitglieder der Menge:
{v(name), L(name) , numerals, programming variables}
Das v(name) ist ein Wertoperator, der einen numerischen Wert des benannten Datentyps erzeugt, und L(name) ist ein Längenoperator, der einen numerischen Wert der benannten Zeichenkettenlänge erzeugt.
Die Programmiervariable wird unter Termformat drei beschrieben. Die arithmetischen Operatoren sind unten gezeigt und haben ihre üblichen Bedeutungen.
{*, /, +, -}
oder 2) das Terminal '#', das ein beliebiges Vielfaches des Wertausdrucks bedeutet.
Der Wertausdruck ist der Einheitswert eines Terms, ausgedrückt im durch den Datentyp angegebenen Format. Der Wertausdruck wird gemäß dem Replikationsausdruck wiederholt. Ein Wertausdruck hat das Format:
- wie Teil 1) des Replikationsausdrucks, wobei wieder v(name) einen numerischen Wert erzeugt
oder 2) ein einzelnes Mitglied der Menge
{v(name), quoted literal}
wobei v(name) einen Wert vom Datentyp (E oder A) erzeugt). (Beachten Sie, dass Verkettung durch mehrere Terme erreicht wird.)
Der Längenausdruck ist die Länge des Feldes, das den durch den Replikationsausdruck modifizierten Wertausdruck enthält. Er hat dieselben Formate wie ein Replikationsausdruck.
Somit ist der Term
x(E(7.'F'):L(x)) heißt x, ist vom Typ EBCDIC, hat den Wert 'FFFFFFF' und hat die Länge 7.
Der Term
y(A:8) auf der linken Seite einer Regel würde die nächsten 64 Bits der Eingabe als seinen Wert zugewiesen bekommen; auf der rechten Seite würde es lediglich bewirken, dass der Ausgabezeiger um 64 Bitpositionen vorgerückt wird, da es keinen Wertausdruck (Inhalt) hat, um Daten im Ausgabebereich zu erzeugen.
Termformat 2
+---------------------------------------------------------------------+
| |
| name (label) |
| |
+---------------------------------------------------------------------+
Die Marke ist eine symbolische Referenz auf einen zuvor benannten Term in der Regel. Sie hat denselben Wert wie der Term mit diesem Namen.
Die unten stehende Identitätsoperation veranschaulicht die Verwendung der Marken-Notation.
a(A:10) -> (a)
Das (a) auf der rechten Seite bewirkt, dass der Term a im Ausgabebereich ausgegeben wird. Es ist äquivalent zu der unten stehenden Regel.
a(A:10) -> (Av(a):L(a))
Termformat 3
+---------------------------------------------------------------------+
| |
| name ( programming connective operand ) |
| variable expression |
| |
+---------------------------------------------------------------------+
Eine Programmiervariable ist ein benutzergesteuertes Datenelement, das nicht explizit in den Eingabe-/Ausgabeströmen erscheint. Ihr Wert kann mit Eingabedaten, mit Konstanten verglichen und zum Erzeugen von Ausgabedaten verwendet werden. Programmiervariablen sind einzelne griechische Kleinbuchstabensymbole.
Sie werden verwendet: um Indizes, Zähler usw. im Ausgabebereich zu erzeugen; um Indizes, Zähler usw. im Eingabebereich zu vergleichen, und; um Ersetzungsregeln zu binden, wo die Daten kontextsensitiv sind (später erklärt).
Ein Verknüpfungszeichen ist ein Mitglied der Menge:
{<-, =, !=, >=, <=, <, >}
Der Linkspfeil bezeichnet die Ersetzung des linken Teils durch den rechten Teil; die anderen Verknüpfungszeichen sind Vergleichsoperatoren.
Der Operandenausdruck ist ein arithmetischer Ausdruck von Mitgliedern der Menge:
{programming variables, v(name), l(name), numerals}
Zum Beispiel, wenn die Programmiervariable [alpha] den Wert 0 hat und die Regel
a(H[alpha]:1) -> (a), ([alpha]<-[alpha]+1), (H[alpha]:1)
erschöpfend auf eine Zeichenkette hexadezimaler Ziffern angewendet wird
0 1 2 3 4 5
wäre die Ausgabe die hexadezimale Zeichenkette
0 1 1 2 2 3 3 4 4 5 5 6 .
Hinweis: Die obige Regel ist äquivalent zu
a(B[alpha]:4) -> (a), ([alpha]<-[alpha]+1), (B[alpha]:4)
IV. Einschränkungen und Interpretationen von Termfunktionen
Wenn eine Regel erfolgreich ist, wird Ausgabe erzeugt. In der Regel
a(A:#),(A'/':1)->(Ev(a):74),(E'?':1)
wird die Eingabezeichenkette nach einer beliebigen Anzahl von ASCII-Zeichen gefolgt von einem Terminal '/' durchsucht. Die ASCII-Zeichen (a) werden in einem 74-Byte-Feld in EBCDIC umgewandelt, gefolgt von einem Terminal '?'. Dies bringt drei Probleme zum Vorschein:
-
Terme beliebiger Länge müssen durch Literale getrennt werden, da die Daten nicht typspezifisch sind.
-
Das # darf nur auf der linken Seite einer Regel verwendet werden.
-
Ein Abschneide-/Auffüllschema ist erforderlich.
Das Abschneide-/Auffüllschema ist wie folgt:
-
Zeichen zu Zeichen (Typen: A, E) Die Ausgabe ist linksbündig mit Abschneiden oder Auffüllen (mit Leerzeichen) auf der rechten Seite.
-
Zeichen zu Numerisch (A, E zu D, O, H, B)
-
Numerisch zu Zeichen (D, O, H, B zu A, E)
-
Numerisch zu Numerisch (D, O, H, B) Die Ausgabe ist rechtsbündig mit Auffüllen oder Abschneiden auf der linken Seite. Das Auffüllen erfolgt mit Nullen, wenn die Ausgabe numerisch ist.