back : next : content =
 
 

5.3 ** QDOS Vectors

 

Overview:

S supervisor mode, only, and not from within an interrupt routine,
U user mode, only.
+ vectors $124 and higher should be called offset by $4000.
 
BP - BV
bp.chan $140 + faetch a channel number, default #1
bp.chand $142 + ditto, default selectable
bp.chnew $146 + new SBasic channel open
bp.chnid $144 + channel ID check
bp.fname $148 + fetch parameter as file name
BP.INIT $110 insert new SBasic commands
BP.LET $120 variable values assignation
BV.CHRIX $11A memory allocation im arithmetic stack
 
CA - CN
CA.GTFP $114 fetch f.p. number
CA.GTINT $112 fetch 16-bit integer
CA.GTLIN $118 fetch 32-Bit integer
CA.GTSTR $116 fetch character string
ca.cnvrt $14a + data type conversion
ca.eval $14e + (remains un-clear)
ca.opexe $14c + (ditto) 
CN.BTOIB $104 ASCII to Binary, 8-Bit number
CN.BTOIL $108 ditto, 32-Bit
CN.BTOIW $106 ditto, 16-Bit
  CN.DATE $0EC Date in seconds as 32-Bit integer 
CN.DAY $0EE day of the week
CN.dittoF $100  ASCII to f.p. number
CN.dittoI  $102 ditto, 16-Bit
CN.FTOD $0F0 f.p. to ASCII
CN.HTOIB $10A ASCII to sedecimal, 8-Bit number 
CN.HTOIL $10E ditto, 32-Bit
CN.HTOIW $10C ditto, 16-Bit
CN.ITOBB $0F4 binary to ASCII, 8-Bit number
CN.ITOBL $0F8 ditto, 32-Bit
CN.ITOBW $0F6  ditto, 16-Bit
CN.ITOD $0F2 16-bit integer to ASCII
CN.ITOHB  $0FA sedecimal to ASCII, 8-Bit number
CN.ITOHL $0FE ditto, 32-Bit
CN.ITOHW $0FC ditto, 16-Bit 
 
GO
go.new $13e + NEW execute
 
IO - IP
IO.NAME $122 Analyze e device name 
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
IO.QTEST $0DE Status einer Queue prüfen
IO.SERIO $0EA S general I/O-Bearbeitung
IO.SERQ $0EB S direct Queue-Bearbeitung 
ip.kbend $152 S + final Tastatur-Auswertung
ip.kbrd $150 S + keyboard read
 
MD - MI - MM
MD.READ $124 + a Sector read
MD.SECTR $12A + sector header read
MD.VERIN $128 + Sector verify
MD.WRITE $126 + a Sector write
MM.ALCHP $0C0 S Common heap allocation
MM.ALLOC $0D8 heap area reservieren
MM.LNKFR $0DA memory an Heap zurückgeben
mm.move $158 + memory transfer absolute
mm.mrtoa $15a U +  ditto, rel to abs
mm.mator $15c U + ditto, abs to rel
mm.mrtor $15e U + ditto, rel to rel
MM.RECHP $0C2 S area des Common Heap release
 
RI
RI.EXEC $11C eine arithmetic operation execute
RI.EXECB $11E arithmetic operations execute
 
SB
sb.start $154 + SBasic job start
 
UT
UT.CON $0C6 console window einrichten
UT.CSTR $0E6 two Strings compare
UT.ERR0 $0CA error message an channel 0 or 1
UT.ERR $0CC ditto, an any channel
ut.istr $13c +  INSTR operation execute
UT.LINK $0D2 item in list einfügen
UT.MINT $0CE Integer to ASCII
UT.MTEXT $0D0 a Text ausgeben
UT.SCR $0C8 window einrichten
UT.UNLNK $0D4 list element entfernen
UT.WINDW $0C4 window any Art einrichten
 

 

