zurück : weiter : inhalt =
 
 

5.3 ** Vector-Aufrufe

 

Alphabetische Übersicht (MINERVA-Vectoren klein geschrieben):

S NUR im Supervisor-Betrieb und NICHT aus Interrupt- Routine heraus,
U NICHT im Supervisor-Betrieb aufzurufen.
F intern supervisor mit erzwungener Rückkehr in den user-Modus
+ Vectoren ab $124 gelten mit $4000(An).
 
BP - BV
bp.chan $140 + Kanalnummer holen, Vorgabe #1
bp.chand $142 + dto., Vorgabe wählbar
bp.chnew $146 + neuen Basic-Kanal aufmachen
bp.chnid $144 + Kanal-ID überprüfen
bp.fname $148 + Parameter als Filenamen holen
BP.INIT $110 Einfügen neuer Basic-Befehle
BP.LET $120 Variablenzuweisung
BV.CHRIX $11A Speicherzuweisung im Rechnerstack
 
CA - CN
CA.GTFP $114 f.p.-Zahl holen
CA.GTINT $112 16-Bit-Ganzzahl holen
CA.GTLIN $118 32-Bit-Ganzzahl holen
CA.GTSTR $116 Zeichenkette holen
ca.cnvrt $14a + Datentyp umwandeln
ca.eval $14e + (der Sinn bleibt dunkel)
ca.opexe $14c + (dto.) 
CN.BTOIB $104 ASCII nach Binär, 8-Bit-Zahl
CN.BTOIL $108 dto., 32-Bit
CN.BTOIW $106 dto., 16-Bit
  CN.DATE $0EC Datum in sec als 32-Bit-Zahl 
CN.DAY $0EE Wochentag
CN.DTOF $100  ASCII nach f.p.-Zahl
CN.DTOI  $102 dto., 16-Bit
CN.FTOD $0F0 f.p. nach ASCII
CN.HTOIB $10A ASCII nach sedecimal, 8-Bit-Zahl 
CN.HTOIL $10E dto., 32-Bit
CN.HTOIW $10C dto., 16-Bit
CN.ITOBB $0F4 binär nach ASCII, 8-Bit-Zahl
CN.ITOBL $0F8 dto., 32-Bit
CN.ITOBW $0F6  dto., 16-Bit
CN.ITOD $0F2 16-Bit-Ganzzahl nach ASCII
CN.ITOHB  $0FA sedecimal nach ASCII, 8-Bit-Zahl
CN.ITOHL $0FE dto., 32-Bit
CN.ITOHW $0FC dto., 16-Bit 
 
GO
go.new $13e + NEW ausführen
 
IO - IP
IO.NAME $122 Analyse eines Devicenamen 
IO.QEOF $0E4 Queue EOF markieren
IO.QIN $0E0 Byte in Queue ablegen
IO.QOUT $0E2 Byte einer Queue entnehmen
IO.QSET $0DC Queue einrichten, Länge D1.W
io.qsetl $16c Qeue einrichten, Läge D1.L
IO.QTEST $0DE Status einer Queue prüfen
IO.SERIO $0EA S Allgemeine I/O-Bearbeitung
IO.SERQ $0EB S Direkte Queue-Bearbeitung 
ip.kbend $152 S + abschließende Tastatur-Auswertung
ip.kbrd $150 S + Tastatur lesen
 
MD - MI - MM
MD.READ $124 + einen Sector lesen
MD.SECTR $12A + Sectorheader lesen
MD.VERIN $128 + Sector kontrollieren
MD.WRITE $126 + einen Sector schreiben
MM.ALCHP $0C0 S Common Heap-Zuweisung
mm.aclr $168 + Speicherbereich löschen
MM.ALLOC $0D8 Heap-Bereich reservieren
MM.LNKFR $0DA Speicher an Heap zurückgeben
mm.move $158 + Speichertransfer absolut
mm.mrtoa $15a U F + dto., rel nach abs
mm.mator $15c U F + dto., abs nach rel
mm.rclr $16a U F + Speicherbereich relA6 löschen
mm.mrtor $15e U F + dto., rel nach rel
MM.RECHP $0C2 S Bereich des Common Heap freigeben
 
RI
RI.EXEC $11C eine Rechneroperation ausführen
RI.EXECB $11E Rechneroperationen ausführen
 
SB
sb.start $154 + Basic-Job starten
 
