allegro-C Logo

allegro - Manipulationsbefehle

Vorbemerkungen

Die Manipulationsbefehle der allegro-Exportsprache sind ein vielseitiges Werkzeug zur Gestaltung des Exporttextes. Nachfolgend soll versucht werden, den Umgang mit diesem Werkzeug näher zu beschreiben. Dafür legen wir folgende Begriffe fest:

Anweisung
eine Zeile im Exportparameterfile, die mit # oder ! eingeleitet wird;

Befehl
einer oder mehrere Manipulationsbefehle (durch je ein Leerzeichen getrennt);

Arbeitstext
(Abk.: AT) augenblicklicher Inhalt der Zeichenkette, den eine Anweisung ausgeben soll. Bei Beginn einer Anweisung ist es eine Kopie der angegebenen Kategorie, beginnend mit der Position ks . (Die Konstante ks gilt global für alle Anweisungen.)

Der Arbeitstext wird verändert, wenn eine Anweisung Manipulationsbefehle enthält. Nach Abarbeitung dieser Befehle (das geschieht von links nach rechts) wird in der Regel der dann entstandene Arbeitstext ausgegeben:

Ausgabe
Übergabe an die Ausgaberoutine, die den Zeilenumbruch vornimmt. Der Arbeitstext wird an den bereits vorher produzierten Text angeschlossen und in der voreingestellten Zeilenstruktur umgebrochen.

Die Manipulationsbefehle bilden fünf Gruppen mit unterschiedlichen Wirkungen:

Gruppe 1:
Manipulationsbefehle im engeren Sinne - sie verändern den Arbeitstext und sind in der Regel wiederholbar.

Gruppe 2:
Befehle zum Umgang mit Anwendervariablen - sie sind ebenfalls in einer Anweisung wiederholbar, und ihre Wirkungen erfolgen in der Reihenfolge der Abarbeitung. Da sie den Arbeitstext nicht verändern, können sie in die Folge der Befehle der Gruppe 1 problemlos integriert werden;

Gruppe 3:
Befehle mit scheinbarer Manipulationswirkung - sie manipulieren den Arbeitstext nicht, aber sie veranlassen Ausgaben vor bzw. nach der Ausgabe des Arbeitstextes. Alle Befehle der Gruppe 3 in einer Anweisung werden in der Reihenfolge ihres Auftretens realisiert. Befehle der Gruppe 3 können ebenfalls wiederholt werden. Alle Befehle der Gruppen 1 oder 2 werden vor denen der Gruppe 3 ausgeführt;

Gruppe 4:
Prüfbefehle; verschiedene Arten von Prüfungen auf Gleichheit oder Ungleichheit des Arbeitstextes oder einzelner Zeichen. Bei Nichterfüllung wird in der Regel die Anweisung abgebrochen

Gruppe 5:
Steuerbefehle - sie haben keine Wirkung auf den Arbeitstext.

Im Umgang mit dem Arbeitstext gelten diese Regeln:

Hat der Arbeitstext die Länge 0, wird i.a. die Bearbeitung abgebrochen und es erfolgt keine Ausgabe - auch nicht von indirekten Prä- und Postfixen. (Ausnahme: e0 und Z).

Ist der Befehl ausführbar (mit allen Teilbefehlen), wird der dadurch entstehende Arbeitstext ausgegeben und dann der evtl. angegebene bedingte Sprung ausgeführt.

Ist der Befehl nicht ausführbar (d.h. einer der Teilbefehle hat kein Ergebnis), wird die ganze Anweisung ohne Ergebnis abgebrochen, als ob die Kategorie nicht existieren würde; es wird mit der nächsten Zeile fortgefahren.

Vereinbarungen für Bezeichnungen (==> Kap.10.2, S.149)


n  ganze Zahl >= 0                    x, y druckbare Zeichen

k  ganze Zahl zw. 0 und 255 (Byte)    CS   Steuerzeichenkette (==> SHKap.10.2.0)

z  ganze Zahl zw. 0 und 99            X    Zeichenfolge, eingeschlossen in "..." oder

                                           '...'

#xy     eine gültige Kategorienummer.

Manipulationsbefehle - alphabetische Übersicht

Wir verwenden folgende Abkürzungen:

