컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� TI-82 ROM Documentation by Wouter Demuynck wouter.demuynck@student.kuleuven.ac.be - http://karma.ticalc.org/ 컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� The information in this document was collected from the 82-XXX.TXT files by Dines Justesen and Mattias Lindqvist AND my own findings. This document rather gives a listing of all useful and non-useful (are there?) functions I found in the ROM sorted according to the address. Please note that none (or very little) of thes functions have been tested by me (Wouter Demuynck). The ones from the 82-XXX.TXT files have probably been tested by Dines Justesen or Mattias Lindqvist. This file will be always available on my homepage http://karma.ticalc.org/ (TI-82 ASM Corner) in the Infobase section I need to thank Dines Justesen and Matthias Lindqvist for their groundbreaking work. Without them, I would still writing BASIC games (or threw the calculator away). Have fun :) -- Wouter P.S. If you have additions or corrections, you can always mail them to me at wouter.demuynck@student.kuleuven.ac.be P.P.S. I try to use a standard notation (#) in case I want to convert this document to a database file. 컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� Last Update : August 12, 1998 Current State : Jumped over FP routines and continued. (about $1900 or sth) Version : 0.01 컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� 컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� RST calls : RST $00 Startup code RST $08 OP1 -> OP2 RST $10 Search for variable by name RST $18 Push value in OP1 or OP1/OP2 on FP stack RST $20 (HL) -> OP1 RST $28 OP1 = OP1 * OP2 RST $30 OP1 = OP1 + OP2 RST $38 Standard interrupt routine 컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� #ADDRESS: $0000 (All) #TITLE : Startup code #DESC : OUT ($04),$17 and jump to initialization routine ($07cc) #---------------------------------------------------------------------------- #ADDRESS: $0007 (16/19) #DESC : Call interrupt handler and copy OP1 to OP2 #---------------------------------------------------------------------------- #ADDRESS: $0008 (16/19) #TITLE : copy OP1 to OP2 (jp to) #---------------------------------------------------------------------------- #ADDRESS: $000B (16/19) #TITLE : BIT 0,(IY+$07) #---------------------------------------------------------------------------- #ADDRESS: $0010 (16/19) #TITLE : Search for variable by name (jp to) #---------------------------------------------------------------------------- #ADDRESS: $0013 (16/19) #TITLE : BIT 4,(IY+$02) : test if Graph Mode is function #OUTPUT : zero flag set if so #---------------------------------------------------------------------------- #ADDRESS: $0018 (16/19) #TITLE : Push value in OP1 or OP1/OP2 on FP stack (jp to) #---------------------------------------------------------------------------- #ADDRESS: $001B (16/19) #TITLE : SET 0,(IY+$03) : Redraw graph #---------------------------------------------------------------------------- #ADDRESS: $0020 (16/19) #TITLE : Copy (HL) to OP1 (jp to) #---------------------------------------------------------------------------- #ADDRESS: $0023 (16/19) #TITLE : Check if ($8bcb) is zero #OUTPUT : A = ($8BCB) or ($8BCB) #---------------------------------------------------------------------------- #ADDRESS: $0028 (16/19) #TITLE : OP1 = OP1 * OP2 (jp to) #---------------------------------------------------------------------------- #ADDRESS: $002B (16/19) #TITLE : Set ($8BCB) to zero #OUTPUT : A = 0; ($8BCB)=0; Zero flag set #---------------------------------------------------------------------------- #ADDRESS: $0030 (16/19) #TITLE : OP1 = OP1 + OP2 (jp to) #---------------------------------------------------------------------------- #ADDRESS: $0030 (16-19) #TITLE : LD HL,(HL) #INPUT : HL points to a word #OUTPUT : HL contains word; A=L #---------------------------------------------------------------------------- #ADDRESS: $0038 (16/19) #TITLE : Standard interrupt handler #---------------------------------------------------------------------------- #ADDRESS: $004f (16/19) #TITLE : bit stuff #OUTPUT : BIT 1,(IY+$03) NZ ? -> SET 0,(IY+$03) BIT 1,(IY+$03) Z ? -> SET 6,(IY+$13) and SET 0,(IY+$03) #---------------------------------------------------------------------------- #ADDRESS: $0081 (16/19) #TITLE : BIT 4,(IY+$09) : has an ON key interrupt occurred ? #OUTPUT : zero flag set if so #---------------------------------------------------------------------------- #ADDRESS: $0086 (16/19) #TITLE : BIT 5,(IY+$02) : is graph mode polar ? #OUTPUT : zero flag set if so #---------------------------------------------------------------------------- #ADDRESS: $008b (16/19) #TITLE : BIT 7,(IY+$02) : is graph mode sequence ? #OUTPUT : zero flag set if so #---------------------------------------------------------------------------- #ADDRESS: $0090 (16/19) #TITLE : BIT 6,(IY+$02) : is graph mode param ? #OUTPUT : zero flag set if so #---------------------------------------------------------------------------- #ADDRESS: $0095 (16-19) #TITLE : CP HL,DE #INPUT : HL and DE contain numbers to compare #OUTPUT : Flags are set; no registers destroyed #---------------------------------------------------------------------------- #ADDRESS: $009B (16/19) #TITLE : Display ":" #NOTE : calls $39ec (19) : (TX_CHARPUT) #---------------------------------------------------------------------------- #ADDRESS: $00A1 (16-19) #TITLE : Unpack one digit of HL to A #INPUT : HL contains data to be unpacked #OUTPUT : HL = int(HL/10); A = HL MOD 10 #---------------------------------------------------------------------------- #ADDRESS: $00A3 (16-19) #TITLE : Divide HL by A, remainder stored in A #INPUT : HL and A contain data #OUTPUT : HL = int(HL/A); A = HL MOD A #---------------------------------------------------------------------------- #ADDRESS: $00B3 (16/19) #TITLE : Update busy counter #OUTPUT : ($8026) decreased, and if zero reached update screen #---------------------------------------------------------------------------- #ADDRESS: $0103 (19) #TITLE : APD #OUTPUT : APD is executed #---------------------------------------------------------------------------- #ADDRESS: $0129 (19) #TITLE : Execute a HALT instruction and return #---------------------------------------------------------------------------- #ADDRESS: $012b (19) #TITLE : Reset APD counter ($8009) #INPUT : None #OUTPUT : ($800A)=$74 #NOTE : Only MSB reset (no problem though) #---------------------------------------------------------------------------- #ADDRESS: $0131 (19) #TITLE : Keyboard handler 1 #INPUT : None #OUTPUT : All memory locations concerning keypresses are updated #NOTE : called by onterrupt handler to handle keypresses #---------------------------------------------------------------------------- #ADDRESS: $017E (19) #TITLE : Read key from port #INPUT : None #OUTPUT : A = key; carry set if more than 1 key pressed #NOTE : #---------------------------------------------------------------------------- #ADDRESS: $01B8 (19) #TITLE : Read information from keyboard #INPUT : A contains mask to use #OUTPUT : A and B both contain the result sent back from port 1 OUT ($01),$FF ; reset port ? #---------------------------------------------------------------------------- #ADDRESS: $01C7 (19) #TITLE : Store keystroke in buffer #INPUT : A is scancode for key #OUTPUT : ($8000)=A; ($8006)=A [only if A<>0] SET 3,(IY+$00) [a key has been pressed] #---------------------------------------------------------------------------- #ADDRESS: $01D4 (16-19) #TITLE : Read keystroke from buffer : GET_KEY #INPUT : None #OUTPUT : A=($8000); ($8000)=$00 RES 3,(IY+$00) [no key has been pressed] [HL=$8000;EI] #---------------------------------------------------------------------------- #ADDRESS: $01E1 (19) #TITLE : Alpha Stuff (perhaps called by interrupt handler??) #INPUT : None #OUTPUT : returns immediately when ALPHA is on (NZ) else, jumps to $01f0 #---------------------------------------------------------------------------- #ADDRESS: $01E8 (19) #TITLE : Alpha Stuff (Used to turn off alpha or insert???) #INPUT : None #OUTPUT : RES 4,(IY+$05); RES 6,(IY+$12) RES 4,(IY+$12) if bit 7,(IY+$12) not set #---------------------------------------------------------------------------- #ADDRESS: $01FA (19) #TITLE : More alpha stuff (used for locking ALPHA ??) #INPUT : None #OUTPUT : SET 7,(IY+$12); SET 4,(IY+$12); RES 5,(IY+$12) #---------------------------------------------------------------------------- #ADDRESS: $0200 (19) #TITLE : More alpha stuff #INPUT : None #OUTPUT : SET 6,(IY+$12); SET 4,(IY+$12); RES 5,(IY+$12) #---------------------------------------------------------------------------- #ADDRESS: $020D (19) #TITLE : TI-OS main routines ?? #INPUT : #OUTPUT : #---------------------------------------------------------------------------- #ADDRESS: $0213 (19) #TITLE : CrASH uses this one when going back to TI-OS #INPUT : None; A ? scancode ?? #OUTPUT : bit stuff #---------------------------------------------------------------------------- #ADDRESS: $0355 (19) #TITLE : Copy some words #INPUT : None #OUTPUT : word from ($8d10) copied to ($8D12) word from ($8d0c) copied to ($8D0E) word from ($8143) copied to ($8D1A) HL=($8D1A)=($8143) #---------------------------------------------------------------------------- #ADDRESS: $0368 (19) #TITLE : load SP with ($8143), call $374 and jp to $213 #INPUT : None #OUTPUT : #---------------------------------------------------------------------------- #ADDRESS: $0374 (19) #TITLE : calls $385 and restores ROM page afterwards #INPUT : A contains sth (calc function used??) #OUTPUT : ROM page unchanged $385 called with A as argument ($8005)=0; B contains sth (calc function ?) #---------------------------------------------------------------------------- #ADDRESS: $0385 (19) #TITLE : Something to do with Calc functions #INPUT : A contains a calc function ? #OUTPUT : IF A=($8121) AND A=$45 -> Call $395C with BC saved IF A=($8121) AND A<>$40 -> B=$21 returned IF A<>($8121) OR A=$40 -> B=.. ... etc B should contain a (new?) calc function #---------------------------------------------------------------------------- #ADDRESS: $0454 (19) #TITLE : ?? #INPUT : #OUTPUT : BC = AF; res 5,(IY+$01) #NOTE : calls $4ec #---------------------------------------------------------------------------- #ADDRESS: $0452 (19) #TITLE : calls functions at ($8116) and ($8118) [rom page in ($8120)] #INPUT : None #OUTPUT : RES 0,(IY+$11) #---------------------------------------------------------------------------- #ADDRESS: $0462 (19) #TITLE : calls functions at ($8116) and ($8118) rom page ($8120) #INPUT : #OUTPUT : #---------------------------------------------------------------------------- #ADDRESS: $0465 (19) #TITLE : calls function at ($8118) [rom page in ($8120)] #INPUT : None #OUTPUT : RES 0,(IY+$11) #---------------------------------------------------------------------------- #ADDRESS: $046d (19) #TITLE : calls function at ($8116) [rom page in ($8120)] #INPUT : None #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $0473 (19) #TITLE : call function at ($8118) page ($8120) #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $046c #TITLE : calls function at ($8114) [rom page in ($8120)] #INPUT : None #OUTPUT : function called, rom page changed to $8120 #DESC : No regs destroyed #---------------------------------------------------------------------------- #ADDRESS: $04ec #TITLE : #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $051c (19) #TITLE : table of addresses, sth to do with calc functions #DESC : ADDR CALCFUNC Function to call ? ----------------------------------------------------------------- $3968 $40 Homescreen/Menus $4000 page $03 (using $2E60:call) $396e $41 Link menu $7370 page $02 (using $2E60:call) $3974 $42 Matrix edit menu $4003 page $05 (using $2E60:call) -> Mem error ? $397a $43 List edit mode $4746 page $05 (using $2E60:call) -> Mem error ? $3980 $44 Stat-Calc-setup menu $61CB page $05 (using $2E60:call) $3986 $45 Graph Mode $4575 page $04 (using $2E60:call) $398c $46 Mode menu $6723 page $05 (using $2E60:call) $3992 $47 Program Editor $4105 page $06 (using $2E60:call) $3998 $48 Program name input $4000 page $06 (using $2E60:call) $399e $49 Window Menu $6895 page $05 (using $2E8F:jump) $39a4 $4A Y-Var input $6833 page $06 (using $2E60:call) $39aa $4B Table Mode $4f29 page $05 (using $2E60:call) $39b0 $4C TableSet Menu $7ab6 page $03 (using $2E8F:jump) $39b6 $4D MEM-Check RAM $5e3e page $05 (using $2E60:call) $39bc $4E Delete $79ca page $02 (using $2E60:call) $39c2 $4F Mem reset ? $5e33 page $05 (using $2E60:call) $39c8 $50 ? $5e91 page $03 (using $2E60:call) $39ce $51 Zoom factors menu $7a9d page $03 (using $2E60:call) $39d4 $52 Error $728a page $04 (using $2E60:call) $39da $53 Stat plot settings $5f3a page $05 (using $2E60:calll) #---------------------------------------------------------------------------- #ADDRESS: $0544 (19) #TITLE : Table of $0D bytes possibly with calc functions #NOTE : listed functions $41 Link $42 Matrix edit mode $44 Stat-Calc-Setup $46 Mode $47 Program Editor $48 Program Name Input $4C Tableset $4D Check RAM $4E Delete $4F Mem Reset $52 Error $53 Stat plot $49 Window Not all functions are listed here, see $51c for more functions #---------------------------------------------------------------------------- #ADDRESS: $0551 #TITLE : a lot to do with status port and rom page port and on/off state of calculator #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $05C5 (19) #TITLE : Turn of calc #INPUT : None #OUTPUT : Display turned off; checksum at ($8145) is updated and calc halted text screen cleared when bit 2,(IY+$09) set #NOTE : Used for APD ($0103) by interrupt handler #---------------------------------------------------------------------------- #ADDRESS: $05f2 (19) #TITLE : ?? #INPUT : #OUTPUT : #NOTE : Perhaps used when calc is in APD state by interrupt handler at $0038 ???; jumped to from $0681 with 4,IY+$08 reset #---------------------------------------------------------------------------- #ADDRESS: $0641 (19) #TITLE : indicate that ON key has been pressed #INPUT : None #OUTPUT : SET 4,(IY+$09) #DESC : #---------------------------------------------------------------------------- #ADDRESS: $0646 (19) #TITLE : #INPUT : #OUTPUT : #DESC : check checksum with ($8145) and reset mem if not equal #---------------------------------------------------------------------------- #ADDRESS: $0684 (19) #TITLE : Reset calculator #INPUT : None #OUTPUT : Everything is reset SP = $FFFF all mem from $8000 to $FFFF cleared (set to $00) ($8008) = $07 : current contrast level CALL $38f0 ?? Link port reset (%00001100 written to ~) SET 3,(IY+$09) : calculator running ($800A)=$74 : APD counter reset SET 2,(IY+$08) : ?? SET 1,(IY+$0d) : ?? ($8c9a)=$FF : ?? call $0779 (init system pointers) -> look at $0779 for more info ($8d18)=$fe6e : pointer to last VAT entry (does not include ANS) ($8d12)=$fe6e : pointer to last byte of free MEM ($8d10)=$fe6e : pointer to last VAT entry (includes ANS) create 10 Y-vars, 6 Xt/Yt/r vars and the Un/Vn vars ($87b5)=$01 : part of word $87b4 or just a byte ??? CALL $1b16 : ?? CALL $38fc : ?? copy OP1->($888c) [9 bytes] : ?? ($802a)=$10 : inside OP 1 ! copy OP1->($888c) [9 bytes] : ?? ($88a2)=$01 : ?? ($88a6)=$01 : ?? ($88a9)=$01 : ?? ($88ac)=$01 : ?? ($8555)=$8557 : pointer to end of last entry buffer at $8557 ? CALL $3902 : ?? CALL $3908 : ?? CALL $390e : ?? LD HL,$04ed CALL $28f7 ; call func using errorhandler ?? ; loads values from mem to stack ($8143)=SP 0738 ------ Label9: 0738 db 03 IN A,($03) ; get status 073a e6 08 AND $08 ; %00001000 073c 28 fa JR Z,Label9 ; LCD off -> jump to label9? RES 4,(IY+$09) ; no ON-key interrupt OUT ($03),$0B : standard status CALL $38f0 EI ($8c8f)=$0800 : Number of first row and last in window (0-8) CALL $38e4 : clear text screen display ZT string normal font $29c2 at pos $0203 ("Mem Cleared") CALL $391a : goto top of screen (cursor_pos)=$0000 CALL $3938 : ?? CALL $01D4 : read current keystroke from buffer CALL $393e : keyboard handler CALL $38e4 : clear text screen RES 2,(IY+$09) : ??? JP $0220 #DESC : #---------------------------------------------------------------------------- #ADDRESS: $0779 (19) #TITLE : Initialize some system pointers #INPUT : None #OUTPUT : ($8d0a)=($8d0c)=($8d0e)=$8d24 (start of user mem) ($8d18)=($8d10)=($8d12)=$FE6E (start of VAT) ($8553)=$40 ($8554)=$60 #DESC : #---------------------------------------------------------------------------- #ADDRESS: $079a (19) #TITLE : Calc Checksum between $8d24 and $FE70 #INPUT : None #OUTPUT : IX saved DE = -HL HL = checksum BC = 0 #DESC : #---------------------------------------------------------------------------- #ADDRESS: $07b9 (19) #TITLE : ?? set homescreen ?? #INPUT : None #OUTPUT : $1e8 called res 3,(IY+$05) $3920 called res 6,(IY+$0c) jumped to $385 with A=$40 (homescreen code) #DESC : #---------------------------------------------------------------------------- #ADDRESS: $07CC (16/19) #TITLE : Initialization routine, jumped to from $0000 #INPUT : None #OUTPUT : SP=$FFCD OUT ($04),$17 IM 1 OUT ($00),$c0 OUT ($03),$00 OUT ($03),$01 EI HALT Display delay at $7F3 executed #DESC : #---------------------------------------------------------------------------- #ADDRESS: $07EA (19) #TITLE : Power OFF display #INPUT : None #OUTPUT : OUT (3),0; OUT (3),1;EI; HALT; DISPLAY_DELAY #DESC : #---------------------------------------------------------------------------- #ADDRESS: $07F3 (16-19) #TITLE : Display delay #INPUT : None #OUTPUT : Does 11+10+10+6+6=43 T-states of useless actions (together with call : 43+17=60 states) Flags not changed #DESC : Should be called every time when using the display controller #---------------------------------------------------------------------------- #X--------------------------------------------------------------------------- #X START OF FP MATH FUNCTIONS #X -> (Not actually looked up, taken over from 82-ROM.TXT) <- #X--------------------------------------------------------------------------- #---------------------------------------------------------------------------- #ADDRESS: $07F8 (19) #TITLE : CP OP1,OP2 #INPUT : OP1 and OP2 contain numbers to compare #OUTPUT : ? #DESC : ? #---------------------------------------------------------------------------- #ADDRESS: $0801 (19) #TITLE : OP1 = MIN(OP1,OP2) #INPUT : OP1 and OP2 contain numbers to compare #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $080A (19) #TITLE : OP1 = MAX(OP1,OP2) #INPUT : OP1 and OP2 contain numbers to compare #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0813 (19) #TITLE : OP1 = OP1 + (HL) (no extra digits) #INPUT : OP1, OP2 and HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0818 (19) #TITLE : OP1 = |OP1| + |OP2| (no extra digits) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0820 (19) #TITLE : OP1 = INT(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0831 (19) #TITLE : OP1 = OP2 - OP1 (no extra digits) #INPUT : OP1, OP2 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0836 (19) #TITLE : OP1 = IPART(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $083F (19) #TITLE : OP1 = OP1 * 2 (no extra digits) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0842 (19) #TITLE : OP1 = OP1 + 1 (no extra digits) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0847 (19) #TITLE : OP1 = OP1 - 1 (no extra digits) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $084A (19) #TITLE : OP1 = OP1 - OP2 (no extra digits) #INPUT : OP1, OP2 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0851 (19) #TITLE : OP1 = OP1 + OP2 #INPUT : OP1, OP2 #OUTPUT : #NOTES : RST $30 #---------------------------------------------------------------------------- #ADDRESS: $085A (19) #TITLE : OP1 = OP1 + OP2 #INPUT : OP1, OP2 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $08F7 (19) #TITLE : Convert OP1 from deg to rad #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $08FB (19) #TITLE : Convert OP1 from rad to deg #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0905 (19) #TITLE : Convert OP1 from deg to rad #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $090E (19) #TITLE : Convert OP1 from rad to deg #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $091C (19) #TITLE : OP1 = OP1 * 0.5 #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0917 (19) #TITLE : OP1 = OP1^3 #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0924 (19) #TITLE : OP1 = OP1^2 #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0925 (19) #TITLE : OP1 = OP1 * OP2 (no extra digits) #INPUT : OP1, OP2 #OUTPUT : #NOTES : This is RST $28 #---------------------------------------------------------------------------- #ADDRESS: $092C (19) #TITLE : OP1 = OP1 * OP2 (no extra digits) #INPUT : OP1, OP2 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0A5E (19) #TITLE : OP1 = -OP1 #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0A6E (19) #TITLE : OP2 = -OP2 #INPUT : OP2 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0A84 (19) #TITLE : OP1 = FPART(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0ACB (19) #TITLE : OP1 = OP1 / OP2 #INPUT : OP1, OP2 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0AD1 (19) #TITLE : OP1 = 1 / OP1 #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0AD5 (19) #TITLE : OP1 = OP1 / OP2 #INPUT : OP1, OP2 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0B9C (19) #TITLE : OP1 = SQRT(OP1) ? #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0BA2 (19) #TITLE : OP1 = SQRT(OP1) ? #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0D28 (19) #TITLE : OP1 = LN(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0D2C (19) #TITLE : OP1 = LOG(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0E7B (19) #TITLE : Table of 8 bytes : ? #INPUT : / #OUTPUT : / #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0F04 (19) #TITLE : OP1 = e^OP1 #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $0F0E (19) #TITLE : OP1 = 10^OP1 #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $10E0 (19) #TITLE : OP1 = SIN(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $10E4 (19) #TITLE : OP1 = COS(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $10E8 (19) #TITLE : OP1 = TAN(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $14C8 (19) #TITLE : OP1 = TANH(OP1) ? #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $14CC (19) #TITLE : OP1 = COSH(OP1) ? #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $14D0 (19) #TITLE : OP1 = SINH(OP1) ? #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1567 (19) #TITLE : OP1 = ARCCOS(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $156D (19) #TITLE : OP1 = ARCSIN(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1578 (19) #TITLE : OP1 = ARCTAN(OP1) #INPUT : OP1 #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #X--------------------------------------------------------------------------- #X End of part taken from 82-ROM.TXT #X--------------------------------------------------------------------------- #ADDRESS: $1901 (19) #TITLE : HL = HL * 9 #INPUT : HL #OUTPUT : HL = HL * 9 #NOTES : BC destroyed (=original HL); Wrong answer if HL*9 > $FFFF (duh..) #---------------------------------------------------------------------------- #ADDRESS: $190B (19) #TITLE : get type of OP1 #INPUT : / #OUTPUT : A = (OP1) AND $0F #NOTES : / #---------------------------------------------------------------------------- #ADDRESS: $1911 (19) #TITLE : get type of OP1 #INPUT : / #OUTPUT : EX OP1,OP2 \ LD D,0 \ JP $15E7 #NOTES : / #---------------------------------------------------------------------------- #ADDRESS: $1919 (19) #TITLE : CP OP4,OP3 #INPUT : OP3, OP4 #OUTPUT : OP4 -> OP1 \ OP3 -> OP2 \ CP OP1,OP2 #NOTES : / #---------------------------------------------------------------------------- #ADDRESS: $1921 (19) #TITLE : CP OP1,(HL) #INPUT : OP1, HL #OUTPUT : call $1a8e \ CP OP1,OP2 #NOTES : / #---------------------------------------------------------------------------- #ADDRESS: $1926 (19) #TITLE : CP |OP1|,|OP2| #INPUT : OP1,OP2 #OUTPUT : OP1=|OP1| \ OP2=|OP2| \ CP OP1,OP2 #NOTES : / #---------------------------------------------------------------------------- #ADDRESS: $192c (19) #TITLE : CP OP1,OP2 #INPUT : OP1,OP2 #OUTPUT : / #NOTES : / #---------------------------------------------------------------------------- #ADDRESS: $196F (19) #TITLE : OP3 -> OP4 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1978 (19) #TITLE : OP1 -> OP4 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1981 (19) #TITLE : OP2 -> OP4 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $198A (19) #TITLE : OP4 -> OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1993 (19) #TITLE : OP3 -> OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $199B (19) #TITLE : OP3 -> OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19A3 (19) #TITLE : OP5 -> OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19AB (19) #TITLE : OP5 -> OP6 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19B3 (19) #TITLE : OP5 -> OP4 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19BB (19); $19a1 (16) #TITLE : OP1 -> OP2 #INPUT : #OUTPUT : #NOTES : This is RST $08 #---------------------------------------------------------------------------- #ADDRESS: $19C3 (19) #TITLE : OP6 -> OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19CB (19) #TITLE : OP6 -> OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19D0 (19) #TITLE : OP4 -> OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19D5 (19) #TITLE : OP5 -> OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19DA (19) #TITLE : OP3 -> OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19DF (19) #TITLE : OP4 -> OP5 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19E7 (19) #TITLE : OP3 -> OP5 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19EF (19) #TITLE : OP2 -> OP5 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19FF (19) #TITLE : OP2 -> OP6 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $19FF (19) #TITLE : OP1 -> OP6 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a07 (19) #TITLE : OP1 -> OP5 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1A0F (19) #TITLE : OP2 -> OP1 #INPUT : OP2 #OUTPUT : OP1 = OP2 #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a15 (19) #TITLE : LDI 11 times #INPUT : #OUTPUT : #NOTES : Use Addresses 1a17 -> 1a29 (every 2 bytes) for 10 -> 1 times LDI #---------------------------------------------------------------------------- #ADDRESS: $1a2c (19) #TITLE : Copy 8 bytes from OP4+2 -> OP2+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a34 (19) #TITLE : Copy 8 bytes from OP1+2 -> OP4+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a2c (19) #TITLE : Copy 8 bytes from OP4+2 -> OP1+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a41 (19) #TITLE : Copy 8 bytes from OP2+2 -> OP1+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a49 (19) #TITLE : Copy 7 bytes from OP2+2 -> OP3+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a49 (19) #TITLE : Copy 7 bytes from OP1+2 -> OP5+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a49 (19) #TITLE : Copy 7 bytes from OP1+2 -> OP3+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a49 (19) #TITLE : Copy 7 bytes from OP1+2 -> OP3+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a49 (19) #TITLE : Copy 8 bytes from OP1+2 -> OP3+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a69 (19) #TITLE : Copy 7 bytes from HL -> OP3+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a49 (19) #TITLE : Copy 7 bytes from OP2+2 -> OP3+2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a6e (19) #TITLE : Copy 11 bytes from OP2 -> OP3 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a76 (19) #TITLE : Copy 11 bytes from OP4 -> OP3 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a7b (19) #TITLE : Copy 11 bytes from OP5 -> OP3 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a80 (19) #TITLE : Copy 11 bytes from OP4 -> OP6 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a88 (19); $1a6e (16) #TITLE : Copy 9 bytes from HL -> OP1 #INPUT : #OUTPUT : #NOTES : This is RST $20 #---------------------------------------------------------------------------- #ADDRESS: $1a8d (19) #TITLE : Copy HL to OP1 and 9 bytes of HL to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a8e (19) #TITLE : Copy 9 bytes from HL to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a93 (19) #TITLE : Copy 9 bytes from OP1 to DE #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a98 (19) #TITLE : Write real 1.0 to OP4 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1a9D (19) #TITLE : Write real 1.0 to OP3 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1aa2 (19) #TITLE : Write real 8.0 to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1aa9 (19) #TITLE : Write real 5.0 to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ab0 (19) #TITLE : Write real 4.0 to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ab7 (19) #TITLE : Write real 3.0 to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1abe (19) #TITLE : POP HL and write real 1.0 to OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1abf (19) #TITLE : Write real 1.0 to OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ac4 (19) #TITLE : Write real 4.0 to OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1acb (19) #TITLE : Write real 3.0 to OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ad2 (19) #TITLE : Write real 2.0 to OP3 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ad7 (19) #TITLE : Write real 2.0 to OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1adc (19) #TITLE : Write real 2.0 to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ac4 (19) #TITLE : Write real 2.0 to HL #INPUT : HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ae3 (19) #TITLE : Write 10 00 00 00 00 00 00 00 at HL #INPUT : HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1ae7 (19) #TITLE : Write real 1.0 to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1aea (19) #TITLE : Write real 1.0 to HL #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1aec (19) #TITLE : Write real number at HL : 00 80 XX 00 00 00 00 00 00 (XX = A) #INPUT : A, HL #OUTPUT : Real number written (0.0 -> 9.0) #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1af1 (19) #TITLE : Write .. XX 00 00 00 00 00 00 00 from HL on (.. = unchanged byte \ XX = contents of A) #INPUT : A, HL #OUTPUT : HL points to last byte written #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1af2 (19) #TITLE : Write A at HL and zero out next 7 bytes #INPUT : A, HL #OUTPUT : HL points to last written zero byte #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1af6 (19) #TITLE : Write 8 zero bytes from (HL) on #INPUT : HL #OUTPUT : HL points to last written zero byte, A = 0 #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1af8 (19) #TITLE : Write 7 bytes A from HL+1 on #INPUT : A, HL #OUTPUT : HL points to last byte written #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b07 (19) #TITLE : Write real 0.0 to OP4 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b0c (19) #TITLE : Write real 0.0 to OP3 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b11 (19) #TITLE : Write real 0.0 to OP2 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b16 (19) #TITLE : Write real 0.0 to OP1 #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b19 (19) #TITLE : Write real 0.0 to HL #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1bc1 (19) #TITLE : Write 0.0 to OP1 (without changing sign/exp) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b21 (19) #TITLE : Zero out OP1 (write 11 zero bytes) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b21 (19) #TITLE : Zero out OP2 (write 11 zero bytes) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b2b (19) #TITLE : Zero out OP3 (write 11 zero bytes) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b2e (19) #TITLE : Write 11 zero bytes from HL on #INPUT : HL #OUTPUT : A = 0, HL points to last written zero byte #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b36 (19) #TITLE : Write B zero bytes from HL on ($100 when B=0) #INPUT : HL, B #OUTPUT : HL points to byte past last written zero byte #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b3c (19) #TITLE : Get upper nibble of C #INPUT : C #OUTPUT : A = upper nibble #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b3d (19) #TITLE : Get upper nibble of A #INPUT : A #OUTPUT : A = upper nibble #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b44 (19) #TITLE : A = C * 16 (Move lower nibble to upper nibble) #INPUT : A #OUTPUT : A = C * 16 #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b45 (19) #TITLE : A = A * 16 (Move lower nibble to upper nibble) #INPUT : A #OUTPUT : A = A * 16 #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b4A (19) #TITLE : OP1 = OP1/10 (7 digits to right) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b50 (19) #TITLE : Rotate 9 digits right from OP1 + 1 (EXP byte!) (insert 0!) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b59 (19) #TITLE : OP1 = OP1 / 10 (8 digits to right) #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b60 (19) #TITLE : Rotate 8 digits right (insert digit on the left) #INPUT : lower nibble of A, HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b60 (19) #TITLE : Rotate 7 digits right (insert digit on the left) #INPUT : lower nibble of A, HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b76 (19) #TITLE : Rotate 7 digits right (insert digit on the left) #INPUT : lower nibble of A, HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b90 (19) #TITLE : Rotate 8 digits left (insert 0 digit on the right) #INPUT : lower nibble of A, HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1b94 (19) #TITLE : Rotate 7 digits left (insert digit on the right) #INPUT : lower nibble of A, HL #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1D33 (19) #TITLE : Exchange OP1 and OP2 #INPUT : / #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1D36 (19) #TITLE : Exchange 11 bytes from HL on and OP1 #INPUT : / #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1D39 (19) #TITLE : Exchange 11 bytes from HL on with 11 bytes from DE on #INPUT : / #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $1D3B (19) #TITLE : Exchange B bytes from HL on with B bytes from DE on #INPUT : / #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: #TITLE : #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: #TITLE : #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: #TITLE : #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $1fae (19) #TITLE : ? #INPUT : #OUTPUT : can return sth (C/NC) #DESC : #---------------------------------------------------------------------------- #ADDRESS: $20B6 (19); $209C (16) #TITLE : Write 7 to port 10 #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $20C0 (19); $20A6 (16) #TITLE : Write 5 to port 10 #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $2143 (19); $2129 (16) #TITLE : Search for variable by name (jumped to by $0010) #---------------------------------------------------------------------------- #ADDRESS: $273E (19); $2724 (16) #TITLE : Push value in OP1 or OP1/OP2 on the stack (jumped to by $0018) #---------------------------------------------------------------------------- #ADDRESS: $2dc8 (19) #TITLE : create Yt var #INPUT : A contains a number from $01 to $06 for var to create ?????????? #OUTPUT : Yt var created #NOTES : according to 82-ROM.TXT the number for the var to create has to be in ($854D) Perhaps this is used for returning var info to OP1 #---------------------------------------------------------------------------- #ADDRESS: $2dc8 (19) #TITLE : create Xt var #INPUT : A contains a number from $01 to $06 for var to create ?????????? #OUTPUT : Xt var created #NOTES : according to 82-ROM.TXT the number for the var to create has to be in ($854D) Perhaps this is used for returning var info to OP1 #---------------------------------------------------------------------------- #ADDRESS: $2dde (19) #TITLE : create Y var #INPUT : A contains a number from $01 to $0a for var to create ?????????? #OUTPUT : Y var created #NOTES : according to 82-ROM.TXT the number for the var to create has to be in ($854D) Perhaps this is used for returning var info to OP1 #---------------------------------------------------------------------------- #ADDRESS: $2de3 (19) #TITLE : create r var #INPUT : A contains a number from $01 to $06 for var to create ?????????? #OUTPUT : r var created #NOTES : according to 82-ROM.TXT the number for the var to create has to be in ($854D) Perhaps this is used for returning var info to OP1 #---------------------------------------------------------------------------- #ADDRESS: $2dfa (19) #TITLE : create Un or Vn var #INPUT : A contains a number from $01 to $02 for var to create ?????????? #OUTPUT : Un or Vn var created #NOTES : according to 82-ROM.TXT the number for the var to create has to be in ($854D) Perhaps this is used for returning var info to OP1 #---------------------------------------------------------------------------- #ADDRESS: $2397 (19) #TITLE : called every time after a var created ???? #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $2E60 (19) #TITLE : Call ROM function #INPUT : CALL $2E60 \ .DW Addr \ .DB Rompage #OUTPUT : function called, returns to address stored on stack #NOTES : Uses $2E87 for return #---------------------------------------------------------------------------- #ADDRESS: $2E8F (19) #TITLE : Jump to ROM function #INPUT : CALL $2E8F \ .DW Addr \ .DB Rompage #OUTPUT : Jumped to function #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $38d2 (19) #TITLE : #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $38d8 (19) #TITLE : #INPUT : #OUTPUT : #NOTES : #---------------------------------------------------------------------------- #ADDRESS: $38ea (19) #TITLE : #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $38F0 (19) #TITLE : #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $38F6 (19) #TITLE : #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $3920 (19) #TITLE : #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $3950 (19) #TITLE : ?? #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $3968 (19) #TITLE : table of rom calls, according to table at $51c #DESC : see info about $51c for more info goes on to $39E0 #---------------------------------------------------------------------------- #ADDRESS: $39E0 (19) #TITLE : Copy display contents to APD_BUF #INPUT : #OUTPUT : #DESC : #---------------------------------------------------------------------------- #ADDRESS: $39EC (19); $39D2 (16) #TITLE : TX_CHARPUT #DESC : Prints a character with translation #----------------------------------------------------------------------------