UT
UT.CON $0C6 Consolfenster einrichten
UT.CSTR $0E6 zwei Strings vergleichen
UT.ERR0 $0CA Fehlermeldung an Kanal 0 oder 1
UT.ERR $0CC dto., an beliebigen Kanal
ut.istr $13c +  INSTR-Operation ausführen
UT.LINK $0D2 Posten in Liste einfügen
UT.MINT $0CE Integer nach ASCII
UT.MTEXT $0D0 einen Text ausgeben
UT.SCR $0C8 Bildschirmfenster einrichten
UT.UNLNK $0D4 Listenelement entfernen
UT.WINDW $0C4 Fenster beliebiger Art einrichten
v.vres $170 S + Kaltstart (undokumentiert)
v.mres $172 S + Kaltstart ohne Speichertest (undokumentiert)
 

 

Die Namen für SQ nach {15}:
 

BI.INIPR $0110 CV.IBBIN $00F4 MEM.ALHP $00D8
BI.SPRM $0120 CV.IBHEX $00FA MEM.AUHP $00D8
CA.FLOAT $08 CV.ILBIN $00F8 MEM.LLST $00D2
CA.INT  $04 CV.ILDAT $00EC MEM.RCHP $00C2
CA.MOP $011E CV.ILDAY $00EE MEM.REHP $00DA
CA.NINT $02 CV.ILHEX $00FE MEM.RLST $00D4
CA.NLINT $06 CV.IWBIN $00F6 MEM.RUHP $00DA
CA.OP $011C CV.IWDEC $00F2 OPW.CON $00C6
CV.BINIB $0104 CV.IWHEX $00FC OPW.SCR $00C8
CV.BINIL $0108 IOQ.GBYT $00E2 OPW.WIND $00C4
CV.BINIW $0106 IOQ.PBYT $00E0 UT.WERMS $00CC
CV.DECFP $0100 IOQ.SEOF $00E4 UT.WERSY $00CA 
CV.DECIW $0102 IOQ.SETQ  $00DC UT.WINT  $00CE
CV.HEXIB $010A IOQ.TEST $00DE UT.WTEXT $00D0
CV.HEXIL $010E IOU.DNAM $0122 CV.HEXIW $010C
MEM.ACHP $00C0
 

 


 
mem.achp MM.ALCHP sm 192 $0C0
Speicherzuweisung im Heap
  IN:   OUT:  
D1 benötigter Platz D1 zugeteilter Platz
D2, D3 verdorben
A0 Basisadresse
A1 - A3 verdorben
A6 Sysvari A6 NUR nach {15}: verdorben
 
ERR.OM -3 (nur D0, nicht Flags)
Die Anforderung muß mindestens 16 Bytes für einfache Definitionen oder 24 Bytes für IOSS Kanäle umfassen. In A0 kehrt die Adresse des Headers zurück, nicht die des freien Bereichs. Der freie Block wird gelöscht.


 
mem.rchp MM.RECHP sm 194 $0C2
Rückgabe einer Heap-Zuweisung 
  IN:   OUT:  
D1 - D3 verdorben
A0 Anfang des Speicherblocks A0 - A3 verdorben
A6 NUR nach {15}: verdorben
 

 
opw.wind UT.WINDW st 196 $0C4
Fenster mit angegebenem Namen einrichten 
  IN:   OUT:  
D1 - D3 verdorben
A0 Ptr auf Namen A0 Kanal ID
A1 Ptr auf Parameterblock A1 - A3 verdorben
 
ERR.BN -12
ERR.OM -3
ERR.NO -6
ERR.OR -4 (Fenster in Standardmaßen geöffnet, A0 gültig)
A1 zeigt auf 4 Parameterbytes für Farben und Breite:
00(A1) Border
01(A1) Breite
02(A1) Paper, zugleich Strip
03(A1) Ink

 
opw.con UT.CON st 198 $0C6
Consolfenster nach Parametertabelle einrichten 
opw.scr UT.SCR st  200 $0C8
Richtet ein Bildschirmfenster vom SCR-Typen ein
  IN:   OUT:  
D1 - D3 verdorben
A0 Kanal ID
A1 Ptr auf Parameterblock A1 - A3 verdorben
 
ERR.OM -3
ERR.NO -6
ERR.OR -4 (Fenster in Standardmaßen geöffnet, A0 gültig)
A1 zeigt auf 4 Parameterbytes für Farben und Breite:
00(A1) .b Borderfarbe
01(A1) .b Borderbreite
02(A1) .b Papier, zugleich Strip
03(A1) .b Ink
04(A1) .w Fensterbreite
06(A1) .w Fensterhöhe
08(A1) .w X-Ursprung
0A(A1) .w Y-Ursprung

 
ut.wersy UT.ERR0 st  202 $0CA
Schreibt Fehlermeldung in Kanal mit ID $00000000
ut.werms UT.ERR st 204 $0CC
Schreibt Fehlermeldung in angegebenen Kanal
  IN:   OUT:  
D0 Fehlercode oder Adresse
A0 UT.ERR: Kanal ID
 