Die Names for SQ to {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
memory allocation im Heap
  IN:   OUT:  
D1 requested space D1 allocated space
D2, D3 smashed
A0 base address
A1 - A3 smashed
A6 base of system variables A6 NUR to {15}: smashed
 
ERR.OM -3 (nur D0, not Flags)
Die request muß at least 16 Bytes for simple definitions or 24 Bytes for IOSS channels umfassen. In A0 kehrt die address des Headers zurück, not die des free area. Der free Block wird cleared.


 
mem.rchp MM.RECHP sm 194 $0C2
Rückgabe einer heap allocation 
  IN:   OUT:  
D1 - D3 smashed
A0 beginning des memory block A0 - A3 smashed
A6 NUR to {15}: smashed
 

 
opw.wind UT.WINDW st 196 $0C4
window mit angegebenem Names einrichten 
  IN:   OUT:  
D1 - D3 smashed
A0 Ptr to Names A0 channel ID
A1 Ptr to parameter block A1 - A3 smashed
 
ERR.BN -12
ERR.OM -3
ERR.NO -6
ERR.OR -4 (window wird dennoch opened)
A1 points to 4 words for colours and sizes:
00(A1) Border
01(A1) sizes
02(A1) Paper, zugleich Strip
03(A1) Ink

 
opw.con UT.CON st 198 $0C6
console window to parameter table einrichten 
opw.scr UT.SCR st  200 $0C8
Richtet a window of type SCR a
  IN:   OUT:  
D1 - D3 smashed
A0 channel ID
A1 Ptr to parameter block A1 - A3 smashed
 
ERR.OM -3
ERR.NO -6
ERR.OR -4
A1 points to 6 words for colours and sizes:
00(A1) .b border colour
01(A1) .b border width
02(A1) .b paper, zugleich Strip
03(A1) .b Ink
04(A1) .w window width
06(A1) .w window height
08(A1) .w left origin
0A(A1) .w top origin

 
ut.wersy UT.ERR0 st  202 $0CA
Schreibt error message in channel mit ID $00000000
ut.werms UT.ERR st 204 $0CC
Schreibt error message in angegebenen channel
  IN:   OUT:  
D0 error code or address
A0 UT.ERR: channel ID
 
Gelegentlich keine or false output. Hierzu s. UT.MTEXT.
 

 
ut.wint UT.MINT st 206 $0CE
integer in ASCII-Zeichen gewandelt in a channel write
  IN:   OUT:  
D1.W integer  D1, D2 smashed
D3 -1 (if A0<>0, else =0)
A0 channel ID
A1 - A3 smashed
 
ERR.NC -1
ERR.NO -6
ERR.DF -11
if A0 die ID des command channel enthält and dieser in Gebrauch ist, wird die output redirected (s. UT.MTEXT).
 

 
ut.wtext UT.MTEXT st 208 $0D0
sends a Text in a channel 
  IN:   OUT:  
D1, D2 smashed
D3 0 to A0 = 0, else -1
A0 channel ID
A1 address des text A1 smashed
 
ERR.NC -1
ERR.NO -6
ERR.DF -11
interrupt routines, routines im supervisor mode, UT.ERR0 and UT.ERR können UT.MTEXT mit A0=0 aufrufen.
if der command channel in Gebrauch is, wird die output an a channel mit ID $00010001 geleitet. Existiert der not, geht die error message u.U. lost.


 
mem.list UT.LINK st 210 $0D2
Fügt a Ptr in eine linked list a
mem.rlst UT.UNLNK  st 212 $0D4
unlink a Ptr aus einer linked list 
  IN:   OUT:  
A0 Adr des Ptr
A1 Ptr to previous Ptr A1 adjusted
 
UT.LINK: Beim 1st entry space for 4 Bytes sicherstellen.
UT.UNLK: A1 muß to den previous entry zeigen.
 

 
  not defined   214 $0D6
 

 
mem.alhp MM.ALLOC gu 216 $0D8
Zuweisung a Blocks im user heap 
  IN:   OUT:  
D1 requested space D1 allocated space
D2 - D3 smashed
A0 Ptr to Ptr to free space A0 beginning des Blocks
A1 - A3 smashed
A6 base of system variables 
 
ERR.OM -3 (Flags müssen abgefragt werden)
Im memory gelangen an Position
0(A0)  area size
4(A0)  zu seiner address relative Ptr to den next free area.
MT.ALLOC is eine "atomic" Version dieses Vectors.


 
mem.rehp MM.LNKFR gu 218 $0DA
return an den user heap
  IN:   OUT:  
D1 length des area D1 - D3 smashed
A0 address des new space A0 - A3 smashed
A1 Ptr to Ptr to free space
 
MT.LNKFR is eine "atomic" Version dieses Vectors.
 

 
ioq.setq IO.QSET gu 220 $0DC
Einrichten einer Queue
  IN:   OUT:  
D1 buffer length < 32768 D1 smashed (not MI, SQ)
A2 Ptr to header
A3 smashed
 
A2 points to a available memory area der size 16 + buffer length.
 

 
ioq.test IO.QTEST gu 222 $0DE
Status einer Queue read 
  IN:   OUT:  
D1 next zu lesendes Byte
D2 free space
A2 Adr des queue header
A3 changed
 
ERR.NC -1 Queue is leer
ERR.EF -10

 
ioq.pbyt IO.QIN gu 224 $0E0
Ein Byte in eine Queue write 
  IN:   OUT:  
D1.B  data byte
A2 Ptr to queue header
A3 changed
 
ERR.NC -1 Queue is voll
EOF weist die input ab, liefert aber no error code.
Der EOF state can durch IO.QTEST or in Bit #7(A2) geprüft werden.
 

 
ioq.gbyt IO.QOUT gu 226 $0E2
Ein Byte aus der Queue fetch 
  IN:   OUT:  
D1.B fetched Byte
A2 Ptr to queue header
A3 changed
 
ERR.NC -1 Queue is leer
ERR.EF -10
 

 
ioq.seof IO.QEOF gu 228 $0E4
Queue EOF markieren 
  IN:   OUT:  
A2 Ptr to queue header
 
ERR.NC -1 Queue is voll

 
ut.cstr UT.CSTR bu 230 $0E6
Compare of two Strings. rel A6 
  IN:   OUT:  
D0.B type of comparison D0 result flag -1,0 or 1
D1 Standard IOSS value D1 Standard IOSS value
D2 Standard IOSS value D2 Standard IOSS value
D3.W timeout D3 smashed
A0 channel ID
A1 Standard IOSS value A1 Standard IOSS value
A2 A2, A3 smashed
 
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 requires im channel definition block:
28(cdt) address einer input queue or Null,
32(cdt) address einer output queue or Null.
IO.SERIO kehrt hinter eine table aus three lonword addresses zurück, in der die routines to pending data input, zum fetching a Byte and zum Senden mit ihrer absolute address verzeichnet sind. re to im Abschnitt 3.3.2.3.3.


 
cv.ildat CN.DATE bu 236 $0EC
Datum and time in ASCII convert. rel A6 
cv.ilday CN.DAY bu 238 $0EE
Tag as ASCII String aus dem Datum ermitteln, rel A6
  IN:   OUT:  
D1 QL date in seconds D1 put queue or Null. IO.SERIO kehrt hinter eine table aus three lonword addresses zurück, in der die routines to pending data input, zum fetching a Byte and zum Senden mit ihrer absolute address verzeichnet sind. re to im Abschnitt 3.3.2.3.3.


 
cv.ildat CN.DATE bu 236 $0EC
Datum and time in ASCII convert. rel A6 
cv.ilday CN.DAY bu 238 $0EE
Tag as ASCII String aus dem Datum ermitteln, rel A6
  IN:   OUT:  
D1 QL date in seconds D1
A1 Ptr to buffer(A6) A1 Ptr to den String
 
Im buffer sind 22 Bytes space (6 Bytes for CN.DAY) bereitzuhalten.
 

 
cv.fpdec CN.FTOD bu 240 $0F0
f.p. number in ASCII String convert. rel A6
cv.iwdec CN.ITOD bu 242 $0F2
integer in ASCII String. rel A6
cv.ibbin CN.ITOBB bu 244 $0F4
Byte in binary ASCII String. rel A6
cv.iwbin CN.ITOBW bu 246 $0F6
Word in binary ASCII String. rel A6
cv.ilbin CN.ITOBL bu 248 $0F8
Longword in binary ASCII String. rel A6
cv.ibhex CN.ITOHB bu 250 $0FA
Byte in Sedecimal ASCII String. rel A6
cv.iwhex CN.ITOHW bu  252 $0FC
Word in Sedecimal ASCII String. rel A6
cv.ilhex CN.ITOHL bu 254 $0FE
Longword in Sedecimal ASCII String. rel A6
  IN:   OUT:  
D1 - D3 smashed
A0 Ptr to buffer A0 Ptr zum buffer
A1 Ptr to number im RI-Stack A1 Ptr to Stack
A2, A3 smashed
A6 reference address
 
NOERR
Die number to 0(A1,A6.L) geht as String to 0(A0,A6.L).
 

 
cv.decfp CN.dittoP bu 256 $100
decimal ASCII String in f.p. number. rel A6
cv.deciw CN.dittoI  bu 258 $102
decimal ASCII String in 16-Bit number. rel A6
cv.binib CN.BTOIB bu 260 $104
8 Bit binary ASCII String in Byte. rel A6
cv.biniw CN.BTOIW bu 262 $106
16 Bit binary ASCII String in Word. rel A6
cv.binil CN.BTOIL bu 264 $108
32 Bit binary ASCII String in Longword. rel A6
cv.hexib CN.HTOIB bu 266 $10A
2 character sedecimal ASCII String in Byte. rel A6
cv.hexiv CN.HTOIW bu  268 $10C
4 character Sedecimal ASCII String in Word. rel A6
cv.hexil CN.HTOIL bu 270 $10E
8 character sedecimal ASCII String in Longword. rel A6
  IN:   OUT:  
D1 - D3 smashed
D7 0 or ptr to end of buffer
A0 Ptr to String im buffer A0 Ptr zum buffer
A1 Ptr to RI-Stack A1 beginning der number
A2, A3 smashed
A6 reference address
 
ERR.XP -17 conversion failed
Bei Fehlern bleiben A0 and A1 unchanged.
Der String to 0(A0,A6.L) geht as number to 0(A1,A6.L).
Im buffer (A1,A6.L) muß sufficient space zum Rechnen sein.
 

 
sb.inipr BP.INIT bp 272 $110
Installieren einer Anzahl SBasic extensions. {4.5.2}
  IN:   OUT:  
D2 smashed - nur to {2}
A1 Adr der definition list A1 smashed
A4 smashed (?)
 

 
sb.gtint CA.GTINT bp  274 $112
16-Bit numbers SBasic parameters fetch. {4.5.4.2} rel A6 
sb.gtfp CA.GTFP bp 276 $114
f.p. numbers ditto {4.5.4.3} rel A6
sb.gtstr CA.GTSTR bp 278 $116
Strings ditto {4.5.4.5} rel A6
sb.gtlin CA.GTLIN bp  280 $118
Long integer ditto {4.5.4.4} rel A6
  IN:   OUT:  
D1, D2 smashed
D4, D6 smashed
D3.W number der fetched Parameter
A0 smashed
A1 RI-Stack, 1st Parameter
A2 smashed
A3 Ptr bottom Name Table
A5 ditto, top
A6 reference address A6 reference, u.U. changed
 
ERR.BP -15
ERR.XP -17
saparator bits der Name Table werden smashed.
Der lesende SBasic job, and im Gefolge evtl. auch die anderen, can durch den call seine position and die Ptr relations change. Allein die depth des RI-Stack remains mit Sicherheit erhalten, not seine Position.
 

 
qa.resri BV.CHRIX bp 282 $11A
Reserviert space im arithmetic stack. {4.5.6} rel A6
  IN:   OUT:  
D1 requested Anzahl Bytes D1 - D3 smashed
A1 A1 nur SQ {15}: smashed
 
SMSQ without Möglichkeit der error handling
ERR.OM -3 nur to {15}
ERR.NC -1 bei MINERVA keine error
Nach {4} sind die other routines zur memory manipulation auch der anderen areae ebenfalls vectorized and wie die anderen vectors aufzurufen. Obgleich officially not documented, greifen commonly verbreitete extensions darauf zurück (.B. TK2). Es steht daher zu hoffen, daß sie auch in künftigen Systems in gleicher Form present sein werden...

Bei einigen der calls wird im Rom bereits eine Anzahl Bytes in D1 preset (s.u.), andere require die Angabe separately. Die in {4} angegebenen vectors liegen in diesen cases to 2 Bytes higher address. Es wird sinnvoll sein, wo present, die requested length in multiples der - system dependent - Zahlen anzugeben, diese also den Rom-Daten zu entnehmen and sie not as known vorauszusetzen.

Die Offsets to {4, 2/92} mit d1.l Bytes and running ptr :
 

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-buffer bv.bfp 4 04
32 $20 BV.CHTKX Token List bv.tkp 12 $0C
36 $24 BV.CHNLX Name list bv.nlp 36 $24
40 $28 BV.CHVVX Variable values (not SQ) bv.vvp 44 $2C
 44 $2C BV.CHCHX channel table bv.chp 52 $34
48 $30 BV.CHLNX line numbers bv.lnp 68 $44
52 $34 BV.CHPFX program bv.pfp 20 $14
 
Die new angegebenen vectors werden aufgerufen
 
move.l #space,d1 requested size
move.w $011a,a2 bv.chrix 
jmp ofs(a2) ausführung mit offset dazu 
 


 
qa.op RI.EXEC ar 284 $11C
Executes eine arithmetic Operation aus. {4.5.7} rel A6
qa.mop RI.EXECB ar 286 $11E
Executes eine Group of arithmetic Operations aus. rel A6
  IN:   OUT:  
D0.W RI.EXEC: RI Opcode (s.u.)
D7 RI.EXP {1} till QDOS 1.03 & MINERVA: 0
A1 RI-Stack rel(A6) A1 adjusted
A3 RI.EXECB: code table abs.
A4 RI.EXECB: Variable rel(A6)
 
ERR.OV -18
Die kleingeschriebenen Op-Codes gelten nur for MINERVA.

Abgekürzt:
tos Top Of Stack, das unmittelbar accessible Element,
nos Next On Stack, das danach eingetragene Element.
top Top Of Stack to einer Operation
 

Name Code Stack Function
RI.TERM 00   0 terminates die arithmetic operations.
ri.one 01 -6 Constant One ablegen
RI.NINT 02 +4 rounded Integer
ri.zero 03 -6 Constant Null ablegen
RI.INT 04 +4 truncated Integer
ri.n 05 -6 Byte in f.p. number -128 till 127
RI,.NLINT 06 +2 f.p. in rounded long Integer 
ri.k 07 -6 (?) s. User Guide
RI.FLOAT 08 -4 Integer to f.p.
ri.flong 09 -2 long Integer to 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 tangent
RI.ASIN 30  0 arcus sinus
RI.ACOS 32  0 arcus cosinus
RI.ATAN 34  0 arcus tangent
ri.arg 35 +6 tos, nos: k * cis( arg )
RI.ACOT 36  0 arcus cotangent
ri.mod 37 +6 sqrt( tos^2 + nos°2 )
RI.SQRT 38  0 square root
ri.sqar 39  0 sqare
RI.LN 40  0 logarithmus naturalis (requires ca 60 Bytes RI-Stack!)
RI.LOG10 42  0 lg
RI.EXP 44  0 exponential function
ri.power 45 +2 nos(fp) ^ tos(Integer)
RI.POWFP 46 +6 nos ^ tos
 

 
sb.putp BP.LET bp 288 $120
Variable as Parameter new set {4.5.4.6} rel A6
  IN:   OUT:  
D1 - D3 smashed
A0 - A2 smashed
A3 bottom der Name Table
 

 
iou.dnam IO.NAME gu 290 $122
Decodes a device name. {3.3.2.3.3}
  IN:   OUT:  
D1 - D3 smashed
A0 Ptr to Names
A1 - A2 smashed
A3 Ptr to intermediate memory
 
error messaging in Gestalt adjusted Return addresses.


 

All folgenden vectors sind mit Offset $4000 aufzurufen.
Sie sind for SQ sämtlich not defined.
 


 
  MD.READ md 292 $124
Reads a Sector of Microdrive. Offset $4000
  MD.WRITE md 294 $126
Schreibt a Sector to Microdrive. Offset $4000
  MD.VERIN md 296 $128
Verifies a Sector. Offset $4000
  MD.SECTR md 298 $12A
Reads Sektor header of Microdrive. Offset $4000
  IN:   OUT:  
D1 file number 
D2 block number
D0, D3-D7 smashed
A0 A0 smashed
A1 buffer A1 end of buffer
A2 smashed
A3 $18020
A4, A5 smashed
MD.WRITE: (A7) {File no .b | Block no. .b}
Der Stack pointer wird for die Rückkehr entsprechend adjusted:
0(A7) error exit; bei MD.SECTR unbrauchbarer data storage medium
2(A7) execution error free; bei MD.SECTR: bad header
4(A7) nur MD.SECTR: execution error free.
MD.WRITE geht stets without error to (A7).


 

An den Plätzen $12C till $013A stehen vectors des Basic zur Intialisierung, Syntaxprüfung and der Listenausgabe. Details werden dazu 'officially' not genannt.
 

Die folgenden vectors gelten nur for MINERVA.
 


 
  UT.ISTR   316 $13C
 INSTR operation Type 3 rel A6
  IN:   OUT:  
D1 Position des String
A0 zu suchender String
A1 abzusuchender String
 
D1 =  0 Fehlanzeige,
D1 else ab 1 zählende Position, wo der gesuchte String in (A1)+ found was.


 
  GO.NEW   318 $13E
NEW command execute
Die "most Register" werden smashed.
 

 
  BP.CHAN   320 $140
channel number fetch, default #1 - rel A6
  BP.CHAND   322 $142
ditto, default in D1.w - rel A6
  IN:   OUT:  
D1 default channel no. D1 channel number (preserved)
A0 ID, if channel exists
A2 b.chan definition block
A3 SBasic parameters A3 adjusted
A5 ditto, top
 
ERR.NO -6
Expects a 16bit channel number, else using the default, which is returned by D1.w.


 
  BP.CHNID   324 $144
channel find and ID liefern rel A6
  IN:   OUT:  
D1 channel number
A0 channel ID
A2 SBasic cdt
 
ERR.NO -6, bei unset X-Flag weist A2 über die channel table.

 
  BP.CHNEW   326 $146
New SBasic channel einbauen rel A6 
  IN:   OUT:  
D1 channel number D1
A0 channel ID A0
 
ERR.EX -8 if der channel already present war.

 
  BP.FNAME   328 $148
a String / Variable name as file name fetch. rel A6
  IN:   OUT:  
A1 RI-Ptr to the names A1
A3 Parameter ptr A3 adjusted
A5 Parameter ptr, top
 
"any sort of error messageing"

NOTE:
"fast return" to one level back if no parameters were given! (in MI. 1.87 & 1.97)
- Bug fixed in the (more or less) UQLX specific M89 version -


 
  CA.CNVRT   330 $14A
data type convert rel A6 
  IN:   OUT:  
D0 requested Type
A1 RI Stackpointer A1 adjusted
A5 Parameter ptr, top
 
ERR.XP -17 conversion failed
Für den requested Type gelten 1, 2 and 3, dazu 4 zur Ermittlung a Flag of value 0 or 1.

RI-Stack wird dem expected Type entsprechend adjusted.
Der Type der top Entry der name table wird concerted.
Die Entry muß im RI-Stack liegen, der Type in den 4 least significant Bits to -7(a6,a5.l) mit 0 or 1 for Strings, 2 for f.p. numbers, 3 for 16-Bit integers.
 


 
  CA.OPEXE   332 $14C
Operator execute
  CA.EVAL    334 $14E
Top Übergabestack-Eintragung/RI-Wert ausrechnen
 
"execution of monadic or dyadic operation. no mor comments..."
 

 
  IP.KBRD   336 $150
extended KEYROW Function supervisor mode
  IN:   OUT:  
D1 keyrow Data D0, D1 smashed
D2 shift data D2 smashed
D6 smashed
A1 smashed
A2 keyboard queue A2
 

à ?!%?~0?H  call Rückkehr D1  D2 s A2 Adr. der  D0 - D2, D6, A1 - A4  Bits D1 Function Bits D2 Function
 

  Bits D1 Function Bits D2 Function
31..6 don't care 31 .. 3 don't care
5 .. 3 7 - row number 2  CTRL
2 .. 0 column number 1 SHIFT
0 ALT
 
reading the keyboard.
vector call to implement other keyboards.

Sämtliche möglichen Codes werden received, ggf. doppelte Codes to ALT (255), diese werden auch von der automatic Tastenwiederholung erfasst.
 


 
  IP.KBEND   338 $152
Tastenabfrage beenden 
  IN:   OUT:  
D0 - D2 smashed
D3 missed polls
D5 Bit#4 Flag bei gedrückter Taste D5 smashed
A2 keyboard queue
A3 smashed
 
SUPERVISOR mode, only (?).

Ist zur Anzeige of Code zur Bedienung fremder keyboards aufzurufen, ob eine Taste noch pressed wird. Danach sind all KEYROW-entsprechenden Daten mittels IP.KBENC greifbar.

Nur Bit 4 aus D5 is auswertbar, 0 bedeutet, daß die latest Taste released was.


 
  SB.START   340 $154
a SBasic job einrichten rel A6 
  IN:   OUT:  
A0 ID des command channel - Interpreter Flag
A1 size des available memory area
 
MultiBASIC-Job durch direktes Anspringen - JMP $4000(An).
Das 2nd long(?) word im program memory des Jobs muß die Differenz der Job-Base zu den BASIC Tables (A6) enthalten.
  • A0

    • Mit channel ID beginnt der Job, die Quelle zu interpretieren. Bei Null and without Kanalübergabe mit dem Job-Aufruf wird das standardmäßige Monitor- or TV screen eingerichtet.
    • A5

    size des memory, -1(a6,a5.l) points to das latest Byte.
    • A6

    is to die Basis des own memory zu setzen.
    • A7

    points to die Übergabeparameter aus dem EXEC-Aufruf.

 
  MM.MOVE   344 $158
Move data im memory absolute adressed
  MM.MRTOA   346 $15A
ditto, von relative an absolute address User Mode
  MM.MATOR 48 $15C
ditto, von absolute an relative address User Mode
  MM.MRTOR   350 $15E
ditto, von relative an relative address User Mode 
  IN:   OUT:  
D0 Null
D1 Anzahl Bytes >0
A0 destination pointer
A1 source pointer
A6 außer MM.MOVE: reference
 
Transport stets "memory preserving". Auch odd Addresses in A0 and A1 sind erlaubt.

Aus dem Basic can 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
 

  


top : back : next : content 

= (count)