----------------------------------------------------------------- | SOFTWARE- | | MOS | | DOKUMENTATION | MACRO 1600 |-------------| |-----------------| Sprachbeschreibung | OMOS 2.0 | | 11/87 | | | ----------------------------------------------------------------- Programmtechnische Sprachbeschreibung Beschreibung Makroassemblersprache MACRO 1600 MGS K 1600 VEB Robotron-Vertrieb Berlin Dok.-Nr. C 8066-0577-1M2031 Die vorliegende Softwaredokumentation, Sprachbeschreibung MACRO 1600, entspricht dem Stand von 11/87. 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 Postfach 1235 Berlin 1086 (C) Kombinat Robotron 1987 Kurzreferat In der vorliegenden Sprachbeschreibung wird die Makroassembler- sprache MACRO 1600 der Betriebssysteme OMOS 1630, MOOS 1600 und LAOS 1600 dargestellt. MACRO 1600 ist eine maschinenorientierte Programmiersprache. Sie gestattet die symbolische Programmierung unter Verwendung aller Maschinenbefehle sowie verschiedener Pseudobefehle. Insbesondere bietet MACRO 1600 folgende Leistungen: - Bedingte Uebersetzung - Nutzung globaler Symbole - Definition von Programmsektionen - Makrotechnik Der Assembler MAC 1630 (OMEX) erzeugt aus MACRO 1600-Quellpro- grammen Uebersetzungsliste und Objektprogramm, beschrieben in der Anleitung fuer den Bediener, Teil 5, Makroassembler. Inhaltsverzeichnis ------------------ Seite 1. Beschreibungsform 5 2. Aufbau eines MACRO 1600-Programms 6 2.1. Programmstruktur 6 2.2. Zeilenformat 8 2.2.1. Markenfeld 8 2.2.2. Operationsfeld 9 2.2.3. Operandenfeld 9 2.2.4. Kommentar 9 2.2.5. Standardformat 9 3. Grundelemente der Sprache MACRO 1600 11 3.1. Zeichen, Symbole, Ausdruecke 11 3.1.1. Zeichen 11 3.1.2. Zahlen 12 3.1.3. Symbole 12 3.1.4. Lokale Symbole 13 3.1.5. Speicherplatzzaehler 14 3.1.6. Zeichenkonstanten 14 3.1.7. Konstanten mit Typkennzeichen 14 3.1.7.1. Oktal-, Dezimal- und Binaerkonstanten 15 3.1.7.2. Radix 50-Konstanten 15 3.1.7.3. Gleitkommakonstanten 16 3.1.8. Registerausdruecke 16 3.1.9. Ausdruecke 17 3.2. Direktanweisung 18 3.3. Anwendung der Maschinenbefehle 19 3.3.1. Allgemeines 19 3.3.2. Anmerkungen zu einigen Befehlen 20 3.3.3. Adressierung der Verzweigungsbefehle 21 3.3.4. Unterprogrammtechnik 22 3.4. Adressierungsmodi 23 4. Pseudobefehle 28 4.1. Definition von Daten und Adressen 28 4.1.1. Wort- und Byte-Definitionen 28 4.1.2. Definition von Integerzahlen 29 4.1.3. Definition von tetradischen Dezimalzahlen 30 4.1.4. Definition von Gleitkommazahlen 31 4.1.5. Definition von Zeichenketten 34 4.1.6. Definition von Radix 50-Zeichenketten 34 4.2. Speicherplatzvereinbarungen 35 4.2.1. Block-Wort- und Block-Byte-Vereinbarung 35 4.2.2. Steuerung des Speicherplatzzaehlers 35 4.3. Pseudobefehle zum Programmaufbau 36 4.3.1. Programmtitel 36 4.3.2. Untertitel 36 4.3.3. Programm-Identifikation 36 4.3.4. Programmende 37 4.4. Pseudobefehle zur Uebersetzungssteuerung 37 4.4.1. Allgemeine Uebersetzungssteuerung 37 4.4.2. Steuerung der Zahlenbasis 39 4.5. Pseudobefehle mit Bezug zum Task-Builder 40 4.5.1. Globale Symbole 40 4.5.2. Bereitstellung der Programmgrenzen 42 3 Seite 4.6. Programmsektionen 42 4.7. Bedingte Uebersetzung 45 4.7.1. Bloecke zur bedingten Uebersetzung 45 4.7.2. Unterbloecke zur bedingten Uebersetzung 47 4.7.3. Anweisung .IIF 47 4.8. Steuerung der Uebersetzungsliste 48 4.8.1. Steuerung des Listenumfangs 48 4.8.2. Seitenvorschub 50 5. Makrotechnik 51 5.1. Allgemeines 51 5.2. Bereitstellung der Makros 51 5.3. Allgemeiner Aufbau von Makros 52 5.3.1. Makrodefinitionen 52 5.3.2. Makroanweisungen 53 5.4. Makroparameter 53 5.4.1. Stellungsparameter 53 5.4.2. Kennwortparameter 54 5.4.3. Standardwerte 54 5.4.4. Zeichenketten als Parameter 55 5.4.5. Verkettung von Parametern 55 5.4.6. Numerische Parameter 55 5.4.7. Makroeigene lokale Symbole 56 5.5. Attributanweisungen 57 5.5.1. Parameteranzahl-Attribut 57 5.5.2. Zeichenanzahl-Attribut 57 5.5.3. Adressierungsart-Attribut 57 5.6. Makroschachtelung 58 5.7. Makroabbruchanweisung 58 5.8. Fehler- und Protokolldruckanweisung 58 5.9. Wiederholungsbloecke 59 5.9.1. Wiederholungsblock mit Parameterliste 59 5.9.2. Wiederholungsblock mit Zeichenliste 60 5.9.3. Wiederholungsblock ohne Parameter 60 Anlage 1 KOI-7-Code 61 Anlage 2 Befehlsliste K 1600 62 Anlage 3 Verzeichnis der Pseudobefehle 69 Anlage 4 Hinweise und Empfehlungen zur Gestaltung von MACRO 1600-Quellprogrammen 71 Anlage 5 Darstellung der Befehle 75 Sachwortverzeichnis 117 Tabellenverzeichnis ------------------- 1 Sonderzeichen in MACRO 1600 11 2 Radix-50-Zeichen 16 3 Befehlsarten und Operandenfeld 20 4 Adressierungsmodi 24 5 Adressierungsmodi nach Adressierungsstufen 25 6 Adressierungsmodi mit PC 26 7 Argumente bei .ENABL/.DSABL 38 8 Argumente bei .PSECT 43 9 Bedingungsoperatoren fuer bedingte Uebersetzung 46 10 Argumente bei .LIST/.NLIST 48 4 1. Beschreibungsform -------------------- Die Anweisungen und einige weitere Sprachelemente von MACRO 1600 werden (jeweils unter der Ueberschrift "Formaler Aufbau") mit Hilfe formalisierter Darstellungen beschrieben, die hier erlaeu- tert werden. abc Folge von Kleinbuchstaben: bezeichnet eine "Variable", d.h. ein Sprachelement, das an anderer Stelle beschrieben ist. [ ] Option: Der in eckige Klammern eingeschlossene Teil kann wahlweise uebernommen oder weggelassen werden. ... Wiederholung: Ein Sprachelement, dem drei Punkte nachgestellt sind, kann einmal oder mehrfach hinter- einander gesetzt vorkommen. ,... Folge: Ein Sprachelement, dem ein Trennzeichen und drei Punkte nachgestellt sind, kann einmal oder mehr- fach als Teil einer Folge - durch das angegebene Trennzeichen voneinander getrennt - vorkommen. | | | | Alternative: Zwischen geschweiften Klammern stehen < > mehrere Zeilen untereinander, von denen eine auszu- | | waehlen ist. | | XYZ Grossbuchstaben und sonstige Zeichen: werden unveraendert uebernommen. 5 2. Aufbau eines MACRO 1600-Programms ------------------------------------ 2.1. Programmstruktur --------------------- Eine verbindliche Forderung zum Aufbau eines MACRO 1600-Programms besteht nur darin, dass es durch die Anweisung .END abgeschlossen sein muss (siehe Abschnitt 4.3.4.). Um eine einheitliche aeussere Form der Programme zu erhalten, kann die im folgenden dargestellte Standardform des Programmauf- baus benutzt werden. Danach besteht ein MACRO 1600-Programm aus dem Programmkopf, dem Programmkoerper und der Programmendean- weisung. Der Programmkopf enthaelt maximal die in folgendem Schema aufge- fuehrten Anweisungen sowie gegebenenfalls Makrodefinitionen der internen Makros. Der Programmkoerper besteht aus beliebigen Ma- schinenbefehlen, Pseudobefehlen (ausser .TITLE, .IDENT, .END) und Makroanweisungen. Darin koennen eine Gliederung in logische Ein- heiten - Programmsektionen - (siehe Abschnitt 4.6.) und in forma- le Abschnitte - Untertitel - (siehe Abschnitt 4.3.2.) vorkommen. 6 ----------------- .TITLE name Programmtitel .IDENT /version/ Programmversion .LIST MEB | .NLIST BEX | Festlegungen, die Pro- .ENABL FPT,LC > fuer das gesamte gramm- .DSABL GBL | Programm gelten kopf .RADIX 10 | .MCALL MAC1,MAC2 Externe Makros .GLOBL GLO1,GLO2 Externe globale Symbole ; .MACRO MAC3 Makrodefinitionen : fuer : interne Makros .ENDM : : A = wert | B = wert > Direkt- : | anweisungen : | ----------------- .SBTTL ... : .PSECT ... Pro- : : : : : Un- .PSECT ... ----: : gramm- : : : .SBTTL ... :---- Pro- : : ter- gramm- : sek- : koerper .SBTTL ... :---- : : : : .PSECT ... tio- ----: titel : : : : .PSECT ... ----: : nen : : : ----------------- .END Ende- Anweis. 7 2.2. Zeilenformat ----------------- Ein Programm der Makroassemblersprache MACRO 1600 gliedert sich in Zeilen. Eine Zeile besteht aus maximal 80 Zeichen und wird mit dem Zeilenendezeichen abgeschlossen, das bei dem benutzten Ein- gabegeraet als solches erklaert ist, z.B. mit Wagenruecklauf(CR)/ Zeilenvorschub(LF). Es gibt vier Arten von Zeilen: Anweisungs- zeilen, Markenzeilen, Kommentarzeilen und Leerzeilen. Eine Anweisungszeile umfasst allgemein vier Teile (Felder), die durch die Reihenfolge bzw. besondere Begrenzerzeichen charakteri- siert sind: Markenfeld, Operationsfeld, Operandenfeld und Kommen- tarfeld. Formaler Aufbau einer Anweisungszeile: [marke...] operator [operand,...] [;kommentar] In einer Markenzeile fehlen das Operations- und das Operanden- feld. Sie wirkt so, als ob die Marke im Markenfeld der naechst- folgenden Anweisungszeile steht. (Diese Moeglichkeit kann genutzt werden, wenn eine Anweisung mit mehreren Marken zu versehen ist, um dabei das Standardformat, siehe Abschn. 2.2.5., einzuhalten.) Es sind auch Leerzeilen gestattet. Diese bestehen nur aus dem Zeilenendezeichen und haben keine signifikante Bedeutung. (Die Kommentarzeilen sind in Abschnitt 2.2.4. erlaeutert.) 2.2.1. Markenfeld ----------------- Das Markenfeld enthaelt eine oder mehrere Marken. Eine Marke ist ein Symbol (siehe Abschnitt 3.1.3.), dem als Begrenzerzeichen ein Doppelpunkt : folgt. (Bei globalen Marken folgen zwei Doppelpunk- te, siehe Abschnitt 4.5.1.) Durch seine Verwendung als Marke, d.h. durch sein Auftreten im Markenfeld einer Anweisung wird ein Symbol definiert und erhaelt einen Wert. Bei Speicherplatz belegenden Anweisungen (das sind z.B. alle Maschinenbefehle sowie einige Pseudobefehle) ist der Wert einer Marke die Adresse des (ersten) belegten Speicherplat- zes (Wort- oder Byteadresse). Falls das Markenfeld mehrere Marken enthaelt, haben alle Marken den gleichen Wert. Jede Marke kann im Programm nur einmal definiert werden, d.h. im Markenfeld vorkommen. (Das gilt nicht fuer lokale Symbole als Marken, siehe Abschnitt 3.1.4.) Das Markenfeld einer Anweisungszeile kann auch fehlen. Bei eini- gen Anweisungen (z.B. .EVEN) ist eine Markierung im allgemeinen nicht sinnvoll. Beispiel: M: GLOB:: MOV X,Y .BYTE 101 BQ: .BYTE 102 Falls der MOV-Befehl ab Speicherplatz 140 steht (er belegt drei Worte, entspricht 6 Bytes), haben die Marken M und GLOB (globale Marke) den Wert 140 und die Marke BQ den Wert 147. 8 2.2.2. Operationsfeld --------------------- Das Operationsfeld einer Anweisung enthaelt den Operationscode (Operator), d.h. entsprechend den Arten von Anweisungen den Mne- monik eines Maschinenbefehls, eines Pseudobefehls oder im Falle einer Makroanweisung einen Makronamen. Im Operationsfeld (und nur in diesem) kann also nur ein permanentes Symbol oder ein Makro- symbol vorkommen (siehe Abschnitt 3.1.3.). Der Operator wird beiderseits durch Leerzeichen(SP) oder Horizon- taltabulator(HT) begrenzt oder durch ein anderes Zeichen, welches kein Radix-50-Zeichen ist. Weitere voran- oder nachgestellte (SP) oder (HT) haben keine signifikante Bedeutung. Einen Sonderfall stellt das leere Operationsfeld (mit belegtem Operandenfeld) dar, es wird als .WORD-Anweisung behandelt (siehe Abschnitt 4.1.1.). 2.2.3. Operandenfeld -------------------- Das Operandenfeld enthaelt einen oder mehrere Operanden. Bei Maschinenbefehlen handelt es sich dabei um Ausdruecke, die die zu verarbeitenden Operanden bezeichnen, bei Pseudobefehlen stehen Argumente in unterschiedlicher Bedeutung und bei Makroanweisungen aktuelle Parameter im Operandenfeld. Mehrere Operanden sind durch ein Operanden-Trennzeichen (in der Regel ein Komma, in einigen Faellen auch (SP) oder (HT) moeglich) voneinander getrennt. Das Operandenfeld wird durch ; , falls Kommentar folgt, bzw. durch das Quellzeilenende abgeschlossen. Bei Anweisungen ohne Operanden ist das Operandenfeld leer, dann folgt ; bzw. das Quellzeilenende dem Operationsfeld. 2.2.4. Kommentar ---------------- Das Kommentarfeld einer Anweisungszeile beginnt mit ; und reicht bis zum Quellzeilenende. Es enthaelt den Kommentar, d.h. erlaeu- ternden Text, der auf die Uebersetzung keinen Einfluss hat. Es sind alle druckbaren KOI-7-Zeichen sowie (HT) zulaessig. Ausser den normalen Anweisungszeilen gibt es Kommentarzeilen. Diese beginnen mit ; und werden vollstaendig als Kommentar gewer- tet. 2.2.5. Standardformat --------------------- Zwischen den Feldern einer Anweisungszeile koennen beliebig (SP) und (HT) stehen, so dass die Position der Felder innerhalb der Quellzeile zunaechst nicht festgelegt ist. Um uebersichtliche Uebersetzungslisten zu erhalten, empfiehlt es sich, das Standard- format zu benutzen. Durch Einfuegen von (HT) ist das bequem er- reichbar. Danach gilt: 9 Markenfeld beginnt ab Spalte 1 Operationsfeld " " " 9 (nach 1 Tabulator) Operandenfeld " " " 17 ( " 2 Tabulatoren) Kommentarfeld " " " 33 ( " 4 " ) Beispiel: Nach den Regeln sind folgende Anweisungen moeglich: A:CLR(R0);KOMMENTAR SYM421: MOV@A, B + 2 ( R0 ); KOMMENTAR Im Standardformat sehen sie so aus: A: CLR (R0) ;KOMMENTAR SYM421: MOV @A,B+2(R0) ;KOMMENTAR ' ' ' ' 1 9 17 33 10 3. Grundelemente der Sprache Macro 1600 --------------------------------------- 3.1. Zeichen, Symbole, Ausdruecke --------------------------------- 3.1.1. Zeichen -------------- In der Sprache MACRO 1600 werden folgende Zeichen verwendet: - Grossbuchstaben A B C ... - Ziffern 0 1 2 3 4 5 6 7 8 9 - 25 Sonderzeichen (siehe Tabelle 1) Eine besondere Gruppe hieraus sind die Radix-50-Zeichen, zu denen die Grossbuchstaben und Ziffern sowie Punkt, Dollar und das (SP) gehoeren. Sie sind zur Bildung von Symbolen und Radix-50-Konstan- ten vorgesehen. Kleinbuchstaben sind zulaessig, sie werden automatisch in Gross- buchstaben umgewandelt. In Kommentaren und Textvereinbarungen koennen auch die uebrigen druckbaren KOI-7-Zeichen vorkommen (z.B. ?). Tabelle 1: Sonderzeichen in MACRO 1600 ---------------------------------------------------------------- Zeichen Funktion ---------------------------------------------------------------- : Markenbegrenzer ; Beginn des Kommentarfeldes , Trennzeichen fuer Operanden . Speicherplatzzaehler oder Kennzeichen fuer Dezimalzahlen $ Kennzeichen fuer lokale Symbole % Registerkennzeichen @ Kennzeichen fuer indirekte Adressierung ( ) Begrenzer fuer Registerausdruecke # Kennzeichen fuer Direktoperanden = Kennzeichen fuer Direktanweisung oder Kennzeichen fuer Makro-Kennwortparameter + - Arithmetische Operatoren oder Kennzeichen fuer Autoincrement- bzw. Autodecrement-Modus * / Arithmetische Operatoren "und" ! Logische Operatoren "und" bzw. "oder" ^ Kennzeichen fuer verschiedene einstellige Operatoren oder Begrenzer fuer Ausdruecke < > Begrenzer fuer Ausdruecke ' " Kennzeichen fuer ein bzw. zwei KOI-7-Zeichen \ Kennzeichen fuer numerische Parameter bei Makroanweisungen (SP) Trennzeichen fuer Operanden (HT) Trennzeichen fuer Operanden ---------------------------------------------------------------- 11 3.1.2. Zahlen ------------- Anmerkung: An dieser Stelle wird die aeussere Darstellung von einfachen Zahlen (mit einer Laenge von einem Wort), die als Ausdrucksbestandteile vorkommen koennen, beschrieben. Es gibt Oktal- und Dezimalzahlen. Nicht gekennzeichnete Zahlen werden als Oktalzahlen gewertet, Dezimalzahlen sind durch einen nachgestellten Punkt . gekennzeichnet. (Mit der Anweisung .RADIX kann eine andere Festlegung getroffen werden, siehe Abschnitt 4.4.2.) Oktalzahlen bestehen aus Vorzeichen (+ oder -) und 1 bis 6 Oktal- ziffern (0, 1, ...7). Das positive Vorzeichen kann weggelassen werden. Zulaessiger Zahlenbereich: 0 bis 177777. Bei negativem Vorzeichen wird das Zweierkomplement gebildet, z.B. sind die Ok- talzahlen -400 und 177400 gleichwertig. Dezimalzahlen bestehen aus Vorzeichen, 1 bis 5 Dezimalziffern (0, 1, ...9) und dem Punkt. Das positive Vorzeichen kann weggelassen werden. Zulaessiger Zahlenbereich: -32768. bis +32767. Zahlen koennen z.B. absolute Adressen sein; sie kommen als Be- standteile von Ausdruecken, in Direktoperanden u.a. vor. Zahlen koennen auch durch spezielle Typkennzeichen erklaert wer- den, siehe Abschnitt 3.1.7. 3.1.3. Symbole -------------- In MACRO 1600 werden hinsichtlich der aeusseren Darstellungsform normale Symbole und lokale Symbole (siehe Abschnitt 3.1.4.) un- terschieden. Ein normales Symbol ist eine Folge von maximal 6 alphanumerischen Zeichen (Buchstaben oder Ziffern) oder . oder $ , wobei das erste Zeichen keine Ziffer sein darf. Es koennen auch mehr Zeichen benutzt werden, jedoch sind nur die ersten 6 Zeichen signifikant. Beispiele: A SYMBOL X2Y4 ..B F$125 Es gibt 2 278 547 452 verschiedene Symbole. Die Zeichen . und $ sind vor allem fuer Symbole in den Systemprogrammen reserviert und sollten daher vom Nutzer nicht verwendet werden. Hinsichtlich der Verwendungsform gibt es permanente Symbole, Nutzersymbole und Makrosymbole. Permanente Symbole sind in ihrer Bedeutung festgelegt und brau- chen nicht definiert zu werden. Es handelt sich dabei um die Mnemoniks der Maschinenbefehle und Pseudobefehle. Nutzersymbole (Symbole im engeren Sinn) werden im Programm definiert, und zwar im Markenfeld oder durch eine Direktanweisung. Ein Sonderfall ist die Definition von Symbolen durch Attributanweisungen (siehe Ab- schnitt 5.5.). 12 Hinsichtlich des Gueltigkeitsbereiches werden bei den Nutzersym- bolen interne Symbole und globale Symbole (siehe Abschn. 4.5.1.) unterschieden. Makrosymbole werden als Makronamen benutzt (siehe Abschnitt 5.1. und 5.3.). Im Markenfeld werden Symbole stets als Nutzersymbole behandelt.Im Operationsfeld haben Makrosymbole den Vorrang vor den permanenten Symbolen. (Ist ein Makro definiert, dessen Name z.B. mit dem Mnemonik eines Pseudobefehls uebereinstimmt, so gilt eine ent- sprechende Anweisung als Makroanweisung.) Im Operandenfeld gelten Symbole im allgemeinen als Nutzersymbole. (Fuer nicht definierte und nicht als global spezifizierte Symbole im Operandenfeld, die mit dem Mnemonik eines Maschinenbefehls uebereinstimmen, gilt der entsprechende Befehlscode als Wert.) Im Normalfall gelten Nutzersymbole jeweils fuer das Programm, in dem sie definiert sind (interne Symbole). Ausserdem koennen auch globale Symbole verwendet werden, die in allen Moduln gelten, die zu einer Task verbunden werden und dadurch Bezugnahmen zwischen mehreren Programmen gestatten (siehe Abschnitt 4.5.1.). 3.1.4. Lokale Symbole --------------------- Lokale Symbole sind spezielle Nutzersymbole, die sich in der aeusseren Darstellungsform von den normalen Symbolen unterschei- den und die nur innerhalb eines begrenzten Programmabschnitts, des "lokalen Symbolblocks" gueltig sind. Lokale Symbole haben die Form: n$ wobei n eine Dezimalzahl zwischen 1 und 65535 ist. Im Normalfall ist ein lokaler Symbolblock durch zwei aufeinander- folgende Marken, die als normale Symbole gebildet sind, begrenzt. Auch die Anweisungen .PSECT begrenzen einen lokalen Symbolblock. Direktanweisungen beeinflussen die Grenzen eines lokalen Symbol- blockes nicht. Ausserdem koennen lokale Symbolbloecke durch die Anweisungen .ENABL LSB bzw. .DSABL LSB (siehe Abschnitt 4.4.1.) erklaert werden. Dadurch kann der sonst bestehende lokale Symbolblock zwischen zwei aufeinanderfolgenden Marken ausgedehnt bzw. verkuerzt werden. Die besondere Eigenschaft lokaler Symbole besteht darin, dass in verschiedenen lokalen Symbolbloecken die gleichen lokalen Symbole (in jeweils eigener Bedeutung) definiert und benutzt werden koen- nen. Die Benutzung lokaler Symbole innerhalb kurzer Programmstuecke kann die Uebersichtlichkeit eines umfangreichen Programms erhoe- hen. Es empfiehlt sich, lokale Symbole fuer Marken von lokaler Bedeutung (z.B. Zieladressen von Verzweigungsbefehlen) zuverwen- den und z.B. Eintrittspunkte durch normale Symbole zu bezeichnen. Lokale Symbole werden in der Symboltabelle der Uebersetzungsliste und in der Cross-reference-Tabelle nicht beruecksichtigt. Lokale Symbole beanspruchen weniger Speicherplatz in der Symbol- tabelle des Makroassemblers als normale Symbole. 13 Lokale Symbole n$ mit n = 64 ... 127 sind fuer die automatische Symbolgenerierung bei der Makrouebersetzung (siehe Abschnitt 5.4.7.) reserviert. 3.1.5. Speicherplatzzaehler --------------------------- Eine wichtige Groesse des Makroassemblers ist der Speicherplatz- zaehler (location counter). Am Programmanfang wird er auf Null eingestellt, und von da an registriert er die Anzahl der bis an eine beliebige Stelle des Programms belegten Speicherplaetze (als Byteadresse). Sein Stand entspricht also stets der Adresse, die ein Befehl belegt (relativ zum Programmanfang). Der Speicherplatzzaehler wird durch einen Punkt . dargestellt. Im Operandenfeld stellt er seinen Wert, d.h. die laufende relative Adresse dar. In einer Direktanweisung kann dem Speicherplatzzaehler ein Wert zugewiesen werden (siehe Abschnitt 3.2.). 3.1.6. Zeichenkonstanten ------------------------ Durch die einstelligen Operatoren ' bzw. " werden 16-Bit-Konstan- ten aus einem bzw. zwei nachfolgend angegebenen Zeichen des KOI- 7-Codes erzeugt. Die Zeichenkonstanten haben die Form 'x bzw. "xy wobei fuer x und y beliebige druckbare KOI-7-Zeichen stehen. Der Wert des nach ' stehenden Zeichens wird in das niederwertige Byte eines 16-Bit-Wortes uebertragen, das hoeherwertige Byte wird geloescht. Die Werte der beiden nach " stehenden Zeichen werden nacheinander in das nieder- bzw. hoeherwertige Byte eines 16-Bit- Wortes uebertragen. Beispiel: Der Ausdruck 'A erzeugt folgendes Wort: 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 '-------------' Binaerwert des Zeichens A Der Ausdruck "AB erzeugt folgendes Wort: 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 1 '-------------' '-------------' Binaerwert des Binaerwert des Zeichens B Zeichens A 3.1.7. Konstanten mit Typkennzeichen ------------------------------------ Die verschiedenen Arten von Konstanten werden durch bestimmte Operatoren spezifiziert, naemlich: Oktalzahlen (s. Abschn. 3.1.2.) ohne Dezimalzahlen (s. Abschn. 3.1.2.) durch nachgestellten Punkt Zeichenkonstanten (s. Abschn. 3.1.6.) durch ' bzw. " 14 Ergaenzend dazu stehen einige einstellige Operatoren zur Erzeu- gung dieser und weiterer Konstantentypen zur Verfuegung. Formaler Aufbau einer Konstante mit Typkennzeichen: ^t operand Dabei ist t das Typkennzeichen, fuer das stehen kann: O bei Oktalkonstanten D bei Dezimalkonstanten B bei Binaerkonstanten R bei Radix-50-Konstanten F bei Gleitkommakonstanten Zwischen dem Typkennzeichen und dem Operanden koennen (SP) oder (HT) stehen (ausser bei ^R). 3.1.7.1. Oktal-, Dezimal- und Binaerkonstanten ---------------------------------------------- Bei den Operatoren ^O bzw. ^D steht als Operand eine Oktalzahl bzw. Dezimalzahl (s. Abschn. 1.2.2.). So sind z.B. die Ausdruecke 140. und ^D 140 Darstellungen fuer die gleiche Zahl. Bei dem Operator ^B steht als Operand eine Binaerzahl, d.h. eine Folge von maximal 16 Binaerziffern (0 oder 1). Die Anwendung dieser Konstantentypen ist vor allem dann sinnvoll, wenn Konstanten definiert werden sollen, die unabhaengig von im Programm vorkommenden .RADIX-Anweisungen sein sollen (das trifft besonders in Makrodefinitionen zu). Die Operatoren ^O, ^D und ^B kommen auch als temporaere Radix- Operatoren in Ausdruecken vor (s. Abschn. 3.1.9.). 3.1.7.2. Radix-50-Konstanten ---------------------------- Bei dem Operator ^R stehen als Operand ein bis drei Radix-50- Zeichen, deren Wert im Radix-50-Format in ein 16-Bit-Wort gespei- chert wird. Das Radix-50-Format gestattet eine Packungsdichte von drei Zei- chen je 16-Bit-Wort. Die dabei zulaessigen Zeichen (Radix-50- Zeichen) und die ihnen zugeordneten Werte sind in Tabelle 2 aufgefuehrt. 15 Tabelle 2: Radix-50-Zeichen ----------------------------------------------- | Zeichenwert | Radix-50-Wert | (oktal) | (oktal) ----------------------------------------------- (SP) | 40 | 0 Buchstaben A...Z | 101...132 | 1...32 $ | 44 | 33 . | 56 | 34 (nicht benutzt) | | 35 Ziffern 0...9 | 60...71 | 36...47 ----------------------------------------------- Die Packung von drei Zeichen XYZ mit dem Radix-50-Werten x, y und z erfolgt nach: Radix-50-Wert von XYZ = ((x*50)+y)*50+z So entspricht z.B. die Radix-50-Konstante ^RAB1 dem Wert ((1*50)+2)*50+37 = 3257 (oktal) Der maximale Wert einer Radix-50-Konstanten ist 174777. Sind in einer Radix-50-Konstante weniger als drei Zeichen angege- ben, so werden Nullen ergaenzt. 3.1.7.3. Gleitkommakonstanten ----------------------------- Bei dem Operator ^F steht als Operand eine Gleitkommazahl, die gerundet in ein 16-Bit-Wort gespeichert wird. Der formale Aufbau und die interne Darstellung von Gleitkommazah- len ist in Abschnitt 4.1.4. beschrieben. 3.1.8. Registerausdruecke ------------------------- Zur Bezeichnung der Register 0 bis 7 dienen die Registersymbole. Sie haben die Form %n (mit n = 0...7). Standardgemaess sind spezielle Symbole diesen Registersymbolen gleichgesetzt und verfuegbar, und zwar: R0 = %0 R4 = %4 R1 = %1 R5 = %5 R2 = %2 SP = %6 R3 = %3 PC = %7 Die Definitionen dieser Symbole sind automatisch gegeben. (Durch die Anweisung .DSABL REG werden diese Definitionen ausser Kraft gesetzt, siehe Abschnitt 4.4.1.) Registerausdruecke sind Ausdruecke, die ein Register bezeichnen. Sie sind wie Ausdruecke (s. Abschn. 3.1.9.) aufgebaut und ent- halten mindestens ein Registersymbol bzw. das Registerkennzei- chen %. Beispiele: R0+2 bezeichnet das Register 2 R1+R2 bezeichnet das Register 3 %X bezeichnet z.B. das Register 1, wenn vor- h X=1 gesetzt ist (in einer Direktanwei- sung) 16 Ein allgemeiner Registerausdruck ist ein Registerausdruck in der beschriebenen Form oder ein anderer Ausdruck, der einen absoluten Wert zwischen 0 und 7 hat. So bezeichnet in einem allgemeinen Registerausdruck z.B. die Zahl 1 das Register 1. 3.1.9. Ausdruecke ----------------- Formaler Aufbau eines Ausdrucks: | operator1... term | < > | term [operator2 term]... | Formaler Aufbau eines Terms: | zahl | | symbol | | speicherplatzzaehler | < zeichenkonstante > | konstante mit typkennzeichen | | | Fuer operator1 steht einer der folgenden einstelligen Operatoren: - Negation (Zweierkomplement) ^C (Einer-)Komplement ^O | ^D > Temporaere Radix-Operatoren ^B | Fuer operator2 steht einer der folgenden zweistelligen Operatoren: + Addition - Subtraktion * Multiplikation / Division (ganzzahlig) "und" Konjunktion (Logisches "und") ! Disjunktion (Logisches "oder") Beispiele: F+G .+4/2 -"XY ^CSUMM+2 MASK"und"^B1101 ^RAB1!40000 Die zweistelligen Operatoren haben untereinander die gleiche Pri- oritaet, d.h. die Terme eines Ausdrucks werden stets von links nach rechts abgearbeitet. Beispiel: A+B*C entspricht *C Einstellige Operatoren haben Vorrang vor zweistelligen Operato- ren, z.B. im Ausdruck A+^CB Es koennen mehrere einstellige Operatoren aufeinander folgen, Beispiel: ^D-8 entspricht ^D<-8> Die temporaeren Radix-Operatoren bewirken, dass alle im nachfol- genden Term enthaltenen Zahlen entsprechend des Typkennzeichens O, D oder B als Oktal-, Dezimal- oder Binaerzahlen interpretiert werden. Beispiel: ^D<*> entspricht * 17 Bei einem fehlenden oder unzulaessigen Operator wird die Auswer- tung des Ausdrucks abgebrochen. Ein Ausdruck ist absolut, verschieblich, extern oder komplex. Ab- solute Ausdruecke haben konstante Werte, unabhaengig von der spaeteren Stellung des Programms im Speicher. Verschiebliche Aus- druecke sind auf die Anfangsadresse des Programms bezogen, die beim Aufbau der Task festgelegt wird. Externe Ausdruecke beziehen sich auf ein externes globales Symbol, das in einem anderen Pro- gramm definiert ist. Komplexe Ausdruecke sind Kombinationen mehrerer verschieblicher und/oder externer Ausdruecke. Bei ver- schieblichen, externen und komplexen Ausdruecken uebergibt der Makroassembler vorlaeufige und besonders gekennzeichnete Werte, die durch den Taskbilder korrigiert bzw. ergaenzt werden. Es ist zu beachten, dass bei einigen Anweisungen nur absolute Ausdruecke zugelassen sind. Fuer Terme gilt im einzelnen: Absolut sind: - Zahlen - Zeichenkonstanten - Konstanten mit Typkennzeichen - Symbole, die in Direktanweisungen mit absolutem Ausdruck definiert sind - Symbole, die in einer absoluten Programmsektion definiert sind Verschieblich sind: - Symbole, die als Marken definiert sind (ausser in der absolu- ten Programmsektion) - Symbole, die in Direktanweisungen mit verschieblichem Aus- druck definiert sind - Speicherplatzzaehler Extern sind: - Globale Symbole, die in einem anderen Programm definiert sind Jede Verknuepfung von absoluten Termen ist ein absoluter Aus- druck; die Differenz zweier verschieblicher Terme ist absolut; Summe und Differenz von verschieblichen bzw. externen Termen und absoluten Termen sind verschieblich bzw. extern. Alle anderen zu- sammengesetzten Ausdruecke sind komplex. 3.2. Direktanweisung -------------------- Ein Symbol, das als Marke definiert wird, erhaelt seinen Wert ueber den Speicherplatzzaehler, abhaengig von der Anzahl der bis dahin belegten Speicherplaetze. Im Gegensatz dazu kann einem Sym- bol auch in einer besonderen Anweisung, der "Direktanweisung", unmittelbar (d.h. ohne dabei Speicherplatz zu belegen) ein Wert zugewiesen werden. Formaler Aufbau einer Direktanweisung: symbol =[=] ausdruck Vor und nach dem = koennen (SP) oder (HT) stehen. Durch == werden globale Symbole gekennzeichnet (s. Abschn. 2.5.1.). 18 Durch eine Direktanweisung wird ein Symbol definiert. Dieses ist absolut oder verschieblich, je nachdem, ob der definierende Aus- druck absolut oder verschieblich ist. Der Ausdruck muss einen definierten Wert haben, das bedeutet, dass vorkommende Symbole im Programm vorher definiert sein muessen, und dass externe globale Symbole darin umzulaessig sind. Eine Ausnahme sind die noch ge- statteten einstufigen Vorwaertsverweise, wie z.B.: X=Y Y=1 Das Symbol steht im Markenfeld, das Zeichen = stellt den Operator dar und der definierende Ausdruck den Operanden. Im Standardfor- mat von MACRO 1600 (s. Abschn. 2.2.5.) werden die Felder einer Direktanweisung wie bei den anderen Anweisungen positioniert: X = 1 LAB1: MOV #X,R0 Direktanweisungen koennen zusaetzlich markiert werden. Da eine Direktanweisung keinen Speicherplatz belegt, entspricht der Wert einer Marke der Adresse der naechstfolgenden speicherplatzbe- legenden Anweisung. Mit Direktanweisungen koennen auch dynamische Wertzuweisungen realisiert werden, d.h. ein durch eine Direktanweisung definier- tes Symbol (jedoch nicht eine Marke) kann durch eine weitere, im Programm spaeter auftretende Direktanweisung einen neuen Wert erhalten. In diesem Falle gilt stets der aktuelle Wert. Es ist nicht moeglich, einem lokalen Symbol in einer Direktanwei- sung einen Wert zu geben. Auch dem Speicherplatzzaehler kann in einer Direktanweisung ein Wert zugewiesen werden: . = ausdruck Dadurch kann z.B. Speicherplatz freigehalten werden. Der definie- rende Ausdruck muss stets verschieblich sein. 3.3. Anwendung der Maschinenbefehle ----------------------------------- 3.3.1. Allgemeines ------------------ Die Mnemoniks und der Befehlsablauf der Maschinenbefehle sind in Anlage 2 aufgefuehrt. Formaler Aufbau eines Maschinenbefehls: [marke...] mnemonik [operand [,operand]] [;kommentar] Die bei den einzelnen Befehlsarten erforderlichen Operanden sind in Tabelle 3 aufgefuehrt. 19 Tabelle 3: Befehlsarten und Operandenfeld ---------------------------------------------------------------- Befehle Inhalt des Operandenfeldes ---------------------------------------------------------------- Zweioperandenbefehle Quelloperand, Zieloperand Einoperandenbefehle Operand Register-Adress-Befehle MUL, DIV, ASH, ASHC (Quell-)Operand, Allg. Reg.-ausdruck XOR Allg. Reg.-ausdruck, (Ziel-)Operand SOB Allg. Reg.-ausdruck, Verzweigungsadr. JSR Allg. Reg.-ausdruck, (Ziel-)Operand RTS Allg. Reg.-ausdruck Verzweigungsbefehle Verzweigungsadresse EMT/TRAP Trap-Nummer 1) MARK Mark-Laenge 2) SPL Prioritaet 3) Bedingungscode-Operat. (leer) Sonstige Befehle (leer) ARP-Befehle ----------- Zweioperandenbefehle Gruppe 1 (z.B. LDF) Quelloperand 4) , ARP-Reg.-Ausdruck (z.B. STF) Zieloperand 4) , ARP-Reg.-Ausdruck Gruppe 2 (z.B. LDCIF) Quelloperand 5) , ARP-Reg.-Ausdruck (z.B. STCIF) Zieloperand 5) , ARP-Reg.-Ausdruck Einoperandenbefehle Gruppe 1 (z.B. CLRF) Operand 4) Gruppe 2 (z.B. TSTF) Operand 5) Adresslose Befehle (leer) ---------------------------------------------------------------- 1) Zahl zwischen 0 und 377 (oktal) oder absoluter Ausdruck mit einem entsprechenden Wert 2) Zahl zwischen 0 und 77 (oktal) 3) Zahl zwischen 0 und 7 Fuer den Aufbau der Operanden im eigentlichen Sinne sind die Adressierungsmodi (siehe Abschnitt 3.4.) wesentlich. Zu den all- gemeinen Registerausdruecken siehe Abschnitt 3.1.8. 4) Entspricht in formalem Aufbau und Bedeutung den Operanden bei den allg. Maschinenbefehlen, jedoch bezeichnet ein Re- gisterausdruck im Modus 0 ein ARP-Register (0 bis 5). 5) Entspricht in formalem Aufbau und Bedeutung den Operanden bei den allg. Maschinenbefehlen (ein Registerausdruck im Modus 0 bezeichnet ein allg. Register). ARP-Register-Ausdruck: entspricht im formalen Aufbau dem allge- meinen Registerausdruck, wobei hier nur die Registernummern 0 bis 3 zulaessig sind. 3.3.2. Anmerkungen zu einigen Befehlen -------------------------------------- Die Befehle ADC bzw. SBC koennen dazu benutzt werden, um Doppel- wortoperationen durch Befehlsfolgen zu realisieren. Doppelwortaddition: ADD A0,B0 ;ADDITION DER NIEDERWERTIGEN TEILE ADC B1 ADD A1,B1 ;ADDITION DER HOEHERWERTIGEN TEILE 20 Doppelwortsubtraktion: SUB A0,B0 SBC B1 SUB A1,B1 Der Vergleich zweier Operanden durch den Befehl CMP (bzw. CMPB) wird durch einen nachfolgenden Verzweigungsbefehl ausgewertet. Eine Verzweigung erfolgt, wenn fuer die Operanden (s) und (d) bei dem CMP-Befehl gilt: BLT: (s)<(d) (Arithmetischer Vergleich) BLE: (s)<(d) oder (s)=(d) " " BGE: (s)>(d) oder (s)=(d) " " BGT: (s)>(d) " " BLO: (s) niederwertiger als (d) (Adressenvergleich) BLOS: (s) niederwertiger oder gleich (d) " " BHIS: (s) hoeherwertiger oder gleich (d) " " BHI: (s) hoeherwertiger als (d) " " Bei Adressenvergleichen sollten die vorzeichenbehafteten Ver- gleichsbefehle BLT, BLE, BGE, BGT nicht verwendet werden. Die Benutzung des MOV-Befehls zur Programmsteuerung (z.B. MOV #ALPHA,PC) sowie die analoge Benutzung anderer Befehle (z.B. ADD, SUB) mit Bezug auf den PC ist wegen der dabei fehlenden Ueber- sicht des Programmablaufs und der erhoehten Fehleranfaelligkeit ungeeignet. 3.3.3. Adressierung der Verzweigungsbefehle ------------------------------------------- In MACRO 1600 wird im Operandenfeld der Verzweigungsbefehle ein Ausdruck angegeben, der die Verzweigungsadresse (Zieladresse) bezeichnet. Im Befehlswort der Verzweigungsbefehle ist im nieder- wertigen Byte der Offset enthalten, das ist die relative Sprung- weite als vorzeichenbehaftete Zahl fuer einen Sprung um die be- treffende Anzahl von Worten vor- bzw. rueckwaerts. Es besteht folgende Beziehung: Verzweigungsadresse = (PC) + 2 * Offset (Dabei zeigt der PC stets auf den naechsten Befehl.) Beispiele: Verzweigungsadresse Offset .+4 1 .+2 0 . 377 .-2 376 Die Verzweigungsadresse A muss folgenden Bedingungen genuegen: - innerhalb der Reichweite gelegen, d.h.: A-.-2 -200 < ----- < 200 (oktal) = 2 - innerhalb der gleichen Programmsektion - Externe globale Symbole sind unzulaessig. Beim Befehl SOB ist der Offset eine vorzeichenlose positive Zahl.Es wird ein Sprung um die betreffende Anzahl von Worten rueckwaerts ausgefuehrt. 21 3.3.4. Unterprogrammtechnik --------------------------- Ein Unterprogramm ("subroutine") ist ein Programmstueck, das in einem Programm zur mehrfachen Benutzung zur Verfuegung steht, so dass eine bestimmte Funktion - evtl. mit verschiedenen Parametern - wiederholt ausgefuehrt werden kann. Ein Unterprogramm kann von beliebigen Stellen im Programm aus angesprungen ("aufgerufen") werden. Um die Rueckkehr zum aufrufenden Programm zu realisieren sowie evtl. gegebene Parameter zu uebertragen, stehen spezielle Befehle und Programmiertechniken zur Verfuegung. Unterprogramme werden mit dem Befehl JSR ("jump to subroutine") aufgerufen, die Rueckkehr zum aufrufenden Programm erfolgt mit dem Befehl RTS ("return from subroutine"). Der Unterprogrammsprung hat allgemein die Form: JSR Rn,SUBR Das Register Rn ist das "linkage register", ueber das die Rueck- kehr zum aufrufenden Programm erfolgt; der Ausdruck SUBR bezeich- net das Ziel des Unterprogrammsprungs. Der Unterprogrammrueck- sprung hat allgemein die Form: RTS Rn Bei einem JSR-Befehl muss das gleiche Register als linkage re- gister benutzt werden, das in dem aufgerufenen Unterprogramm beim RTS-Befehl angegeben ist, und dessen Inhalt darf im Ablauf des Unterprogramms nicht zerstoert werden. Als besonders vorteilhaft erweist sich die Verwendung des PC als Linkage register; es koen- nen dann Unterprogrammspruenge beliebig weit geschachtelt werden. Zur Parameteruebertragung (Uebergabe von Werten zum Unterprogramm bzw. von Ergebniswerten zum aufrufenden Programm) gibt es folgen- de drei Moeglichkeiten: Verwendung gemeinsamer Speicherplaetze; Definition eines Parameterblocks nach dem Unterprogrammaufruf; Benutzung des Stack. Als gemeinsame Speicherplaetze zur Parame- teruebertragung koennen Register (sofern nicht als linkage re- gister benutzt) oder gemeinsam vereinbarte Variablen im Arbeits- speicher verwendet werden. Beispiel zur Verwendung eines Parameterblocks: Aufrufendes Programm: Unterprogramm: JSR R5,SUBR -----> SUBR: MOV (R5)+,R0 .WORD PAR1 MOV (R5)+,R1 .WORD PAR2 : BR FEHL <-- : : <-- : N: ADD #2,R5 F: RTS R5 Fuer die Verwendung des Unterprogramms SUBR gilt hier die Verein- barung, dass jedem Aufruf zwei Parameter (PAR1, PAR2) folgen. Diese werden im Unterprogramm durch die MOV-Befehle mit Auto- increment-Modus uebernommen. Im aufrufenden Programm sind zwei Rueckkehrstellen eingerichtet; der erste Befehl nach dem Parame- terblock wird im "Fehlerfall" erreicht, der zweite im "Normal- fall". Im Unterprogramm wird die entsprechende Verzweigung bei den Stellen mit den Marken F bzw. N erreicht. 22 Beispiel zur Benutzung des Stack: Aufrufendes Programm: Unterprogramm: MOV #PAR1,-(SP) SUBR: MOV 2(SP),R1 MOV #PAR2,-(SP) MOV 4(SP),R0 JSR PC,SUBR : ADD #4,SP : : RTS PC In diesem Falle gilt die Vereinbarung, dass vor jedem Aufruf des Unterprogramms SUBR die Adressen von zwei Parametern (PAR1, PAR2) in den Stack gespeichert werden. Diese werden im Unterprogramm uebernommen. Nach Abarbeitung des Unterprogramms wird der Stack- pointer zurueckgestellt. Es sind grundsaetzlich zwei Arten von Unterprogrammen zu unter- scheiden: Interne Unterprogramme sind Routinen, die als Bestandteil eines Quellprogramms auftreten und jeweils nur in einem Programm be- nutzt werden. Bibliotheksunterprogramme werden selbstaendig uebersetzt und koennen dann in eine Bibliothek aufgenommen werden. Beim Bilden der Task werden sie an das aufrufende Programm gebunden. Auf diese Weise koennen sie in mehreren Programmen benutzt werden. Insbesondere steht dem Programmierer eine Reihe von Standard- Unterprogrammen zur Verfuegung, die in System-Unterprogrammbib- liotheken zusammengefasst sind. Vor allem fuer die Bibliotheksunterprogramme stehen die Makros CALL und RETURN zur Verfuegung, die den Unterprogrammsprung und - ruecksprung mit dem PC als Linkage register realisieren. Formaler Aufbau: CALL name (entspricht JSR PC,name) RETURN (entspricht RTS PC) Diese Makros sind auch als Pseudobefehle vorhanden. 3.4. Adressierungsmodi ---------------------- Der Operandenteil im Befehlswort eines Maschinenbefehls enthaelt die Nummer des Registers (0...7) und den Adressierungsmodus (0...7). Der Adressierungsmodus gibt an, wie das Register zu be- nutzen ist, um den eigentlichen, im Befehl zu verarbeitenden Ope- randen zu erhalten. Es gibt acht allgemeine Adressierungsmodi (vor allem mit den Registern 0 bis 6) und vier spezielle Adres- sierungsmodi (bei Register 7). Formaler Aufbau eines Operanden bei den einzelnen Adressierungs- modi: 23 Adressierungs- modus Operand -------------------------------- 0n | R 1n | @R oder (R') 2n | (R')+ 3n > n = @(R')+ 4n | 0...6 -(R') 5n | @-(R') 6n | A(R') 7n | @A(R') 27 #A 37 @#A 67 A 77 @A -------------------------------- Dabei bedeuten: R Registerausdruck (s. Abschn. 3.1.8.) R' Universeller Registerausdruck ( " ) A Ausdruck (s. Abschn. 3.1.9.) Zwischen den einzelnen Sonderzeichen, dem Index A und dem Regi- sterausdruck koennen beliebig (SP) oder (HT) stehen. Die Funktionen der einzelnen Adressierungsmodi sind in Tabelle 4 aufgefuehrt. Tabelle 4: Adressierungsmodi ---------------------------------------------------------------- | Modus | Name | Form | Bedeutung | |-------|---------------|--------|-----------------------------| | | | Direkte Adressierung | | | | 0 | Registermodus | Rn | Das Register enthaelt den | | | | | Operanden | | 2 | Autoincrement | (Rn)+ | Das Register enthaelt die | | | | | Adresse des Operanden. Nach | | | | | Ausfuehrung des Befehls | | | | | wird der Registerinhalt um | | | | | 2 (bei Byte-Befehlen um 1) | | | | | erhoeht. | | 4 | Autodecrement | -(Rn) | Vor Ausfuehrung des Befehls | | | | | wird der Registerinhalt um | | | | | 2 (bei Byte-Befehlen um 1) | | | | | vermindert. Dann enthaelt | | | | | das Register die Adresse | | | | | des Operanden. | | 6 | Indexmodus | x(Rn) | Der dem Befehl folgende | | | | | Speicherplatz enthaelt den | | | | | Index x (ein Wort). Die Sum-| | | | | me x + Inhalt des Registers | | | | | ist die Adresse des Operan- | | | | | den. | |--------------------------------------------------------------- | 24 Tabelle 4: (Fortsetzung) ---------------------------------------------------------------- | Modus | Name | Form | Bedeutung | |-------|---------------|--------|-----------------------------| | Indirekte Adressierung | | | | 1 | Registermodus | @Rn | Das Register enthaelt die | | | indirekt | | Adresse des Operanden. | | 3 | Autoincrement | @(Rn)+ | Das Register enthaelt die | | | indirekt | | Adresse der Operandenadres- | | | | | se. Nach Befehlsausfuehrung | | | | | wird der Registerinhalt um | | | | | 2 erhoeht. | | 5 | Autodecrement | @-(Rn) | Vor Befehlsausfuehrung wird | | | indirekt | | der Registerinhalt um 2 ver-| | | | | mindert. Dann enthaelt das | | | | | Register die Adresse der | | | | | Operandenadresse. | | 7 | Indexmodus | @x(Rn) | Der dem Befehl folgende | | | indirekt | | Speicherplatz enthaelt den | | | | | Index x (ein Wort). Die Sum-| | | | | me x + Inhalt des Registers | | | | | ist die Adresse der Operan- | | | | | denadresse. | ---------------------------------------------------------------- Anmerkungen: - Bei den Adressierungsmodi 6 und 7 wird der PC nach Befehlsaus- fuehrung nochmals um 2 erhoeht (und zeigt dann auf den nach dem Index folgenden Befehl). - Die Register 6 (SP) und 7 (PC) werden im Autoincrement- bzw. Autodecrement-Modus stets um 2 erhoeht bzw. vermindert. - Beim Befehl JMP ist Registermodus verboten. Die Wirkung eines zweifach indirekten Registermodus laesst sich erzielen durch: @0(Rn) Dafuer kann auch geschrieben werden: @(Rn) Die folgende Uebersicht zeigt die allgemeinen Adressierungsmodi nach Adressierungsstufen (Indirektstufen) geordnet. Tabelle 5: Adressierungsmodi nach Adressierungsstufen. ----------------------------------------------------------------- | | Ohne Index |Mit Ind.| | Stufe |-------------------------|--------| | Zusatzbehandlung: | ohne | incr. | decr. | ohne | |----------------------------|-------|--------|--------|--------| | 1 (Operand im Register) | Rn | | | | | | | | | | | 2 (Operandenadresse | (Rn) | (Rn)+ | -(Rn) | x(Rn) | | im Register) | | | | | | 3 (Adresse der Operanden- | @(Rn) | @(Rn)+ | @-(Rn) | @x(Rn) | | adresse im Register) | | | | | ----------------------------------------------------------------- Bei Verwendung des Befehlszaehlers als Register ergeben sich die folgenden speziellen Adressierungsmodi. 25 Tabelle 6: Adressierungsmodi mit PC ---------------------------------------------------------------- | Modus | Name | Form | Bedeutung | |-------|---------------|--------|-----------------------------| | 27 | Direkte | #A | Der dem Befehl folgende | | | Adressierung | | Speicherplatz enthaelt den | | | | | Operanden A. | | 37 | Absolute | @#A | Der dem Befehl folgende | | | Adressierung | | Speicherplatz enthaelt die | | | | | Adresse A des Operanden. | | 67 | Relative | A | Der dem Befehl folgende | | | Adressierung | | Speicherplatz enthaelt die | | | | | relative Adresse (d.h. den | | | | | Abstand zum Befehlszaehler- | | | | | stand) des Operanden. | | 77 | Relativ indi- | @A | Der dem Befehl folgende | | | rekt | | Speicherplatz enthaelt die | | | | | relative Adresse (d.h. den | | | | | Abstand zum Befehlszaehler- | | | | | stand) der Operandenadresse.| ---------------------------------------------------------------- Direkte Adressierung: Nach # steht unmittelbar der Operand (z.B. eine Zahl oder Adres- se). Absolute Adressierung: Eine nach @# stehende Zahl (bzw. absoluter Ausdruck) bezeichnet die absolute Operandenadresse. Diese Adressierung ist positions- unabhaengig (Ein verschieblicher Ausdruck nach @# ist jedoch nicht ueblich). Relative Adressierung: Ein Ausdruck allein bezeichnet die relative Operandenadresse (d.h. bezueglich Programmanfangsadresse). Ein verschieblicher Ausdruck allein ist positionsunabhaengig. Relativ indirekte Adressierung: Ein nach @ stehender Ausdruck bezeichnet die relative Adresse der Operandenadresse. Die folgende Uebersicht zeigt die Adressierungsmodi mit PC in ihrer Entsprechung als allgemeine Adressierungsmodi. MOV #1000,R0 entspricht MOV (PC)+,R0 .WORD 1000 MOV @#1000,R0 entspricht MOV @(PC)+,R0 .WORD 1000 MOV 1000,R0 entspricht MOV 1000-.-4(PC),R0 MOV @1000,R0 entspricht MOV @1000-.-4(PC),R0 26 Beispiel: Das folgende Programmstueck sei ab 50000 geladen; A sei ein verschieblicher Ausdruck mit dem Wert 1200. Befehl Ausfuehrung PIC ----------------------------------------------------------------- MOV #1000,R0 Wert 1000 nach Register 0 * MOV 1000,R0 Inhalt der Speicherzelle 1000 nach Register 0 MOV @#1000,R0 dito * MOV @1000,R0 Auf 1000 stehe der Wert 2000; dann: Inhalt der Speicherzelle 2000 nach Register 0 MOV #A,R0 Wert 51200 (Adresse von A) nach Register 0 MOV A,R0 Inhalt der Speicherzelle 51200 nach * Register 0 MOV @#A,R0 dito MOV @A,R0 Auf 51200 stehe der Wert 3000; dann: * Inhalt der Speicherzelle 3000 nach Register 0 ---------------------------------------------------------------- Positionsunabhaengiger Code (PIC): Die mit * bezeichneten Anweisungen sind positionsunabhaengig, d.h.unabhaengig von der Position der Task im Speicher wird bei der Befehlsausfuehrung der gleiche Operand erreicht. 27 4. Pseudobefehle ---------------- 4.1. Definition von Daten und Adressen -------------------------------------- 4.1.1. Wort- und Byte-Definitionen ---------------------------------- Die allgemeinen Anweisungen zur Definition von Konstanten ver- schiedener Typen von Wort- oder Bytelaenge sowie Adressen sind die Pseudobefehle .WORD und .BYTE. Formaler Aufbau: [marke...] .WORD ausdruck,... [marke...] .BYTE ausdruck,... Zulaessiges Trennzeichen: Komma. Die Werte der im Operandenfeld angegebenen Ausdruecke (welche absolut, verschieblich, extern oder komplex sein koennen) werden in aufeinanderfolgende Worte (bei .WORD) bzw. Bytes (bei .BYTE) gespeichert. Fuer einen fehlenden Ausdruck wird der Wert Null ge- nommen. Die Anweisung .WORD ist nur bei geradzahligem Speicherplatzzaeh- lerstand moeglich. Die Werte der Ausdruecke bei .WORD duerfen die Laenge eines 16-Bit-Wortes (d.h. -32768 bis 32767) nicht ueber- schreiten. Die Werte der Ausdruecke bei .BYTE duerfen die Laenge eines Bytes (d.h. -128 bis 127) nicht ueberschreiten. (Teilaus- druecke koennen auch Wortlaenge haben.) Ein verschieblicher Ausdruck bei .BYTE kann bei der Bildung der Task zu einem Wert fuehren, der ausserhalb der vorgeschriebenen Grenzen liegt; in diesem Falle bringt der Taskbilder eine ent- sprechende Fehlermitteilung. Beispiel: 51 000202 000001 W: .WORD 1 52 000204 077777 .WORD 32767. 53 000206 000000 .WORD ,^B1101,^F2.5 000210 000015 000212 040440 54 000214 000130 .WORD 'X,^C"XY, 000216 123247 000220 000000 55 000222 000036 .WORD B-W 56 000224 000204' .WORD W+2,.-2 ;VERSCHIEBLICH 000226 000224' 57 000230 000002G .WORD GLOB+2 ;EXTERN 58 000232 000000C .WORD W*2,B+W ;KOMPLEX 000234 000000C 59 000236 000000C .WORD GLOB"und"2 60 000240 200 B: .BYTE -200,.-B 000241 001 61 000242 241' .BYTE B+1 62 000243 000C .BYTE GLOB/20 28 Eine Anweisungszeile mit leerem Operationsfeld und besetztem Ope- randenfeld wird als .WORD-Anweisung behandelt. So entspricht z.B. die Anweisungszeile N: 1 der Anweisung N: .WORD 1 4.1.2. Definition von Integerzahlen ----------------------------------- In einem MACRO 1600-Programm koennen Integerzahlen (ganze Dezi- malzahlen) in vier verschiedenen Laengen definiert werden. Ein- fache Integerzahlen (mit einer Laenge von einem 16-Bit-Wort) werden mit der Anweisung .WORD definiert (s. Abschn. 4.1.1.). Zur Definition von Integerzahlen mit einer Laenge von 2, 3 oder 4 Worten stehen die Anweisungen .LONG, .TRI, .QUAD zur Verfuegung. Formaler Aufbau: [marke...] .LONG zahl,... [marke...] .TRI zahl,... [marke...] .QUAD zahl,... Die als Operanden angegebenen Zahlen bestehen jeweils aus einem Vorzeichen (wobei das positive Vorzeichen weggelassen werden kann) und einer dem zulaessigen Zahlenbereich entsprechenden An- zahl von Dezimalziffern. Fuer eine fehlende Zahl wird Null ge- nommen. Zahlenbereiche: Integer, 1 Wort: -32768 bis +32767 Integer, 2 Worte: -2147483648 bis +2147483647 Integer, 3 Worte: -140737488355328 bis +140737488355327 Integer, 4 Worte: -9223372036854775808 bis +9223372036854775807 In der internen Darstellung der Integerzahlen wird das hoechst- wertige Bit als Vorzeichen benutzt. Negative Zahlen werden im Zweierkomplement dargestellt. Eine Integerzahl von 2 Worten Laenge wird in folgendem Format entwickelt: 1.Wort 2.Wort SNNNNNNNNNNNNNNN NNNNNNNNNNNNNNNN ' ' ' ' 32 16 15 0 Hierbei stellen dar: S Vorzeichen (1 Bit) N Wert der Zahl (31 Bits) Integerzahlen von 3 und 4 Worten Laenge sind analog aufgebaut. 29 Beispiel: 51 000202 000001 L: .LONG 32768,-1,+1000000 000204 000000 000206 177777 000210 177777 000212 000017 000214 041100 52 000216 073465 .LONG 2000000000 000220 112000 4.1.3. Definition von tetradischen Dezimalzahlen ------------------------------------------------ Die Dezimalbefehle arbeiten mit tetradischen Dezimalzahlen. Es handelt sich dabei um eine besondere Art der Zahlendarstellung, die eine einfache Konvertierung gestattet. Jede Dezimalziffer wird in vier zusammenhaengenden Bits dargestellt, so dass in einem 16-Bit-Wort stets vier Dezimalziffern verschluesselt werden koennen. Tetradische Dezimalzahlen koennen in einem MACRO 1600- Programm mit der Anweisung .PACKED definiert werden. Formaler Aufbau: [marke...] .PACKED zahl,... Die als Operanden angegebenen Zahlen bestehen jeweils aus einem Vorzeichen (wobei das positive Vorzeichen weggelassen werden kann) und maximal 31 Dezimalziffern. Anmerkung: Im Operationsco- de dieser Anweisung sind nur die Zeichen .PACKE signifikant. Tetradische Dezimalzahlen werden entsprechend der Anzahl der an- gegebenen Dezimalziffern in 1 bis 16 aufeinanderfolgenden Bytes dargestellt. Das niedrigstwertige Byte (mit der hoechsten Adres- se) enthaelt in Bit 0 bis 3 das Vorzeichen. Eine tetradische De- zimalzahl der Form abc...x mit n Dezimalziffern a, b, c bis x fuehrt zu folgender internen Darstellung: n ungerade: n gerade: (Byte-)Adresse (Byte-)Adresse a AAAABBBB a 0000AAAA a+1 CCCCDDDD a+1 BBBBCCCC : : : : : : : : a+k (k=(n-1)/2) XXXXssss a+k (k=n/2) XXXXssss Dabei ist z.B. AAAA die vierstellige Binaercodierung des Wertes der Dezimalziffer a. Fuer ssss steht die Vorzeichencodierung, und zwar bei positiven Zahlen 1100, bei negativen Zahlen 1101. 30 Beispiel: 51 000202 014 P: .PACKED 0,-6 000203 155 52 000204 225 .PACKED 957,57 000205 174 000206 005 000207 174 53 000210 003 .PACKED -343500 000211 103 000212 120 000213 015 4.1.4. Definition von Gleitkommazahlen -------------------------------------- Die Anweisungen zur Definition von Gleitkommazahlen sind die Pseudobefehle .FLT2 und .FLT4. Durch die Anweisung .FLT2 wird eine Gleitkommazahl mit einer Laenge von 2 Worten definiert (ent- spricht dem Datenformat F), und durch .FLT4 wird eine Gleitkomma- zahl von 4 Worten Laenge definiert (entspricht dem Datenformat D). Formaler Aufbau: [marke...] .FLT2 zahl,... [marke...] .FLT4 zahl,... Fuer zahl steht hier eine Gleitkommazahl, die wie folgt aufgebaut ist. Formaler Aufbau einer Gleitkommazahl: [sign] [ganzer teil] [.gebrochener teil] [exponent] Formaler Aufbau des Exponenten: E [sign] exponentbetrag Dabei steht fuer sign das Vorzeichen (+ oder -); das positive Vorzeichen kann weggelassen werden. Die Mantisse der Gleitkommazahl besteht aus dem ganzen Teil und/oder dem gebrochenen Teil. Der Exponent ist ein Zehnerexpo- nent. Beispiel: Die folgenden Gleitkommazahlen sind verschiedene Darstellungen fuer den gleichen Wert. 3 +3 3.000 3E0 +3.0E0 .3E1 +0.03E+02 300E-2 31 Eine Gleitkommazahl wird allgemein in folgendem Format als Folge von vier zusammenhaengenden Worten entwickelt: 1.Wort 2.Wort 3.Wort seeeeeeeemmmmmmm mmmmmmmmmmmmmmmm mmmmmmmmmmmmmmmm ' ' ' ' ' ' ' 63 55 48 47 32 31 16 4.Wort mmmmmmmmmmmmmmmm ' ' 15 0 Hierbei stellen dar: s Vorzeichen (1 Bit) e Exponent (8 Bits) m Mantisse (55 Bits) Eine Gleitkommazahl von 2 Worten Laenge wird wie folgt darge- stellt: 1.Wort 2.Wort seeeeeeeemmmmmmm mmmmmmmmmmmmmmmm ' ' ' ' ' 31 23 16 15 0 Fuer die interne Darstellung einer Gleitkommazahl z wird die exp Zerlegung z = m*2 (mit 0.5 < m < 1.0) = zugrundegelegt. Der interne Exponent wird aus exp+128 gebildet, daraus ergibt sich der zulaessige Zahlenbereich fuer den Zweier- exponenten: -128 < exp < 128. Die interne Mantisse ist der Betrag der Mantisse m, wobei in der Binaerentwicklung das erste Bit (mit der Wertigkeit 0.5) wegge- lassen wird. Die Gleitkommazahl 0.0 wird intern durch Null (d.h. alle Bits geloescht) dargestellt. Beispiele: 1) Die Gleitkommazahl 2.5 ist nach den Regeln als 2 0.625*2 darzustellen. Daraus ergibt sich: Interner Exponent = 2 + 128 = 202 (oktal) 0.625 in Binaerentwicklung: 0.5 10000000 0.125 00100000 ----- -------- 0.625 10100000 Interne Mantisse: 0100000 Interne Darstellung von 2.5: 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 32 2) Die Gleitkommazahl -0.01 ist darstellbar als -6 -0.64*2 , daraus ergibt sich: Interner Exponent = -6 + 128 = 172 (oktal) 0.64 in Binaerentwicklung: 0.5 10000000 0.125 00100000 0.0078125 00000010 0.0039062 00000001 --------- -------- 0.6367187 10100011 0.64 10100100 (gerundet) Interne Mantisse: 0100100 Interne Darstellung von -0.01: 1 0 1 1 1 1 0 1 0 0 1 0 0 1 0 0 Eine im Programm angegebene Gleitkommazahl wird gegebenenfalls so verkuerzt, dass sie in der zutreffenden Weise gespeichert werden kann, d.h. bei den Anweisungen .FLT2 bzw. .FLT4 auf zwei bzw. vier Worte und bei Gleitkommakonstanten (s. Abschn. 3.1.7.3.) auf ein Wort. Standardgemaess wird dabei eine Rundung durchgefuehrt. Dabei wird das hoechstwertige Bit des nicht beizubehaltenden Mantissenteils zum niedrigstwertigen Bit des beizubehaltenden Mantissenteils addiert. Durch die Anweisung .ENABL FPT (s. Abschn. 4.4.1.) wird statt Rundung das Abschneiden von Gleit- kommazahlen veranlasst, dabei wird der nicht beizubehaltende Mantissenteil weggelassen. Beispiel: 51 000202 000000 F: .FLT2 0,2,-0.5 000204 000000 000206 040400 000210 000000 000212 140000 000214 000000 52 000216 037375 .FLT2 .124 000220 171666 53 000222 037775 .FLT2 49.6E-2 000224 171666 54 000226 040375 .FLT2 +0.01984E+02 000230 171666 55 000232 040775 .FLT2 7936E-3 000234 171666 56 000236 077777 .FLT2 1.7014117E38 ;MAX. 000240 077777 57 000242 000200 .FLT2 2.938736E-39 ;MIN. 000244 000000 58 000246 040511 .FLT4 3.141592653589793 ;PI 000250 007732 000252 121041 000254 064276 59 000256 040455 .FLT4 2.718281828459045 ;E 000260 174124 000262 054242 000264 135506 33 4.1.5. Definition von Zeichenketten ----------------------------------- Die Anweisungen zur Definition von Zeichenketten sind die Pseudo- befehle .ASCII und .ASCIZ. Formaler Aufbau: [marke...] .ASCII zeichenkettenterm... [marke...] .ASCIZ zeichenkettenterm... Formaler Aufbau eines Zeichenkettenterms: | /string/ | < > | | Fuer string steht eine Folge von druckbaren KOI-7-Zeichen. Als Begrenzerzeichen kann statt / auch ein beliebiges anderes Zei- chen (ausser = < > ;) benutzt werden, sofern es nicht in der ei- gentlichen Zeichenfolge vorkommt. Insbesondere fuer nicht druckbare Zeichen ist die Darstellung des in < > eingeschlossenen Zeichenwertes geeignet. Fuer den Zei- chenwert steht eine Zahl zwischen 0 und 377 (oktal) oder ein ab- soluter Ausdruck mit einem solchen Wert. Die angegebenen Zeichen werden byteweise nacheinander abgespei- chert. Bei der Anweisung .ASCIZ wird am Ende ein Null-Byte hinzu- gefuegt; dies gestattet einen bequemen Endetest beim byteweisen Verarbeiten einer Zeichenkette. Beispiel: 51 000202 124 A: .ASCII /TEXT/ 000203 105 000204 130 000205 124 52 000206 015 .ASCII <15><12>:1/2: 000207 012 000210 061 000211 057 000212 062 53 000213 123 .ASCII ESEL,LAMA 000214 054 000215 115 54 000216 061 .ASCIZ /12/ 000217 062 000220 000 4.1.6. Definition von Radix-50-Zeichenketten --------------------------------------------- Die Anweisung .RAD50 dient zur Definition von Zeichenketten, die im Radix-50-Format (s. Abschn. 3.1.7.2.) gespeichert werden. Formaler Aufbau: [marke...] .RAD50 zeichenkettenterm... 34 Formaler Aufbau eines Zeichenkettenterms: | /string/ | < > | | Fuer string steht eine Folge von Radix-50-Zeichen (Buchstaben, Ziffern, (SP), "$", Punkt). Statt eines Zeichens kann auch sein Radix-50-Zeichenwert, in < > eingeschlossen, angegeben werden. Die angegebenen Zeichen werden nacheinander zu je dreien zusam- mengefasst und im Radix-50-Format in ein Wort gespeichert. Gege- benenfalls werden am Ende der Zeichenkette ein bzw. zwei (SP) er- gaenzt. Beispiel: 51 000202 005302 R: .RAD50 /A.4/ 52 000204 001700 .RAD50 / X "$"Y/ 000206 126250 53 000210 143146 .RAD50 /1/<35><36> 4.2. Speicherplatzvereinbarungen -------------------------------- 4.2.1. Block-Wort- und Block-Byte-Vereinbarung ---------------------------------------------- Zur Speicherplatzvereinbarung dienen die Pseudobefehle .BLKW (block words) bzw. .BLKB (block bytes), mit denen Bloecke, d.h. eine Anzahl zusammenhaengender Worte bzw. Bytes reserviert wer- den. Formaler Aufbau: [marke...] .BLKW [ausdruck] [marke...] .BLKB [ausdruck] Der im Operandenfeld angegebene Ausdruck stellt die Anzahl der zu reservierenden Worte (bei .BLKW) bzw. Bytes (bei .BLKB) dar. Alle evtl. in diesem Ausdruck vorkommenden Symbole muessen im Programm vorher definiert sein. Fehlt der Ausdruck, so wird 1 angenommen. 4.2.2. Steuerung des Speicherplatzzaehlers ------------------------------------------ Formaler Aufbau: .EVEN .ODD Mit dem Pseudobefehl .EVEN bzw. .ODD wird der Speicherplatzzaeh- ler auf den naechsten geradzahligen bzw. ungeradzahligen Wert eingestellt. Der Pseudobefehl .EVEN ist insbesondere nach einer bytebelegen- den Anweisung (.BYTE, .BLKB, .ASCII, .ASCIZ, .PACKED) geeignet, die fuer eine nachfolgende wortbelegende Anweisung (Maschinenbe- fehl oder .WORD, .RAD50, .BLKW u.a.) erforderliche Wortadresse zu gewaehrleisten. 35 4.3. Pseudobefehle zum Programmaufbau ------------------------------------- 4.3.1. Programmtitel -------------------- Die erste Anweisung eines MACRO 1600-Programms ist in der Regel die Programmtitelanweisung. Formaler Aufbau: .TITLE [name] Fuer name steht eine beliebige Folge von Radix 50-Zeichen. Mit der Anweisung .TITLE wird ein Programmtitel festgelegt, der dem erzeugten Objektmodul als Modulname zugewiesen wird. Dabei werden maximal die ersten sechs Zeichen der angegebenen Zeichen- folge uebernommen, nachfolgend koennen weitere KOI-7-Zeichen stehen. Bei fehlendem Namen wird der Standardname .MAIN. verwen- det. Falls im Programm mehrere .TITLE-Anweisungen vorkommen, gilt die letzte Anweisung. 4.3.2. Untertitel ----------------- Ein Programm kann durch Untertitel gegliedert werden, so dass sein Aufbau in der Uebersetzungsliste uebersichtlich erkennbar wird. Dazu dient die Anweisung .SBTTL ("subtitle"). Formaler Aufbau: .SBTTL [name] Fuer name steht eine beliebige Folge von druckbaren KOI-7-Zeichen. Mit der Anweisung .SBTTL wird ein Untertitel festgelegt, der fuer das nachfolgende Programmstueck (bis zur naechsten .SBTTL-Anwei- sung oder bis zur .END-Anweisung) gilt. Vor der eigentlichen Uebersetzungsliste wird ein Inhaltsverzeich- nis ausgegeben, das alle Untertitel des Programms enthaelt. In der zweiten Kopfzeile jeder Seite erscheint der jeweils gueltige Untertitel. 4.3.3. Programm-Identifikation ------------------------------ Mit der Programm-Identifikation kann das aus einem MACRO 1600- Programm erzeugte Objektmodul zusaetzlich zum Modulnamen gekenn- zeichnet werden. Diese Identifikation erscheint in der Task- bilder-Liste. Formaler Aufbau: .IDENT /string/ Fuer string steht eine Kette von maximal sechs Radix-50-Zeichen. 36 Beispiel: .IDENT /VERS.3/ Falls im Programm mehrere .IDENT-Anweisungen vorkommen, gilt die letzte Anweisung. 4.3.4. Programmende ------------------- Ein MACRO 1600-Programm wird stets durch die Anweisung .END abge- schlossen. Formaler Aufbau: .END [ausdruck] Der im Operandenfeld angegebene Ausdruck bezeichnet die Start- adresse des Programms. Bei der Bildung einer Task aus mehreren Objektmoduln muss genau ein Modul mit angegebener Startadresse vorhanden sein. Die nicht spezifizierte Startadresse wird im Objektmodul durch die Adresse 1 gekennzeichnet. 4.4. Pseudobefehle zur Uebersetzungssteuerung --------------------------------------------- 4.4.1. Allgemeine Uebersetzungssteuerung ---------------------------------------- Die Anweisungen .ENABL ("enable") und .DSABL ("disable") dienen dazu, den Ablauf der Uebersetzung eines Programms in verschieden- artiger Weise zu beeinflussen. Formaler Aufbau: .ENABL arg,... .DSABL arg,... Fuer arg stehen die in Tabelle 7 aufgefuehrten Argumente. Zu- laessige Trennzeichen: Komma, (SP), (HT). In der .ENABL-Anweisung wird die einem Argument entsprechende Funktion freigegeben, in der .DSABL-Anweisung wird sie unterdrueckt. Zu jedem Argument gibt es eine Standardfestlegung fuer die entsprechende Funktion, die fuer das Programm gilt, solange das Argument noch nicht in einer .ENABL- oder .DSABL-Anweisung aufgetreten ist. 37 Tabelle 7: Argumente bei .ENABL/.DSABL ----------------------------------------------------------------- | Argu- | Funktion | Stan- | | ment | | dard | |-------|-----------------------------------------------|-------| | AMA | ("absolute mode addressing") | nein | | | Alle relativen Adressen (Adressierungsmodus | | | | 67) werden als absolute Adressen (Adressie- | | | | rungsmodus 37) uebersetzt. | | | | (Diese Funktion kann in der Testphase der | | | | Programmentwicklung nuetzlich sein.) | | | REG | ("register definitions") | ja | | | Die Standard-Registersymbole R0, R1, ... PC | | | | sind gueltig. (In Verbindung mit .DSABL REG | | | | den.) | | | GBL | ("global symbols") | ja ** | | | Alle nicht definierten Symbole des Programms | | | | werden als (externe) globale Symbole behan- | | | | delt. (Bei .DSABL GBL erscheint bei den | | | | nicht definierten Symbolen das Fehlerkennzei- | | | | chen U.) | | | LC | ("lower case") | nein | | | Kleinbuchstaben werden vom Uebersetzer unver- | | | | aendert uebernommen. (Sonst werden sie auto- | | | | matisch in Grossbuchstaben umgewandelt.) | | | CDR | ("card reader") | nein | | | Die Positionen 73 bis 80 der Quellzeilen wer- | | | | den stets als Kommentar behandelt. | | | FPT | ("float point truncation") | nein | | | Die im Programm definierten Gleitkommazahlen | | | | werden abgeschnitten. (Im Standardfall werden | | | | sie gerundet.) | | | LSB | ("local symbol block") | nein | | | Durch .ENABL LSB wird ein lokaler Symbol- | | | | block eroeffnet (s. Abschn. 3.1.4). Dieser | | | | erstreckt sich bis zur naechsten Anweisung | | | | .ENABL LSB oder .DSABL LSB. | | | ABS | ("absolute binary output") | nein | | | Absolute Binaerausgabe anstelle der Ausgabe | | | | des Objektcodes. | | | PNC | ("punch") | ja | | | Durch .DSABL PNC wird die Binaerausgabe | | | | unterbrochen. | | | CRF | ("cross reference") | ja | | | Ausgabe der Cross-reference-Tabelle | | | PIC * | ("position independent code") | nein | | | Es sind nur die Adressierungsarten des posi- | | | | tionsunabhaengigen Codes zulaessig. | | ----------------------------------------------------------------- ** Standard: nein bei LAOS 1600 * Das Argument PIC ist nur bei MOOS 1600 und OMOS 1630 vorhan- den. Die Funktionen zur Uebersetzungssteuerung koennen auch durch Schalter im Kommando angewiesen werden. In diesem Falle treten die entsprechenden .ENABL/.DSABL-Anweisungen ausser Kraft. In Ab- haengigkeit von der Generierung des Makroassemblers koennen auch andere Standards gelten. 38 Beispiel: 51 .DSABL GBL U 52 000202 000000 E: .WORD UNDEF1 ;UNDEFINIERT 53 .ENABL GBL 54 000204 000000G .WORD UNDEF2 ;GLOBAL 55 ; 56 .DSABL REG 57 000206 000000 R0: .WORD 0 58 000210 005067 CLR R0 177772 59 .ENABL REG 60 000214 005000 CLR R0 61 ; 62 .ENABL LC 63 000216 141 .ASCII /a/ 64 .DSABL LC 65 000217 101 .ASCII /a/ 66 ; 67 .ENABL FPT 68 000220 040231 .WORD ^F1.2 69 .DSABL FPT 70 000222 040232 .WORD ^F1.2 71 ; 72 .ENABL AMA 73 000224 005037 CLR E 000202' 74 .DSABL AMA 75 000230 005067 CLR E 177746 4.4.2. Steuerung der Zahlenbasis -------------------------------- Zahlen ohne zusaetzliche Kennzeichnung werden standardgemaess als Oktalzahlen behandelt (siehe Abschnitt 3.1.2.). Mit dem Pseudo- befehl .RADIX kann die Basis fuer unbezeichnete Zahlen festgelegt werden. Formaler Aufbau: .RADIX n Fuer n steht die Zahlenbasis, und zwar 2, 8 oder 10. Fuer alle unbezeichneten Zahlen (d.h. Zahlen ohne Dezimalpunkt und ohne vorangestellten Konstantentyp bzw. temporaeren Radix- Operator) gilt dann die in der .RADIX-Anweisung festgelegte Zah- lenbasis, d.h. sie werden als Binaer-, Oktal- oder Dezimalzahlen behandelt. Das gilt jeweils bis zur naechstfolgenden .RADIX- Anweisung. 39 4.5. Pseudobefehle mit Bezug zum Taskbilder ------------------------------------------- 4.5.1. Globale Symbole ---------------------- Bei der Verbindung einzelner Objektmoduln zu einer Task durch den Taskbilder werden im allgemeinen globale Symbole benutzt. Glo- bale Symbole gelten in allen Moduln, die zu einer Task verbunden werden und gestatten damit Bezugnahmen zwischen den betreffenden Programmen. Ein globales Symbol muss in einem der zur Verbindung vorgesehenen Programme definiert sein (es wird dort als internes Symbol behandelt, ist aber als global gueltig gekennzeichnet), und in allen anderen Programmen, in denen es ebenfalls als global erklaert (aber nicht definiert) ist, kann es (als externes Sym- bol) benutzt werden. Mit dem Pseudobefehl .GLOBL werden die globalen Symbole eines Programms (und zwar die internen wie auch die externen) erklaert. Formaler Aufbau: .GLOBL symbol,... Zulaessige Trennzeichen: Komma, (SP), (HT) Die in einem Programm vorkommenden nicht definierten Symbole werden standardgemaess als (externe) globale Symbole aufgefasst. (Durch die Anweisung .DSABL GBL kann dies ausser Kraft gesetzt werden.) Die in einem Programm definierten (internen) globalen Symbole koennen auch durch die Form ihrer Definition als solche gekenn- zeichnet werden. (Dann ist ihre Aufnahme in eine .GLOBL- An- weisung nicht erforderlich.) Definition eines globalen Symbols als Marke: symbol:: Definition eines globalen Symbols in einer Direktanweisung: symbol == ausdruck 40 Beispiel: Die folgenden Programmausschnitte gehoeren zu Pro- grammen, die zu einer Task verbunden werden sollen. 1 .TITLE PROG1 2 .GLOBL GLO1 3 .GLOBL REF2 : : : : 21 000022 005010 GLO1: CLR (R0) : : : : 30 000044 000207 RTS PC 31 000046 016767 MOV REF2,GLO2 000000G 000106 : : : : 71 000162 GLO2:: .BLKW 2 ;GLOBALE MARKE 72 000000' .END START 1 .TITLE PROG2 2 .GLOBL GLO1,GLO2 3 .GLOBL REF3 4 000000 004767 JSR PC,GLO1 000000G : : : : 16 000034 016700 MOV GLO2+2,R0 000002G : : : : 40 000126 000177 JMP @REF3 000000G 41 000004 REF2 == 4 ;GLOBALES SYMBOL 42 000001 .END 1 .TITLE PROG3 2 .GLOBL GLO2,REF3 : : : : 20 000032 000046' REF3: .WORD ADR : : : : 31 000046 016700 ADR: MOV GLO2,R0 000000G : : : : 54 000001 .END 41 4.5.2. Bereitstellung der Programmgrenzen ----------------------------------------- Durch die Anweisung .LIMIT werden zwei Speicherplaetze freige- halten, die vom Taskbilder mit Werten belegt werden. Auf dem ersten Wort wird die Endadresse (d.h. die untere Adresse) des von der Task belegten Stack, und auf dem zweiten Wort wird die erste freie Adresse nach dem Programm eingetragen. Formaler Aufbau: [marke...] .LIMIT 4.6. Programmsektionen ---------------------- Jedes MACRO 1600-Programm besteht aus einer oder mehreren Pro- grammsektionen (P-section's), das sind logische Programmeinhei- ten, zu denen der Taskbilder einzeln Zugriff hat und die ent- sprechend ihrer Eigenschaften beim Aufbau der Task umgruppiert, ueberlagert und zusammengesetzt werden koennen. Die Verwendung von Programmsektionen gestattet einen modularen Programmaufbau sowie eine effektive und flexible Speicherbelegung. Der Pseudobefehl .PSECT dient zur Definition von Programmsektio- nen. Formaler Aufbau: .PSECT [name] [,arg,...] Dabei steht fuer name ein Symbol, das den Namen der Programmsek- tion angibt, und fuer arg stehen die in Tabelle 8 aufgefuehrten Argumente. Zulaessige Trennzeichen: Komma, (SP), (HT). Der Pro- grammsektionsname kann auch fehlen, dann muss ein fuehrendes Kom- ma angegeben sein, falls Argumente folgen. Die Argumente sind paarweise vorhanden, wobei jedem Argumente- Paar eine bestimmte Eigenschaft der Programmsektion entspricht. Aus jedem Argumente-Paar kann ein Argument zur Spezifizierung einer Programmsektion benutzt werden, wodurch die entsprechende Eigenschaft gegeben bzw. unterdrueckt wird. Zu jedem Argumente- paar gibt es eine Standardfestlegung, welche gilt, wenn keines der beiden Argumente angegeben ist. 42 Tabelle 8: Argumente bei .PSECT ----------------------------------------------------------------- | Argu- | Eigenschaft | Stan-| | ment | der Programmsektion | dard | |---------|----------------------------------------------|------| | ABS/REL | ABS: Absolute Programmsektion. | REL | | | Die Programmsektion ist an einen be- | | | | stimmten Speicherbereich gebunden und | | | | beim Aufbau der Task nicht verschieb- | | | | lich. Alle vorkommenden Adressen gelten | | | | absolut. | | | | REL: ("relocatable") | | | | Verschiebliche Programmsektion. | | | | Die Anfangsadresse ist nicht fest, und | | | | alle verschieblichen Adressen beziehen | | | | sich auf diese Anfangsadresse. | | | CON/OVR | CON: ("concatenated") | CON | | | Verkettete Programmsektion. | | | | Alle Beitraege zu der Programmsektion | | | | werden linear aneinandergereiht. | | | | OVR: ("overlaid") | | | | Ueberlagerungs-Programmsektion. | | | | Die aus verschiedenen Moduln stammen- | | | | den Beitraege zu der Programmsektion | | | | werden im Speicher ueberlagert. | | | LCL/GBL | LCL: ("local") | LCL | | | Die Programmsektion ist fuer ein Seg- | | | | ment gueltig. | | | | GBL: ("global") | | | | Die Programmsektion gilt fuer mehrere | | | | Segmente. Falls in verschiedenen Seg- | | | | menten Beitraege zu einer globalen | | | | Programmsektion vorkommen, werden diese | | | | im "hoechsten" Segment gesammelt. | | | I/D | I: ("instructions") | I | | | Die Programmsektion enthaelt Befehle. | | | | D: ("data") | | | | Die Programmsektion enthaelt nur Daten. | | | RO/RW | RO: ("read only") | RW | | | Als Zugriff zur Programmsektion ist nur | | | | Lesen erlaubt. | | | | RW: ("read/write") | | | | Als Zugriff zur Programmsektion ist | | | | Lesen und Schreiben erlaubt. | | ----------------------------------------------------------------- In den fuer eine Task vorgesehenen Programmen sind insgesamt ma- ximal 256 Programmsektionen moeglich, und zwar 2 Standard-Pro- grammsektionen und 254 eigentliche, mit frei waehlbaren Namen und Eigenschaften versehene Programmsektionen. Die Standard-Pro- grammsektionen werden stets beruecksichtigt und im erzeugten Ob- jektcode sowie in der Uebersetzungsliste ausgewiesen (bei Fehlen mit der Laenge 0). Es handelt sich dabei um die unbenannte, ver- schiebliche Programmsektion (mit dem nur aus Leerzeichen beste- henden Namen = blank) und um die absolute Programmsektion, die den Namen .ABS. traegt. Ein Programm, das keine .PSECT-Anweisung enthaelt, wird automatisch als unbenannte, verschiebliche Pro- grammsektion behandelt. Die absolute Standard-Programmsektion .ABS. nimmt alle absoluten (internen) globalen Symbole eines 43 Programms auf. Jede Programmsektion beginnt mit dem Speicher- platzzaehlerstand Null. In einer absoluten Programmsektion muss am Anfang der Speicherplatzzaehler durch eine Anweisung .=ausdruck eingestellt werden. An verschiedenen Stellen eines Programms verteilt koennen mehrere Beitraege zu der gleichen Programmsektion vorkommen, dies ergibt sich daraus, dass der gleiche Programmsektionsname benutzt wird. Dann gelten die in der zum ersten Beitrag gehoerigen .PSECT- Anweisung festgelegten Eigenschaften auch fuer alle weiteren Bei- traege (und in deren zugehoerigen .PSECT-Anweisung koennen die Argumente weggelassen werden). Auch die Eigenschaften der in ver- schiedenen Moduln vorkommenden Beitraege muessen uebereinstimmen. Die Speicherplatzzuweisung fuer eine Programmsektion innerhalb eines Programms erfolgt fortlaufend ueber alle ihre Beitraege hinweg. Das wird dadurch ermoeglicht, dass der Assembler fuer jede Programmsektion einen eigenen Speicherplatzzaehler fuehrt. Adressverbindungen zwischen verschiedenen verschieblichen Pro- grammsektionen werden bei der Uebersetzung als relativ zur An- fangsadresse der betreffenden Programmsektion ausgewiesen. Der Taskbilder wandelt diese in die endgueltigen Adressen um. Beispiel: Die folgenden Programmausschnitte gehoeren zu Pro- grammen, die zu einer Task verbunden werden sollen. 1 .TITLE PROG1 2 000000 .PSECT SEK1,ABS 3 020000 . = .+20000 4 020000 000000 A: .WORD 0,1 020002 000001 5 020004 B: .BLKW 2 6 ; 7 000000 .PSECT SEK2 8 000000 005067 START: CLR B 020004 9 000004 005067 CLR B+2 020006 10 000010 000167 JMP S 000002 11 ; 12 000000 .PSECT SEK3,OVR 13 000000 000010 X: .WORD 10,20 000002 000020 14 000004 000030 .WORD 30,40 000006 000040 15 ; 16 000014 .PSECT SEK2 17 000016' . = .+2 18 000016 016767 S: MOV X+2,B 000002' 020004 : : : : 80 020010 .PSECT SEK1 81 020010 .BLKW 1 : : 170 000000' .END START 44 1 .TITLE PROG2 2 000000 .PSECT SEK3,OVR 3 000010' . = .+10 4 000010 000050 .WORD 50,60 000012 000060 : : : : 65 .END Nach der Bildung der Task ergibt sich die folgende Speicherbele- gung - angedeutet durch die entsprechenden Anweisungen. (Hier sind a und b die vom Taskbilder festgelegten Anfangsadressen der verschieblichen Programmsektionen SEK2 und SEK3.) 20000 A: .WORD 0,1 | 20004 B: .BLKW 2 | 20010 .BLKW 1 > Programmsektion SEK1 : : | : : | ----- a CLR B | a+4 CLR B+2 | a+10 JMP S > Programmsektion SEK2 a+16 S: MOV X,B | : : | ----- b X: .WORD 10,20 | b+4 .WORD 30,40 | b+10 .WORD 50,60 > Programmsektion SEK3 : : | : : | 4.7. Bedingte Uebersetzung -------------------------- Die bedingte Uebersetzung ermoeglicht es, dass aus einem Quell- programm eine bestimmte Auswahl zur Uebersetzung gelangt, waeh- rend die uebrigen Quellzeilen unberuecksichtigt bleiben. Die Steuerung geschieht dabei durch Bedingungstests in speziellen Pseudobefehlen. Mit Hilfe der bedingten Uebersetzung ist es moeg- lich, das verschiedene Versionen (Objektmoduln) vom gleichen Quellprogramm aus generiert werden. 4.7.1. Bloecke zur bedingten Uebersetzung ----------------------------------------- Ein Block zur bedingten Uebersetzung (conditional assembly block) wird durch den Pseudobefehl .IF eroeffnet und durch den naechstfolgenden Pseudobefehl .ENDC abgeschlossen. Formaler Aufbau: .IF cond,arg .ENDC Dabei ist cond einer der in Tabelle 9 aufgefuehrten Bedingungs- operatoren, und fuer arg stehen ein bzw. zwei Argumente, in Ab- haengigkeit von dem Bedingungsoperator. Zulaessige Trennzeichen: Komma, (SP), (HT). 45 Der Pseudobefehl .IF bewirkt folgendes: Ist die angegebene Be- dingung erfuellt, so wird der sich bis .ENDC erstreckende Block- uebersetzt, andernfalls wird dieser Block uebergangen. Tabelle 9: Bedingungsoperatoren fuer bedingte Uebersetzung ----------------------------------------------------------------- | Bedingungs-| Argu- | Bedingung | | operator | ment(e) | | |------------|----------|---------------------------------------| | EQ oder Z | Ausdruck | Wert des Ausdrucks = 0 (equal; zero) | | NE oder NZ | Ausdruck | Wert des Ausdr. ungleich 0 (not equal)| | GT oder G | Ausdruck | Wert des Ausdrucks > 0 (greater than) | | LE oder L | Ausdruck | Wert des Ausdrucks < 0 (less than | | | | = or equal) | | LT | Ausdruck | Wert des Ausdrucks < 0 (less than) | | GE | Ausdruck | Wert des Ausdrucks > 0 (greter than | | | | = or equal) | | DF | Symbol | Symbol ist definiert | | NDF | Symbol | Symbol ist nicht definiert | | B | Makropa- | Argument ist leer (blank) | | | rameter | | | NB | Makropa- | Argument ist nicht leer (not blank) | | | rameter | | | IDN | 2 Makro- | Argumente sind identisch | | | param. | | | DIF | 2 Makro- | Argumente sind nicht identisch | | | param. | (different) | ----------------------------------------------------------------- Beispiele: Der nachfolgende Block zur bedingten Uebersetzung wird uebersetzt, wenn: .IF EQ X X = 0 .IF GT .-200 Speicherplatzzaehler > 200 Bei den Bedingungsoperatoren DF und NDF koennen auch komplexe Be- dingungen formuliert werden, die sich auf mehrere Symbole bezie- hen. Dabei steht anstelle des einen Symbols eine Serie von mehre- ren Symbolen, die durch die logischen Operatoren "und" oder ! ("oder") verkettet sind. Beispiel: Die Bedingung DF SYM1"und"SYM2 ist erfuellt, wenn die beiden Symbole SYM1 und SYM2 definiert sind. Bloecke zur bedingten Uebersetzung koennen auch ineinander ver- schachtelt sein, z.B.: .IF DF SYM1 | : | : | .IF DF SYM2 | | : > Innerer > Aeusserer : | Block | Block .ENDC | | : | .ENDC | Wenn die Bedingung des aeusseren Blocks nicht erfuellt ist, wird dieser und damit auch der innere Block nicht uebersetzt. Es sind bis zu 16 Stufen der Verschachtelung moeglich. 46 Die Variabilitaet bei der bedingten Uebersetzung innerhalb von Makros ergibt sich vor allem aus den aktuellen Parametern. Eine vorteilhafte Benutzung der bedingten Uebersetzung ausserhalb von Makros, also im eigentlichen Programm, ergibt sich z.B. dann, wenn ein Quellprogramm in mindestens zwei Teile zerlegt wird und im ersten (austauschbaren) Teil Stellgroessen bereitgestellt werden, von deren Wert die Uebersetzung in den anderen Teilen ab- haengt. 4.7.2. Unterbloecke zur bedingten Uebersetzung ---------------------------------------------- Innerhalb eines Blocks zur bedingten Uebersetzung koennen mit den Pseudobefehlen .IFF, .IFT und .IFTF Unterbloecke eroeffnet werden, deren Uebersetzung vom Resultat des Bedingungstests beim Beginn des Blocks abhaengt. Formaler Aufbau: .IFF .IFT .IFTF Ein Unterblock zur bedingten Uebersetzung reicht bis zum Beginn des naechsten Unterblocks bzw. bis zum Ende des uebergeordneten Blocks zur bedingten Uebersetzung. Die Funktion dieser Pseudobefehle ist folgende: .IFF ("if false") Der Unterblock wird uebersetzt, wenn die Be- dingung beim uebergeordneten Block nicht erfuellt ist. .IFT ("if true") Der Unterblock wird uebersetzt, wenn die Be- dingung beim uebergeordneten Block erfuellt ist. .IFTF ("if true or false") Der Unterblock wird stets uebersetzt. Im Unterschied zu den verschachtelten Bloecken zur bedingten Uebersetzung werden die Unterbloecke auch dann beruecksichtigt, wenn die Bedingung beim uebergeordneten Block nicht erfuellt ist. 4.7.3. Die Anweisung .IIF ------------------------- Ein Block zur bedingten Uebersetzung, der nur eine Anweisung enthaelt, kann mit Hilfe des Pseudobefehls .IIF ("immediate if") verkuerzt in einer Zeile formuliert werden. Formaler Aufbau: [marke...] .IIF cond,arg,anweisung Dabei ist cond ein Bedingungsoperator und fuer arg stehen ein bzw. zwei Argumente in der gleichen Bedeutung wie beim Pseudo- befehl .IF (siehe Abschnitt 4.7.1). Fuer Anweisung steht eine beliebige Anweisung (ein Maschinenbefehl, ein Pseudobefehl oder eine Makroanweisung). Zulaessige Trennzeichen: Komma, (SP), (HT). Der Pseudobefehl .IIF bewirkt folgendes: Ist die angegebene Be- dingung erfuellt, so wird die nachfolgende Anweisung uebersetzt, andernfalls wird sie uebergangen. 47 Beispiel: .IIF DF SYM, JSR PC,SUBR Ist das Symbol SYM definiert, so wird die Anweisung JSR PC,SUBR eingefuegt und uebersetzt. 4.8. Steuerung der Uebersetzungsliste ------------------------------------- 4.8.1. Steuerung des Listenumfangs ---------------------------------- Mit den Anweisungen .LIST und .NLIST ("no list") kann der Umfang der auszugebenden Uebersetzungsliste eingestellt werden. Formaler Aufbau: .LIST [arg,...] .NLIST [arg,...] Fuer arg stehen die in Tabelle 10 aufgefuehrten Argumente. Zulaessige Trennzeichen: Komma, (SP), (HT). In der .LIST-Anwei- sung wird die einem Argument entsprechende Funktion ausgefuehrt, d.h. der entsprechende Teil der Uebersetzungsliste wird ausgege- ben, und in der .NLIST-Anweisung wird die entsprechende Ausgabe unterdrueckt. Zu jedem Argument gibt es eine Standardfestlegung fuer die entsprechende Ausgabe, die fuer das Programm gilt, so- lange das Argument noch nicht in einer .LIST- oder .NLIST-Anwei- sung aufgetreten ist. Tabelle 10: Argumente bei .LIST/.NLIST ----------------------------------------------------------------- | Argu-| Funktion | Stan-| | ment | | dard | |------|-------------------------------------------------|------| | SEQ | ("source line sequence number") | ja | | | Druck der Quellzeilennummer | | | | (Wird diese Ausgabe unterdrueckt, so bleibt das | | | | Feld fuer die Quellzeilennummer frei.) | | | LOC | ("location counter field") | ja | | | Druck des Speicherplatzzaehlers | | | | (Wird diese Ausgabe unterdrueckt, so wird das | | | | Feld fuer den Speicherplatzzaehler durch die | | | | folgenden, nach links aufrueckenden Felder | | | | ueberlagert.) | | | BIN | ("binary code") | ja | | | Druck des erzeugten Objektcodes (Binaercodes) | | | | (Wird diese Ausgabe unterdrueckt, so werden die | | | | Felder fuer den Objektcode durch die folgende, | | | | nach links aufrueckende Quellzeile ueberlagert.)| | |---------------------------------------------------------------| 48 Tabelle 10: (Fortsetzung) ----------------------------------------------------------------- | Argu-| Funktion | Stan-| | ment | | dard | |------|-------------------------------------------------|------| | BEX | ("binary extension") | ja | | | Druck der Binaerextension, d.h. bei Anweisungen,| | | | die im Objektcode mehrere Worte belegen, werden | | | | zusaetzliche Zeilen (ohne Quellzeilenzaehlung) | | | | eingefuegt. (BEX ist eine Teilfunktion von BIN) | | | SRC | ("source lines") | ja | | | Druck der Quellzeilen | | | COM | Druck des Kommentarfeldes | ja | | | (COM ist eine Teilfunktion von SRC.) | | | MD | Druck der Makrodefinitionen und | ja | | | Wiederholungsbloecke | | | MC | ("macro calls") | ja | | | Druck der Makroanweisungen und | | | | Wiederholungsbloecke | | | ME | Druck der Makroexpansionen | nein | | MEB | Druck des erzeugten Objektcodes (Binaercodes) | nein | | | (aber nicht des erzeugten Quellcodes) bei | | | | Makroexpansionen | | | | (MEB ist eine Teilfunktion von ME.) | | | CND | ("conditional coding") | ja | | | Druck der Bloecke zur bedingten Uebersetzung | | | | bei nicht erfuellter Bedingung | | | LD | ("listing directives") | nein | | | Druck der .LIST/.NLIST-Anweisungen ohne Argu- | | | | ment | | | TOC | ("table of contents") | ja | | | Druck des Inhaltsverzeichnisses | | | SYM | Druck der Symboltabelle | ja | | TTM | Teleprinterformat | nein | | | d.h. fuer den Objektcode ist eine Spalte ein- | | | | gerichtet. (Besteht der Objektcode zu einer | | | | Anweisung aus mehreren Worten, so treten die | | | | folgenden als Binaerextension auf.) | | | | Im Standardfall (entspricht .NLIST TTM) gilt | | | | das Zeilendruckerformat, d.h. fuer den Objekt- | | | | code sind drei Spalten eingerichtet. | | ----------------------------------------------------------------- Die Funktionen zur Listensteuerung koennen auch durch Schalter im Kommando erzielt werden. In Abhaengigkeit von der Generierung des Makroassemblers koennen auch andere Standards gelten. Bei der Uebersetzung eines Programms wird ein Listenzaehler ge- fuehrt. Dieser wird am Anfang auf Null gesetzt; durch jede .LIST- Anweisung ohne Argument wird er um 1 erhoeht, und durch jede .NLIST-Anweisung ohne Argument um 1 vermindert. Bei positivem Listenzaehlerstand werden die entstehenden Listenzeilen gedruckt, bei negativem Listenzaehlerstand werden sie unterdrueckt, und wenn der Listenzaehlerstand gleich Null ist, haengt der Druck von den gueltigen Argumenten zur Listensteuerung ab. Die Einstellung des Listenzaehlers dient vor allem dazu, dass Makroexpansionen auszugsweise gedruckt werden koennen und der Stand der Listen- steuerung vor dem jeweiligen Makroaufruf wiederherstellbar ist. 49 4.8.2. Seitenvorschub --------------------- Durch die Anweisung .PAGE wird bei der Ausgabe der Uebersetzungs- liste ein Seitenvorschub erzielt; gleichzeitig wird eine neue Seitenhauptnummer eingestellt. Sonst erfolgt ein Seitenvorschub in folgenden Faellen: - nach jeweils 60 Listenzeilen, - bei Vorkommen des Zeichens (FF) = form feed, - bei Beginn einer neuen Quelldatei. 50 5. Makrotechnik --------------- 5.1. Allgemeines ---------------- Ein Makrobefehl (kurz "Makro") ist eine Zusammenfassung mehrerer Anweisungen (Maschinenbefehle oder Pseudobefehle) unter einem ge- meinsamen Namen. Die in der Sprache MACRO 1600 enthaltene Makro- technik ist die Gesamtheit aller Regeln zur Definition und Benut- zung von Makros. Die Verwendung von Makros erleichtert die Handhabung haeufig vor- kommender Befehlsfolgen. Die Moeglichkeiten der Makrotechnik ge- statten es, kleinere und oft in aehnlicher Form wiederkehrende programmiertechnische Realisierungen - z.B. von einfachen Formeln - vom Uebersetzer ausfuehren zu lassen. Durch die Benutzung von Makros laesst sich die formale Programmierarbeit reduzieren, und die Uebersichtlichkeit der Programme erhoeht sich. Der allgemeine "Bauplan" fuer alle Befehlsfolgen, die aehnlich aufgebaut sind bzw. sich aus der gleichen Grundform ableiten, ist die Makrodefinition. Sie muss fuer die Uebersetzung eines Pro- gramms, in dem sie benutzt wird, bereitgestellt werden. Eine Makrodefinition wird aktiviert durch eine Makroanweisung (auch Makroaufruf genannt), und die Korrespondenz wird durch den Makro- namen hergestellt. (Die Kurzbezeichnung "Makro" kann sowohl die Makrodefinition als auch die Makroanweisung betreffen.) Bei der Uebersetzung einer Makroanweisung werden die in der zu- gehoerigen Makrodefinition enthaltenen Anweisungen nacheinander verarbeitet, das Ergebnis sind sekundaere Quellzeilen (die "Mak- roexpansion"), die an Stelle der Makroanweisung in das Programm eingefuegt und dann ebenso uebersetzt werden wie die anderen, primaeren Quellzeilen. 5.2. Bereitstellung der Makros ------------------------------ Fuer alle Makros, die in einem Programm aufgerufen werden, mues- sen dem Makroassembler die entsprechenden Makrodefinitionen zur Verfuegung stehen. Dafuer gibt es zwei Moeglichkeiten, und dem- entsprechend sind zwei Typen von Makros zu unterscheiden. 1) Interne Makros: sind Bestandteil des Quellprogramms. Innerhalb eines Programms (in der Regel am Anfang, spaetestens vor ihrer ersten Benutzung) koennen Makrodefinitionen stehen. Das trifft z.B. dann zu, wenn in der im Kommando angegebenen Folge von Eingabedateien zuerst Makrodateien (Quelldateien, die nur Makrodefinitionen enthalten) und anschliessend die eigentlichen Quellprogrammdateien aufge- fuehrt werden. 2) Externe Makros: sind Bestandteile einer Makrobibliothek, und zwar einer vom An- wender erstellten Nutzer-Makrobibliothek oder der Systemmakro- bibliothek. 51 Kommen gleichnamige Makros verschiedener Typen vor, so gelten folgende Vorrangregeln: Interne Makros haben Vorrang vor externen Makros Kommen mehrere gleichnamige interne Makros vor, so hat jede Mak- rodefinition bis zum Auftreten der naechsten Gueltigkeit. Die Namen aller in einem Programm aufgerufenen externen Makros (auch der Systemmakros) muessen in einer Anweisung .MCALL ("macrocall") aufgeuehrt sein. Formaler Aufbau: .MCALL name,... Fuer name steht ein Makroname. Zulaessige Trennzeichen: Komma, (SP), (HT). 5.3. Allgemeiner Aufbau von Makros ---------------------------------- 5.3.1. Makrodefinitionen ------------------------ Eine Makrodefinition wird mit der Makroanfangsanweisung .MACRO (Makrokopf) eroeffnet, es folgt der Makrokoerper, und die Makro- endeanweisung .ENDM schliesst die Makrodefinition ab. Formaler Aufbau: .MACRO name [,parameter,...] .ENDM [name] wobei name der Makroname (ein Symbol, siehe Abschnitt 3.1.3.) ist, und fuer parameter stehen die formalen Parameter, die auf verschiedenartige Weise aufgebaut sein koennen (siehe Abschnitt 5.4.). Zulaessige Trennzeichen: Komma, (SP), (HT). Der bei der Anweisung .ENDM anzugebende Name muss mit dem Makro- namen in der zugehoerigen .MACRO-Anweisung uebereinstimmen. (Er gestattet bei verschachtelten Makrodefinitionen eine zusaetzliche Kontrolle.) Der Makrokoerper enthaelt die "Modellanweisungen". Eine Modell- anweisung ist die formale Gestalt (das Modell) einer Anweisung, aus der bei der Verarbeitung des Makros durch Substitution ver- schiedener formaler Elemente (z.B. formale Parameter) die end- gueltige Anweisung entsteht. Modellanweisungen koennen sein: Maschinenbefehle, Pseudobefehle und Makroanweisungen. Es sind auch verschachtelte Makrodefinitionen zulaessig. Dabei ist zu beachten, dass eine innere Makrodefinition erst dann auf- gerufen werden kann, wenn die sie enthaltende aeussere Makrodefi- nition einmal aufgerufen wurde. 52 5.3.2. Makroanweisungen ----------------------- Ein Code im Operationsfeld des Programms, der mit einem Makro- namen der fuer die Uebersetzung bereitgestellten Makros ueberein- stimmt, wird als Makroanweisung (auch Makroaufruf genannt) be- handelt, und es wird die Verarbeitung und Uebersetzung dieses Makros veranlasst. Formaler Aufbau: [marke...] name [parameter,...] [;kommentar] Die Marke bei einer Makroanweisung verkoerpert die Adresse, die dem ersten der von den generierten Anweisungen belegten Speicher- plaetze entspricht. Im Operandenfeld einer Makroanweisung koennen ein oder mehrere aktuelle Parameter stehen, die mit den formalen Parametern der zugehoerigen Makrodefinitionen korrespondieren (siehe Abschnitt 5.4.). Zulaessige Trennzeichen: Komma, (SP), (HT). Wenn ein Makroname mit einem Nutzersymbol (z.B. einer Marke) uebereinstimmt, wird dieses Symbol im Operationsfeld als Makro- symbol, im Operandenfeld als Nutzersymbol behandelt. Beispiel: ABS: CLR R0 ;ABS WIRD ALS MARKE DEFINIERT : : BR ABS ;BEZUG ZUR MARKE ABS : : ABS #2 ;MAKROANWEISUNG (ABS ALS MAKRONAME) 5.4. Makroparameter ------------------- Bei der Uebersetzung einer Makroanweisung koennen von Fall zu Fall unterschiedliche Anweisungsfolgen generiert werden. Ein wesentliches Steuerelement fuer diese Variabilitaet sind die Makroparameter. Die formalen Parameter einer Makrodefinition werden bei jeder Aktivierung durch die aktuellen Parameter der Makroanweisung ersetzt. Die Zuordnung kann dabei ueber die Position innerhalb der Parameterkette oder ueber ein Kennwort er- folgen, und dementsprechend sind zwei Arten von Parametern zu unterscheiden: Stellungs- und Kennwortparameter. Innerhalb einer Makrodefinition wird jedes Symbol, das mit einem formalen Para- meter uebereinstimmt (auch innerhalb von Kommentar) als solcher behandelt. 5.4.1. Stellungsparameter ------------------------- Die formalen Parameter im Makrokopf sind Symbole. Die Zuordnung der aktuellen Parameter in der Makroanweisung zu den formalen Parametern geschieht ueber ihre Stellung in der Parameterkette. d.h. der n-te formale Parameter wird durch den n-ten aktuellen Parameter ersetzt. Einzelne aktuelle Parameter koennen weggelas- sen werden, dann muessen jedoch an ihrer Stelle die Trennzeichen gesetzt werden. Die Trennzeichen fuer am Ende der Parameterkette 53 weggelassene aktuelle Parameter koennen entfallen. Die maximale Anzahl von formalen Parametern ergibt sich aus der maximalen Quellzeilenlaenge und betraegt 50. 5.4.2. Kennwortparameter ------------------------ Ein aktueller Parameter kann als Kennwortparameter auftreten. Er hat dann die Form: symbol = string Dabei stellt string den eigentlichen aktuellen Parameter dar, und das Symbol fungiert als Kennwort. Der aktuelle Parameter ersetzt den formalen Parameter, der mit dem angegebenen Kennwort ueber- einstimmt, unabhaengig von der Position in der Parameterkette. Falls der dem Kennwort entsprechende formale Parameter fehlt, wird der gesamte Kennwortparameter wie ein Stellungsparameter be- handelt. Es sind auch gemischte Parameterketten moeglich. Dabei beeinflus- sen die Kennwortparameter nicht die Position der uebrigen (Stellung-)Parameter. 5.4.3. Standardwerte -------------------- Einem formalen Parameter im Makrokopf kann ein Standardwert zu- geordnet sein, er hat dann die Form: symbol = string Dabei stellt string den Standardwert dar. Wenn der zu einem for- malen Parameter gehoerige aktuelle Parameter in der Makroanwei- sung fehlt, gilt der Standardwert. Fuer formale Parameter mit Standardwert koennen sowohl Stellungsparameter als auch Kennwort- parameter als aktuelle Parameter auftreten und den Standardwert ausser Kraft setzen. Beispiel: Die Makrodefinition mit folgendem Makrokopf sei gegeben: .MACRO NAME A=1,B,C,D=SYM Einige Makroanweisungen lauten: a) NAME 0,2,4 b) NAME ,2,,REL+2 c) NAME B=3,D=(0),C=6 d) NAME ,4,6,A=2,D=. e) NAME ,5,,C=7,ABS Dann werden den formalen Parametern A, B, C und D folgende Werte zugeordnet: a) b) c) d) e) A: 0 1 1 2 1 B: 2 2 3 4 5 C: 4 (leer) 6 6 7 D: SYM REL+2 (0) . ABS 54 5.4.4. Zeichenketten als Parameter ---------------------------------- Zeichenketten als aktuelle Parameter, welche Trennzeichen (Komma, (SP) oder (HT)) enthalten, muessen in spitze Klammern < > ein- geschlossen werden. Dann wird der innere Teil als Wert des Para- meters behandelt. Es kann auch die Form ^/string/ benutzt werden, insbesondere dann, wenn spitze Klammern bereits zum aktuellen Parameter gehoeren. Beispiel: Die Makrodefinition mit folgendem Makrokopf sei gegeben: .MACRO REN A,B,C,D,E,F Eine Makroanweisung lautet: REN ,X,Y,^//,F<1,2> Dann werden den formalen Parametern folgende Werte zugeordnet: A: MOV X,Y B: X C: Y D: E: F<1 F: 2> 5.4.5. Verkettung von Parametern -------------------------------- Innerhalb des Makrokoerpers hat ein Apostroph, dem unmittelbar ein formaler Parameter folgt oder vorausgeht, die Funktion eines Verkettungszeichens. Mehrere durch ' voneinander getrennte for- male Parameter werden durch eine Zeichenfolge ersetzt, die durch Aneinanderreihung der entsprechenden aktuellen Parameter entsteht. Beispiel: .MACRO DEF A,B,C A'B: .BYTE ''C Die Makroanweisung DEF X,1,H fuehrt zu der Makroexpansion: X1: .BYTE 'H 5.4.6. Numerische Parameter --------------------------- Symbole, die als aktuelle Parameter vorkommen, werden normaler- weise unveraendert uebernommen. Ist dem aktuellen Parameter je- doch das Zeichen \ vorangestellt, so wird der numerische Wert des Symbols uebernommen, und in der Makroexpansion erscheinen die KOI-7-Zeichen, die diesen Wert darstellen. Es wird stets der absolute Wert erzeugt. 55 Beispiel: .MACRO CON A,B .ASCII /'A/ .ASCII /'B/ Die Makroanweisung X=10 CON X,\X fuehrt zu der Makroexpansion: .ASCII /X/ .ASCII /10/ 5.4.7. Makroeigene lokale Symbole --------------------------------- Symbole, die im Makrokoerper definiert und benutzt werden, koen- nen als Parameter eingefuehrt werden. Sie muessen dann in jeder Makroanweisung in geeigneter Weise spezifiziert werden, um Mehr- fachdefinitionen zu vermeiden. Eine spezielle Moeglichkeit ist ausserdem in der automatischen Erzeugung makroeigener lokaler Symbole gegeben. Das sind Symbole der Form n"$" wobei n eine Dezimalzahl zwischen 64 und 127 ist. Fuer jeden for- malen Parameter, dem ein Fragezeichen ? vorangestellt ist, wird ein makroeigenes lokales Symbol erzeugt, sofern in der Makroan- weisung kein entsprechender aktueller Parameter angegeben ist. Die makroeigenen lokalen Symbole sind nicht an die fuer sonstige lokale Symbole (siehe Abschnitt 3.1.4.) gueltigen lokalen Symbolbloecke gebunden. Beispiel: .MACRO ALPHA A,?B TST A BEQ B : : B: CLR (R0) .ENDM Die Makroanweisungen ALPHA R1,L3400 ALPHA R1 Fuehren zu den Makroexpansionen: TST R1 BEQ L3400 : : L3400: CLR (R0) bzw. TST R1 BEQ 64"$" : : 64"$": CLR (R0) 56 5.5. Attributanweisungen ------------------------ Attributanweisungen sind Pseudobefehle, die es gestatten, ver- schiedene Eigenschaften von Makroparametern zu bestimmen. Durch eine Attributanweisung wird ein Symbol definiert und mit einem Wert versehen, in ihrer Wirkung entspricht sie daher einer Direktanweisung. 5.5.1. Parameteranzahl-Attribut ------------------------------- Durch den Pseudobefehl .NARG ("number of arguments") - welcher nur in Makrodefinitionen zulaessig ist - wird die Anzahl der in einer Makroanweisung angegebenen Parameter bestimmt. Formaler Aufbau: [marke...] .NARG symbol Das angegebene Symbol erhaelt als Wert die Anzahl der in der laufenden Makroanweisung angegebenen aktuellen Parameter zugewie- sen. 5.5.2. Zeichenanzahl-Attribut ----------------------------- Durch den Pseudobefehl .NCHR ("number of characters") wird die Zeichenanzahl einer spezifischen Zeichenkette bestimmt. Formaler Aufbau: [marke...] .NCHR symbol, string Das angegebene Symbol erhaelt als Wert die Zeichenanzahl der nachfolgend spezifizierten Zeichenkette zugewiesen. Fuer string steht die Zeichenkette. Wenn diese Trennzeichen (Komma, (SP) oder (HT)) enthaelt, muss sie in spitze Klammern eingeschlossen bzw. von ^ angefuehrt sein: bzw. ^/string/. Der Pseudobefehl .NCHR ist besonders zur Bestimmung der Laenge von Makroparametern geeignet, er ist aber auch ausserhalb von Makrodefinitionen zulaessig. 5.5.3. Adressierungsart-Attribut -------------------------------- Durch den Pseudobefehl .NTYPE - welcher nur in Makrodefinitio- nen zulaessig ist - wird die Adressierungsart eines in einer Makroanweisung angegebenen aktuellen Parameters bestimmt. Formaler Aufbau: [marke...] .NTYPE symbol,ausdruck Das angegebene Symbol erhaelt als Wert den Adressierungsmodus des nachfolgend spezifizierten Ausdrucks (dargestellt als 6-Bit-Wert 00 bis 77) zugewiesen. 57 5.6. Makroschachtelung ---------------------- Im Makrokoerper kann eine Makroanweisung vorkommen, wodurch eine Makroschachtelung entsteht. Damit die Parameteruebergabe vom aeusseren zum inneren Makro stets eindeutig moeglich ist, em- pfiehlt es sich, die aktuellen Parameter in allen inneren Makro- anweisungen in spitze Klammern einzuschliessen. Beispiel: .MACRO LEVEL1 DUM1,DUM2 LEVEL2 LEVEL2 .ENDM .MACRO LEVEL2 DUM3 DUM3 ADD #10,R0 MOV R0,(R1)+ .ENDM Die Makroanweisung LEVEL1 , fuehrt zu folgender Makroexpansion: MOV X,R0 ADD #10,R0 MOV R0,(R1)+ MOV R2,R0 ADD #10,R0 MOV R0,(R1)+ Es sind auch verschachtelte Makrodefinitionen moeglich (siehe Abschnitt 5.3.1.). 5.7. Makroabbruchanweisung -------------------------- Durch die Anweisung .MEXIT wird der Abbruch der Makroex- pandsion (vor Erreichen von .ENDM) veranlasst. Bei Makroschach- telung wird die Makroexpansion in der naechsthoeheren Stufe fort- gesetzt. 5.8. Fehler- und Protokolldruckanweisung ---------------------------------------- Die Fehleranweisung dient dazu, bei fehlerhaft gebildeten Makro- anweisungen (z.B. wenn ein aktueller Parameter einen Bereich zu- laessiger Werte ueberschreitet) in der Uebersetzungsliste ein Fehlerkennzeichen auszugeben. Sie kann auch ausserhalb von Makro- definitionen benutzt werden, insbesondere in Bedingungsbloecken zur Information ueber illegale Bedingungen im Programm. Formaler Aufbau: [marke...] .ERROR [ausdruck] ;text [marke...] .PRINT [ausdruck] ;text 58 Wird bei der Uebersetzung eines Programms eine Fehleranweisung erreicht, so wird diese in der Uebersetzungsliste dem allgemeinen Listenzeilenformat entsprechend ausgewiesen, wobei anstelle des Binaercodes der Wert des im Operandenfeld angegebenen Ausdrucks erscheint. Dieser Wert kann zur Kontrolle ueber den Ablauf Ueber- setzung dienen. Bei der Anweisung .ERROR wird ueberdies das Feh- lerkennzeichen P erzeugt. Die Protokolldruckanweisung .PRINT hat die gleiche Wirkung wie die Fehleranweisung, jedoch entfaellt hier die Ausgabe des Fehlerkennzeichens. Sie ist vor allem zur Kontrolle des Uebersetzungsablaufs in der Testphase der Programm- entwicklung geeignet. 5.9. Wiederholungsbloecke ------------------------- Ein Wiederholungsblock ist ein Abschnitt in einem MACRO 1600-Pro- gramm, der mehrmals hintereinander uebersetzt wird. Er kann als verkuerzte Schreibweise einer Makrodefinition und mehrerer darauf bezueglicher Makroanweisungen aufgefasst werden. Ein Wieder- holungsblock kann innerhalb oder ausserhalb einer Makrodefinition erscheinen. Es sind auch verschachtelte Wiederholungsbloecke moeglich. 5.9.1. Wiederholungsblock mit Parameterliste -------------------------------------------- Ein Wiederholungsblock mit Parameterliste wird durch die Anwei- sung .IRP ("indefinite repeat block") eroeffnet und erstreckt sich bis zur zugehoerigen Makroendeanweisung .ENDM. Formaler Aufbau: [marke...] .IRP symbol, Dabei stellt das Symbol den formalen Parameter dar, der im Wie- derholungsblock benutzt wird. Die in spitzen Klammern ein ge- schlossene Parameterliste enthaelt die aktuellen Parameter. Zu- laessige Trennzeichen: Komma, (SP), (HT). Der zwischen der Anweisung .IRP und der zugehoerigen .ENDM-Anwei- sung gelegene Programmabschnitt wird entsprechend der Anzahl der angegebenen aktuellen Parameter mehrmals hintereinander ueber- setzt und eingefuegt, wobei der formale Parameter in jedem Zyklus durch den jeweiligen aktuellen Parameter ersetzt wird. Beispiel: .IRP F, MOV F,(R0)+ .ENDM Dieser Wiederholungsblock fuehrt zu der Uebersetzung: MOV A,(R0)+ MOV A,(R0)+ MOV A,(R0)+ 59 5.9.2. Wiederholungsblock mit Zeichenliste ------------------------------------------ Ein Wiederholungsblock mit Zeichenliste wird durch die Anweisung .IRPC eroeffnet und erstreckt sich bis zur zugehoerigen Makro- endeanweisung .ENDM. Formaler Aufbau: [marke...] .IRPC symbol, Fuer string steht eine Zeichenkette, die in spitzen Klammern ein- geschlossen sein muss, falls sie Trennzeichen (Komma, (SP) oder (HT)) enthaelt. Die Wirkung von .IRPC entspricht der von .IRP, jedoch wird hier der formale Parameter in jedem Zyklus durch ein Zeichen aus der angegebenen Zeichenkette ersetzt. Beispiel: .IRPC F,<123> MOVB #X'F,-(R1) .ENDM Dieser Wiederholungsblock fuehrt zu der Uebersetzung: MOVB #X1,-(R1) MOVB #X2,-(R1) MOVB #X3,-(R1) 5.9.3. Wiederholungsblock ohne Parameter ---------------------------------------- Ein Wiederholungsblock ohne Parameter wird durch die Anweisung .REPT ("repeat") eroeffnet und erstreckt sich bis zur zugehoe- rigen Makroendeanweisung .ENDM. Formaler Aufbau: [marke...] .REPT ausdruck Im Operandenfeld muss ein absoluter Ausdruck stehen. Sein Wert gibt die Anzahl der Zyklen an, in denen der Wiederholungsblock nacheinander uebersetzt und eingefuegt wird. (Ist dieser Wert kleiner oder gleich Null, so wird der Wiederholungsblock ueber- gangen.) Es sind auch verschachtelte Wiederholungsbloecke ohne Parameter moeglich. 60 Anlage 1: KOI-7-Code (St RGW 356-76) ---------------------------------------- ----------------------------------------------------------------- | Wert Zeichen | Wert Zeichen | Wert Zeichen | Wert Zeichen | ----------------------------------------------------------------- | 0 (NUL) | 40 (SP) | 100 @ | 140 ` | | 1 (SOH) | 41 ! | 101 A | 141 a | | 2 (STX) | 42 " | 102 B | 142 b | | 3 (ETX) | 43 # | 103 C | 143 c | | 4 (EOT) | 44 $ | 104 D | 144 d | | 5 (ENQ) | 45 % | 105 E | 145 e | | 6 (ACK) | 46 & | 106 F | 146 f | | 7 (BEL) | 47 ' | 107 G | 147 g | | 10 (BS) | 50 ( | 110 H | 150 h | | 11 (HT) | 51 ) | 111 I | 151 i | | 12 (LF) | 52 * | 112 J | 152 j | | 13 (VT) | 53 + | 113 K | 153 k | | 14 (FF) | 54 , | 114 L | 154 l | | 15 (CR) | 55 - | 115 M | 155 m | | 16 (SO) | 56 . | 116 N | 156 n | | 17 (SI) | 57 / | 117 O | 157 o | | 20 (DLE) | 60 0 | 120 P | 160 p | | 21 (DC1) | 61 1 | 121 Q | 161 q | | 22 (DC2) | 62 2 | 122 R | 162 r | | 23 (DC3) | 63 3 | 123 S | 163 s | | 24 (DC4) | 64 4 | 124 T | 164 t | | 25 (NAK) | 65 5 | 125 U | 165 u | | 26 (SYN) | 66 6 | 126 V | 166 v | | 27 (ETB) | 67 7 | 127 W | 167 w | | 30 (CAN) | 70 8 | 130 X | 170 x | | 31 (EM) | 71 9 | 131 Y | 171 y | | 32 (SUB) | 72 : | 132 Z | 172 z | | 33 (ESC) | 73 ; | 133 [ | 173 { | | 34 (FS) | 74 < | 134 \ | 174 | | | 35 (GS) | 75 = | 135 ] | 175 } | | 36 (RS)=(NL) | 76 > | 136 ^ | 176 ~ | | 37 (US) | 77 ? | 137 _ | 177 (DEL) | ----------------------------------------------------------------- Bedeutung der Steuerzeichen: (ACK) Positive Rueckmeldung (FS) file separator (acknowledge) (GS) group separator (BEL) Glocke (bell) (HT) (Horizontal-)Tabulator (BS) Rueckwaertsschritt (LF) Zeilenvorschub (backspace) (line feed) (CAN) Ungueltig (cancel) (NAK) Negative Rueckmeldung (CR) Wagenruecklauf (no acknowledge) (carriage return) (NL) Neue Zeile (new line) (DCx) device control (NUL) Null (DEL) Loeschen (delete) (RS) Record separator (DLE) data link escape (SI) shift in (EM) end of medium (SO) shift out (ENQ) Stationsaufforderung (SOH) start of heading (enquiry) (SP) Leerzeichen (space) (EOT) end of transmission (STX) start of text (ESC) Umschaltung (escape) (SUB) Substitution (ETB) end of transmission block (SYN) Synchronisation (ETX) end of text (US) unit separator (FF) Seitenvorschub (form feed) (VT) Vertikaltabulator 61 Anlage 2: Befehlsliste K 1600 ------------------------------- ----------------------------------------------------------------- | Mnemo- Code Operation Beding.-Codes | | nik (oktal) N Z V C | |---------------------------------------------------------------| | Zweioperandenbefehle | | | | MOV 01ssdd (s)=>(d) move (Transport) + + 0 - | | CMP 02ssdd (s)-(d) compare (Vergleich) + + + + | | BIT 03ssdd (s)"und"(d) bit test + + 0 - | | BIC 04ssdd "neg"(s)"und"(d)=>(d) bit clear + + 0 - | | BIS 05ssdd (s)"oder"(d)=>(d) bit set + + 0 - | | ADD 06ssdd (s)+(d)=>(d) add (Addition) + + + + | | SUB 16ssdd (d)-(s)=>(d) subtract (Subtraktion) + + + + | | MOVB 11ssdd | | | CMPB 12ssdd | Byte-Befehle | | BITB 13ssdd > (Operationen wie bei den | | BICB 14ssdd | entsprechenden Wort-Befehlen) | | BISB 15ssdd | | | | | Einoperandenbefehle | | | | CLR 0050dd 0=>(d) clear (Loeschen) 0 1 0 0 | | COM 0051dd "neg"(d)=>(d) complement (Einerkompl.)+ + 0 1 | | INC 0052dd (d)+1=>(d) increment + + + - | | DEC 0053dd (d)-1=>(d) decrement + + + - | | NEG 0054dd -(d)=>(d) negate (Zweierkomplem.) + + + + | | ADC 0055dd (d)+(C)=>(d) add carry + + + + | | SBC 0056dd (d)-(C)=>(d) subtract carry + + + + | | TST 0057dd (d)=>(d) test + + 0 0 | | ROR 0060dd rotate right + + + + | | ROL 0061dd rotate left + + + + | | ASR 0062dd (d):2=>(d) arithmetic shift right + + + + | | ASL 0063dd (d)*2=>(d) arithmetic shift left + + + + | | CLRB 1050dd | | | COMB 1051dd | | | INCB 1052dd | | | DECB 1053dd | | | NEGB 1054dd | Byte-Befehle | | ADCB 1055dd > (Operationen wie bei den | | SBCB 1056dd | entsprechenden Wort-Befehlen) | | TSTB 1057dd | | | RORB 1060dd | | | ROLB 1061dd | | | ASRB 1062dd | | | ASLB 1063dd | | | JMP 0001dd (d)=>(PC) jump (Sprungbefehl) - - - - | | SWAB 0003dd swap bytes + + 0 0 | | SXT 0067dd Falls (N)=1: sign extend (Vorzeichen - + 0 - | | -1=>(d), sonst: 0=>(d) erweiterung) | |+MTPS 1064dd (d)=>(PSW) move to PSW (aus PSW)| |+MFPS 1067dd (PSW)=>(d) move from PSW - - - - | |*MTPI oo66dd move to prev.inst.space + + 0 - | |*MFPI 0065dd move from " " " + + 0 - | |---------------------------------------------------------------| 62 ----------------------------------------------------------------- | Mnemo- Code Operation Beding.-Codes | | nik (oktal) N Z V C | |---------------------------------------------------------------| | Register-Adress-Befehle | | | | MUL 070rss (s)*(r)=>(r,r+1) multiply (Multiplikat.)+ + 0 + | | DIV 071rss (r,r+1):(s)=>(r) divide (Division) + + + + | | Rest=>(r+1) | | ASH 072rss arithmetic shift + + + + | | ASHC 073rss arith. shift combined + + + + | | XOR 074rdd (r)"exo"(d)=>(d) exclusive or + + 0 - | | SOB 077rxx (r)-1=>(r) subtract one and branch- - - - | | Falls danach (r) ungleich 0: | | (PC)-2*xx=>(PC) | | | | Verzweigungsbefehle | | | | BR 0004xx Verzweigung branch (unconditional) - - - - | | BNE 0010xx " wenn (Z)=0 br. if not equal - - - - | | BEQ 0014xx " wenn (Z)=1 br. if equal - - - - | | BPL 1000xx " wenn (N)=0 br. if plus - - - - | | BMI 1004xx " wenn (N)=1 br. if minus - - - - | | BVC 1020xx " wenn (V)=0 br. if overflow clear - - - - | | BVS 1024xx " wenn (V)=1 br. if overflow set - - - - | | BCC 1030xx " wenn (C)=0 br. if carry clear - - - - | | BCS 1034xx " wenn (C)=1 br. if carry set - - - - | | BGE 0020xx " wenn (N)"exo"(V)=0 - - - - | | BLT 0024xx " wenn (N)"exo"(V)=1 - - - - | | BGT 0030xx " wenn ((N)"exo"(V))"oder"(Z)=0 - - - - | | BLE 0034xx " wenn ((N)"exo"(V))"oder"(Z)=1 - - - - | | BHI 1010xx " wenn (C)"oder"(Z)=0 - - - - | | BLOS 1014xx " wenn (C)"oder"(Z)=1 - - - - | | BHIS entspricht BCC br. if higher or same - - - - | | BLO entspricht BCS br. if lower - - - - | | | | Bedingungscode-Operationen | | | | NOP 000240 Keine Operation no operation - - - - | | CLC 000241 0=>(C) clear C - - - 0 | | CLV 000242 0=>(V) clear V - - 0 - | |!CVC 000243 0=>(C),(V) clear V and C - - 0 0 | | CLZ 000244 0=>(Z) clear Z - 0 - - | | CLN 000250 0=>(N) clear N 0 - - - | |!CNZ 000254 0=>(Z),(N) clear N and Z 0 0 - - | | CCC 000257 0=>(C),(V),(Z),(N) cl. cond.codes 0 0 0 0 | | SEC 000261 1=>(C) set C - - - 1 | | SEV 000262 1=>(V) set V - - 1 - | | SEZ 000264 1=>(Z) set Z - 1 - - | | SEN 000270 1=>(N) set N 1 - - - | | SCC 000277 1=>(C),(V),(Z),(N) set cond.codes 1 1 1 1 | | | | Dezimalbefehle | | | | BMOV 076200 (s)=>(d) block move 0 1 0 0 | |*DADD 076770 (s)+(d)=>(d) decimal add + + + 0 | |*DSUB 076760 (s)-(d)=>(d) decimal subtract + + + 0 | |*DSR 076700 decimal shift right + + 0 0 | |*DSL 076710 decimal shift left + + + 0 | |---------------------------------------------------------------| 63 ----------------------------------------------------------------- | Mnemo- Code Operation Beding.-Codes | | nik (oktal) N Z V C | |---------------------------------------------------------------| | Sonstige Befehle | | | | JSR 004rdd (d)=>(t), (r)=>St, jump to subrout.- - - - | | (PC)=>(r), (t)=>(PC) (Unterprogrammsprung) | | RTS 00020r (r)=>(PC), St=>(r) return from - - - - | | subroutine | | EMT 104... (PC)=>St, (PSW)=>St, emulator trap (vom Trap-| | (30)=>(PC), (32)=>(PSW) vektor)| | TRAP 104... (PC)=>St, (PSW)=>St, trap (vom Trap-| | (34)=>(PC), (36)=>(PSW) vektor)| | BPT 000003 (PC)=>St, (PSW)=>St, breakpoint (vom Trap-| | (14)=>(PC), (16)=>(PSW) trap vektor)| | IOT 000004 (PC)=>St, (PSW)=>St, input/output (vom Trap-| | (20)=>(PC), (22)=>(PSW) trap vektor)| | RTI 000002 St=>(PC), St=>(PSW) return from (vom Stack)| | interrupt | | RTT 000006 St=>(PC), St=>(PSW) return from (vom Stack)| | interrupt | | HALT 000000 halt - - - - | | WAIT 000001 wait for interrupt - - - - | | RESET 000005 reset external bus - - - - | | MARK 0064nn (SP)+2*n=>(SP), mark (markieren) - - - - | | (R5)=>(PC), St=>(R5) | | SPL 00023n n=>(PSW)5-7 set priority level - - - - | ----------------------------------------------------------------- * Nur bei K 1630 vorhanden + Nur bei K 1620 vorhanden ! Nur bei MOOS 1600 und OMOS 1630 vorhanden Erlaeuterungen zu den Operationen: (s) Quelloperand (source) (d) Zieloperand (destination) (r) Register als Operand (t) Temporaeres Hilfsregister (PC) Befehlszaehler (program counter) (PSW) Prozessor-Status-Wort "und" Konjunktion (Logisches "und") "oder" Disjunktion (Logisches "oder") "exo" Antivalenz ("Exklusives oder") "neg" Negation =>St nach Stack (wird "gekellert") St=> vom Stack (wird "ausgekellert") Erlaeuterungen zu den Bedingungscodes: 0 wird geloescht 1 wird gesetzt + wird gesetzt bei erfuellter Bedingung - bleibt unveraendert Die Bedingungen sind: N wird gesetzt, wenn Resultat < 0 ("negativ") Z " wenn Resultat = 0 ("zero") V " wenn arith. Ueberlauf entsteht ("overflow") C " wenn Uebertrag beim hoechstwertigen Bit entsteht ("carry") 64 Erlaeuterungen zu einzelnen Befehlen: ROR ----- --------------------------- ---> | C | --> | O p e r a n d | --- | ----- --------------------------- | | 15 ... 0 | ------------------------------------------------- ROL ----- --------------------------- ---- | C | <-- | O p e r a n d | <-- | ----- --------------------------- | | 15 ... 0 | ------------------------------------------------- ASR ------- | | | --------------------------- ----- --> | | O p e r a n d | --> | C | --------------------------- ----- 15 14 ... 0 ASL ----- --------------------------- | C | <-- | O p e r a n d | <-- 0 ----- --------------------------- ASH Der Inhalt des Registers r wird arithmetisch verschoben um ss Stellen nach links oder rechts. Die Anzahl der Ver- schiebungen liegt zwischen -32 und +31. (Negatives Vor- zeichen bedeutet Rechtsverschiebung.) ASHC Das aus dem Inhalt der Register r und r"oder"1 gebildete 2-Bit-Wort wird arithmetisch verschoben um ss Stellen nach links oder rechts. Die Anzahl der Verschiebungen liegt zwischen -32 und +31. (Negatives Vorzeichen bedeu- tet Rechtsverschiebung.) Dezimalbefehle Es werden tetradische Dezimalzahlen verarbeitet, die in aufeinanderfolgenden Bytes gespeichert sind. Parameter: a(R0) = Anzahl der Tetraden (ausser dem Vorzeichen) (R1) = Adresse des Quelloperanden s (Byte mit der hoechstwertigen Tetrade) (R3) = Adresse des Zieloperanden d (Byte mit der hoechstwertigen Tetrade) Anmerkungen: 1) MOVB mit Modus 0 bei Zieloperand: Es wird das niederwertige Byte belegt, und im hoeherwertigen Byte erfolgt Vorzeichenerweiterung. 2) JMP und JSR mit Modus 0 sind verboten. 3) Der Operand bei SWAB muss eine Wortadresse sein. 4) MUL: Falls r ungerade ist, wird nur der niederwertige Teil des Resultats nach (r) gespeichert. 5) DIV: Falls r ungerade ist, bleiben die Operanden unveraendert. 65 Anmerkungen zu den Bedingungscodes: CMP 1=>(V) wenn (s)15 ungl. (d)15 und (d)15 = (Res.)15 (arith. Ueberlauf) 0=>(C) wenn Uebertrag aus hoechstwertigem Bit ADD 1=>(V) wenn (s)15 = (d)15 und (d)15 ungl. (Res.)15 (Arith. Ueberlauf) 1=>(C) wenn Uebertrag aus hoechstwertigem Bit SUB 1=>(V) wenn (s)15 ungl. (d)15 und (s)15 = (Res.)15 (Arith. Ueberlauf) 0=>(C) wenn Uebertrag aus hoechstwertigem Bit INC 1=>(V) wenn (d) = 077777 war DEC 1=>(V) wenn (d) = 100000 war NEG 1=>(V) wenn (d) = 100000 war (Ergebnis ist 100000) 0=>(C) wenn (d) = 0 war (Ergebnis ist 0) ADC 1=>(V) wenn (d) = 077777 und (C) = 1 waren 1=>(C) wenn (d) = 177777 und (C) = 1 waren SBC 1=>(V) wenn (d) = 100000 und (C) = 1 waren 0=>(C) wenn (d) = 0 ROR/ROL/ASR/ASL (C)"exo"(N) (nach der Verschiebung) => (V) SWAB 1=>(N) wenn (d)15 = 1 war 1=>(Z) wenn (d)8-15 = 0 war SXT 1=>(Z) wenn (N) = 0 DIV 1=>(V) wenn (s) = 0 oder wenn das Ergebnis nicht in (r,r+1) aufgenommen werden kann sowie bei Angabe einer ungeraden Registernummer r 1=>(C) wenn (s) = 0 66 Ergaenzung zur Befehlsliste: ARP-Befehle ----------- ----------------------------------------------------------------- | Mnemo- Code Operation ARP-Bed.-Codes | | nik (oktal) FN.Z.V.C | |---------------------------------------------------------------| | Zweioperandenbefehle | | | | LDF 172(4+a)fs (fs)=>(a) load floating + + 0 0 | | LDD 172(4+a)fs (fs)=>(a) load float. double + + 0 0 | | LDCDF 177(4+a)fs cDF(fs)=>(a) load and convert + + + 0 | | LDCFD 177(4+a)fs cFD(fs)=>(a) " " " + + 0 0 | | LDCIF 177ass cIF(s)=>(a) " " " + + 0 0 | | LDCID 177ass cID(s)=>(a) " " " + + 0 0 | | LDCLF 177ass cLF(s)=>(a) " " " + + 0 0 | | LDCLD 177ass cLD(s)=>(a) " " " + + 0 0 | | LDEXP 176(4+a)ss exp(s)=>(a) load exponent + + + 0 | | STF 174afd (a)=>(fd) store floating - - - - | | STD 174afd (a)=>(fd) store float. double - - - - | | STCDF 176afd cDF(a)=>(fd) store and convert + + + 0 | | STCFD 176afd cFD(a)=>(fd) " " " + + 0 0 | | STCFI 175(4+a)dd cFI(a)=>(d) " " " + + 0 + | | STCFL 175(4+a)dd cFL(a)=>(d) " " " + + 0 + | | STCDI 175(4+a)dd cDI(a)=>(d) " " " + + 0 + | | STCDL 175(4+a)dd cDL(a)=>(d) " " " + + 0 + | | STEXP 175add exp(a)=>(d) store exponent + + 0 0 | | ADDF 172afs (fs)+(a)=>(a) add floating + + + 0 | | ADDD 172afs (fs)+(a)=>(a) add fl. double + + + 0 | | SUBF 173afs (a)-(fs)=>(a) subtract floating + + + 0 | | SUBD 173afs (a)-(fs)=>(a) subtract fl. double + + + 0 | | MULF 171afs (fs)*(a)=>(a) multiply floating + + + + | | MULD 171afs (fs)*(a)=>(a) multiply fl. double + + + + | | DIVF 174(4+a)fs (a):(fs)=>(a) divide floating + + + 0 | | DIVD 174(4+a)fs (a):(fs)=>(a) divide fl. double + + + 0 | | MODF 171(4+a)fs multiply and integrize fl. + + + 0 | | MODD 171(4+a)fs multiply and integrize fl.d.+ + + 0 | | CMPF 173(4+a)fs (fs)-(a) compare floating + + 0 0 | | CMPD 173(4+a)fs (fs)-(a) compare fl. double + + 0 0 | | | | Einoperandenbefehle | | | | CLRF 1704fd 0=>(fd) clear floating 0 1 0 0 | | CLRD 1704fd 0=>(fd) clear fl. double 0 1 0 0 | | TSTF 1705fd (fd)=>(fd) test floating + + 0 0 | | TSTD 1705fd (fd)=>(fd) test fl. double + + 0 0 | | ABSF 1706fd abs(fd)=>(fd) make absolute float.0 + 0 0 | | ABSD 1706fd abs(fd)=>(fd) make abs. fl.double 0 + 0 0 | | NEGF 1707fd -(fd)=>(fd) negate floating + + 0 0 | | NEGD 1707fd -(fd)=>(fd) negate fl. double + + 0 0 | | LDFPS 1701ss (s)=>(ARP) load ARP prog.status- - - - | | STFPS 1702dd (ARP)=>(d) store " " " - - - - | | STST 1703dd (FEC)=>(d), store ARP status - - - - | | (FEA)=>(d+2) | |---------------------------------------------------------------| 67 ----------------------------------------------------------------- | Mnemo- Code Operation ARP-Bed.-Codes | | nik (oktal) FN.Z.V.C | |---------------------------------------------------------------| | Adresslose Befehle | | | | CFCC 170000 (Fx)=>(x) fuer copy fl. cond. codes- - - - | | x = N, Z, V, C | | SETF 170001 0=>(FD) set floating mode - - - - | | SETD 170011 1=>(FD) set fl. double mode - - - - | | SETI 170002 0=>(FL) set integer mode - - - - | | SETL 170012 1=>(FL) set long int. mode - - - - | ----------------------------------------------------------------- Erlaeuterungen zu den Operationen: (a) ARP-Register (fs) Quelloperand (mit ARP-Register bei Modus 0) (fd) Zieloperand " " " " " (s) Quelloperand (mit ZVE-Register bei Modus 0) (d) Zieloperand " " " " " (ARP) ARP-Programmstatusregister (FEC) ARP-Fehlerregister (FEA) ARP-Befehlsadressregister (FD) FD-Bit im ARP-Programmstatusregister (FL) FL-Bit im ARP-Programmstatusregister cXY Konvertierung von Format X nach Format Y exp Exponent abs Absoluter Betrag 68 Anlage 3: Verzeichnis der Pseudobefehle ----------------------------------------- Mnemonik Operanden Bedeutung ----------------------------------------------------------------- .ASCII /string/ Definition einer Zeichenkette .ASCIZ /string/ Definition einer Zeichenkette mit abschliessender Null .BLKB ausdruck Speicherplatzvereinbarung (Bytes) .BLKW ausdruck Speicherplatzvereinbarung (Worte) .BYTE ausdruck,... Definition von Byte-Daten .DSABL arg,... Uebersetzungssteuerung (schaltet die angegebene Funktion aus) .ENABL arg,... Uebersetzungssteuerung (schaltet die angegebene Funktion ein) .END [ausdruck] Programmende (evtl. mit Startadresse) .ENDC Ende eines Blockes zur bedingten Uebersetzung .ENDM Ende einer Makrodefinition oder Ende eines Wiederholungsblocks .ERROR ausdruck;text Fehleranweisung .EVEN Speicherplatzzaehler geradzahlig .FLT2 zahl,... Definition von Gleitkommazahlen mit einer Laenge von 2 Worten .FLT4 zahl,... Definition von Gleitkommazahlen mit einer Laenge von 4 Worten .GLOBL symbol,... Spezifizierung globaler Symbole .IDENT /string/ Programmversions-Identifikation .IF cond,arg Beginn eines Blockes zur bedingten Uebersetzung .IFF Beginn eines Unterblockes zur bedingten Uebersetzung .IFT dito .IFTF dito .IIF cond,arg,anweisung Anweisung mit bedingter Uebersetzung .IRP symbol, Wiederholungsblock mit Parameter- liste .IRPC symbol,string Wiederholungsblock mit Zeichen- liste .LIMIT Bereitstellung der Stack- und Programmgrenzen .LIST [arg] Listensteuerung .LONG zahl,... Definition von Integer-Zahlen mit einer Laenge von 2 Worten .MACRO name,[parameter,...] Makrodefinition .MCALL name,... Spezifizierung von externen Makros .MEXIT Makroabbruchanweisung .NARG symbol Parameteranzahl-Attribut .NLIST [arg] Listensteuerung .NTYPE symbol,ausdruck Adressierungsart-Attribut .ODD Speicherplatzzaehler ungeradzahlig .PACKED zahl,... Definition von tetradischen Dezimalzahlen .PAGE Seitenvorschub bei Listenausgabe .PRINT ausdruck;text Mitteilungsanweisung .PSECT name [,arg,...] Programmsektion 69 Mnemonik Operanden Bedeutung ----------------------------------------------------------------- .QUAD zahl,... Definition von Integer-Zahlen mit einer Laenge von 4 Worten .RADIX n Zahlenbasis einstellen (n=2,8,10) .RAD50 /string/ Definition einer Zeichenkette im Radix-50-Format .REPT ausdruck Wiederholungsblock ohne Parameter .SBTTL string Untertitel .TITLE string Programmtitel .TRI zahl,... Definition von Integerzahlen mit einer Laenge von 3 Worten .WORD ausdruck,... Definition von Wort-Daten ----------------------------------------------------------------- 70 Anlage 4: Hinweise und Empfehlungen zur Gestaltung von MACRO 1600-Quellprogrammen -------------------------------------------------------- 1. Zeilenformat --------------- Fuer die Gliederung der Quellprogrammzeilen wird das im Abschnitt 2.2.5. beschriebene Standardformat empfohlen. 2. Symbole ---------- Zur Bezeichnung der Register werden die in Abschnitt 3.1.8. be- schriebenen Standardregistersymbole empfohlen; deren Benutzung fuer andere Zwecke ist dann nicht moeglich. Fuer den Bezug auf Geraeteregister sollten nur die mit ihrer Hardwarebenennung identischen Symbole benutzt werden. Haeufig be- nutzte Konstanten mit spezifischer Bedeutung wie etwa Zeichen- konstanten (z.B. CR = 15) oder Offsets sollten als Symbole ver- einbart werden. Bei groesseren Programmsystemen ist es vorteilhaft, alle derarti- gen Standardsymbole in einer besonderen Datei zusammenzufassen, die entweder als fuehrende Quelldatei zu den eigentlichen Quell- programmen bei der Uebersetzung oder (mit globalen Symbolen) als Objektdatei beim Task Building hinzugefuegt wird. Ausdruecke mit Bezug auf den Speicherplatzzaehler der Form .+n sollten in Sprungbefehlen sowie ueberhaupt als Operand von Maschinenbefehlen vermieden werden. Fuer Marken, die Zieladressen von Spruengen mit programminterner, lokaler Bedeutung sind, empfiehlt sich die Benutzung von lokalen Symbolen (siehe Abschnitt 3.1.4). Lokale Symbole sollten so be- nannt werden, dass die Nummern in Richtung der Zeilenaufeinander- folge ansteigen. Globale Symbole, die in anderen Quellmoduln eines Programms de- finiert sind (externe globale Symbole) sollten im Programmkopf in .GLOBL-Anweisungen spezifiziert und gegebenenfalls nach Herkunft und Bedeutung kommentiert werden. In den Systembibliotheken wer- den globale Symbole verwendet, die das Zeichen "$" oder . ent- halten, und zwar bei Adressen an erster, bei Konstanten an zwei- ter und bei Bitmasken an dritter Stelle; daher sollten globale Symbole dieser Form in Anwendungsprogrammen nicht vereinbart wer- den. 3. Kommentar ------------ In Kommentaren bei Befehlszeilen ist der Sinn des Befehls darzu- stellen, nicht eine woertliche Beschreibung zu geben. Vor beson- ders schwierigen Befehlsfolgen ist ein erlaeuternder Kommentarab- schnitt einzufuegen. Kommentarzeilen werden beiderseits durch eine leere Kommentarzei- le begrenzt, die nur ein fuehrendes Semikolon enthaelt. Die eigentlichen Kommentarzeilen enthalten ab Spalte 3 (nach Semi- kolon und einem Leerzeichen) den Kommentartext. Falls in einer zu 71 kommentierenden Befehlszeile das Operandenfeld den Beginn des Kommentarfeldes (Spalte 33) ueberschreitet, soll vor dem Semiko- lon ein Leerzeichen stehen. Falls ein Kommentar zu einer Befehls- zeile nicht auf derselben Zeile untergebracht werden kann, wird eine Fortsetzungskommentarzeile eingerichtet, auf der der Kommen- tar mit der gleichen Spalte beginnt wie bei der dazugehoerigen Befehlszeile. Einleitungstext, der Moduln, Unterprogramme und Programmstuecke beschreibt, wird durch die speziellen Zeilen ;+ und ;- begrenzt. 4. Programm-Moduln ------------------ Insbesondere bei groesseren Programmen erweist sich ein modularer Aufbau, d.h. eine Gliederung des Quellprogramms in mehrere, unab- haengig voneinander zu uebersetzende Quellmoduln als sehr vorteilhaft. Fuer jeden Quellmodul ist die in Abschn. 2.1 aufge- fuehrte Programmstruktur massgebend. Im Programmkopf sollte nach der .TITLE- und .IDENT-Anweisung ein Modulvorwort (als Kommentarzeilen) stehen, welches in einheitli- cher Reihenfolge Angaben zu dem Quellmodul enthaelt, z.B. wie folgt: - Urhebervermerk ("COPYRIGHT") - Name des Hauptautors und Datum der ersten Herstellung - Fuer jede Modifikation chronologisch geordnet Name des Autors und Datum der Modifikation - Kurzbeschreibung der Funktion des Moduls - Liste der Eingangsdaten fuer den Modul - Liste der Ausgangsdaten, die im Ergebnis der Abarbeitung des Moduls entstehen - Liste der Effekte, die im Ergebnis der Abarbeitung des Moduls entstehen, z.B. Aenderungen im Systemzustand Befehls- und Datenteile sind zu trennen, desgleichen nur lesbare Daten von auch beschreibbaren Datenfeldern; dazu kann die Ver- einbarung von Programmsektionen benutzt werden. Der modulare Pro- grammaufbau erfordert die Einhaltung einiger Aufruf- und Rueck- kehrkonventionen fuer den Verkehr zwischen den Moduln. Fuer den intermodularen Aufruf und die entsprechende Rueckkehr sollten nur die CALL- und RETURN-Anweisung (s. Abschn. 3.3.4.) benutzt wer- den. (Fuer Registerrettungsroutinen sind jedoch Aufrufe der Form JSR Rn,name moeglich.) Alle Register, die ein Unter- programm zu aendern beabsichtigt (mit Ausnahme der Resultatregi- ster) sollen gerettet und vor dem Ausgang wiederhergestellt wer- den. Bei der Benutzung mehrerer Register zur Parameteruebertra- gung sollten diese fortlaufend gewaehlt werden. Alle Beendigungen eines Unterprogramms sollten ueber einen Ausgang (RETURN-Anwei- sung) gefuehrt werden. Als Fehleranzeige soll das C-Bit benutzt werden; erfolgreiche Operation entspricht dabei 0 und Fehler ent- spricht 1. Ergebnisregister koennen zur Uebergabe zusaetzlicher Fehlerdaten benutzt werden. Die Unterprogramme sind verantwort- lich fuer die Ueberpruefung der Gueltigkeit der ihnen uebergebe- nen Parameter. Diese Gueltigkeitspruefungen koennen minimiert werden, indem die ungueltigen Parameterkombinationen minimiert werden. Fuer Unterprogrammaufrufe innerhalb eines Moduls sind die genannten Konventionen nicht bindend. 72 5. Programmfluss ---------------- Programme sollten so geschrieben sein, dass sie auf der Ueber- setzungsliste fortlaufend lesbar sind, auch dann, wenn dafuer ge- legentlich ein zusaetzlicher Sprung eingefuegt werden muss. Beispiel: Das Programmstueck -- - - - - -----< TEST >---- | - - | | - - | | -- | ------- ------- | A | | B | ------- ------- | | | ------- | |--->| C |<---| ------- sollte in der Liste wie folgt dargestellt sein: TST ... BNE B A: ... ... BR C B: ... ... C: ... und nicht so: TST ... BNE B A: ... ... C: ... ... B: ... ... BR C Ein allgemeiner Ausgang sollte als letzte Befehlsfolge auf der Uebersetzungsliste erscheinen. 73 Beispiel: Das Programmstueck ------- ------- ------- | A | | B | | C | ------- ------- ------- | | | | | | |------->|<-------| | | -------- | EXIT | -------- sollte auf der Liste wie folgt dargestellt sein: A: ... ... BR EXIT B: ... ... BR EXIT C: ... ... EXIT: ... und nicht so: A: ... ... EXIT: ... ... B: ... ... BR EXIT C: ... ... BR EXIT Falls virtuelle Speicherkapazitaet genutzt werden soll, sollten Programmbezuege moeglichst eng beieinander liegen, d.h. Spruenge ueber grosse absolute Adressdistanzen sind moeglichst wenig zu verwenden. 6. Quellprogrammdateien ----------------------- Es ist zweckmaessig, die Herstellung und Aufbewahrung von Quell- programmen nach Basisstufen zu organisieren. Eine Basisstufe wird dann definiert, wenn die Quellprogrammdateien als fertiggestellt angesehen werden. Von einer Basisstufe zur naechsten erfolgen Korrekturen nicht direkt, sondern ueber Korrekturdateien. Wenn eine aktualisierte Quellprogrammdatei benoetigt wird, werden die Korrekturdateien abgearbeitet. Die Ansammlung von Korrekturdatei- en erfolgt bis eine neue Basisstufe festgelegt wird. Dann werden alle Korrekturen ausgefuehrt und die Korrekturdateien geloescht. 74 Anlage 5: Darstellung der Befehle --------------------------------- 1. Einoperand-Befehle --------------------- CLR --- Loesche Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 0 0 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D ( 15:0) <---- 0 N <---- 0 Z <---- 1 V <---- 0 C <---- 0 CLRB ---- Loesche Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 0 0 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D ( 7:0) <---- 0 N <---- 0 Z <---- 0 V <---- 0 C <---- 0 Beschreibung: Wort: Der Inhalt der angegebenen Destination- adresse wird geloescht. Byte: entsprechend Wort 75 COM --- Bilde Einerkomlement des Destinationwortes +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 0 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <----- - D (15:0) N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 0 C <---- 1 COMB ---- Bilde Einerkomplement des Destinationbytes +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 0 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:0) <---- - D (7:0) N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 0 C <---- 1 Beschreibung: Wort: Der Inhalt der angegebenen Destination- adresse wird durch sein logisches Komplement ersetzt. Byte: entsprechend Wort 76 INC --- Inkrementiere Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 0 1 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <---- D (15:0) + 1 N <---- 1, wenn Resultatwort < 0, sonst N <---- 0 Z <---- 1, wenn Resultatwort = 0, sonst Z <---- 0 V <---- 1, wenn D (15:0) = '077777 war, sonst V <---- 0 C bleibt unveraendert INCB ---- Inkrementiere Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 0 1 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:0) <---- D (7:0) + 1 N <---- 1, wenn Resultatbyte < 0, sonst N <---- 0 Z <---- 1, wenn Resultatbyte = 0, sonst Z <---- 0 V <---- 1, wenn D (7:0) = '177 war, sonst V <---- 0 C bleibt unveraendert Beschreibung: Wort: Addiere 1 zum Inhalt der angegebenen Destinationadresse. Byte: entsprechend Wort 77 DEC --- Dekrementiere Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 0 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <---- D (15:0) - 1 N <---- 1, wenn Resultatwort < 0, sonst N <---- 0 Z <---- 1, wenn Resultatwort = 0, sonst Z <---- 0 V <---- 1, wenn D (15:0) = '100000 war, sonst V <---- 0 C bleibt unveraendert DECB ---- Dekrementiere Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 0 1 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:0) <---- D (7:0) - 1 N <---- 1, wenn Resultatbyte < 0, sonst N <---- 0 Z <---- 1, wenn Resultatbyte = 0, sonst Z <---- 0 V <---- 1, wenn D (7:0) = '200 war, sonst V <---- 0 C bleibt unveraendert Beschreibung: Wort: Subtrahiere 1 vom Inhalt der angegebenen Destinationadresse. Byte: entsprechend Wort 78 NEG --- Bilde Zweierkomplement des Destinationwortes +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 1 0 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <---- - D (15:0) + 1 N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 1, wenn Ergebniswort = '100000, sonst V <---- 0 C <---- 0, wenn Ergebniswort = 0, sonst C <---- 1 Beachte: '100000 wird nicht veraendert, da im Zweierkomplement die groesste negative Zahl kein positives Gegenstueck hat. NEGB ---- Bilde Zweierkomplement des Destinationbytes +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 1 0 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:0) <---- - D (7:0) + 1 N <---- 1, wenn Ergebnisbyte 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 1, wenn Ergebnisbyte = '200, sonst V <---- 0 C <---- 0, wenn Ergebnisbyte = 0, sonst C <---- 1 Beachte: '200 wird nicht veraendert, da im Zweierkomlement die groesste negative Zahl kein positives Gegenstueck hat. Beschreibung: Wort: Der Inhalt der angegebenen Destinationadres- se wird durch sein Zweierkomplement ersetzt. Byte: entsprechend Wort 79 ADC --- Addiere Uebertragsbit zum Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 1 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <---- D (15:0) + C N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 1, wenn D (15:0) = '077777 und C = 1 waren, sonst V <---- 0 C <---- 1, wenn D (15:0) = '177777 und C = 1 waren, sonst C <---- 0 ADCB ---- Addiere Uebertragsbit zum Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 1 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:0) <---- D (7:0) + C N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 1, wenn D (7:0) = '177 und C = 1 waren, sonst V <---- 0 C <---- 1, wenn D (7:0) = '377 und C = 1 waren, sonst C <---- 0 Beschreibung: Wort: Addition des C- Bits zum Inhalt der ange- gebenen Destinationadresse. Byte: entsprechend Wort Anwendungsbeispiel: Doppelwortaddition ------------------- ADD A0, B0 Addition der niederwertigen Teile ADC B1 Addition des Uebertrags zum hoeher- wertigen Teil ADD A1, B1 Addition der hoeherwertigen Teile 80 SBC --- Subtrahiere Uebertragsbit vom Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 1 1 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <---- D (15:0) - C N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 1, wenn D (15:0) = '100000 und C = 1 waren, sonst V <---- 0 C <---- 0, wenn D (15:0) = 0 und C = 1 waren, sonst C <---- 1 SBCB ---- Subtrahiere Uebertragsbit vom Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 1 1 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:0) <---- D (7:0) - C N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 1, wenn D (7:0) = '200 und C = 1 waren, sonst V <---- 0 C <---- 0, wenn D (7:0) = 0 und C = 1 waren, sonst C <---- 1 Beschreibung: Wort: Subtraktion des C- Bits vom Inhalt der an- gegebenen Destinationadresse. Byte: entsprechend Wort Anwendungsbeispiel: Doppelwortsubtraktion ------------------- SUB A0, B0 SUB B1 SUB A1 81 TST --- Teste Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 1 | 1 1 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <---- D (15:0) N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 0 C <---- 0 TSTB ---- Teste Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 1 | 1 1 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:0) <---- D (7:0) N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 0 C <---- 0 Beschreibung: Wort: Die Flagbits N, Z, V und C werden in Ab- haengigkeit vom Inhalt der angegebenen Destinationadresse gesetzt. Byte: entsprechend Wort 82 ROR --- Verschiebe Destinationwort zyklisch rechts +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 1 0 | 0 0 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (14:0) <---- D (15:1) D (15) <---- C C <---- D (0) N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- N v C (nach Verschiebung) +---+ +------------------------------+ | C |---->| ----------> | +---+ +------------------------------+ ^ 15 |0 |------------------------------------| RORB ---- Verschiebe Destinationbyte zyklisch rechts +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 1 0 | 0 0 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (6:0) <---- D (7:1) D (7) <---- C C <---- D (0) N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- N v C (nach Verschiebung) +---------------------+ +---------------------+ | ---------> | | ---------> | +---------------------+ +---------------------+ ^15 +---+ |8 ^7 +---+ |0 |------| C |------| |------| C |------| +---+ +---+ bei ungerader Adresse bei gerader Adresse Beschreibung: Wort: Der Inhalt der angegebenen Destination- adresse wird um eine Stelle nach rechts ver- schoben. D (0) wird in das (C)- Bit und der alte Inhalt des C- Bits nach D (15) geladen. Byte: entsprechend Wort 83 ROL --- Verschiebe Destinationwort zyklisch links +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 1 0 | 0 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:1) <---- D (14:0) D (0) <---- C C <---- D (15) Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 V <---- N v C (nach Verschiebung) +---+ +----------------------------+ | C |<----| <----------- | +---+ +----------------------------+ | 15 ^0 |----------------------------------| ROLB ---- Verschiebe Destinationbyte zyklisch nach links +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 1 0 | 0 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:1) <---- D (6:0) D (0) <---- C C <---- D (7) Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 V <---- N v C (nach Verschiebung) +---------------------+ +---------------------+ | <--------- | | <--------- | +---------------------+ +---------------------+ |15 +---+ ^8 |7 +---+ ^0 |------| C |-------| |------| C |-------| +---+ +---+ bei ungerader Adresse bei gerader Adresse Beschreibung: Wort: Der Inhalt der angegebenen Destination- adresse wird um eine Stelle nach links ver- schoben. D (15) wird in das C- Bit und der alte Inhalt des C- Bits nach D (0) geladen. Byte: entsprechend Wort 84 ASR --- Verschiebe Destinationwort arithmetisch rechts +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 1 0 | 0 1 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15) <---- D (15) D (14:0) <---- D (15:1) C <---- D (0) N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- N v C (beide nach Verschiebung ) Der Befehl dividiert vorzeichenbehaftet durch 2. +-----------------------------+ +---+ --->| ---------> |---->| C |----| | +-----------------------------+ +---+ | |-----|15 0 v ASRB ---- Verschiebe Destinationbyte arithmetisch rechts +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 1 0 | 0 1 0 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7) <---- D (7) D ( 6:0) <---- D <---- (7:1) C <---- D (0) N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- N v C (beide nach Verschiebung) Der Befehl dividiert vorzeichenbehaftet durch 2. +-------------+ +---+ +-------------+ +---+ |--| -----> |--->| C |--| |--| -----> |--->| C |--| | +-------------+ +---+ | | +-------------+ +---+ | |---|15 8 v |---|7 0 v bei ungerader Adresse bei gerader Adresse Bescreibung: Wort: Der Inhalt der angegebenen Destinationadresse wird um eine Stelle nach rechts verschoben. D (0) wird in das C- Bit geladen. Freiwerdende Stellen werden mit D (15) aufgefuellt. Der alte Inhalt des C- Bits geht verloren. Byte: entsprechend Wort 85 ASL --- Verschiebe Destinationwort arithmetisch links +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 1 0 | 0 1 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:1) <---- D (14:0) D (0) <---- 0 C <---- D (15) N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- N v C (beide nach Verschiebung) Der Befehl multipliziert vorzeichenbehaftet mit 2. +---+ +--------------------------+ ----| C |<----| <--------- |<---- 0 | +---+ +--------------------------+ | 15 0 v ASLB ---- Verschiebe Destinatiosbyte arithmetisch links +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 1 0 | 0 1 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (7:1) <---- D (6:0) D (0) <---- 0 C <---- D (7) N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- N v C (beide nach Verschiebung) Der Befehl multipliziert vorzeichenbehaftet mit 2. +---+ +------------+ +---+ +------------+ |--| C |<---| <----- |<-- 0 |--| C |<---| <------ |<-- 0 | +---+ +------------+ | +---+ +------------+ v 15 8 v 7 0 Beschreibung: Wort: Der Inhalt der angegebenen Destinationadres- se wird um eine Stelle nach links verschoben. D (15) wird in das C- Bit geladen. Freiwer- dende Stellen werden mit Nullen aufgefuellt. Der alte Inhalt des C- Bits geht verloren. Byte: entsprechend Wort 86 SWAB ---- Vertauschte Bytes im Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 1 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:8) <---- D (7:0) D (7:0) <---- D (15:8) N <---- 1, wenn D (15) = 1 war, sonst N <---- 0 Z <---- 1, wenn D (15:8) = 0 war, sonst Z <---- 0 V <---- 0 C <---- 0 Beachte: Die durch DDD DDD angegebene Adresse muss eine Wort- adresse sein. Beschreibung: Das hoeherwertige und das niederwertige Byte des Inhaltes der angegebenen Destinationadresse werden vertauscht. 87 2. Zweioperand- Befehle ----------------------- MOV --- Transportiere Sourcewort nach Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 0 1 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (15:0) <---- S (15:0) N <---- 1, wenn S (15:0) < 0, sonst N <---- 0 Z <---- 1, wenn S (15:0) = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert MOVB ---- Transportiere Sourcebyte nach Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 0 1 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (7:0) <---- S (7:0), wenn Destinationmodus = 0 D (7:0) <---- S (7:0), D (15:8) <---- S (7), wenn Desti- nationmodus = 0 N <---- 1, wenn S (7:0) < 0, sonst N <---- 0 Z <---- 1, wenn S (7:0) = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert Beschreibung: Wort: Der Sourceoperand wird unter der angegebenen Destinationadresse abgespeichert. Der alte Inhalt der Destinationadresse geht verloren. Der Sourceoperand bleibt unveraendert. Byte: entsprechend Wort Wird der MOVB- Befehl in Bezug auf ein Re- gister ausgefuehrt, so erfolgt eine automa- tische Vorzeichenerweiterung, d.h. jedes Bit des hochwertigen Bytes des Destinationregis- ters wird nach Ausfuehrung der Transpotope- ration mit dem Inhalt des hoechstwertigsten Bits des niederwertigen Bytes beschrieben. 88 CMP --- Vergleiche Sourcewort mit Detinationwort +---+-------+-------+-------+-------+-------+ | 0 | 0 1 0 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: S (15:0) - D (15:0), beide Operanden unveraendert N <---- 1, wenn Ergebnis < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnis = 0, sonst Z <---- 0 V <---- 1, wenn arithmetischer Ueberlauf, sonst V <----0 C <---- 0, wenn Uebertrag aus hoechstwertigem Bit, sonst C <---- 1 CMPB ---- Vergleiche Sourcebyte mit Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 0 1 0 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: S (7:0) - D (7:0), beide Operanden unveraendert N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 1, wenn arithmetischer Ueberlauf, sonst V <---- 0 C <---- 0, wenn Uebertrag aus hoechstwertigem Bit, sonst C <---- 1 Kriterium fuer arithmetischen Ueberlauf: Die Operanden hatten unterschiedliche Vorzeichen; das Ergebnis- vorzeichen ist gleich dem des Destination-Operanden. Beschreibung: Wort: Der Source- und der Destinationoperand wer- den verglichen. In Abhaengigkeit vom Resultat werden die Flagbits N, Z, V und C gesetzt. Beide Operanden bleiben unveraendert. Byte: entsprechend Wort 89 BIT --- Bittest (Wort) +---+-------+-------+-------+-------+-------+ | 0 | 0 1 1 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (15:0) ^ S (15:0), beide Operanden unveraendert N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert BITB ---- Bittest (Byte) +---+-------+-------+-------+-------+-------+ | 1 | 0 1 1 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (7:0) ^ S (7:0), beide Operanden unveraendert N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert Beschreibung: Wort: Es wird das logische Produkt aus Source- und Destinationoperand gebildet. In Abhaeng- igkeit vom Resultat werden die Flagbits N und Z gesetzt. Beide Operanden bleiben unver- aendert. Byte: entsprechend Wort 90 BIC --- Loesche Bits im Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 1 0 0 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (15:0) <---- -S (15:0) ^ D (15:0) N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert BICB ---- Loesche Bits im Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 1 0 0 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (7:0) <---- -S (7:0) ^ D (7:0) N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert Beschreibung: Wort: Zwischen Source- und Destinationoperand wird die logische Operation Inhibition ausge- fuehrt, d.h. es wird jedes Bit des Destina- tionwortes geloescht, das einem gesetzten Bit im Sourcewort entspricht. Byte: entsprechend Wort 91 BIS --- Setze Bits im Destinationwort +---+-------+-------+-------+-------+-------+ | 0 | 1 0 1 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (15:0) <---- S (15:0) v D (15:0) N <---- 1, wenn Ergebniswort < 0, sonst N <---- 0 Z <---- 1, wenn Ergebniswort = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert BISB ---- Setze Bits im Destinationbyte +---+-------+-------+-------+-------+-------+ | 1 | 1 0 1 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (7:0) <---- S (7:0) v D (7:0) N <---- 1, wenn Ergebnisbyte < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnisbyte = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert Beschreibung: Wort: Es wird die logische Summe aus Source- und Destinaionoperand gebildet. Das Resultat wird unter der angegebenen Destinationadresse ab- gespeichert. Der Sourceoperand bleibt unver- aendert. Byte: entsprechend Wort 92 ADD --- Addiere Sourcewort zum Destinationwort dual +---+-------+-------+-------+-------+-------+ | 0 | 1 1 0 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (15:0) <---- S (15:0) + D (15:0) N <---- 1, wenn Resultat < 0, sonst N <---- 0 Z <---- 1, wenn Resultat = 0, sonst Z <---- 0 V <---- 1, wenn arithmetischer Ueberlauf, sonst V <---- 0 C <---- 1, wenn Uebertrag aus dem hoechstwertigen Bit, sonst C <---- 0 Kriterium fuer arithmetischen Ueberlauf: Beide Operanden hatten ein gleiches Vorzeichen und das Ergebnis hat entgegengesetztes Vorzeichen. Beschreibung: Source- und Destinationoperand werden addiert. Das Resultat wird unter der angegebenen Destinationad- resse abgespeichert. Der Sourceoperand bleibt un- veraendert. 93 SUB --- Subtrahiere Sourcewort vom Destinationwort dual +---+-------+-------+-------+-------+-------+ | 1 | 1 1 0 | S S S | S S S | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 12 11 6 5 0 Wirkung: D (15:0) <---- D (15:0) - S (15:0) Ausfuehrung: D (15:0) <---- D (15:0) + - S (15:0) + 1 N <---- 1, wenn Resultat < 0, sonst N <---- 0 Z <---- 1, wenn Resultat = 0, sonst Z <---- 0 V <---- 1, wenn arithmetischer Ueberlauf, sonst V <---- 0 C <---- 0, wenn Uebertrag aus dem hoechstwertigen Bit, 1) sonst C <---- 1 Kriterium fuer arithmetischen Ueberlauf: Die Operanden hatten unterschiedliches Vorzeichen und das Ergeb- nisvorzeichen ist gleich dem des Sourceoperanden. 1) Das C- Bit wird so gesetzt, dass bei Subtraktion mit doppelter Genauigkeit ein "borrow" durch C = 1 angezeigt wird. Beschreibung: Der Sourceoperand wird vom Destinationoperand sub- trahiert. Das Resultat wird unter der angegebenen Destinationadresse abgespeichert. Der Sourceope- rand bleibt unveraendert. 94 3. Branch- Befehle ------------------ Ein Branch- Befehl verursacht eine Verzweigung zu einer Adresse, die durch die Summe der im Befehl angegebenen Verzweigungsweite (Offset; multipliziert mit 2) und dem laufenden Befehlserzaehler- stand defineirt wird, und zwar a) wenn der Branch- Befehl unbedingt ist b) wenn er bedingt ist, und die Bedingung erfuellt ist. Die im Befehl angegebene Verzweigungsweite wird automatisch mit 2 multipliziert, bevor sie zum Befehlszaehlerinhalt addiert wird. Bit 7 der Verzweigugsweite kennzeichnet das Vorzeichen. Der 8 Bit lange Offset gestattet eine Verzweigungsweite von - 128 bis +127. Branch- Befehle haben keinen Einfluss auf die Flagbits. Durch die vorzeichenbedingten Verzweigungen werden besondere Kom- binationen der Flagbits getestet. Diese Befehle werden zur Tes- tung der Resultate von Befehlen verwendet, in denen die Operanden als vorzeichenbehaftete Werte (im Zweierkomplement) betrachtet werden. Vorzeichenunabhaengige bedingte Verzweigungen dienen zum Testen von Resultaten der Vergleichsoperationen, in denen die Operanden als Werte ohne Vorzeichen betrachtet werden. 95 BR -- Verzweigung unbedingt +---+-------+-------+---+---------------+ | 0 | 0 0 0 | 0 0 0 | 1 | offset | +---+-------+-------+---+---------------+ 15 8 7 0 Wirkung: BZ (15:0) <---- BZ (15:0) + 2 * BR (7:0) N, Z, V, C bleiben unveraendert Beschreibung: Der Offset wird mit 2 multipliziert und vorzeichen- behaftet zum aktualisierten Befehlszaehlerstand ad- diert (Zweierkomplementdarstellung). Damit werden Sprungweiten von - 128 bis + 127 Worten relativ zum Befehlszaehler moeglich. Der aktualisierte Befehls- zaehlerstand entspricht der Adresse des Verzwei- gungsbefehls plus 2. 96 Bedingte Verzweigungen (allgemein) ---------------------- +---------------+---------------+ | OP-Code | offset | +---------------+---------------+ 15 8 7 0 Wirkung: BZ (15:0) <---- BZ (15:0) + 2 * BR (7:0), wenn Bedingung erfuellt BZ (15:0) <---- BZ (15:0), wenn Bedingung nicht erfuellt N, Z, V, C bleiben unveraendert Folgende bedingte Verzweigungen sind moeglich: Mnemonik Basiskode Verzweige- Verwendung bedingung BNE 001000 Z = 0 Verzweigung bei = 0 BEQ 001400 Z = 1 Verzweigung bei = 0 BPL 100000 N = 0 Verzweigung bei + BMI 100400 N = 1 Verzweigung bei - BVC 102000 V = 0 Verzweige, wenn kein Ueberlauf BVS 102400 V = 1 Verzweige, wenn Ueberlauf BCC 103000 C = 0 Verzweige, wenn kein Uebertrag BCS 103400 C = 1 Verzweige, wenn Uebertrag BGE 002000 N v V = 0 Verzweige bei groesser oder gleich 0 BLT 002400 N v V = 1 Verzweige bei kleiner als 0 BGT 003000 Zv(N-V)=0 Verzweige bei groesser als 0 BLE 003400 Zv(N-V)=1 Verzweige bei kleiner oder gleich 0 BHI 101000 C v Z = 0 Verzweige bei betragsmaessig groesser BLOS 101400 C v Z = 1 Verzweige bei betragsmaessig kleiner oder gleich BLO 103400 C = 1 Verzweige bei betragsmaessig kleiner BHIS 103000 C = 0 Verzweige bei betragsmaessig groesser oder gleich 97 4. PSW- Behandlung ------------------ Setze/ Loesche Flagbits +---+-------+-------+-------+---+-----+---------+ | 0 | 0 0 0 | 0 0 0 | 0 1 0 | 1 | S/L | N Z V C | +---+-------+-------+-------+---+-----+---------+ 15 5 4 3 0 S/L: Setzen/ Loeschen Wirkung: PS (3:0) <---- PS (3:0) v BR (3:0), wenn BR (4) = 1 PS (3:0) <---- PS (3:0) ^|BR (3:0), wenn BR (4) = 0 Beschreibung: In Abhaengigkeit von dem Bit BR (4) werden die durch die Maske BR (3:0) angegebenen Bits im PSW- Register gesetzt, wenn BR (4) = 1, oder geloescht, wenn BR (4) = 0. Folgende Operationen sind moeglich: Mnemonik OP- Kode Bezeichnung CLC 000241 Loesche C- Bit CLV 000242 Loesche V- Bit CLZ 000244 Loesche Z- Bit CLN 000250 Loesche N- Bit SEC 000261 Setze C- Bit SEV 000262 Setze V- Bit SEZ 000264 Setze Z- Bit SEN 000270 Setze N- Bit SCC 000277 Setze alle Flagbits CCC 000257 Loesche alle Flagbits CVC 000243 Loesch V- und C- Bit Kombinationen der obigen Setz- oder Loeschoperationen koennen geordert werden. Somit besteht die Moeglichkeit, kombineirte Be- fehle zu bilden. 98 5. Trap- Befehle ---------------- Trap- Befehle dienen zur Organisation von Rufen, zum Beispiel Emulatorrufe E/A- Rufe Aufruf von Testhilfsprogrammen Aufruf fuer anwenderspeziefische Interpreter Ein Trap- Befehl ist eine Unterbrechung, die programmtechnisch erzeugt wird. Tritt ein Trap- Befehl auf, so wird der Inhalt des laufenden Befehlszaehlers und des laufenden PSW im Keller- speicher abgespeichert und ein Trapvektor, bestehend aus zwei Worten, aufgerufen. Dieser Trapvektor enthaelt den neuen Befehls- zaehlerstand sowie ein neues PSW. Die Rueckkehr aus einem Pro- gramm, das durch einen Trap- Befehl angesprungen wurde, erfolgt mit dem RTI- Befehl. Dieser Befehl laedt den Befehlszaehler und das PSW- Register mit den alten Werten, indem diese aus dem Kel- lerspeicher geholt werden. Die einzelnen Trap-Befehle haben fest zugeordnete Vektoradressen. 99 EMT --- Emulator- Trap +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 0 | 0 X X | X X X | X X X | +---+-------+-------+-------+-------+-------+ 15 8 7 0 Wirkung: | <---- PS (15:0) | <---- BZ (15:0) BZ (15:0) <---- <'000030> PS (15:0) <---- <'000032> N, Z, V, C durch Trap- Vektor geladen Beachte: Der EMT- Befehl wird durch das Betriebssystem verwendet und wird deshalb nicht fuer den allgemeinen Gebrauch empfohlen. Beschreibung: Alle Operationskodes von '104000 bis '104377 sind EMT- Befehle. Sie koennen verwendet werden, um In- formationen zu Emulator- Routinen zu uebertragen. Der Trapvektor fuer den EMT- Befehl ist unter der Adresse '000030 abgespeichert. Die Zelle '000030 enthaelt den neuen Befehlszaeh- lerstand, die Zelle '000032 das neue PSW. 100 TRAP ---- Trap- Befehl +---+-------+-------+-------+-------+-------+ | 1 | 0 0 0 | 1 0 0 | 1 X X | X X X | X X X | +---+-------+-------+-------+-------+-------+ 15 0 Wirkung: | <---- PS (15:0) | <---- BZ (15:0) BZ (15:0) <---- <'000034> PS (15:0) <---- <'000036> N, Z, V, C durch Trap- Vektor geladen Beachte: Da der EMT- Befehl von dem Betriebssystem verwendet wird, ist der TRAP- Befehl fuer den allgemeinen Ge- brauch vorgesehen. Beschreibung: Die Operationskodes von '104400 bis '104777 sind TRAP- Befehle. TRAP- Befehle und EMT- Befehle sind in ihrer Funktionsweise identisch. Der Trapvektor fuer den TRAP- Befehl ist unter der Adresse '000034 abgespeichert. 101 BPT --- Breakpoint- Trap +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 1 1 | +---+-------+-------+-------+-------+-------+ 15 0 Wirkung: | <---- PS (15:0) | <---- BZ (15:0) BZ (15:0) <---- <'000014> PS (15:0) <---- <'000016> N, Z, V, C durch Trap- Vektor geladen Beschreibung: Dieser Befehl gestattet Unterbrechungspunkte zu setzen. Es wird eine Trapfolge ueber die Trapvek- toradresse '000014 eingeleitet. Der Befehl wird verwendet, um Testhilfsprogramme aufzurufen. IOT --- +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | 1 0 0 | +---+-------+-------+-------+-------+-------+ 15 0 Wirkung: | <---- PS (15:0) | <---- BZ (15:0) BZ (15:0) <---- <'000020> PS (15:0) <---- <'000022> N, Z, V, C durch Trap- Vektor geladen Beschreibung: Dieser Befehl leitet eine Trapfolge ueber die Trap- vektoradresse '000020 ein. Es wird zum Aufruf von E/A- Ausfuehrungsroutinen verwendet. 102 6. Sprungbefehle ---------------- JMP --- Sprungbefehl +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: BZ (15:0) <---- D (15:0) N, Z, V, C bleiben unveraendert Beschreibung: Die Adressierungsmodi laufen wie bei Operandenzu- griff ab. Die in der Adressrechnung gebildete Adresse wird jedoch nicht als Operandenadresse ausgesendet, sondern als Sprungadresse in BZ ein- getragen. Modus 0 ist verboten, da keine Register- nummer in BZ eingetragen werden kann. Modus 0 fuehrt zu Fehlertrap ueber Zelle '000004. JSR --- Springe zum Unterprogramm +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 0 0 | R R R | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 9 8 6 5 0 Wirkung: | (15:0) <---- D (15:0) ZR: internes Zwischen- | <---- R (15:0) register R (15:0) <---- BZ (15:0) BZ (15:0) <---- ZR (15:0) N, Z, V, C bleiben unveraendert Beschreibung: Die Adressierungsmodi laufen wie bei Operandenzu- griff ab. Die in der Adressrechnung gebildete Adresse wird jedoch nicht als Operandenadresse ausgesendet, sondern als Sprungadresse in BZ ein- getragen. Der Adressierungsmodus 0 ist verboten, da keine Registernummer in BZ eingetragen werden kann. Er fuehrt zum Fehlertrap ueber Zelle '000004. 103 7. Interrupt- und Unterprogrammruecksprung ------------------------------------------ RTI --- Rueckkehr aus Interruptprogramm +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 1 0 | +---+-------+-------+-------+-------+-------+ 15 0 Wirkung: BZ (15:0) <---- | PS (15:0) <---- | N, Z, V, C aus Kellerspeicher geladen Beschreibung: Dieser Befehl wird fuer den Ruecksprung aus einer Unterbrechungs- oder Trap- Behandlungsroutine ver- wendet. Dabei werden der Befehlszaehler und das PSW- Register mit den im Kellerspeicher gespei- cherten alten Werten geladen. Wenn nach Ausfuehrung des RTI- Befehls im PSW das T- Bit gesetzt ist, erfolgt der T- Bit- Trap erst nach Abarbeitung des Befehls nach dem RTI. RTT --- Rueckkehr aus dem Trap- Programm +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | 1 1 0 | +---+-------+-------+-------+-------+-------+ 15 0 Wirkung: wie RTI RTS --- Rueckkehr aus dem Unterprogramm +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | R R R | +---+-------+-------+-------+-------+-------+ 15 0 Wirkung: BZ (15:0) <---- R (15:0) R (15:0) <---- | N, Z, V, C bleiben unveraendert Beschreibung: Der Befehlszaehler wird mit dem Inhalt des ange- gebenen Registers und das Register mit dem ober- sten Element des Kellerspeichers geladen. 104 8. Steuerbefehle ---------------- HALT ---- Haltbefehl +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | +---+-------+-------+-------+-------+-------+ 15 0 Beschreibung: N, Z, V, C bleiben unveraendert Der Prozessor springt ins Bedienmikroprogramm, gibt den Inhalt des BZ auf dem Bediengeraet aus und war- tet auf weitere Bedienzeichen. Der Prozessor kann durch Eingaben des Zeichens G von einer vorher ein- gegebenen Adresse und durch Eingeben des Zeichens P vom aktuellen Befehlszaehlerstand an (Befehl der auf HALT folgt) gestartet werden. WAIT ---- Warte auf Interupt +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 1 | +---+-------+-------+-------+-------+-------+ 15 0 Beschreibung: N, Z, V, C bleiben unveraendert Der Prozessor nimmt einen Wartezustand ein, wobei der Bus freigegeben wird und der BZ auf den naech- sten abzuarbeitenden Befehl zeigt. Der Wartezustand wird durch einen exteren Interupt beendet. 105 RESET ----- Setze externen Bus zurueck +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 0 0 | 0 0 0 | 1 0 1 | +---+-------+-------+-------+-------+-------+ 15 0 Laufzeit: 10 ms Beschreibung: Der Prozessor aktiviert fuer 10 us die GENLO- Leitung. Damit werden alle Geraete am Bus auf den Zustand bei Spannungszuschalten rueckgesetzt. Der Prozessor setzt die Programmabarbeitung erst nach 10 ms fort. Nur bei Spannungsausfall kann der RESET- Befehl bereits nach Ablauf von 10 us been- det werden. NOP --- Keine Operation +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 1 0 | 1 0 0 | 0 0 0 | +---+-------+-------+-------+-------+-------+ 15 0 Beschreibung: N, Z, V, C bleiben unveraendert Dieser Befehl ist ein Blindbefehl. 106 9. Zusatzbefehle ---------------- SPL --- Setze Prioritaetsniveau +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 0 0 0 | 0 1 0 | 0 1 1 | N N N | +---+-------+-------+-------+-------+-------+ 15 3 2 0 Wirkung: PS (7:5) <---- Prioritaet N, Z, V, C bleiben unveraendert Beschreibung: Die niederwertigsten drei Bits des Befehls werden in die PSW Bits (7:5) geladen und bewirken einen Prioritaetswechsel. Die alte Prioritaet geht ver- loren. 107 MARK ---- +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 1 0 | 1 0 0 | N N N | N N N | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: SP <---- SP + 2 N (5:0) BZ <---- R5 R5 <---- | N, Z, V, C bleiben unveraendert Beschreibung: MARK erleichtert die Stack- Reinigungsprozeduren, die in Unterprogrammen inbegriffen sind. 108 SXT --- Vorzeichenerweiterung des Destinationoperanden +---+-------+-------+-------+-------+-------+ | 0 | 0 0 0 | 1 1 0 | 1 1 1 | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 6 5 0 Wirkung: D (15:0) <---- 0, wenn N = 0 D (15:0) <---- 1, wenn N = 1 Z <---- 1, wenn N = 0; V <---- 0 N, C bleiben unveraendert Beschreibung: Wenn das Flagbit N = 1, dann wird - 1 als Desti- nationoperand eingesetzt. Dieser Befehl ist beson- ders nuetzlich, weil er die Vorzeichenerweiterung ueber mehrere Woerter erlaubt. 109 MUL --- Multiplikation +---+-------+-------+-------+-------+-------+ | 0 | 1 1 1 | 0 0 0 | R R R | S S S | S S S | +---+-------+-------+-------+-------+-------+ 15 9 8 6 5 0 Wirkung: R, Rv1 <---- R * S (15:0) N <---- 1, wenn Resultat < 0, sonst N <---- 0 Z <---- 1, wenn Resultat = 0, sonst Z <---- 0 V <---- 0 15 15 C <---- 1, wenn Resultat < - 2 oder > 2 - 1, - sonst C <---- 0 Beschreibung: Das Sourcewort und der Inhalt von R werden multi- pliziert. Wenn R gerade ist, wird das Resultat in R und das nachfolgende Register Rv1 (Register geord- net mit 1) eingeschrieben. Ist R ungerade, so wird nur der niederwertige Teil des Ergebnisses in R eingeschrieben, da in diesem Fall R und Rv1 die gleichen Register sind. 110 DIV --- Division +---+-------+-------+-------+-------+-------+ | 0 | 1 1 1 | 0 0 1 | R R R | S S S | S S S | +---+-------+-------+-------+-------+-------+ 15 9 8 6 5 0 Wirkung: R, Rv1 <---- R, Rv1 : S (15:0) N <---- 1, wenn der Quotient < 0, sonst N <---- 0 Z <---- 1, wenn der Quotient = 0, sonst Z <---- 0 V <---- 1, wenn der Sourceoperand = 0, oder wenn der Quotient den zulaessigen Zahlenbereich ueber- schreitet (d.h. wenn der absolute Betrag von R (15:0) > dem absoluten von S (15:0)), sonst - V <---- O C <---- 1, bei versuchter Division durch 0, sonst C <---- 0 Beschreibung: Der Inhalt von R und Rv1 (Regiser geordnet mit 1) wird durch das Sourcewort dividiert. Der Quotient wird in R eingetragen, der Rest in Rv1. Der Rest hat das gleiche Vorzeichen wie der Divident. Das Register R muss gerade sein. 111 ASH --- Verschiebung arithmetisch +---+-------+-------+-------+-------+-------+ | 0 | 1 1 1 | 0 1 0 | R R R | S S S | S S S | +---+-------+-------+-------+-------+-------+ 15 9 8 6 5 0 Wirkung: R <---- R arithmetisch verschoben um NN Stellen nach rechts oder links, wobei NN = S (5:0) N <---- 1, wenn Ergebnis < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnis = 0, sonst Z <---- 0 V <---- 1, wenn sich das Vorzeichen des Registers waeh- rend der Verschiebung aendert, sonst V <----0 C wird geladen vom letzten Bit, das aus dem Register herausgeschoben wird Beschreibung: Der Inhalt des Registers wird nach links oder rechts verschoben. Die Anzahl der Verschiebungen wird durch den Sourceoperanden bestimmt. Der Ver- schiebungszaehler besteht aus den niederwertigen 6 Bits des Sourceoperanden. Die Zahl der Verschie- bungen bewegt sich zwischen - 32 und + 31. Das ne- gative Vorzeichen bedeutet Rechtsverschiebung, das positive Linksverschiebung. +----------------------------+ +---+ ---->| -----------> |------>| C | | +----------------------------+ +---+ | | 15 0 ------- +---+ +----------------------------+ | C |<-----| <---------- |<------ 0 +---+ +----------------------------+ 15 0 112 ASHC ---- Verschiebung arithmetisch kombiniert +---+-------+-------+-------+-------+-------+ | 0 | 1 1 1 | 0 1 1 | R R R | S S S | S S S | +---+-------+-------+-------+-------+-------+ 15 9 8 6 5 0 Wirkung: R, Rv1 <---- R, Rv1 Das Doppelwort wird um NN Stellen nach links oder rechts verschoben, wobei NN = S (5:0) N <---- 1, wenn Ergebnis < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnis = 0, sonst Z <---- 0 V <---- 1, wenn sich das Vorzeichen waehrend der Ver- schiebung aendert, sonst V = 0 C wird beim Linksschieben mit dem hoechstwertigen und beim Rechtsschieben mit dem niederwertigsten Bit des Resultates geladen Beschreibung: Die Inhalte des Registers und des mit 1 geoderten Registers bilden ein 32 Bit Wort. Rv1 (Bits 0-15) und R (Bits 16-31) werden nach links oder rechts verschoben. Die Anzahl der Verschiebungen wird durch den Sourceoperanden bestimmt. Der Verschie- bungszaehler besteht aus den niederwertigen 6 Bits des Sourceoperanden. Die Zahl der Verschiebungen bewegt sich zwischen -32 und +31. Das negative Vor- zeichen bedeutet Rechtsverschiebung, das positive Linksverschiebung. Wenn das gewaehlte Register eine ungerade Nummer hat, sind das Register und das mit 1 geoderte Register dieselben. In diesem Falle wird die Rechtsverschiebung eine zyklische Ver- schiebung. Das 16 Bit Wort wird zyklisch nach rechts verschoben, wobei die Zahl der Verschie- bungen vom Verschiebungszaehler angegeben werden. +-----------------------------+ ---->| 31 ------------> 16 | | +-----------------------------+ -------| -----------------------| | +-----------------------------+ +---+ | 15 ------------> 0 |---->| C | +-----------------------------+ +---+ +---+ +-----------------------------+ | C |<----| 31 ------------> 16 | +---+ +-----------------------------+ ^ --------------------------| | +-----------------------------+ | 15 <----------- 0 |<---- 0 +-----------------------------+ 113 XOR --- Exklusivoder +---+-------+-------+-------+-------+-------+ | 0 | 1 1 1 | 1 0 0 | R R R | D D D | D D D | +---+-------+-------+-------+-------+-------+ 15 9 8 6 5 0 Wirkung: D (15:0) <---- R (15:0) v D (15:0) N <---- 1, wenn Ergebnis < 0, sonst N <---- 0 Z <---- 1, wenn Ergebnis = 0, sonst Z <---- 0 V <---- 0 C bleibt unveraendert Beschreibung: Die Exklusivoderung von Register und Destination- operand wird unter der angegebenen Destinationad- resse abgespeichert. Der Registerinhalt bleibt un- veraendert. 114 SOB --- Subtrahiere 1 und Verzweige +---+-------+-------+-------+----------+ | 0 | 1 1 1 | 1 1 1 | R R R | offset | +---+-------+-------+-------+----------+ 15 9 8 6 5 0 Wirkung: R (15:0) <---- R (15:0) - 1 Wenn Ergebnis = 0, dann BZ (15:0) <---- BZ (15:0) - 2 BR (5:0) N, Z, V, C bleiben unveraendert Beschreibung: Der Inhalt des Registers wird um 1 vermindert. Ist das Ergebnis = 0, wird der Offset mit 2 multipli- ziert und vom Befehlszaehler subtrahiert. Der Offset wird als eine 6 Bit breite positive Zahl interpretiert. 115 BMOV ---- Blocktransport von Zeichenketten +---+-------+-------+-------+-------+-------+ | 0 | 1 1 1 | 1 1 0 | 1 1 1 | 0 1 0 | 0 0 0 | +---+-------+-------+-------+-------+-------+ 15 0 Wirkung: D <---- S N <---- 0 Z <---- 1 V <---- 0 C <---- 0 Beschreibung: Vor Befehlsbeginn muessen folgede Parameter einge- tragen sein: R0 (15:0) <---- n = Blocklaenge in Byte R1 (15:0) <---- Anfangsadresse S der Quellkette R3 (15:0) <---- Anfangsadresse D der Zielkette Eine Quellzeichenkette der Laenge n- Byte wird in die Zielkette transportiert. Eine Ueberlappung der Quell- und Zielkette hat keinen Einfluss auf die Operation. Sonderfall n = 0: Es wird kein Zeichen transpor- tiert. Nach der Befehlsausfuehrung sind R1 und R3 ge- loescht, R0 enthaelt die Zahl der nicht transpor- tierten Bytes, d. h. bei vollstaendiger Befehlsab- arbeitung ist R0 geloescht. Der Befehl wird bei folgenden Ursachen unterbro- chen : - Spannungsabfall - Luefterausfall - externe Unterbrechungen - Busfehler 116 Sachwortverzeichnis ------------------- Absolute Adressierung 26 Makroschachtelung 58 Absoluter Ausdruck 18 Marke, Markenfeld 8 Adressierungsmodi 23 Maschinenbefehle 19 Anweisung, -zeile 8 .MCALL 52 .ASCII, .ASCIZ 34 .MEXIT 58 Attributanweisungen 57 .NARG 57 Ausdruck 17 .NCHR 57 Bedingte Uebersetzung 45 .NLIST 48 Binaerkonstante 15 .NTYPE 57 .BLKB, .BLKW 35 Numerische Parameter 55 .BYTE 28 Oktalzahlen 12 CALL 23 Operand, Operandenfeld 9 Dezimalkonstante 15 .PACKED 30 Dezimalzahl 12 .PAGE 50 Direktanweisung 18 Parameter (Makro) 53 Direkte Adressierung 26 Parameter (Unterprog.) 22 .DSABL 37 Positionsunabhaeng.Code 27 .ENABL 37 .PRINT 58 .ENDC 45 Programmaufbau 6 .ERROR 58 Programmende 37 .EVEN 35 Programmsektion 42 Externer Ausdruck 18 Programmtitel 36 Externer Makro 51 .PSECT 42 Externes Symbol 40 .RADIX 39 Fehleranweisung 58 Radix-50-Konstante 15 .FLT2, .FLT4 31 Radix-50-Zeichenkette 34 Gleitkommakonstante 16 .RAD50 34 Gleitkommazahlen 31 Registerausdruck 16 Globales Symbol 40 Registersymbol 16 .GLOBL 40 Relative Adressierung 26 .IDENT 36 .REPT 60 .IF 45 RETURN 23 .IFF, .IFT, .IFTF 47 .SBTTL 36 .IIF 47 Speicherplatz- vereinbarung 35 Index, Indexmodus 24 Speicherplatzzaehler 14,44 Inhaltsverzeichnis 36 Startadresse 37 Integerzahlen 29 Stellungsparameter 53 Interner Makro 51 Symbol 12 .IRP 59 Tetradische Dezimalzahlen30 Kennwortparameter 54 .TITLE 36 Kommentar, -feld 9 Uebersetzungsliste 48 Komplexer Ausdruck 18 Unterprogramm 22 Konstantentypen 15 Untertitel 36 .LIMIT 42 Verkettung von Parametern55 .LIST 48 Verschieblicher Ausdruck 18 Listenzaehler 49 Verzweigungsbefehle 21 Lokales Symbol 13 Wiederholungsblock 59 .LONG 29 .WORD 28 Makroanweisung 51,53 Zahlen 12,39 Makrodefinition 51,52 Zeichenkette 34 Makroparameter 53,57 Zeichenkonstante 14 117