Gelegentlich keine oder fehlerhafte Ausgabe. Hierzu s. UT.MTEXT.
 

 
ut.wint UT.MINT st 206 $0CE
Ganzzahl in ASCII-Zeichen gewandelt in einen Kanal schreiben
  IN:   OUT:  
D1.W Ganzzahl  D1, D2 verdorben
D3 -1 (wenn A0<>0, sonst =0)
A0 Kanal-ID
A1 - A3 verdorben
 
ERR.NC -1
ERR.NO -6
ERR.DF -11
Wenn A0 die ID des Kommandokanals enthält und dieser in Gebrauch ist, wird die Ausgabe umgeleitet (s. UT.MTEXT).
 

 
ut.wtext UT.MTEXT st 208 $0D0
Sendet einen Text in einen Kanal 
  IN:   OUT:  
D1, D2 verdorben
D3 0 nach A0 = 0, sonst -1
A0 Kanal ID
A1 Adresse des Textes A1 verdorben
 
ERR.NC -1
ERR.NO -6
ERR.DF -11
Interrupt-Routinen, Routinen im Supervisor-Mode, UT.ERR0 und UT.ERR können UT.MTEXT mit A0=0 aufrufen.
Wenn der Kommandokanal in Gebrauch ist, wird die Ausgabe an einen Kanal mit ID $00010001 geleitet. Existiert der nicht, geht die Fehlermeldung u.U. verloren.


 
mem.list UT.LINK st 210 $0D2
Fügt einen Ptr in eine verkettete Liste ein
mem.rlst UT.UNLNK  st 212 $0D4
Herausnehmen eines Ptr aus einer verketteten Liste 
  IN:   OUT:  
A0 Adr des Ptr
A1 Ptr auf vorangehenden Ptr A1 nachgestellt
 
UT.LINK: Beim ersten Eintrag Platz für 4 Bytes sicherstellen.
UT.UNLK: A1 muß auf den vorangehenden Eintrag zeigen.
 

 
  Nicht definiert   214 $0D6
 

 
mem.alhp MM.ALLOC gu 216 $0D8
Zuweisung eines Blocks im User-Heap 
  IN:   OUT:  
D1 geforderter PLatz D1 zugeteilter Platz
D2 - D3 verdorben
A0 Ptr auf Ptr auf freien Platz A0 Anfang des Blocks
A1 - A3 verdorben
A6 Sysvari 
 
ERR.OM -3 (Flags müssen abgefragt werden)
Im Speicher gelangen an Position
0(A0)  Bereichslänge
4(A0)  zu seiner Adresse relativer Ptr auf den nächsten freien Bereich.
MT.ALLOC ist eine "atomic" Version dieses Vectors.


 
mem.rehp MM.LNKFR gu 218 $0DA
Rückgabe an den User-Heap
  IN:   OUT:  
D1 Länge des Bereiches D1 - D3 verdorben
A0 Adresse des neuen Platzes A0 - A3 verdorben
A1 Ptr auf Ptr auf freien Platz
 
MT.LNKFR ist eine "atomic" Version dieses Vectors.
 

 
ioq.setq IO.QSET gu 220 $0DC
Einrichten einer Queue
  IN:   OUT:  
D1 Pufferlänge < 32768 D1 verdorben (nicht MI, SQ)
A2 Ptr auf Headerposition
A3 verdorben
 
A2 zeigt auf einen verfügbaren Speicherbereich der Größe 16 + Pufferlänge.
 

 
ioq.test IO.QTEST gu 222 $0DE
Status einer Queue lesen 
  IN:   OUT:  
D1 nächstes zu lesendes Byte
D2 freier Platz
A2 Adr des Queue-Headers
A3 verändert
 
ERR.NC -1 Queue ist leer
ERR.EF -10

 
ioq.pbyt IO.QIN gu 224 $0E0
Ein Byte in eine Queue schreiben 
  IN:   OUT:  
D1.B  Datenbyte
A2 Ptr auf Queue-Header
A3 verändert
 
ERR.NC -1 Queue ist voll
EOF weist die Eingabe ab, liefert aber keinen Fehlercode.
Der EOF-Zustand kann durch IO.QTEST oder in Bit #7(A2) geprüft werden.
 

 
ioq.gbyt IO.QOUT gu 226 $0E2
Ein Byte aus der Queue holen 
  IN:   OUT:  
D1.B geholtes Byte
A2 Ptr auf Queue-Header
A3 verändert
 
ERR.NC -1 Queue ist leer
ERR.EF -10
 

 
ioq.seof IO.QEOF gu 228 $0E4
Queue EOF markieren 
  IN:   OUT:  
A2 Ptr auf Queue-Header
 
