Und oder nicht?
Die boolschen Befehle werden häufig genutzt, um einzelne Bits zu setzen oder zu löschen. Schaut euch am besten nochmal die Boolsche Algebra an, falls ihr nicht mehr genau vor Augen habt, wie UND und ODER funktionieren.
Wir testen die Boolschen-Befehle in einem neuen, kleinen Beispiel.
Wir werden nun bei den ersten 240 Zeichen auf dem BS jedes zweite invertieren. Wer möchte kann als kleine Übung das Programm ja später so ändern, dass das Programm sich auf den gesamten Bildschirm bezieht. Invertieren bedeutet nichts Anderes, als Zeichen- und Hingrundfarbe zu vertauschen. Wer sich mal Bild-1 und Bild-2 beim Char-ROM ansieht, dem wird jetzt bestimmt etwas auffallen. Das zweite Bild zeigt exakt die gleichen Zeichen, die auch schon auf dem ersten zu sehen sind, nur invertiert. Uns als Binär-Profis sollte bei einem Blick auf die Nummern der einzelnen Zeichen noch etwas ins Auge stechen (Autsch!).
Nehmen wir als Beispiel mal das Zeichen für die Ziffer 7, dies hat in der normalen Darstellung die Nr. 55 / $37 und invertiert die Nr. 183 / $b7 im Zeichensatz.
|
1 2 |
normal....: 55 = $37 = %00110111 invertiert: 183 = $b7 = %10110111 |
Jetzt sollte allen klar sein, dass man zum invertierten Zeichen kommt, wenn man einfach das höchste Bit setzt. Das seht ihr ja auch in den beiden Bildern beim Char-ROM, da alle normalen Zeichen im 1. Bild von Nr. 0-127 zu finden sind, die invertierten aber von Nr. 128 bis 255 im zweiten Bild.
Oder
Wir brauchen nun also ein Programm, dass für jedes Zeichen das höchste Bit setzt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
;*** Variablen SCREENRAM = $03ff ;Start des Bildschirmspeichers ORAMASK = %10000000 ;*** Startadresse BASIC-Zeile *=$0801 !byte $0c,$08,$e2,$07,$9e,$20,$32,$30,$36,$32,$00,$00,$00 ;*** Start des Assemblerprogrammes ldy #$f0 ;die ersten 240 Zeichen loop_ora lda SCREENRAM,y ;Zeichen in den Akku |
Beim Turbo Assembler könnt ihr keine Unterstriche wie bei loop_ora verwenden, lasst diese einfach weg und schreibt die Labelbezeichnungen direkt zusammen. Denkt auch weiterhin daran, dass die Label dort max. 15 Zeichen lang sein dürfen.
Hier ist nichts Spektakuläres zu sehen, einzig die neue Variable ORAMASK. In unserer Schleife direkt hinter loop_ora laden wir erstmal das Zeichen in den Akku, dass sich an der Adresse SCRENNRAM plus Y-Register (absolute Y-indizierte Adressierung) befindet.
|
1 |
ora #ORAMASK ;ODER-Verknüpfung des Akkus mit mit unserer Maske |
ORA: OR with Accumulator (bitweises ODER mit dem Akku)
ORA Akku ($09, 2B, 2T, NZ)
Hier führen wir jetzt mit
ORA eine bitweise ODER-Verknüpfung mit dem Akku und unserer
ORAMASK durch. Das Ergebnis landet dann wieder im Akkumulator. Ist das Ergebnis 0, dann wird das Z-Flag gesetzt, sollte Bit-7 auf eins stehen, dann wird das N-Flag gesetzt.
Beim ODER wird ein Bit immer dann zu 1, wenn entweder das erste oder das zweite oder beide beteiligten Bits eine 1 aufweisen:
|
1 2 3 4 |
%0101 ORA %0011 ===== %0111 |
ORA wird daher verwendet, um gezielt einzelne Bits zu setzen, dazu läßt man in seiner Maske alle Bits, die man nicht ändern möchte auf 0 und setzt nur die Bits auf 1 die man auf jeden Fall auf 1 setzen will. Deshalb ist in unserer Maske nur Bit-7 auf 1 gesetzt worden, alle anderen sind 0.
Im Detail sieht das für unser Zeichen 7, wenn es im Akku liegt, so aus:
|
1 2 3 4 5 |
Akku: %00110111 ORA Maske: %10000000 ========= Akku: %10110111 |
Voiala, wir haben das Zeichen 183, das der invertierten Darstellung der entspricht.
|
1 2 3 4 5 6 7 |
sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern und gleich nochmal, da dey ;wir nur jedes 2. Zeichen invertieren wollen bne loop_ora ;solange nicht 0 wieder zum loop_ora springen rts ;Zurück zum BASIC |
Anschließend schreiben wir den geänderten Akku-Inhalt wieder zurück an unsere Position auf dem BS, verringern das Y-Register zweimal fürs übernächste Zeichen und springen solange zu loop_ora zurück, bis das Z-Flag gesetzt ist. Zum Ende gehts zurück ins Basic.
Nach einem Start sollte euer BS ungefähr so aussehen:
Nun wollen wir unsere Invertierung wieder rückgängig machen. Dazu verwenden wir diesmal die Möglichkeit aus Basic heraus direkt an die gewünschte Stelle in unserem Programm zuspringen. Vom Prinzip her machen wir das schon bei jedem Programmstart. Unsere Programme beginnen bekanntlich mit der Zeile: 2018 SYS 2062
Diesen SYS-Befehl können wir natürlich auch direkt eingeben, also statt RUN einfach SYS 2062. Ändern wir unser Programm und probieren es mal.
Und
Gebt bitte am Sourcebeginn, hinter ORAMASK , eine neue Variable ein:
|
1 |
ANDMASK = %01111111 |
Fügt dann hinter unser bisheriges Programm (Ausschnitt ist unten zur Orientierung markiert), die nächsten Zeilen ein:
|
1 2 3 4 5 6 7 8 9 10 |
... bne loop_ora ;solange nicht 0 wieder zum loop_ora springen rts ;Zurück zum BASIC *=$1000 ;(4096) ldy #$f0 ;wieder nur die ersten 240 Zeichen loop_and lda SCREENRAM,y ;Zeichen in den Akku |
Etwas irritiert könntet ihr jetzt durch *=$1000 sein. Eigentlich benutzen wir dies ja, um die Startadresse für unser Programm festzulegen (bisher fast immer *=$0801). Auch wenn es nicht wirklich benötigt wird, teilen wir hier dem Assembler mit, dass die nächsten Befehle an der Speicherstelle $1000 oder 4096 dezimal beginnen sollen. Falls ihr neue Adressen angebt, passt besser auf, dass sich diese nicht überschneiden. Das C64 Studio wirft einen Fehler, sollte dies der Fall sein. Bei ACME gibt es eine Warnung, die ja unterdrückt werden können. Der Turbo Assembler nimmt eure Angabe ohne weitere Hinweise / Warnungen an. Wir benutzen dies nur um eine schönere Einsprungadresse für unsere neue Funktion zu erhalten.
|
1 |
and #ANDMASK ;UND-Verknüpfung des Akkus mit mit unserer Maske |
AND: AND with Accumulator (bitweises UND mit dem Akku)
AND Akku ($29, 2B, 2T, NZ)
Auch wenn wir das
AND schon hatten, wiederhole das hier der Vollständigkeit nochmal. Wir führen jetzt mit
AND eine bitweise UND-Verknüpfung mit dem Akku und unserer
ANDMASK durch. Das Ergebnis landet dann wieder im Akkumulator. Ist das Ergebnis Null, dann wird das Zero-Flag gesetzt, sollte Bit-7 auf 1 stehen, dann wird das N-Flag gesetzt.
Beim
AND wird ein Bit immer dann zu 1, wenn das erste und das zweite Bit eine 1 aufweist:
|
1 2 3 4 |
%0101 AND %0011 ===== %0001 |
AND verwenden wir, um gezielt einzelne Bits zu löschen, dazu läßt man in seiner Maske alle Bits, die man nicht ändern möchte auf 1 und setzt nur die Bits auf 0, die man auf jeden Fall löschen will. Daher ist in unserer Maske nur Bit-7 auf 0 gesetzt worden, alle Anderen sind 1.
Und jetzt nochmal für unser invertiertes Zeichen , wenn es im Akku liegt:
|
1 2 3 4 5 |
Akku: %10110111 AND Maske: %01111111 ========= Akku: %00110111 |
Schon haben wir wieder das Zeichen 55, das der normalen Darstellung der 7 entspricht.
|
1 2 3 4 5 6 |
sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern (jetzt nur einmal) bne loop_and ;solange nicht 0 wieder zum loop_and springen rts ;Zurück zum BASIC |
Der Rest entspricht dem Block von eben, nur das wir hier einfach mal alle 240 Zeichen anfassen. Es gibt absichtlich nur ein dey, um zu zeigen, dass sich wirklich nur unsere invertierten Zeilen ändern.
Wenn ihr das Progamm nun startet, gibt es zunächst keinen Unterschied zu eben. Gebt jetzt aber mal SYS 4096 ein, drückt RETURN und schon ist die Invertierung verschwunden. Wir springen damit direkt zum Beginn unserer neuen Routine, die ja hinter *=$1000 beginnt. Mit RUN könnt ihr natürlich wieder die Invertierung vornehmen.
Exklusives Oder
Abschließend möchten wir jetzt unsere Invertierung invertieren 😉 . Wir wollen also innerhalb der ersten 240 Zeichen alle normalen invertiert darstellen und alle invertierten normal. Dazu könnten wir in unserer Schleife, das in den Akku geladene Zeichen prüfen und dann zur jeweiligen Verknüpfung springen.
Die Routine würde dann so aussehen (bitte am Programmende einfügen!):
|
1 2 3 4 5 6 |
*=$2000 ;(8192) ;*** Start des Assemblerprogrammes ldy #$f0 ;die ersten 240 Zeichen loop_onoff lda SCREENRAM,y ;Zeichen in den Akku und |
Bis auf unsere neue Startadresse *=$2000 ist alles wie gehabt.
|
1 |
bmi donormal ;wenn Bit-7 (Invers) gesetzt ist, zu donormal: springen |
BMI: Branch if MInus (springe wenn Minus)
BMI relativ ($30, 2B, 2-4T, <keine>)
Mit
BMI verzweigen wir zur angegebenen Adresse, wenn nach der letzten Aktion das „Minuszeichen“ gesetzt ist. Es wird also einfach geprüft, ob das Negativ-Flag = 1 ist. Wie von den anderen bedingten Sprüngen gewohnt, werden 2 Taktzyklen benötigt, wenn nicht gesprungen wird, 3TZ beim Sprung und sogar 4TZ falls der Sprung über eine Pagegrenze geht.
Wir überprüfen hier unser eben in den Akku geladenes Zeichen. Ist es bereits invertiert, dann ist das Bit-7 ja gesetzt und wir springen zu
donormal, um die Invertierung aufzuheben, wenn es aktuell nicht invertiert ist invertieren wir es mit dem nächsten Befehl…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
ora #ORAMASK ;sonst ODER-Verknüpfung für Invers jmp charout ;weiter zur Ausgabe donormal and #ANDMASK ;UND-Verknüpfung für 'normal' charout sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern bne loop_onoff ;solange nicht 0 wieder zum loop_onoff springen rts ;Zurück zum BASIC |
Wenn wir invertieren mussten, springen wir nach dem ORA direkt zu charout, müssen wir die Invertierung aufheben, landen wir nach dem BMI bei donormal und löschen mit dem AND unsere Invertierung. Anschließen wird das Zeichen wieder ausgegeben usw. (alles wieder wie eben).
Startet das Programm und es erscheint wieder unsere gestreifte Darstellung. Mit SYS 4096 könnt ihr diese wieder rückgängig machen. Gebt ihr nach dem RUN aber die Startadresse SYS 8192 ein, wird der obere Bereich des Bildschrims inveriert. Bei jedem Aufruf (einfach mit dem Cursor wieder auf den SYS-Befehl gehen und RETURN drücken) ändert sich unsere Anzeige. Probiert das ruhig mal mit der gestreiften und der blanken Darstellung (nach SYS 4096) aus.
OK, dass habe ich jetzt nur eingebaut, um mal den BMI-Befehl zu verwenden und nochmal zu zeigen, dass es viele Lösungsmöglichkeiten gibt. Wir können das Problem auch viel eleganter lösen. Es gibt nämlich einen Befehl, der es uns ermöglicht die Umschaltung zwischen invertiert und normal automatisch vorzunehmen. Gebt die nächsten Zeilen direkt hinter dem Block mit dem BMI-Befehl von eben, also wieder am Ende unseres Sourcecodes ein.
|
1 2 3 4 5 6 |
;(8213) start_eor ldy #$f0 ;die ersten 240 Zeichen durchgehen loop_eor lda SCREENRAM,y ;Zeichen in den Akku |
Dieses Mal verzichten wir auf eine neue Startadresse, daher ist es sehr wichtig, dass die vorherige Routine unverändert von euch übernommen wurde, sonst stimmt die im Kommentar ;(8213) angezeigte Startadresse nicht! Der Rest ist mittlerweile kalter Kaffee für uns.
|
1 |
eor #ORAMASK ;Exklusiv-ODER-Verknüpfung Akku mit mit unserer Maske |
EOR: Exclusiv OR with Accumulator (bitweises exklusives ODER mit dem Akku)
EOR Akku ($49, 2B, 2T, NZ)
Wow, etwas ganz exklusives…
EOR arbeitet fast wie
ORA. Wir verwenden hier auch unsere ORAMASK und das Ergebnis landet wieder im Akku. Ist das Ergebnis negativ (also Bit-7 gesetzt), dann wird das Negativ-Flag gesetzt, sollte das Ergebnis Null sein, wird das Z-Flag gesetzt.
Beim
EOR wird ein Bit nur dann zu 1, wenn ausschließlich das erste oder das zweite Bit eine 1 aufweist:
|
1 2 3 4 |
%0101 EOR %0011 ===== %0110 |
EOR wird häufig zum Umschalten von einzelnen Bits verwendet. Dazu setzen wir in unserer Maske alle Bits, die Umgeschaltet werden sollen auf 1 und die anderen auf 0.
Für unser Zeichen 7 im Akku, sähe das dann so aus:
|
1 2 3 4 5 6 7 8 9 |
Akku: %00110111 EOR Maske: %10000000 ========= Akku: %10110111 nächstes EOR Maske: %10000000 ========= Akku: %00110111 |
Wie ihr seht, schalten wir mit jedem EOR immer das 7-Bit um, die anderen bleiben unverändert.
|
1 2 3 4 5 |
sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern bne loop_eor ;solange nicht 0 wieder zum loop_eor springen jmp start_eor ;für Endlosschleife zu start_eor springen |
Wir fabrizieren hier eine Endlosschleife (also obacht beim Start, ggf. vorher speichern), um mal wieder unsere Anfälligkeit für schnelle Bildwechsel zu prüfen.
Zur Sicherheit hier wieder das komplette Programm:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
;*** Variablen SCREENRAM = $03ff ;Start des Bildschirmspeichers ORAMASK = %10000000 ANDMASK = %01111111 ;*** Startadresse BASIC-Zeile *=$0801 !byte $0c,$08,$e2,$07,$9e,$20,$32,$30,$36,$32,$00,$00,$00 ;*** Start des Assemblerprogrammes ldy #$f0 ;die ersten 240 Zeichen loop_ora lda SCREENRAM,y ;Zeichen in den Akku ora #ORAMASK ;ODER-Verknüpfung des Akkus mit mit unserer Maske sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern und gleich nochmal, da dey ;wir nur jedes 2. Zeichen invertieren wollen bne loop_ora ;solange nicht 0 wieder zum loop_ora springen rts ;Zurück zum BASIC *=$1000 ;(4096) ldy #$f0 ;wieder nur die ersten 240 Zeichen loop_and lda SCREENRAM,y ;Zeichen in den Akku and #ANDMASK ;UND-Verknüpfung des Akkus mit mit unserer Maske sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern (jetzt nur einmal) bne loop_and ;solange nicht 0 wieder zum loop_and springen rts ;Zurück zum BASIC *=$2000 ;(8192) ;*** Start des Assemblerprogrammes ldy #$f0 ;die ersten 240 Zeichen loop_onoff lda SCREENRAM,y ;Zeichen in den Akku und bmi donormal ;wenn Bit-7 (Invers) gesetzt ist, zu donormal: springen ora #ORAMASK ;sonst ODER-Verknüpfung für Invers jmp charout ;weiter zur Ausgabe donormal and #ANDMASK ;UND-Verknüpfung für 'normal' charout sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern bne loop_onoff ;solange nicht 0 wieder zum loop_onoff springen rts ;Zurück zum BASIC ;(8213) start_eor ldy #$f0 ;die ersten 240 Zeichen durchgehen loop_eor lda SCREENRAM,y ;Zeichen in den Akku eor #ORAMASK ;Exklusiv-ODER-Verknüpfung Akku mit mit unserer Maske sta SCREENRAM,y ;Zeichen auf der 1. Page des BS-Speichers ausgeben dey ;Y-Register verringern bne loop_eor ;solange nicht 0 wieder zum loop_eor springen jmp start_eor ;für Endlosschleife zu start_eor springen |
Ein Start zeigt unser Streifenmuster, mit SYS 8213 springt ihr aber in die Endlosschleife mit dem EOR-Befehl und alles flackert…
Eine Bemerkung am Rande, wenn ihr jetzt einen RESET (z. B. mit ALT+R bei Vice) auslöst und dann SYS 8213 eingebt. Läuft unser Programm wieder an. Also merke, der Speicher wird bei einem RESET nicht gelöscht / initialisiert (jedenfalls nicht alles, Teilbereiche werden schon verändert!).
Wer sich die Boolsche Algebra angesehen hat, der fragt sich jetzt bestimmt wo denn der NOT-Befehl bleibt. Den gibt es zwar unter BASIC, aber nicht im Assembler. Macht noch ein paar Übungen mit den drei boolschen Befehlen und ihr kommt sicher auf die Lösung. Hilfreich könnte es evtl. sein, unser Programm aus dem letzten Beitrag Mit dem Rechner rechnen so anzupassen, dass auch die boolschen Befehle getestet werden können.
Weitere Adressierungsarten
Es folgt wieder die endlos erscheinende Liste, der alternativen Adressierungsarten. Da AND, ORA und EOR identische Adressierungsarten besitzen, werden die jeweils am Stück behandelt.
|
1 |
ora $0821 |
ORA absolut ($0D, 3B, 4T, NZ)
|
1 |
and $0821 |
AND absolut ($2D, 3B, 4T, NZ)
|
1 |
eor $0821 |
EOR absolut ($4D, 3B, 4T, NZ)
Eine Verknüpfung mit dem Akku und dem Byte, dass an der absoluten Adresse zu finden ist.
|
1 |
ora $0821,x |
ORA absolut X-indiziert ($1D, 3B, 4-5T, NZ)
|
1 |
and $0821,x |
AND absolut X-indiziert ($3D, 3B, 4-5T, NZ)
|
1 |
eor $0821,x |
EOR absolut X-indiziert ($5D, 3B, 4-5T, NZ)
Eine Verknüpfung mit dem Akku und dem Byte, dass an der absoluten Adresse plus dem X-Register zu finden ist. Beim überschreiten einer Page-Grenze wird ein extra Taktzyklus fällig.
|
1 |
ora $0821,y |
ORA absolut Y-indiziert ($19, 3B, 4-5T, NZ)
|
1 |
and $0821,y |
AND absolut Y-indiziert ($39, 3B, 4-5T, NZ)
|
1 |
eor $0821,y |
EOR absolut Y-indiziert ($59, 3B, 4-5T, NZ)
Wie eben, nur mit dem Y-Register.
|
1 |
ora $fb |
ORA Zero-Page ($05, 2B, 3T, NZ)
|
1 |
and $fb |
AND Zero-Page ($25, 2B, 3T, NZ)
|
1 |
eor $fb |
EOR Zero-Page ($45, 2B, 3T, NZ)
|
1 |
ora $fb,x |
ORA Zero-Page X-indiziert ($15, 2B, 4T, NZ)
|
1 |
and $fb,x |
AND Zero-Page X-indiziert ($35, 2B, 4T, NZ)
|
1 |
eor $fb,x |
EOR Zero-Page X-indiziert ($55, 2B, 4T, NZ)
|
1 |
ora ($fb,x) |
ORA indirekt X-indiziert ($01, 2B, 6T, NZ)
|
1 |
and ($fb,x) |
AND indirekt X-indiziert ($21, 2B, 6T, NZ)
|
1 |
eor ($fb,x) |
EOR indirekt X-indiziert ($41, 2B, 6T, NZ)
|
1 |
ora ($fb),y |
ORA indirekt Y-nach-indiziert ($11, 2B, 5-6T, NZ)
|
1 |
and ($fb),y |
AND indirekt Y-nach-indiziert ($31, 2B, 5-6T, NZ)
|
1 |
eor ($fb),y |
EOR indirekt Y-nach-indiziert ($51, 2B, 5-6T, NZ)
Bei Überschreitung einer Page-Grenze wird wieder ein extra Takt benötigt.
Abschließend für alle, die immer noch über den fehlenden NOT-Befehl grübeln, hier ist die Lösung (in unser Programm aus Mit dem Rechner rechnen eingebettet):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
CHROUT = $ffd2 ;Jump-Table Adr.: Zeichenausgabe SETCURSOR = $fff0 ;Jump-Table Adr.: get/set cursor pos TEXTADR = $fb ;Zero-Page-Adr. für den Text BINPOS = $05 ;Spalte in der unsere Ausgabe beginnt N1 = %10101010 ;erste Zahl / Maske N2 = %11111111 ;zweite Zahl / Maske ;*** Startadresse BASIC-Zeile *=$0801 !byte $0b,$08,$e2,$07,$9e,$20,$32,$30,$36,$32,$00,$00, $00 ;*** Start des Assemblerprogrammes cld ;D-Flag zur Sicherheit löschen jsr showmask ;Hauptmaske anzeigen lda #$05 ;#$01 = Addition | #$02 = Subtraktion | ;#$03 = AND | #$04 = ORA | #$05 = EOR jsr showoperator ;Operant anzeigen ;*** rechnen lda #N1 ;1. Zahl in den Akku eor #N2 ;Durch eine Maske mit lauter einsen, erreichen wir ;beim eor dass, was sonst mit NOT geschieht: ;1 wird 0 und 0 wird 1 jsr result ;Ergebnis ausgeben rts ;zurück zum BASIC ;************************************************************ ;*** Das Ergebnis ausgeben ;************************************************************ ;*** Übergabe: A = Ergebnis der Operation ;************************************************************ ;*** Rückgabe: - ;************************************************************ ;*** ändert: A,X,Y,SR ;************************************************************ result php ;Flags für Anzeige auf den Stack ;*** Ergebnis im Akku ausgeben ldx #$0b ldy #BINPOS jsr binaryout ;*** Flags ausgeben pla ldx #$0b ldy #BINPOS+10 jsr binaryout rts ;************************************************************ ;*** Operator ausgeben ;************************************************************ ;*** Übergabe: A = Nr. des Operanten ;************************************************************ ;*** Rückgabe: - ;************************************************************ ;*** ändert: X,Y,SR und A (durch Unterprogramme) ;************************************************************ showoperator cmp #$01 bne showoperatornext_1 lda #<textadd sta TEXTADR lda #>textadd sta TEXTADR+1 jmp showoperatortextout showoperatornext_1 cmp #$02 bne showoperatornext_2 lda #<textsub sta TEXTADR lda #>textsub sta TEXTADR+1 jmp showoperatortextout showoperatornext_2 cmp #$03 bne showoperatornext_3 lda #<textand sta TEXTADR lda #>textand sta TEXTADR+1 jmp showoperatortextout showoperatornext_3 cmp #$04 bne showoperatornext_4 lda #<textora sta TEXTADR lda #>textora sta TEXTADR+1 jmp showoperatortextout showoperatornext_4 cmp #$05 bne showoperatornext_5 lda #<texteor sta TEXTADR lda #>texteor sta TEXTADR+1 jmp showoperatortextout showoperatornext_5 rts showoperatortextout ldx #$09 ldy #$01 jsr textout rts ;************************************************************ ;*** Unsere Maske ausgeben ;************************************************************ ;*** Übergabe: - ;************************************************************ ;*** Rückgabe: - ;************************************************************ ;*** ändert: A,X,Y,SR ;************************************************************ showmask ;BS löschen lda #$93 jsr CHROUT ;1. Zahl ausgeben lda #N1 ldx #$08 ldy #BINPOS jsr binaryout ;2. Zahl ausgeben lda #N2 ldx #$09 ldy #BINPOS jsr binaryout ;Überschrift für Flags lda #<textflags sta TEXTADR lda #>textflags sta TEXTADR+1 ldx #$0a ldy #BINPOS+11 jsr textout ;========= ausgeben lda #<textline sta TEXTADR lda #>textline sta TEXTADR+1 ldx #$0a ldy #BINPOS jsr textout rts ;************************************************************ ;*** Beliebigen Text ausgeben (null-terminiert) ;************************************************************ ;*** Übergabe: X = Zeile in der die Ausgabe beginnt ;*** Y = Spalte in der die Ausgabe beginnt ;*** TEXTADR = An dieser Zero-Page-Adresse wird die ;*** Adresse des Textes erwartet. ;*** Das Textende wird durch $00 gekennzeichnet! ;************************************************************ ;*** Rückgabe: - ;************************************************************ ;*** ändert: A,X,Y,SR ;************************************************************ textout clc ;C=0 für set / C=1 für get Cursor jsr SETCURSOR ;Jump-Table: get/set cursor ldy #$00 ;Pos. im Text textcharin lda (TEXTADR),Y ;Aktuelles Zeichen in den Akku laden beq textdone ;wenn 0 dann sind wir fertig jsr CHROUT ;Jump-Table: Zeichenausgeben iny ;X erhöhen, für nächstes Zeichen jmp textcharin ;und wieder hochspringen textdone ;Ziel, sobald wir eine 0 haben rts ;zurück zum Aufrufer (jsr textout) ;*** unsere Texte textadd !text " +" !byte $00 textsub !text " -" !byte $00 textand !text "AND" !byte $00 textora !text "ORA" !byte $00 texteor !text "EOR" !byte $00 textflags !text "NV-BDIZC" !byte $00 textline !text "=========" !byte $00 ;************************************************************ ;*** Den Inhalt des Akkus als Binärzahl auf dem BS ausgeben ;************************************************************ ;*** Übergabe: A = Zahl, die ausgegeben wird ;*** X = Zeile in der die Ausgabe beginnt ;*** Y = Spalte in der die Ausgabe beginnt ;************************************************************ ;*** Rückgabe: - ;************************************************************ ;*** ändert: X,Y,SR ;************************************************************ binaryout pha ;Akku auf dem Stack merken (wg. SETCURSOR) clc ;C=0 für set / C=1 für get Cursor jsr SETCURSOR ;Jump-Table: get/set cursor lda #"%" ;Prozent-Zeichen in den Akku jsr CHROUT ;und ausgeben pla ;Akku wieder vom Stack holen pha ;und direkt nochmal merken (für Rücksprung) ldy #$07 ;Schleife rückwärts von Bit 7-0 binoutloop ldx #"0" ;Zeichen "0" ins X-Register asl ;Akku nach <-links verschieben bcc out ;Wenn es eine 0 ist, direkt zur Ausgabe, inx ;sonst erhöhen, damit wir eine 1 haben. out ;Sprungziel, wenn wir eine 0 haben pha ;Akku merken, wird überschrieben (CHROUT) txa ;X -> Akku; Zeichen in den Akku jsr CHROUT ;Jump-Table: Zeichenausgeben pla ;Akku fürs nächste Bit wiederholen dey ;Schleife runterzählen bpl binoutloop ;bis 8-Bit verarbeitet sind -> binoutloop pla ;sonst, den Akku wiederherstellen rts ;und zurück zum Aufrufer (jsr binaryout) ;************************************************************ ;*** Den Inhalt des Akkus als Hexzahl auf dem BS ausgeben ;************************************************************ ;*** Übergabe: A = Zahl, die ausgegeben wird ;*** X = Zeile in der die Ausgabe beginnt ;*** Y = Spalte in der die Ausgabe beginnt ;************************************************************ ;*** Rückgabe: - ;************************************************************ ;*** ändert: X,Y,SR ;************************************************************ hexout pha ;Akku auf dem Stack merken (wg. SETCURSOR) clc ;C=0 für set / C=1 für get Cursor jsr SETCURSOR ;Jump-Table: get/set cursor lda #"$" ;Dollar-Zeichen in den Akku jsr CHROUT ;und ausgeben pla ;Akku wiederherstellen pha ;und merken bis zum Rücksprung pha ;gleich nochmal wg. LSR und CHROUT lsr ;jetzt msb -> ins lsb verschieben lsr ;dafür 4* LSR lsr lsr tax ;Akku ins X-Register, lda possiblehexchars,x ;das Zeichen fürs obere Nibble holen jsr CHROUT ;und auszugeben pla ;Akku vom Stack holen and #$0F ;oberes Nibble ausmaskieren tax ;Akku wieder nach X lda possiblehexchars,x ;das Zeichen fürs untere Nibble holen jsr CHROUT ;und wieder ausgeben pla ;Ursprünglichen Akkuwert vom Stack holen rts ;und zurück zum Aufrufer (jsr hexout) ;*** die Hex-Ziffern possiblehexchars !text "0123456789ABCDEF" |
Beachtet beim Turbo Assembler wieder, die Besonderheiten, z. B. max. 15 Zeichen für die Label und keine Unterstriche!
(10 Bewertungen | Ø 4,50 von 5 | 90,00%)
Loading...