AT = Arbeitstext; AV = Anwendervariable (Sonderkategorie #uxy)

Mit * gekennzeichnete Befehle dürfen innerhalb einer Befehlszeile nur einmal vorkommen.

Die Seitenangeben beziehen sich auf das Systemhandbuch.


+-------------+---+--------------------------------------------------------+-----+

|Befehl       |Typ| Wirkung                                                |Seite|

+-------------+---+--------------------------------------------------------+-----+

|=xy          | 2 | Vergleiche AT mit Inhalt von #uxy und speichere AT in  | 181 |

|             |   | #uxy   gleich: nächster Befehl, ungleich: Ausgabe des  |     |

|             |   | AT und bed.Sprung                                      |     |

+-------------+---+--------------------------------------------------------+-----+

|¦im       *  | 5 | AT als Schlüssel nehmen, im Index i mit Modus m        | 193 |

|             |   | suchen, Aufnahme laden. m=8 oder 9: gefundenen         |     |

|             |   | Schlüssel in #uxi laden                                |     |

+-------------+---+--------------------------------------------------------+-----+

|x           | 1 | Teilfeld x aus AT entnehmen und als neuen AT          | 180 |

|             |   | verwenden                                              |     |

+-------------+---+--------------------------------------------------------+-----+

|,"_X_Y_"     | 1 | Lokale Ersetzung: ersetze im Arbeitstext X durch Y     | 180 |

+-------------+---+--------------------------------------------------------+-----+

|axy          | 2 | AT + #uxy in #uxy speichern (AT nicht ausgeben)        | 181 |

+-------------+---+--------------------------------------------------------+-----+

|Axy          | 2 | #uxy + AT in #uxy speichern (AT nicht ausgeben)        | 181 |

+-------------+---+--------------------------------------------------------+-----+

|bk           | 1 | Beginne AT nach Position n. Wenn AT kürzer ist:        | 178 |

|             |   | Abbruch der Anweisung, keine Ausgabe, kein bedingter   |     |

|             |   | Sprung                                                 |     |

+-------------+---+--------------------------------------------------------+-----+

|bX           | 1 | Beginne AT hinter Zeichenkette X. X nicht vorhanden:   | 178 |

|             |   | Abbruch                                                |     |

+-------------+---+--------------------------------------------------------+-----+

|Bk           | 1 | Beginne AT nach dem n-ten Zeichen. Wenn AT kürzer,     | 178 |

|             |   | dann bleibt er unverändert.                            |     |

+-------------+---+--------------------------------------------------------+-----+

|BX           | 1 | Beginne AT hinter Zeichenkette X;wenn X nicht          | 179 |

|             |   | vorhanden, bleibt AT unverändert                       |     |

+-------------+---+--------------------------------------------------------+-----+

|C            | 5 | Zeilenvorschub vor Ausgabe des AT                      | 183 |

+-------------+---+--------------------------------------------------------+-----+

|cX           | 4 | Prüfe, ob AT die Zeichenkette X enthält. Wenn ja:      | 183 |

|             |   | Anweisung fortsetzen (AT unverändert); wenn nein:      |     |

|             |   | Abbruch                                                |     |

+-------------+---+--------------------------------------------------------+-----+

|dxy          | 2 | Anwendervariable #uxy löschen                          | 181 |

+-------------+---+--------------------------------------------------------+-----+

|ek           | 1 | Beende AT hinter dem nten Zeichen (Sonderfall n=0,     | 179 |

|             |   | siehe Z)                                               |     |

+-------------+---+--------------------------------------------------------+-----+

|Ek           | 1 | wie en , aber letztes Wort weglassen, wenn es sonst    | 179 |

|             |   | zerschnitten würde                                     |     |

+-------------+---+--------------------------------------------------------+-----+

|eX           | 1 | Beende AT vor Zeichenkette X; wenn X nicht vorhanden,  | 179 |

|             |   | bleibt AT unverändert                                  |     |

+-------------+---+--------------------------------------------------------+-----+

|EX           | 1 | Beende AT hinter der Zeichenkette X; wenn X nicht      | 179 |

|             |   | vorhanden, bleibt AT unverändert                       |     |

+-------------+---+--------------------------------------------------------+-----+

|fk / Fk      | 1 | Entferne ASCII-Code k am Anfang/Ende des AT (evtl.     | 179 |

|             |   | mehrere)                                               |     |

+-------------+---+--------------------------------------------------------+-----+

|fx / Fx      | 1 | Entferne Zeichen x am Anfang / Ende des AT (evtl.      | 179 |

|             |   | mehrere)                                               |     |

+-------------+---+--------------------------------------------------------+-----+

|fX / FX      | 1 | Entferne alle in X enthaltenen Zeichen am Anfang/Ende  | 179 |

|             |   | des AT                                                 |     |

+-------------+---+--------------------------------------------------------+-----+

|ik,x         | 4 | Anweisung nur fortsetzen, wenn auf Position k das      | 183 |

|             |   | Zeichen x steht  (Position 1 = erste Kategorieziffer), |     |

|             |   | sonst Abbruch d. Anw.                                  |     |

+-------------+---+--------------------------------------------------------+-----+

|Ik,x         | 4 | Anweisung nur fortsetzen, wenn auf Position k nicht x  | 183 |

|             |   | steht                                                  |     |

+-------------+---+--------------------------------------------------------+-----+

|Kz  kz       | 1 | "Matchcode" bilden, z.B. Titelschlüssel; für Index     | 184 |

|             |   | nutzbar. Beispiel: #20 K4 K2 K2 K1  :  4221-Schlüssel  |     |

|             |   | aus Titel bilden                                       |     |

+-------------+---+--------------------------------------------------------+-----+

|lxy          | 5 | Länge des aktuellen Arbeitstextes in #uxy schreiben    | 183 |

+-------------+---+--------------------------------------------------------+-----+

|mX m{CS}  *  | 3 | Direktes und Indirektes Mehrfachpräfix                 | 178 |

|             |   | (Zeichenkette/Steuerkette)                             |     |

+-------------+---+--------------------------------------------------------+-----+

|m>K       *  | 3 | Unterprogramm #(K vor Mehrfachkategorie ausführen      | 182 |

+-------------+---+--------------------------------------------------------+-----+

|mz        *  | 3 | Indirektes Mehrfachpräfix (Zwischenteil)               | 182 |

+-------------+---+--------------------------------------------------------+-----+

|N            | 5 | Seitenumbruch vor Ausgabe des AT                       | 183 |

+-------------+---+--------------------------------------------------------+-----+

|p{CS}     *  | 3 | Indirektes Präfix: Steuerzeichenkette CS vor fertigem  | 182 |

|             |   | AT ausgeben                                            |     |

+-------------+---+--------------------------------------------------------+-----+

|P{CS}     *  | 3 | Indirektes Postfix: Kette CS ausgeben, nachdem AT      | 183 |

|             |   | ausgegeben                                             |     |

+-------------+---+--------------------------------------------------------+-----+

|p>K          | 3 | Unterprogramm #(K aufrufen, bevor AT ausgegeben wird   | 182 |

+-------------+---+--------------------------------------------------------+-----+

|P>K       *  | 3 | Unterprogramm #(K aufrufen, nachdem AT ausgegeben ist  | 182 |

+-------------+---+--------------------------------------------------------+-----+

|pX        *  | 1 | Direktes Präfix: X vorn an den AT anfügen              | 178 |

+-------------+---+--------------------------------------------------------+-----+

|PX           | 1 | Direktes Postfix: X hinten an AT anfügen               | 178 |

+-------------+---+--------------------------------------------------------+-----+

|pz           | 3 | Indirektes Präfix: Zwischenteil Nummer z vor AT        | 182 |

|             |   | ausgeben                                               |     |

+-------------+---+--------------------------------------------------------+-----+

|Pz        *  | 3 | Indirektes Postfix: Zwischenteil Nummer z nach AT      | 183 |

|             |   | ausgeben                                               |     |

+-------------+---+--------------------------------------------------------+-----+

|R            | 1 | AT rechtsbündig in aktuelle Zeile stellen              | 180 |

+-------------+---+--------------------------------------------------------+-----+

|rk,x         | 1 | AT k-stellig rechtsbündig machen, links mit x          | 180 |

|             |   | auffüllen                                              |     |

+-------------+---+--------------------------------------------------------+-----+

|sk,x         | 1 | AT k-stellig linksbündig machen, rechts mit x          | 180 |

|             |   | auffüllen                                              |     |

+-------------+---+--------------------------------------------------------+-----+

|tk           | 1 | k Zeichen vom Ende des AT entfernen                   | 179 |

+-------------+---+--------------------------------------------------------+-----+

|Tk           | 1 | die letzten k Zeichen des AT als neuen AT nehmen       | 179 |

+-------------+---+--------------------------------------------------------+-----+

|tX           | 1 | vom AT hinten den mit X beginnenden Teil entfernen     | 179 |

+-------------+---+--------------------------------------------------------+-----+

|TX           | 1 | hinteren Teil des AT ab Zeichenkette X als neuen AT    | 179 |

|             |   | nehmen                                                 |     |

+-------------+---+--------------------------------------------------------+-----+

|u   u[] U    | 1 | Entfernen der Übergehwörter bzw. zwischen []           | 180 |

|U[]          |   | eingeschlossene Teile; U genauso, aber erstes Wort     |     |

|             |   | dann in Großschreibung ändern                          |     |

+-------------+---+--------------------------------------------------------+-----+

|w            | 1 | AT als Kategorienummer nehmen, deren Inhalt wird neuer | 180 |

|             |   | AT                                                     |     |

+-------------+---+--------------------------------------------------------+-----+

|x"OpW"       | 1 | Rechenbefehl: AT als Zahl nehmen, Operation Op mit     | 190 |

|             |   | Wert W ausführen, das Ergebnis wird als neuer AT       |     |

|             |   | genommen                                               |     |

+-------------+---+--------------------------------------------------------+-----+

|y0           | 1 | Verhindern der Umcodierung des AT, dann Anweisung      | 180 |

|             |   | fortsetzen                                             |     |

+-------------+---+--------------------------------------------------------+-----+

|y1 / y2      | 1 | Codierung mit p- bzw. q-Befehlen sofort ausführen,     | 180 |

|             |   | Anweisung fortsetzen                                   |     |

+-------------+---+--------------------------------------------------------+-----+

|Z         *  | 5 | Unterdrücken des Ausgabe des AT (gleiche Wirkung wie   | 183 |

|             |   | e0)                                                    |     |

+-------------+---+--------------------------------------------------------+-----+
Es folgt eine Sammlung von Beispielen zu jedem einzelnen Befehl. Das allegro- Lehrbuch enthält außerdem auch eine zweite Tabelle mit allen anderen Befehlen. Zu jedem Befehl gibt es auf der Lerndiskette eine Parameterdatei, die genau die Wirkung dieses Befehls mit Hilfe der Lerndatenbank zeigt.

Befehlsbeschreibungen

=xy... Anwendervariable vergleichen/gleichsetzen.

Der Arbeitstext wird mit dem Inhalt einer Anwendervariablen verglichen und dann kann eine Reaktion erfolgen. Mit diesem Befehl kann man also eine Reaktion programmieren, die eintritt, wenn der Inhalt einer Kategorie wechselt.

Es gibt drei Varianten:

=xy AT in AV überführen, keine Ausgabe

Der Arbeitstext wird in der Anwendervariablen #uxy gespeichert. Der Rest der Anweisung wird nicht mehr ausgeführt. Bei Ungleichheit wird der bedingte Sprung ausgeführt, bei Gleichheit nicht.

Beispiel:


        Wert von #uaa vorher:    Goethe

        Arbeitstext vorher:      Schiller

        Befehl:                  #xxf +M =aa

        Ausgabe:                 keine

        Arbeitstext nachher:     leer, Sprung nach #-M , da Ungleichheit

        Wert von #uaa nachher:   Schiller

=xy+M Vergleiche AT mit AV, bei Ungleichheit speichern, bei Gleichheit springen

Der Arbeitstext wird mit dem Inhalt der Anwendervariablen #uxy verglichen.

Sind beide gleich, erfolgt der Sprung zur Marke #-M, aber der aktuelle Arbeitstext wird "vergessen".

Sind AT und AV nicht gleich, wird der Arbeitstext in der Anwendervariablen #uxy gespeichert, und die Bearbeitung des Arbeitstextes wird fortgesetzt, dann erfolgt die Ausgabe und der bedingte Sprung, falls einer angegeben ist.

Beispiel:


        Wert von #uaa vorher:    Goethe

        Arbeitstext vorher:      Goethe

        Befehl                   =aa+u P": " ...

        Ausgabe:                 keine

        Arbeitstext nachher:     leer - Fortsetzung bei Marke #-u

        Wert von #uaa nachher:   Goethe

aber:


        Wert von #uaa vorher:    Goethe

        Arbeitstext vorher:      Schiller

        Befehl:                  =aa+u P": " ...

        Ausgabe:                 noch keine, da Bearbeitung noch nicht beendet

        Arbeitstext nachher:     Schiller:

        Wert von #uaa nachher:   Schiller

=xy,z Vergleiche AT mit AV, bei Ungleichheit speichern, bei Gleichheit z ausg.

Der Arbeitstext wird mit dem Inhalt der Anwendervariablen #uxy verglichen.

Sind beide gleich, hat der Befehl die Ausgabe des Zwischenteils z und den sofortigen Abbruch der Anweisung zur Folge - der Rest der Anweisung und der bedingte Sprung werden ignoriert.

Sind AT und AV nicht gleich, wird der Arbeitstext in der Anwendervariablen #uxy gespeichert, und es wird mit der Bearbeitung des Arbeitstextes fortgefahren, anschließend erfolgt der bedingte Sprung, falls einer angegeben ist.

Beispiel:

In der Ausgabeparameterdatei ist das Zwischenteil 35=C "*** " (Neue Zeile, dann "*** ") definiert.


        Wert von #uaa vorher:    Schiller

        Arbeitstext vorher:      Schiller

        Befehl:                  =aa,35 P": " ...

        Ausgabe:                 "*** " auf neuer Zeile, statt des Namens

        Arbeitstext nachher:     leer

        Wert von #uaa nachher:   Schiller

aber


        Wert von #uaa vorher:    Schiller

        Arbeitstext vorher:      Goethe

        Befehl:                  =aa,35 P": " ...

        Ausgabe:                 noch keine, da Bearbeitung noch nicht zu Ende

        Arbeitstext nachher:     Goethe:

        Wert von #uaa nachher:   Goethe

¦im Arbeitstext als Schlüssel nehmen, im Register i danach suchen, den gefundenen Satz in den Arbeitsspeicher laden und ihn zum aktuellen Satz machen. Dabei ist 

   i  =        Registernummer (1 - 11): in Register i soll gesucht werden

    m =        Modusziffer (0,1,2,3,4,6,8,9), und zwar: gesucht wird immer nach dem aktuellen

               Arbeitstext, jedoch mit unterschiedlichen Modalitäten:

               0 :  der erste Satz mit einem genau dem Arbeitstext gleichen Schlüssel

               1 :  der nächste mit genau gleichem Schlüssel (ein Befehl mit 0

                    muß vorangehen)

               2 :  wie 0, aber der Schlüssel kann länger sein als der Arbeitstext,

                    er muß nur am Anfang mit ihm übereinstimmen

               3 :  wie 1, aber wieder auf den Anfangsteil beschränkt

               Falls mehrere Ladebefehle aufeinander folgen, werden die nachgeladenen

               Sätze jeweils im Arbeitsspeicher aufgestapelt, falls man nicht #<

               gibt. Dies kann zwar erwünscht sein, manchmal jedoch nicht - dann addiert

               man besser gleich eine 4 auf die Modusziffer, also

               4 :  wie 0, aber ein vorher geladener Satz wird beseitigt

               5 :  wie 1, usw.



               8 :  der erste Registereintrag, dessen Anfangsteil mit dem AT

                    übereinstimmt, wird gesucht und in die AV #uxi übertragen. Wird

                    keine Übereinstimmung gefunden, wird #uxi gelöscht.

               9 :  (wenn ein Zugriff mit Modus 8 voranging) der nächste, in gleicher

                    Weise übereinstimmende Eintrag wird gesucht. Ist keiner mehr

                    vorhanden, wird #uxi gelöscht.
Beispiel:

Im Register 9 sollen die Id-Nummern der Sätze stehen. Der AT enthalte eine Nummer, die nun im Register gesucht werden soll:


   Arbeitstext vorher:         123456

   Befehl:                     ¦90

   Ausgabe:                    keine, Abbruch der Anweisung, wenn nichts gefunden

   Arbeitstext nachher:        leer

   aktuelle Aufnahme nachher:  die mit der Id-Nr. 123456  (zurück mit Schaltbefehl

                               #<...)

Beispiel:

Nehmen wir an, daß im Register 10 die Signaturen stehen. Jedes Exemplar habe hier eine Eintragung mit der Grundsignatur und den wichtigsten Angaben zum Exemplar. In diesem Fall braucht man nicht unbedingt den Exemplarsatz selbst nachzuladen:


   Arbeitstext vorher:       allg 123

        Befehl:              ¦108   in Reg. 10 Eintragung mit "allg 123" suchen

       Ausgabe:              keine, Abbruch der Anweisung, wenn nichts gefunden

   Arbeitstext nachher:      leer

   Inhalt von #ux8 nacher:   die erste Registerzeile, die mit "allg 123" beginnt bzw. nichts,

                             wenn nicht gefunden

x Teilfeld x aus dem AT entnehmen und als neuen AT verwenden
Wenn man mit Teilfeldern (Subfields) in der international üblichen Weise arbeitet, d.h. mit dem Steuerzeichen  (Code 31 = auf der Spitze stehendes Dreieck) und einem darauf folgenden Kennbuchstaben den Kategorieinhalt untergliedert, kann man jedes so markierte Teilfeld mit diesem Befehl bequem "herausoperieren"

Beispiel:


   Arbeitstext vorher:       aBerlinbSpringerc1981

        Befehl:              b

   Arbeitstext nachher:      Springer

,"_X_Y_"
,",X,Y,"

Innerhalb des Arbeitstextes die Zeichenkette X durch die Zeichenkette Y ersetzen.

axy AT vorn an AV anfügen, das Ganze wieder in AV speichern

Die Anwendervariable #uxy wird verlängert, indem der Arbeitstext vorn angesetzt wird. Der Arbeitstext wird dann verworfen, die Anweisung beendet.

Beispiel:


   Wert von #upq vorher:     wetter

   Arbeitstext vorher:       sau

        Befehl:              apq

   Arbeitstext nachher:      leer, daher keine Ausgabe!

   Wert von #upq nachher:    sauwetter

Axy AT hinten an AV anhängen, das Ganze wieder in AV abspeichern

Der Arbeitstext wird hinten an die Zeichenkette der Anwendervariablen #uxy angehängt. Das Ergebnis wird wieder in #uxy gespeichert. Der Arbeitstext wird dann verworfen, die Anweisung beendet.

Beispiel:


   Wert von #upq vorher:     regen

   Arbeitstext vorher:       wetter

        Befehl:              Apq

   Arbeitstext nachher:      leer, daher keine Ausgabe!

   Wert von #upq nachher:    regenwetter

bk Beginne AT nach Position k. Wenn AT kürzer als k ist, Anweisung abbrechen

Der Arbeitstext wird zuerst umcodiert, denn dadurch könnte sich die Länge ändern! Danach werden von vorn n Zeichen abgeschnitten. Ist n gleich oder größer als die Länge des Arbeitstextes, so wird seine neue Länge gleich 0 und damit wird die Anweisung abgebrochen.

Der Befehl kann mehrfach angewendet werden.

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              b3 b2

   Arbeitstext nachher:      erfekt 5.1 : das Kompendium
Beispiel:

   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              b99

   Arbeitstext nachher:      leer

bX Beginne AT hinter Zeichenkette X. Ist X nicht enthalten: Abbruch

Der Arbeitstext wird verkürzt - er beginnt genau hinter der Zeichenkette X. Ist die Zeichenkette nicht im Arbeitstext enthalten, wird die Anweisung abgebrochen.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              b" : "

   Arbeitstext nachher:      das Kompendium
Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              b" ! "

   Arbeitstext nachher:      leer

Bk Nimm vorne k Zeichen vom AT weg. Wenn kürzer: AT bleibt unverändert.

Der Arbeitstext wird zuerst umcodiert. Sodann werden vorn k Zeichen abgeschnitten. Ist k gleich oder größer als die Länge des Arbeitstextes, so wird der Arbeitstext unverändert gelassen. (vgl. im Gegensatz den Befehl bk )

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              B7

   Arbeitstext nachher:      fect 5.1 : das Kompendium
Beispiel:

   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              B99

   Arbeitstext nachher:      WordPerfect 5.1 : das Kompendium

BX Beginne AT nach Zeichenkette X. Wenn X nicht enthalten: AT bleibt unverändert.

Der Arbeitstext wird verkürzt. Er beginnt hinter der Zeichenkette X. Ist die Zeichenkette nicht im Arbeitstext enthalten, bleibt der Arbeitstext unverändert.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              B"ord"

   Arbeitstext nachher:      Perfect 5.1 : das Kompendium

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              B"word"

   Arbeitstext nachher:      WordPerfect 5.1 : das Kompendium

C
Bevor der AT ausgegeben wird, wird ein Zeilenvorschub ausgeführt. Die aktuelle Zeile wird also beendet und das erste Zeichen des AT erscheint dann auf der ersten Position der nächsten Zeile, wobei die Einrückung (Befehl zi) berücksichtigt wird! Soll die Einrückung ausnahmsweise entfallen: am besten statt C folgendes schreiben: { C &0 } . Dann wird der Zeilenvorschub ausgeführt, das nächste Zeichen erscheint aber auf jeden Fall am Zeilenanfang.

C wirkt wie das indirekte Präfix p{ C } oder p{ 13 }

cX Test: enthält AT die Zeichenkette X?

Es wird geprüft, ob die Zeichenkette X im Arbeitstext vorkommt.

Wenn X nicht gefunden wird: Abbruch der Anweisung,

Wenn X gefunden wird: Bearbeitung des Arbeitstextes wird fortgesetzt, wenn ein bedingter Sprung angegeben ist, wird dieser anschließend ausgeführt. Man setzt diesen Befehl oft ein, um bedingte Sprünge auszulösen. Wenn der Befehl Z folgt, wird nur der Sprung ausgeführt!

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       xxx ¬Das Ende der Parabel

        Befehl:              c"xxx" U

   Arbeitstext nachher:      xxx Ende der Parabel
aber:

   Arbeitstext vorher:       xyx ¬Das Ende der Parabel

        Befehl:              c"xxx" U

   Arbeitstext nachher:      leer

dxy Beseitige die AV #uxy

Die Anwendervariable #uxy wird gelöscht. Dieser Befehl verändert den Arbeitstext nicht. Die Anweisung wird fortgesetzt. Deshalb kann er an beliebiger Stelle stehen.

ek Beende AT nach Position k

Der Arbeitstext wird umcodiert (falls p- bzw. q-Befehle vorhanden) und dann nach dem k-ten Zeichen abgeschnitten. Ist der Arbeitstext kürzer, bleibt er unverändert.

Der Befehl kann wiederholt werden.

Beispiel: (Voraussetzung: Befehle wie p Ö "Oe" und p ß "ss" sind vorhanden


   Arbeitstext vorher:       Österreichs Paßstraßen

        Befehl:              e20

   Arbeitstext nachher:      Oesterreichs Passstr

eX Beende AT vor der Zeichenkette X

Der Arbeitstext wird vor dem ersten Auftreten der Zeichenkette X abgeschnitten. Ist X nicht vorhanden, bleibt der AT unverändert. (vgl. dagegen den Befehl tX )

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              e" : "

   Arbeitstext nachher:      WordPerfect 5.1

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

         Befehl              e" : " e"er"

   Arbeitstext nachher:      WordP

Beispiel:


   Arbeitstext vorher:       WordPerfect 5.1 : das Kompendium

        Befehl:              e"tium"

   Arbeitstext nachher:      WordPerfect 5.1 : das Kompendium

Ek Beende AT nach Position k minus letztes Wort

Der Arbeitstext wird umcodiert und dann nach dem k-ten Zeichen abgeschnitten. Liegt diesr Punkt mitten in einem Wort, wird auch der Wortrest abgeschnitten.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       Österreichs Paßstraßen

        Befehl:              E20

   Arbeitstext nachher:      Oesterreichs

EX Beende AT hinter der Zeichenkette X

Der Arbeitstext wird hinter dem letzten Zeichen von X abgeschnitten; wenn X mehrfach vorkommt, beim ersten Auftreten. Wird die Zeichenkette im AT nicht gefunden, bleibt er unverändert.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       Müller ; Meier ; Schulze

        Befehl:              E" ; "

   Arbeitstext nachher:      Müller

fk Unterdrücke ASCII-Code k am Anfang des AT

Falls am Anfang des Arbeitstextes ein oder mehrere Zeichen mit dem Kode k auftreten, werden sie entfernt.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       -----------------789

        Befehl:              f45 (der ASCII-Wert von "-" ist 45)

   Arbeitstext nachher:      789

fx Unterdrücke Zeichen x am Anfang AT (keine Ziffern!)

Falls am Anfang des Arbeitstextes ein oder mehrere Zeichen x auftreten - es dürfen keine Ziffernzeichen sein - werden sie entfernt.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       ............789

        Befehl:              f.

   Arbeitstext nachher:      789

fX Unterdrücke alle Zeichen aus X am Anfang des AT

Falls am Anfang des Arbeitstextes Zeichen aus der Zeichenkette X auftreten, werden sie alle entfernt.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       .-.-.-.-.-.-.-.-.-.-.-.-.789

        Befehl:              f".-"

   Arbeitstext nachher:      789
Man beachte: nicht die Zeichenkombination X wird entfernt, das würde BX machen, sondern jedes in X vorkommende Zeichen.

Fk Unterdrücke ASCII-Code k am Ende des AT

Falls am Ende des Arbeitstextes ein oder mehrere Zeichen mit dem Code k auftreten, werden sie entfernt.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       17520.3200000000

        Befehl:              F48     (F"0" würde auch gehen, F0 nicht)

   Arbeitstext nachher:      17520.32

Fx Unterdrücke Zeichen x am Ende des AT

Falls am Ende des Arbeitstextes ein oder mehrere Zeichen x auftreten - es dürfen keine Ziffernzeichen sein - werden sie entfernt.

(Für Ziffern ist Befehl Fk zuständig: z.B. F48, um Nullen zu entfernen)

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       987pppppppppppppppppp

        Befehl:              fp

   Arbeitstext nachher:      987

FX Unterdrücke Zeichenkette X am Ende des AT

Falls am Ende des Arbeitstextes Zeichen aus der Zeichenkette X auftreten, werden sie alle entfernt. (vgl. fX )

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       999MDMDMDMDMDMDMDM

        Befehl:              F"DM"

   Arbeitstext nachher:      999

ik,x Indikatorprüfung:

Anweisung nur fortsetzen, wenn auf Position k das Zeichen x steht

Die Position k der Ausgangskategorie (die Kategorienummer beginnt in Position 1) wird darauf geprüft, ob dort das Zeichen x vorhanden ist. Ist das nicht der Fall, wird die Anweisung abgebrochen, sonst wird sie weiter abgearbeitet. (Nützlich für bedingte Sprünge)

Der Befehl ist wiederholbar.

Beispiel:


   Ausgangskategorie:        #31gMadagaskar

        Befehl:              i3,p  Ist es ein Personenschlagwort?

   Arbeitstext:              leer, daher Abbruch der Anweisung!

Beispiel:


   Ausgangskategorie:        #7A 101... Beispiel für eine Schalterbatterie

        Befehl:              i6,1 i5,0  Schalter 3 eingeschaltet? Schalter 2

                                        ausgeschaltet?

   Arbeitstext:              101...     Beides trifft zu, nun wird AT weiter bearbeitet,

                                        sonst würde die Anweisung abgebrochen

Ik,x Negative Indikatorprüfung

Anweisung nur fortsetzen, wenn auf Pos. k nicht Zeichen x steht

Die Position k der Ausgangskategorie (die Kategorienummer beginnt in Position 1) wird darauf geprüft, ob dort das Zeichen x vorhanden ist. Ist das der Fall, wird die Anweisung abgebrochen, sonst wird sie weiter abgearbeitet.

Der Befehl kann wiederholt werden.

Beispiel:


   Ausgangskategorie:        #31gMadagaskar

   Arbeitstext vorher:       Madagaskar

        Befehl:              I3,p       Ist es ein Personenschlagwort?

   Arbeitstext nachher:      Madagaskar

Beispiel:


   Ausgangskategorie:        #7A 101... Beispiel für eine Schalterbatterie

   Arbeitstext vorher:       101...     Beispiel für eine Schalterbatterie

        Befehl:              I6,1       Schalter 3 nicht eingeschaltet?

   Arbeitstext:              leer, Abbruch der Anweisung!

lxy Länge des AT in die Variable #uxy schreiben

Anschließend besteht der AT nicht mehr aus dem Text, sondern nur noch aus einer Zahl, die die Länge des Textes angibt. Man braucht das für seltene Spezialaufgaben.

mz Indirektes Mehrfachpräfix
m{ CS }

Ein indirektes Mehrfachpräfix kann nur in einer Anweisung enthalten sein, in der statt des bedingten Sprungs der Befehl ++ steht. Es wird ab der zweiten Abarbeitung, d.h. bei Mehrfachkategorien wirksam.

Ein indirektes Mehrfachpräfix wird nicht mit dem Arbeitstext verknüpft, sondern vor ihm ausgegeben (nach Ausgabe des bedingten Präfixes). D.h., das indirekte Präfix wirkt vor allen echten Manipulationsbefehlen.

Das indirekte Mehrfachpräfix unterliegt nicht der Umcodierung!

Als indirektes Mehrfachpräfix kann man Zwischenteile z oder Steuerzeichenketten CS verwenden.

Beispiel:


    Kategorien:              #40 Meier, H.

                             #402Schulze, P.

                             #403Haase, E.

        Befehl:              #40 ++ p{ 13 "AU: " } m{ "; " }

   Arbeitstext 1:            Meier, H.

     Ausgabe 1:              AU: Meier, H.

   Arbeitstext 2:            Schulze, P.

     Ausgabe 2:              ...; Schulze, P.

   Arbeitstext 3:            Haase, E.

     Ausgabe 3:              ...; Haase, E.

   Ausgabe gesamt:           AU: Meier, H.; Schulze, P.; Haase, E.

m>K Indirekter Präfix-Unterprogrammaufruf

(siehe Erläuterung zu p>K) wirksam nur bei Mehrfachkategorien

mX Direktes Mehrfachpräfix
m{ CS }
Dieses Präfix wirkt nur in einer Anweisung, in der anstelle des Sprunges "++" steht. Dies bewirkt, daß alle nachfolgenden Kategorien, die in den ersten 2 Stellen übereinstimmen, ebenfalls ausgegeben werden. Ab der zweiten Abarbeitung, d.h. wenn tatsächlich Mehrfachkategorien vorliegen, wird X vor den Arbeitstext als Präfix (Umcodierung!) gesetzt.

Beispiel:


    Kategorien:              #40 Meier, K.

                             #402Schulze, P.

                             #403Müller, H.

        Befehl:              #40 ++ p"Verf.: " m"; "

   Arbeitstext 1:            Verf.: Meier, K.

   Arbeitstext 2:            ; Schulze, P.

   Arbeitstext 3:            ; Müller, H.

   Ausgabetext:              Verf.: Meier, K.; Schulze, P.; Müller, H.

N Seitenumbruch

Der Befehl N wirkt sich nicht auf den Arbeitstext aus, sondern unterbricht seine weitere Bearbeitung, um sofort einen Seitenumbruch auszuführen, bevor der AT ausgegeben wird.

Beispiel:


   Arbeitstext vorher:       J. W. v. Goethe

        Befehl:              p"von: " N ...     Seitenumbruch, dann weiter!

   Arbeitstext nachher:      von: J. W. v. Goethe

p>K Indirekter Präfix-Unterprogrammaufruf

Ein Präfix-Unterprogrammaufruf wird anstelle der Ausgabe des Arbeitstextes durchgeführt. Eine Bezugnahme auf die aktuelle Kategorie im Unterprogramm ist über die Sonderkategorie #cc möglich. Allerdings behält bei verschachtelten Unterprogrammen #cc den Wert, den es beim Aufruf des ersten UP hat.

Beispiel:


   Arbeitstext vorher:       ¬Das Ende der Parabel

        Befehl:              p>U

   Arbeitstext nachher:      Arbeitstext ist nach Ausführung des Unterprogramms #(U

                             verworfen. Innerhalb von #(U steht der Kategorietext aber unter

                             der Sonderkategorie #cc zur Verfügung.

pX Direktes Präfix / Direktes Postfix
PX
Die Zeichenkette X wird vor bzw. hinter den Arbeitstext gestellt. Das Ergebnis ist ein neuer Arbeitstext. Die Umcodierung wird also auch an den Zeichenketten vorgenommen, falls sie nicht vorher (z.B. durch einen y-Befehl) ausgeführt wurde.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       Paul Meier

        Befehl:              p"herausgegeben von " P"."

   Arbeitstext nachher:      herausgegeben von Paul Meier.

Beispiel:


   Arbeitstext vorher:       Physikalische Monographien ; 59

        Befehl:              C p"(" P")"

   Arbeitstext nachher:      (Physikalische Monographien ; 59)   (auf neuer Zeile)

pz Indirektes Präfix
p{ CS }

Ein indirektes Präfix wird nicht mit dem Arbeitstext verknüpft, sondern vor ihm ausgegeben. D.h., das indirekte Präfix wirkt vor allen echten Manipulationsbefehlen.

Das indirekte Präfix unterliegt nicht der Umcodierung!

Als indirektes Präfix kann man ein Zwischenteil (mit Nummer z) oder eine Steuerzeichenkette CS verwenden.

pz ist wiederholbar, p{ CS } nicht. Die pz-Befehle werden vor p{ CS } ausgeführt, ungeachtet der tatsächlichen Reihenfolge.

Beispiel:


   Arbeitstext vorher:       Max Krause

        Befehl:              p"Hrsg.: " p{ ". - " 13 }

   Arbeitstext nachher:      Hrsg.: Max Krause

       Ausgabe:              ... . -

               Hrsg.: Max Krause

Pz Indirektes Postfix
P{ CS }

Ein indirektes Postfix wird nicht mit dem Arbeitstext verknüpft, sondern nach ihm ausgegeben (aber vor Ausgabe des bedingten Postfixes). Das heißt, das indirekte Postfix wirkt nach allen echten Manipulationsbefehlen. Das indirekte Postfix unterliegt nicht der Umcodierung!

Als indirektes Postfix kann man Zwischenteile z oder Steuerzeichenketten CS verwenden.

Beide sind nicht wiederholbar.

Beispiel:


   Arbeitstext vorher:       Max Krause

        Befehl:              P{ ". - " 13 } P" [Hrsg.]"

   Arbeitstext nachher:      Max Krause [Hrsg.]

       Ausgabe:              Max Krause [Hrsg.]. -

PX Direktes Postfix - wird sofort hinten an den AT angehängt

(siehe Erläuterung zu pX)

rk AT auf k Stellen rechtsbündig setzen, links mit x auffüllen
rk,x
Der Arbeitstext wird umcodiert. Ist er dann kürzer als k, wird er in ein Feld der Länge k umgewandelt und nach links mit dem Zeichen x aufgefüllt. Ist x nicht angegeben, so wird mit Leerzeichen aufgefüllt. Ist die Länge des Arbeitstextes größer oder gleich k, so wird der Befehl ignoriert.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       123

        Befehl:              r12,-

   Arbeitstext nachher:      ---------123

Beispiel:


   Arbeitstext vorher:       123

        Befehl:              r8 r10,*

   Arbeitstext nachher:      **     123

R AT rechtsbündig in Zeile stellen

Der Arbeitstext wird rechtsbündig in die aktuelle Zeile gestellt. Falls die Zeile dazu keinen ausreichenden Platz mehr hat, wird eine neue Zeile begonnen. Der Arbeitstext expandiert.

Beispiel: zl=39; Leerzeichen werden durch "" symbolisiert


   aktuelle Zeile:           123456

   Arbeitstext vorher:       ABCD

        Befehl:              R

   Arbeitstext nachher:      ABCD
Beispiel: zl=30

   aktuelle Zeile:           12345678901234567890

   Arbeitstext vorher:       ABCDEFGHIJK

        Befehl:              R

   Arbeitstext nachher:      ABCDEFGH
Ausgabe auf neuer Zeile, da nicht mehr genug Platz

sk AT auf k Stellen linksbündig setzen, mit x nach rechts auffüllen
sk,x
Der Arbeitstext wird umcodiert. Ist er dann kürzer als k Zeichen, wird er auf diese Länge durch Anhängen von Zeichen x verlängert. Ist x nicht angegeben, wird mit Leerzeichen aufgefüllt. Ist der Arbeitstext nicht kürzer, wird der Befehl ignoriert.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       123

        Befehl:              s12,0

   Arbeitstext nachher:      123000000000

Beispiel:


   Arbeitstext vorher:       123

        Befehl:              s12 s15,x

   Arbeitstext nachher:      123         xxx

tk Vom AT von hinten k Zeichen abschneiden

Der AT wird am Ende um k Zeichen verkürzt. Ist k größer als die ursprüngliche Länge des Arbeitstextes, wird die Anweisung abgebrochen.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       Data Structures in ANSI C

        Befehl:              t1

   Arbeitstext nachher:      Data Structures in ANSI

Beispiel:


   Arbeitstext vorher:       Data Structures in ANSI C

        Befehl:              b" " t1

   Arbeitstext nachher:      Structures in ANSI

tX Im AT von hinten X suchen und Endpunkt des AT vor X setzen

Der Arbeitstext wird von hinten durchsucht und beim Auffinden von X vor dieser Zeichenkette abgeschnitten. Neuer Arbeitstext ist der vordere Rest. Tritt X nicht auf, bleibt der Arbeitstext unverändert.

Der Befehl kann wiederholt werden.

Beispiel: AT vor einem bestimmten Wort abschneiden:


   Arbeitstext vorher:       Data Structures in ANSI C

        Befehl:              t" in"

   Arbeitstext nachher:      Data Structures
Beispiel: vom AT hinten 3 Wörter abschneiden

   Arbeitstext vorher:       Data Structures in ANSI C

        Befehl:              t" " t" " t" "

   Arbeitstext nachher:      Data Structures

Tk Die letzten k Zeichen des AT als neuen AT nehmen

Vom Arbeitstext werden von hinten k Zeichen abgeschnitten. Diese bilden den neuen Arbeitstext. Ist k größer als die Länge des ursprünglichen Arbeitstextes, wird die Anweisung abgebrochen.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       Data Structures in ANSI C

        Befehl:              T1

   Arbeitstext nachher:      C

Beispiel:


   Arbeitstext vorher:       Programmiersprachen

        Befehl:              T8 t2

   Arbeitstext nachher:      sprache

TX Der am Ende des AT mit X beginnende Teil wird als neuer AT genommen

Der Arbeitstext wird von hinten her nach der Zeichenkette X durchsucht. Tritt sie auf, wird der Teil einschließlich X abgetrennt und bildet den neuen Arbeitstext. Wird X nicht gefunden, bleibt der Arbeitstext unverändert.

Der Befehl kann wiederholt werden.

Beispiel:


   Arbeitstext vorher:       C-Programmierung : effektiv - elegant - komplett

        Befehl:              T" - " B" - "

   Arbeitstext nachher:      komplett

Vergleiche!


   Arbeitstext vorher:       C-Programmierung : effektiv - elegant - komplett

        Befehl:              B" - "

   Arbeitstext nachher:      elegant - komplett

u Entferne die Übergehwörter aus dem AT
uxy

Der Arbeitstext wird auf Wörter hin geprüft, die von den Zeichen x und y eingeschlossen sind. Derartige Wörter werden aus dem Arbeitstext entfernt.

Sind x und y nicht angegeben, so gelten für sie folgende Annahmen standardmäßig:

Beim Nichtsortier-Modus n1: x=y=Nichtsortierzeichen

Beim Nichtsortier-Modus n0: x=Nichtsortierz., y=Leerzeichen

Der Befehl kann mit anderen Zeichen wiederholt werden.

Beispiel: im Konfigurationsfile ist zu finden: n0, N170


   Arbeitstext vorher:       ¬Die neuen Leiden des jungen W.

        Befehl:              u

   Arbeitstext nachher:      neuen Leiden des jungen W.

Beispiel: im Konfigurationsfile: n1, N95


   Arbeitstext vorher:       _Die_ neuen Leiden _d._ jungen W.

        Befehl:              u

   Arbeitstext nachher:      neuen Leiden jungen W.

Beispiel:


   Arbeitstext vorher:       Deutsches Bibliotheksinstitut <Berlin>

        Befehl:              u<>

   Arbeitstext nachher:      Deutsches Bibliotheksinstitut

U Entferne Übergehwörter - AT soll mit Großbuchstabe beginnen
Uxy

Der Befehl wirkt wie u bzw. uxy , aber das erste Wort des verbleibenden AT wird in Großschreibung umgewandelt.

Der Befehl kann mit anderen Zeichen wiederholt werden.

Beispiel: im Konfigurationsfile: n0, N170


   Arbeitstext vorher:       ¬Die neuen Leiden des jungen W.

        Befehl:              U

   Arbeitstext nachher:      Neuen Leiden des jungen W.
Beispiel: im Konfigurationsfile: n1, N95

   Arbeitstext vorher:       _Die_ neuen Leiden _d._ jungen W.

        Befehl:              U

   Arbeitstext nachher:      Neuen Leiden jungen W.

w Der AT wird als Kategorienummer interpretiert.

Der AT kann, muß aber nicht, mit dem Zeichen '#' anfangen. Die betreffende Kategorie wird in der aktuellen Aufnahme gesucht, ihr Inhalt wird neuer Arbeitstext.

Wenn diese Kategorie nicht in der aktuellen Aufnahme vorkommt: Abbruch der Anweisung.


   Arbeitstext vorher:       74    oder    #74

        Befehl:              w

   Arbeitstext nachher:      Greifswald

               (wenn #74 Greifswald in der aktuellen Aufnahme steht.)

x"OpW" Aus dem AT eine Zahl entnehmen und Operation Op mit Wert W durchführen - Rechenbefehl

Aus dem Arbeitstext wird die erste darin enthaltene Zahl extrahiert (Dezimalzahlen können mit Punkt oder Komma geschrieben sein). Auf diese Zahl wird die Operation Op mit dem Wert W angewendet. Das Ergebnis des Rechenvorganges bildet den neuen Arbeitstext, und zwar stets mit 10 Nachkommastellen, auch wenn es eine ganze Zahl ist.

Mögliche Operationen:

+ - * / %
Grundrechenarten, Divisionsrest

r
Rundung (dahinter als Wert eine Ziffer, 0 für Rundung auf ganze Zahl)

=
Wertzuweisung: AT wird durch W ersetzt

> >= < <= ==
Vergleiche: wenn der Vergleich positiv ausfällt, wird die Anweisung fortgesetzt (ohne Änderung am AT), andernfalls abgebrochen.

Mögliche Werte: W kann eine Zahl sein (Vorzeichen, Punkt und Komma erlaubt),
eine AV (z.B. xy für #uxy) oder
eine andere Kategorie (z.B. #503)

Beispiel:


   Arbeitstext vorher:       Meyer / DM 531,90

        Befehl:              x"*0.8" x"*1.14" x"r2"

   Arbeitstext nachher:      485.09

y0 Unterdrücke die Umcodierung des AT

Bei der Ausgabe des Arbeitstextes erfolgt in der Regel ein Umcodieren mit Hilfe der p- (#kkf) bzw. q-Befehle (!kkf).

Durch den Befehl wird dieses Umcodieren ausgeschaltet.

Achtung: wenn vor y0 ein Befehl wie bk oder en steht, dann ist die Umcodierung bereits automatisch erfolgt und y0 wirkungslos.

Beispiel: folgender Umcodierungsbefehl sei angegeben: p A/Z 97


   Inhalt von #20:           ¬Die Enden der Parabel

        Befehl:              #20 U y0

       Ausgabe:              Enden der Parabel

        Befehl:              #20 U

       Ausgabe:              enden der parabel

y1 Erzwinge die Umcodierung des AT mit p- bzw. q-Befehlen
y2
Diese Befehle bewirken ein sofortiges Umcodieren des Arbeitstextes. Bei y1 werden die p-Befehle, bei y2 die q-Befehle ausgeführt. Danach wird die Anweisung normal weiter abgearbeitet. Direkte Prä- oder Postfixe, die dann noch folgen, werden nicht mehr umcodiert, was meist der Sinn dieser Befehle ist.

Z Unterdrücken der Ausgabe des AT

Der Befehl Z ist der letzte wirksame, nachfolgende Manipulationen haben keine Wirkung mehr. Der AT wird quasi als leere Zeichenkette behandelt - bedingte und indirekte Prä- und Postfixe werden ausgeben und indirekte Sprünge ausgeführt. (Also aufpassen, besonders wegen der bedingten Postfixe!)

Dasselbe bewirkt der Befehl e0.

Beispiel:


   Kategorieinhalt:          #79 101...

        Befehl:              i6,1 p{ ", eigenhändige Unterschrift" } Z

       Ausgabe:              ..., eigenhändige Unterschrift

               (wenn der dritte Schalter auf 1 steht)



   

© Universitätsbibliothek Braunschweig, Bernhard Eversberg, 30.09.1996
B.Eversberg@tu-bs.de