ERR.NC -1 Queue ist voll

 
ut.cstr UT.CSTR bu 230 $0E6
Vergleichen zweier Strings. rel A6 
  IN:   OUT:  
D0.B Vergleichstyp D0 Ergebnisflag -1,0 oder 1
A0 Adr(A6) des ersten String
A1 Adr(A6) des zweiten String
 
Der Vergleichstyp ist im User Guide beschrieben:
 
0 Zeichen für Zeichen, mit Unterscheidung der Schreibweise
1 wie 0, Schreibweise Groß oder Klein gleichgültig
2 wie 0, Ziffernfolgen werden als Zahlen eingeordnet
3 wie 1, Ziffernfolgen werden als Zahlen eingeordnet
 
Das Ergebnis entspricht dem Vorzeichen der Subtraktion des zweiten vom ersten String bis einschließlich des ersten abweichenden Zeichens.
 

 
iou.ssq IO.SERQ sm 232 $0E8
Direkte I/O-Queue-Bedienung 
iou.ssio IO.SERIO sm 234 $0EA
Allgemeine serielle I/O-Behandlung
  IN:   OUT:  
D0 Op-Code zur Trap #3 D0 Fehlermeldung
D1 Standard IOSS Wert D1 Standard IOSS Wert
D2 Standard IOSS Wert D2 Standard IOSS Wert
D3.W Wartezeit D3 verdorben
A0 Kanal-ID
A1 Standard IOSS Wert A1 Standard IOSS Wert
A2 A2, A3 verdorben
 
ERR.BP -15 Op-Code falsch
Op-Codes in D0:
00 IO.PEND   07 IO.SSTRG
01 IO.FBYTE $46 FS.HEADS 
02 IO.FLINE $47 FS.HEADR
03 IO.FSTRG $48 FS.LOAD
05 IO.SBYTE $49 FS.SAVE
 
IO.SERQ erfordert im Kanaldefinitionsblock:
28(Def.Blockbasis) Adresse einer Eingabe-Queue oder Null,
32(Def.Blockbasis) Adresse einer Ausgabe-Queue oder Null.
IO.SERIO kehrt hinter eine Tabelle aus drei Langwortadressen zurück, in der die Routinen auf anstehende Dateneingabe, zum Holen eines Byte und zum Senden mit ihrer absoluten Adresse verzeichnet sind. Näheres im Abschnitt 3.3.2.3.3.


 
cv.ildat CN.DATE bu 236 $0EC
Datum und Zeit in ASCII wandeln. rel A6 
cv.ilday CN.DAY bu 238 $0EE
Tag als ASCII-String aus dem Datum ermitteln, rel A6
  IN:   OUT:  
D1 QL-Datum in Sekunden D1
A1 Ptr auf Pufferanfang(A6) A1 Ptr auf den String
 
Im Puffer sind 22 Bytes Platz (6 Bytes für CN.DAY) bereitzuhalten.
 

 
cv.fpdec CN.FTOD bu 240 $0F0
Fließkommazahl in ASCII-String wandeln. rel A6
cv.iwdec CN.ITOD bu 242 $0F2
Ganzzahl in ASCII-String. rel A6
cv.ibbin CN.ITOBB bu 244 $0F4
Byte in binären ASCII-String. rel A6
cv.iwbin CN.ITOBW bu 246 $0F6
Wort in binären ASCII-String. rel A6
cv.ilbin CN.ITOBL bu 248 $0F8
Langwort in binären ASCII-String. rel A6
cv.ibhex CN.ITOHB bu 250 $0FA
Byte in Sedezimalen ASCII-String. rel A6
cv.iwhex CN.ITOHW bu  252 $0FC
Wort in Sedezimalen ASCII-String. rel A6
cv.ilhex CN.ITOHL bu 254 $0FE
Langwort in Sedezimalen ASCII-String. rel A6
  IN:   OUT:  
D1 - D3 verdorben
A0 Ptr auf Puffer A0 Ptr zum Puffer
A1 Ptr auf Zahl im RI-Stack A1 Ptr auf Stapel
A2, A3 verdorben
A6 Referenzadresse
 
NOERR
Die Zahl auf 0(A1,A6.L) geht als String nach 0(A0,A6.L).
Nur MINERVA: D1 gibt die Länge des erzeugten String an.
 

 
cv.decfp CN.DTOF bu 256 $100
Dezimaler ASCII String in Fließkommazahl. rel A6
cv.deciw CN.DTOI  bu 258 $102
Dezimaler ASCII String in 16-Bit-Zahl. rel A6
cv.binib CN.BTOIB bu 260 $104
8 Bit binärer ASCII-String in Byte. rel A6
cv.biniw CN.BTOIW bu 262 $106
16 Bit binärer ASCII-String in Wort. rel A6
cv.binil CN.BTOIL bu 264 $108
32 Bit binärer ASCII-String in Langwort. rel A6
cv.hexib CN.HTOIB bu 266 $10A
2 Zeichen sedezimaler ASCII-String in Byte. rel A6
cv.hexiv CN.HTOIW bu  268 $10C
4 Zeichen Sedezimaler ASCII-String in Wort. rel A6
cv.hexil CN.HTOIL bu 270 $10E
8 Zeichen sedezimaler ASCII-String in Langwort. rel A6
  IN:   OUT:  
