----------------------------------------------------------------- | SOFTWARE- | Systembibliotheksroutinen | MOS | | DOKUMENTATION | | | |-----------------| Anleitung fuer den |------------| | 11/87 | Programmierer | OMOS 2.0 | ----------------------------------------------------------------- Programmtechnische Anleitung fuer den Programmierer Beschreibung Teil 6 Systembibliotheksroutinen MGS K 1600 VEB Robotron-Vertrieb Berlin Dok.-Nr. C 8064-0507-1M2031 Die vorliegende Ausgabe der Systemunterlagen-Dokumentation - Anleitung fuer Programmierer, Teil 6: "Systembibliotheks- routinen" - entspricht dem Stand von 11/87 und unterliegt nicht dem Aenderungsdienst. Nachdruck, jegliche Vervielfaeltigung oder Auszuege daraus sind unzulaessig. Die Ausarbeitung erfolgte durch ein Kollektiv des VEB Robotron- Vertrieb Berlin. Im Interesse einer staendigen Weiterentwicklung werden alle Leser gebeten, Hinweise zur Verbesserung dem Herausgeber mitzuteilen. Herausgeber: VEB Robotron-Vertrieb Berlin Mohrenstr. 62 Berlin 1086 (C) Kombinat Robotron 1987 Kurzreferat Systembibliotheksroutinen werden in MACRO-1600-Programmen verwendet, um folgende Aufgaben zu realisieren: Registerinhalte retten und wiederherstellen Ein- und Ausgabekonvertierung Arithmetik fuer Mehrwortformate und Tetraden Ausgabeformatierung Verwaltung des dynamischen und des virtuellen Speichers Benutzung von Universalbibliotheken Im einzelnen werden Informationen zum Aufruf und zur Parameteruebergabe sowie zur Verarbeitung und zu den Rueckkehrinformationen gegeben. Inhaltsverzeichnis ------------------ Seite 1. Einfuehrung 6 2. Routinen zur Registerbearbeitung 7 2.1. Ueberblick 7 2.2. Rettung aller Register ($SAVAL) 7 2.3. Rettung der Register 3 bis 5 ($SAVRG) 8 2.4. Rettung der Register 0 bis 2 ($SAVVR) 9 2.5. Rettung der Register 1 bis 5 (.SAVR1) 9 3. Routinen fuer Arithmetik 10 3.1. Grundroutinen fuer Arithmetik 10 3.1.1. Integer-Multiplikation ($MUL,$DMUL) 10 3.1.2. Integer-Division ($DIV,$DDIV) 12 3.2. Arithmetik fuer das Datenformat Mehrfachwort 14 3.2.1. Integer-Addition ($ADDM) 14 3.2.2. Integer-Subtraktion ($SUBM) 15 3.2.3. Integer-Multiplikation ($MULM) 17 3.2.4. Integer-Division ($DIVM) 18 3.3. Arithmetik fuer das Datenformat Tetraden 20 3.3.1. Tetradische Addition ($TEAD) 20 3.3.2. Tetradische Subtraktion ($TESU) 21 3.3.3. Tetradische Verschiebung ($TEVE) 21 3.3.4. Tetradischer Vergleich ($TECP) 22 4. Routinen fuer Eingabekonvertierung 24 4.1. Grundroutinen der Eingabekonvertierung 24 4.1.1. KOI-7-Code in Binaer-Doppelwort (.DD2CT,.0D2CT) 24 4.1.2. KOI-7-Code in Binaer-Wort ($CDTB,DD1CT,$COTB) 26 4.1.3. KOI-7-Code in Radix-50 ($CAT5,$CAT5B) 29 4.2. Eingabekonvertierung fuer das Datenformat Mehrfachwort 31 4.2.1. Integer-Dreifachwort (DD3CT) 31 4.2.2. Integer-Vierfachwort (DD4CT) 32 4.3. Eingabekonvertierung fuer das Datenformat Tetraden ($KOTE) 33 5. Routinen fuer Ausgabekonvertierung 35 5.1. Grundroutinen der Ausgabekonvertierung 35 5.1.1. Binaer in Dezimal ($CBDAT,$CBDMG,$BDSG,$CDDMG, DCDD2W) 35 5.1.2. Binaer in Oktal ($CBOMG,$CBOSG,$CBTMG) 39 5.1.3. Universelle Routine Binaer in KOI-7 ($CBTA) 41 5.1.4. Radix-50 in KOI-7 ($C5TA) 42 5.2. Ausgabekonvertierung fuer das Datenformat Mehrfachwort 43 5.2.1. Integer-Dreifachwort (DCDD3W) 43 5.2.2. Integer-Vierfachwort (DCDD4W) 44 5.3. Ausgabekonvertierung fuer das Datenformat Tetraden ($TEKO) 45 6. Routinen zur Formatierung von Ausgaben 47 6.1. Uebertragung in Grossbuchstaben 47 6.2. Konvertierung von Datum und Uhrzeit 48 6.2.1. Datumskonvertierung ($DAT) 48 6.2.2. Zeitkonvertierung ($TIM) 49 6.3. Aufbereitung von Ausgabezeichenfolgen ($EDMSG) 50 3 7. Programme zur Speicherverwaltung 58 7.1. Einleitung 58 7.2. Verwaltung des virtuellen Speichers 58 7.2.1. Vorbemerkungen 58 7.2.2. Voraussetzungen fuer die Nutzung der Programme 58 7.2.2.1. Taskbilderforderungen 58 7.2.2.2. Fehlerbehamdlungsroutine ($ERMSG) 59 7.2.3. Initialisierung des virtuellen Speichers ($INIVM) 60 7.2.4. Speicherzuordnung 61 7.2.4.1. Blockzuordnung ($ALBLK) 61 7.2.4.2. Speicherplatzbereitstellung ($GTCOR) 62 7.2.4.3. Taskerweiterung ($EXTSK) 63 7.2.4.4. Transfer eines Blockes zum Plattenspeicher ($WRPAG) 64 7.2.5. Zuordnung von virtuellem Speicher 64 7.2.5.1. Zuordnung eines kleinen virtuellen Blockes ($ALSVB) 64 7.2.5.2. Zuordnung eines grossen virtuellen Blockes ($ALVRT) 65 7.2.5.3. Zuordnung eines Blockes der Plattendatei ($RQVCB) 66 7.2.6. Blockverwaltung 66 7.2.6.1. Adresskonvertierung und Kennzeichnung eines Blockes ($CVLOK) 66 7.2.6.2. Konvertierung einer virtuellen in eine reale Adresse ($CVRL) 67 7.2.6.3. Suchen eines Blockes ($FNDPG) 67 7.2.6.4. Setzen des Kennzeichenbytes ($LCKPG) 68 7.2.6.5. Lesen eines Blockes ($RDPAG) 69 7.2.6.6. Loeschen eines Kennzeichenbytes ($UNLPG) 69 7.2.6.7. Setzen des "Eingeschrieben"-Flag ($WRMPG) 70 7.3. Verwaltung des dynamischen Speichers 70 7.3.1. Vorbemerkungen 70 7.3.2. Voraussetzungen fuer die Nutzung der Programme 71 7.3.3. Initialisierung des dynamischen Speichers ($INIDM) 71 7.3.4. Anfordern eines Speicherblockes ($RQCB) 71 7.3.5. Freigabe eines Speicherblockes ($RLCB) 72 8. Universalbibliotheken 73 8.1. Einleitung 73 8.2. Zugriff zu Universalbibliotheken 73 Abkuerzungsverzeichnis 75 Sachwortverzeichnis 78 Routinennamen 79 4 Tabellenverzeichnis ------------------- 1: Registerrettung 7 2: Kellerspeicherinhalt (R0-R5) 8 3: Kellerspeicherinhalt (R3-R5) 8 4: Kellerspeicherinhalt (R0-R2) 9 5: Kellerspeicherinhalt (R1-R5) 9 6: Routinen der Arithmetik 10 7: Routinen der Eingabekonvertierung 24 8: Routinen der Ausgabekonvertierung 35 9: Bearbeitungsanweisungen fuer $EDMSG 51 10: Speicherverwaltungsprogramme 72 5 1. Einfuehrung -------------- Die hier beschriebenen allgemeingueltigen Routinen koennen von den MACRO-1600-Programmierern angewendet werden. Es werden die Aufrufprozeduren fuer die Bibliotheksroutinen, die Ergebnisse,die dem rufenden Programm uebergeben werden, und die Uebergabe der Steuerung und der Daten zwischen den Bibliotheksroutinen und dem rufenden Programm beschrieben. Die Bibliotheksroutinen rufen sich gegenseitig auf. So rufen z.B. die Routinen der Datenkonvertie- rung die arithmetischen Routinen, wenn Multiplikation und Division benoetigt werden. Die Bibliotheksroutinen kommunizieren mit dem rufenden Programm ueber die allgemeinen Register, in denen Ergebnisse uebergeben werden, und durch Setzen des C-Bit, so dass erkannt werden kann, ob die angeforderte Funktion erfolgreich durchgefuehrt wurde. Die Bibliotheksroutinen werden dem Nutzer als Objektmoduln in zwei Bibliotheken bereitgestellt: - SYSLIB.OLB (Systembibliothek), die folgende Routinen enthaelt: . Registerroutinen . Arithmetikroutinen . Ein- und Ausgabekonvertierungsroutinen . Formatgesteuerte Ausgabekonvertierung . Routinen fuer die Zuordnung und Freigabe des dynamischen Speichers . Zugriffsroutinen fuer die Universalbibliotheken - VMLIB.OLB, die die Routinen zur Verwaltung des dynamischen und virtuellen Speichers enthaelt Waehrend des Taskbildens sucht der Taskbilder (TKB) automatisch in der Systembibliothek nach den angeforderten Routinen. Die Bibliothek VMLIB.OLB muss jedoch beim Taskbilden angegeben werden, wenn Routinen benutzt werden, die zur Verwaltung des dynamischen oder virtuellen Speichers gehoeren. 6 2. Routinen zur Registerbearbeitung ----------------------------------- 2.1. Ueberblick --------------- Die Systembibliothek enthaelt folgende vier Routinen zur Bear- beitung der Registerinhalte. Es werden die Register N-M gerettet und danach zurueckgespeichert. Tabelle 1: Registerrettungsroutinen ---------------------------------------------------- | Routine | Register |Beschreibung unter Pkt.| -------------|-------------|------------------------ | $SAVAL | 0 - 5 | 2.2. | -------------|-------------|------------------------ | $SAVRG | 3 - 5 | 2.3. | -------------|-------------|------------------------ | $SAVVR | 0 - 2 | 2.4. | -------------|-------------|------------------------ | .SAVR1 | 1 - 5 | 2.5. | ---------------------------------------------------- Die Routinen zur Registerrettung bewirken folgenden Effekt: Ein Hauptprogramm ruft ein Unterprogramm. Das Unterprogramm ruft seinerseits am Anfang eine Registerbearbeitungsroutine, diese uebergibt die Registerinhalte in einen Zwischenspeicher (Keller- speicher) und veranlasst die Weiterarbeit im Unterprogramm. Nach Beendigung des Unterprogramms wird die Registerbearbeitungsrou- tine wieder aufgerufen und diese speichert die urspruenglichen Registerinhalte aus dem Kellerspeicher zurueck und kehrt zum rufenden Hauptprogramm zurueck. 2.2. Rettung aller Register ($SAVAL) ------------------------------------ Aufgabe: Retten und Rueckspeichern der Registerinhalte 0-5 wie in ------- der Einleitung beschrieben. Aufruf: JSR PC,$SAVAL ------- Ausfuehrung: ------------ Die Inhalte der Register 5 bis 0 werden durch $SAVAL dem Keller- speicher uebergeben. Die $SAVAL-Routine enthaelt einen Ruf in der Form CALL @(SP)+, durch welchen die Steuerung an das Unter- programm uzurueckgegeben wird. Sobald die Steuerung dem Unter- programm wieder uebergeben wird, steht der Kellerzeiger auf der Rueckkehradresse zur $SAVAL-Routine, wobei der Kellerspeicher folgenden Inhalt besitzt: 7 Tabelle 2: Kellerspeicherinhalt (R0-R5) -------------------------------------- | Rueckkehradresse zum Hauptprogramm | -------------------------------------- | Register 5 | -------------------------------------- | Register 4 | -------------------------------------- | Register 3 | -------------------------------------- | Register 2 | -------------------------------------- | Register 1 | -------------------------------------- | Register 0 | -------------------------------------- | Rueckkehradresse zu $SAVAL | -------------------------------------- Das Unterprogramm arbeitet nun, bis die Ruecksprunganweisung (RTS PC) abgearbeitet wird, welche die Steuerung also nochmals der $SAVAL-Routine uebergibt. Diese entnimmt die Inhalte von RO- R5 dem Kellerspeicher und speichert sie zurueck. Ueber eine Rueckkehranweisung in der $SAVAL-Routine wird die Rueckkehr zum rufenden Hauptprogramm organisiert. 2.3. Rettung der Register 3 bis 5 ($SAVRG) ------------------------------------------ Aufgabe: Rettung und Rueckspeichern der Register 3 bis 5 fuer ein ------- Unterprogramm. Aufruf: JSR R5,$SAVRG ------- Ausfuehrung: ------------ Die Inhalte von R5 bis R3 werden durch $SAVRG in den Keller- speicher gespeichert. Danach wird wie in Abschn. 2.2. verfahren. Tabelle 3: Kellerspeicherinhalt (R3-R5) --------------------------------------- | Rueckkehradresse des Hauptprogramms | --------------------------------------- | Register 5 | --------------------------------------- | Register 4 | --------------------------------------- | Register 3 | --------------------------------------- | Rueckkehradresse zu $SAVRG | --------------------------------------- 8 2.4. Rettung der Register 0 bis 2 ($SAVVR) ------------------------------------------ Aufgabe: Retten und Rueckspeichern der Register 0 bis 2 fuer ein ------- Unterprogramm. Aufruf: JSR R2,$SAVVR ------- Ausfuehrung: ------------ Entsprechend Abschn. 2.2. fuer die Register 0 bis 2. Tabelle 4: Kellerspeicherinhalt (R0-R2) --------------------------------------- | Rueckkehradresse des Hauptprogramms | --------------------------------------- | Register 2 | --------------------------------------- | Register 1 | --------------------------------------- | Register 0 | --------------------------------------- | Rueckkehradresse zu $SAVVR | --------------------------------------- 2.5. Rettung der Register 1 bis 5 (.SAVR1) ------------------------------------------ Aufgabe: Rettung und Rueckspeichern der Register 1 bis 5 fuer ein ------- Unterprogramm. Aufruf: JSR R5,.SAVR1 ------- Ausfuehrung: ------------ Entsprechend Abschn. 2.2. fuer die Register 1 bis 5. Tabelle 5: Kellerspeicherinhalt (R1-R5) --------------------------------------- | Rueckkehradresse des Hauptprogramms | --------------------------------------- | Register 5 | --------------------------------------- | Register 4 | --------------------------------------- | Register 3 | --------------------------------------- | Register 2 | --------------------------------------- | Register 1 | --------------------------------------- | Rueckkehradresse zu .SAVR1 | --------------------------------------- 9 3. Routinen fuer Arithmetik --------------------------- 3.1. Grundroutinen fuer Arithmetik ---------------------------------- Tabelle 6: Routinen der Arithmetik ----------------------------------------------------------------- | Name |Operation |Operandenformat |Ergebnisformat |Pkt. | ----------------------------------------------------------------- | $ADDM |Addition |bis Vierfachwort |bis Vierfachwort |3.2.1. | | $SUBM |Subtraktion|bis Vierfachwort |bis Vierfachwort |3.2.2. | | $DMUL |Multipl. |Doppelwort, Wort |Doppelwort |3.1.1. | | $MUL |Multipl. |Wort |Doppelwort |3.1.1. | | $MULM |Multipl. |bis Vierfachwort |bis Vierfachwort |3.2.3. | | $DIV |Division |Wort |Wort |3.1.2. | | $DDIV |Division |Doppelwort, Wort |Doppelwort |3.1.2. | | $DIVM |Division |bis Vierfachwort |bis Vierfachwort |3.2.4. | | $TEAD |Addition |Tetraden |Tetraden |3.3.1. | | $TESU |Subtraktion|Tetraden |Tetraden |3.3.2. | | $TECP |Vergleich |Tetraden |Tetraden |3.3.4. | | $TEVE |Verschieb. |Tetraden |Tetraden |3.3.3. | ----------------------------------------------------------------- 3.1.1. Integer-Multiplikation ($MUL,$DMUL) ------------------------------------------ Multiplikationsroutine (Wort) ----------------------------- Aufgabe: Es erfolgt eine vorzeichenlose Multiplikation von Inte- -------- gerzahlen (Wort), deren Ergebnis ein Integerdoppelwort ist. Aufruf: CALL $MUL ------- Parameter: ---------- - Eingabe: . in Register 0 - Multiplikator . in Register 1 - Multiplikand - Ausgabe: . in Register 0, hoeherwertiger Teil des Produktes . in Register 1, niederwertiger Teil des Produktes Von der Multiplikationsroutine werden die Register R2 bis R5 nicht benutzt. 10 Beispiel: --------- . . . MOV MULTKT,R0 ;R0 enthaelt Multiplikator MOV MULTKD,R1 ;R1 enthaelt Multiplikand CALL $MUL MOV R0,PRODKT ;R0 enthaelt Produkt (hoeherw.) MOV R1,PRODKT+2 ;R1 enthaelt Produkt (niederw.) . . . MULTKT: .WORD 32762. ;FAKTOR 1 (WORT) MULTKD: .WORD 327 ;FAKTOR 2 (WORT) PRODKT: .BLKW 2 ;PRODUKT (2-Wort) Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Multiplikationsroutine (Doppelwort) ----------------------------------- Aufgabe: Multiplikation einer vorzeichenlosen Integerzahl im Dop- ------- pelwortformat mit einer vorzeichenlosen Integerzahl im Einwortformat, deren Ergebnis eine Integerzahl im Doppelwortformat ist. Aufruf: CALL $DMUL ------- Parameter: ---------- - Eingabe: . in Register 0 Multiplikator als Einfachwort . in Register 2 hoeherwertiger Teil des Multiplikanden . in Register 3 niederwertiger Teil des Multiplikanden - Ausgabe: . in Register 0 hoeherwertiger Teil des Produktes . in Register 1 niederwertiger Teil des Produktes Die Register R4, R5 werden von der Routine nicht benutzt. Die Inhalte der Register R2 und R3 werden zerstoert. 11 Beispiel: --------- . . . MOV MULTKT,R0 ;R0 enthaelt Multiplikator MOV MULTKD,R2 ;R2 enthaelt Multiplikand (hoeherwertig) MOV MULTKD+2,R3 ;R3 enthaelt Multiplikand (niederwertig) CALL $DMUL ;Multiplikation MOV R0,PRODKT ;R0 enthaelt Produkt (hoeherwertig) MOV R1,PRODKT+2 ;R1 enthaelt Produkt (niederwertig) . . . MULTKT: .WORD 999. ;Multiplikator MULTKD: .LONG 100000 ;Multiplikand (2 Worte) PRODKT: .BLKW 2 ;Produkt (2 Worte) Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehlermeldung. 3.1.2. Integer-Division ($DIV,$DDIV) ------------------------------------ Divisionsroutine (Wort) ----------------------- Aufgabe: Es erfolgt eine vorzeichenlose Division von ------- Integerzahlen im Wortformat. Aufruf: CALL $DIV ------- Parameter: ---------- - Eingabe . in Register 0 Dividend . in Register 1 Divisor - Ausgabe: . in Register 0 Quotient . in Register 1 Rest Von der Divisionsroutine werden die Register R2 bis R5 nicht be- nutzt. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. 12 Beispiel: --------- . . . MOV DIVDND,R0 ;R0 enthaelt Divident MOV DIVSOR,R1 ;R1 enthaelt Divisor CALL $DIV MOV R1,REST ;R1 enthaelt Rest der Division MOV R0,QUOTND ;R0 enthaelt Quotient . . . DIVDND: .WORD 10000 ;Dividend DIVSOR: .WORD 999. ;Divisor REST: .BLKW 1 ;Rest QUOTND: .BLKW 1 ;Quotient Divisionsroutine (Doppelwort) ----------------------------- Aufgabe: Division einer vorzeichenlosen Integerzahl im Doppel ------- wortformat durch eine vorzeichenlose Integerzahl im Wortformat, deren Ergebnis eine Integerzahl im Doppel- wortformat ist. Aufruf: CALL $DDIV ------- Parameter: ---------- - Eingabe: . in Register 0 Divisor . in Register 1 hoeherwertiger Teil des Dividenden . in Register 2 niederwertiger Teil des Dividenden - Ausgabe: . in Register 0 Rest . in Register 1 hoeherwertiger Teil des Quotienten . in Register 2 niederwertiger Teil des Quotienten Die Register R4, R5 werden von der Routine nicht benutzt. Der Inhalt des Registers R3 wird gerettet. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. 13 Beispiel: --------- . . MOV DIVDND,R1 ;hoeherw. Teil des Divid. nach R1 MOV DIVDND+2,R2 ;niederw. Teil des Divid. nach R2 MOV DIVSOR,R0 ;Divisor nach R0 CALL $DDIV MOV R0,REST ;R0 enthaelt Rest der Division MOV R1,QUOTND ;R1 enthaelt hoeherw. Teil des Qu. MOV R2,QUOTND+2 ;R2 enthaelt niederw. Teil des Qu. . . . DIVDND: .LONG 100000 ;Dividend DIVSOR: .WORD 999. ;Divisor REST: .BLKW 1 ;Rest QUOTND: .BLKW 2 ;Quotient 3.2. Arithmetik fuer das Datenformat Mehrfachwort ------------------------------------------------- Es ergeben sich folgende Zahlenbereiche: Integer-Wort -2(hoch 15)...2(hoch 15)-1 Integer-Doppelwort -2(hoch 31)...2(hoch 31)-1 Integer-Dreifachwort -2(hoch 47)...2(hoch 47)-1 Integer-Vierfachwort -2(hoch 63)...2(hoch 63)-1 3.2.1. Integer-Addition ($ADDM) ------------------------------- Aufgabe: Diese Routine umfasst die vorzeichenbehaftete Addition ------- von Integerzahlen im Wort- bis Vierfachwortformat. Aufruf: CALL $ADDM ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD s1 ;Adresse des 1. Summanden .WORD s2 ;Adresse des 2. Summanden .WORD su ;Adresse der Summe .WORD wl ;Adresse der Laengenzelle Fuer die Belegung der Laengenzelle gelten folgende Regeln: Anzahl der Worte der Summanden gleich bit 0 bis 2 Anzahl der Worte bit 3 bis 15 0 14 Anzahl der Worte der Summanden ungleich bit 0 bis 2 Anzahl der Worte 2. Summand bit 3 bis 5 Anzahl der Worte 1. Summand bit 6 bis 15 0 Zugelassen sind nur die Kombinationen (oktal) 21, 31, 32, 41, 42, 43 Die Anzahl der Worte der Summe wird durch die groesste Anzahl der Worte der Summanden bestimmt. Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert zurueckgesetzt. Fehlerkennzeichnung ------------------- C-Bit = 1 Fehler durch Ueberlauf C-Bit = 0 Fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #PARAM,R0 ; R0 zeigt auf Param.-Tabelle CALL $ADDM BCS ERROR ;C=1 : Ueberlauf . . . ERROR: . . . ; PARAM: .WORD SUMND1,SUMND2,SUMME,WLEN SUMND1: .TRI 140737488355327 ;3-Wort-Zahl SUMND2: .LONG -2147483648. ;2-Wort-Zahl SUMME: .BLKW 3 ;Summe (3-Wort-Zahl) WLEN: .WORD 32 ;WL=3(SUMND1),WL=2(SUMND2) 3.2.2. Integer-Subtraktion ($SUBM) ---------------------------------- Aufgabe: Diese Routine umfasst die vorzeichenbehaftete Subtrak- ------- tion von Integerzahlen im Integer- bis Vierfachwort- format. Aufruf: CALL $SUBM ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten. 15 PARA: .WORD mn ;Adresse des Minuenden .WORD st ;Adresse der Subtrahenden .WORD df ;Adresse der Differenz .WORD wl ;Adresse der Laengenzelle Fuer die Belegung der Laengenzelle gelten folgende Regeln: Anzahl der Worte der Operanden gleich bit 0 bis 2 Anzahl der Worte bit 3 bis 15 0 Anzahl der Worte der Operanden ungleich bit 0 bis 2 Anzahl der Worte 2. Operand bit 3 bis 5 Anzahl der Worte 1. Operand bit 6 bis 15 0 Zugelassen sind nur die Kombinationen (oktal) 21, 31, 32, 41, 42, 43 Die Anzahl der Worte der Differenz wird durch die groesste Anzahl der Worte eines Operanden bestimmt. Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert rueckgesetzt. Fehlerkennzeichnung: -------------------- C-Bit = 1 Fehler durch Ueberlauf C-Bit = 0 Fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $SUBM BCS ERROR ;C=1 : Ueberlauf . . . ERROR: . . . ; PARAM: .WORD MINUND,SUBTND,DIFFNZ,WLEN ; MINUND: .TRI 140737488355327 ;3-Wort-Zahl SUBTND: .LONG 2147483647 ;2-Wort-Zahl DIFFNZ: .BLKW 3 ;Differenz (3-Wort-Zahl) WLEN: .WORD 32 ;WL=3(MINUND),WL=2(SUBTND) 16 3.2.3. Integer-Multiplikation ($MULM) ------------------------------------- Aufgabe: Diese Routine umfasst die vorzeichenbehaftete Multipli- ------- kation von Integerzahlen im Wort- bis Vierfachwort- format. Aufruf: CALL $MULM ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD f1 ;Adresse des 1. Faktors .WORD f2 ;Adresse des 2. Faktors .WORD pr ;Adresse des Produktes .WORD wl ;Adresse der Laengenzelle Fuer die Belegung der Laengenzelle gelten folgende Regeln: Anzahl der Worte der Faktoren gleich bit 0 bis 2 Anzahl der Worte bit 3 bis 7 0 bit 8 bis 15 Korrekturfaktor k Anzahl der Worte der Faktoren ungleich bit 0 bis 2 Anzahl der Worte 2. Faktor bit 3 bis 5 Anzahl der Worte 1. Faktor bit 6 und 7 0 bit 8 bis 15 Korrekturfaktor k Zugelassen sind nur die Kombinationen (oktal) 21, 31, 32, 41, 32, 43 Die Anzahl der Worte des Produktes ergibt sich aus der Addition der Anzahl der Worte der Operanden, wobei maximal 4 Worte dargestellt werden. Bei Angabe eines Korrekturfaktors k erfolgt eine dezimale Rechtsverschiebung des Produktes um k Stellen. Die letzte Dezimalstelle des Produktes ist gerundet. k=0 bewirkt keine Verschiebung. k = k1 + k2 - K3 k1 gedachte Kommastelle des 1. Faktors k2 gedachte Kommastelle des 2. Faktors k3 gedachte Kommastelle des Produktes Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert gesetzt. 17 Fehlerkennzeichnung: -------------------- C-Bit = 1 - das Produkt vor Auswertung des Korrekturfaktors ist gleich bzw. groesser als 2(hoch 79) - das Produkt P*10[hoch-(k-1)]+5 ist gleich bzw. groesser als 2(hoch 63) C-Bit = 0 - fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $MULM BCS ERROR ;C=1 : Ueberlauf . . . ERROR: . . . ; PARAM: .WORD FAKTR1,FAKTR2,PRODKT,WLEN ; FAKTR1: .TRI 140737488355327. ;3-Wort-Zahl FAKTR2: .LONG 100000 ;2-Wort-Zahl PRODKT: .BLKW 4 ;Produkt (4-Wort), da max. Wortlaenge WLEN: .WORD 32 ;WL=3(FAKTR1),WL=2(FAKTR2) 3.2.4. Integer-Division ($DIVM) ------------------------------- Aufgabe: Diese Routine umfasst die vorzeichenbehaftete Division ------- von Integerzahlen im Wort- bis Vierfachwortformat. Aufruf: CALL $DIVM ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD dd ;Adresse des Dividenden .WORD ds ;Adresse des Divisors .WORD qu ;Adresse des Quotienten .WORD wl ;Adresse der Laengenzelle Fuer die Belegung der Laengenzelle gelten folgende Regeln: Anzahl der Worte der Operanden gleich bit 0 bis 2 Anzahl der Worte bit 3 bis 7 0 bit 8 bis 15 Korrekturfaktor k 18 Anzahl der Worte der Operanden ungleich bit 0 bis 2 Anzahl der Worte Divisor bit 3 bis 5 Anzahl der Worte Dividend bit 6 bis 7 0 bit 8 bis 15 Korrekturfaktor k Zugelassen sind nur die Kombinationen (oktal) 21, 31, 32, 41, 42, 43 Die Anzahl der Worte des Quotienten ist gerundet. Bei Angabe eines Korrekturfaktors k erfolgt vor der Division eine dezimale Linksverschiebung des Dividenden um k Stellen. Fuer k=0 erfolgt keine Verschiebung. k = k1 - k2 + k3 k1 gedachte Kommastelle des Divisors k2 gedachte Kommastelle des Dividenden k3 gedachte Kommastelle des Quotienten Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert gesetzt. Fehlerkennzeichnung: -------------------- C-Bit = 1 - der Divisor besitzt den Wert 0 - bei der dezimalen Linksverschiebung tritt Ueberlauf ein C-Bit = 0 - fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $DIVM BCS ERROR ;C=1 : Ueberlauf . . . ERROR: . . . ; PARAM: .WORD DIVDND,DIVSOR,QUOTND,WLEN DIVDND: .TRI 140737488355327. ;3-Wort-Zahl DIVSOR: .LONG -2147483648. ;2-Wort-Zahl QUOTND: .BLKW 3 ;QUOTIENT (3-Wort-Zahl) WLEN: .WORD 32 ;WL=3(DIVDND),WL=2(DIVSOR) 19 3.3. Arithmetik fuer das Datenformat Tetraden --------------------------------------------- 3.3.1. Tetradische Addition ($TEAD) ----------------------------------- Aufgabe: Die Routine umfasst die vorzeichenbehaftete Addition ------- von tetradischen Zeichenketten mit max. 31 Ziffern. Aufruf: CALL $TEAD ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten. PARA: .WORD k1 ;Adresse der 1. Tetradenkette .WORD k2 ;Adresse der 2. Tetradenkette .WORD k5 ;Adresse der Summe Die Laenge der Summe ist immer um ein Byte groesser als die des groessten Operanden. Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert zurueckgesetzt. Fehlerkennzeichnung: -------------------- C-Bit = 1 Fehler durch Ueberlauf C-Bit = 0 Fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $TEAD BCS ERROR ;C=1 : Ueberlauf . . . ERROR: . . . ; PARAM: .WORD TETRA1,TETRA2,TETRAS ;Param.-Liste ; TETRA1: .BLKB 10. ;Feld fuer Tetradenkette 1 TETRA2: .BLKB 5 ;Feld fuer Tetradenkette 2 TETRAS: .BLKB 11. ;Feld fuer Summen-Tetradenkette 20 3.3.2. Tetradische Subtraktion ($TESU) -------------------------------------- Aufgabe: Die Routine umfasst die vorzeichenbehaftete Subtraktion -------- tetradischer Zeichenketten mit max. 31 Ziffern. Aufruf: CALL $TESU ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD k1 ;Adresse der 1. Tetradenkette .WORD k2 ;Adresse der 2. Tetradenkette .WORD kd ;Adresse der Differenz Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert zurueckgesetzt. Fehlerkennzeichnung ------------------- C-Bit = 1 Ueberschreitung der max. Ziffernanzahl C-Bit = 0 Fehlerfreie Abarbeitung Beispiel: --------- . . . MOV $PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $TESU BCS ERROR ;C=1 : Ueberlauf . . . ERROR: . . . ; PARAM: .WORD TETRA1,TETRA2,TETRAD ;Param.-Liste ; TETRA1: .BLKB 10. ;Feld fuer Tetradenkette 1 TETRA2: .BLKB 5 ;Feld fuer Tetradenkette 2 TETRAD: .BLKB 11. ;Feld fuer Diff.-Tetradenkette 3.3.3. Tetradische Verschiebung ($TEVE) --------------------------------------- Aufgabe: Die Routine realisiert die Rechtsverschiebung einer ------- tetradischen Zeichenkette, wobei eine Rundung der letzten Stelle wahlweise erfolgt. Die max. Ziffernan- zahl betraegt 31. Aufruf: CALL $TEVE ------- 21 Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD k1 ;Adresse der Tetradenkette .BYTE n ;Anzahl der Verschiebungen .BYTE m ;= 0 keine Rundung ;> 0 Rundung der letzten Stelle Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert zurueckgesetzt. Beispiel: --------- . . . MOV $PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $TEVE BCS ERROR . . . ERROR: . . . ; PARAM: .WORD TETRAK ;Param.-Liste .BYTE 11. ;Rechtsverschiebung um 11 Stellen .BYTE 1 ;letzte Stelle gerundet ; TETRAK: .BLKW 8. ;Bereich fuer Tetradenkette Fehlerkennzeichnung: -------------------- C-Bit = 1 Falsche Parameter C-Bit = 0 Fehlerfreie Abarbeitung 3.3.4. Tetradischer Vergleich ($TECP) ------------------------------------- Aufgabe: Die Routine realisiert den Vergleich zweier tetradischer ------- Zeichenketten von max. 31 Ziffern. Der Vergleich kann vorzeichenbehaftet oder betragsmaessig erfolgen. Aufruf: CALL $TECP ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD k1 ;Adresse 1. Tetradenkette .WORD k2 ;Adresse 2. Tetradenkette .Word n ;= 0 mit Vorzeichen ;= 1 ohne Vorzeichen 22 Das Ergebnis des Vergleiches wird im PSW bereitgestellt. Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert zurueckgesetzt. Fehlerkennzeichnung: -------------------- C-Bit = 1 Laengenueberschreitung der Tetradenkette C-Bit = 0 Fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $TECP BCS ERROR BEQ 2$ ;Auswertung des Vergleichs BMI 3$ NOP ;TETRA1 > TETRA2 . . 2$: NOP ;TETRA1 = TETRA2 . . 3$: NOP ;TETRA1 < TETRA2 . . ERROR: . ; PARAM: .WORD TETRA1,TETRA2 ;Param.-Liste .WORD O ;Vergleich mit Vorzeichen ; TETRA1: .BLKW 8. ;Feld fuer Tetradenkette 1 TETRA2: .BLKW 8. ;Feld fuer Tetradenkette 2 23 4. Routinen fuer Eingabekonvertierung ------------------------------------- 4.1. Grundroutinen der Eingabekonvertierung ------------------------------------------- Die Eingabekonvertierung akzeptiert KOI-7-Daten als Eingabe und konvertiert sie in entsprechende Zahlenformate. Es gibt drei Typen der Eingabekonvertierung: KOI-7 in Binaer-Doppelwort KOI-7 in Binaer-Einwort KOI-7 in Radix-50 Tabelle 7: Routinen der Eingabekonvertierung --------------------------------------------------------- |Name |ext. Datentyp |internes Format | Pkt. | --------------------------------------------------------- |DD1CT |Dezimal mit VZ |Wort |4.1.2. | |.DD2CT |Dezimal mit VZ |Doppelwort |4.1.1. | |DD3CT |Dezimal mit VZ |Dreifachwort |4.2.1. | |DD4CT |Dezimal mit VZ |Vierfachwort |4.2.2. | |$CDTB |Dezimal ohne VZ |Wort |4.1.2. | |.OD2CT |Oktal mit VZ |Doppelwort |4.1.1. | |$COTB |Oktal ohne VZ |Wort |4.1.2. | --------------------------------------------------------- |$CAT5 |3 KOI-7-Zeichen |Wort, RADIX50 |4.1.3. | |$CAT5B | |Wort, RADIX50 |4.1.3. | |$KOTE |KOI-7-Zeichen |beliebig, Te- |4.3. | | | |traden | | --------------------------------------------------------- 4.1.1. KOI-7-Code in Binaer-Doppelwort (.DD2CT,.0D2CT) ------------------------------------------------------ Dezimal in Binaer-Doppelwort (.DD2CT) ------------------------------------- Aufgabe: Die Routine konvertiert vorzeichenbehaftete Dezimal- -------- zahlen in vorzeichenbehaftete Binaerzahlen (Doppelwort- format). Konvertiert werden Zahlen mit vorangestelltem Vorzeichen und nachgestelltem Dezimalpunkt. Ein vorange- gestelltes #-Symbol erzwingt eine oktale Konvertierung. Andere Zeichen als die Ziffern 0 bis 9 innerhalb der Eingabekette fuehren zum Abbruch der Routine. Aufruf: CALL .DD2CT ------- Parameter: ---------- Register 3 Adresse des Doppelwortes, in dem die konvertierte Zahl abgespeichert werden soll Register 4 Anzahl der Eingabezeichen, die zu konvertieren sind Register 5 Adresse der Zeichenkette, die zu konvertieren ist 24 Der hoeherwertige Teil der konvertierten Zahl steht im 1. Wort des durch Register 3 adressierten Doppelwortes und der niederwertige Teil im 2. Wort. Nach dem Verlassen der Routine werden die Anfangswerte der Register wiederhergestellt. Fehlerkennzeichnung: -------------------- C-Bit = 1 Verbotenes Zeichen, Konvertierung unvollstaendig C-Bit = 0 Konvertierung erfolgreich Beispiel: --------- . . . MOV #WERT,R3 ;R3 zeigt auf konvert. Zahl MOV #9.,R4 ;9 Zeichen werden konvertiert MOV #EINFLD,R5 ;R5 zeigt auf Eingabebereich CALL .DD2CT BCS ERROR ;C=1 : Konvertierungsfehler . . . ERROR: . ;Fehlermitteilung . . EINFLD: .BLKW 5 ;Eingabebereich WERT: .BLKW 2 ;Bereich fuer konvert. Zahl Oktal in Binaer-Doppelwort (.OD2CT) ----------------------------------- Aufgabe: Die Routine konvertiert Oktalzahlen in Binaerzahlen des ------- Doppelwortformates. Zur Konvertierung zugelassen sind Zahlen, bestehend aus vorangestelltem Vorzeichen und den Ziffern 0 - 7. Ein vorangestelltes #-Symbol ist erlaubt. Ein nachgestellter Dezimalpunkt fuehrt zu einer dezimalen Konvertierung. Andere als die angegebenen Zeichen fuehren zum Abbruch der Konvertierung. Aufruf: CALL .OD2CT ------- Parameter: ---------- Register 3 Adresse des Doppelwortes, in dem die konvertierte Zahl abgespeichert werden soll Register 4 Anzahl der Eingabezeichen, die zu konvertieren sind Register 5 Adresse der Zeichenkette, die zu konvertieren ist Der hoeherwertige Teil des Wortes steht im 1. Wort des im Register 3 angegebenen Doppelwortes und der niederwertige Teil im 2. Wort. Nach dem Verlassen der Routine werden die Anfangswerte der Register wiederhergestellt. 25 Fehlerkennzeichnung: -------------------- C-Bit = 1 Verbotenes Zeichen, Konvertierung unvollstaendig C-Bit = 0 Konvertierung erfolgreich Beispiel: --------- . . . MOV #WERT,R3 ;R3 zeigt auf konvert. Zahl MOV #12.,R4 ;12 Zeichen werden konvert. MOV #EINFLD,R5 ;R5 zeigt auf Eingabebereich CALL .OD2CT BCS ERROR ;C=1 : Konvertierungsfehler . . . ERROR: . ;Fehlermitteilung . . ; EINFLD: .BLKW 7 ;Eingabebereich WERT: .BLKW 2 ;Bereich fuer konvert. Zahl 4.1.2. KOI-7-Code in Binaer-Einwort ($CDTB,DD1CT,$COTB) ------------------------------------------------------- Dezimal in binaer ohne Vorzeichen ($CDTB) ----------------------------------------- Aufgabe: Die Routine konvertiert vorzeichenlose KOI-7-Dezimalzah- ------- len in Binaerzahlen. Zugelassene Zeichen sind lediglich die Ziffern 0 bis 9. Die zu konvertierenden Zahlen mues- sen durch ein Endezeichen abgeschlossen werden. Endezei- chen sind: Leerzeichen, Tab, Alphazeichen und spezielle Symbole. Vorangestellte Leerzeichen und Tabulatoren wer- den ignoriert. Die groesste zu konvertierende Zahl be- sitzt den Wert 65535. Es ist zu beachten, dass keine Ueberpruefung der Groesse des Eingabewertes erfolgt und keine Fehlermeldung ausgegeben wird. Aufruf: CALL $CDTB ------- Parameter: ---------- -Eingabe . Register 0 Adresse des ersten Bytes der zu konvertieren- den Zahl -Ausgabe . Register 0 Adresse des naechsten Bytes des Eingabepuffers . Register 1 konvertierte Zahl . Register 2 erkanntes Endezeichen Die Routine nutzt die Routine $SAVRG zum Registerretten bzw. -wiederherstellen. 26 Fehlerkennzeichnung: -------------------- Bei ordnungsgemaesser Konvertierung steht im Register R2 das zu erwartende Endezeichen. Ein anderer Inhalt des Registers bedeutet ein unzulaessiges Zeichen im Eingabebereich. Beispiel: --------- Konvertierung einer Reihe von Dezimalzahlen in die Binaerzahlen. Die Zeichenkette steht im Eingangspuffer (EPUF) und hat folgendes Format: YYYY(HT)YY(HT)YYY(SP) Die Tabulatoren trennen die Dezimalzahlen und das Leerzeichen dient als Endezeichen. Die Binaerzahlen werden im Ausgabepuffer (APUF) abgespeichert. . . . MOV #APUF,R4 ;Ausgabeadresse MOV #EPUF,R0 ;Eingabeadresse 1$: CALL $CDTB ;Konvertieren MOV R1,(R4)+ ;Ergebnis speichern ;und Pufferadresse weiterstellen CMP #11,R2 ;HT? BEQ 1$ ;naechste Zahl CMP #40,R2 ;SP? BEQ 2$ ;Weiterarbeit JMP FEH ;Fehlerbehandlung 2$: . . FEH: . . . Dezimal in Binaer mit Vorzeichen (DD1CT) ---------------------------------------- Aufgabe: Die Routine DD1CT konvertiert eine vorzeichenbehaftete ------- Dezimalzahl in eine vorzeichenbehaftete Binaerzahl. Es sind die Ziffern 0 bis 9 zugelassen. Positive Zahlen koennen mit dem Zeichen + und negative Zahlen muessen mit dem Zeichen - beginnen. Der Dezimalpunkt wird uebergangen. Jedes andere nicht zugelassene Zeichen fuehrt zum Abbruch. Die zu konvertierenden Dezimalzahlen koennen zwischen -2 (hoch 15) und +2(hoch 15)-1 liegen. Aufruf: CALL DD1CT ------- 27 Parameter: ---------- Fuer die Abarbeitung der Routine sind vom Anwender folgende Parameter in Registern bereitzustellen: R3: Adresse des Wort-Feldes, in dem die konvertierte Zahl abgespeichert werden soll R4: Anzahl der zu konvertierenden Zeichen R5: Adresse der Zeichenkette, die konvertiert werden soll Nach dem Verlassen der Routine sind die Anfangswerte der Register wiederhergestellt. Fehlerkennzeichnung: -------------------- C-Bit = 1 Fehlerhafte Konvertierung C-Bit = 0 Fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #WERT,R3 ;R3 zeigt auf konvertierte Zahl MOV #5,R4 ;5 Zeichen werden konvertiert MOV #EINFLD,R5 ;R5 zeigt auf Eingabebereich CALL DD1CT BCS ERROR ;C=1 : Konvertierungsfehler . . . ERROR: . ;Fehlermitteilung . . ; EINFLD: .BLKW 3 ;Eingabebereich WERT: .BLKW 1 ;Bereich fuer konvert. Zahl Oktal in Binaer ($COTB) ----------------------- Aufgabe: Die Routine konvertiert KOI-7-Oktalzahlen in Binaerzah- ------- len. Zugelassene Zeichen sind die Ziffern 0 - 7. Die zu konvertierenden Zahlen muessen durch ein Endezeichen abgeschlossen werden. Endezeichen sind: Leerzeichen, Alphazeichen und spezielle Symbole. Vorangestellte Leerzeichen und Tab werden ignoriert. Aufruf: CALL $COTB ------- Parameter: ---------- - Eingabe: . Register 0 Adresse des 1. Bytes der zu konvertierenden Zahl - Ausgabe: . Register 0 Adresse des naechsten Byte im Eingabepuffer . Register 1 konvertierte Zahl . Register 2 erkannte Endezeichen 28 Die Routine nutzt die Routine $SAVRG zur Registerrettung und - -wiederherstellung. Fehlerkennzeichnung: -------------------- Bei ordnungsgemaesser Konvertierung steht im Register R2 das zu erwartende Endezeichen. Ein anderer Inhalt des Registers bedeutet ein unzulaessiges Zeichen im Eingabebereich. Beispiel: --------- . . . MOV #EINFLD,R0 ;R0 zeigt auf Eingabebereich CALL $COTB TST R2 ;R2 enthaelt Endezeichen BNE ERROR ;R2 ungleich 0: kein Endezeichen MOV R1,WERT ;konv. Wert abspeichern . . . ERROR: . ;Fehlermitteilung . . ; EINFLD: .BLKW 3 WERT: .BLKW 1 4.1.3. KOI-7-Code in Radix-50 ($CAT5,$CAT5B) -------------------------------------------- KOI-7-Code in Radix-50 ($CAT5) ------------------------------ Aufgabe: Die Routine konvertiert ein bis drei KOI-7-Zeichen in ------- einen Radix-50-Wert von 16 bit. Zugelassene Zeichen sind die Ziffern 0 - 9, Alphazeichen und die Zeichen $ und Punkt. Fuer eine vollstaendige Konvertierung werden drei gueltige Zeichen benoetigt. Unzulassige Zeichen fuehren zum Abbruch der Konvertierung. Wird in einer Eingabezeichenkette ein unzulaessiges Zeichen gefunden, so ergibt sich die konvertierte Zahl aus (n) zulaes- sigen Zeichen und nachgestellten Leerzeichen. Ein Leerzeichen in der KOI-7-Zeichenkette fuehrt zum Abbruch der Konvertierung. Aufruf: CALL $CAT5 ------- Paramater: ---------- - Eingabe: . Register 0 Adresse des ersten Zeichens der zu konvertie- renden Zahl . Register 1 = 0 der Punkt dient als Endezeichen = 1 der Punkt wird als zulaessiges Zeichen konvertiert 29 - Ausgabe: . Register 0 Adresse des naechsten Zeichens der Eingabe- zeichenkette . Register 1 Radix-50-Wert . Register 2 Endezeichen Letztes Zeichen der Eingabezeichenkette oder das unzulaessige Zeichen, das zum Abbruch fuehrte. Die Routine nutzt die Routine $SAVRG zu Registerretten und - -wiederherstellen. - Fehlerkennzeichnung: -------------------- C-Bit = 1 wenn weniger als drei Zeichen konvertiert werden C-Bit = 0 vollstaendige Konvertierung Beispiel: --------- . . . MOV #EINFLD,R0 ;R0 zeigt auf Eingabefeld CLR R1 ;R1=0 : Punkt ist Endezeichen CALL $CAT5 BCS ERROR ;C=1 : Konvertierungsfehler MOV R1,WERT ;Radix-Wort abspeichern . . . ERROR: . . . ; EINFLD: .ASCII /RA./ ;zu konvert. Textzeichen WERT: .BLKW 1 ;konvertierter Radix-Wert KOI-7-Code mit Leerzeichen in Radix-50 ($CAT5B) ----------------------------------------------- Aufgabe: Die Routine konvertiert eine dreistellige KOI-7- ------- Zeichenkette einschliesslich Leerzeichen in einen Radix- 50-Wert von 16 bit. Zulaessige Zeichen sind die Ziffern 0 - 9, Alphazeichen und die Zeichen $, Leerzeichen und Punkt. Fuer eine vollstaendige Konvertierung werden drei guel- tige Zeichen benoetigt. Unzulaessige Zeichen fuehren zum Abbruch der Konvertierung. Wird in einer Eingabezeichen- kette ein unzulaessiges Zeichen gefunden, so ergibt sich die konvertierte Zahl aus den (n) zulaessigen Zeichen und nachgestellten Leerzeichen. Aufruf: CALL $CAT5B ------- 30 Parameter: ---------- - Eingabe: . Register 0 Adresse des 1. Zeichens der zu konvertierenden Zahl . Register 1 = 0 Punkt dient als Endezeichen = 1 Punkt wird als zulaessiges Zeichen konvertiert - Ausgabe: . Register 0 Adresse des naechsten Zeichens in der Eingabe- zeichenkette . Register 1 Radix-50-Wert . Register 2 Endezeichen Letztes Zeichen der Eingabezeichenkette oder das unzulaessige Zeichen, das zum Abbruch der Konvertierung fuehrte. Die Routine nutzt die Routine $SAVRG zur Registerrettung und - -wiederherstellung. Fehlerkennzeichnung: -------------------- C-Bit = 1 wenn weniger als drei Zeichen konvertiert werden C-Bit = 0 vollstaendige Konvertierung 4.2. Eingabekonvertierung fuer das Datenformat Mehrfachwort ----------------------------------------------------------- 4.2.1. Integer-Dreifachwort (DD3CT) ----------------------------------- Der Modul DD3CT konvertiert eine vorzeichenbehaftete KOI-7- Dezimalzahl in eine vorzeichenbehaftete Binaerzahl in der Laenge von 3 Worten. Es sind die Ziffern 0 bis 9 zugelassen. Positive Zahlen koennen mit dem Zeichen + und negative Zahlen muessen mit dem Zeichen - beginnen. Der Dezimalpunkt wird uebergangen. Jedes andere nicht zugelassene Zeichen fuehrt zum Abbruch. Die zu konvertierenden Dezimalzahlen koennen zwischen -2(hoch 47) und +2(hoch 47)-1 liegen. Parameter: ---------- Fuer die Abarbeitung des Moduls sind vom Anwender folgende Parameter in Registern bereitzustellen: R3: Adresse des Dreiwort-Feldes, in dem die konvertierte Zahl stehen soll R4: Anzahl der Zeichen in der zu konvertierenden Zeichen- kette R5: Adresse der Zeichenkette, die konvertiert werden soll Der Modul veraendert keine Register. Die konvertierte Zahl wird mit den hoeherwertigen 15 bit in Wort 1 des in R3 definierten Feldes abgespeichert. Im Bit 15 befindet sich das Vorzeichen. In absteigender Wertigkeit befinden sich die weiteren 32 bit in den Worten 2 und 3. Aufruf: CALL DD3CT ------- 31 Fehlerkennzeichnung: -------------------- C-Bit = 1 zu lange Zeichenktte bzw. unerlaubtes Zeichen C-Bit = 0 fehlerfreie Abarbeitung Beispiel: --------- . . . MOV #WERT,R3 ;R3 zeigt auf konvert. Zahl MOV #15.,R4 ;15 Zeichen werden konvert. MOV #EINFLD,R5 ;R5 zeigt auf Eingabebereich CALL DD3CT BCS ERROR ;C=1 : Konvertierungsfehler . . . ERROR: . ;Fehlermitteilung . . ; EINFLD: .BLKW 8. ;Eingabebereich WERT: .BLKW 3 ;Bereich fuer 3-Wort-Zahl 4.2.2. Integer-Vierfachwort (DD4CT) ----------------------------------- Aufgabe: Der Modul DD4CT konvertiert eine vorzeichenbehaftete ------- KOI-7-Dezimalzahl in eine vorzeichenbehaftete Binaerzahl in der Laenge von 4 Worten. Es sind die Ziffern 0 - 9 zugelassen. Positive Zahlen koennen mit dem Zeichen + und negative Zahlen muessen mit dem Zeichen - beginnen. Der Dezimalpunkt wird uebergangen. Jedes andere nicht zugelassene Zeichen fuehrt zum Abbruch. Die zu konvertierenden Dezimalzahlen koennen zwischen -2(hoch 63) und +2(hoch 63)-1 liegen. Parameter: ---------- Fuer die Abarbeitung des Moduls sind vom Anwender folgende Parameter in Registern bereitzustellen: R3: Adresse des Vierwort-Feldes, in dem die konvertierte Zahl gespeichert stehen soll R4: Anzahl der Zeichen in der zu konvertierenden Zeichen- kette R5: Adresse der Zeichenkette, die konvertiert werden soll Der Modul veraendert keine Register. Die konvertierte Zahl wird mit den hoeherwertigen 15 bit in Wort 1 des in R3 definierten Feldes abgespeichert. Im Bit 15 in diesem Wort befindet sich das Vorzeichen. In absteigender Wertigkeit befinden sich die weiteren 48 bit in den Worten 2, 3 und 4. Aufruf: CALL DD4CT ------- Fehlerkennzeichnung: -------------------- C-Bit = 1 Fehlerhafte Konvertierung C-Bit = 0 Konvertierung erfolgreich 32 Beispiel: --------- . . . MOV #WERT,R3 ;R3 zeigt auf konvertierte Zahl MOV #19.,R4 ;19 Zeichen werden konvertiert MOV #EINFLD,R5 ;R5 zeigt auf Eingabebereich CALL DD4CT BCS ERROR ;C=1 : Konvertierungsfehler . . . ERROR: . ;Fehlermitteilung . . ; EINFLD: .BLKW 10. ;Eingabebereich WERT: .BLKW 4 ;Bereich fuer 4-Wort-Zahl 4.3. Eingabekonvertierung fuer das Datenformat Tetraden ($KOTE) --------------------------------------------------------------- Aufgabe: Die Routine realisiert die Konvertierung einer KOI-7- ------- Zeichenkette in die Tetradendarstellung. Zugelassene Zeichen sind: Ziffern, Vorzeichen vor und nach der Zahl, Dezimalpunkt Aufruf: CALL $KOTE ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD t ;Adresse der konvertierten Zahl (Tetradenkette) .WORD k ;Adresse der Textkette .BYTE n ;Zeichenanzahl (extern) .BYTE m ;Byteanzahl (intern) Bei n=0 werden alle KOI-7-Zeichen bis zu einem nicht zulaessigen Endekennzeichen konvertiert. Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine auf ihren Anfangswert zurueckgestellt. Fehlerkennzeichnung: -------------------- C-Bit = 1 Laenge der Eingabekette ueberschritten, falsches Zeichen in der Eingabekette C-Bit = 0 fehlerfreie Abarbeitung 33 Beispiel: --------- . . . MOV #PARAM,R0 ;R0 zeigt auf Parameterliste CALL $KOTE . . . PARAM: .WORD EINFLD,TETRAK .BYTE 31. ;Zeichenanzahl im Eingabefeld .BYTE 16. ;Byteanzahl der Tetradenkette ; ; ZEICHENKETTE IM EINGABEFELD : EINFLD: .ASCII /-111111111122222222223333333333/ TETRAK: .BLKW 8. ;Tetradenkette 34 5. Routinen fuer Ausgabekonvertierung ------------------------------------- 5.1. Grundroutinen der Ausgabekonvertierung ------------------------------------------- Die Ausgabekonvertierung akzeptiert numerisch abgespeicherte Binaerdaten als Eingabe und konvertiert sie in entsprechende Zeichenketten. Es gibt vier Gruppen der Ausgabekonvertierung: Binaer in dezimal Binaer in oktal Binaer in KOI-7 Radix-50 in KOI-7 Tabelle 8: Routinen der Ausgabekonvertierung -------------------------------------------------------- |Name |internes Format |externer Datentyp |Pkt. | -------------------------------------------------------- |DCDD2W |Doppelwort |Dezimal mit VZ |5.1.1.| |DCDD3W |Dreifachwort |Dezimal mit VZ |5.2.1.| |DCDD4W |Vierfachwort |Dezimal mit VZ |5.2.2.| |$CBDSG |Wort |Dezimal mit VZ |5.1.1.| |$CBDMG |Wort |Dezimal fuenfstellig |5.1.1.| |$CDDMG |Doppelwort |Dezimal ohne VZ |5.1.1.| |$CBOSG |Wort |Oktal mit VZ |5.1.2.| |$CBTMG |Byte |Oktal ohne VZ |5.1.2.| |$CBOMG |Wort |Oktal sechsstellig |5.1.2.| |$TIM |Uhrzeit |KOI-7 HH:MM:SS.S |6.2.2.| |$DAT |Datum |KOI-7 TT-MMM-JJ |6.2.1.| |$CBDAT |Wort |Dezimal zweistellig |5.1.1.| |$CBTA |Wort |Dezimal / Oktal |5.1.3.| |$C5TA |Wort, Radix50 |3 KOI-7-Zeichen |5.1.4.| |$TEKO |Tetraden |KOI-7-Zeichen |5.3. | |$EDMSG |allgemeine Ausgabeformatierung |6.3. | -------------------------------------------------------- 5.1.1. Binaer in Dezimal ($CBDAT,$CBDMG,$BDSG,$CDDMG,DCDD2W) ------------------------------------------------------------ Die Konvertierung von Binaerzahlen in Dezimalzahlen umfasst 5 Routinen. Sie nutzen alle die $SAVRG Routine zum Retten der Register R3-R5. Die Inhalte der Register R1 und R2 werden zerstoert. Die Routine $CBTA wird von allen Routinen, die zu Abschn. 5.2.1. gehoeren, aufgerufen. Dabei werden, ausser von der $CDDMG-Routine, selbstaendig Konvertierungsparameter an die Routine gegeben, die lediglich ueber den Inhalt des Registers R2 veraendert werden koennen. Binaere Datumskonvertierung ($CBDAT) --------------------------------------- Aufgabe: Konvertiert wird ein Datum in binaerer Darstellung -------- (Wort) in eine zweistellige Dezimalzahl. Aufruf: CALL $CBDAT ------- 35 Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches R1 zu konvertierende Binaerzahl R2 Nullenunterdrueckung R2=0 Vornullenunterdrueckung; linksbuendige Darstellung R2>0 keine Vornullenunterdrueckung Nach Rueckkehr in das aufrufende Programm steht die naechste nutzbare Adresse des Ausgabebereiches im Register R0. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Binaer in 5stellige Dezimalzahl ohne Vorzeichen ($CBDMG) -------------------------------------------------------- Aufgabe: Konvertiert wird eine Binaerzahl (Wort) in eine 5stel- -------- lige KOI-7-Dezimalzahl. Aufruf: CALL $CBDMG ------- Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches R1 zu konvertierende Binaerzahl R2 Nullenunterdrueckung R2=0 Vornullenunterdrueckung; linksbuendige Darstellung R2>0 keine Vornullenunterdrueckung Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV WERT,R1 ;R1 enthaelt zu konvert. Wert MOV #1,R2 ;R2 Inform. ueber Vornullen CALL $CBDMG . . . AUSFLD: .BLKW 3 ;Ausgabebereich WERT: .WORD 32765. ;interner Wert Binaer in Dezimal mit Vorzeichen ($CBDSG) ----------------------------------------- Aufgabe: Konvertiert wird eine Binaerzahl (Wort) in eine 5stel- ------- lige vorzeichenbehaftete KOI-7-Dezimalzahl. Aufruf: CALL $CBDSG ------- 36 Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches R1 zu konvertierende Binaerzahl R2 Nullenunterdrueckung R2=0 Vornullenunterdrueckung; linksbuendige Darstellung R2>0 keine Vornullenunterdrueckung Nach Rueckkehr in das aufrufende Programm steht die naechste nutzbare Adresse des Ausgabebereiches im Register R0. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV WERT,R1 ;R1 enthaelt zu konvert. Wert MOV #1,R2 ;R2 Inform. ueber Vornullen CALL $CBDSG . . . AUSFLD: .BLKW 3 ;Ausgabebereich WERT: .WORD -32764. ;interner Wert Binaer in Dezimal doppelter Laenge ohne Vorzeichen ($CDDMG) ----------------------------------------------------------- Aufgabe: Konvertiert wird eine vorzeichenlose Binaerzahl ------- (Doppelwort) in eine 9stellige KOI-7-Dezimalzahl. Aufruf: CALL $CDDMG ------- Parameter: ---------- R0 Anfangsadresse des Ausgabenbereiches R1 Anfangsadresse des 2-Wort-Eingabebereiches R2 Nullenunterdrueckung R2=0 Vornullenunterdrueckung; linksbuendige Darstellung R2>0 keine Vornullenunterdrueckung Nach Rueckkehr in das aufrufende Programm steht die naechste nutzbare Adresse des Ausgabebereiches im Register R0. Besitzen die ersten 5 Stellen der Dezimalzahl den Wert 0, so erfolgt unabhaengig von R2 eine Vornullenunterdrueckung. Fehlerkennzeichnung: -------------------- Besitzt die Dezimalzahl mehr als 9 Zeichen, so setzt die $CDDMG- Routine fuenf $-Zeichen in den Ausgabebereich. 37 Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV #WERT,R1 ;R1 zeigt auf unkonv. 2-Wort-Wert MOV #1,R2 ;R2 Inform. ueber Vornullen CALL $CDDMG . . . AUSFLD: .BLKW 5 ;Ausgabebereich WERT: .LONG 100000 ;interner Wert Binaer in Dezimal doppelter Laenge mit Vorzeichen (DCDD2W) ---------------------------------------------------------- Aufgabe: Konvertiert wird eine vorzeichenbehaftete Binaerzahl ------- (Doppelwort) in eine 9stellige KOI-7-Dezimalzahl. Aufruf: CALL DCDD2W ------- Parameter: ---------- R0 enthaelt die Anfangsadresse des Ausgabefeldes, in dem die KOI-7-Dezimalzahl abgespeichert wird R1 enthaelt die Adresse des 2-Wort-Eingabefeldes R2 beinhaltet die Kennzeichnung fuer Vornullenbehandlung, wobei ein von Null verschiedener Inhalt Vornullenunter- drueckung bewirkt Nach erfolgreich verlaufener Konvertierung steht im Ausgabefeld die konvertierte Dezimalzahl. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV #WERT,R1 ;R1 Adr. unkonv.2-Wort-Wert MOV #1,R2 ;R2 Inform. ueber Vornullen CALL DCDD2W . . . AUSFLD: .BLKW 5 ;Ausgabebereich WERT: .LONG 100000 ;interner Wert 38 5.1.2. Binaer in Oktal ($CBOMG,$CBOSG,$CBTMG) --------------------------------------------- Die Konvertierung von Binaerzahlen in Oktalzahlen umfasst 3 Routinen. Sie nutzen alle die $SAVRG-Routine zum Retten und Wiederherstellen der Register R3 bis R5. Die Inhalte der Register R1-R2 werden zerstoert. Alle Routinen nutzen die $CBTA-Routine. Von den Routinen werden Konvertierungsparameter fuer die $CBTA- Routine bereitgestellt, die lediglich ueber den Inhalt des Registers R2 veraendert werden koennen. Binaer in 6stellige Oktalzahl ohne Vorzeichen ($CBOMG) ------------------------------------------------------ Aufgabe: Konvertiert wird eine Binaerzahl (Wort) in eine 6stel- ------- lige vorzeichenlose KOI-7-Oktalzahl. Aufruf: CALL $CBOMG ------- Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches R1 zu konvertierende Binaerzahl R2 Nullenunterdrueckung R2=0 Vornullenunterdrueckung; linksbuendige Darstellung R2>0 keine Vornullenunterdrueckung Nach Rueckkehr in das aufrufende Programm steht die naechste nutzbare Byte-Adresse des Ausgabebereiches im Register R0. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige: Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV WERT,R1 ;R1 enthaelt zu konv. Wert CLR R0 ;Vornullenunterdrueckung CALL $CBOMG . . . AUSFLD: .BLKW 3 ;Ausgabebereich WERT: .WORD 177777 ;interner Wert Binaer in Oktal mit Vorzeichen ($CBOSG) --------------------------------------- Aufgabe: Konvertiert wird eine Binaerzahl (Wort) in eine 6stel- ------- lige vorzeichenbehaftete KOI-7-Oktalzahl. Aufruf: CALL $CBOSG ------- 39 Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches R1 zu konvertierende Binaerzahl R2 Nullenunterdrueckung R2=0 Vornullenunterdrueckung; linksbuendige Darstellung R2>0 keine Vornullenunterdrueckung Nach Rueckkehr in das aufrufende Programm steht die naechste Adresse des Ausgabebereiches im Register R0. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV WERT,R1 ;R1 enthaelt zu konv. Wert MOV #1,R2 ;keine Vornullenunterdrueckung CALL $CBOSG . . . AUSFLD: .BLKW 3 ;Ausgabebereich WERT: .WORD 177777 ;interner Wert Binaer in Oktal ohne Vorzeichen ($CBTMG) ---------------------------------------- Aufgabe: Konvertiert wird ein Binaer-Byte in eine 3stellige vor- ------- zeichenlose KOI-7-Oktalzahl. Aufruf: CALL $CBTMB ------- Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches R1 zu konvertierendes Byte; steht im niederwertigen Byte R2 Nullenunterdrueckung R2=0 Vornullenunterdrueckung; linksbuendige Darstellung R2>0 keine Vornullenunterdrueckung Nach Rueckkehr in das aufrufende Programm steht die naechste nutzbare Byte-Adresse des Ausgabebereiches im Register R0. Das niedere Byte des Registers R1 bleibt unveraendert. Das hoehere Byte wird von der Routine geloescht. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. 40 5.1.3. Universelle Routine Binaer in KOI-7 ($CBTA) -------------------------------------------------- Aufgabe: Konvertiert werden Binaerzahlen (Wortformat) in KOI-7- ------- Zahlen oder Oktalzahlen. Durch entsprechenden Parammter- aufbau koennen die Leistungen folgender Routinen durch direkten Aufruf der Routine $CBTA genutzt werden. Konv.-Radix Feldgroesse $CBDAT 10. 2 $CBDMG 10. 5 $CBDSG 10. 5 $CBOMG 8. 6 $CBOSG 8. 6 $CBTMG 8. 3 Aufruf: CALL $CBTA ------- Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches R1 zu konvertierende Binaerzahl R2 Konvertierungsparameter bit 0-7 Konvertierungsradix (2. - 10.) bit 8 = 0 Binaerzahl ohne Vorzeichen = 1 Binaerzahl mit Vorzeichen bit 9 Vornullenunterdrueckung = 0 keine Vornullen = 1 mit Vornullen bit 10 Flag fuer das Ersetzen von Vornullen durch Leerzeichen = 0 Vornullen werden nicht mit Blanks gefuellt, wenn bit 9 = 1 = 1 Vornullen werden mit Blanks gefuellt, wenn bit 9=1 bit 11 - 15 Feldgroesse des Ausgabebereiches (1 - 32) Die Routine nutzt die $SAVRG Routine zum Retten und Rueckspeichern der Register R3 bis R5. Die Register R1 und R2 werden zerstoert. Nach Rueckkehr in das aufrufende Programm steht im Register R0 die naechste Adresse des Ausgabebereiches. Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Beispiele: ---------- Es werden Beispiele fuer den Inhalt von R2 (Konvertierungsvorschrift) fuer bestimmte Faelle gegeben. 1. Binaerzahl in 2-stellige KOI-7-Dezimalzahl ohne Vorzeichen Konvertierungsradix = 10 Feldgroesse = 2 kein Vorzeichen keine Vornullenunterdrueckung kein Ersetzen der Vornullen durch Leerzeichen R2=11012 (oktal) 41 2. Binaerzahl in 5-stellige KOI-7-Dezimalzahl ohne Vorzeichen Konvertierungsradix = 10 Feldgroesse = 5 kein Vorzeichen keine Vornullenunterdrueckung Ersetzen der Vornullen durch Leerzeichen R2=27012 (oktal) 3. Binaerzahl in 5-stellige KOI-7-Dezimalzahl mit Vorzeichen Konvertierungsradix = 10 Feldgroesse = 6 Vorzeichen keine Vornullenunterdrueckung Ersetzen der Vornullen durch Leerzeichen R2=33412 (oktal) 4. Binaerzahl in 6-stellige Oktalzahl mit Vorzeichen Konvertierungsradix = 8 Feldgroesse = 7 Vorzeichen Vornullenunterdrueckung R2=34410 (oktal) 5. Binaerzahl in 6-stellige Oktalzahl ohne Vorzeichen Konvertierungsradix = 8 Feldgroesse = 6 ohne Vorzeichen Vornullenunterdrueckung R2=30010 (oktal) 6. Binaerzahl in 3-stellige Oktalzahl ohne Vorzeichen Konvertierungsradix = 8 Feldgroesse = 3 ohne Vorzeichen keine Vornullenunterdrueckung Vornullen bleiben Null R2=15010 (oktal) 5.1.4. Radix-50 in KOI-7 ($C5TA) -------------------------------- Aufgabe: Konvertiert wird eine Radix-50-Zahl von 16 bit in eine ------- KOI-7-Zeichenkette. Aufruf: CALL $C5TA ------- Parameter: ---------- R0 Anfangsadresse des Ausgabebereiches (erstes Byte der konvertierten Zahl) R1 zu konvertierender Radix-50-Wert Nach Rueckkehr in das aufrufende Programm steht im Register R0 die Adresse des naechsten Bytes. Die ausgegebenen KOI-7-Zeichen belegen 3 Bytes des Ausgabebereiches. Die Register R3 - R5 werden nicht benutzt. Die Register R1 und R2 werden zerstoert. 42 Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV WERT,R1 ;R1 enthaelt Radix-Wert CALL $C5TA . . . AUSFLD: .BLKW 2 ;Ausgabebereich WERT: .WORD 3223 ;Radix-Wert fuer "ABC" 5.2. Ausgabekonvertierung fuer das Datenformat Mehrfachwort ----------------------------------------------------------- 5.2.1. Integer-Dreifachwort (DCDD3W) ------------------------------------ Aufgabe: Der Modul DCDD3W konvertiert eine Binaerzahl, abgespei- ------- chert in 3 Worten, in eine KOI-7-Dezimalzahl mit maximal 15 Ziffern. Bei einer negativen Zahl wird ein Minus- zeichen vor die Dezimalzahl gesetzt. Parameter: ---------- Es muessen folgende Parameter fuer die Abarbeitung des Moduls bereitgestellt werden: R0: enthaelt die Anfangsadresse des Ausgabefeldes, in dem die KOI-7-Dezimalzahl abgespeichert werden soll R1: enthaelt die Adresse des 3 Worte langen Eingabefeldes R2: beinhaltet die Kennzeichnung fuer die Vornullenbehand- lung, wobei der Inhalt Null eine Vornullenunterdruek- kung und der Inhalt ungleich Null keine Vornullenunter- drueckung bewirkt Nach erfolgreich verlaufener Konvertierung steht im Ausgabefeld die konvertierte Dezimalzahl. Aufruf: CALL DCDD3W ------ Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. 43 Beispiel: --------- . . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV #WERT,R1 ;R1 zeigt auf unkonv. 3-Wort-Wert MOV #1,R2 ;R2=1:keine Vornullenunter- drueckung CALL DCDD3W . . . AUSFLD: .BLKW 8. ;Ausgabebereich WERT: .TRI 14000000123123000 ;interner Wert 5.2.2. Integer-Vierfachwort (DCDD4W) ------------------------------------ Aufgabe: Der Modul DCDD4W konvertiert eine Binaerzahl, abgespei- ------- chert in 4 Worten, in eine KOI-7-Dezimalzahl mit maximal 19 Ziffern. Bei einer negativen Zahl wird ein Minuszeichen vor die Dezimalzahl gesetzt. Parameter: ---------- Es muessen folgende Parameter fuer die Abarbeitung des Moduls bereitgestellt werden: R0: enthaelt die Anfangsadresse des Ausgabefeldes, in dem die KOI-7-Dezimalzahl gspeichert werden soll R1: enthaelt die Adresse des 4 Worte langen Eingabefeldes R2: beinhaltet die Kennzeichnung fuer die Vornullenbehand- lung, wobei der Inhalt Null eine Vornullenunterdruek- kung und der Inhalt ungleich Null keine Vornullenunter- drueckung bewirkt Nach einer erfolgreich verlaufenen Konvertierung steht im Ausgabefeld die konvertierte Dezimalzahl. Aufruf: CALL DCDD4W ------- Fehlerkennzeichnung: -------------------- Es erfolgt keine Fehleranzeige. Beispiel: --------- . . MOV #AUSFLD,R0 ;R0 zeigt auf Ausgabebereich MOV #WERT,R1 ;R1 Adr. unkonv. 4-Wort-Wert MOV #0,R2 ;R2=0 : Vornullenunterdrueckung CALL DCDD4W . . AUSFLD: .BLKW 10. ;Ausgabebereich WERT: .QUAD 72231720366547756071 ;interner Wert 44 5.3. Ausgabekonvertierung fuer das Datenformat Tetraden ($TEKO) -------------------------------------------------------- Aufgabe: Die Routine realisiert die Konvertierung von Tetraden in ------- KOI-7-Zeichenketten. Zugelassen sind nur Zeichenketten mit max. 31 Ziffern. Aufruf: CALL $TEKO ------- Parameter: ---------- Die Parameteruebergabe erfolgt ueber das Register R0. Dieses muss die Adresse eines Parameterfeldes mit folgendem Aufbau enthalten: PARA: .WORD j ;Adresse der Ausgabektte .WORD t ;Adresse der Tetradenkette .BYTE n ;= 0 keine Vornullen .BYTE m ;Vorzeichenindikator ;bit 0 = 0 Vorzeichen vor Zahl ; = 1 Vorzeichen nach Zahl ;bit 1 = 0 + Signifikant ; = 1 + wird ignoriert ;bit 2 = 0 mit Vorzeichen = 1 ohne Vorzeichen ;bit 7 = 0 letzte Stelle mit Rundung ; = 1 letzte Stelle ohne Rundung .BYTE l ;Gesamtzeichenzahl .BYTE p ;Ziffern nach dem Dezimalpunkt Ist die im Ausgabeformat angegebene Anzahl der zu druckenden Ziffern kleiner als die Ziffernanzahl der Tetradendarstellung, so werden die niedrigsten Ziffern abgeschnitten. Die letzte Stelle kann gerundet werden. Die Registerinhalte der benutzten Register werden vor dem Verlassen der Routine wiederhergestellt. Bei l = 0 wird die gesamte Tetradenkette konvertiert. Fehlerkennzeichnung ------------------- C-Bit = 0 fehlerfreie Abarbeitung C-Bit = 1 verbotene Zeichen in der Tetradenkette 45 Beispiel: --------- . . . MOV #PARAM,R0 ;R0 zeigt auf Param.-Tabelle CALL $TEKO BCS ERROR . . . ERROR: . . . PARAM: .WORD AUSFLD,TETRAK ;Param.-Liste .BYTE 0 ;keine Vornullen .BYTE 0 ;Vorzeichen vor Zahl, Rundung .BYTE 31. ;31 Zeichen der Ausgabekette .BYTE 0 ;keine Ziffer nach Dez.-Punkt ; AUSFLD: .BLKW 16. ;Ausgabefeld TETRAK: .BLKW 8. ;Bereich fuer Tetradenkette 46 6. Routinen zur Formatierung von Ausgaben ----------------------------------------- Mit diesen Routinen koennen Daten, welche intern gespeichert sind, in das KOI-7-Format uebertragen werden. Dabei werden diese Zeichen zu lesbaren Ausgabeinformationen geordnet. Zu nutzen sind folgende Formatierungs-Routinen: - $CVTUC Mit kleinen Zeichen dargestellte KOI-7-Zeichenfolgen werden in grosse Zeichen uebertragen. - $DAT Eine binaer dargestellte 3-Wort-Information (Datum) wird in eine K0I-7-Zeichenkette von 9 Zeichen uebertragen. - $TIM Eine binaer dargestellte Zeitinformation wird in eine KOI-7- Zeichenkette uebergefuehrt. Intern gespeicherte Daten werden in KOI-7-Formate uebertragen, die der Anwender selbst spezifizieren kann. Moeglich sind die Formate: alphanumerisch oktal dezimal Darueber hinaus koennen diese konvertierten Daten so umgruppiert werden, dass Ausgaben fuer Drucker oder Bildschirm entstehen (siehe auch Makro $GTIM, Anleitung fuer Programmierer, Teil 2). 6.1. Uebertragung in Grossbuchstaben ($CVTUC) --------------------------------------------- Aufgabe: Klein geschriebener KOI-7-Text wird byteweise in gross- ------- geschriebenen umgewandelt und umgespeichert. Parameter: --------- Im Anwenderprogramm sind folgende Parameter bereitzustellen: R0: Adresse der zu konvertierenden Textfolge R1: Adresse des Ausgabebereichs R2: Byteanzahl in der zu konvertierenden Textfolge Aufruf: CALL $CVTUC ------ Ausfuehrung: ------------ Die Register 3 bis 5 werden von der Routine nicht genutzt. Bei der Rueckkehr zur rufenden Task wird Register 2 zerstoert, waeh- rend Register 0 und 1 nicht veraendert werden. Die Reihenfolge der Zeichen bleibt unveraendert, alle alphabetischen Zeichen, welche klein geschrieben waren, werden in grosse Zeichen umge- setzt, die bereits gross geschriebenen bleiben erhalten. Der gross geschriebene Text steht danach im Ausgabebereich. Beim Aufruf der Routine werden der Eingabe- und Ausgabebereich vom Nutzer festgelegt. Der Fall, dass R0=R1 ist ebenfalls moeglich. Dabei werden die kleinen Zeichen im gleichen Bereich durch grosse ersetzt. 47 Beispiel: --------- . . . MOV #KBUCH,R0 ;R0 zeigt auf Feld mit Kleinb. MOV #GBUCH,R1 ;R1 zeigt auf Feld mit Grossb. MOV #10.,R2 ;R2 enthaelt Zeichenanzahl CALL $CVTUC . . . ; KLEINBUCHSTABEN (OKTAL DEFINIERT) : KBUCH: .BYTE 141,142,143,144,145,146,147,150,151,152 GBUCH: .BLKB 10. ;Feld fuer Grossbuchstaben 6.2. Konvertierung von Datum und Uhrzeit ---------------------------------------- Konvertiert werden das binaer dargestellte Datum und die Uhrzeit in KOI-7-Ausgabefolgen. Das Datum wird in Tag - Monat - Jahr, die Uhrzeit in eines der Formate Stunde Stunde : Minute Stunde : Minute : Sekunde Stunde : Minute : Sekunde : Teil der Sekunde umgewandelt. 6.2.1. Datumskonvertierung ($DAT) --------------------------------- Aufgabe: Konvertiert wird das interne binaere Datum in das -------- standardisierte 9-Zeichen KOI-7-Format. TT-MMM-JJ, wobei TT = Tag (1 - 31) MM = Monat (erste 3 Buchstaben) und JJ = Jahr (letzte 2 Ziffern) bedeuten. Parameter: --------- Im Anwenderprogramm sind zwei Register mit Informationen zu versorgen. Register 0 muss die Adresse des Ausgabebereiches enthalten, in welchem das konvertierte Datum gespeichert wird. Register 1 muss die Adresse des Eingabebereiches (3 Worte) enthalten, in dem die binaeren Daten gespeichert sind. In diesem Bereich muessen stehen: 48 im 1. Wort: die letzten zwei Ziffern des Jahres, im 2. Wort: entsprechend dem Monat Ziffern von 01 - 12 im 3. Wort: entsprechend dem Tag ein Wert von 01 - 31 Aufruf: CALL $DAT ----- Ausfuehrung: ------------ Genutzt wird die Routine $SAVRG zur Rettung der Register 3 bis 5 der rufenden Task. Gearbeitet wird mit Register 2. Der Inhalt wird dabei zerstoert. Wenn dieser benoetigt wird, muesste er durch die rufende Task vor dem Aufruf gerettet werden. Pruefungen des Inhaltes der Eingangsinformation werden nicht durchgefuehrt. Der Ausgang ist folgender: 1. Das konvertierte Datum ist im Ausgabebereich gespeichert. 2. In R0 steht die Adresse des naechsten verfuegbaren Speicher- platzes des Ausgabebereiches. 3. In R1 steht die Adresse des anschliessenden Eingabebereiches (R1+6). 6.2.2. Zeitkonvertierung ($TIM) ------------------------------- Aufgabe: Konvertiert wird die binaer gespeicherte Zeit in eine -------- KOI-7-Ausgabefolge. Diese hat die Form HH:MM:SS.S Der Eingangswert hat das folgende Format: Wort 1: 0 - 23 Tagesstunde Wort 2: 0 - 59 Minuten der Stunde Wort 3: 0 - 59 Sekunden der Minute Wort 4: Ist von der Uhrfrequenz abhaengig Wort 5: Ist von der Uhrfrequenz abhaengig (Teile der Sekunde) Parameter: --------- Im Anwenderprogramm muessen 3 Register mit den folgenden Informationen versorgt werden. Register 0 muss die Adresse des Ausgabebereiches enthalten. In welchem die konvertierte Zeit gespeichert wird. Register 1 muss die Anfangsadresse des Eingabebereiches enthalten, in welchem die Zeitwerte gespeichert sind. Register 2 muss die Parameterspezifikation enthalten. Es bedeuten: R2 = 0 oder 1, dass die Stunde in das Format HH, R2 = 2, dass die Stunde und Minute in das Format HH:MM, R2 = 3, dass in das Format HH:MM:SS, R2 = 4 oder 5, dass in das Format HH:MM:SS.S konvertiert werden soll. Aufruf: CALL $TIM ------ 49 Ausfuehrung: ------------ Genutzt wird die Routine $SAVRG zur Rettung der Register 3 bis 5 der rufenden Task, die Register 0 und 1 werden neu eingestellt. Das Register 2, welches den Parameterzaehler enthaelt, ist danach zerstoert. Weiter genutzt werden die Routinen $CBDAT, welche die bei der KOI-7-Konvertierung benoetigte Division bzw. die Zeitkon- vertierung von jeweils zwei Ziffern durchfuehren. Der Ausgang von $TIM ist folgender: 1. Die konvertierte Zeit ist im Ausgabebereich gespeichert 2. In R0 steht die Adresse des naechsten verfuegbaren Speicher- platzes 3. In R1 steht die Adresse des folgenden Wortes des Eingabebe- reiches Beispiel: --------- Das Beispiel zeigt die Anwendung der Routinen $DAT und $TIM. EBER: .WORD 80. :Jahr .WORD 10. ;Monat = OCT .WORD 06. ;Tag .WORD 12. ;Stunde .WORD 20. ;Minute .WORD 33. ;Sekunde .WORD .WORD .WORD ABER: .BLKB 20. MOV ABER,R0 ;Ausgabebereich MOB EBER,R1 ;Eingabebereich CALL $DAT MOVB 11,(R0)+ MOV 3,R2 CALL $TIM Im Ausgabebereich steht nach Ablauf des Programms 06 - OCT - 80 12:20:33 6.3. Aufbereitung von Ausgabe-Zeichenfolgen ($EDMSG) ---------------------------------------------------- Konvertiert werden intern gespeicherte Daten in KOI-7-Zeichen. Bei der Ausgabe entstehen Folgen von Druckzeichen, die auf Drucker oder Terminal ausgegeben werden koennen. Verschiedene KOI-7-Datentypen koennen in formatisierte Zeilen eingeordnet werden. Leerzeichen werden eingesteuert. Intern aufbereitete Daten, welche in einem Block stehen, werden in das externe Format umgewandelt und in den Ausgabeblock des rufenden Programms gespeichert. Die Bearbeitung, welche durch $EDMSG auszufuehren ist, wird durch Anweisngen in Eingabefolgen spezifiziert. Die Eingabefolgen koennen sowohl KOI-7-Text als auch Bearbeitungs- anweisungen enthalten. Alle nicht zu veraendernden Zeichen werden kopiert und in den Ausgabeblock gebracht. Eingabefolgen sind im ASCIZ-Format zu schreiben. Es gibt folgende 2 Arten von Bearbei- tungsanweisungen: - Datenkonvertierungsanweisungen - Steuerungsanweisungen fuer das Ausgabeformat 50 Die Anweisungen sind wie folgt aufgebaut: % Begrenzer fuer Bearbeitungsanweisung n Wiederholungszaehler (Dezimalzahl) fuer Bearbeitungsopera- tionen n=0 oder n nicht spezifiziert bilden den Wieder- holungszaehler 1 V besagt, dass der Wiederholungszaehler durch einen Wert dar- gestellt wird, welcher unmittelbar vor den weiteren Angaben zu den entsprechenden Bearbeitungsoperationen des in der Task stehenden Argumentblockes spezifiziert ist L Buchstaben fuer 18 Bearbeitungsoperationen %L, nL oder VL Tabelle 9: Bearbeitungsanweisungen ---------------------------------------------------------------- Anweisung Form Operation ---------------------------------------------------------------- A %A Das KOI-7-Zeichen wird von der im Block (KOI-7-Folge) der Task stehenden Adresse in den Ausgabe- auch nicht block gebracht. druckbare --------------------------------------------------- Zeichen %nA Die naechsten n KOI-7-Zeichen werden ent- werden in sprechend in den Ausgabeblock gebracht. den Ausga- --------------------------------------------------- beblock %VA Der Wert des im Block der Task stehenden gebracht folgenden Wortes wird als Wiederholungs- zaehler genutzt, und es wird wie oben uebertragen. ---------------------------------------------------------------- B %B Das folgende Binaer-Byte wird von der im Byteweise Block der Task stehenden Adresse in den Konvertie- Ausgabeblock uebertragen, wobei die ent- rung von sprechende Konvertierung ausgefuehrt wird. Binaer in --------------------------------------------------- Oktal %nB Es werden n Binaer-Bytes entsprechend konvertiert und uebertragen. Zwischen den Zahlen sind Leerzeichen eingefuegt. --------------------------------------------------- %VB Uebertragung wie bei %VA, Konvertierung von Binaer-Byte in Oktal. Zwischen den Zahlen sind Leerzeichen eingefuegt. ---------------------------------------------------------------- D %D Der Binaerwert im folgenden Wort des Arg.- Konvertie- -Blocks der Task wird konvertiert und in rung von den Ausg.-Block uebertragen. Binaer in --------------------------------------------------- vorzeichen- %nD Konvertierung und Uebertragung der behaftete naechsten n Binaerw. des Arg.-Blocks gem. Dezimal- %D, zwischen den Zahlen wurden Tabulatoren zahl, eingefuegt. keine Nullen- --------------------------------------------------- unter- %VD Nutzt den Wert des folgenden Wortes im drueckung Arg.-Block als Wiederholungszahler, konver- tiert und uebertraegt gem. %D. Zwischen den Zahlen stehen Tabulatoren. ----------------------------------------------------------------- 51 Tabelle 9 (Fortsetzung) ---------------------------------------------------------------- Anweisung Form Operation ---------------------------------------------------------------- E %E Die KOI-7-Zeichen werden von der im Block (Ausw. KOI- der Task stehenden Adresse in den Ausgabe- 7) druckbare block uebertragen. KOI-7-Zei- -------------------------------------------------- chen in %nE n Zeichen werden wie bei %E uebertragen. 7-Bit -------------------------------------------------- KOI-7-Code. %VE Gemaess dem Wert im folgenden Wort des in Nicht druck- der Task stehenden Blockes wird die da- bare Zeichen durch spezifizierte Anzahl von Zeichen in werden durch den Ausgabeblock uebertragen. Leerzeichen im Ausgabe- block er- setzt ---------------------------------------------------------------- F %F Ein Form-Feed-Zeichen wird im Ausgabeblock Seitenvor- gesetzt. schub ------------------------------------------------- (FF) %nF n Form-Feed-Zeichen werden im Ausgabeblock gesetzt. ------------------------------------------------- %VF Setzen von Form-Feed-Zeichen mit dem Wie- derholungszaehler gem. %VA. ---------------------------------------------------------------- I %I Transportiert eine ASCIZ-Zeichenkette von Einfuegen der angegebenen Adresse in den Ausgabe- einer ASCIZ- block. Zeichenkette ---------------------------------------------------------------- M %M Konvertiert wird ein Binaerwert im folgen- Binaer- in den Wort des in der Task stehenden Blockes Dezimalzahl, in einen Dezimalwert, wobei fuehrende Nul- unterdrueckt len unterdrueckt werden. Abspeichern im fuehrende Ausgabeblock. Nullen -------------------------------------------------- %nM Es werden n Binaerwerte gem. %M konver- tiert und uebertragen. Zwischen den Zahlen werden Tabulatoren gesetzt. -------------------------------------------------- %VM Uebertragung wie bei %VA mit entsprechen- der Konvertierung gem. %M. Zwischen den Zahlen werden Tabulatoren gesetzt. ---------------------------------------------------------------- N %N CR und LF werden im Ausgabeblock gesetzt. Zeilenbe- -------------------------------------------------- ginn (CR) %nN n CR und LF werden im Ausgabeblock gesetzt und Zeilen- -------------------------------------------------- vorschub %VN Setzen von CR und LF mit Wiederholungs- (LF) zaehler gemaess %VA. ---------------------------------------------------------------- 52 Tabelle 9 (Fortsetzung) ---------------------------------------------------------------- Anweisung Form Operation ---------------------------------------------------------------- O %O wie %D fuer O Binaer in -------------------------------------------------- vorzeichen- %nO Wie %nD fuer O. zwischen den Zahlen werden behaftete Tabulatoren gesetzt. Oktalzahl -------------------------------------------------- %VO Wie %VA fuer O. zwischen den Zahlen werden Tabulatoren gesetzt. ---------------------------------------------------------------- P %P wie %D fuer P Binaer in -------------------------------------------------- Oktalzahlen %nP Wie %nD fuer P. Zwischen den Zahlen werden ohne Vor- Tabulatoren gesetzt. zeichen, -------------------------------------------------- keine %VP Wie %VA fuer P. Zwischen den Zahlen werden Nullen- Tabulatoren gesetzt. unterdruek- kung ---------------------------------------------------------------- Q %Q wie %D fuer Q Binaer in -------------------------------------------------- Oktalzahlen %nQ Wie %nD fuer Q. Zwischen den Zahlen werden ohne Vor- Tabulatoren gesetzt. zeichen, -------------------------------------------------- mit Nullen- %VQ Wie %VA fuer Q. Zwischen den Zahlen werden unterdruek- Tabulatoren gesetzt. kung ---------------------------------------------------------------- R %R wie %D fuer R (Radix-50-Wert im Arg.Block) Radix-50 -------------------------------------------------- in KOI-7 %nR wie %nD fuer R -------------------------------------------------- %VR wie %VA fuer R ---------------------------------------------------------------- S %S Leerzeichen im Ausgabeblock wird gesetzt. Leerzeichen -------------------------------------------------- %nS n Leerzeichen im Ausgabeblock werden ge- setzt. -------------------------------------------------- %VS Setzen von Leerzeichen mit Wiederholungs- zaehler gemaess %VA. ---------------------------------------------------------------- T %T wie %M fuer T (Doppelwort im Arg. Block) Doppelwort -------------------------------------------------- Binaer- in %nT Wie %nM fuer T. Zwischen den Zahlen werden Dezimalzahl Tabulatoren gesetzt. -------------------------------------------------- %VT Wie %VA fuer T. Zwischen den Zahlen werden Tabulatoren gesetzt. ---------------------------------------------------------------- U %U wie %D fuer U Binaer in -------------------------------------------------- Dezimalzahl, %nU Wie %nD fuer U. Zwischen den Zahlen Tab. keine Vor- -------------------------------------------------- nullenunter- %VU Wie %VA fuer U. Zwischen den Zahlen Tab. drueckung ---------------------------------------------------------------- 53 Tabelle 9 (Fortsetzung) ---------------------------------------------------------------- Anweisung Form Operation ---------------------------------------------------------------- X %X Konvertiert wird ein Dateiname, im Block Dateinamen der Task stehend, in eine KOI-7-Folge des Konver- Formats name.typ. Wenn vorhanden, werden tierung Oktalwerte in KOI-7 konvertiert und in den Ausgabeblock gespeichert. -------------------------------------------------- %nX Wie %nA fuer X. Zwischen den Zeichenfolgen werden Tabulatoren gesetzt. -------------------------------------------------- %VX Wie %VA fuer X. Zwischen den Zeichenketten werden Tabulatoren gesetzt. ---------------------------------------------------------------- Y %Y Die naechsten 3 Binaer-Worte des Blockes Datumskon- in der Task werden in KOI-7-Zeichenfolgen vertierung des Formats TT-MM-JJ uebertragen und im Ausgabeblock gespeichert. ---------------------------------------------------------------- Z %0Z Das naechste Wort des Blockes in der Task Binaere oder enthaelt die Binaerdarstellung der Stunde Darstel- %1Z des Tages. Diese wird in eine KOI-7-Zei- lung der chenfolge uebertragen und im Ausgabeblock Zeit in abgespeichert. KOI-7-Zei- Format HH chenfolgen --------------------------------------------------- %2Z Die naechsten 2 Worte des Blockes in der Task enthalten die Binaerdarstellung von Stunde des Tages und Minute der Stunde. Diese werden in eine KOI-7-Zeichenfolge uebertragen und im Ausgabeblock abgespei- chert. Format HH:MM --------------------------------------------------- %3Z Die naechsten 3 Worte des Blockes in der Task enthalten die Binaerdarstellung der Stunde des Tages, Minute der Stunde und Sekunde der Minute. Diese werden in eine KOI-7-Zeichenfolge uebertragen und im Aus- gabeblock abgespeichert. Format HH:MM:SS --------------------------------------------------- %4Z Die naechsten 5 Worte des Blockes in der oder Task enthalten die Binaerdarstellung der %5Z Stunde des Tages, der Minute der Stunde, der Sekunde der Minute und Teile der Se- kunde. Diese werden in eine KOI-7-Zei- chenfolge uebertragen und im Ausgabe- block abgespeichert. Format HH:MM:SS.S, wobei .S Zehntelsekun- den sind. ---------------------------------------------------------------- < %n< n KOI-7-Leerzeichen, welche durch eine (Vereinba- Marke (Null) abgeschlossen sind, werden im ren eines Ausgabeblock vorgesehen. Damit wird ein Byte-Feldes) festes Byte-Feld vereinbart. Der Ausgabe- zeiger steht auf dem 1. Leerzeichen. ---------------------------------------------------------------- 54 Tabelle 9 (Fortsetzung) ---------------------------------------------------------------- Anweisung Form Operation ---------------------------------------------------------------- > %n> Der Zeiger des Ausgabeblockes wird bis (Festlegen zu einer Feldmarke (Null) oder, bis der einer Wiederholungszaehler n mal weitergestellt Feldmarke) wurde, gefuehrt. ---------------------------------------------------------------- Bemerkungen: ------------ - Der Argumentblock der Task enthaelt die zu konvertierenden Binaerinformationen oder die Adressen von KOI-7-Zeichen und Auswahl-KOI-7-Zeichen (nur druckbare Zeichen). - Der Ausgabeblock dient zur Abspeicherung der uebertragenen Zeichenfolgen. - Bevor die $EDMSG-Routine aufgerufen wird, muss der Nutzer den Argumentblock in der Task aufbauen. . Wenn KOI-7- oder Auswahl-KOI-7-Zeichen in den Ausgabeblock uebertragen werden sollen, muessen die Adressen der Zeichenfolge im Argumentblock stehen. . Wenn binaer-byte-weise in Oktalzahlen konvertiert wird, muessen die Adressen der Binaerinformationen im Argumentblock stehen. Wenn Binaerwerte zu konvertieren sind, muessen die Werte selbst im Argumentblock stehen. . Bei der Konvertierung von Dateinamen muss der Argumentblock in Wort 1 - 3 den Radix-50-Dateinamen, in Wort 4 den Radix- 50-Dateityp und in Wort 5 binaer die Versionsnummer enthalten. . Wenn das Binaerdatum zu konvertieren ist, muss der Argument- block im 1. Wort die letzten 2 Ziffern des Jahres, im 2. Wort die Angabe des Monats (1 - 12) und im 3. Wort den Tag des Monats (1 - 31) enthalten. . Wenn die Binaerzeit zu konvertieren ist, muessen im Wort 1 die Tagesstunde (0 - 23), im 2. Wort die Minuten der Stunde (0 - 59), im Wort 3 die Sekunden der Minute (0 - 59), im Wort 4 und 5 Teile der Sekunde, die von der Uhrfrequenz ab- haengen, enthalten sein. . Vor dem Aufruf von $EDMSG muessen im Anwenderprogramm folgende Parameter bereitgestellt werden: in Register 0 die Startadresse des Ausgabeblockes in Register 1 die Adresse der Eingabefolge in Register 2 die Startadresse des Argumentblockes Danach erfolgt der Aufruf CALL $EDMSG . Genutzt werden die $SAVRG-Routine zum Retten und Wiederher- stellen der Register 3 - 5 der rufenden Task sowie die Ausgabe-, Zeit- und Datumskonvertierung. . Ausgang der Routine sind: Konvertierte bzw. formatisierte Daten im Ausgabeblock. In R0 steht die Adresse des folgenden verfuegbaren Byte des Aus- gabeblockes. In R1 steht die Anzahl der Bytes der Information des Ausgabeblockes. In R2 steht die Adresse des folgenden Arguments des Blockes in der Task. 55 Beispiele: ---------- Beispiel 1: ----------- Eingabefolge fuer die Bearbeitung EGFOLG:.ASCIZ /%F%10SXXXZAHLENXXX%2N%8S%VD%4N%10SXXXENDEXXX/ Aufbau des Argumentblockes ARBLOK: .WORD 3. ;Wiederholungszahler .WORD 20. .WORD -54. ;Binaerzahlen .WORD -2414. Ausgabeblock AUBLOK: .BLKB 100 Quellenprogrammanweisungen START: MOV #AUBLOK,RO MOV #EGFOLG,R1 MOV #ARBLOK,R2 CALL $EDMSG Dabei entsteht die folgende Ausgabe .............XXXZAHLENXXX ........20.....-54......-2414 .............XXXENDEXXX Beispiel 2: ----------- Eingabefolge fuer die Bearbeitung EGFOLG: .ASCIZ /%F%8SXXAUSGABE: %2N%8S vom %Y bis %Y/ Aufbau des Argumentblockes ARBLOK: .WORD 85. ;Jahr .WORD 9. ;Monat (SEP) .WORD 4. ;Tag .WORD 85. ;Jahr .WORD 10. ;Monat (OCT) .WORD 12. ;Tag 56 Aufbau des Ausgabeblockes dabei entsteht folgende Ausgabe AUBLOK: .BLKB 100 ........XXAUSGABE: Quellenprogrammanweisungen Anfang: MOV #AUBLOK,R0 .......vom 4-SEP-85 bis 12-OCT-85 MOV #EGFOLG,R1 MOV #ARBLOK,R2 CALL $EDMSG 57 7. Programme zur Speicherverwaltung ----------------------------------- 7.1. Einleitung --------------- Mit Hilfe der Programme zur Speicherverwaltung ist es moeglich, den taskfreien dynamischen Speicher zu nutzen. Das betrifft den Adressraum vom Ende einer Task bis zur Grenze der Partition. Auf Anforderung werden innerhalb dieses Bereiches Speicherbloecke zur Verfuegung gestellt. Waehrend die Programme zur Verwaltung des dynamischen Speichers nur den taskfreien Raum innerhalb einer Partition nutzen, wird durch die Programme zur Verwaltung des virtuellen Speichers der Plattenspeicher einbezogen. Die zugehoerigen Programme sind in den Systembibliotheken VMLIB.OLB und SYSLIB.OLB enthalten. 7.2. Verwaltung des virtuellen Speichers ---------------------------------------- 7.2.1. Vorbemerkungen --------------------- Wenn der verfuegbare freie dynamische Speicher nicht ausreicht, um eine bestimmte Taskforderung zu erfuellen, werden Bloecke aus dem dynamischen Speicher in die Plattenarbeitsdatei ausgelagert. Ueber virtuelle Adressen ist ein Zugriff auf die ausgelagerten Bloecke moeglich. Im einzelnen stehen Programme fuer folgende Funktionen zur Verfuegung: - Initialisierung des virtuellen Speichers - Zuordnung von dynamischem Speicher - Zuordnung von virtuellem Speicher - Blockverwaltung Es ist empfehlenswert, dass der Nutzer zur Erleichterung der Arbeit nur auf folgende Programme zurueckgreift: $INIVM zur Initialisierung des dynamischen Speichers und der Arbeitsdatei $ALSVB Programme zur Zuordnung von virtuellem Speicher $ALVRT $CVLOK Programme zur Blockverwaltung $UNLPG $CVRL $WRMPG 7.2.2. Voraussetzungen fuer die Nutzung der Programme ----------------------------------------------------- 7.2.2.1. Taskbilderforderungen ------------------------------ Es gibt 2 Versionen der Programme zur Verwaltung des virtuellen Speichers S: die statistische und die nichtstatistische. Jede Version besteht aus 12 Programmoduln und einem Datenmodul. Die Programmoduln enthalten ein oder mehrere Teilprogramme, die sich gegenseitig aufrufen koennen. Eine diesbezuegliche Uebersicht ist in Tabelle 7 enthalten. 58 Bei der statistischen Version kann der Anwender ueber globale Symbole auf die Werte fuer erfolgte Plattenzugriffe und die Groesse des dynamischen Speichers zugreifen. Im einzelnen sind es folgende Moduln: - INIVS Er initialisiert 3 Doppelwortfelder: $WRKAC enthaelt Anzahl der Arbeitsdateizugriffe $WRKRD enthaelt Anzahl der Lesezugriffe $WRKWR enthaelt Anzahl der Schreibzugriffe Die Definition dieser Felder erfolgt im Modul VMDAS. - CVRS Er versorgt $WRKAC mit der Anzahl der Arbeitsdatei- zugriffe. - RDPAS Er versorgt $WRKRD und $WRKAC mit den Arbeitsdateilese- bzw. Arbeitsdateischreibzugriffen. - GTCOS Er versorgt $FRSIZ mit der Groesse des freien dyna- mischen Speichers. $FRSIY muss als Einfachwort im Quell- programm definiert sein. Beim Taskbilden muessen vom Anwender die Objektbibliothek der Speicherverwaltungsprogramme (VMLIB) und alle benoetigten Moduln einschliesslich des Datenmoduls angegeben werden. Wahlweise Moduln sind ALSVB und INIDM. Im folgenden werden zwei Beispiele fuer die Spezifizierung der statistischen und der nichtstatistischen Version angegeben: Statistische Version: LB:[1,1]VMLIB/LB:ALBLK:ALSVB:ALVRT:CVRS:EXTSK:FNDPG:GTCOS LB:[1,1]VMLIB/LB:INIDM:INIVS:MRKPG:RDPAS:RQVCB:VMUTL:VMDAS Nichtstatistische Version: LB:[1,1]VMLIB/LB:ALBLK:ALSVB:ALVRT:CVRL:EXTSK:FNDPG:GTCOR LB:[1,1]VMLIB/LB:INIDM:INIVM:MRKPG:RDPAG:RQVCB:VMUTL:VMDAT 7.2.2.2. Fehlerbehandlungsroutine ($ERMSG) ------------------------------------------ Vom Anwender ist eine Fehlerbehandlungsprogramm $ERMSG beim Taskbilden anzugeben. Es wird von den Programmen $ALVRT, $ALBLK, $RDPAG und $WRPAG benoetigt. Wird kein Fehlerbehandlungsprogramm angegeben, dann erfolgt beim Taskbilden eine Global- Fehlermeldung. Das Fehlerbehandlungsprogramm muss Definitionen fuer folgende globale symbolische Fehlercodes enthalten: E$R4 - $ALBLK, keine dynamische Speicherzuordnung moeglich E$R73 - $RDPAG, $WRPAG I/0-Fehler beim Transfer Speicher/Platte und umgekehrt E$R76 - $ALVRT, keine virtuelle Speicherzuordnung moeglich S$V2 - Er wird von den o.g. Programmen benutzt, um Fehler anzu- zeigen, die vor einer Taskfortsetzung behoben sein muessen. Tritt ein Fehler auf, dann erfolgt in dem betreffenden Programm ein Aufruf des Fehlerbehandlungsprogramms mit: R1 niederes Byte: Fehlercode hoeheres Byte: Zusatzcode (S$V2) R2 Blockadresse CALL $ERMSG 59 Im Fehlerbehandlungsprogramm sollte dann eine Meldung ueber den spezifischen Fehler erfolgen, die Plattendatei mit CLOSE$ $WRKPT geschlossen und das Programm abgebrochen werden. 7.2.3. Initialisierung des virtuellen Speichers ($INIVM) -------------------------------------------------------- Das Programm initialisiert den taskfreien dynamischen Speicher, stellt den Kopf der Blockadressliste auf und initialisiert die Plattenarbeitsdatei $WRKPT. Die Arbeitsdatei hat eine Kapazitaet von 64 K Worten. Im Programm sind vom Anwender folgende Vereinba- rungen zu treffen: FSRSZ$ 0 ;definiert Dateispeicherbereich fuer FCS $FRHD:: .BLKW 2 ;Bereich fuer Adresse des Beginns des freien ;dynamischen Speichers W$KLUN==lun ;logische Geraetenummer (LUN) der Arbeits- ;platte. Der Anwender muss selbst fuer die ;Zuweisung der LUN zum Plattengeraet sorgen. W$KEXT==x ;Arbeitsdateigroesse in Bloecken ;X>=0 nicht zusammenhaengend ;X> 0 zusammenhaengend N$MPAG==512. ;Groesse des festen Blockes fuer die Blockzu- ;ordnung. Wenn es genuegend freien ;dynamischen Speicher gibt, wird ein fester ;Block definiert, um die Zuordnung zu be- ;schleunigen. Parameter: --------- R1 naechste Adresse des taskfreien dynamischen Speichers Aufruf: CALL $INIVM ------ Rueckkehr: Initialisierung erfolgt: ---------- C-Bit = 0 R0=0 Initialisierung nicht erfolgt: C-Bit = 1 R0=-2 Fehler bei Eroeffnung der Arbeitsdatei R0=-1 Fehler bei Markierung fuer Loeschen R0...R2 zerstoert R3...R5 bleiben erhalten Nachfolgend wird das Zusammenspiel der Routine $INIVM mit dem Anwenderprogramm sowie mit der Routine $ALBLK beschrieben. Die Routine $INIVM ruft die Routine $SAVRG zum Retten und Wiederherstellen der Register 3 bis 5 des rufenden Programms. Beginnend mit der hoechsten Adresse des freien dynamischen Speicherbereiches des rufenden Programms loescht die Routine $INIVM die Steuerfelder und die Steuertabelle fuer die Seiten- adressierung. Die Routine $INIVM eroeffnet dann den Beginn einer neuen Steuertabelle fuer die Seitenadressierung und ruft die Routine $ALBLK zur Zuordnung eines Speicherseitenblockes fuer die 60 Steuertabelle. Die Routine $INIVM ruft dann erneut die Routine $ALBLK zur Zuordnung eines Speicherseitenblockes fuer die Steuer- tabelle. Die Routine $INIVM verbindet die erste zugeordnete Seite mit der Steuertabelle fuer die Seitenadressierung. Anschliessend eroeffnet und initialisiert die Routine $INIVM die Arbeitsdatei des Nutzers. Wenn die Arbeitsdatei erfolgreich eroeffnet wurde, meldet die Routine $INIVM diese Datei zum Loeschen an. Damit wird abgesichert, dass die Datei automatisch geloescht wird, wenn sie abgeschlossen wird oder das Programm anormal endet. Die Arbeitsdatei kann durch die Anweisung CLOSE$ $WRKPT abgeschlossen werden. Wenn die Routine $INIVM fehlerfrei abgearbeitet wurde, wird das C-bit im Bedingungscode geloescht und die Steuerung an die Rou- tine $SAVRG zum Wiederherstellen der Register 3 bis 3 und zur Rueckkehr zum rufenden Programm uebergeben. Konnte die Arbeitsdatei nicht eroeffnet werden, so setzt die Routine $INIVM das C-Bit im Bedingungscode, speichert in R0 den Wert -2 und uebergibt die Steuerung an die Routine $SAVRG. Konnte die Arbeitsdatei nicht erfolgreich zum Loeschen angemeldet werden, so setzt die Routine $INIVM das C-Bit im Bedingungscode, speichert in R0 den Wert -1 und uebergibt die Steuerung an die Routine $SAVRG. Die Routine $SAVRG stellt die Register 3 bis 5 des rufenden Programms wieder her und uebergibt ihm die Steuerung. Der urspruengliche Inhalt der Register 0 bis 2 ist zerstoert. 7.2.4. Speicherzuordnung ------------------------ 7.2.4.1. Blockzuordnung ($ALBLK) -------------------------------- Dieses Programm stellt eine Verbindung zwischen der aufrufenden Task und den weiteren Speicherzuordnungsprogrammen her. Das bedeutet, dass die Task alle Leistungen der gesamten Zuordnungsprogramme durch den Aufruf von $ALBLK oder des Programms, das $ALBLK ruft, nutzt. Parameter: R1 Groesse des zuzuordnenden Blockes in Bytes --------- (<513.). Aufruf: CALL $ALBLK ------ Rueckkehr: Bei erfolgter Zuordnung: --------- R0 Adresse des zugeordneten Blockes Bei nicht erfolgter Zuordnung: R1 E$R4,S$V2 gesetzt R2 Adresse der Seitenadressliste Aufruf von $ERMSG R0...R2 zerstoert R3...R5 bleiben erhalten Das Zusammenspiel der Routine $ALBLK mit dem Anwenderprogramm und anderen Routinen der virtuellen Speicherverwaltung wird nachstehend beschrieben. 61 Zusaetzlich zum Anwenderprogramm wird die Routine $ALBLK von folgenden Routinen der virtuellen Speicherverwaltung gerufen: - Der Routine $INIVM, die die Routine $ALBLK fuer die Zuordnung von Startbloecken aus dem dynamischen Speicher fuer die Gewaehrleistung des Seitenaustausches zwischen Hauptspeicher und Plattenspeicher aufruft. - Der Routine $CVRL, die die Routine $ALBLK fuer die Zuordnung eines dynamischen Speicherblockes zu einem virtuellen Speicher- block aufruft. - Der Routine $ALVRT, die die Routine $ALBLK zur Zuordnung eines Speicherblockes fuer einen viertuellen Speicherblock aufruft, der in die Arbeitsdatei ausgelagert werden soll. Die Routine $ALBLK ruft stets die Routine $GTCOR zur Zuordnung des angeforderten Speicherblockes wie folgt: - Anforderung einer Zuordnung von freiem dynamischen Speicher- bereich - Falls die Anforderung nicht erfuellt werden kann, wird ein Versuch gemacht, das Programm zu erweitern, um die Groesse des freien dynamischen Speicherbereiches zu erhoehen. - Wenn das Programm nicht erweitert werden kann, werden zur Auslagerung freigegebene Seiten des Hauptspeicherplatzes in die Arbeitsdatei ausgelagert, um neuen Speicherplatz fuer weitere Zuordnungen zu erhalten. 7.2.4.2. Speicherplatzbereitstellung ($GTCOR) --------------------------------------------- Das Programm wird aufgerufen von $ALBLK und dient der effektiven Zuordnung von Speicherplatz. Es versucht, den geforderten Speicherplatz auf drei Wegen zuzuordnen: - Zuordnung von verfuegbarem Speicher im freien dynamischen Speicher - Erweiterung der Task zur Vergroesserung des freien dynamischen Speichers - Auslagerung unmarkierter Bloecke aus dem dynamischen Speicher auf die Platte Parameter: R1 Groesse des geforderten Blockes in Bytes --------- (<513.) Aufruf: CALL $GTCOR ------ Bei Anwendung der statistischen Version muss im Anwenderprogramm $FRSIZ definiert sein. Rueckkehr: Bei erfolgter Zuordnung: ---------- R0 Adresse des zugeordneten Blockes C-Bit = 0 Bei nicht erfolgter Zuordnung: C-Bit = 1 R0...R2 zerstoert R3...R5 bleiben erhalten 62 Beschreibung des Zusammenspiels der Routine $GTCOR mit den anderen Routinen der virtuellen Speicherverwaltung: Die Routine $GTCOR wird immer vor der Routine $ALBLK gerufen. Die Routine $GTCOR ruft die Routine $AVRG zum Retten und Wiederher- stellen der Register 3 bis 5 des rufenden Programms. Die Systemroutine $RQCB wird gerufen, um festzustellen, ob genuegend freier dynamischer Speicherplatz gegenwaertig verfuegbar ist, um die Zuordnungsanforderung zu befriedigen. Wenn dem so ist, gibt die Routine $GTCOR die Adresse des zugeordneten freien dynamischen Speicherplatzes an das rufende Programm weiter. Wenn der angeforderte Speicherblock aus dem gegenwaertig freien dynamischen Speicherbereich nicht zugeordnet werden kann, sucht die Routine $GTCOR nach gegenwaertig im Hauptspeicher befindlichen zugeordneten (und nicht gesperrten) Seiten zur Auslagerung. Wenn nicht gesperrte Seiten gefunden werden, so wird die zuletzt genutzte Seite freigegeben, und ihr Speicherplatz wird der neuen Seite zugeordnet. Wenn keine ungesperrten Seiten gefunden werden, so wird das C-Bit gesetzt, und die Steuerung wird an das rufende Programm zurueckgegeben. Wurde eine nicht gesperrte Seite gefunden, so prueft die Routine $GTCOR diese Seite, um zu ermitteln, ob sie bereits benutzt wurde. Wenn dem so ist, so wird die Routine $WRPAG gerufen, um die Seite in die Arbeitsdatei zu schreiben. Die Systemroutine $RLCB wird gerufen, um die Seite wieder freizugeben und anschliessend die Systemroutine $RQCB, um sie neu zuzuordnen. Die Hauptspeicheradresse der zugeordneten Seite wird im Register 0 dem rufenden Programm uebermittelt. Wenn es der Routine $GTCOR nicht moeglich ist, genuegend Speicherplatz fuer den angeforderten Speicherblock zu erhalten, wird das C-Bit im Bedingungscode gesetzt und die Steuerung an das rufende Programm zurueckgegeben. 7.2.4.3. Taskerweiterung ($EXTSK) --------------------------------- Das Programm erweitert den Taskbereich zur Vergroesserung des freien dynamischen Speichers. Die Groesse des geforderten Blockes wird auf 32 Worte gerundet. Parameter: R1 Groesse der geforderten Erweiterung in Byte ---------- Aufruf: CALL $EXTSK ------ Rueckkehr: Bei erfolgter Erweiterung: ---------- R1 Groesse der Erweiterung (auf 32 Worte gerundet) C-Bit = 0 Bei nicht erfolgter Erweiterung: C-Bit = 1 R2...R5 bleiben erhalten Die Routine $EXTSK wird von der Routine $GTCOR gerufen, wenn im gegenwaertig verfuegbaren freien dynamischen Speicherbereich unzureichend Platz vorhanden ist, um Anforderungen fuer Speicherblockzuordnungen zu erfuellen. Die Routine $EXTSK rundet die angeforderte Erweiterungsgroesse auf die naechste 32-Wort- 63 Grenze. Wenn genuegend dynamischer Speicherplatz verfuegbar ist, wird das Programm vergroessert und der Gesamtbetrag der Erweiterung im Register 1 der Routine $GTCOR mitgeteilt. Kann das Programm nicht erweitert werden, setzt die Routine $EXTSK das C- Bit im Bedingungscode und gibt die Steuerung an die Routine $GTCOR zurueck. Die Routine $EXTSK kann direkt vom Nutzer gerufen werden. Die Routine wird von der Routine $INIDM gerufen. 7.2.4.4. Transfer eines Blockes zum Plattenspeicher ($WRPAG) ------------------------------------------------------------ Das Programm bewirkt die Auslagerung eines Speicherblockes des dynamischen Speichers in die Plattenarbeitsdatei. Parameter: R2 Adresse des auszulagernden Speicherblockes --------- Aufruf: CALL $WRPAG ------ Rueckkehr: Bei erfolgtem Transfer: ---------- C-Bit = 0 Bei nicht erfolgtem Transfer: Aufruf von $ERMSG R1 E$R73,S$V2 gesetzt R0...R5 bleiben erhalten Die Routine $WRPAG wird von der Routine $GTCOR gerufen, wenn eine benutzte Hauptspeicherseite in die Arbeitsdatei des Nutzers ausgelagert werden soll. Die Routine $WRPAG ruft die Routine $SAVVR zum Retten und Wiederherstellen der Register 0 bis 2. Anschliessend fuehrt sie folgendes durch: - Ermitteln eines freien Speicherplatzes in der Arbeitsdatei fuer das Auslagern der Seite. - Initialisieren des Auslagerns der Seite. - Ueberpruefen des Status der Schreiboperation. - Anzeige des erfolgreichen Auslagerns (Loeschen des C-Bits im Bedingungscode) und Uebergabe der Steuerung an $SAVVR oder Aufruf der Fehlerbehandlungsroutine $ERMSG, wenn ein schwerer Ein-Ausgabefehler bei der Arbeitsdatei das Auslagern verhinderte. 7.2.5. Zuordnung von virtuellem Speicher ---------------------------------------- 7.2.5.1. Zuordnung eines kleinen virtuellen Blockes ($ALSVB) ------------------------------------------------------------ Das Programm ordnet kleine Bloecke den grossen Bloecken im Speicher und auf der Platte zu. $ALSVB ordnet zu Beginn einen grossen Block zu und fuehrt danach die Zuordnung der kleinen Bloecke zu diesem grossen Block durch. 64 Parameter: In der Task muss --------- N$DLGH==y (y <513. Byte) definiert sein. Das ist die Groesse der grossen Speicherbloecke. R1 = 0 beim ersten Aufruf von $ALSVB R1 = a a Groesse des zuzuordnenden Blockes Aufruf: CALL $ALSVB ------ Rueckkehr: R0 Adresse des zugeordneten Blockes --------- R1 virtuelle Adresse des zugeordneten Blockes der zugeordnete Speicherblock ist "eingeschrieben" R2 zerstoert R3...R5 erhalten Wenn eine kleine Speicherseite innerhalb einer existierenden grossen Speicherseite zugeordnet werden soll, ruft die Routine $ALSVB die Routine $CVRL zur Durchfuehrung folgender Aufgaben: - Lokalisieren der zugeordneten grossen Speicherseite, falls sie sich im Hauptspeicher befindet. Ist sie ausgelagert, wird sie von der Arbeitsdatei in den Hauptspeicher gelesen. - Konvertieren der virtuellen Seitenadresse in eine Hauptspei- cherseitenadresse. - Transport der grossen Speicherseite vom Plattenspeicher in den Hauptspeicher. Die Routine $ALSVB ruft die Routine $WRMPG zur Kennzeichnung der zugeordneten Hauptspeicherseite als genutzt im Belegungsbit. Wenn eine grosse Speicherseite zugeordnet werden soll, wird die Routine $ALVRT gerufen, um folgendes durchzufuehren: - Zuordnung von Hauptspeicher- und Plattenspeicherplatz fuer die angeforderte grosse Seite. - Konvertierung der virtuellen Adresse in eine Hauptspeicher- adresse. - Transport einer grossen Speicherseite, wenn notwendig, von der Arbeitsdatei in den dynamischen Speicherbereich. - Kennzeichnung der zugeordneten Seite als benutzt. 7.2.5.2. Zuordnung eines grossen virtuellen Blockes ($ALVRT) ------------------------------------------------------------ Das Programm prueft, ob ein grosser Block im virtuellen Speicher der Plattenarbeitsdatei zugeordnet werden kann. Wenn ja, dann erfolgen entsprechende Eintragungen in die Blockadress- und - kontrolliste und eine Uebergabe der Platten- und Speicheradressen an das aufrufende Programm. $ALVRT ruft $WRMPG zum Setzen des "Eingeschrieben-Flag". Parameter: R1 Groesse des zuzuordnenden Plattenspeicher- --------- blockes in Byte (<513.) Aufruf: CALL $ALVRT ------ 65 Rueckkehr: Bei erfolgter Zuordnung: --------- R0 Speicheradresse des zugeordneten Blockes R1 Plattenadresse des geordneten Blockes Bei nicht erfolgter Zuordnung: Aufruf von $ERMSG R1 E$R72,S$V2 gesetzt R2 zerstoert R3...R5 erhalten Ausser vom Anwenderprogramm wird die Routine $ALVRT auch von der Routine $ALSVB gerufen. Die Routine $ALVRT ruft die Routine $RQVCB, um zu bestimmen, ob der angeforderte Speicherplatz in der Arbeitsdatei zugeordnet werden kann. Wenn nicht, wird ein schwerer Fehler angezeigt und die Routine $ALVRT ruft die Fehler- behandlungsroutine $ERMSG. Kann in der Arbeitsdatei Speicherplatz zugeordnet werden, wird von der Routine $QVCB die Adresse der Plattenspeicherseite an die Routine $ALVRT uebergeben, die dann ermittelt, ob eine Speicherseite im Hauptspeicher verfuegbar ist. Wenn nicht, wird die Routine $ALBLK gerufen, um eine Speicher- seite zuzuordnen. Die Routine $ALVRT ruft dann die Routine $CVRL, um die virtuelle Adresse in eine Hauptspeicheradresse zu konver- tieren. Die Routine $ALVRT ruft die Routine $WRMPG zum Setzen des Belegungsbits (Seite ist genutzt) in der Speicherseite. 7.2.5.3. Zuordnung eines Blockes der Plattendatei ($RQVCB) ---------------------------------------------------------- Das Programm fuert die Blockzuordnung auf dem Plattenspeicher durch. Es kann nur durch das Programm zur virtuellen Blockzuordnung ($ALVRT) aufgerufen werden. Die Routine $RQVCB rundet die angeforderte Anzahl von Bytes auf die naechste Wortgrenze. Wenn der aufgerundete Wert die Grenze einer Plattenspeicherseite uebersteigt, erfolgt die Zuordnung zu Beginn der naechsten Plattenspeicherseite. War die Zuordnung erfolgreich, loescht die Routine $RQVCB das C-Bit im Bedingungscode und uebermittelt der Routine $ALVRT die Adresse der zugeordneten Plattenspeicherseite. War die Zuordnung nicht erfolgreich, setzt die Routine $RQVCB das C-Bit im Bedingungscode auf 1 und gibt die Steuerung an die Routine $ALVRT zurueck. Zwei Ursachen gibt es fuer diesen Zuordnungsfehler: - Es ist kein Plattenspeicherplatz mehr verfuegbar. - Eine Speicherseite mit einer Laenge ueber 512 Byte wurde ange- fordert. 7.2.6. Blockverwaltung ---------------------- 7.2.6.1. Adresskonvertierung und Kennzeichnung eines Blockes ($CVLOK) ------------------------------------------------------------ Das Programm konvertiert eine virtuelle Adresse in eine reale und kennzeichnet den Block, um eine Auslagerung zu verhindern. Parameter: R1 virtuelle Adresse --------- 66 Aufruf: CALL $CVLOK ------ Rueckkehr: Bei erfolgter Konvertierung: --------- R0 Speicheradresse R1 virtuelle Adresse C-Bit =0 Bei nicht erfolgter Konvertierung: C-Bit =1 R2...R5 bleiben erhalten 7.2.6.2. Konvertierung einer virtuellen in eine reale Adresse ($CVRL) ------------------------------------------------------------- Das Programm konvertiert eine virtuelle Adresse in eine Speicheradresse (ohne Blockkennzeichnung). Parameter: R1 virtuelle Adresse --------- Aufruf: CALL $CVRL ------ Rueckkehr: R0 Speicheradresse --------- R1,R3...R5 bleiben erhalten R2 zerstoert Die Routine $CVRL ruft die Routine $FNDPG, um zu ermitteln, ob sich die spezifizierte Seite im Hauptspeicher befindet. Wenn dem so ist, wird die virtuelle Adresse in eine Hauptspeicheradresse konvertiert, die dem rufenden Programm uebermittelt wird. Befindet sich die Seite nicht im Hauptspeicher, wird die Routine $ALBLK gerufen, um eine Hauptspeicherseite zuzuordnen. Die Routine $CVRL ruft dann die Routine $RDPAG, um die betreffende Seite aus der Arbeitsdatei in den dynamischen Speicherbereich zu lesen. Die Seitenadresse wird dann in eine Hauptspeicheradresse konvertiert. Die Hauptspeicheradresse der Seite wird in Register 0 gespeichert und die Steuerung der Routine $SAVRG uebergeben, die die Register 3 bis 5 wiederherstellt und zum rufenden Programm zurueckkehrt. 7.2.6.3. Suchen eines Blockes ($FNDPG) -------------------------------------- Das Programm prueft, ob ein virtueller Speicherblock bereits im dynamischen Speicher resident ist. Parameter: R1 virtuelle Adresse --------- Aufruf: CALL $FNDPG ------ 67 Rueckkehr: Seite im Speicher resident ---------- R0 Blockadresse C-Bit =0 Seite nicht im Speicher resident: C-Bit =1 Die Routine $FNDPG wird von folgenden Routinen der Verwaltung des virtuellen Speichers gerufen: - Routine $CVRL, wenn eine virtuelle Adresse in eine Hauptspei- cheradresse konvertiert werden muss. - Routine $LCKPG, wenn eine Hauptspeicherseite im Hauptspeicher wieder freigegeben werden kann (Auslagern erlaubt). - Routine $WRMPG, wenn das Belegungsbit "Seite ist benutzt" in der Hauptspeicherseite gesetzt werden soll. Die Routine $FNDPG bestimmt, ob die angegebene Seite im dynamischen Speicherbereich vorhanden ist. Wenn dem so ist, wird der Zeitpunkt des Zugriffs gemerkt, die Adresse der Seite im Register 0 gespeichert, das C-Bit im Bedingungscode geloescht und die Steuerung an das rufende Programm zurueckgegeben. War die Seite nicht im Hauptspeicher, so wird das C-Bit im Bedingungscode gesetzt und die Steuerung an das rufende Programm zurueckgegeben. 7.2.6.4. Setzen des Kennzeichenbytes ($LCKPG) --------------------------------------------- Das Programm kennzeichnet einen speicherresidenten Block, um ein Auslagern auf den Plattenspeicher zu verhindern. Parameter: R1 virtuelle Adresse des Blockes --------- Aufruf: CALL $UNLPG ------ Rueckkehr: Kennzeichenbyte wurde geloescht ---------- C-Bit =0 Seite wurde nicht gefunden: C-Bit =1 R0...R5 bleiben erhalten Die Routine $LCKPG ruft die Routine $SAVVR zum Retten und Wiederherstellen der Register 0 bis 2 des rufenden Programms. Danach wird die Routine $FNDPG gerufen, um zu ermitteln, ob sich die Speicherseite im Hauptspeicher befindet. Wenn dem so ist, wird in der Seite das Kennzeichenbit "Seite ist gesperrt" gesetzt, das C-Bit im Bedingungscode geloescht und die Steuerung an die Routine $SAVVR gegeben, damit sie die Register 0 bis 2 wiederherstellen kann und zum rufenden Programm zurueckkehrt. Wenn die angegebene Seite nicht im Hauptspeicher ist, wird das C- Bit im Bedingungscode gesetzt und die Steuerung ueber die Routine $SAVVR dem rufenden Programm zurueckgegeben. 68 7.2.6.5. Lesen eines Blockes ($RDPAG) ------------------------------------- Das Programm bewirkt den Transfer eines Blockes der Arbeitsdatei in den Hauptspeicher. Parameter: R0 Plattenadresse des Blockes --------- Aufruf: CALL $RDPAG ------ Rueckkehr: Transfer erfolgt: ---------- C-Bit =0 Transfer nicht erfolgt: R1 E$R73,S$V2 gesetzt Aufruf des Fehlerprogramms $ERMSG Die Routine $RDPAG ruft die Routine $SAVVR zum Retten und Wieder- herstellen der Register 0 bis 2 des rufenden Programms. Anschliessend fuehrt sie folgendes durch: - Festlegung der Adresse der zu transportierenden Seite. - Initialisierung der Leseoperation fuer die Seite. - Ueberpruefung des Status der Leseoperation. - Anzeige des erfolgreichen Einlesens (Loeschen des C-Bits im Bedingungscode) und Uebergabe der Steuerung an die Routine $SAVVR oder Aufruf der Fehlerbehandlungsroutine $ERMSG des Nutzers, wenn ein schwerer Ein-Ausgabefehler bei der Arbeits- datei den Transport der Seite verhinderte. 7.2.6.6. Loeschen eines Kennzeichenbytes ($UNLPG) ------------------------------------------------- Das Programm loescht das Kennzeichenbyte fuer einen speicherresidenten Block. Damit ist der Block frei fuer eine Auslagerung auf die Platte. Parameter: R1 virtuelle Adresse des Blockes --------- Aufruf: CALL $UNLPG ------ Rueckkehr: Kennzeichenbyte wurde geloescht: --------- C-Bit =0 Kennzeichenbyte wurde nicht geloescht: C-Bit =1. R0...R5 bleiben erhalten Durch die Routine $UNLPG wird die Routine $FNDPG gerufen, um festzustellen, ob sich die Seite im Hauptspeicher befindet. Wenn dem so ist, wird das Kennzeichenbit "Seite ist gesperrt" in der Seite geloescht, das C-Bit im Bedingungscode geloescht und die Steuerung an die Routine $SAVVR gegeben, damit sie die Register 0 bis 2 wiederherstellen und zum rufenden Programm zurueckkehren kann. Befindet sich die angegebene Seite nicht im Hauptspeicher, wird das C-Bit im Bedingungscode gesetzt und die Steuerung ueber die Routine $SAVVR an das rufende Programm zurueckgegeben. 69 7.2.6.7. Setzen des "Eingeschrieben-Flag" ($WRMPG) -------------------------------------------------- Durch dieses Programm wird das "Eingeschrieben-Flag" fuer den angegebenen Block gesetzt. Damit wird dieser Block als benutzt gekennzeichnet. Aufruf: R1 virtuelle Adresse des Blockes ------- CALL $WRMPG Rueckkehr: Speicherresidenter Block wurde gekennzeichnet: ---------- C-Bit =0 Block ist nicht im Speicher resident: C-Bit =1 R0..R5 bleiben erhalten. Die Routine $WRMPG wird von folgenden Routinen der virtuellen Speicherverwaltung gerufen: - Routine $ALVRT, wenn eine Plattenspeicherseite dem dynamischen Speicherbereich zugeordnet wurde. - Routine $ALSVB, wenn eine kleine Speicherseite innerhalb einer grossen Speicherseite zugerordnet wurde. Die Routine $WRMPG ruft die Routine $SAVVR zum Retten und Wieder- herstellen der Register 0 bis 2 des rufenden Programms. Die Routine $FNDPG wird gerufen, um festzustellen, ob sich die spezi- fizierte Seite im Hauptspeicher befindet. Wenn nicht, so wird das C-Bit im Bedingungscode gesetzt und die Steuerung an die Routine $SAVVR uebergeben, damit sie die Register 0 - 2 wiederherstellt und zum rufenden Programm zurueckkehrt. War die angegebene Seite im Hauptspeicher, so wird das Belegungsbit "Seite ist genutzt" gesetzt, das C-Bit im Bedingungscode geloescht und die Steuerung an die Routine $SAVVR gegeben, damit sie die Register 0 - 2 wiederherstellt und zum rufenden Programm zurueckkehrt. 7.3. Verwaltung des dynamischen Speichers ----------------------------------------- 7.3.1. Vorbemerkungen --------------------- Nach der Initialisierung steht ein grosser Bereich als freier dynamischer Speicher zur Verfuegung. Durch Anforderung von Bloecken durch die Task wird dieser Adressraum von der hoechsten Adresse beginnend belegt. Dabei sind vom Anwender die Blocklaenge und die Blockanfangsadresse von Bedeutung. Bei der Freigabe von Speicherbloecken wird eine Liste aufgebaut, die Laenge und Beginn der freien Speicherbereiche enthaelt. Wenn moeglich, werden dabei freie Bereiche zusammengefasst. Zur Verwaltung des dynamischen Speichers stehen 3 Programme zur Verfuegung: - Programm zur Initialisierung des dynamischen Speichers $INIDM - Programm zur Anforderung eines Speicherblockes $RQCB - Programm zur Freigabe eines Speicherblockes $RLCB Die Programme $RQCB und $RLCB sind Bestandteil der SYSLIB.OLB. 70 7.3.2. Voraussetzungen fuer die Nutzung der Programme ----------------------------------------------------- Im Programm ist vom Anwender ein Kopf fuer die Liste der freien Bloecke in folgender Form zu vereinbaren: FREEHD:: .BLKW 2. Der Aufruf der einzelnen Programme hat in der unter Abschnitt 7.3.3. bis Abschnitt 7.3.5. genannten Form zu erfolgen. Beim Taskbilden sind die Moduln INIDM und EXTSK mittels LB:[1,1]VMLIB/LB:INIDM:EXTSK zu beruecksichtigen. 7.3.3. Initialisierung des dynamischen Speichers ($INIDM) --------------------------------------------------------- Waehrend der Initialisierung werden folgende Operationen durchgefuehrt: - Runden der Basisadresse des freien dynamischen Speichers auf 2 Worte - Initialisierung des freien dynamischen Speichers als einen grossen Speicherblock - Berechnung der Groesse des freien dynamischen Speichers - R0,R1,R2 mit Rueckkehrinformationen fuellen Parameter: R0 Adresse des Listenkopfes --------- Aufruf: CALL $INIDM ------ Rueckkehr: R0 erste Adresse der Task --------- R1 erste Adresse des freien dynamischen Speichers R2 Groesse des freien dynamischen Speichers (in Bytes) R3...R5 bleiben erhalten Nach der Initialisierung kann der Anwender die Programme zur Anforderung und zum Freisetzen von Speicherbloecken aufrufen. 7.3.4. Anforderung eines Speicherblockes ($RQCB) ------------------------------------------------ Das Programm ist Bestandteil der Systembibliothek (SYSLIB.OLB). Es prueft zunaechst, ob der freie dynamische Speicher der geforderten Blockgroesse genuegt und ordnet danach den Block zu. Parameter: R0 Adresse des Listenkopfes --------- R1 Groesse des geforderten Blockes (in Bytes) R1>=0 optimale Zuordnung R1<0 (Zweierkomplement), der erste moegliche Block wird zugewiesen Aufruf: CALL $RQCB ------ 71 Rueckkehr: Bei erfolgter Zuordnung: --------- R0 Adresse des geforderten Blockes R1 Groesse des Blockes (auf zwei Worte gerundet) C-Bit =0 Bei nicht erfolgter Zuordnung: C-Bit =1 R2 zerstoert R3...R5 bleiben erhalten 7.3.5. Freigabe eines Speicherblockes ($RLCB) --------------------------------------------- Das Programm ist Bestandteil der Systembibliothek (SYSLIB.OLB). Es traegt den freizugebenden Block in die Liste der freien Bloecke ein. Dabei werden sich beruehrende freie Bloecke verbunden. Parameter: R0 Adresse des Listenkopfes --------- R1 Groesse des Blockes in Byte R2 Adresse des freizugebenden Blockes Aufruf: CALL $RLCB ------ Rueckkehr: R0 Adresse des Listenkopfes --------- R1,R2 zerstoert R3...R5 bleiben erhalten Tabelle 10: Speicherverwaltungsprogramme ---------------------------------------------------------------- Modulname Programmname Bezugsprogramme ---------------------------------------------------------------- Stat. N. Stat. ---------------------------------------------------------------- ALBLK ALBLK $ALBLK $GTCOR $EXTSK $WRPAG ALSVB ALSVB $ALSVB $ALVRT $WRMPG $CVRL $ALBLK $RQVCB $FNDPG $RDPAG CVRS CVRL $CVRL $FNDPG $ALBLK $RDPAG EXTSK EXTSK $EXTSK keine FNDPG FNDPG $FNDPG keine GTCOS GTCOR $GTCOR $EXTSK $WRPAG INIDM INIDM $INIVM $EXTSK INIVS INIVM $INIVM $ALBLK $GTCOR $EXTSK $WRPAG MRKPG MRKPG $LCKPG $FNDPG $UNLPG $FNDPG $WRMPG $FNDPG RDPAS RDPAG $RDPAG keine $WRPAG keine RQVCB RQVCB $RQVCB keine VMUTL VMUTL $CVLOK $CVRL $LCKPG $FNDPG $RDPAG $ALBLK VMDAS VMDAT Datenmodul ---------------------------------------------------------------- 72 8. Universalbibliotheken ------------------------ 8.1. Einleitung --------------- Im OMOS-1630-System kann der Nutzer Universalbibliotheken aufbauen, um in ihnen Dateien eines gleichen Typs zu speichern. Das Bibliotheks-Dienstprogramm LBR baut Universalbibliotheken mit dem Dateityp .ULB auf. Mit seiner Hilfe kann der Nutzer Dateien als Moduln in die Bibliothek einfuegen. 8.2. Zugriff zu den Universalbibliotheken ----------------------------------------- Fuer den Zugriff zu einem Modul in einer Universalbibliothek kann das Anwenderprogramm die Routine $ULA rufen, die die notwendigen Voraussetzungen fuer Lesezugriff schafft. Die Routine $ULA ruft zunaechst die Initialisierungsroutine $ULAIN, um zu ueberpruefen, ob sich die Bibliothek in einem ordnungsgemaessen Zustand befindet, und um die notwendigen Informationen aus dem Dateibeschreibungssatz der Bibliothek zu erhalten. Anschliessend ruft die Routine $ULA die Routine $ULAFD, die den Beschreibungssatz des Moduls liest, innerhalb der Universalbibliothek den Zeiger auf den Anfang des Moduls stellt und fuer das Dateiverwaltungssystem FCS den notwendigen Dateibeschreibungssatz FDB aufbaut. Wenn der notwendige Dateibeschreibungssatz einmal aufgebaut wurde, kann das Anwenderprogramm auf den Modul in der Bibliothek in gleicher Art und Weise wie zu einer separaten Datei zugreifen, d.h., das Programm kann die Saetze in den Modul durch normale GET$- Anweisungen im Transport-Modus lesen. Fuer den Aufruf der Routine $ULA muessen folgende Daten bereitgestellt werden: - R0: Die Adresse des FDB der Universalbibliothek. Die Univer- salbibliothek muss bereits fuer Lesezugriff eroeffnet worden sein. - R1: Die Adresse eines 34-Worte-Puffers. Die ersten zwei Worte des Puffers muessen den Namen des zu lesenden Moduls im Radix-50-Format enthalten. In die restlichen 64 Bytes speichert die Routine $ULA eine Kopie des Modulbeschrei- bungssatzes aus der Bibliothek. Die FDB-Argumente urba und urbs (Adressierung im FDB durch F.URBD und F.URBBD+2) muessen durch FDRC$A initialisiert worden sein. Die Rou- tine $ULA rettet die Argumente, nutzt den Platz zum Speichern der Modulbeschreibung und stellt die Werte wieder her, bevor die Steuerung an das rufende Programm zurueckgegeben wird. Im Ergebnis der Abarbeitung der Routine $ULA entstehen folgende Daten: - R0: unveraendert - R1: unveraendert 73 - Das Wort F.FFBY des FDB der Universalbibliothek enthaelt die Anzahl der verfuegbaren Bytes hinter dem Ende des Moduls. - Das Wort F.ERR des FDB der Universalbibliothek hat die Stan- dardbedeutung mit Ausnahme folgender spezieller Bedingungen: . Der Wert IE.BHD bedeutet entweder "Datei ist keine Universal- bibliothek" oder "Ungueltiger Bibliotheksdateibeschrei- bungskopf". . Der Wert IE.NSF bedeutet "kein derartiger Modul". - Ein gesetztes C-Bit im Bedingungscode zeigt Fehler an. Fuer die richtige Anwendung der Routine $ULA ist folgende Programmanweisungsfolge einzuhalten: . . . OPEN$ R0 ;Eroeffnen der Universalbibliothek . . . ;Speichern der ersten sieben Worte des FDB der Bibliothek . . . CALL $ULA . . . GET$ R0 ;Zugriff im Uebertragungs-Modus . . . ;Wiederherstellen der ersten sieben Worte des FDB der Bibliothek . . . CLOSE$ R0 ;oder erneuter Aufruf von $ULA Es ist zu beachten, dass das Programm die Universalbibliothek fuer Lesezugriff eroeffnet haben muss. Zum Auswechseln eines Moduls in der Universalbibliothek muss das Dienstprogramm LBR benutzt werden. Vor dem ersten Aufruf der Routine $ULA muss das Programm die ersten sieben Worte des FDB der Bibliothek gerettet haben. Die Routine $ULA veraendert diese Worte im Verarbei- tungsprozess. Die urspruenglichen Werte werden jedoch wieder benoetigt, entweder um einen anderen Modul zu lesen oder die Bibliotheksdatei ordnungsgemaess abzuschliessen. Das Programm muss diese sieben Worte vor dem Zugriff zu einem anderen Modul bzw. vor dem Abschliessen der Bibliotheksdatei wiederherstellen. 74 Abkuerzungsverzeichnis ---------------------- AS Anschlusssteuereinheit AFP - fuer Festplattenspeicher AFS - fuer Folienspeichereinheit AIP - fuer paralleles Interface AIS - fuer serielles Interface AKP - fuer Kassettenplatten- speicher AMB - fuer Magnetbandspeicher AST Asynchroner Systemtrap BAD (Bad Block Locator Utility) Plattenpruefprogramm BDE Bedieneinheit BRU (Backup and Restore Utility) Datensicherungsprogramm BS Betriebssystem CDA Abbruchanalyseprogramm CLI (Command Line Interpreter) Programm zur Bearbeitung von Kommandos CMP (File Compare Utility) Dateivergleichsprogramm DEP (Debugging Program) Testprogramm DMP (Dump Utility) Dateidruckprogram DSC (Disk Save and Compress) Dateirettungs- und Ver- dichtungsprogramm DSW (Directive Status Word) Anweisungsstatuswort E/A Ein- und Ausgabe EDI Editoren EDT EOF (End of File) Dateiendekennsatz EOV (End of Volume) Datentraegerendekennsatz ERL (Error Logging) Fehlerregistrierung FCB (File Control Block) Dateisteuerblock FCS (File Control Services) Dateizugriffsroutinen FD16 Datensicherungsformat FE16 Global genormte Dateiformate (Dateiformat "established") FEX (File Exchange Utility) Dateiaustauschprogramm FL16 Dateiformat LAOS 1630 FLX (File Transfer Utility) Dateiumwandlungsprogramm FMT (Format Utility) Formatierungsprogramm fuer Magnetplatten FM16 Dateiformat MOOS 1600 und OMOS 1630 FPEM (Floating-point Emulation Program) Gleitkommaemulator FPS Festplattenspeicher FQ16 Lokal genormte Dateiformate (Datenformat "queered") FSE Folienspeichereinheit HDR (Header Label) Dateianfangskennsatz IOX (I/O Exerciser) Allgemeines Geraetestprogramm KBR Kommerzielles Basisrechner- system 75 KMBE Kassettenmagnetbandeinheit KROS Kombinat Robotron Standard KPS Kassettenplattenspeicher LBL Lochbandleser LBN (Logical Block Number) Logische Blocknummer LBR (Librarian Utility) Bibliothekar LC (Location Counter) Speicherplatzzaehler des Assemblers LUN (Logical Unit Number) logische Geraetenummer LP (Line Printer) Zeilendrucker MAC Makro-Assembler MBG Magnetbandgeraet MCR Kommandoprogramm MFD (Master File Directory) Hauptdateiverzeichnis MGS Mikrorechnergeraetesystem MOEX Exekutive des MOOS MOOS 1600 Modulares Operationssystem NP Nutzerprogramm ODT (On Line Debugging Tool) Testprogramm OMEX Exekutive des OMOS OMOS 1630 Optimiertes Modulares Betriebssystem PAR (Page Address Register) Seitenadressregister PAT (Objekt Module Patch Utility) Objektmodul-Korrekturprogramm PC (Program Counter) Befehlszaehler PDR (Page Description Register) Seitenbeschreibungsregister PIP (Peripheral Interchange Dateitransferprogramm Program) PRESRV (Preservation Utility) Duplizier- und Sicherungs- programm PRT (Print spooler) Print-Spooler PS Prozessorstatuswort RAM (Random Access Memory) Speicher mit wahlfreiem Zu- griff SD Seriendrucker SHF (Shuffler) Speicherverdichtungsprogramm SLP (Source Line Processor) Quelltext-Korrekturprogramm SKR System der Kleinrechner SRD (Sort Directory Program) Sortierprogramm fuer Verzeichnisdateien SST Synchroner Systemtrap SVE Speichervermittlungseinheit TKB Taskbilder UFD (User File Directory) Nutzerdateiverzeichnis UIC (User Identification Code) Nutzeridentifikationscode UHL (User Header Label) Benutzereigene Dateikennsaetze UTL (User Trailer Label) UVL (User Volume Label) VBN (Virtual Block Number) Virtuelle Blocknummer VCB (Volume Control Block) Datentraegersteuerblock 76 VFY (File Structure Verification Dateipruefprogramm Utility) VMR (Virtual Monitor Console Virtuelles Kommandoprogramm Routine) VOL (Volume Label) Datentraegerkennsatz ZAP Dateikorrekturprogramm ZVE Zentrale Verarbeitungseinheit 77 Sachwortverzeichnis ------------------- Addition 14 Adresskonvertierung 66,67 Arithmetik 10ff. Ausgabekonvertierung 35ff. Bibliothekar 73 Binaer in Dezimal 35 Binaer in Oktal 39 Block,virtuell 64,65 Blockverwaltung 66 Datumskonvertierung 48 Division 12,18 Eingabekonvertierung 24ff. Eingeschrieben-Flag 70 Fehlerbehandlungsprogramm 59 Formatierung 47ff. Initialisierung 60,71 Integer-Addition 14 Integer-Division 12 Integer-Dreifachwort 31,43 Integer-Multiplikation 10,17 Integer-Subtraktion 15 Integer-Vierfachwort 32,44 Kellerspeicher 8,9 Kennzeichenbyte 68 KOI-7-Code 24,26,29,42 Mehrfachwort 14ff.,31ff.,43ff. Multiplikation 10,17 Radix-50 29,42 Registerbearbeitung 7ff. Speicher,dynamisch 71 Speicher,virtuell 60,64 Speicherverwaltung 58ff. Subtraktion 15 Taskbilden 58 Taskerweiterung 63 Tetraden 20,33,45 Uhrzeit 49 Universalbibliothek 73 78 Routinennamen ------------- $ADDM 14 $ALBLK 61 $ALSVB 65 $ALVRT 65 $CAT5 29 $CAT5B 29 $CBDAT 35 $CBDMG 35 $CBGSG 35 $CBOMG 39 $CBOSG 39 $CBTA 41 $CBTMG 39 $CDDMG 35 CDTB 26 $COTB 26 $CVTUC 47 $CVLOC 66 $CVRL 67 $C5TA 42 $DAT 48 DCDD2W 35 DCDD3W 43 DCDD4W 44 DD1CT 26 DD3CT 31 DD4CT 32 .DD2CT 24 $DDIV 12 $DIV 12 $DIVM 18 $DMUL $EDMSG 50 $ERMSG 59 $EXTTSK 63 $FNDPG 67 $GTCOR 62 $INIDM 71 $INIVM 60 $KOTE 33 $LCKPG 68 $MUL 10 $MULM 17 .OD2CT 24 $RDPAG 69 $RLCB 72 $RQCB 71 $RQVCB 66 $SAVAL 7 $SAVRG 8 .SAVR1 9 $SAVVR 9 $SUBM 15 $TEAD 20 $TECP 22 $TEKO 45 $TESU 21 $TEVE 21 $TIM 48 $ULA 73ff. $UNLPG 69 $WRMPG 70 $WRPAG 64 79