D1 - D3 verdorben
D7 0 oder Pufferend-Ptr
A0 Ptr auf String im Puffer A0 Ptr zum Puffer
A1 Ptr auf RI-Stack A1 Anfang der Zahl
A2, A3 verdorben
A6 Referenzadresse
 
ERR.XP -17 Umwandlung mißlungen
Bei Fehlern bleiben A0 und A1 unverändert.
Der String auf 0(A0,A6.L) geht als Zahl nach 0(A1,A6.L).
Im Puffer (A1,A6.L) muß ausreichend Platz zum Rechnen sein.
 

 
sb.inipr BP.INIT bp 272 $110
Installieren einer Anzahl Basicerweiterungen. {4.5.2}
  IN:   OUT:  
D2 verdorben - nur nach {2}
A1 Adr der Definitionsliste A1 verdorben
A4 verdorben (?)
 

 
sb.gtint CA.GTINT bp  274 $112
16-Bit-Zahlen Basicparameter holen. {4.5.4.2} rel A6 
sb.gtfp CA.GTFP bp 276 $114
Fließkommazahlen dto. {4.5.4.3} rel A6
sb.gtstr CA.GTSTR bp 278 $116
Strings dto. {4.5.4.5} rel A6
sb.gtlin CA.GTLIN bp  280 $118
Lange Ganzzahl dto. {4.5.4.4} rel A6
  IN:   OUT:  
D1, D2 verdorben
D4, D6 verdorben
D3.W Zahl der geholten Parameter
A0 verdorben
A1 RI-Stack, erster Parameter
A2 verdorben
A3 Ptr Untergrenze Name Table
A5 dto, Obergrenze
A6 Referenzadresse A6 Referenz, u.U. verändert
 
ERR.BP -15
ERR.XP -17
Separatoren-Markierungen der Name-Table werden verdorben.
Der lesende Basic-Job, und im Gefolge evtl. auch die anderen, kann durch den Aufruf seine Lage und die Ptr-Relationen verändern. Allein die Tiefe des RI-Stack bleibt mit Sicherheit erhalten, nicht seine Position.
 

 
qa.resri BV.CHRIX bp 282 $11A
Reserviert Platz im Arithmetikstapel. {4.5.6} rel A6
  IN:   OUT:  
D1 geforderte Anzahl Bytes D1 - D3 verdorben
A1 A1 nur SQ {15}: verdorben (auch ATARI-e, wenn kein Parm angekommen ist)
 
SMSQ ohne Möglichkeit der Fehlerbehandlung
ERR.OM -3 nur nach {15}
ERR.NC -1 bei MINERVA keine Fehlersituation
Nach {4} sind die weiteren Routinen zur Speicherveränderung auch der anderen Bereiche ebenfalls vectorisiert und wie die anderen Vectoren aufzurufen. Obgleich offiziell nicht dokumentiert, greifen allgemein verbreitete Erweiterungen darauf zurück (.B. TK2). Es steht daher zu hoffen, daß sie auch in künftigen Systemen in gleicher Form vorhanden sein werden. Abweichungen im SQ existieren u.a. wegen seiner Natur als Zwischencode compilierenden Systems.

Bei einigen der Aufrufe wird im Rom bereits eine Anzahl Bytes in D1 vorgegeben (s.u.), andere verlangen die Angabe gesondert. Die in {4} angegebenen Vectoren liegen in diesen fällen auf 2 Bytes höherer Adresse. Es wird sinnvoll sein, wo vorhanden, die geforderte Länge in Vielfachen der - systemabhängigen - Zahlen anzugeben, diese also den Rom-Daten zu entnehmen und sie nicht als bekannt vorauszusetzen.

Die Offsets nach {4, 2/92} mit d1.l Bytes und Laufpointer :
 

-2 -2 BV.CHRRX RI Stack 60 Bytes - NUR(?) MINERVA (1.89) bv.rip 88 $58
0 00 BV.CHRIX RI Stack bv.rip 88 $58
4 04 BV.CHBTX Backtrack Stack $0C Bytes bv.btp 72 $48
6 06 BV.CHBTX Backtrack Stack bv.btp 72 $48
10 $0A BV.CHTGX Temp. Graph Stack $04 bv.tgp 80 $50
12 $0C BV.CHTGX Temp. Graph Stack bv.tgp 80 $50
16 $10 BV.CHNTX Name Table $08 bv.ntp 28 $1C
18 $12 BV.CHNTX Name Table bv.ntp 28 $1C
22 $16 BV.CHRTX Return Table $18 (MI) bv.rtp 60 $3c
$16 (MGG)
24 $18 BV.CHRTX Return Table bv.rtp 60 $3c
28 $1C BV.CHBFX Basic-Puffer bv.bfp 4 04
32 $20 BV.CHTKX Token-Liste bv.tkp 12 $0C
36 $24 BV.CHNLX Namen-Liste bv.nlp 36 $24
40 $28 BV.CHVVX Variablenwerte (nicht SQ) bv.vvp 44 $2C
 44 $2C BV.CHCHX Kanaltabelle bv.chp 52 $34
48 $30 BV.CHLNX Zeilennummern (nicht SQ) bv.lnp 68 $44
52 $34 BV.CHPFX Programm bv.pfp 20 $14
 
Die neu angegebenen Vectoren werden aufgerufen
 
move.l #space,d1 geforderte bereichsgröße
move.w $011a,a2 bv.chrix 
jmp ofs(a2) ausführung mit offset dazu 
 


 
qa.op RI.EXEC ar 284 $11C
Führt eine arithmetische Operation aus. {4.5.7} rel A6
qa.mop RI.EXECB ar 286 $11E
Führt eine Gruppe arithmetischer Operationen aus. rel A6
  IN:   OUT:  
D0.W RI.EXEC: RI-Opcode (s.u.)
D7 RI.EXP {1} bis QDOS 1.03 & MINERVA: 0
A1 RI-Stack rel(A6) A1 justiert
A3 RI.EXECB: Codetabelle abs.
A4 Variable rel(A6)
 
ERR.OV -18
Die kleingeschriebenen Op-Codes gelten nur für MINERVA.

Abgekürzt:
tos Top Of Stack, das unmittelbar zugängliche Element,
nos Next On Stack, das danach eingetragene Element.
top Top Of Stack nach einer Operation
 

Name Code Stack Funktion
RI.TERM 00   0 Beendet die Rechenoperationen.
ri.one 01 -6 Constante Eins ablegen
RI.NINT 02 +4 gerundete Integer
ri.zero 03 -6 Constante Null ablegen
RI.INT 04 +4 gekappte Integer
ri.n 05 -6 Byte in f.p.-Zahl -128 bis 127
RI,.NLINT 06 +2 f.p. in gerundete lange Integer 
ri.k 07 -6 (?) s. Handbuch
RI.FLOAT 08 -4 Integer nach f.p.
ri.flong 09 -2 lange Integer nach f.p.
RI.ADD 10 +6 top := tos + nos
RI.SUB 12 +6 top := nos - tos
ri.halve 13  0 top := tos / 2
RI.MULT 14 +6 top := tos * nos
ri.doubl 15  0 top := tos * 2
RI.DIV 16 -6 top := nos / tos
ri.recip 17  0 tos := 1 / tos
RI.ABS 18  0 tos := | tos |
ri.roll 19  0 tos: fp1 fp2 fp3 => tos: fp2 fp3 fp1  (?)
RI.NEG 20  0 tos := - tos 
ri.over 21 -6 tos: fp1 fp2 => tos: fp2 fp1 fp2
RI.DUP 22 -6 tos: fp1 => tos: fp1 fp1
ri.swap 23  0 tos: fp1 fp2 => tos: fp2 fp1
RI.COS 24  0 cosinus
RI.SIN 26  0 sinus
RI.TAN 28  0 tangens
RI.ASIN 30  0 arcus sinus
RI.ACOS 32  0 arcus cosinu
RI.ATAN 34  0 arcus tangens
ri.arg 35 +6 tos, nos: k * cis( arg )
RI.ACOT 36  0 arcus cotangens
ri.mod 37 +6 sqrt( tos^2 + nos°2 )
RI.SQRT 38  0 Quadratwurzel
ri.sqar 39  0 Quadrat
RI.LN 40  0 logarithmus naturalis (braucht ca 60 Bytes RI-Stack!)
RI.LOG10 42  0 lg
RI.EXP 44  0 Exponentialfunktion
ri.power 45 +2 nos(fp) ^ tos(Integer)
RI.POWFP 46 +6 nos ^ tos
 

 
sb.putp BP.LET bp 288 $120
Variable als Parameter neu besetzen {4.5.4.6} rel A6
  IN:   OUT:  
D1 - D3 verdorben
A0 - A2 verdorben
A3 Untergrenze der NameTable
 

 
iou.dnam IO.NAME gu 290 $122
Decodiert einen Devicenamen. {3.3.2.3.3}
  IN:   OUT:  
D1 - D3 verdorben
A0 Ptr auf Namen
A1 - A2 verdorben
A3 Ptr auf Zwischenspeicher
 
Fehlermeldungen in Gestalt justierter Return-Adressen.


 

Alle folgenden Vectoren sind mit Offset $4000 aufzurufen.
Sie sind für SQ sämtlich nicht definiert.
 


 
  MD.READ md 292 $124
Liest einen Sektor vom Microdrive. Offset $4000
  MD.WRITE md 294 $126
Schreibt einen Sektor auf Microdrive. Offset $4000
  MD.VERIN md 296 $128
Vergleicht einen Sektor. Offset $4000
  MD.SECTR md 298 $12A
Liest Sektorheader vom Microdrive. Offset $4000
  IN:   OUT:  
D1 Filenummer 
D2 Blocknummer
D0, D3-D7 verdorben
A0 A0 verdorben
A1 Pufferanfang A1 Pufferende
A2 verdorben
A3 $18020
A4, A5 verdorben
MD.WRITE: (A7) {Filenr .b | Blocknr. .b}
Der Stackpointer wird für die Rückkehr entsprechend justiert:
0(A7) Fehlerausgang; bei MD.SECTR unbrauchbarer Datenträger
2(A7) Ausführung fehlerfrei; bei MD.SECTR: Header-Fehler
4(A7) nur MD.SECTR: Ausführung fehlerfrei.
MD.WRITE geht stets ohne Fehler nach (A7).


 

An den Plätzen $12C bis $013A stehen Vectoren des Basic zur Intialisierung, Syntaxprüfung und der Listenausgabe. Details werden dazu 'offiziell' nicht genannt.
 

Die folgenden Vectoren gelten nur für MINERVA.
 


 
  UT.ISTR   316 $13C
 INSTR-Operation Typ 3 rel A6
  IN:   OUT:  
D1 Position des String
A0 zu suchender String
A1 abzusuchender String
 
D1 =  0 Fehlanzeige,
D1 sonst ab 1 zählende Position, wo der gesuchte String in (A1)+ gefunden wurde.


 
  GO.NEW   318 $13E
NEW-Befehl ausführen
Die "meisten Register" werden verdorben.
 

 
  BP.CHAN   320 $140
Kanalnummer holen, Vorgabe #1 rel A6
  BP.CHAND   322 $142
dto., mit anzugebender Vorgabe rel A6
  IN:   OUT:  
D1 ggf. Kanalnummer D1 Kanalnummer (erhalten)
A0 ID, wenn Kanal existiert
A2 Definitionsblock dazu
A3 Basicparameter A3 angepasst
A5 dto., Obergrenze
 
ERR.NO -6
Erwartet eine Kanalnummer mit '#' als 16-Bit-Zahl oder verwendet die Vorgabe. Diese (bei BP.CHAND) oder Kanal #1 wird dann nach D1.w übergeben.

HINWEIS:
'fast-return' unter unklaren (nicht dokumentierten) Umständen - s. "bp.fname".


 
  BP.CHNID   324 $144
Kanal suchen und ID liefern rel A6
  IN:   OUT:  
D1 Kanalnummer
A0 Kanal-ID
A2 Basic-Definitionsblock
 
ERR.NO -6, bei ungesetztem X-Flag weist A2 über die Kanaltabelle.

 
  BP.CHNEW   326 $146
Neuen Basic-Kanal einbauen rel A6 
  IN:   OUT:  
D1 Kanalnummer D1
A0 Kanal-ID A0
 
ERR.EX -8 wenn der Kanal schon vorhanden war.

 
  BP.FNAME   328 $148
einen String / Variablennamen als Filenamen holen. rel A6
  IN:   OUT:  
A1 RI-Ptr auf den Namen A1
A3 Parameterptr A3 weitergezählt (außer ERR.BP)
A5 Parameterptr, Obergrenze
 
"Fehlermeldungen verschiedener Art."
HINWEIS (minerva 1.89, 1.97, andere ungeprüft):
Für einen QDOS-Vector nicht gerade geistreich (zumal undokumentiert) kehrt der Aufruf nur, wenn keine Parameter vorhanden sind, mit ERR.BP dorthin zurück, was als nächster Stackposten für die Rückkehradresse zur übergeordneten Routine gehalten wird - welche er keineswegs auch wirklich sein muß! Ebenfalls nur dann wird auch A3 nicht justiert.
Einheitliches Abfangen von Parameterfehlern z.B.:
 
    get_fname
                    pea error_exit(pc)
                    move.w bp_fname,a1
                    jsr $4000(a1)
                    addq.l #4,sp
                    bne.s error_exit ? fehler im parameter
                    .. name in ordnung ..
                error_exit
                    .. fehlerbehandlung ..
 

 
  CA.CNVRT   330 $14A
Datentyp wandeln rel A6 
  IN:   OUT:  
D0 geforderter Typ
A1 RI-Stackpointer A1 angepaßt
A5 Parameterptr, Obergrenze
 
ERR.XP -17 Wandlung mißlungen
Für den angeforderten Typ gelten 1, 2 und 3, dazu 4 zur Ermittlung eines Flag vom Wert 0 oder 1.

RI-Stack wird dem erwarteten Typ entsprechend angepaßt.
Der Typ der oberen Eintragung der Namentabelle wird umgewandelt.
Die Eintragung muß im RI-Stack liegen, der Typ in den 4 niederwertigen Bits auf -7(a6,a5.l) mit 0 oder 1 für Strings, 2 für f.p.-Zahlen, 3 für 16-Bit Ganzzahlen.
 


 
  CA.OPEXE   332 $14C
Operator ausführen
  CA.EVAL    334 $14E
Obere Übergabestack-Eintragung/RI-Wert ausrechnen
 
"Ausführung einer monadischen oder dyadischen Operation. Derzeit keine weiteren Angaben ..."
 

 
  IP.KBRD   336 $150
erweiterte KEYROW-Funktion Supervisor-Mode
  IN:   OUT:  
D1 keyrow-Daten D0, D1 verdorben
D2 shift-Daten D2 verdorben
D6 verdorben
A1 verdorben
A2 Tastatur-Queue A2
 
  Bits D1 Funktion Bits D2 Funktion
31..6 belanglos 31 .. 3 belanglos
5 .. 3 7 - Zeilennummer 2  CTRL
2 .. 0 Spaltennummer 1 SHIFT
0 ALT
 
Allgemeines Lesen der Tastatur.
Aufruf zur Darstellung anderer Tastaturen.

Sämtliche möglichen Codes werden empfangen, ggf. doppelte Codes nach ALT (255), diese werden auch von der automatischen Tastenwiederholung erfasst.
 


 
  IP.KBEND   338 $152
Tastenabfrage beenden 
  IN:   OUT:  
D0 - D2 verdorben
D3 übersprungene Poll-Aufrufe
D5 Bit#4 Flag bei gedrückter Taste D5 verdorben
A2 Tastatur-Queue
A3 verdorben
 
Sinnfällig scheint, daß auch dieser Aufruf im SUPERVISOR- Betrieb erfolgen muß. Es gibt aber keinen Hinweis darauf im Handbuch.

Ist zur Anzeige vom Code zur Bedienung fremder Tastaturen aufzurufen, ob eine Taste noch festgehalten wird. Danach sind alle KEYROW-entsprechenden Daten mittels IP.KBENC greifbar.

Nur Bit 4 aus D5 ist auswertbar, 0 bedeutet, daß die letzte Taste freigegeben wurde.


 
  SB.START   340 $154
einen Basic-Job einrichten rel A6 
  IN:   OUT:  
A0 ID des Befehlskanals - Interpreter-Flag
A1 Größe des verfügbaren Speicherbereichs
 
MultiBASIC-Job durch direktes Anspringen - JMP $4000(An).
Das zweite Lang(?)-Wort im Programmspeicher des Jobs muß die Differenz der Job-Basis zu den BASIC-Tabellen (A6) enthalten.
 

 
  MM.MOVE   344 $158
Datentransport im Speicher absolut adressiert
  MM.MRTOA   346 $15A
dto., von relativer an absolute Adresse User-Mode
  MM.MATOR 48 $15C
dto., von absoluter an relative Adresse, User-Mode
  MM.MRTOR   350 $15E
dto., von relativer an relative Adresse, User-Mode
  MM.ACLR   $168
Speicherbereich läschen
  MM.RCLR   $16a
wie MM.ACLR, Bereich an relativer Adresse, User-Mode
  IN:   OUT:  
D0 Null
D1 Anzahl Bytes >0
A0 Zielpointer
A1 Quellenpointer außer MM.ACLR, MM.RCLR
A6 Referenz außer MM.MOVE, MM.ACLR
 
Transport stets "nichtüberschreibend". Auch ungerade Adressen in A0 und A1 sind erlaubt.

Aus dem Basic kann MM.MOVE aufgerufen werden:

10 mm_move=peek_w(344):mm_move=mm_move+16384
20 CALL mm_move,anzahlbytes,2,3,4,5,6,7,zieladresse,quellenadresse
 
  

oben : zurück : weiter : inhalt 

= (count)