URL
https://opencores.org/ocsvn/raptor64/raptor64/trunk
Subversion Repositories raptor64
[/] [raptor64/] [trunk/] [software/] [sample code/] [bootrom.lst] - Rev 43
Go to most recent revision | Compare with Previous | Blame | View Log
; ============================================================================; (C) 2012,2013 Robert Finch, Stratford; All Rights Reserved.; robfinch<remove>@opencores.org;; This source file is free software: you can redistribute it and/or modify; it under the terms of the GNU Lesser General Public License as published; by the Free Software Foundation, either version 3 of the License, or; (at your option) any later version.;; This source file is distributed in the hope that it will be useful,; but WITHOUT ANY WARRANTY; without even the implied warranty of; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the; GNU General Public License for more details.;; You should have received a copy of the GNU General Public License; along with this program. If not, see <http://www.gnu.org/licenses/>.;; ============================================================================;CR EQU 0x0D ;ASCII equatesLF EQU 0x0ATAB EQU 0x09CTRLC EQU 0x03CTRLH EQU 0x08CTRLS EQU 0x13CTRLX EQU 0x18XON EQU 0x11XOFF EQU 0x13DATA_PRESENT EQU 0x01 ; there is data preset at the serial port bc_uart3XMIT_NOT_FULL EQU 0x20BUFLEN EQU 80 ; length of keyboard input buffer; Initial stack tops for contexts; Each context gets 1k from the special 16k startup stack memory;STACKTOP0 EQU 0xFFFF_FFFF_FFFE_FFF8STACKTOP1 EQU 0xFFFF_FFFF_FFFE_FBF8STACKTOP2 EQU 0xFFFF_FFFF_FFFE_F7F8STACKTOP3 EQU 0xFFFF_FFFF_FFFE_F3F8STACKTOP4 EQU 0xFFFF_FFFF_FFFE_EFF8STACKTOP5 EQU 0xFFFF_FFFF_FFFE_EBF8STACKTOP6 EQU 0xFFFF_FFFF_FFFE_E7F8STACKTOP7 EQU 0xFFFF_FFFF_FFFE_E3F8STACKTOP8 EQU 0xFFFF_FFFF_FFFE_DFF8STACKTOP9 EQU 0xFFFF_FFFF_FFFE_DBF8STACKTOP10 EQU 0xFFFF_FFFF_FFFE_D7F8STACKTOP11 EQU 0xFFFF_FFFF_FFFE_D3F8STACKTOP12 EQU 0xFFFF_FFFF_FFFE_CFF8STACKTOP13 EQU 0xFFFF_FFFF_FFFE_CBF8STACKTOP14 EQU 0xFFFF_FFFF_FFFE_C7F8STACKTOP15 EQU 0xFFFF_FFFF_FFFE_C3F8; BOOT ROM routinesTCBSize EQU 0x200 ; 512 bytes per TCBTCBBase EQU 0x00000001_00000000 ; TCB pagesTCBr1 EQU 0x00TCBr2 EQU 0x08TCBr3 EQU 0x10TCBr4 EQU 0x18TCBr5 EQU 0x20TCBr6 EQU 0x28TCBr7 EQU 0x30TCBr8 EQU 0x38TCBr9 EQU 0x40TCBr10 EQU 0x48TCBr11 EQU 0x50TCBr12 EQU 0x58TCBr13 EQU 0x60TCBr14 EQU 0x68TCBr15 EQU 0x70TCBr16 EQU 0x78TCBr17 EQU 0x80TCBr18 EQU 0x88TCBr19 EQU 0x90TCBr20 EQU 0x98TCBr21 EQU 0xA0TCBr22 EQU 0xA8TCBr23 EQU 0xB0TCBr24 EQU 0xB8TCBr25 EQU 0xC0TCBr26 EQU 0xC8TCBr27 EQU 0xD0TCBr28 EQU 0xD8TCBr29 EQU 0xE0TCBr30 EQU 0xE8TCBr31 EQU 0xF0warmStart EQU 0x1020usrJmp EQU 0x1028TickIRQAddr EQU 0x1030TaskBlock EQU 0x1038tencount EQU 0x13F8Milliseconds EQU 0x1400Lastloc EQU 0x1408ScreenColor EQU 0x1414CursorRow EQU 0x1416CursorCol EQU 0x1418CursorFlash EQU 0x141AKeybdEcho EQU 0x141CKeybdBuffer EQU 0x1440KeybdHead EQU 0x1450KeybdTail EQU 0x1451Score EQU 0x1500Manpos EQU 0x1508MissileActive EQU 0x1510MissileX EQU 0x1512MissileY EQU 0x1514InvadersRow1 EQU 0x1520InvadersRow2 EQU 0x1530InvadersRow3 EQU 0x1540InvadersRow4 EQU 0x1550InvadersRow5 EQU 0x1560InvadersColpos EQU 0x1570InvadersRowpos EQU 0x1571Uart_rxfifo EQU 0x1600Uart_rxhead EQU 0x1800Uart_rxtail EQU 0x1802Uart_ms EQU 0x1808Uart_rxrts EQU 0x1809Uart_rxdtr EQU 0x180AUart_rxxon EQU 0x180BUart_rxflow EQU 0x180CUart_fon EQU 0x180EUart_foff EQU 0x1810Uart_txrts EQU 0x1812Uart_txdtr EQU 0x1813Uart_txxon EQU 0x1814Uart_txxonoff EQU 0x1815TaskList EQU 0x2000ReadyList1 EQU 0x2000ReadyList2 EQU 0x2020ReadyList3 EQU 0x2040ReadyList4 EQU 0x2060ReadyList5 EQU 0x2080ReadyNdx1 EQU 0x20A0ReadyNdx2 EQU 0x20A1ReadyNdx3 EQU 0x20A2ReadyNdx4 EQU 0x20A3ReadyNdx5 EQU 0x20A4RunningTCB EQU 0x20A6NextToRunTCB EQU 0x20A8r1save EQU 0x20B0r2save EQU 0x20B8AXCstart EQU 0x20C0p100IRQvec EQU 0x3000keybdIRQvec EQU 0x3008serialIRQvec EQU 0x3010rasterIRQvec EQU 0x3018TEXTSCR EQU 0xD0_0000COLORSCR EQU 0xD1_0000TEXTREG EQU 0xDA_0000TEXT_COLS EQU 0x0TEXT_ROWS EQU 0x2TEXT_CURPOS EQU 0x16KEYBD EQU 0xDC_0000KEYBDCLR EQU 0xDC_0002UART EQU 0xDC_0A00UART_LS EQU 0xDC_0A01UART_MS EQU 0xDC_0A02UART_IS EQU 0xDC_0A03UART_IE EQU 0xDC_0A04UART_MC EQU 0xDC_0A06DATETIME EQU 0xDC_0400PIC EQU 0xDC_0FF0PIC_IE EQU 0xDC_0FF2PSG EQU 0xD5_0000PSGFREQ0 EQU 0xD5_0000PSGPW0 EQU 0xD5_0002PSGCTRL0 EQU 0xD5_0004PSGADSR0 EQU 0xD5_0006SPRRAM EQU 0xD8_0000AC97 EQU 0xDC_1000LED EQU 0xDC_0600GACCEL EQU 0xDA_E000RASTERIRQ EQU 0xDA_0100BOOT_STACK EQU 0xFFFF_FFFF_FFFE_FFF8SPRITEREGS EQU 0xDA_D000BITMAPSCR EQU 0x00000001_00200000txempty EQU 0x40rxfull EQU 0x01;; Internal variables follow:;0000000100600000 bss0000000000001038 org 0x10380000000000000000 pos dh 0 ; text screen position0000000000001040 org 0x10401040 0000000000000000 lineLinkTbl fill.b 25,0 ; screen line link table1048 00000000000000001050 00000000000000001058 00000000000000000000000000001068 align 80000000000001080 org 0x10800000000000001088 align 80000000000001088 0000000000000001 OSSP dw 1 ; OS value of sp0000000000001090 0000000000000001 CURRNT dw 1 ; Current line pointer0000000000001098 0000000000000001 STKGOS dw 1 ; Saves stack pointer in 'GOSUB'00000000000010A0 0000000000000001 STKINP dw 1 ; Saves stack pointer during 'INPUT'00000000000010A8 0000000000000001 LOPVAR dw 1 ; 'FOR' loop save area00000000000010B0 0000000000000001 LOPINC dw 1 ; increment00000000000010B8 0000000000000001 LOPLMT dw 1 ; limit00000000000010C0 0000000000000001 LOPLN dw 1 ; line number00000000000010C8 0000000000000001 LOPPT dw 1 ; text pointer00000000000010D0 0000000000000001 TXTUNF dw 1 ; points to unfilled text area00000000000010D8 0000000000000001 VARBGN dw 1 ; points to variable area00000000000010E0 0000000000000001 IVARBGN dw 1 ; points to integer variable area00000000000010E8 0000000000000001 SVARBGN dw 1 ; points to string variable area00000000000010F0 0000000000000001 FVARBGN dw 1 ; points to float variable area00000000000010F8 0000000000000001 STKBOT dw 1 ; holds lower limit for stack growth1100 0000000000000000 NUMWKA fill.b 24,0 ; numeric work area1108 00000000000000001110 00000000000000001118 0000000000000000 BUFFER fill.b BUFLEN,0x00 ; Keyboard input buffer1120 00000000000000001128 00000000000000001130 00000000000000001138 00000000000000001140 00000000000000001148 00000000000000001150 00000000000000001158 00000000000000001160 0000000000000000000000000000116E bss0000000100600000 org 0x1_00600000TXT equ 0x1_00600000 ; Beginning of program area; org 0x070; iret; nop; nop; nop; nop; nop; nop; nop;0000000000000000 codeFFFFFFFFFFFFB000 org 0xFFFF_FFFF_FFFF_B000; jump table;FFFFFFFFFFFFB000 33FFED54 jmp SerialGetCharFFFFFFFFFFFFB004 33FFED0C jmp SerialPutCharFFFFFFFFFFFFB008 33FFEE06 jmp SetKeyboardEchoFFFFFFFFFFFFB00C 33FFEE1D jmp KeybdCheckForKeyFFFFFFFFFFFFB010 33FFEE08 jmp KeybdGetCharFFFFFFFFFFFFB014 33FFEF47 jmp DisplayCharFFFFFFFFFFFFB018 33FFEFE7 jmp DisplayStringFFFFFFFFFFFFB01C start:; lea MSGRAM,a1; jsr DisplayStringFFFFFFFFFFFFB01C ColdStart:FFFFFFFFFFFFB01C 0000000A icache_on ; turn on the ICacheFFFFFFFFFFFFB020 0000000D dcache_off ; turn on the DCache; Initialize the context schedule with all contexts treated equally; There are only 16 contexts, but 256 schedule slots. Each context is; given 16 slots distributed evenly throughout the execution pattern; table.;FFFFFFFFFFFFB024 0410840A xor r1,r1,r1 ; r1 = 0FFFFFFFFFFFFB028 ict1:FFFFFFFFFFFFB028 0410803A mtep r1,r1 ; only the low order four bits of r1 will move to the pattern tableFFFFFFFFFFFFB02C 0A108001 addui r1,r1,#1FFFFFFFFFFFFB030 101100FF cmpi r2,r1,#255FFFFFFFFFFFFB034 BE207FA9 bne r2,r0,ict1; Point the interrupt return address register of the context to the; context startup code. The context will start up when an interrupt return; occurs.;; We cannot use a loop for this. Fortunately there's only 16 contexts.;FFFFFFFFFFFFB038 E6BFB214 ; SETLOFFFFFFFFFFFFB03C 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB040 E6BEFFF8 ; SETLOFFFFFFFFFFFFB044 6A0D782D lea r30,STACKTOP0FFFFFFFFFFFFB048 0000000F ieppFFFFFFFFFFFFB04C DE000000 nopFFFFFFFFFFFFB050 DE000000 nopFFFFFFFFFFFFB054 E6BFB214 ; SETLOFFFFFFFFFFFFB058 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB05C E6BEFBF8 ; SETLOFFFFFFFFFFFFB060 6A0D782D lea r30,STACKTOP1FFFFFFFFFFFFB064 0000000F ieppFFFFFFFFFFFFB068 DE000000 nopFFFFFFFFFFFFB06C DE000000 nopFFFFFFFFFFFFB070 E6BFB214 ; SETLOFFFFFFFFFFFFB074 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB078 E6BEF7F8 ; SETLOFFFFFFFFFFFFB07C 6A0D782D lea r30,STACKTOP2FFFFFFFFFFFFB080 0000000F ieppFFFFFFFFFFFFB084 DE000000 nopFFFFFFFFFFFFB088 DE000000 nopFFFFFFFFFFFFB08C E6BFB214 ; SETLOFFFFFFFFFFFFB090 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB094 E6BEF3F8 ; SETLOFFFFFFFFFFFFB098 6A0D782D lea r30,STACKTOP3FFFFFFFFFFFFB09C 0000000F ieppFFFFFFFFFFFFB0A0 DE000000 nopFFFFFFFFFFFFB0A4 DE000000 nopFFFFFFFFFFFFB0A8 E6BFB214 ; SETLOFFFFFFFFFFFFB0AC 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB0B0 E6BEEFF8 ; SETLOFFFFFFFFFFFFB0B4 6A0D782D lea r30,STACKTOP4FFFFFFFFFFFFB0B8 0000000F ieppFFFFFFFFFFFFB0BC DE000000 nopFFFFFFFFFFFFB0C0 DE000000 nopFFFFFFFFFFFFB0C4 E6BFB214 ; SETLOFFFFFFFFFFFFB0C8 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB0CC E6BEEBF8 ; SETLOFFFFFFFFFFFFB0D0 6A0D782D lea r30,STACKTOP5FFFFFFFFFFFFB0D4 0000000F ieppFFFFFFFFFFFFB0D8 DE000000 nopFFFFFFFFFFFFB0DC DE000000 nopFFFFFFFFFFFFB0E0 E6BFB214 ; SETLOFFFFFFFFFFFFB0E4 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB0E8 E6BEE7F8 ; SETLOFFFFFFFFFFFFB0EC 6A0D782D lea r30,STACKTOP6FFFFFFFFFFFFB0F0 0000000F ieppFFFFFFFFFFFFB0F4 DE000000 nopFFFFFFFFFFFFB0F8 DE000000 nopFFFFFFFFFFFFB0FC E6BFB214 ; SETLOFFFFFFFFFFFFB100 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB104 E6BEE3F8 ; SETLOFFFFFFFFFFFFB108 6A0D782D lea r30,STACKTOP7FFFFFFFFFFFFB10C 0000000F ieppFFFFFFFFFFFFB110 DE000000 nopFFFFFFFFFFFFB114 DE000000 nopFFFFFFFFFFFFB118 E6BFB214 ; SETLOFFFFFFFFFFFFB11C 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB120 E6BEDFF8 ; SETLOFFFFFFFFFFFFB124 6A0D782D lea r30,STACKTOP8FFFFFFFFFFFFB128 0000000F ieppFFFFFFFFFFFFB12C DE000000 nopFFFFFFFFFFFFB130 DE000000 nopFFFFFFFFFFFFB134 E6BFB214 ; SETLOFFFFFFFFFFFFB138 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB13C E6BEDBF8 ; SETLOFFFFFFFFFFFFB140 6A0D782D lea r30,STACKTOP9FFFFFFFFFFFFB144 0000000F ieppFFFFFFFFFFFFB148 DE000000 nopFFFFFFFFFFFFB14C DE000000 nopFFFFFFFFFFFFB150 E6BFB214 ; SETLOFFFFFFFFFFFFB154 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB158 E6BED7F8 ; SETLOFFFFFFFFFFFFB15C 6A0D782D lea r30,STACKTOP10FFFFFFFFFFFFB160 0000000F ieppFFFFFFFFFFFFB164 DE000000 nopFFFFFFFFFFFFB168 DE000000 nopFFFFFFFFFFFFB16C E6BFB214 ; SETLOFFFFFFFFFFFFB170 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB174 E6BED3F8 ; SETLOFFFFFFFFFFFFB178 6A0D782D lea r30,STACKTOP11FFFFFFFFFFFFB17C 0000000F ieppFFFFFFFFFFFFB180 DE000000 nopFFFFFFFFFFFFB184 DE000000 nopFFFFFFFFFFFFB188 E6BFB214 ; SETLOFFFFFFFFFFFFB18C 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB190 E6BECFF8 ; SETLOFFFFFFFFFFFFB194 6A0D782D lea r30,STACKTOP12FFFFFFFFFFFFB198 0000000F ieppFFFFFFFFFFFFB19C DE000000 nopFFFFFFFFFFFFB1A0 DE000000 nopFFFFFFFFFFFFB1A4 E6BFB214 ; SETLOFFFFFFFFFFFFB1A8 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB1AC E6BECBF8 ; SETLOFFFFFFFFFFFFB1B0 6A0D782D lea r30,STACKTOP13FFFFFFFFFFFFB1B4 0000000F ieppFFFFFFFFFFFFB1B8 DE000000 nopFFFFFFFFFFFFB1BC DE000000 nopFFFFFFFFFFFFB1C0 E6BFB214 ; SETLOFFFFFFFFFFFFB1C4 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB1C8 E6BEC7F8 ; SETLOFFFFFFFFFFFFB1CC 6A0D782D lea r30,STACKTOP14FFFFFFFFFFFFB1D0 0000000F ieppFFFFFFFFFFFFB1D4 DE000000 nopFFFFFFFFFFFFB1D8 DE000000 nopFFFFFFFFFFFFB1DC E6BFB214 ; SETLOFFFFFFFFFFFFB1E0 6A0D642D lea r25,ctxstartFFFFFFFFFFFFB1E4 E6BEC3F8 ; SETLOFFFFFFFFFFFFB1E8 6A0D782D lea r30,STACKTOP15FFFFFFFFFFFFB1EC 0000000F ieppFFFFFFFFFFFFB1F0 DE000000 nopFFFFFFFFFFFFB1F4 DE000000 nop; Ensure that context zero is the active context;FFFFFFFFFFFFB1F8 ctxstart3:FFFFFFFFFFFFB1F8 02008568 mfspr r1,AXCFFFFFFFFFFFFB1FC BE1000A8 beq r1,r0,ctxstart2FFFFFFFFFFFFB200 0000000F ieppFFFFFFFFFFFFB204 DE000000 nopFFFFFFFFFFFFB208 DE000000 nopFFFFFFFFFFFFB20C BE007F6A bra ctxstart3FFFFFFFFFFFFB210 ctxstart2:FFFFFFFFFFFFB210 6000A0C0 sb r1,AXCstart ; save off the startup context which should be context zero; Entry point for context startup;; Avoid repeating all the system initialization when a context starts up by testing whether; or not the context is the starting context.;FFFFFFFFFFFFB214 ctxstart:FFFFFFFFFFFFB214 02008568 mfspr r1,AXCFFFFFFFFFFFFB218 4A0120C0 lbu r2,AXCstartFFFFFFFFFFFFB21C BE1107E9 bne r1,r2,ctxstart1;; set system vectors; TBA defaults to zero on reset;FFFFFFFFFFFFB220 E0C00000 setlo r3,#0FFFFFFFFFFFFB224 E08001FF setlo r2,#511FFFFFFFFFFFFB228 9A00EA20 lea r1,nmiroutFFFFFFFFFFFFB22C csj5:FFFFFFFFFFFFB22C 66308000 sw r1,[r3]FFFFFFFFFFFFB230 0A318008 addui r3,r3,#8FFFFFFFFFFFFB234 BE017FCF loop r2,csj5FFFFFFFFFFFFB238 E6BFB768 ; SETLOFFFFFFFFFFFFB23C 6A0D042D lea r1,KeybdSC ; keyboard BIOS vectorFFFFFFFFFFFFB240 66008D08 sw r1,0xD08FFFFFFFFFFFFB244 9A00E950 lea r1,irqroutFFFFFFFFFFFFB248 66008E08 sw r1,0xE08 ; set IRQ vectorFFFFFFFFFFFFB24C 9A00E8BC lea r1,dberr_routFFFFFFFFFFFFB250 66008FE0 sw r1,0xFE0 ; set Bus error vectorFFFFFFFFFFFFB254 9A00E8A4 lea r1,iberr_routFFFFFFFFFFFFB258 66008FE8 sw r1,0xFE8 ; set Bus error vectorFFFFFFFFFFFFB25C 9A00EA20 lea r1,nmiroutFFFFFFFFFFFFB260 66008FF0 sw r1,0xFF0 ; set NMI vectorFFFFFFFFFFFFB264 E6BFB7C4 ; SETLOFFFFFFFFFFFFB268 6A0D042D lea r1,KeybdIRQFFFFFFFFFFFFB26C 6600B008 sw r1,keybdIRQvecFFFFFFFFFFFFB270 E6BFB8EC ; SETLOFFFFFFFFFFFFB274 6A0D042D lea r1,Pulse100FFFFFFFFFFFFB278 6600B000 sw r1,p100IRQvecFFFFFFFFFFFFB27C E6BFB628 ; SETLOFFFFFFFFFFFFB280 6A0D042D lea r1,SerialIRQFFFFFFFFFFFFB284 6600B010 sw r1,serialIRQvecFFFFFFFFFFFFB288 9A00CAC4 lea r1,RasterIRQfnFFFFFFFFFFFFB28C 6600B018 sw r1,rasterIRQvec;-------------------------------; Initialize I/O devices;-------------------------------FFFFFFFFFFFFB290 31FFECEC call SerialInitFFFFFFFFFFFFB294 31FFEDEC call KeybdInitFFFFFFFFFFFFB298 31FFECE4 call PICInitFFFFFFFFFFFFB29C 31FFF299 call SetupRasterIRQFFFFFFFFFFFFB2A0 00000040 cli ; enable interrupts; call HelloWorldFFFFFFFFFFFFB2A4 E0C000CE setlo r3,#0xCE ; blue on blueFFFFFFFFFFFFB2A8 62019414 sc r3,ScreenColorFFFFFFFFFFFFB2AC 42019414 lc r3,0x1414FFFFFFFFFFFFB2B0 E0C00020 setlo r3,#32FFFFFFFFFFFFB2B4 62019416 sc r3,0x1416 ; we do a store, then a load through the dcacheFFFFFFFFFFFFB2B8 42011416 lc r2,0x1416 ;FFFFFFFFFFFFB2BC BE218048 beq r2,r3,dcokayFFFFFFFFFFFFB2C0 0000000D dcache_off ; data cache failedFFFFFFFFFFFFB2C4 dcokay:FFFFFFFFFFFFB2C4 620020A8 sc r0,NextToRunTCBFFFFFFFFFFFFB2C8 620020A6 sc r0,RunningTCBFFFFFFFFFFFFB2CC 31FFEED9 call ClearScreenFFFFFFFFFFFFB2D0 31FFEEC4 call ClearBmpScreenFFFFFFFFFFFFB2D4 31FFF1ED call RandomizeSprramFFFFFFFFFFFFB2D8 62001416 sc r0,CursorRowFFFFFFFFFFFFB2DC 62001418 sc r0,CursorColFFFFFFFFFFFFB2E0 E0400001 setlo r1,#1FFFFFFFFFFFFB2E4 6000941A sb r1,CursorFlashFFFFFFFFFFFFB2E8 E6BFB36D ; SETLOFFFFFFFFFFFFB2EC 6A0D042D lea r1,MSGSTARTFFFFFFFFFFFFB2F0 31FFEFF5 call DisplayStringCRLFFFFFFFFFFFFFB2F4 33FFF096 jmp MonitorFFFFFFFFFFFFB2F8 31FFF1F7 call SetupAC97 ; and BeepFFFFFFFFFFFFB2FC E0C00004 setlo r3,#4FFFFFFFFFFFFB300 E69C0600 ; SETLOFFFFFFFFFFFFB304 EE800003 ; SETMIDFFFFFFFFFFFFB308 6A0D0C28 outb r3,LEDFFFFFFFFFFFFB30C 31FFF221 call BeepFFFFFFFFFFFFB310 j4:FFFFFFFFFFFFB310 33FFF096 jmp MonitorFFFFFFFFFFFFB314 BE007FEA bra j4; for now hang the contexts;FFFFFFFFFFFFB318 ctxstart1:FFFFFFFFFFFFB318 BE00000A bra ctxstart1; call ramtest;-----------------------------------------; Hello World!;-----------------------------------------FFFFFFFFFFFFB31C HelloWorld:FFFFFFFFFFFFB31C 0FEF0018 subui r30,r30,#24FFFFFFFFFFFFB320 67E08000 sw r1,[sp]FFFFFFFFFFFFB324 67E10008 sw r2,8[sp]FFFFFFFFFFFFB328 67EF8010 sw lr,16[sp]FFFFFFFFFFFFB32C E6BFB360 ; SETLOFFFFFFFFFFFFB330 6A0D082D lea r2,MSGFFFFFFFFFFFFB334 j3:FFFFFFFFFFFFB334 40208000 lb r1,[r2]FFFFFFFFFFFFB338 BE100088 beq r1,r0,j2FFFFFFFFFFFFB33C 31FFED0C call SerialPutCharFFFFFFFFFFFFB340 0A210001 addui r2,r2,#1FFFFFFFFFFFFB344 BE007F8A bra j3FFFFFFFFFFFFB348 j2:FFFFFFFFFFFFB348 67EF8010 sw lr,16[sp]FFFFFFFFFFFFB34C 67E10008 sw r2,8[sp]FFFFFFFFFFFFB350 67E08000 sw r1,[sp]FFFFFFFFFFFFB354 37EF8018 ret #24FFFFFFFFFFFFB358 0000000000000000 align 16FFFFFFFFFFFFB360 align 16FFFFFFFFFFFFB360 MSG:FFFFFFFFFFFFB360 6F57206F6C6C6548 db "Hello World!",0FFFFFFFFFFFFB36D MSGSTART:FFFFFFFFFFFFB368 7061520021646C72 db "Raptor64 system starting....",0FFFFFFFFFFFFB370 7973203436726F74FFFFFFFFFFFFB378 617473206D657473FFFFFFFFFFFFB380 2E2E2E676E697472FFFFFFFFFFFFB388 000000000000002E align 16FFFFFFFFFFFFB390 align 16;----------------------------------------------------------; Initialize programmable interrupt controller (PIC); 0 = nmi; 1 = keyboard reset; 2 = 1000Hz pulse (context switcher); 3 = 100Hz pulse (cursor flash); 8 = uart; 13 = raster interrupt; 15 = keyboard char;----------------------------------------------------------FFFFFFFFFFFFB390 PICInit:FFFFFFFFFFFFB390 E6BFB3AC ; SETLOFFFFFFFFFFFFB394 6A0D042D lea r1,PICretFFFFFFFFFFFFB398 66009030 sw r1,TickIRQAddr; enable: raster irq,FFFFFFFFFFFFB39C E07FA00F setlo r1,#0xA00F ; enable nmi,kbd_rst,and kbd_irq; A10F enable serial IRQFFFFFFFFFFFFB3A0 E69C0FF2 ; SETLOFFFFFFFFFFFFB3A4 EE800003 ; SETMIDFFFFFFFFFFFFB3A8 6A0D0429 outc r1,PIC_IEFFFFFFFFFFFFB3AC PICret:FFFFFFFFFFFFB3AC 37EF8000 ret;==============================================================================; Serial port;==============================================================================;-----------------------------------------; Initialize the serial port;-----------------------------------------;FFFFFFFFFFFFB3B0 SerialInit:FFFFFFFFFFFFB3B0 62001800 sc r0,Uart_rxhead ; reset buffer indexesFFFFFFFFFFFFB3B4 62001802 sc r0,Uart_rxtailFFFFFFFFFFFFB3B8 E04001F0 setlo r1,#0x1f0FFFFFFFFFFFFB3BC 62009810 sc r1,Uart_foff ; set threshold for XOFFFFFFFFFFFFFFB3C0 E0400010 setlo r1,#0x010FFFFFFFFFFFFB3C4 6200980E sc r1,Uart_fon ; set threshold for XONFFFFFFFFFFFFB3C8 E0400001 setlo r1,#1FFFFFFFFFFFFB3CC E69C0A04 ; SETLOFFFFFFFFFFFFB3D0 EE800003 ; SETMIDFFFFFFFFFFFFB3D4 6A0D0428 outb r1,UART_IE ; enable receive interrupt onlyFFFFFFFFFFFFB3D8 60001809 sb r0,Uart_rxrts ; no RTS/CTS signals availableFFFFFFFFFFFFB3DC 60001812 sb r0,Uart_txrts ; no RTS/CTS signals availableFFFFFFFFFFFFB3E0 60001813 sb r0,Uart_txdtr ; no DTR signals availableFFFFFFFFFFFFB3E4 6000180A sb r0,Uart_rxdtr ; no DTR signals availableFFFFFFFFFFFFB3E8 E0400001 setlo r1,#1FFFFFFFFFFFFB3EC 60009814 sb r1,Uart_txxon ; for nowFFFFFFFFFFFFB3F0 37EF8000 ret;---------------------------------------------------------------------------------; Get character directly from serial port. Blocks until a character is available.;---------------------------------------------------------------------------------;FFFFFFFFFFFFB3F4 SerialGetCharDirect:FFFFFFFFFFFFB3F4 sgc1:FFFFFFFFFFFFB3F4 E69C0A01 ; SETLOFFFFFFFFFFFFB3F8 EE800003 ; SETMIDFFFFFFFFFFFFB3FC 6A0D0420 inb r1,UART_LS ; uart statusFFFFFFFFFFFFB400 14108001 andi r1,r1,#rxfull ; is there a char available ?FFFFFFFFFFFFB404 BE107F88 beq r1,r0,sgc1FFFFFFFFFFFFB408 E69C0A00 ; SETLOFFFFFFFFFFFFB40C EE800003 ; SETMIDFFFFFFFFFFFFB410 6A0D0420 inb r1,UARTFFFFFFFFFFFFB414 37EF8000 ret;------------------------------------------------; Check for a character at the serial port; returns r1 = 1 if char available, 0 otherwise;------------------------------------------------;FFFFFFFFFFFFB418 SerialCheckForCharDirect:FFFFFFFFFFFFB418 E69C0A01 ; SETLOFFFFFFFFFFFFB41C EE800003 ; SETMIDFFFFFFFFFFFFB420 6A0D0420 inb r1,UART_LS ; uart statusFFFFFFFFFFFFB424 14108001 andi r1,r1,#rxfull ; is there a char available ?FFFFFFFFFFFFB428 04100439 sne r1,r1,r0FFFFFFFFFFFFB42C 37EF8000 ret;-----------------------------------------; Put character to serial port; r1 = char to put;-----------------------------------------;FFFFFFFFFFFFB430 SerialPutChar:FFFFFFFFFFFFB430 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFB434 67E10000 sw r2,[sp]FFFFFFFFFFFFB438 67E18008 sw r3,8[sp]FFFFFFFFFFFFB43C 67E20010 sw r4,16[sp]FFFFFFFFFFFFB440 67E28018 sw r5,24[sp]FFFFFFFFFFFFB444 E69C0A06 ; SETLOFFFFFFFFFFFFB448 EE800003 ; SETMIDFFFFFFFFFFFFB44C 6A0D0820 inb r2,UART_MCFFFFFFFFFFFFB450 16210003 ori r2,r2,#3 ; assert DTR / RTSFFFFFFFFFFFFB454 E69C0A06 ; SETLOFFFFFFFFFFFFB458 EE800003 ; SETMIDFFFFFFFFFFFFB45C 6A0D0828 outb r2,UART_MCFFFFFFFFFFFFB460 40011812 lb r2,Uart_txrtsFFFFFFFFFFFFB464 BE200168 beq r2,r0,spcb1FFFFFFFFFFFFB468 46021400 lw r4,MillisecondsFFFFFFFFFFFFB46C E0C00064 setlo r3,#100 ; delay count (1 s)FFFFFFFFFFFFB470 spcb3:FFFFFFFFFFFFB470 80011808 inb r2,UART_MSFFFFFFFFFFFFB474 1421000A andi r2,r2,#10 ; is CTS asserted ?FFFFFFFFFFFFB478 BE2000C9 bne r2,r0,spcb1FFFFFFFFFFFFB47C 46029400 lw r5,MillisecondsFFFFFFFFFFFFB480 BE42FF88 beq r4,r5,spcb3FFFFFFFFFFFFB484 02520009 mov r4,r5FFFFFFFFFFFFB488 BE01FF4F loop r3,spcb3FFFFFFFFFFFFB48C BE00046A bra spcabortFFFFFFFFFFFFB490 spcb1:FFFFFFFFFFFFB490 40011813 lb r2,Uart_txdtrFFFFFFFFFFFFB494 BE200168 beq r2,r0,spcb2FFFFFFFFFFFFB498 46021400 lw r4,MillisecondsFFFFFFFFFFFFB49C E0C00064 setlo r3,#100 ; delay countFFFFFFFFFFFFB4A0 spcb4:FFFFFFFFFFFFB4A0 80011808 inb r2,UART_MSFFFFFFFFFFFFB4A4 14210014 andi r2,r2,#20 ; is DSR asserted ?FFFFFFFFFFFFB4A8 BE2000C9 bne r2,r0,spcb2FFFFFFFFFFFFB4AC 46029400 lw r5,MillisecondsFFFFFFFFFFFFB4B0 BE42FF88 beq r4,r5,spcb4FFFFFFFFFFFFB4B4 02520009 mov r4,r5FFFFFFFFFFFFB4B8 BE01FF4F loop r3,spcb4FFFFFFFFFFFFB4BC BE0002EA bra spcabortFFFFFFFFFFFFB4C0 spcb2:FFFFFFFFFFFFB4C0 40011814 lb r2,Uart_txxonFFFFFFFFFFFFB4C4 BE2000C8 beq r2,r0,spcb5FFFFFFFFFFFFB4C8 spcb6:FFFFFFFFFFFFB4C8 40011815 lb r2,Uart_txxonoffFFFFFFFFFFFFB4CC BE200088 beq r2,r0,spcb5FFFFFFFFFFFFB4D0 80021808 inb r4,UART_MSFFFFFFFFFFFFB4D4 14420080 andi r4,r4,#0x80 ; DCD ?FFFFFFFFFFFFB4D8 BE407F89 bne r4,r0,spcb6FFFFFFFFFFFFB4DC spcb5:FFFFFFFFFFFFB4DC 46021400 lw r4,MillisecondsFFFFFFFFFFFFB4E0 E0C00064 setlo r3,#100 ; wait up to 1sFFFFFFFFFFFFB4E4 spcb8:FFFFFFFFFFFFB4E4 E69C0A01 ; SETLOFFFFFFFFFFFFB4E8 EE800003 ; SETMIDFFFFFFFFFFFFB4EC 6A0D0820 inb r2,UART_LSFFFFFFFFFFFFB4F0 14210020 andi r2,r2,#0x20 ; tx not full ?FFFFFFFFFFFFB4F4 BE2000C9 bne r2,r0,spcb7FFFFFFFFFFFFB4F8 46029400 lw r5,MillisecondsFFFFFFFFFFFFB4FC BE42FF48 beq r4,r5,spcb8FFFFFFFFFFFFB500 02520009 mov r4,r5FFFFFFFFFFFFB504 BE01FF0F loop r3,spcb8FFFFFFFFFFFFB508 BE00008A bra spcabortFFFFFFFFFFFFB50C spcb7:FFFFFFFFFFFFB50C E69C0A00 ; SETLOFFFFFFFFFFFFB510 EE800003 ; SETMIDFFFFFFFFFFFFB514 6A0D0428 outb r1,UARTFFFFFFFFFFFFB518 spcabort:FFFFFFFFFFFFB518 47E10000 lw r2,[sp]FFFFFFFFFFFFB51C 47E18008 lw r3,8[sp]FFFFFFFFFFFFB520 47E20010 lw r4,16[sp]FFFFFFFFFFFFB524 47E28018 lw r5,24[sp]FFFFFFFFFFFFB528 37EF8020 ret #32;-------------------------------------------------; Compute number of characters in recieve buffer.; r4 = number of chars;-------------------------------------------------FFFFFFFFFFFFB52C CharsInRxBuf:FFFFFFFFFFFFB52C 42021800 lc r4,Uart_rxheadFFFFFFFFFFFFB530 42011802 lc r2,Uart_rxtailFFFFFFFFFFFFB534 04411005 subu r4,r4,r2FFFFFFFFFFFFB538 BE4000A3 bgt r4,r0,cirxb1FFFFFFFFFFFFB53C E1000200 setlo r4,#0x200FFFFFFFFFFFFB540 04411003 addu r4,r4,r2FFFFFFFFFFFFB544 42011800 lc r2,Uart_rxheadFFFFFFFFFFFFB548 04411005 subu r4,r4,r2FFFFFFFFFFFFB54C cirxb1:FFFFFFFFFFFFB54C 37EF8000 ret;----------------------------------------------; Get character from rx fifo; If the fifo is empty enough then send an XON;----------------------------------------------;FFFFFFFFFFFFB550 SerialGetChar:FFFFFFFFFFFFB550 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFB554 67E10000 sw r2,[sp]FFFFFFFFFFFFB558 67E18008 sw r3,8[sp]FFFFFFFFFFFFB55C 67E20010 sw r4,16[sp]FFFFFFFFFFFFB560 67EF8018 sw lr,24[sp]FFFFFFFFFFFFB564 42019800 lc r3,Uart_rxheadFFFFFFFFFFFFB568 42011802 lc r2,Uart_rxtailFFFFFFFFFFFFB56C BE218528 beq r2,r3,sgcfifo1 ; is there a char available ?FFFFFFFFFFFFB570 9A019600 lea r3,Uart_rxfifoFFFFFFFFFFFFB574 6A218400 lb r1,[r2+r3] ; get the char from the fifo into r1FFFFFFFFFFFFB578 0A210001 addui r2,r2,#1 ; increment the fifo pointerFFFFFFFFFFFFB57C 142101FF andi r2,r2,#0x1ffFFFFFFFFFFFFB580 62011802 sc r2,Uart_rxtailFFFFFFFFFFFFB584 4001180C lb r2,Uart_rxflow ; using flow control ?FFFFFFFFFFFFB588 BE2003A8 beq r2,r0,sgcfifo2FFFFFFFFFFFFB58C 4201980E lc r3,Uart_fon ; enough space in Rx buffer ?FFFFFFFFFFFFB590 31FFED4B call CharsInRxBufFFFFFFFFFFFFB594 BE418343 bgt r4,r3,sgcfifo2FFFFFFFFFFFFB598 6000180C sb r0,Uart_rxflow ; flow offFFFFFFFFFFFFB59C 40021809 lb r4,Uart_rxrtsFFFFFFFFFFFFB5A0 BE400108 beq r4,r0,sgcfifo3FFFFFFFFFFFFB5A4 E69C0A06 ; SETLOFFFFFFFFFFFFB5A8 EE800003 ; SETMIDFFFFFFFFFFFFB5AC 6A0D1020 inb r4,UART_MC ; set rts bit in MCFFFFFFFFFFFFB5B0 16420002 ori r4,r4,#2FFFFFFFFFFFFB5B4 E69C0A06 ; SETLOFFFFFFFFFFFFB5B8 EE800003 ; SETMIDFFFFFFFFFFFFB5BC 6A0D1028 outb r4,UART_MCFFFFFFFFFFFFB5C0 sgcfifo3:FFFFFFFFFFFFB5C0 4002180A lb r4,Uart_rxdtrFFFFFFFFFFFFB5C4 BE400108 beq r4,r0,sgcfifo4FFFFFFFFFFFFB5C8 E69C0A06 ; SETLOFFFFFFFFFFFFB5CC EE800003 ; SETMIDFFFFFFFFFFFFB5D0 6A0D1020 inb r4,UART_MC ; set DTRFFFFFFFFFFFFB5D4 16420001 ori r4,r4,#1FFFFFFFFFFFFB5D8 E69C0A06 ; SETLOFFFFFFFFFFFFB5DC EE800003 ; SETMIDFFFFFFFFFFFFB5E0 6A0D1028 outb r4,UART_MCFFFFFFFFFFFFB5E4 sgcfifo4:FFFFFFFFFFFFB5E4 4002180B lb r4,Uart_rxxonFFFFFFFFFFFFB5E8 BE4000A8 beq r4,r0,sgcfifo5FFFFFFFFFFFFB5EC E1000011 setlo r4,#XONFFFFFFFFFFFFB5F0 E69C0A00 ; SETLOFFFFFFFFFFFFB5F4 EE800003 ; SETMIDFFFFFFFFFFFFB5F8 6A0D1028 outb r4,UARTFFFFFFFFFFFFB5FC sgcfifo5:FFFFFFFFFFFFB5FC sgcfifo2: ; return with char in r1FFFFFFFFFFFFB5FC 47E10000 lw r2,[sp]FFFFFFFFFFFFB600 47E18008 lw r3,8[sp]FFFFFFFFFFFFB604 47E20010 lw r4,16[sp]FFFFFFFFFFFFB608 47EF8018 lw lr,24[sp]FFFFFFFFFFFFB60C 37EF8020 ret #32FFFFFFFFFFFFB610 sgcfifo1:FFFFFFFFFFFFB610 E07FFFFF setlo r1,#-1 ; no char availableFFFFFFFFFFFFB614 47E10000 lw r2,[sp]FFFFFFFFFFFFB618 47E18008 lw r3,8[sp]FFFFFFFFFFFFB61C 47E20010 lw r4,16[sp]FFFFFFFFFFFFB620 47EF8018 lw lr,24[sp]FFFFFFFFFFFFB624 37EF8020 ret #32;-----------------------------------------; Serial port IRQ;-----------------------------------------;FFFFFFFFFFFFB628 SerialIRQ:FFFFFFFFFFFFB628 0FEF0028 subui sp,sp,#40FFFFFFFFFFFFB62C 67E08000 sw r1,[sp]FFFFFFFFFFFFB630 67E10008 sw r2,8[sp]FFFFFFFFFFFFB634 67E18010 sw r3,16[sp]FFFFFFFFFFFFB638 67E20018 sw r4,24[sp]FFFFFFFFFFFFB63C 67EF8020 sw lr,32[sp]FFFFFFFFFFFFB640 E69C0A03 ; SETLOFFFFFFFFFFFFB644 EE800003 ; SETMIDFFFFFFFFFFFFB648 6A0D0420 inb r1,UART_IS ; get interrupt statusFFFFFFFFFFFFB64C BE1000A1 bge r1,r0,sirq1FFFFFFFFFFFFB650 1410807F andi r1,r1,#0x7f ; switch on interrupt typeFFFFFFFFFFFFB654 B0100D04 beqi r1,#4,srxirqFFFFFFFFFFFFB658 B0100B0C beqi r1,#0xC,stxirqFFFFFFFFFFFFB65C B0100710 beqi r1,#0x10,smsirqFFFFFFFFFFFFB660 sirq1:FFFFFFFFFFFFB660 47E08000 lw r1,[sp]FFFFFFFFFFFFB664 47E10008 lw r2,8[sp]FFFFFFFFFFFFB668 47E18010 lw r3,16[sp]FFFFFFFFFFFFB66C 47E20018 lw r4,24[sp]FFFFFFFFFFFFB670 47EF8020 lw lr,32[sp]FFFFFFFFFFFFB674 37EF8028 ret #40; Get the modem status and record itFFFFFFFFFFFFB678 smsirq:FFFFFFFFFFFFB678 80009808 inb r1,UART_MSFFFFFFFFFFFFB67C 60009808 sb r1,Uart_msFFFFFFFFFFFFB680 BE007F0A bra sirq1FFFFFFFFFFFFB684 stxirq:FFFFFFFFFFFFB684 BE007EEA bra sirq1; Get a character from the uart and store it in the rx fifoFFFFFFFFFFFFB688 srxirq:FFFFFFFFFFFFB688 srxirq1:FFFFFFFFFFFFB688 E69C0A00 ; SETLOFFFFFFFFFFFFB68C EE800003 ; SETMIDFFFFFFFFFFFFB690 6A0D0420 inb r1,UART ; get the char (clears interrupt)FFFFFFFFFFFFB694 40011814 lb r2,Uart_txxonFFFFFFFFFFFFB698 BE200108 beq r2,r0,srxirq3FFFFFFFFFFFFB69C B2100413 bnei r1,#XOFF,srxirq2FFFFFFFFFFFFB6A0 E0400001 setlo r1,#1FFFFFFFFFFFFB6A4 60009815 sb r1,Uart_txxonoffFFFFFFFFFFFFB6A8 BE00016A bra srxirq5FFFFFFFFFFFFB6AC srxirq2:FFFFFFFFFFFFB6AC B2100311 bnei r1,#XON,srxirq3FFFFFFFFFFFFB6B0 60001815 sb r0,Uart_txxonoffFFFFFFFFFFFFB6B4 BE00010A bra srxirq5FFFFFFFFFFFFB6B8 srxirq3:FFFFFFFFFFFFB6B8 60001815 sb r0,Uart_txxonoffFFFFFFFFFFFFB6BC 42011800 lc r2,Uart_rxheadFFFFFFFFFFFFB6C0 9A019600 lea r3,Uart_rxfifoFFFFFFFFFFFFB6C4 6A310410 sb r1,[r3+r2] ; store in bufferFFFFFFFFFFFFB6C8 0A210001 addui r2,r2,#1FFFFFFFFFFFFB6CC 142101FF andi r2,r2,#0x1ffFFFFFFFFFFFFB6D0 62011800 sc r2,Uart_rxheadFFFFFFFFFFFFB6D4 srxirq5:FFFFFFFFFFFFB6D4 E69C0A01 ; SETLOFFFFFFFFFFFFB6D8 EE800003 ; SETMIDFFFFFFFFFFFFB6DC 6A0D0420 inb r1,UART_LS ; check for another ready characterFFFFFFFFFFFFB6E0 14108001 andi r1,r1,#rxfullFFFFFFFFFFFFB6E4 BE107D29 bne r1,r0,srxirq1FFFFFFFFFFFFB6E8 4000980C lb r1,Uart_rxflow ; are we using flow controls?FFFFFFFFFFFFB6EC BE1003C9 bne r1,r0,srxirq8FFFFFFFFFFFFB6F0 31FFED4B call CharsInRxBufFFFFFFFFFFFFB6F4 42009810 lc r1,Uart_foffFFFFFFFFFFFFB6F8 BE408360 blt r4,r1,srxirq8FFFFFFFFFFFFB6FC E0400001 setlo r1,#1FFFFFFFFFFFFB700 6000980C sb r1,Uart_rxflowFFFFFFFFFFFFB704 40009809 lb r1,Uart_rxrtsFFFFFFFFFFFFB708 BE100108 beq r1,r0,srxirq6FFFFFFFFFFFFB70C E69C0A06 ; SETLOFFFFFFFFFFFFB710 EE800003 ; SETMIDFFFFFFFFFFFFB714 6A0D0420 inb r1,UART_MCFFFFFFFFFFFFB718 141080FD andi r1,r1,#0xFD ; turn off RTSFFFFFFFFFFFFB71C E69C0A06 ; SETLOFFFFFFFFFFFFB720 EE800003 ; SETMIDFFFFFFFFFFFFB724 6A0D0428 outb r1,UART_MCFFFFFFFFFFFFB728 srxirq6:FFFFFFFFFFFFB728 4000980A lb r1,Uart_rxdtrFFFFFFFFFFFFB72C BE100108 beq r1,r0,srxirq7FFFFFFFFFFFFB730 E69C0A06 ; SETLOFFFFFFFFFFFFB734 EE800003 ; SETMIDFFFFFFFFFFFFB738 6A0D0420 inb r1,UART_MCFFFFFFFFFFFFB73C 141080FE andi r1,r1,#0xFE ; turn off DTRFFFFFFFFFFFFB740 E69C0A06 ; SETLOFFFFFFFFFFFFB744 EE800003 ; SETMIDFFFFFFFFFFFFB748 6A0D0428 outb r1,UART_MCFFFFFFFFFFFFB74C srxirq7:FFFFFFFFFFFFB74C 4000980B lb r1,Uart_rxxonFFFFFFFFFFFFB750 BE1000A8 beq r1,r0,srxirq8FFFFFFFFFFFFB754 E0400013 setlo r1,#XOFFFFFFFFFFFFFFB758 E69C0A00 ; SETLOFFFFFFFFFFFFB75C EE800003 ; SETMIDFFFFFFFFFFFFB760 6A0D0428 outb r1,UARTFFFFFFFFFFFFB764 srxirq8:FFFFFFFFFFFFB764 BE0077EA bra sirq1;==============================================================================; Keyboard BIOS; BIOS interrupt #417;; Function in R1; 0 = initialize keyboard; 1 = set keyboard echo; 2 = get keyboard character; 3 = check for key available;==============================================================================;FFFFFFFFFFFFB768 KeybdSC:FFFFFFFFFFFFB768 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFB76C 67EF8000 sw lr,[sp]FFFFFFFFFFFFB770 B2100300 bnei r1,#0,kbdsc1FFFFFFFFFFFFB774 31FFEDEC call KeybdInitFFFFFFFFFFFFB778 BE00016A bra kbdscRetFFFFFFFFFFFFB77C kbdsc1:FFFFFFFFFFFFB77C B2100401 bnei r1,#1,kbdsc2FFFFFFFFFFFFB780 02208009 mov r1,r2FFFFFFFFFFFFB784 31FFEE06 call SetKeyboardEchoFFFFFFFFFFFFB788 BE0000EA bra kbdscRetFFFFFFFFFFFFB78C kbdsc2:FFFFFFFFFFFFB78C B2100302 bnei r1,#2,kbdsc3FFFFFFFFFFFFB790 31FFEE08 call KeybdGetCharFFFFFFFFFFFFB794 BE00008A bra kbdscRetFFFFFFFFFFFFB798 kbdsc3:FFFFFFFFFFFFB798 B2100303 bnei r1,#3,kbdsc4FFFFFFFFFFFFB79C 31FFEE1D call KeybdCheckForKeyFFFFFFFFFFFFB7A0 BE00002A bra kbdscRetFFFFFFFFFFFFB7A4 kbdsc4:FFFFFFFFFFFFB7A4 kbdscRet:FFFFFFFFFFFFB7A4 47EF8000 lw lr,[sp]FFFFFFFFFFFFB7A8 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFB7AC 01800021 eret;------------------------------------------------------------------------------; Initialize keyboard;------------------------------------------------------------------------------FFFFFFFFFFFFB7B0 KeybdInit:FFFFFFFFFFFFB7B0 60001450 sb r0,KeybdHeadFFFFFFFFFFFFB7B4 60001451 sb r0,KeybdTailFFFFFFFFFFFFB7B8 E0400001 setlo r1,#1 ; turn on keyboard echoFFFFFFFFFFFFB7BC 6000941C sb r1,KeybdEchoFFFFFFFFFFFFB7C0 37EF8000 ret;------------------------------------------------------------------------------; Normal keyboard interrupt, the lowest priority interrupt in the system.; Grab the character from the keyboard device and store it in a buffer.;------------------------------------------------------------------------------;FFFFFFFFFFFFB7C4 KeybdIRQ:FFFFFFFFFFFFB7C4 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFB7C8 67E10000 sw r2,[sp]FFFFFFFFFFFFB7CC 4A009450 lbu r1,KeybdHeadFFFFFFFFFFFFB7D0 1410800F andi r1,r1,#0x0f ; r1 = index into bufferFFFFFFFFFFFFB7D4 KeybdIRQa:FFFFFFFFFFFFB7D4 E69C0000 ; SETLOFFFFFFFFFFFFB7D8 EE800003 ; SETMIDFFFFFFFFFFFFB7DC 6A0D0821 inch r2,KEYBD ; get keyboard characterFFFFFFFFFFFFB7E0 E69C0002 ; SETLOFFFFFFFFFFFFB7E4 EE800003 ; SETMIDFFFFFFFFFFFFB7E8 6A0D0029 outc r0,KEYBD+2 ; clear keyboard strobe (turns off the IRQ)FFFFFFFFFFFFB7EC 60111440 sb r2,KeybdBuffer[r1] ; store character in bufferFFFFFFFFFFFFB7F0 0A108001 addui r1,r1,#1 ; increment head indexFFFFFFFFFFFFB7F4 1410800F andi r1,r1,#0x0fFFFFFFFFFFFFB7F8 60009450 sb r1,KeybdHeadFFFFFFFFFFFFB7FC KeybdIRQb:FFFFFFFFFFFFB7FC 4A011451 lbu r2,KeybdTail ; check to see if we've collidedFFFFFFFFFFFFB800 BE110089 bne r1,r2,KeybdIRQc ; with the tailFFFFFFFFFFFFB804 0A210001 addui r2,r2,#1 ; if so, increment the tail indexFFFFFFFFFFFFB808 1421000F andi r2,r2,#0x0f ; the oldest character will be lostFFFFFFFFFFFFB80C 60011451 sb r2,KeybdTailFFFFFFFFFFFFB810 KeybdIRQc:FFFFFFFFFFFFB810 47E10000 lw r2,[sp]FFFFFFFFFFFFB814 37EF8008 ret #8;------------------------------------------------------------------------------; r1 0=echo off, non-zero = echo on;------------------------------------------------------------------------------FFFFFFFFFFFFB818 SetKeyboardEcho:FFFFFFFFFFFFB818 6000941C sb r1,KeybdEchoFFFFFFFFFFFFB81C 37EF8000 ret;-----------------------------------------; Get character from keyboard buffer;-----------------------------------------FFFFFFFFFFFFB820 KeybdGetChar:FFFFFFFFFFFFB820 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFB824 67E10000 sw r2,[sp]FFFFFFFFFFFFB828 67EF8008 sw lr,8[sp]FFFFFFFFFFFFB82C 4A011451 lbu r2,KeybdTailFFFFFFFFFFFFB830 4A009450 lbu r1,KeybdHeadFFFFFFFFFFFFB834 BE110188 beq r1,r2,nocharFFFFFFFFFFFFB838 4A209440 lbu r1,KeybdBuffer[r2]FFFFFFFFFFFFB83C 0A210001 addui r2,r2,#1FFFFFFFFFFFFB840 1421000F andi r2,r2,#0x0fFFFFFFFFFFFFB844 60011451 sb r2,KeybdTailFFFFFFFFFFFFB848 4001141C lb r2,KeybdEchoFFFFFFFFFFFFB84C BE2000E8 beq r2,r0,kgc3FFFFFFFFFFFFB850 B210030D bnei r1,#CR,kgc2FFFFFFFFFFFFB854 31FFF93F call CRLF ; convert CR keystroke into CRLFFFFFFFFFFFFFB858 BE00008A bra kgc3FFFFFFFFFFFFB85C kgc2:FFFFFFFFFFFFB85C 31FFEF47 call DisplayCharFFFFFFFFFFFFB860 BE00004A bra kgc3FFFFFFFFFFFFB864 nochar:FFFFFFFFFFFFB864 E07FFFFF setlo r1,#-1FFFFFFFFFFFFB868 kgc3:FFFFFFFFFFFFB868 47EF8008 lw lr,8[sp]FFFFFFFFFFFFB86C 47E10000 lw r2,[sp]FFFFFFFFFFFFB870 37EF8010 ret #16;------------------------------------------------------------------------------; Check if there is a keyboard character available in the keyboard buffer.;------------------------------------------------------------------------------;FFFFFFFFFFFFB874 KeybdCheckForKey:FFFFFFFFFFFFB874 4A009451 lbu r1,KeybdTailFFFFFFFFFFFFB878 4A011450 lbu r2,KeybdHeadFFFFFFFFFFFFB87C 04110439 sne r1,r1,r2FFFFFFFFFFFFB880 37EF8000 ret;------------------------------------------------------------------------------; Check if there is a keyboard character available. If so return true (1); otherwise return false (0) in r1.;------------------------------------------------------------------------------;FFFFFFFFFFFFB884 KeybdCheckForKeyDirect:FFFFFFFFFFFFB884 E69C0000 ; SETLOFFFFFFFFFFFFB888 EE800003 ; SETMIDFFFFFFFFFFFFB88C 6A0D0421 inch r1,KEYBDFFFFFFFFFFFFB890 04100430 slt r1,r1,r0FFFFFFFFFFFFB894 37EF8000 ret;------------------------------------------------------------------------------; Get character directly from keyboard. This routine blocks until a key is; available.;------------------------------------------------------------------------------;FFFFFFFFFFFFB898 KeybdGetCharDirect:FFFFFFFFFFFFB898 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFB89C 67E10000 sw r2,[sp]FFFFFFFFFFFFB8A0 67EF8008 sw lr,8[sp]FFFFFFFFFFFFB8A4 E09C0000 setlo r2,KEYBDFFFFFFFFFFFFB8A8 kgc1:FFFFFFFFFFFFB8A8 E69C0000 ; SETLOFFFFFFFFFFFFB8AC EE800003 ; SETMIDFFFFFFFFFFFFB8B0 6A0D0421 inch r1,KEYBDFFFFFFFFFFFFB8B4 BE107FA1 bge r1,r0,kgc1FFFFFFFFFFFFB8B8 E69C0002 ; SETLOFFFFFFFFFFFFB8BC EE800003 ; SETMIDFFFFFFFFFFFFB8C0 6A0D0029 outc r0,KEYBD+2 ; clear keyboard strobeFFFFFFFFFFFFB8C4 141080FF andi r1,r1,#0xff ; remove strobe bitFFFFFFFFFFFFB8C8 4001141C lb r2,KeybdEcho ; is keyboard echo on ?FFFFFFFFFFFFB8CC BE2000A8 beq r2,r0,gk1FFFFFFFFFFFFB8D0 B210030D bnei r1,#'\r',gk2 ; convert CR keystroke into CRLFFFFFFFFFFFFFB8D4 31FFF93F call CRLFFFFFFFFFFFFFB8D8 BE00004A bra gk1FFFFFFFFFFFFB8DC gk2:FFFFFFFFFFFFB8DC 31FFEF47 call DisplayCharFFFFFFFFFFFFB8E0 gk1:FFFFFFFFFFFFB8E0 47E10000 lw r2,[sp]FFFFFFFFFFFFB8E4 47EF8008 lw lr,8[sp]FFFFFFFFFFFFB8E8 37EF8010 ret #16;==============================================================================;==============================================================================;------------------------------------------------------------------------------; 100 Hz interrupt; - takes care of "flashing" the cursor;------------------------------------------------------------------------------;FFFFFFFFFFFFB8EC Pulse100:FFFFFFFFFFFFB8EC 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFB8F0 67EF8000 sw lr,[sp]FFFFFFFFFFFFB8F4 E6900000 ; SETLOFFFFFFFFFFFFB8F8 EE800003 ; SETMIDFFFFFFFFFFFFB8FC 6A0D082D lea r2,TEXTSCRFFFFFFFFFFFFB900 8220814E inch r1,334[r2]FFFFFFFFFFFFB904 0A108001 addui r1,r1,#1FFFFFFFFFFFFB908 9220814E outc r1,334[r2]FFFFFFFFFFFFB90C 31FFF2D8 call DisplayDatetimeFFFFFFFFFFFFB910 31FFEE4A call SelectNextToRunTCBFFFFFFFFFFFFB914 31FFEE4C call SwitchTaskFFFFFFFFFFFFB918 E6BF0010 ; SETLOFFFFFFFFFFFFB91C 6A0D0010 sb r0,0xFFFF_FFFF_FFFF_0010 ; clear interrupt; lw r1,TickIRQAddr; jal r31,[r1]; lw r1,Milliseconds; andi r1,r1,#0x0f; bnei r1,#5,p1001; call FlashCursorFFFFFFFFFFFFB920 p1001:FFFFFFFFFFFFB920 47EF8000 lw lr,[sp]FFFFFFFFFFFFB924 37EF8008 ret #8;------------------------------------------------------------------------------;------------------------------------------------------------------------------FFFFFFFFFFFFB928 SelectNextToRunTCB:FFFFFFFFFFFFB928 620020A8 sc r0,NextToRunTCBFFFFFFFFFFFFB92C 37EF8000 ret;------------------------------------------------------------------------------; Switch from the RunningTCB to the NextToRunTCB;------------------------------------------------------------------------------FFFFFFFFFFFFB930 SwitchTask:FFFFFFFFFFFFB930 6600A0B0 sw r1,r1saveFFFFFFFFFFFFB934 660120B8 sw r2,r2saveFFFFFFFFFFFFB938 4C00A0A8 lcu r1,NextToRunTCBFFFFFFFFFFFFB93C 4C0120A6 lcu r2,RunningTCBFFFFFFFFFFFFB940 BE110089 bne r1,r2,swtsk1 ; are we already running this TCB ?FFFFFFFFFFFFB944 4600A0B0 lw r1,r1saveFFFFFFFFFFFFB948 460120B8 lw r2,r2saveFFFFFFFFFFFFB94C 37EF8000 retFFFFFFFFFFFFB950 swtsk1:FFFFFFFFFFFFB950 142101FF andi r2,r2,#0x1ff ; max 512 TCB'sFFFFFFFFFFFFB954 1A210200 mului r2,r2,#TCBSizeFFFFFFFFFFFFB958 E6800000 ; SETLOFFFFFFFFFFFFB95C EE800400 ; SETMIDFFFFFFFFFFFFB960 042D0803 addui r2,r2,#TCBBaseFFFFFFFFFFFFB964 4600A0B0 lw r1,r1save ; get back r1FFFFFFFFFFFFB968 66208000 sw r1,TCBr1[r2]FFFFFFFFFFFFB96C 4600A0B8 lw r1,r2save ; get back r2FFFFFFFFFFFFB970 66208008 sw r1,TCBr2[r2]FFFFFFFFFFFFB974 66218010 sw r3,TCBr3[r2]FFFFFFFFFFFFB978 66220018 sw r4,TCBr4[r2]FFFFFFFFFFFFB97C 66228020 sw r5,TCBr5[r2]FFFFFFFFFFFFB980 66230028 sw r6,TCBr6[r2]FFFFFFFFFFFFB984 66238030 sw r7,TCBr7[r2]FFFFFFFFFFFFB988 66240038 sw r8,TCBr8[r2]FFFFFFFFFFFFB98C 66248040 sw r9,TCBr9[r2]FFFFFFFFFFFFB990 66250048 sw r10,TCBr10[r2]FFFFFFFFFFFFB994 66258050 sw r11,TCBr11[r2]FFFFFFFFFFFFB998 66260058 sw r12,TCBr12[r2]FFFFFFFFFFFFB99C 66268060 sw r13,TCBr13[r2]FFFFFFFFFFFFB9A0 66270068 sw r14,TCBr14[r2]FFFFFFFFFFFFB9A4 66278070 sw r15,TCBr15[r2]FFFFFFFFFFFFB9A8 66280078 sw r16,TCBr16[r2]FFFFFFFFFFFFB9AC 66288080 sw r17,TCBr17[r2]FFFFFFFFFFFFB9B0 66290088 sw r18,TCBr18[r2]FFFFFFFFFFFFB9B4 66298090 sw r19,TCBr19[r2]FFFFFFFFFFFFB9B8 662A0098 sw r20,TCBr20[r2]FFFFFFFFFFFFB9BC 662A80A0 sw r21,TCBr21[r2]FFFFFFFFFFFFB9C0 662B00A8 sw r22,TCBr22[r2]FFFFFFFFFFFFB9C4 662B80B0 sw r23,TCBr23[r2]FFFFFFFFFFFFB9C8 662C00B8 sw r24,TCBr24[r2]FFFFFFFFFFFFB9CC 662C80C0 sw r25,TCBr25[r2]FFFFFFFFFFFFB9D0 662D00C8 sw r26,TCBr26[r2]FFFFFFFFFFFFB9D4 662D80D0 sw r27,TCBr27[r2]FFFFFFFFFFFFB9D8 662E00D8 sw r28,TCBr28[r2]FFFFFFFFFFFFB9DC 662E80E0 sw r29,TCBr29[r2]FFFFFFFFFFFFB9E0 662F00E8 sw r30,TCBr30[r2]FFFFFFFFFFFFB9E4 662F80F0 sw r31,TCBr31[r2]FFFFFFFFFFFFB9E8 4C0120A8 lcu r2,NextToRunTCBFFFFFFFFFFFFB9EC 620120A6 sc r2,RunningTCBFFFFFFFFFFFFB9F0 1A210200 mului r2,r2,#TCBSizeFFFFFFFFFFFFB9F4 E6800000 ; SETLOFFFFFFFFFFFFB9F8 EE800400 ; SETMIDFFFFFFFFFFFFB9FC 042D0803 addui r2,r2,#TCBBaseFFFFFFFFFFFFBA00 46208000 lw r1,TCBr1[r2]FFFFFFFFFFFFBA04 46218010 lw r3,TCBr3[r2]FFFFFFFFFFFFBA08 46220018 lw r4,TCBr4[r2]FFFFFFFFFFFFBA0C 46228020 lw r5,TCBr5[r2]FFFFFFFFFFFFBA10 46230028 lw r6,TCBr6[r2]FFFFFFFFFFFFBA14 46238030 lw r7,TCBr7[r2]FFFFFFFFFFFFBA18 46240038 lw r8,TCBr8[r2]FFFFFFFFFFFFBA1C 46248040 lw r9,TCBr9[r2]FFFFFFFFFFFFBA20 46250048 lw r10,TCBr10[r2]FFFFFFFFFFFFBA24 46258050 lw r11,TCBr11[r2]FFFFFFFFFFFFBA28 46260058 lw r12,TCBr12[r2]FFFFFFFFFFFFBA2C 46268060 lw r13,TCBr13[r2]FFFFFFFFFFFFBA30 46270068 lw r14,TCBr14[r2]FFFFFFFFFFFFBA34 46278070 lw r15,TCBr15[r2]FFFFFFFFFFFFBA38 46280078 lw r16,TCBr16[r2]FFFFFFFFFFFFBA3C 46288080 lw r17,TCBr17[r2]FFFFFFFFFFFFBA40 46290088 lw r18,TCBr18[r2]FFFFFFFFFFFFBA44 46298090 lw r19,TCBr19[r2]FFFFFFFFFFFFBA48 462A0098 lw r20,TCBr20[r2]FFFFFFFFFFFFBA4C 462A80A0 lw r21,TCBr21[r2]FFFFFFFFFFFFBA50 462B00A8 lw r22,TCBr22[r2]FFFFFFFFFFFFBA54 462B80B0 lw r23,TCBr23[r2]FFFFFFFFFFFFBA58 462C00B8 lw r24,TCBr24[r2]FFFFFFFFFFFFBA5C 462C80C0 lw r25,TCBr25[r2]FFFFFFFFFFFFBA60 462D00C8 lw r26,TCBr26[r2]FFFFFFFFFFFFBA64 462D80D0 lw r27,TCBr27[r2]FFFFFFFFFFFFBA68 462E00D8 lw r28,TCBr28[r2]FFFFFFFFFFFFBA6C 462E80E0 lw r29,TCBr29[r2]FFFFFFFFFFFFBA70 462F00E8 lw r30,TCBr30[r2]FFFFFFFFFFFFBA74 462F80F0 lw r31,TCBr31[r2]FFFFFFFFFFFFBA78 46210008 lw r2,TCBr2[r2]FFFFFFFFFFFFBA7C 37EF8000 ret;------------------------------------------------------------------------------; Flash Cursor;------------------------------------------------------------------------------;FFFFFFFFFFFFBA80 FlashCursor:FFFFFFFFFFFFBA80 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBA84 67E08000 sw r1,[sp]FFFFFFFFFFFFBA88 67E10008 sw r2,8[sp]FFFFFFFFFFFFBA8C 67E18010 sw r3,16[sp]FFFFFFFFFFFFBA90 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBA94 31FFEF37 call CalcScreenLocFFFFFFFFFFFFBA98 E6810000 ; SETLOFFFFFFFFFFFFBA9C 041D0403 addui r1,r1,#0x10000FFFFFFFFFFFFBAA0 4001141A lb r2,CursorFlashFFFFFFFFFFFFBAA4 BE2001C8 beq r2,r0,flshcrsr2; causes screen colors to flip aroundFFFFFFFFFFFFBAA8 82110000 inch r2,[r1]FFFFFFFFFFFFBAAC 0A210001 addui r2,r2,#1FFFFFFFFFFFFBAB0 92110000 outc r2,[r1]FFFFFFFFFFFFBAB4 flshcrsr3:FFFFFFFFFFFFBAB4 46011408 lw r2,LastlocFFFFFFFFFFFFBAB8 BE110088 beq r1,r2,flshcrsr1; restore the screen colors of the previous cursor locationFFFFFFFFFFFFBABC 42019414 lc r3,ScreenColorFFFFFFFFFFFFBAC0 92218000 outc r3,[r2]FFFFFFFFFFFFBAC4 66009408 sw r1,LastlocFFFFFFFFFFFFBAC8 flshcrsr1:FFFFFFFFFFFFBAC8 47E08000 lw r1,[sp]FFFFFFFFFFFFBACC 47E10008 lw r2,8[sp]FFFFFFFFFFFFBAD0 47E18010 lw r3,16[sp]FFFFFFFFFFFFBAD4 47EF8018 lw lr,24[sp]FFFFFFFFFFFFBAD8 37EF8020 ret #32FFFFFFFFFFFFBADC flshcrsr2:FFFFFFFFFFFFBADC 42019414 lc r3,ScreenColorFFFFFFFFFFFFBAE0 92118000 outc r3,[r1]FFFFFFFFFFFFBAE4 BE007E8A bra flshcrsr3FFFFFFFFFFFFBAE8 CursorOff:FFFFFFFFFFFFBAE8 160080A0 lw r1,#0xA0FFFFFFFFFFFFBAEC E69A0010 ; SETLOFFFFFFFFFFFFBAF0 EE800003 ; SETMIDFFFFFFFFFFFFBAF4 6A0D0429 outc r1,TEXTREG+16 ; turn off cursorFFFFFFFFFFFFBAF8 37EF8000 retFFFFFFFFFFFFBAFC CursorOn:FFFFFFFFFFFFBAFC 160080E0 lw r1,#0xE0FFFFFFFFFFFFBB00 E69A0010 ; SETLOFFFFFFFFFFFFBB04 EE800003 ; SETMIDFFFFFFFFFFFFBB08 6A0D0429 outc r1,TEXTREG+16 ; turn on cursorFFFFFFFFFFFFBB0C 37EF8000 ret;------------------------------------------------------------------------------;------------------------------------------------------------------------------FFFFFFFFFFFFBB10 ClearBmpScreen:FFFFFFFFFFFFBB10 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFBB14 67E08000 sw r1,[sp]FFFFFFFFFFFFBB18 67E10008 sw r2,8[sp]FFFFFFFFFFFFBB1C 67E18010 sw r3,16[sp]FFFFFFFFFFFFBB20 E68FFC00 ; SETLOFFFFFFFFFFFFBB24 040D0809 lw r2,#1364*768FFFFFFFFFFFFBB28 06210601 shrui r2,r2,#3 ; r2 = # words to clearFFFFFFFFFFFFBB2C E6A92929 ; SETLOFFFFFFFFFFFFBB30 EEA4A4A4 ; SETMIDFFFFFFFFFFFFBB34 F6829292 ; SETHIFFFFFFFFFFFFBB38 6A0D042D lea r1,0x2929292929292929 ; r1 = color for eight pixelsFFFFFFFFFFFFBB3C E6A00000 ; SETLOFFFFFFFFFFFFBB40 EE800400 ; SETMIDFFFFFFFFFFFFBB44 6A0D0C2D lea r3,BITMAPSCR ; r3 = screen addressFFFFFFFFFFFFBB48 csj4:FFFFFFFFFFFFBB48 66308000 sw r1,[r3] ; store pixel dataFFFFFFFFFFFFBB4C 0A318008 addui r3,r3,#8 ; advance screen address by eightFFFFFFFFFFFFBB50 BE017FCF loop r2,csj4 ; decrement pixel count and loop backFFFFFFFFFFFFBB54 47E08000 lw r1,[sp]FFFFFFFFFFFFBB58 47E10008 lw r2,8[sp]FFFFFFFFFFFFBB5C 47E18010 lw r3,16[sp]FFFFFFFFFFFFBB60 37EF8018 ret #24;------------------------------------------------------------------------------; Clear the screen and the screen color memory; We clear the screen to give a visual indication that the system; is working at all.;------------------------------------------------------------------------------;FFFFFFFFFFFFBB64 ClearScreen:FFFFFFFFFFFFBB64 0FEF0028 subui sp,sp,#40FFFFFFFFFFFFBB68 67E08000 sw r1,[sp]FFFFFFFFFFFFBB6C 67E10008 sw r2,8[sp]FFFFFFFFFFFFBB70 67E18010 sw r3,16[sp]FFFFFFFFFFFFBB74 67E20018 sw r4,24[sp]FFFFFFFFFFFFBB78 67EF8020 sw lr,32[sp]FFFFFFFFFFFFBB7C E69A0000 ; SETLOFFFFFFFFFFFFBB80 EE800003 ; SETMIDFFFFFFFFFFFFBB84 6A0D0C2D lea r3,TEXTREGFFFFFFFFFFFFBB88 82308000 inch r1,TEXT_COLS[r3] ; calc number to clearFFFFFFFFFFFFBB8C 82310002 inch r2,TEXT_ROWS[r3]FFFFFFFFFFFFBB90 04110818 mulu r2,r1,r2 ; r2 = # chars to clearFFFFFFFFFFFFBB94 E0400020 setlo r1,#32 ; space charFFFFFFFFFFFFBB98 42021414 lc r4,ScreenColorFFFFFFFFFFFFBB9C 31FFEF2B call AsciiToScreenFFFFFFFFFFFFBBA0 E6900000 ; SETLOFFFFFFFFFFFFBBA4 EE800003 ; SETMIDFFFFFFFFFFFFBBA8 6A0D0C2D lea r3,TEXTSCR ; text screen addressFFFFFFFFFFFFBBAC csj4:FFFFFFFFFFFFBBAC 92308000 outc r1,[r3]FFFFFFFFFFFFBBB0 E6810000 ; SETLOFFFFFFFFFFFFBBB4 6A3D1029 outc r4,0x10000[r3] ; color screen is 0x10000 higherFFFFFFFFFFFFBBB8 0A318002 addui r3,r3,#2FFFFFFFFFFFFBBBC BE017F8F loop r2,csj4FFFFFFFFFFFFBBC0 47EF8020 lw lr,32[sp]FFFFFFFFFFFFBBC4 47E20018 lw r4,24[sp]FFFFFFFFFFFFBBC8 47E18010 lw r3,16[sp]FFFFFFFFFFFFBBCC 47E10008 lw r2,8[sp]FFFFFFFFFFFFBBD0 47E08000 lw r1,[sp]FFFFFFFFFFFFBBD4 37EF8028 ret #40;------------------------------------------------------------------------------; Scroll text on the screen upwards;------------------------------------------------------------------------------;FFFFFFFFFFFFBBD8 ScrollUp:FFFFFFFFFFFFBBD8 0FEF0028 subui sp,sp,#40FFFFFFFFFFFFBBDC 67E08000 sw r1,[sp]FFFFFFFFFFFFBBE0 67E10008 sw r2,8[sp]FFFFFFFFFFFFBBE4 67E18010 sw r3,16[sp]FFFFFFFFFFFFBBE8 67E20018 sw r4,24[sp]FFFFFFFFFFFFBBEC 67EF8020 sw lr,32[sp]FFFFFFFFFFFFBBF0 E69A0000 ; SETLOFFFFFFFFFFFFBBF4 EE800003 ; SETMIDFFFFFFFFFFFFBBF8 6A0D0C2D lea r3,TEXTREGFFFFFFFFFFFFBBFC 82308000 inch r1,TEXT_COLS[r3] ; r1 = # text columnsFFFFFFFFFFFFBC00 82310002 inch r2,TEXT_ROWS[r3]FFFFFFFFFFFFBC04 04110818 mulu r2,r1,r2 ; calc number of chars to scrollFFFFFFFFFFFFBC08 04208805 subu r2,r2,r1 ; one less rowFFFFFFFFFFFFBC0C E6900000 ; SETLOFFFFFFFFFFFFBC10 EE800003 ; SETMIDFFFFFFFFFFFFBC14 6A0D0C2D lea r3,TEXTSCRFFFFFFFFFFFFBC18 scrup1:FFFFFFFFFFFFBC18 6A309021 inch r4,[r3+r1] ; indexed addressing exampleFFFFFFFFFFFFBC1C 92320000 outc r4,[r3]FFFFFFFFFFFFBC20 0A318002 addui r3,r3,#2FFFFFFFFFFFFBC24 BE017FAF loop r2,scrup1FFFFFFFFFFFFBC28 E69A0000 ; SETLOFFFFFFFFFFFFBC2C EE800003 ; SETMIDFFFFFFFFFFFFBC30 6A0D0C2D lea r3,TEXTREGFFFFFFFFFFFFBC34 82308002 inch r1,TEXT_ROWS[r3]FFFFFFFFFFFFBC38 0E108001 subui r1,r1,#1FFFFFFFFFFFFBC3C 31FFEF16 call BlankLineFFFFFFFFFFFFBC40 47E08000 lw r1,[sp]FFFFFFFFFFFFBC44 47E10008 lw r2,8[sp]FFFFFFFFFFFFBC48 47E18010 lw r3,16[sp]FFFFFFFFFFFFBC4C 47E20018 lw r4,24[sp]FFFFFFFFFFFFBC50 47EF8020 lw lr,32[sp]FFFFFFFFFFFFBC54 37EF8028 ret #40;------------------------------------------------------------------------------; Blank out a line on the display; line number to blank is in r1;------------------------------------------------------------------------------;FFFFFFFFFFFFBC58 BlankLine:FFFFFFFFFFFFBC58 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFBC5C 67E08000 sw r1,[sp]FFFFFFFFFFFFBC60 67E10008 sw r2,8[sp]FFFFFFFFFFFFBC64 67E18010 sw r3,16[sp]FFFFFFFFFFFFBC68 E69A0000 ; SETLOFFFFFFFFFFFFBC6C EE800003 ; SETMIDFFFFFFFFFFFFBC70 6A0D0C2D lea r3,TEXTREG ; r3 = text register addressFFFFFFFFFFFFBC74 82310000 inch r2,TEXT_COLS[r3] ; r2 = # chars to blank outFFFFFFFFFFFFBC78 04208C18 mulu r3,r2,r1FFFFFFFFFFFFBC7C 06318200 shli r3,r3,#1FFFFFFFFFFFFBC80 E6900000 ; SETLOFFFFFFFFFFFFBC84 EE800003 ; SETMIDFFFFFFFFFFFFBC88 043D0C03 addui r3,r3,#TEXTSCR ; r3 = screen addressFFFFFFFFFFFFBC8C E0400020 setlo r1,#' 'FFFFFFFFFFFFBC90 blnkln1:FFFFFFFFFFFFBC90 92308000 outc r1,[r3]FFFFFFFFFFFFBC94 0A318002 addui r3,r3,#2FFFFFFFFFFFFBC98 BE017FCF loop r2,blnkln1FFFFFFFFFFFFBC9C 47E08000 lw r1,[sp]FFFFFFFFFFFFBCA0 47E10008 lw r2,8[sp]FFFFFFFFFFFFBCA4 47E18010 lw r3,16[sp]FFFFFFFFFFFFBCA8 37EF8018 ret #24;------------------------------------------------------------------------------; Convert ASCII character to screen display character.;------------------------------------------------------------------------------;FFFFFFFFFFFFBCAC AsciiToScreen:FFFFFFFFFFFFBCAC 141080FF andi r1,r1,#0x00ffFFFFFFFFFFFFBCB0 A8100541 bltui r1,#'A',atoscr1FFFFFFFFFFFFBCB4 AC10045A bleui r1,#'Z',atoscr1FFFFFFFFFFFFBCB8 AE10037A bgtui r1,#'z',atoscr1FFFFFFFFFFFFBCBC A8100261 bltui r1,#'a',atoscr1FFFFFFFFFFFFBCC0 0C108060 subi r1,r1,#0x60FFFFFFFFFFFFBCC4 atoscr1:FFFFFFFFFFFFBCC4 16108100 ori r1,r1,#0x100FFFFFFFFFFFFBCC8 37EF8000 ret;------------------------------------------------------------------------------; Convert screen character to ascii character;------------------------------------------------------------------------------;FFFFFFFFFFFFBCCC ScreenToAscii:FFFFFFFFFFFFBCCC 141080FF andi r1,r1,#0xffFFFFFFFFFFFFBCD0 AE10021A bgtui r1,#26,stasc1FFFFFFFFFFFFBCD4 0A10803C addui r1,r1,#60FFFFFFFFFFFFBCD8 stasc1:FFFFFFFFFFFFBCD8 37EF8000 ret;------------------------------------------------------------------------------; Calculate screen memory location from CursorRow,CursorCol.; Also refreshes the cursor location.; Destroys r1,r2,r3; r1 = screen location;------------------------------------------------------------------------------;FFFFFFFFFFFFBCDC CalcScreenLoc:FFFFFFFFFFFFBCDC 42009416 lc r1,CursorRowFFFFFFFFFFFFBCE0 1410807F andi r1,r1,#0x7fFFFFFFFFFFFFBCE4 E69A0000 ; SETLOFFFFFFFFFFFFBCE8 EE800003 ; SETMIDFFFFFFFFFFFFBCEC 6A0D0C2D lea r3,TEXTREGFFFFFFFFFFFFBCF0 82310000 inch r2,TEXT_COLS[r3]FFFFFFFFFFFFBCF4 04208818 mulu r2,r2,r1FFFFFFFFFFFFBCF8 42009418 lc r1,CursorColFFFFFFFFFFFFBCFC 1410807F andi r1,r1,#0x7fFFFFFFFFFFFFBD00 04208803 addu r2,r2,r1FFFFFFFFFFFFBD04 92310016 outc r2,TEXT_CURPOS[r3]FFFFFFFFFFFFBD08 06210200 shli r2,r2,#1FFFFFFFFFFFFBD0C E6900000 ; SETLOFFFFFFFFFFFFBD10 EE800003 ; SETMIDFFFFFFFFFFFFBD14 042D0403 addui r1,r2,#TEXTSCR ; r1 = screen locationFFFFFFFFFFFFBD18 37EF8000 ret;------------------------------------------------------------------------------; Display a character on the screen; d1.b = char to display;------------------------------------------------------------------------------;FFFFFFFFFFFFBD1C DisplayChar:FFFFFFFFFFFFBD1C B210080D bnei r1,#'\r',dccr ; carriage return ?FFFFFFFFFFFFBD20 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBD24 67E08000 sw r1,[sp]FFFFFFFFFFFFBD28 67E10008 sw r2,8[sp]FFFFFFFFFFFFBD2C 67E18010 sw r3,16[sp]FFFFFFFFFFFFBD30 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBD34 62001418 sc r0,CursorCol ; just set cursor column to zero on a CRFFFFFFFFFFFFBD38 BE00018A bra dcx7FFFFFFFFFFFFBD3C dccr:FFFFFFFFFFFFBD3C E6800091 ; SETLOFFFFFFFFFFFFBD40 BE1D0209 bnei r1,#0x91,dcx6 ; cursor right ?FFFFFFFFFFFFBD44 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBD48 67E08000 sw r1,[sp]FFFFFFFFFFFFBD4C 67E10008 sw r2,8[sp]FFFFFFFFFFFFBD50 67E18010 sw r3,16[sp]FFFFFFFFFFFFBD54 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBD58 42011418 lc r2,CursorColFFFFFFFFFFFFBD5C B0200338 beqi r2,#56,dcx7FFFFFFFFFFFFBD60 0A210001 addui r2,r2,#1FFFFFFFFFFFFBD64 62011418 sc r2,CursorColFFFFFFFFFFFFBD68 dcx7:FFFFFFFFFFFFBD68 31FFEF37 call CalcScreenLocFFFFFFFFFFFFBD6C 47EF8018 lw lr,24[sp]FFFFFFFFFFFFBD70 47E18010 lw r3,16[sp]FFFFFFFFFFFFBD74 47E10008 lw r2,8[sp]FFFFFFFFFFFFBD78 47E08000 lw r1,[sp]FFFFFFFFFFFFBD7C 37EF8020 ret #32FFFFFFFFFFFFBD80 dcx6:FFFFFFFFFFFFBD80 E6800090 ; SETLOFFFFFFFFFFFFBD84 BE1D0169 bnei r1,#0x90,dcx8 ; cursor up ?FFFFFFFFFFFFBD88 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBD8C 67E08000 sw r1,[sp]FFFFFFFFFFFFBD90 67E10008 sw r2,8[sp]FFFFFFFFFFFFBD94 67E18010 sw r3,16[sp]FFFFFFFFFFFFBD98 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBD9C 42011416 lc r2,CursorRowFFFFFFFFFFFFBDA0 B02FF200 beqi r2,#0,dcx7FFFFFFFFFFFFBDA4 0E210001 subui r2,r2,#1FFFFFFFFFFFFBDA8 62011416 sc r2,CursorRowFFFFFFFFFFFFBDAC BE007DEA bra dcx7FFFFFFFFFFFFBDB0 dcx8:FFFFFFFFFFFFBDB0 E6800093 ; SETLOFFFFFFFFFFFFBDB4 BE1D0169 bnei r1,#0x93,dcx9 ; cursor left ?FFFFFFFFFFFFBDB8 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBDBC 67E08000 sw r1,[sp]FFFFFFFFFFFFBDC0 67E10008 sw r2,8[sp]FFFFFFFFFFFFBDC4 67E18010 sw r3,16[sp]FFFFFFFFFFFFBDC8 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBDCC 42011418 lc r2,CursorColFFFFFFFFFFFFBDD0 B02FE600 beqi r2,#0,dcx7FFFFFFFFFFFFBDD4 0E210001 subui r2,r2,#1FFFFFFFFFFFFBDD8 62011418 sc r2,CursorColFFFFFFFFFFFFBDDC BE007C6A bra dcx7FFFFFFFFFFFFBDE0 dcx9:FFFFFFFFFFFFBDE0 E6800092 ; SETLOFFFFFFFFFFFFBDE4 BE1D0169 bnei r1,#0x92,dcx10 ; cursor down ?FFFFFFFFFFFFBDE8 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBDEC 67E08000 sw r1,[sp]FFFFFFFFFFFFBDF0 67E10008 sw r2,8[sp]FFFFFFFFFFFFBDF4 67E18010 sw r3,16[sp]FFFFFFFFFFFFBDF8 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBDFC 42011416 lc r2,CursorRowFFFFFFFFFFFFBE00 B02FDA1E beqi r2,#30,dcx7FFFFFFFFFFFFBE04 0A210001 addui r2,r2,#1FFFFFFFFFFFFBE08 62011416 sc r2,CursorRowFFFFFFFFFFFFBE0C BE007AEA bra dcx7FFFFFFFFFFFFBE10 dcx10:FFFFFFFFFFFFBE10 E6800094 ; SETLOFFFFFFFFFFFFBE14 BE1D0189 bnei r1,#0x94,dcx11 ; cursor home ?FFFFFFFFFFFFBE18 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBE1C 67E08000 sw r1,[sp]FFFFFFFFFFFFBE20 67E10008 sw r2,8[sp]FFFFFFFFFFFFBE24 67E18010 sw r3,16[sp]FFFFFFFFFFFFBE28 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBE2C 42011418 lc r2,CursorColFFFFFFFFFFFFBE30 BE200068 beq r2,r0,dcx12FFFFFFFFFFFFBE34 62001418 sc r0,CursorColFFFFFFFFFFFFBE38 BE00798A bra dcx7FFFFFFFFFFFFBE3C dcx12:FFFFFFFFFFFFBE3C 62001416 sc r0,CursorRowFFFFFFFFFFFFBE40 BE00794A bra dcx7FFFFFFFFFFFFBE44 dcx11:FFFFFFFFFFFFBE44 0FEF0030 subui sp,sp,#48FFFFFFFFFFFFBE48 67E08000 sw r1,[sp]FFFFFFFFFFFFBE4C 67E10008 sw r2,8[sp]FFFFFFFFFFFFBE50 67E18010 sw r3,16[sp]FFFFFFFFFFFFBE54 67E20018 sw r4,24[sp]FFFFFFFFFFFFBE58 67E28020 sw r5,32[sp]FFFFFFFFFFFFBE5C 67EF8028 sw lr,40[sp]FFFFFFFFFFFFBE60 E6800099 ; SETLOFFFFFFFFFFFFBE64 BE1D00A9 bnei r1,#0x99,dcx13 ; delete ?FFFFFFFFFFFFBE68 31FFEF37 call CalcScreenLocFFFFFFFFFFFFBE6C 04008C09 or r3,r0,r1 ; r3 = screen locationFFFFFFFFFFFFBE70 42009418 lc r1,CursorCol ; r1 = cursor columnFFFFFFFFFFFFBE74 BE00012A bra dcx5FFFFFFFFFFFFBE78 dcx13:FFFFFFFFFFFFBE78 B2101508 bnei r1,#CTRLH,dcx3 ; backspace ?FFFFFFFFFFFFBE7C 42011418 lc r2,CursorColFFFFFFFFFFFFBE80 BE2003A8 beq r2,r0,dcx4FFFFFFFFFFFFBE84 0E210001 subui r2,r2,#1FFFFFFFFFFFFBE88 62011418 sc r2,CursorColFFFFFFFFFFFFBE8C 31FFEF37 call CalcScreenLoc ; a0 = screen locationFFFFFFFFFFFFBE90 04008C09 or r3,r0,r1 ; r3 = screen locationFFFFFFFFFFFFBE94 42009418 lc r1,CursorColFFFFFFFFFFFFBE98 dcx5:FFFFFFFFFFFFBE98 82310002 inch r2,2[r3]FFFFFFFFFFFFBE9C 92310000 outc r2,[r3]FFFFFFFFFFFFBEA0 0A318002 addui r3,r3,#2FFFFFFFFFFFFBEA4 0A108001 addui r1,r1,#1FFFFFFFFFFFFBEA8 E69A0000 ; SETLOFFFFFFFFFFFFBEAC EE800003 ; SETMIDFFFFFFFFFFFFBEB0 6A0D102D lea r4,TEXTREGFFFFFFFFFFFFBEB4 82428000 inch r5,TEXT_COLS[r4]FFFFFFFFFFFFBEB8 BE12FF04 bltu r1,r5,dcx5FFFFFFFFFFFFBEBC E0400020 setlo r1,#' 'FFFFFFFFFFFFBEC0 31FFEF2B call AsciiToScreenFFFFFFFFFFFFBEC4 9230FFFE outc r1,-2[r3]FFFFFFFFFFFFBEC8 BE00016A bra dcx4FFFFFFFFFFFFBECC dcx3:FFFFFFFFFFFFBECC B010090A beqi r1,#'\n',dclf ; linefeed ?FFFFFFFFFFFFBED0 04009009 or r4,r0,r1 ; save r1 in r4FFFFFFFFFFFFBED4 31FFEF37 call CalcScreenLoc ; r1 = screen locationFFFFFFFFFFFFBED8 04008C09 or r3,r0,r1 ; r3 = screen locationFFFFFFFFFFFFBEDC 04020409 or r1,r0,r4 ; restore r1FFFFFFFFFFFFBEE0 31FFEF2B call AsciiToScreen ; convert ascii char to screen charFFFFFFFFFFFFBEE4 92308000 outc r1,[r3]FFFFFFFFFFFFBEE8 31FFEFC4 call IncCursorPosFFFFFFFFFFFFBEEC BE00004A bra dcx4FFFFFFFFFFFFBEF0 dclf:FFFFFFFFFFFFBEF0 31FFEFD2 call IncCursorRowFFFFFFFFFFFFBEF4 dcx4:FFFFFFFFFFFFBEF4 47EF8028 lw lr,40[sp]FFFFFFFFFFFFBEF8 47E28020 lw r5,32[sp]FFFFFFFFFFFFBEFC 47E20018 lw r4,24[sp]FFFFFFFFFFFFBF00 47E18010 lw r3,16[sp]FFFFFFFFFFFFBF04 47E10008 lw r2,8[sp]FFFFFFFFFFFFBF08 47E08000 lw r1,[sp]FFFFFFFFFFFFBF0C 37EF8030 ret #48;------------------------------------------------------------------------------; Increment the cursor position, scroll the screen if needed.;------------------------------------------------------------------------------;FFFFFFFFFFFFBF10 IncCursorPos:FFFFFFFFFFFFBF10 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBF14 67E08000 sw r1,[sp]FFFFFFFFFFFFBF18 67E10008 sw r2,8[sp]FFFFFFFFFFFFBF1C 67E18010 sw r3,16[sp]FFFFFFFFFFFFBF20 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBF24 42009418 lc r1,CursorColFFFFFFFFFFFFBF28 0A108001 addui r1,r1,#1FFFFFFFFFFFFBF2C 62009418 sc r1,CursorColFFFFFFFFFFFFBF30 E69A0000 ; SETLOFFFFFFFFFFFFBF34 EE800003 ; SETMIDFFFFFFFFFFFFBF38 6A0D0821 inch r2,TEXTREG+TEXT_COLSFFFFFFFFFFFFBF3C BE110246 bleu r1,r2,icc1FFFFFFFFFFFFBF40 62001418 sc r0,CursorCol ; column = 0FFFFFFFFFFFFBF44 BE0000CA bra icr1FFFFFFFFFFFFBF48 IncCursorRow:FFFFFFFFFFFFBF48 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFBF4C 67E08000 sw r1,[sp]FFFFFFFFFFFFBF50 67E10008 sw r2,8[sp]FFFFFFFFFFFFBF54 67E18010 sw r3,16[sp]FFFFFFFFFFFFBF58 67EF8018 sw lr,24[sp]FFFFFFFFFFFFBF5C icr1:FFFFFFFFFFFFBF5C 42009416 lc r1,CursorRowFFFFFFFFFFFFBF60 0A108001 addui r1,r1,#1FFFFFFFFFFFFBF64 62009416 sc r1,CursorRowFFFFFFFFFFFFBF68 E69A0002 ; SETLOFFFFFFFFFFFFBF6C EE800003 ; SETMIDFFFFFFFFFFFFBF70 6A0D0821 inch r2,TEXTREG+TEXT_ROWSFFFFFFFFFFFFBF74 BE110086 bleu r1,r2,icc1FFFFFFFFFFFFBF78 0E210001 subui r2,r2,#1 ; backup the cursor row, we are scrolling upFFFFFFFFFFFFBF7C 62011416 sc r2,CursorRowFFFFFFFFFFFFBF80 31FFEEF6 call ScrollUpFFFFFFFFFFFFBF84 icc1:FFFFFFFFFFFFBF84 31FFEF37 call CalcScreenLocFFFFFFFFFFFFBF88 47EF8018 lw lr,24[sp]FFFFFFFFFFFFBF8C 47E18010 lw r3,16[sp]FFFFFFFFFFFFBF90 47E10008 lw r2,8[sp]FFFFFFFFFFFFBF94 47E08000 lw r1,[sp]FFFFFFFFFFFFBF98 37EF8020 ret #32;------------------------------------------------------------------------------; Display a string on the screen.;------------------------------------------------------------------------------;FFFFFFFFFFFFBF9C DisplayString:FFFFFFFFFFFFBF9C 0DEF0018 subi sp,sp,#24FFFFFFFFFFFFBFA0 67E08000 sw r1,[sp]FFFFFFFFFFFFBFA4 67E10008 sw r2,8[sp]FFFFFFFFFFFFBFA8 67EF8010 sw lr,16[sp]FFFFFFFFFFFFBFAC 02110009 mov r2,r1 ; r2 = pointer to stringFFFFFFFFFFFFBFB0 dspj1:FFFFFFFFFFFFBFB0 4A208000 lbu r1,[r2] ; move string char into r1FFFFFFFFFFFFBFB4 0A210001 addui r2,r2,#1 ; increment pointerFFFFFFFFFFFFBFB8 BE100068 beq r1,r0,dsret ; is it end of string ?FFFFFFFFFFFFBFBC 31FFEF47 call DisplayChar ; display characterFFFFFFFFFFFFBFC0 BE007F8A bra dspj1 ; go back for next characterFFFFFFFFFFFFBFC4 dsret:FFFFFFFFFFFFBFC4 47EF8010 lw lr,16[sp]FFFFFFFFFFFFBFC8 47E10008 lw r2,8[sp]FFFFFFFFFFFFBFCC 47E08000 lw r1,[sp]FFFFFFFFFFFFBFD0 37EF8018 ret #24FFFFFFFFFFFFBFD4 DisplayStringCRLF:FFFFFFFFFFFFBFD4 0FEF0008 subui r30,r30,#8FFFFFFFFFFFFBFD8 67EF8000 sw r31,[r30]FFFFFFFFFFFFBFDC 31FFEFE7 call DisplayStringFFFFFFFFFFFFBFE0 47EF8000 lw r31,[r30]FFFFFFFFFFFFBFE4 0BEF0008 addui r30,r30,#8FFFFFFFFFFFFBFE8 CRLF:FFFFFFFFFFFFBFE8 0FEF0010 subui r30,r30,#16FFFFFFFFFFFFBFEC 67E08000 sw r1,[sp]FFFFFFFFFFFFBFF0 67EF8008 sw lr,8[sp]FFFFFFFFFFFFBFF4 E040000D setlo r1,#'\r'FFFFFFFFFFFFBFF8 31FFEF47 call DisplayCharFFFFFFFFFFFFBFFC E040000A setlo r1,#'\n'FFFFFFFFFFFFC000 31FFEF47 call DisplayCharFFFFFFFFFFFFC004 47EF8008 lw lr,8[sp]FFFFFFFFFFFFC008 47E08000 lw r1,[sp]FFFFFFFFFFFFC00C 37EF8010 ret #16;------------------------------------------------------------------------------; Display nybble in r1;------------------------------------------------------------------------------;FFFFFFFFFFFFC010 DisplayNybble:FFFFFFFFFFFFC010 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFC014 67E08000 sw r1,[sp]FFFFFFFFFFFFC018 67EF8008 sw lr,8[sp]FFFFFFFFFFFFC01C 1410800F andi r1,r1,#0x0FFFFFFFFFFFFFC020 0A108030 addui r1,r1,#'0'FFFFFFFFFFFFC024 AC100239 bleui r1,#'9',dispnyb1FFFFFFFFFFFFC028 0A108007 addui r1,r1,#7FFFFFFFFFFFFC02C dispnyb1:FFFFFFFFFFFFC02C 31FFEF47 call DisplayCharFFFFFFFFFFFFC030 47EF8008 lw lr,8[sp]FFFFFFFFFFFFC034 47E08000 lw r1,[sp]FFFFFFFFFFFFC038 37EF8010 ret #16;------------------------------------------------------------------------------; Display the byte in r1;------------------------------------------------------------------------------;FFFFFFFFFFFFC03C DisplayByte:FFFFFFFFFFFFC03C 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFC040 67E08000 sw r1,[sp]FFFFFFFFFFFFC044 67EF8008 sw lr,8[sp]FFFFFFFFFFFFC048 06108804 rori r1,r1,#4FFFFFFFFFFFFC04C 31FFF004 call DisplayNybbleFFFFFFFFFFFFC050 06108802 roli r1,r1,#4FFFFFFFFFFFFC054 31FFF004 call DisplayNybbleFFFFFFFFFFFFC058 47EF8008 lw lr,8[sp]FFFFFFFFFFFFC05C 47E08000 lw r1,[sp]FFFFFFFFFFFFC060 37EF8010 ret #16;------------------------------------------------------------------------------; Display the 64 bit word in r1;------------------------------------------------------------------------------;FFFFFFFFFFFFC064 DisplayWord:FFFFFFFFFFFFC064 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFC068 67E08000 sw r1,[sp]FFFFFFFFFFFFC06C 67E18008 sw r3,8[sp]FFFFFFFFFFFFC070 67EF8010 sw lr,16[sp]FFFFFFFFFFFFC074 E0C00007 setlo r3,#7FFFFFFFFFFFFC078 dspwd1:FFFFFFFFFFFFC078 06109002 roli r1,r1,#8FFFFFFFFFFFFC07C 31FFF00F call DisplayByteFFFFFFFFFFFFC080 BE01FFCF loop r3,dspwd1FFFFFFFFFFFFC084 47EF8010 lw lr,16[sp]FFFFFFFFFFFFC088 47E18008 lw r3,8[sp]FFFFFFFFFFFFC08C 47E08000 lw r1,[sp]FFFFFFFFFFFFC090 37EF8018 ret #24;------------------------------------------------------------------------------; Display memory pointed to by r2.; destroys r1,r3;------------------------------------------------------------------------------;FFFFFFFFFFFFC094 DisplayMem:FFFFFFFFFFFFC094 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFC098 67E08000 sw r1,[sp]FFFFFFFFFFFFC09C 67E18008 sw r3,8[sp]FFFFFFFFFFFFC0A0 67EF8010 sw lr,16[sp]FFFFFFFFFFFFC0A4 E040003A setlo r1,#':'FFFFFFFFFFFFC0A8 31FFEF47 call DisplayCharFFFFFFFFFFFFC0AC 02208009 mov r1,r2FFFFFFFFFFFFC0B0 31FFF019 call DisplayWordFFFFFFFFFFFFC0B4 E0C00007 setlo r3,#7FFFFFFFFFFFFC0B8 dspmem1:FFFFFFFFFFFFC0B8 E0400020 setlo r1,#' 'FFFFFFFFFFFFC0BC 31FFEF47 call DisplayCharFFFFFFFFFFFFC0C0 40208000 lb r1,[r2]FFFFFFFFFFFFC0C4 31FFF00F call DisplayByteFFFFFFFFFFFFC0C8 0A210001 addui r2,r2,#1FFFFFFFFFFFFC0CC BE01FF6F loop r3,dspmem1FFFFFFFFFFFFC0D0 31FFEFFA call CRLFFFFFFFFFFFFFC0D4 47EF8010 lw lr,16[sp]FFFFFFFFFFFFC0D8 47E18008 lw r3,8[sp]FFFFFFFFFFFFC0DC 47E08000 lw r1,[sp]FFFFFFFFFFFFC0E0 37EF8018 ret #24;------------------------------------------------------------------------------; Converts binary number in r1 into BCD number in r2 and r1.;------------------------------------------------------------------------------;FFFFFFFFFFFFC0E4 BinToBCD:FFFFFFFFFFFFC0E4 0FEF0030 subui sp,sp,#48FFFFFFFFFFFFC0E8 67E18000 sw r3,[sp]FFFFFFFFFFFFC0EC 67E20008 sw r4,8[sp]FFFFFFFFFFFFC0F0 67E28010 sw r5,16[sp]FFFFFFFFFFFFC0F4 67E30018 sw r6,24[sp]FFFFFFFFFFFFC0F8 67E38020 sw r7,32[sp]FFFFFFFFFFFFC0FC 67E40028 sw r8,40[sp]FFFFFFFFFFFFC100 E080000A setlo r2,#10FFFFFFFFFFFFC104 E2000013 setlo r8,#19 ; number of digits to produce - 1FFFFFFFFFFFFC108 bta1:FFFFFFFFFFFFC108 04110C1C mod r3,r1,r2FFFFFFFFFFFFC10C 0631F800 shli r3,r3,#60 ; shift result to uppermost bitsFFFFFFFFFFFFC110 0653F800 shli r7,r5,#60 ; copy low order nybble of r5 to r4 topmost nybbleFFFFFFFFFFFFC114 06420801 shrui r4,r4,#4FFFFFFFFFFFFC118 04439009 or r4,r4,r7FFFFFFFFFFFFC11C 06528801 shrui r5,r5,#4FFFFFFFFFFFFC120 04519409 or r5,r5,r3 ; copy new bcd digit into uppermost bits of r5FFFFFFFFFFFFC124 1C108000 divui r1,r1,r2 ; r1=r1/10FFFFFFFFFFFFC128 BE047F0F loop r8,bta1FFFFFFFFFFFFC12C 06426001 shrui r4,r4,#48 ; right align number in registerFFFFFFFFFFFFC130 06532000 shli r6,r5,#16FFFFFFFFFFFFC134 04431009 or r4,r4,r6 ; copy bits into r4FFFFFFFFFFFFC138 0652E001 shrui r5,r5,#48FFFFFFFFFFFFC13C 02408009 mov r1,r4FFFFFFFFFFFFC140 02510009 mov r2,r5FFFFFFFFFFFFC144 47E18000 lw r3,[sp]FFFFFFFFFFFFC148 47E20008 lw r4,8[sp]FFFFFFFFFFFFC14C 47E28010 lw r5,16[sp]FFFFFFFFFFFFC150 47E30018 lw r6,24[sp]FFFFFFFFFFFFC154 47E38020 lw r7,32[sp]FFFFFFFFFFFFC158 47E40028 lw r8,40[sp]FFFFFFFFFFFFC15C 37EF8030 ret #48;------------------------------------------------------------------------------; Converts BCD number in r1 into Ascii number in r2 and r1.;------------------------------------------------------------------------------;FFFFFFFFFFFFC160 BCDToAscii:FFFFFFFFFFFFC160 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFC164 67E18000 sw r3,[sp]FFFFFFFFFFFFC168 67E20008 sw r4,8[sp]FFFFFFFFFFFFC16C 67E28010 sw r5,16[sp]FFFFFFFFFFFFC170 67E40018 sw r8,24[sp]FFFFFFFFFFFFC174 E200000F setlo r8,#15FFFFFFFFFFFFC178 bta2:FFFFFFFFFFFFC178 1411000F andi r2,r1,#0x0FFFFFFFFFFFFFC17C 16210030 ori r2,r2,#0x30FFFFFFFFFFFFC180 06217000 shli r2,r2,#56FFFFFFFFFFFFC184 06421001 shrui r4,r4,#8FFFFFFFFFFFFC188 0632F000 shli r5,r3,#56FFFFFFFFFFFFC18C 04429009 or r4,r4,r5FFFFFFFFFFFFC190 06319001 shrui r3,r3,#8FFFFFFFFFFFFC194 04310C09 or r3,r3,r2FFFFFFFFFFFFC198 06108801 shrui r1,r1,#4FFFFFFFFFFFFC19C BE047EEF loop r8,bta2FFFFFFFFFFFFC1A0 02408009 mov r1,r4FFFFFFFFFFFFC1A4 02310009 mov r2,r3FFFFFFFFFFFFC1A8 47E18000 lw r3,[sp]FFFFFFFFFFFFC1AC 47E20008 lw r4,8[sp]FFFFFFFFFFFFC1B0 47E28010 lw r5,16[sp]FFFFFFFFFFFFC1B4 47E40018 lw r8,24[sp]FFFFFFFFFFFFC1B8 37EF8020 ret #32;------------------------------------------------------------------------------; Convert a binary number into a 20 character ascii string.; r1 = number to convert; r2 = address of string buffer;------------------------------------------------------------------------------;FFFFFFFFFFFFC1BC BinToStr:FFFFFFFFFFFFC1BC 0FEF0038 subui sp,sp,#56FFFFFFFFFFFFC1C0 67E18000 sw r3,[sp]FFFFFFFFFFFFC1C4 67E38008 sw r7,8[sp]FFFFFFFFFFFFC1C8 67E40010 sw r8,16[sp]FFFFFFFFFFFFC1CC 67E48018 sw r9,24[sp]FFFFFFFFFFFFC1D0 67E50020 sw r10,32[sp]FFFFFFFFFFFFC1D4 67E58028 sw r11,40[sp]FFFFFFFFFFFFC1D8 67EF8030 sw lr,48[sp]FFFFFFFFFFFFC1DC 02258009 mov r11,r2FFFFFFFFFFFFC1E0 31FFF039 call BinToBCDFFFFFFFFFFFFC1E4 02250009 mov r10,r2 ; save off r2FFFFFFFFFFFFC1E8 31FFF058 call BCDToAsciiFFFFFFFFFFFFC1EC E2400001 setlo r9,#1FFFFFFFFFFFFC1F0 btos3:FFFFFFFFFFFFC1F0 E2000007 setlo r8,#7FFFFFFFFFFFFC1F4 btos1:FFFFFFFFFFFFC1F4 06938600 shli r7,r9,#3FFFFFFFFFFFFC1F8 0A738000 addui r7,r7,r8FFFFFFFFFFFFC1FC 0A738004 addui r7,r7,#4FFFFFFFFFFFFC200 141180FF andi r3,r1,#0xffFFFFFFFFFFFFC204 6A758C10 sb r3,[r7+r11]FFFFFFFFFFFFC208 06109001 shrui r1,r1,#8FFFFFFFFFFFFC20C BE047F4F loop r8,btos1FFFFFFFFFFFFC210 02208009 mov r1,r2FFFFFFFFFFFFC214 BE04FEEF loop r9,btos3; the last four digitsFFFFFFFFFFFFC218 02A08009 mov r1,r10 ; get back r2FFFFFFFFFFFFC21C 31FFF058 call BCDToAsciiFFFFFFFFFFFFC220 E2000003 setlo r8,#3FFFFFFFFFFFFC224 btos2:FFFFFFFFFFFFC224 141180FF andi r3,r1,#0xffFFFFFFFFFFFFC228 6A858C10 sb r3,[r8+r11]FFFFFFFFFFFFC22C 06109001 shrui r1,r1,#8FFFFFFFFFFFFC230 BE047FAF loop r8,btos2FFFFFFFFFFFFC234 60B00014 sb r0,20[r11] ; null terminateFFFFFFFFFFFFC238 47E18000 lw r3,[sp]FFFFFFFFFFFFC23C 47E38008 lw r7,8[sp]FFFFFFFFFFFFC240 47E40010 lw r8,16[sp]FFFFFFFFFFFFC244 47E48018 lw r9,24[sp]FFFFFFFFFFFFC248 47E50020 lw r10,32[sp]FFFFFFFFFFFFC24C 47E58028 lw r11,40[sp]FFFFFFFFFFFFC250 47EF8030 lw lr,48[sp]FFFFFFFFFFFFC254 37EF8038 ret #56;==============================================================================;==============================================================================FFFFFFFFFFFFC258 Monitor:FFFFFFFFFFFFC258 E6BEFFF8 ; SETLOFFFFFFFFFFFFC25C 6A0D782D lea sp,STACKTOP0 ; top of stack; reset the stack pointerFFFFFFFFFFFFC260 6000141C sb r0,KeybdEcho ; turn off keyboard echoFFFFFFFFFFFFC264 PromptLn:FFFFFFFFFFFFC264 31FFEFFA call CRLFFFFFFFFFFFFFC268 E0400024 setlo r1,#'$'FFFFFFFFFFFFC26C 31FFEF47 call DisplayChar; Get characters until a CR is keyed;FFFFFFFFFFFFC270 Prompt3:FFFFFFFFFFFFC270 31FFEE08 call KeybdGetCharFFFFFFFFFFFFC274 B01FFFFF beqi r1,#-1,Prompt3 ; wait for a characterFFFFFFFFFFFFC278 B010030D beqi r1,#CR,Prompt1FFFFFFFFFFFFC27C 31FFEF47 call DisplayCharFFFFFFFFFFFFC280 BE007F8A bra Prompt3; Process the screen line that the CR was keyed on;FFFFFFFFFFFFC284 Prompt1:FFFFFFFFFFFFC284 62001418 sc r0,CursorCol ; go back to the start of the lineFFFFFFFFFFFFC288 31FFEF37 call CalcScreenLoc ; r1 = screen memory locationFFFFFFFFFFFFC28C 04100C09 or r3,r1,r0FFFFFFFFFFFFC290 82308000 inch r1,[r3]FFFFFFFFFFFFC294 0A318002 addui r3,r3,#2FFFFFFFFFFFFC298 31FFEF33 call ScreenToAsciiFFFFFFFFFFFFC29C B2100424 bnei r1,#'$',Prompt2 ; skip over '$' prompt characterFFFFFFFFFFFFC2A0 82308000 inch r1,[r3]FFFFFFFFFFFFC2A4 0A318002 addui r3,r3,#2FFFFFFFFFFFFC2A8 31FFEF33 call ScreenToAscii; Dispatch based on command character;FFFFFFFFFFFFC2AC Prompt2:FFFFFFFFFFFFC2AC B010563A beqi r1,#':',Editmem ; $: - edit memoryFFFFFFFFFFFFC2B0 B0106344 beqi r1,#'D',Dumpmem ; $D - dump memoryFFFFFFFFFFFFC2B4 B012EF42 beqi r1,#'B',CSTART ; $B - start tiny basicFFFFFFFFFFFFC2B8 B0105D4A beqi r1,#'J',ExecuteCode ; $J - execute codeFFFFFFFFFFFFC2BC B010914C beqi r1,#'L',LoadS19 ; $L - load S19 fileFFFFFFFFFFFFC2C0 B010153F beqi r1,#'?',DisplayHelp ; $? - display helpFFFFFFFFFFFFC2C4 B0100743 beqi r1,#'C',TestCLS ; $C - clear screenFFFFFFFFFFFFC2C8 B0100452 beqi r1,#'R',RandomLinesCallFFFFFFFFFFFFC2CC B012B849 beqi r1,#'I',InvadersFFFFFFFFFFFFC2D0 B011A350 beqi r1,#'P',PianoFFFFFFFFFFFFC2D4 BE007C2A bra MonitorFFFFFFFFFFFFC2D8 RandomLinesCall:FFFFFFFFFFFFC2D8 31FFF1BC call RandomLinesFFFFFFFFFFFFC2DC BE007BEA bra MonitorFFFFFFFFFFFFC2E0 TestCLS:FFFFFFFFFFFFC2E0 82308000 inch r1,[r3]FFFFFFFFFFFFC2E4 0A318002 addui r3,r3,#2FFFFFFFFFFFFC2E8 31FFEF33 call ScreenToAsciiFFFFFFFFFFFFC2EC B21FDB4C bnei r1,#'L',MonitorFFFFFFFFFFFFC2F0 82308000 inch r1,[r3]FFFFFFFFFFFFC2F4 0A318002 addui r3,r3,#2FFFFFFFFFFFFC2F8 31FFEF33 call ScreenToAsciiFFFFFFFFFFFFC2FC B21FD753 bnei r1,#'S',MonitorFFFFFFFFFFFFC300 31FFEED9 call ClearScreenFFFFFFFFFFFFC304 60001418 sb r0,CursorColFFFFFFFFFFFFC308 60001416 sb r0,CursorRowFFFFFFFFFFFFC30C 31FFEF37 call CalcScreenLocFFFFFFFFFFFFC310 BE007A4A bra MonitorFFFFFFFFFFFFC314 DisplayHelp:FFFFFFFFFFFFC314 E07FC320 setlo r1,HelpMsgFFFFFFFFFFFFC318 31FFEFE7 call DisplayStringFFFFFFFFFFFFC31C BE0079EA bra MonitorFFFFFFFFFFFFC320 align 16FFFFFFFFFFFFC320 HelpMsg:FFFFFFFFFFFFC320 70736944203D203F db "? = Display help",CR,LFFFFFFFFFFFFFC328 706C65682079616CFFFFFFFFFFFFC330 203D20534C430A0D db "CLS = clear screen",CR,LFFFFFFFFFFFFFC338 6373207261656C63FFFFFFFFFFFFC340 203A0A0D6E656572 db ": = Edit memory bytes",CR,LFFFFFFFFFFFFFC348 6D2074696445203DFFFFFFFFFFFFC350 79622079726F6D65FFFFFFFFFFFFC358 3D204C0A0D736574 db "L = Load S19 file",CR,LFFFFFFFFFFFFFC360 31532064616F4C20FFFFFFFFFFFFC368 0A0D656C69662039FFFFFFFFFFFFC370 706D7544203D2044 db "D = Dump memory",CR,LFFFFFFFFFFFFFC378 0D79726F6D656D20FFFFFFFFFFFFC380 617473203D20420A db "B = start tiny basic",CR,LFFFFFFFFFFFFFC388 20796E6974207472FFFFFFFFFFFFC390 4A0A0D6369736162 db "J = Jump to code",CR,LFFFFFFFFFFFFFC398 20706D754A203D20FFFFFFFFFFFFC3A0 0D65646F63206F74FFFFFFFFFFFFC3A8 766E49203D20490A db "I = Invaders",CR,LFFFFFFFFFFFFFC3B0 520A0D7372656461 db "R = Random lines",CR,LFFFFFFFFFFFFFC3B8 6F646E6152203D20FFFFFFFFFFFFC3C0 0D73656E696C206DFFFFFFFFFFFFC3C8 616950203D20500A db "P = Piano",CR,LF,0FFFFFFFFFFFFC3D0 000000000A0D6F6E align 16FFFFFFFFFFFFC3D8 0000000000000000FFFFFFFFFFFFC3E0 align 16;------------------------------------------------------------------------------; Ignore blanks in the input; r3 = text pointer; r1 destroyed;------------------------------------------------------------------------------;FFFFFFFFFFFFC3E0 ignBlanks:FFFFFFFFFFFFC3E0 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFC3E4 67EF8000 sw r31,[sp]FFFFFFFFFFFFC3E8 ignBlanks1:FFFFFFFFFFFFC3E8 82308000 inch r1,[r3]FFFFFFFFFFFFC3EC 0A318002 addui r3,r3,#2FFFFFFFFFFFFC3F0 31FFEF33 call ScreenToAsciiFFFFFFFFFFFFC3F4 B01FFD20 beqi r1,#' ',ignBlanks1FFFFFFFFFFFFC3F8 0E318002 subui r3,r3,#2FFFFFFFFFFFFC3FC 47EF8000 lw r31,[sp]FFFFFFFFFFFFC400 37EF8008 ret #8;------------------------------------------------------------------------------; Edit memory byte(s).;------------------------------------------------------------------------------;FFFFFFFFFFFFC404 EditMem:FFFFFFFFFFFFC404 31FFF0F8 call ignBlanksFFFFFFFFFFFFC408 31FFF11C call GetHexNumberFFFFFFFFFFFFC40C 04101409 or r5,r1,r0FFFFFFFFFFFFC410 E1000007 setlo r4,#7FFFFFFFFFFFFC414 edtmem1:FFFFFFFFFFFFC414 31FFF0F8 call ignBlanksFFFFFFFFFFFFC418 31FFF11C call GetHexNumberFFFFFFFFFFFFC41C 60508000 sb r1,[r5]FFFFFFFFFFFFC420 0A528001 addui r5,r5,#1FFFFFFFFFFFFC424 BE027F8F loop r4,edtmem1FFFFFFFFFFFFC428 BE00718A bra Monitor;------------------------------------------------------------------------------; Execute code at the specified address.;------------------------------------------------------------------------------;FFFFFFFFFFFFC42C ExecuteCode:FFFFFFFFFFFFC42C 31FFF0F8 call ignBlanksFFFFFFFFFFFFC430 31FFF11C call GetHexNumberFFFFFFFFFFFFC434 341F8000 jal r31,[r1]FFFFFFFFFFFFC438 BE00710A bra Monitor;------------------------------------------------------------------------------; Do a memory dump of the requested location.;------------------------------------------------------------------------------;FFFFFFFFFFFFC43C DumpMem:FFFFFFFFFFFFC43C 31FFF0F8 call ignBlanksFFFFFFFFFFFFC440 31FFF11C call GetHexNumberFFFFFFFFFFFFC444 02110009 mov r2,r1FFFFFFFFFFFFC448 31FFEFFA call CRLFFFFFFFFFFFFFC44C 31FFF025 call DisplayMemFFFFFFFFFFFFC450 31FFF025 call DisplayMemFFFFFFFFFFFFC454 31FFF025 call DisplayMemFFFFFFFFFFFFC458 31FFF025 call DisplayMemFFFFFFFFFFFFC45C 31FFF025 call DisplayMemFFFFFFFFFFFFC460 31FFF025 call DisplayMemFFFFFFFFFFFFC464 31FFF025 call DisplayMemFFFFFFFFFFFFC468 31FFF025 call DisplayMemFFFFFFFFFFFFC46C BE006F6A bra Monitor;------------------------------------------------------------------------------; Get a hexidecimal number. Maximum of sixteen digits.; R3 = text pointer (updated); R1 = hex number;------------------------------------------------------------------------------;FFFFFFFFFFFFC470 GetHexNumber:FFFFFFFFFFFFC470 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFC474 67E10000 sw r2,[sp]FFFFFFFFFFFFC478 67E20008 sw r4,8[sp]FFFFFFFFFFFFC47C 67EF8010 sw lr,16[sp]FFFFFFFFFFFFC480 E0800000 setlo r2,#0FFFFFFFFFFFFC484 E100000F setlo r4,#15FFFFFFFFFFFFC488 gthxn2:FFFFFFFFFFFFC488 82308000 inch r1,[r3]FFFFFFFFFFFFC48C 0A318002 addui r3,r3,#2FFFFFFFFFFFFC490 31FFEF33 call ScreenToAsciiFFFFFFFFFFFFC494 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC498 B01005FF beqi r1,#-1,gthxn1FFFFFFFFFFFFC49C 06210800 shli r2,r2,#4FFFFFFFFFFFFC4A0 1410800F andi r1,r1,#0x0fFFFFFFFFFFFFC4A4 04208809 or r2,r2,r1FFFFFFFFFFFFC4A8 BE027F0F loop r4,gthxn2FFFFFFFFFFFFC4AC gthxn1:FFFFFFFFFFFFC4AC 02208009 mov r1,r2FFFFFFFFFFFFC4B0 47EF8010 lw lr,16[sp]FFFFFFFFFFFFC4B4 47E20008 lw r4,8[sp]FFFFFFFFFFFFC4B8 47E10000 lw r2,[sp]FFFFFFFFFFFFC4BC 37EF8018 ret #24;------------------------------------------------------------------------------; Convert ASCII character in the range '0' to '9', 'a' to 'f' or 'A' to 'F'; to a hex nybble.;------------------------------------------------------------------------------;FFFFFFFFFFFFC4C0 AsciiToHexNybble:FFFFFFFFFFFFC4C0 A8100E30 bltui r1,#'0',gthx3FFFFFFFFFFFFC4C4 AE100339 bgtui r1,#'9',gthx5FFFFFFFFFFFFC4C8 0E108030 subui r1,r1,#'0'FFFFFFFFFFFFC4CC 37EF8000 retFFFFFFFFFFFFC4D0 gthx5:FFFFFFFFFFFFC4D0 A8100A41 bltui r1,#'A',gthx3FFFFFFFFFFFFC4D4 AE100446 bgtui r1,#'F',gthx6FFFFFFFFFFFFC4D8 0E108041 subui r1,r1,#'A'FFFFFFFFFFFFC4DC 0A10800A addui r1,r1,#10FFFFFFFFFFFFC4E0 37EF8000 retFFFFFFFFFFFFC4E4 gthx6:FFFFFFFFFFFFC4E4 A8100561 bltui r1,#'a',gthx3FFFFFFFFFFFFC4E8 AE100466 bgtui r1,#'f',gthx3FFFFFFFFFFFFC4EC 0E108061 subui r1,r1,#'a'FFFFFFFFFFFFC4F0 0A10800A addui r1,r1,#10FFFFFFFFFFFFC4F4 37EF8000 retFFFFFFFFFFFFC4F8 gthx3:FFFFFFFFFFFFC4F8 E07FFFFF setlo r1,#-1 ; not a hex numberFFFFFFFFFFFFC4FC 37EF8000 ret;==============================================================================; Load an S19 format file;==============================================================================;FFFFFFFFFFFFC500 LoadS19:FFFFFFFFFFFFC500 BE00006A bra ProcessRecFFFFFFFFFFFFC504 NextRec:FFFFFFFFFFFFC504 31FFF1B2 call sGetCharFFFFFFFFFFFFC508 B21FFF0A bne r1,#LF,NextRecFFFFFFFFFFFFC50C ProcessRec:FFFFFFFFFFFFC50C 31FFF1B2 call sGetCharFFFFFFFFFFFFC510 B01F521A beqi r1,#26,Monitor ; CTRL-Z ?FFFFFFFFFFFFC514 B21FFC53 bnei r1,#'S',NextRecFFFFFFFFFFFFC518 31FFF1B2 call sGetCharFFFFFFFFFFFFC51C A01FFA30 blt r1,#'0',NextRecFFFFFFFFFFFFC520 A61FF939 bgt r1,#'9',NextRecFFFFFFFFFFFFC524 04101009 or r4,r1,r0 ; r4 = record typeFFFFFFFFFFFFC528 31FFF1B2 call sGetCharFFFFFFFFFFFFC52C 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC530 04100809 or r2,r1,r0FFFFFFFFFFFFC534 31FFF1B2 call sGetCharFFFFFFFFFFFFC538 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC53C 06210800 shli r2,r2,#4FFFFFFFFFFFFC540 04208809 or r2,r2,r1 ; r2 = byte countFFFFFFFFFFFFC544 04208C09 or r3,r2,r1 ; r3 = byte countFFFFFFFFFFFFC548 B04FEF30 beqi r4,#'0',NextRec ; manufacturer ID record, ignoreFFFFFFFFFFFFC54C B0401E31 beqi r4,#'1',ProcessS1FFFFFFFFFFFFC550 B0401F32 beqi r4,#'2',ProcessS2FFFFFFFFFFFFC554 B0402033 beqi r4,#'3',ProcessS3FFFFFFFFFFFFC558 B04FEB35 beqi r4,#'5',NextRec ; record count record, ignoreFFFFFFFFFFFFC55C B0402037 beqi r4,#'7',ProcessS7FFFFFFFFFFFFC560 B0402238 beqi r4,#'8',ProcessS8FFFFFFFFFFFFC564 B0402439 beqi r4,#'9',ProcessS9FFFFFFFFFFFFC568 BE007CEA bra NextRecFFFFFFFFFFFFC56C pcssxa:FFFFFFFFFFFFC56C 143180FF andi r3,r3,#0xffFFFFFFFFFFFFC570 0E318001 subui r3,r3,#1 ; one less for loopFFFFFFFFFFFFC574 pcss1a:FFFFFFFFFFFFC574 31FFF1B2 call sGetCharFFFFFFFFFFFFC578 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC57C 06210800 shli r2,r2,#4FFFFFFFFFFFFC580 04208809 or r2,r2,r1FFFFFFFFFFFFC584 31FFF1B2 call sGetCharFFFFFFFFFFFFC588 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC58C 06210800 shli r2,r2,#4FFFFFFFFFFFFC590 04208809 or r2,r2,r1FFFFFFFFFFFFC594 60510000 sb r2,[r5]FFFFFFFFFFFFC598 0A528001 addui r5,r5,#1FFFFFFFFFFFFC59C BE01FECF loop r3,pcss1a; Get the checksum byteFFFFFFFFFFFFC5A0 31FFF1B2 call sGetCharFFFFFFFFFFFFC5A4 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC5A8 06210800 shli r2,r2,#4FFFFFFFFFFFFC5AC 04208809 or r2,r2,r1FFFFFFFFFFFFC5B0 31FFF1B2 call sGetCharFFFFFFFFFFFFC5B4 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC5B8 06210800 shli r2,r2,#4FFFFFFFFFFFFC5BC 04208809 or r2,r2,r1FFFFFFFFFFFFC5C0 BE007A2A bra NextRecFFFFFFFFFFFFC5C4 ProcessS1:FFFFFFFFFFFFC5C4 31FFF180 call S19Get16BitAddressFFFFFFFFFFFFC5C8 BE007D2A bra pcssxaFFFFFFFFFFFFC5CC ProcessS2:FFFFFFFFFFFFC5CC 31FFF186 call S19Get24BitAddressFFFFFFFFFFFFC5D0 BE007CEA bra pcssxaFFFFFFFFFFFFC5D4 ProcessS3:FFFFFFFFFFFFC5D4 31FFF18C call S19Get32BitAddressFFFFFFFFFFFFC5D8 BE007CAA bra pcssxaFFFFFFFFFFFFC5DC ProcessS7:FFFFFFFFFFFFC5DC 31FFF18C call S19Get32BitAddressFFFFFFFFFFFFC5E0 66028000 sw r5,S19StartAddressFFFFFFFFFFFFC5E4 BE0063AA bra MonitorFFFFFFFFFFFFC5E8 ProcessS8:FFFFFFFFFFFFC5E8 31FFF186 call S19Get24BitAddressFFFFFFFFFFFFC5EC 66028000 sw r5,S19StartAddressFFFFFFFFFFFFC5F0 BE00634A bra MonitorFFFFFFFFFFFFC5F4 ProcessS9:FFFFFFFFFFFFC5F4 31FFF180 call S19Get16BitAddressFFFFFFFFFFFFC5F8 66028000 sw r5,S19StartAddressFFFFFFFFFFFFC5FC BE0062EA bra MonitorFFFFFFFFFFFFC600 S19Get16BitAddress:FFFFFFFFFFFFC600 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFC604 67EF8000 sw r31,[sp]FFFFFFFFFFFFC608 31FFF1B2 call sGetCharFFFFFFFFFFFFC60C 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC610 04100809 or r2,r1,r0FFFFFFFFFFFFC614 BE00038A bra S1932bFFFFFFFFFFFFC618 S19Get24BitAddress:FFFFFFFFFFFFC618 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFC61C 67EF8000 sw r31,[sp]FFFFFFFFFFFFC620 31FFF1B2 call sGetCharFFFFFFFFFFFFC624 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC628 04100809 or r2,r1,r0FFFFFFFFFFFFC62C BE0001CA bra S1932aFFFFFFFFFFFFC630 S19Get32BitAddress:FFFFFFFFFFFFC630 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFC634 67EF8000 sw r31,[sp]FFFFFFFFFFFFC638 31FFF1B2 call sGetCharFFFFFFFFFFFFC63C 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC640 04100809 or r2,r1,r0FFFFFFFFFFFFC644 31FFF1B2 call sGetCharFFFFFFFFFFFFC648 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC64C 06210800 shli r2,r2,#4FFFFFFFFFFFFC650 04110809 or r2,r1,r2FFFFFFFFFFFFC654 31FFF1B2 call sGetCharFFFFFFFFFFFFC658 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC65C 06210800 shli r2,r2,#4FFFFFFFFFFFFC660 04208809 or r2,r2,r1FFFFFFFFFFFFC664 S1932a:FFFFFFFFFFFFC664 31FFF1B2 call sGetCharFFFFFFFFFFFFC668 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC66C 06210800 shli r2,r2,#4FFFFFFFFFFFFC670 04208809 or r2,r2,r1FFFFFFFFFFFFC674 31FFF1B2 call sGetCharFFFFFFFFFFFFC678 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC67C 06210800 shli r2,r2,#4FFFFFFFFFFFFC680 04208809 or r2,r2,r1FFFFFFFFFFFFC684 S1932b:FFFFFFFFFFFFC684 31FFF1B2 call sGetCharFFFFFFFFFFFFC688 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC68C 06210800 shli r2,r2,#4FFFFFFFFFFFFC690 04208809 or r2,r2,r1FFFFFFFFFFFFC694 31FFF1B2 call sGetCharFFFFFFFFFFFFC698 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC69C 06210800 shli r2,r2,#4FFFFFFFFFFFFC6A0 04208809 or r2,r2,r1FFFFFFFFFFFFC6A4 31FFF1B2 call sGetCharFFFFFFFFFFFFC6A8 31FFF130 call AsciiToHexNybbleFFFFFFFFFFFFC6AC 06210800 shli r2,r2,#4FFFFFFFFFFFFC6B0 04208809 or r2,r2,r1FFFFFFFFFFFFC6B4 0442100A xor r4,r4,r4FFFFFFFFFFFFC6B8 04201409 or r5,r2,r0FFFFFFFFFFFFC6BC 47EF8000 lw r31,[sp]FFFFFFFFFFFFC6C0 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFC6C4 37EF8000 ret;------------------------------------------------------------------------------; Get a character from auxillary input, checking the keyboard status for a; CTRL-C;------------------------------------------------------------------------------;FFFFFFFFFFFFC6C8 sGetChar:FFFFFFFFFFFFC6C8 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFC6CC 67EF8000 sw r31,[sp]FFFFFFFFFFFFC6D0 sgc2:FFFFFFFFFFFFC6D0 31FFEE1D call KeybdCheckForKeyFFFFFFFFFFFFC6D4 BE106908 beq r1,r0,sgc1FFFFFFFFFFFFC6D8 31FFEE08 call KeybdGetcharFFFFFFFFFFFFC6DC B01EDF00 beqi r1,#CRTLC,MonitorFFFFFFFFFFFFC6E0 sgc1:FFFFFFFFFFFFC6E0 31FFF95C call AUXINFFFFFFFFFFFFC6E4 BE107F62 ble r1,r0,sgc2FFFFFFFFFFFFC6E8 47EF8000 lw r31,[sp]FFFFFFFFFFFFC6EC 37EF8008 ret #8;--------------------------------------------------------------------------; Draw random lines on the bitmap screen.;--------------------------------------------------------------------------FFFFFFFFFFFFC6F0 RandomLines:FFFFFFFFFFFFC6F0 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFC6F4 67E08000 sw r1,[sp]FFFFFFFFFFFFC6F8 67E18008 sw r3,8[sp]FFFFFFFFFFFFC6FC 67EF8010 sw lr,16[sp]FFFFFFFFFFFFC700 rl5:FFFFFFFFFFFFC700 00000050 granFFFFFFFFFFFFC704 020088A8 mfspr r1,rand ; select a random colorFFFFFFFFFFFFC708 E69AE000 ; SETLOFFFFFFFFFFFFC70C EE800003 ; SETMIDFFFFFFFFFFFFC710 6A0D042A outh r1,GACCELFFFFFFFFFFFFC714 rl1: ; random X0FFFFFFFFFFFFC714 00000050 granFFFFFFFFFFFFC718 020088A8 mfspr r1,randFFFFFFFFFFFFC71C 16018554 lw r3,#1364FFFFFFFFFFFFC720 0411841C mod r1,r1,r3FFFFFFFFFFFFC724 E69AE008 ; SETLOFFFFFFFFFFFFC728 EE800003 ; SETMIDFFFFFFFFFFFFC72C 6A0D042A outh r1,GACCEL+8FFFFFFFFFFFFC730 rl2: ; random X1FFFFFFFFFFFFC730 00000050 granFFFFFFFFFFFFC734 020088A8 mfspr r1,randFFFFFFFFFFFFC738 16018554 lw r3,#1364FFFFFFFFFFFFC73C 0411841C mod r1,r1,r3FFFFFFFFFFFFC740 E69AE010 ; SETLOFFFFFFFFFFFFC744 EE800003 ; SETMIDFFFFFFFFFFFFC748 6A0D042A outh r1,GACCEL+16FFFFFFFFFFFFC74C rl3: ; random Y0FFFFFFFFFFFFC74C 00000050 granFFFFFFFFFFFFC750 020088A8 mfspr r1,randFFFFFFFFFFFFC754 16018300 lw r3,#768FFFFFFFFFFFFC758 0411841C mod r1,r1,r3FFFFFFFFFFFFC75C E69AE00C ; SETLOFFFFFFFFFFFFC760 EE800003 ; SETMIDFFFFFFFFFFFFC764 6A0D042A outh r1,GACCEL+12FFFFFFFFFFFFC768 rl4: ; random Y1FFFFFFFFFFFFC768 00000050 granFFFFFFFFFFFFC76C 020088A8 mfspr r1,randFFFFFFFFFFFFC770 16018300 lw r3,#768FFFFFFFFFFFFC774 0411841C mod r1,r1,r3FFFFFFFFFFFFC778 E69AE014 ; SETLOFFFFFFFFFFFFC77C EE800003 ; SETMIDFFFFFFFFFFFFC780 6A0D042A outh r1,GACCEL+20FFFFFFFFFFFFC784 E0400002 setlo r1,#2 ; draw line commandFFFFFFFFFFFFC788 E69AE03C ; SETLOFFFFFFFFFFFFC78C EE800003 ; SETMIDFFFFFFFFFFFFC790 6A0D042A outh r1,GACCEL+60FFFFFFFFFFFFC794 rl8:FFFFFFFFFFFFC794 31FFEE08 call KeybdGetCharFFFFFFFFFFFFC798 B0100303 beqi r1,#CTRLC,rl7FFFFFFFFFFFFC79C B01FD972 beqi r1,#'r',rl5FFFFFFFFFFFFC7A0 BE007FAA bra rl8FFFFFFFFFFFFC7A4 rl7:FFFFFFFFFFFFC7A4 47EF8010 lw lr,16[sp]FFFFFFFFFFFFC7A8 47E18008 lw r3,8[sp]FFFFFFFFFFFFC7AC 47E08000 lw r1,[sp]FFFFFFFFFFFFC7B0 37EF8018 ret #24;--------------------------------------------------------------------------; Initialize sprite image caches with random data.;--------------------------------------------------------------------------FFFFFFFFFFFFC7B4 RandomizeSprram:FFFFFFFFFFFFC7B4 E6980000 ; SETLOFFFFFFFFFFFFC7B8 EE800003 ; SETMIDFFFFFFFFFFFFC7BC 6A0D082D lea r2,SPRRAMFFFFFFFFFFFFC7C0 E10037FF setlo r4,#14335 ; number of chars to initializeFFFFFFFFFFFFC7C4 rsr1:FFFFFFFFFFFFC7C4 00000050 granFFFFFFFFFFFFC7C8 020088A8 mfspr r1,randFFFFFFFFFFFFC7CC 92208000 outc r1,[r2]FFFFFFFFFFFFC7D0 0A210002 addui r2,r2,#2FFFFFFFFFFFFC7D4 BE027F8F loop r4,rsr1FFFFFFFFFFFFC7D8 37EF8000 ret;--------------------------------------------------------------------------; Setup the AC97/LM4550 audio controller. Check keyboard for a CTRL-C; interrupt which may be necessary if the audio controller isn't; responding.;--------------------------------------------------------------------------;FFFFFFFFFFFFC7DC SetupAC97:FFFFFFFFFFFFC7DC 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFC7E0 67E08000 sw r1,[sp]FFFFFFFFFFFFC7E4 67EF8008 sw lr,8[sp]FFFFFFFFFFFFC7E8 sac974:FFFFFFFFFFFFC7E8 E69C1026 ; SETLOFFFFFFFFFFFFC7EC EE800003 ; SETMIDFFFFFFFFFFFFC7F0 6A0D0029 outc r0,AC97+0x26 ; trigger a read of register 26 (status reg)FFFFFFFFFFFFC7F4 sac971: ; wait for status to register 0xF (all ready)FFFFFFFFFFFFC7F4 31FFEE08 call KeybdGetChar ; see if we needed to CTRL-CFFFFFFFFFFFFC7F8 B0100A03 beqi r1,#CTRLC,sac973FFFFFFFFFFFFC7FC E69C1068 ; SETLOFFFFFFFFFFFFC800 EE800003 ; SETMIDFFFFFFFFFFFFC804 6A0D0429 outc r1,AC97+0x68 ; wait for dirty bit to clearFFFFFFFFFFFFC808 BE107F69 bne r1,r0,sac971FFFFFFFFFFFFC80C E69C1026 ; SETLOFFFFFFFFFFFFC810 EE800003 ; SETMIDFFFFFFFFFFFFC814 6A0D0429 outc r1,AC97+0x26 ; check status at reg h26, wait forFFFFFFFFFFFFC818 1410800F andi r1,r1,#0x0F ; analogue to be readyFFFFFFFFFFFFC81C B21FF30F bnei r1,#0x0F,sac974FFFFFFFFFFFFC820 sac973:FFFFFFFFFFFFC820 E69C1002 ; SETLOFFFFFFFFFFFFC824 EE800003 ; SETMIDFFFFFFFFFFFFC828 6A0D0029 outc r0,AC97+2 ; master volume, 0db attenuation, mute offFFFFFFFFFFFFC82C E69C1004 ; SETLOFFFFFFFFFFFFC830 EE800003 ; SETMIDFFFFFFFFFFFFC834 6A0D0029 outc r0,AC97+4 ; headphone volume, 0db attenuation, mute offFFFFFFFFFFFFC838 E69C1018 ; SETLOFFFFFFFFFFFFC83C EE800003 ; SETMIDFFFFFFFFFFFFC840 6A0D0029 outc r0,AC97+0x18 ; PCM gain (mixer) mute off, no attenuationFFFFFFFFFFFFC844 E69C100A ; SETLOFFFFFFFFFFFFC848 EE800003 ; SETMIDFFFFFFFFFFFFC84C 6A0D0029 outc r0,AC97+0x0A ; mute PC beepFFFFFFFFFFFFC850 E07F8000 setlo r1,#0x8000 ; bypass 3D soundFFFFFFFFFFFFC854 E69C1020 ; SETLOFFFFFFFFFFFFC858 EE800003 ; SETMIDFFFFFFFFFFFFC85C 6A0D0429 outc r1,AC97+0x20FFFFFFFFFFFFC860 sac972:FFFFFFFFFFFFC860 31FFEE08 call KeybdGetCharFFFFFFFFFFFFC864 B0100503 beqi r1,#CTRLC,sac975FFFFFFFFFFFFC868 E69C1068 ; SETLOFFFFFFFFFFFFC86C EE800003 ; SETMIDFFFFFFFFFFFFC870 6A0D0429 outc r1,AC97+0x68 ; wait for dirty bits to clearFFFFFFFFFFFFC874 BE107F69 bne r1,r0,sac972 ; wait a while for the settings to take effectFFFFFFFFFFFFC878 sac975:FFFFFFFFFFFFC878 47EF8008 lw lr,8[sp]FFFFFFFFFFFFC87C 47E08000 lw r1,[sp]FFFFFFFFFFFFC880 37EF8010 ret #16;--------------------------------------------------------------------------; Sound a 800 Hz beep;--------------------------------------------------------------------------;FFFFFFFFFFFFC884 Beep:FFFFFFFFFFFFC884 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFC888 67E08000 sw r1,[sp]FFFFFFFFFFFFC88C 67EF8008 sw lr,8[sp]FFFFFFFFFFFFC890 E0400008 setlo r1,#8FFFFFFFFFFFFC894 E69C0600 ; SETLOFFFFFFFFFFFFC898 EE800003 ; SETMIDFFFFFFFFFFFFC89C 6A0D0428 outb r1,LEDFFFFFFFFFFFFC8A0 1600800F ori r1,r0,#15 ; master volume to maxFFFFFFFFFFFFC8A4 E6950080 ; SETLOFFFFFFFFFFFFC8A8 EE800003 ; SETMIDFFFFFFFFFFFFC8AC 6A0D0429 outc r1,PSG+128FFFFFFFFFFFFC8B0 1600B46E ori r1,r0,#13422 ; 800HzFFFFFFFFFFFFC8B4 E6950000 ; SETLOFFFFFFFFFFFFC8B8 EE800003 ; SETMIDFFFFFFFFFFFFC8BC 6A0D0429 outc r1,PSGFREQ0FFFFFFFFFFFFC8C0 E0400009 setlo r1,#9FFFFFFFFFFFFC8C4 E69C0600 ; SETLOFFFFFFFFFFFFC8C8 EE800003 ; SETMIDFFFFFFFFFFFFC8CC 6A0D0428 outb r1,LED; decay (16.384 ms)2; attack (8.192 ms)1; release (1.024 s)A; sustain level CFFFFFFFFFFFFC8D0 E07FCA12 setlo r1,#0xCA12FFFFFFFFFFFFC8D4 E6950006 ; SETLOFFFFFFFFFFFFC8D8 EE800003 ; SETMIDFFFFFFFFFFFFC8DC 6A0D0429 outc r1,PSGADSR0FFFFFFFFFFFFC8E0 16009104 ori r1,r0,#0x1104 ; gate, output enable, triangle waveformFFFFFFFFFFFFC8E4 E6950004 ; SETLOFFFFFFFFFFFFC8E8 EE800003 ; SETMIDFFFFFFFFFFFFC8EC 6A0D0429 outc r1,PSGCTRL0FFFFFFFFFFFFC8F0 E6BD7840 ; SETLOFFFFFFFFFFFFC8F4 EE800005 ; SETMIDFFFFFFFFFFFFC8F8 040D0409 ori r1,r0,#25000000 ; delay about 1sFFFFFFFFFFFFC8FC beep1:FFFFFFFFFFFFC8FC BE00800F loop r1,beep1FFFFFFFFFFFFC900 E040000D setlo r1,#13FFFFFFFFFFFFC904 E69C0600 ; SETLOFFFFFFFFFFFFC908 EE800003 ; SETMIDFFFFFFFFFFFFC90C 6A0D0428 outb r1,LEDFFFFFFFFFFFFC910 16008104 ori r1,r0,#0x0104 ; gate off, output enable, triangle waveformFFFFFFFFFFFFC914 E6950004 ; SETLOFFFFFFFFFFFFC918 EE800003 ; SETMIDFFFFFFFFFFFFC91C 6A0D0429 outc r1,PSGCTRL0FFFFFFFFFFFFC920 E6BD7840 ; SETLOFFFFFFFFFFFFC924 EE800005 ; SETMIDFFFFFFFFFFFFC928 040D0409 ori r1,r0,#25000000 ; delay about 1sFFFFFFFFFFFFC92C beep2:FFFFFFFFFFFFC92C BE00800F loop r1,beep2FFFFFFFFFFFFC930 E0400010 setlo r1,#16FFFFFFFFFFFFC934 E69C0600 ; SETLOFFFFFFFFFFFFC938 EE800003 ; SETMIDFFFFFFFFFFFFC93C 6A0D0428 outb r1,LEDFFFFFFFFFFFFC940 16008000 ori r1,r0,#0x0000 ; gate off, output enable off, no waveformFFFFFFFFFFFFC944 E6950004 ; SETLOFFFFFFFFFFFFC948 EE800003 ; SETMIDFFFFFFFFFFFFC94C 6A0D0429 outc r1,PSGCTRL0FFFFFFFFFFFFC950 47EF8008 lw lr,8[sp]FFFFFFFFFFFFC954 47E08000 lw r1,[sp]FFFFFFFFFFFFC958 37EF8010 ret #16;--------------------------------------------------------------------------;--------------------------------------------------------------------------;FFFFFFFFFFFFC95C Piano:FFFFFFFFFFFFC95C 1600800F ori r1,r0,#15 ; master volume to maxFFFFFFFFFFFFC960 E6950080 ; SETLOFFFFFFFFFFFFC964 EE800003 ; SETMIDFFFFFFFFFFFFC968 6A0D0429 outc r1,PSG+128FFFFFFFFFFFFC96C playnt:FFFFFFFFFFFFC96C 31FFEE08 call KeybdGetCharFFFFFFFFFFFFC970 B01E3A03 beqi r1,#CTRLC,MonitorFFFFFFFFFFFFC974 B0100861 beqi r1,#'a',playnt1aFFFFFFFFFFFFC978 B0100A62 beqi r1,#'b',playnt1bFFFFFFFFFFFFC97C B0100C63 beqi r1,#'c',playnt1cFFFFFFFFFFFFC980 B0100E64 beqi r1,#'d',playnt1dFFFFFFFFFFFFC984 B0101065 beqi r1,#'e',playnt1eFFFFFFFFFFFFC988 B0101266 beqi r1,#'f',playnt1fFFFFFFFFFFFFC98C B0101467 beqi r1,#'g',playnt1gFFFFFFFFFFFFC990 BE007EEA bra playntFFFFFFFFFFFFC994 playnt1a:FFFFFFFFFFFFC994 E0401C31 setlo r1,#7217FFFFFFFFFFFFC998 31FFF27A call ToneFFFFFFFFFFFFC99C BE007E8A bra playntFFFFFFFFFFFFC9A0 playnt1b:FFFFFFFFFFFFC9A0 E0401FA5 setlo r1,#8101FFFFFFFFFFFFC9A4 31FFF27A call ToneFFFFFFFFFFFFC9A8 BE007E2A bra playntFFFFFFFFFFFFC9AC playnt1c:FFFFFFFFFFFFC9AC E04010C3 setlo r1,#4291FFFFFFFFFFFFC9B0 31FFF27A call ToneFFFFFFFFFFFFC9B4 BE007DCA bra playntFFFFFFFFFFFFC9B8 playnt1d:FFFFFFFFFFFFC9B8 E04012D1 setlo r1,#4817FFFFFFFFFFFFC9BC 31FFF27A call ToneFFFFFFFFFFFFC9C0 BE007D6A bra playntFFFFFFFFFFFFC9C4 playnt1e:FFFFFFFFFFFFC9C4 E040151F setlo r1,#5407FFFFFFFFFFFFC9C8 31FFF27A call ToneFFFFFFFFFFFFC9CC BE007D0A bra playntFFFFFFFFFFFFC9D0 playnt1f:FFFFFFFFFFFFC9D0 E0401660 setlo r1,#5728FFFFFFFFFFFFC9D4 31FFF27A call ToneFFFFFFFFFFFFC9D8 BE007CAA bra playntFFFFFFFFFFFFC9DC playnt1g:FFFFFFFFFFFFC9DC E040191E setlo r1,#6430FFFFFFFFFFFFC9E0 31FFF27A call ToneFFFFFFFFFFFFC9E4 BE007C4A bra playntFFFFFFFFFFFFC9E8 Tone:FFFFFFFFFFFFC9E8 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFC9EC 67E08000 sw r1,[sp]FFFFFFFFFFFFC9F0 67EF8008 sw lr,8[sp]FFFFFFFFFFFFC9F4 E6950000 ; SETLOFFFFFFFFFFFFC9F8 EE800003 ; SETMIDFFFFFFFFFFFFC9FC 6A0D0429 outc r1,PSGFREQ0; decay (16.384 ms)2; attack (8.192 ms)1; release (1.024 s)A; sustain level CFFFFFFFFFFFFCA00 E07FCA12 setlo r1,#0xCA12FFFFFFFFFFFFCA04 E6950006 ; SETLOFFFFFFFFFFFFCA08 EE800003 ; SETMIDFFFFFFFFFFFFCA0C 6A0D0429 outc r1,PSGADSR0FFFFFFFFFFFFCA10 16009104 ori r1,r0,#0x1104 ; gate, output enable, triangle waveformFFFFFFFFFFFFCA14 E6950004 ; SETLOFFFFFFFFFFFFCA18 EE800003 ; SETMIDFFFFFFFFFFFFCA1C 6A0D0429 outc r1,PSGCTRL0FFFFFFFFFFFFCA20 E683D090 ; SETLOFFFFFFFFFFFFCA24 040D0409 ori r1,r0,#250000 ; delay about 10msFFFFFFFFFFFFCA28 tone1:FFFFFFFFFFFFCA28 BE00800F loop r1,tone1FFFFFFFFFFFFCA2C 16008104 ori r1,r0,#0x0104 ; gate off, output enable, triangle waveformFFFFFFFFFFFFCA30 E6950004 ; SETLOFFFFFFFFFFFFCA34 EE800003 ; SETMIDFFFFFFFFFFFFCA38 6A0D0429 outc r1,PSGCTRL0FFFFFFFFFFFFCA3C E683D090 ; SETLOFFFFFFFFFFFFCA40 040D0409 ori r1,r0,#250000 ; delay about 10msFFFFFFFFFFFFCA44 tone2:FFFFFFFFFFFFCA44 BE00800F loop r1,tone2FFFFFFFFFFFFCA48 16008000 ori r1,r0,#0x0000 ; gate off, output enable off, no waveformFFFFFFFFFFFFCA4C E6950004 ; SETLOFFFFFFFFFFFFCA50 EE800003 ; SETMIDFFFFFFFFFFFFCA54 6A0D0429 outc r1,PSGCTRL0FFFFFFFFFFFFCA58 47EF8008 lw lr,8[sp]FFFFFFFFFFFFCA5C 47E08000 lw r1,[sp]FFFFFFFFFFFFCA60 37EF8010 ret #16;==============================================================================;==============================================================================FFFFFFFFFFFFCA64 SetupRasterIRQ:FFFFFFFFFFFFCA64 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFCA68 67E08000 sw r1,[sp]FFFFFFFFFFFFCA6C E04000C8 setlo r1,#200FFFFFFFFFFFFCA70 E69A0100 ; SETLOFFFFFFFFFFFFCA74 EE800003 ; SETMIDFFFFFFFFFFFFCA78 6A0D0429 outc r1,RASTERIRQFFFFFFFFFFFFCA7C E04000F0 setlo r1,#240FFFFFFFFFFFFCA80 E69A0102 ; SETLOFFFFFFFFFFFFCA84 EE800003 ; SETMIDFFFFFFFFFFFFCA88 6A0D0429 outc r1,RASTERIRQ+2FFFFFFFFFFFFCA8C E0400118 setlo r1,#280FFFFFFFFFFFFCA90 E69A0104 ; SETLOFFFFFFFFFFFFCA94 EE800003 ; SETMIDFFFFFFFFFFFFCA98 6A0D0429 outc r1,RASTERIRQ+4FFFFFFFFFFFFCA9C E0400140 setlo r1,#320FFFFFFFFFFFFCAA0 E69A0106 ; SETLOFFFFFFFFFFFFCAA4 EE800003 ; SETMIDFFFFFFFFFFFFCAA8 6A0D0429 outc r1,RASTERIRQ+6FFFFFFFFFFFFCAAC E0400168 setlo r1,#360FFFFFFFFFFFFCAB0 E69A0108 ; SETLOFFFFFFFFFFFFCAB4 EE800003 ; SETMIDFFFFFFFFFFFFCAB8 6A0D0429 outc r1,RASTERIRQ+8FFFFFFFFFFFFCABC 47E08000 lw r1,[sp]FFFFFFFFFFFFCAC0 37EF8008 ret #8FFFFFFFFFFFFCAC4 RasterIRQfn:FFFFFFFFFFFFCAC4 E69A011E ; SETLOFFFFFFFFFFFFCAC8 EE800003 ; SETMIDFFFFFFFFFFFFCACC 6A0D0421 inch r1,RASTERIRQ+30 ; get the raster compare register # (clears IRQ)FFFFFFFFFFFFCAD0 B0100901 beqi r1,#1,rirq1FFFFFFFFFFFFCAD4 B0100802 beqi r1,#2,rirq2FFFFFFFFFFFFCAD8 B0100703 beqi r1,#3,rirq3FFFFFFFFFFFFCADC B0100604 beqi r1,#4,rirq4FFFFFFFFFFFFCAE0 B0100505 beqi r1,#5,rirq5FFFFFFFFFFFFCAE4 B0100406 beqi r1,#6,rirq6FFFFFFFFFFFFCAE8 B0100307 beqi r1,#7,rirq7FFFFFFFFFFFFCAEC B0100208 beqi r1,#8,rirq8FFFFFFFFFFFFCAF0 37EF8000 retFFFFFFFFFFFFCAF4 rirq1:FFFFFFFFFFFFCAF4 rirq2:FFFFFFFFFFFFCAF4 rirq3:FFFFFFFFFFFFCAF4 rirq4:FFFFFFFFFFFFCAF4 rirq5:FFFFFFFFFFFFCAF4 rirq6:FFFFFFFFFFFFCAF4 rirq7:FFFFFFFFFFFFCAF4 rirq8:FFFFFFFFFFFFCAF4 1A108028 mului r1,r1,#40FFFFFFFFFFFFCAF8 0A1080CC addui r1,r1,#204FFFFFFFFFFFFCAFC E69AD002 ; SETLOFFFFFFFFFFFFCB00 EE800003 ; SETMIDFFFFFFFFFFFFCB04 6A0D0429 outc r1,SPRITEREGS+2FFFFFFFFFFFFCB08 E69AD012 ; SETLOFFFFFFFFFFFFCB0C EE800003 ; SETMIDFFFFFFFFFFFFCB10 6A0D0429 outc r1,SPRITEREGS+18FFFFFFFFFFFFCB14 E69AD022 ; SETLOFFFFFFFFFFFFCB18 EE800003 ; SETMIDFFFFFFFFFFFFCB1C 6A0D0429 outc r1,SPRITEREGS+34FFFFFFFFFFFFCB20 E69AD032 ; SETLOFFFFFFFFFFFFCB24 EE800003 ; SETMIDFFFFFFFFFFFFCB28 6A0D0429 outc r1,SPRITEREGS+50FFFFFFFFFFFFCB2C E69AD042 ; SETLOFFFFFFFFFFFFCB30 EE800003 ; SETMIDFFFFFFFFFFFFCB34 6A0D0429 outc r1,SPRITEREGS+66FFFFFFFFFFFFCB38 E69AD052 ; SETLOFFFFFFFFFFFFCB3C EE800003 ; SETMIDFFFFFFFFFFFFCB40 6A0D0429 outc r1,SPRITEREGS+82FFFFFFFFFFFFCB44 E69AD062 ; SETLOFFFFFFFFFFFFCB48 EE800003 ; SETMIDFFFFFFFFFFFFCB4C 6A0D0429 outc r1,SPRITEREGS+98FFFFFFFFFFFFCB50 E69AD072 ; SETLOFFFFFFFFFFFFCB54 EE800003 ; SETMIDFFFFFFFFFFFFCB58 6A0D0429 outc r1,SPRITEREGS+114FFFFFFFFFFFFCB5C 37EF8000 ret;------------------------------------------------------------------------------;------------------------------------------------------------------------------FFFFFFFFFFFFCB60 DisplayDatetime:FFFFFFFFFFFFCB60 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFCB64 67E08000 sw r1,[sp]FFFFFFFFFFFFCB68 67E10008 sw r2,8[sp]FFFFFFFFFFFFCB6C 67E18010 sw r3,16[sp]FFFFFFFFFFFFCB70 67EF8018 sw lr,24[sp]FFFFFFFFFFFFCB74 31FFEEBA call CursorOffFFFFFFFFFFFFCB78 42011416 lc r2,CursorRowFFFFFFFFFFFFCB7C 42019418 lc r3,CursorColFFFFFFFFFFFFCB80 E69C0418 ; SETLOFFFFFFFFFFFFCB84 EE800003 ; SETMIDFFFFFFFFFFFFCB88 6A0D002B outw r0,DATETIME+24 ; trigger a snapshotFFFFFFFFFFFFCB8C 1600802E lw r1,#46 ; move cursor down to last display lineFFFFFFFFFFFFCB90 62009416 sc r1,CursorRowFFFFFFFFFFFFCB94 16008040 lw r1,#64FFFFFFFFFFFFCB98 62009418 sc r1,CursorColFFFFFFFFFFFFCB9C E69C0400 ; SETLOFFFFFFFFFFFFCBA0 EE800003 ; SETMIDFFFFFFFFFFFFCBA4 6A0D0423 inw r1,DATETIME ; get the snapshotted date and timeFFFFFFFFFFFFCBA8 31FFF019 call DisplayWord ; display on screenFFFFFFFFFFFFCBAC 62011416 sc r2,CursorRow ; restore cursor positionFFFFFFFFFFFFCBB0 62019418 sc r3,CursorColFFFFFFFFFFFFCBB4 31FFEF37 call CalcScreenLocFFFFFFFFFFFFCBB8 31FFEEBF call CursorOnFFFFFFFFFFFFCBBC 47EF8018 lw lr,24[sp]FFFFFFFFFFFFCBC0 47E18010 lw r3,16[sp]FFFFFFFFFFFFCBC4 47E10008 lw r2,8[sp]FFFFFFFFFFFFCBC8 47E08000 lw r1,[sp]FFFFFFFFFFFFCBCC 37EF8020 ret #32;==============================================================================;==============================================================================FFFFFFFFFFFFCBD0 InitializeGame:FFFFFFFFFFFFCBD0 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFCBD4 27F40000004 sm [sp],r3/lrFFFFFFFFFFFFCBD8 E0C00140 setlo r3,#320FFFFFFFFFFFFCBDC 62019508 sc r3,ManposFFFFFFFFFFFFCBE0 62001500 sc r0,ScoreFFFFFFFFFFFFCBE4 60001510 sb r0,MissileActiveFFFFFFFFFFFFCBE8 62001512 sc r0,MissileXFFFFFFFFFFFFCBEC 62001514 sc r0,MissileYFFFFFFFFFFFFCBF0 27740000004 lm [sp],r3/lrFFFFFFFFFFFFCBF4 37EF8010 ret #16FFFFFFFFFFFFCBF8 DrawScore:FFFFFFFFFFFFCBF8 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFCBFC 27F40000005 sm [sp],r1/r3/lrFFFFFFFFFFFFCC00 E0C00001 setlo r3,#1FFFFFFFFFFFFCC04 60019416 sb r3,CursorRowFFFFFFFFFFFFCC08 E0C00028 setlo r3,#40FFFFFFFFFFFFCC0C 60019418 sb r3,CursorColFFFFFFFFFFFFCC10 40009500 lb r1,ScoreFFFFFFFFFFFFCC14 31FFF00F call DisplayByteFFFFFFFFFFFFCC18 40009501 lb r1,Score+1FFFFFFFFFFFFCC1C 31FFF00F call DisplayByteFFFFFFFFFFFFCC20 27740000005 lm [sp],r1/r3/lrFFFFFFFFFFFFCC24 37EF8018 ret #24FFFFFFFFFFFFCC28 DrawMissile:FFFFFFFFFFFFCC28 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFCC2C 27F40000001 sm [sp],r1/lrFFFFFFFFFFFFCC30 42009514 lc r1,MissileYFFFFFFFFFFFFCC34 AC101402 bleu r1,#2,MissileOffFFFFFFFFFFFFCC38 42009512 lc r1,MissileXFFFFFFFFFFFFCC3C 06108601 shrui r1,r1,#3FFFFFFFFFFFFCC40 60009418 sb r1,CursorColFFFFFFFFFFFFCC44 42009514 lc r1,MissileYFFFFFFFFFFFFCC48 60009416 sb r1,CursorRowFFFFFFFFFFFFCC4C 0E108001 subui r1,r1,#1FFFFFFFFFFFFCC50 62009514 sc r1,MissileYFFFFFFFFFFFFCC54 E040005E setlo r1,#'^'FFFFFFFFFFFFCC58 31FFEF47 call DisplayCharFFFFFFFFFFFFCC5C 40009418 lb r1,CursorColFFFFFFFFFFFFCC60 0E108001 subui r1,r1,#1FFFFFFFFFFFFCC64 60009418 sb r1,CursorColFFFFFFFFFFFFCC68 40009416 lb r1,CursorRowFFFFFFFFFFFFCC6C 0E108001 subui r1,r1,#1FFFFFFFFFFFFCC70 60009416 sb r1,CursorRowFFFFFFFFFFFFCC74 E0400020 setlo r1,#' 'FFFFFFFFFFFFCC78 31FFEF47 call DisplayCharFFFFFFFFFFFFCC7C 27740000001 lm [sp],r1/lrFFFFFFFFFFFFCC80 37EF8010 ret #16FFFFFFFFFFFFCC84 MissileOff:FFFFFFFFFFFFCC84 60001510 sb r0,MissileActiveFFFFFFFFFFFFCC88 42009512 lc r1,MissileXFFFFFFFFFFFFCC8C 06108601 shrui r1,r1,#3FFFFFFFFFFFFCC90 60009418 sb r1,CursorColFFFFFFFFFFFFCC94 42009514 lc r1,MissileYFFFFFFFFFFFFCC98 60009416 sb r1,CursorRowFFFFFFFFFFFFCC9C E0400020 setlo r1,#' 'FFFFFFFFFFFFCCA0 31FFEF47 call DisplayCharFFFFFFFFFFFFCCA4 27740000001 lm [sp],r1/lrFFFFFFFFFFFFCCA8 37EF8010 ret #16FFFFFFFFFFFFCCAC DrawMan:FFFFFFFFFFFFCCAC 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFCCB0 27F40000005 sm [sp],r1/r3/lrFFFFFFFFFFFFCCB4 E0C0002E setlo r3,#46FFFFFFFFFFFFCCB8 60019416 sb r3,CursorRowFFFFFFFFFFFFCCBC 42019508 lc r3,ManposFFFFFFFFFFFFCCC0 06318601 shrui r3,r3,#3FFFFFFFFFFFFCCC4 60019418 sb r3,CursorColFFFFFFFFFFFFCCC8 E0400020 setlo r1,#' 'FFFFFFFFFFFFCCCC 31FFEF47 call DisplayCharFFFFFFFFFFFFCCD0 E0400023 setlo r1,#'#'FFFFFFFFFFFFCCD4 31FFEF47 call DisplayCharFFFFFFFFFFFFCCD8 E0400041 setlo r1,#'A'FFFFFFFFFFFFCCDC 31FFEF47 call DisplayCharFFFFFFFFFFFFCCE0 E0400023 setlo r1,#'#'FFFFFFFFFFFFCCE4 31FFEF47 call DisplayCharFFFFFFFFFFFFCCE8 E0400020 setlo r1,#' 'FFFFFFFFFFFFCCEC 31FFEF47 call DisplayCharFFFFFFFFFFFFCCF0 27740000005 lm [sp],r1/r3/lrFFFFFFFFFFFFCCF4 37EF8018 ret #24FFFFFFFFFFFFCCF8 DrawInvader:FFFFFFFFFFFFCCF8 46018000 lw r3,InvaderPosFFFFFFFFFFFFCCFC 160080E9 lw r1,#233FFFFFFFFFFFFCD00 62308000 sc r1,[r3]FFFFFFFFFFFFCD04 160080F2 lw r1,#242FFFFFFFFFFFFCD08 62308001 sc r1,1[r3]FFFFFFFFFFFFCD0C 160080DF lw r1,#223FFFFFFFFFFFFCD10 62308002 sc r1,2[r3]FFFFFFFFFFFFCD14 37EF8000 retFFFFFFFFFFFFCD18 DrawInvaders:FFFFFFFFFFFFCD18 0FEF0028 subui sp,sp,#40FFFFFFFFFFFFCD1C 27F4000000F sm [sp],r1/r2/r3/r4/lrFFFFFFFFFFFFCD20 42009520 lc r1,InvadersRow1FFFFFFFFFFFFCD24 42021570 lc r4,InvadersColposFFFFFFFFFFFFCD28 14110001 andi r2,r1,#1FFFFFFFFFFFFCD2C BE2003A8 beq r2,r0,dinv1FFFFFFFFFFFFCD30 40019571 lb r3,InvadersRowposFFFFFFFFFFFFCD34 60019416 sb r3,CursorRowFFFFFFFFFFFFCD38 60021418 sb r4,CursorColFFFFFFFFFFFFCD3C E0400020 setlo r1,#' 'FFFFFFFFFFFFCD40 31FFF00F call DisplayByteFFFFFFFFFFFFCD44 E0400023 setlo r1,#'#'FFFFFFFFFFFFCD48 31FFF00F call DisplayByteFFFFFFFFFFFFCD4C E0400023 setlo r1,#'#'FFFFFFFFFFFFCD50 31FFF00F call DisplayByteFFFFFFFFFFFFCD54 E0400023 setlo r1,#'#'FFFFFFFFFFFFCD58 31FFF00F call DisplayByteFFFFFFFFFFFFCD5C E0400020 setlo r1,#' 'FFFFFFFFFFFFCD60 31FFF00F call DisplayByteFFFFFFFFFFFFCD64 40009416 lb r1,CursorRowFFFFFFFFFFFFCD68 0A108001 addui r1,r1,#1FFFFFFFFFFFFCD6C 60009416 sb r1,CursorRowFFFFFFFFFFFFCD70 40009418 lb r1,CursorColFFFFFFFFFFFFCD74 0E108005 subui r1,r1,#5FFFFFFFFFFFFCD78 E0400020 setlo r1,#' 'FFFFFFFFFFFFCD7C 31FFF00F call DisplayByteFFFFFFFFFFFFCD80 E0400058 setlo r1,#'X'FFFFFFFFFFFFCD84 31FFF00F call DisplayByteFFFFFFFFFFFFCD88 E0400020 setlo r1,#' 'FFFFFFFFFFFFCD8C 31FFF00F call DisplayByteFFFFFFFFFFFFCD90 E0400058 setlo r1,#'X'FFFFFFFFFFFFCD94 31FFF00F call DisplayByteFFFFFFFFFFFFCD98 E0400020 setlo r1,#' 'FFFFFFFFFFFFCD9C 31FFF00F call DisplayByteFFFFFFFFFFFFCDA0 dinv1:FFFFFFFFFFFFCDA0 2774000000F lm [sp],r1/r2/r3/r4/lrFFFFFFFFFFFFCDA4 37EF8028 ret #40FFFFFFFFFFFFCDA8 DrawBombs:FFFFFFFFFFFFCDA8 37EF8000 retFFFFFFFFFFFFCDAC Invaders:FFFFFFFFFFFFCDAC FFFFFFFFFFFF0000 subui sp,#240FFFFFFFFFFFFCDB0 27F4000000F sm [sp],r1/r2/r3/r4/lrFFFFFFFFFFFFCDB4 31FFF2F4 call InitializeGameFFFFFFFFFFFFCDB8 InvadersLoop:FFFFFFFFFFFFCDB8 31FFF2FE call DrawScoreFFFFFFFFFFFFCDBC 31FFF346 call DrawInvadersFFFFFFFFFFFFCDC0 31FFF36A call DrawBombsFFFFFFFFFFFFCDC4 31FFF30A call DrawMissileFFFFFFFFFFFFCDC8 31FFF32B call DrawManFFFFFFFFFFFFCDCC TestMoveMan:FFFFFFFFFFFFCDCC 31FFEE08 call KeybdGetCharFFFFFFFFFFFFCDD0 B010046B beqi r1,#'k',MoveManRightFFFFFFFFFFFFCDD4 B010096A beqi r1,#'j',MoveManLeftFFFFFFFFFFFFCDD8 B0100D20 beqi r1,#' ',FireMissileFFFFFFFFFFFFCDDC BE0002AA bra Invaders1FFFFFFFFFFFFCDE0 MoveManRight:FFFFFFFFFFFFCDE0 42011508 lc r2,ManposFFFFFFFFFFFFCDE4 E6800280 ; SETLOFFFFFFFFFFFFCDE8 BE2D0247 bgtu r2,#640,Invaders1FFFFFFFFFFFFCDEC 0A210008 addui r2,r2,#8FFFFFFFFFFFFCDF0 62011508 sc r2,ManposFFFFFFFFFFFFCDF4 BE0001EA bra Invaders1FFFFFFFFFFFFCDF8 MoveManLeft:FFFFFFFFFFFFCDF8 42011508 lc r2,ManposFFFFFFFFFFFFCDFC BE2001A2 ble r2,r0,Invaders1FFFFFFFFFFFFCE00 0E210008 subui r2,r2,#8FFFFFFFFFFFFCE04 62011508 sc r2,ManposFFFFFFFFFFFFCE08 BE00014A bra Invaders1FFFFFFFFFFFFCE0C FireMissile:FFFFFFFFFFFFCE0C 40011510 lb r2,MissileActiveFFFFFFFFFFFFCE10 BE200109 bne r2,r0,Invaders1FFFFFFFFFFFFCE14 E0800001 setlo r2,#1FFFFFFFFFFFFCE18 60011510 sb r2,MissileActiveFFFFFFFFFFFFCE1C 42011508 lc r2,ManposFFFFFFFFFFFFCE20 62011512 sc r2,MissileXFFFFFFFFFFFFCE24 E080002E setlo r2,#46FFFFFFFFFFFFCE28 62011514 sc r2,MissileYFFFFFFFFFFFFCE2C BE00002A bra Invaders1FFFFFFFFFFFFCE30 Invaders1:FFFFFFFFFFFFCE30 B0100203 beqi r1,#CTRLC,InvadersEndFFFFFFFFFFFFCE34 BE007C2A bra InvadersLoopFFFFFFFFFFFFCE38 InvadersEnd:FFFFFFFFFFFFCE38 2774000000F lm [sp],r1/r2/r3/r4/lrFFFFFFFFFFFFCE3C 0BEF00F0 addui sp,sp,#240FFFFFFFFFFFFCE40 BE0020CA bra Monitor;==============================================================================;==============================================================================;****************************************************************;; ;; Tiny BASIC for the Raptor64 ;; ;; Derived from a 68000 derivative of Palo Alto Tiny BASIC as ;; published in the May 1976 issue of Dr. Dobb's Journal. ;; Adapted to the 68000 by: ;; Gordon brndly ;; 12147 - 51 Street ;; Edmonton AB T5W 3G8 ;; Canada ;; (updated mailing address for 1996) ;; ;; Adapted to the Raptor64 by: ;; Robert Finch ;; Ontario, Canada ;; robfinch<remove>@opencores.org ;;****************************************************************;; Copyright (C) 2012 by Robert Finch. This program may be ;; freely distributed for personal use only. All commercial ;; rights are reserved. ;;****************************************************************;;; Register Usage; r8 = text pointer (global usage); r3,r4 = inputs parameters to subroutines; r2 = return value;;* Vers. 1.0 1984/7/17 - Original version by Gordon brndly;* 1.1 1984/12/9 - Addition of '0x' print term by Marvin Lipford;* 1.2 1985/4/9 - Bug fix in multiply routine by Rick Murray;; Standard jump table. You can change these addresses if you are; customizing this interpreter for a different environment.;FFFFFFFFFFFFCE44 GOSTART:FFFFFFFFFFFFCE44 33FFF39C jmp CSTART ; Cold Start entry pointFFFFFFFFFFFFCE48 GOWARM:FFFFFFFFFFFFCE48 33FFF3BE jmp WSTART ; Warm Start entry pointFFFFFFFFFFFFCE4C GOOUT:FFFFFFFFFFFFCE4C 33FFF95A jmp OUTC ; Jump to character-out routineFFFFFFFFFFFFCE50 GOIN:FFFFFFFFFFFFCE50 33FFF95B jmp INC ;Jump to character-in routineFFFFFFFFFFFFCE54 GOAUXO:FFFFFFFFFFFFCE54 33FFF962 jmp AUXOUT ; Jump to auxiliary-out routineFFFFFFFFFFFFCE58 GOAUXI:FFFFFFFFFFFFCE58 33FFF95C jmp AUXIN ; Jump to auxiliary-in routineFFFFFFFFFFFFCE5C GOBYE:FFFFFFFFFFFFCE5C 33FFF9EA jmp BYEBYE ; Jump to monitor, DOS, etc.;; Modifiable system constants:;FFFFFFFFFFFFCE60 align 8FFFFFFFFFFFFCE60 0000000010060000 TXTBGN dw 0x000000001_00600000 ;TXT ;beginning of program memoryFFFFFFFFFFFFCE68 00000000107FFFF8 ENDMEM dw 0x000000001_07FFFFF8 ; end of available memory;; The main interpreter starts here:;; Usage; r1 = temp; r8 = text buffer pointer; r12 = end of text in text buffer;FFFFFFFFFFFFCE70 align 16FFFFFFFFFFFFCE70 CSTART:; First save off the link register and OS sp valueFFFFFFFFFFFFCE70 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFCE74 67EF8000 sw lr,[sp]FFFFFFFFFFFFCE78 660F1088 sw sp,OSSPFFFFFFFFFFFFCE7C 460F4E68 lw sp,ENDMEM ; initialize stack pointerFFFFFFFFFFFFCE80 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFCE84 67EF8000 sw lr,[sp] ; save off return addressFFFFFFFFFFFFCE88 62001416 sc r0,CursorRow ; set screen outputFFFFFFFFFFFFCE8C 62001418 sc r0,CursorColFFFFFFFFFFFFCE90 6000141A sb r0,CursorFlashFFFFFFFFFFFFCE94 6600103C sw r0,posFFFFFFFFFFFFCE98 E6800020 ; SETLOFFFFFFFFFFFFCE9C EE800040 ; SETMIDFFFFFFFFFFFFCEA0 040D0809 lw r2,#0x10000020 ; black chars, yellow backgroundFFFFFFFFFFFFCEA4 64011040 sh r2,charToPrintFFFFFFFFFFFFCEA8 31FFEED9 call ClearScreenFFFFFFFFFFFFCEAC 9A00E5C0 lea r1,msgInit ; tell who we areFFFFFFFFFFFFCEB0 31FFF94D call PRMESGAUXFFFFFFFFFFFFCEB4 9A00E5C0 lea r1,msgInit ; tell who we areFFFFFFFFFFFFCEB8 31FFF940 call PRMESGFFFFFFFFFFFFCEBC 4600CE60 lw r1,TXTBGN ; init. end-of-program pointerFFFFFFFFFFFFCEC0 660090D0 sw r1,TXTUNFFFFFFFFFFFFFCEC4 4600CE68 lw r1,ENDMEM ; get address of end of memoryFFFFFFFFFFFFCEC8 0E108800 subui r1,r1,#2048 ; reserve 2K for the stackFFFFFFFFFFFFCECC 660090F8 sw r1,STKBOTFFFFFFFFFFFFCED0 0E10A000 subui r1,r1,#8192 ; 1000 varsFFFFFFFFFFFFCED4 660090D8 sw r1,VARBGNFFFFFFFFFFFFCED8 31FFF4C3 call clearVars ; clear the variable areaFFFFFFFFFFFFCEDC 460090D8 lw r1,VARBGN ; calculate number of bytes freeFFFFFFFFFFFFCEE0 460190D0 lw r3,TXTUNFFFFFFFFFFFFFCEE4 04118404 sub r1,r1,r3FFFFFFFFFFFFCEE8 E0800000 setlo r2,#0FFFFFFFFFFFFCEEC 31FFF88D call PRTNUMFFFFFFFFFFFFCEF0 9A00E668 lea r1,msgBytesFreeFFFFFFFFFFFFCEF4 31FFF940 call PRMESGFFFFFFFFFFFFCEF8 WSTART:FFFFFFFFFFFFCEF8 660010A8 sw r0,LOPVAR ; initialize internal variablesFFFFFFFFFFFFCEFC 66001098 sw r0,STKGOSFFFFFFFFFFFFCF00 66001090 sw r0,CURRNT ; current line number pointer = 0FFFFFFFFFFFFCF04 460F4E68 lw sp,ENDMEM ; init S.P. again, just in caseFFFFFFFFFFFFCF08 9A00E676 lea r1,msgReady ; display "Ready"FFFFFFFFFFFFCF0C 31FFF940 call PRMESGFFFFFFFFFFFFCF10 ST3:FFFFFFFFFFFFCF10 E040003E setlo r1,#'>' ; Prompt with a '>' andFFFFFFFFFFFFCF14 31FFF7D8 call GETLN ; read a line.FFFFFFFFFFFFCF18 31FFF91D call TOUPBUF ; convert to upper caseFFFFFFFFFFFFCF1C 02860009 mov r12,r8 ; save pointer to end of lineFFFFFFFFFFFFCF20 9A04111B lea r8,BUFFER ; point to the beginning of lineFFFFFFFFFFFFCF24 31FFF8FF call TSTNUM ; is there a number there?FFFFFFFFFFFFCF28 31FFF914 call IGNBLK ; skip trailing blanks; does line no. exist? (or nonzero?)FFFFFFFFFFFFCF2C BE101728 beq r1,r0,DIRECT ; if not, it's a direct statementFFFFFFFFFFFFCF30 AC1003FF bleu r1,#0xFFFF,ST2 ; see if line no. is <= 16 bitsFFFFFFFFFFFFCF34 9A00E694 lea r1,msgLineRange ; if not, we've overflowedFFFFFFFFFFFFCF38 BE007F4A bra ERRORFFFFFFFFFFFFCF3C ST2:; ugliness - store a character at potentially an; odd address (unaligned).FFFFFFFFFFFFCF3C 02110009 mov r2,r1 ; r2 = line numberFFFFFFFFFFFFCF40 60817FFE sb r2,-2[r8]FFFFFFFFFFFFCF44 06211001 shrui r2,r2,#8FFFFFFFFFFFFCF48 60817FFF sb r2,-1[r8] ; store the binary line no.FFFFFFFFFFFFCF4C 0E840002 subui r8,r8,#2FFFFFFFFFFFFCF50 31FFF80C call FNDLN ; find this line in save areaFFFFFFFFFFFFCF54 02968009 mov r13,r9 ; save possible line pointerFFFFFFFFFFFFCF58 BE1001C8 beq r1,r0,ST4 ; if not found, insert; here we found the line, so we're replacing the line; in the text area; first step - delete the lineFFFFFFFFFFFFCF5C E0400000 setlo r1,#0FFFFFFFFFFFFCF60 31FFF820 call FNDNXT ; find the next line (into r9)FFFFFFFFFFFFCF64 BE100049 bne r1,r0,ST7FFFFFFFFFFFFCF68 BE900108 beq r9,r0,ST6 ; no more linesFFFFFFFFFFFFCF6C ST7:FFFFFFFFFFFFCF6C 02908009 mov r1,r9 ; r1 = pointer to next lineFFFFFFFFFFFFCF70 02D10009 mov r2,r13 ; pointer to line to be deletedFFFFFFFFFFFFCF74 460190D0 lw r3,TXTUNF ; points to top of save areaFFFFFFFFFFFFCF78 31FFF829 call MVUP ; move up to deleteFFFFFFFFFFFFCF7C 660110D0 sw r2,TXTUNF ; update the end pointer; we moved the lines of text after the line being; deleted down, so the pointer to the next line; needs to be resetFFFFFFFFFFFFCF80 02D48009 mov r9,r13FFFFFFFFFFFFCF84 BE00006A bra ST4; here there were no more lines, so just move the; end of text pointer downFFFFFFFFFFFFCF88 ST6:FFFFFFFFFFFFCF88 660690D0 sw r13,TXTUNFFFFFFFFFFFFFCF8C 02D48009 mov r9,r13FFFFFFFFFFFFCF90 ST4:; here we're inserting because the line wasn't found; or it was deleted from the text areaFFFFFFFFFFFFCF90 02C08009 mov r1,r12 ; calculate the length of new lineFFFFFFFFFFFFCF94 04140404 sub r1,r1,r8FFFFFFFFFFFFCF98 A41FDE03 blei r1,#3,ST3 ; is it just a line no. & CR? if so, it was just a deleteFFFFFFFFFFFFCF9C 460590D0 lw r11,TXTUNF ; compute new end of textFFFFFFFFFFFFCFA0 02B50009 mov r10,r11 ; r10 = old TXTUNFFFFFFFFFFFFFCFA4 04B0AC02 add r11,r11,r1 ; r11 = new top of TXTUNF (r1=line length)FFFFFFFFFFFFCFA8 460090D8 lw r1,VARBGN ; see if there's enough roomFFFFFFFFFFFFCFAC BEB08064 bltu r11,r1,ST5FFFFFFFFFFFFCFB0 9A00E76F lea r1,msgTooBig ; if not, say soFFFFFFFFFFFFCFB4 33FFF7C8 jmp ERROR; open a space in the text areaFFFFFFFFFFFFCFB8 ST5:FFFFFFFFFFFFCFB8 660590D0 sw r11,TXTUNF ; if so, store new end positionFFFFFFFFFFFFCFBC 02A08009 mov r1,r10 ; points to old end of textFFFFFFFFFFFFCFC0 02B10009 mov r2,r11 ; points to new end of textFFFFFFFFFFFFCFC4 02918009 mov r3,r9 ; points to start of line after insert lineFFFFFFFFFFFFCFC8 31FFF82F call MVDOWN ; move things out of the way; copy line into text spaceFFFFFFFFFFFFCFCC 02808009 mov r1,r8 ; set up to do the insertion; move from bufferFFFFFFFFFFFFCFD0 02D10009 mov r2,r13 ; to vacated spaceFFFFFFFFFFFFCFD4 02C18009 mov r3,r12 ; until end of bufferFFFFFFFFFFFFCFD8 31FFF829 call MVUP ; do itFFFFFFFFFFFFCFDC BE0079AA bra ST3 ; go back and get another line;******************************************************************;; *** Tables *** DIRECT *** EXEC ***;; This section of the code tests a string against a table. When; a match is found, control is transferred to the section of; code according to the table.;; At 'EXEC', r8 should point to the string, r9 should point to; the character table, and r10 should point to the execution; table. At 'DIRECT', r8 should point to the string, r9 and; r10 will be set up to point to TAB1 and TAB1_1, which are; the tables of all direct and statement commands.;; A '.' in the string will terminate the test and the partial; match will be considered as a match, e.g. 'P.', 'PR.','PRI.',; 'PRIN.', or 'PRINT' will all match 'PRINT'.;; There are two tables: the character table and the execution; table. The character table consists of any number of text items.; Each item is a string of characters with the last character's; high bit set to one. The execution table holds a 32-bit; execution addresses that correspond to each entry in the; character table.;; The end of the character table is a 0 byte which corresponds; to the default routine in the execution table, which is; executed if none of the other table items are matched.;; Character-matching tables:FFFFFFFFFFFFCFE0 align 8FFFFFFFFFFFFCFE0 TAB1:FFFFFFFFFFFFCFE0 C4414F4CD453494C db "LOA",'D'+0x80FFFFFFFFFFFFCFE8 4153CE5552D7454E db "SAV",'E'+0x80FFFFFFFFFFFFCFF2 TAB2:FFFFFFFFFFFFCFF0 454CD458454EC556 db "LE",'T'+0x80FFFFFFFFFFFFCFF8 47CF544F47C649D4 db "GOSU",'B'+0x80FFFFFFFFFFFFD000 55544552C255534F db "RETUR",'N'+0x80FFFFFFFFFFFFD008 D24F46CD4552CE52 db "FO",'R'+0x80FFFFFFFFFFFFD010 495250D455504E49 db "PRIN",'T'+0x80FFFFFFFFFFFFD018 50C3454B4F50D44E db "POKE",'H'+0x80FFFFFFFFFFFFD020 454B4F50C8454B4F db "POKE",'W'+0x80FFFFFFFFFFFFD028 4F5453C54B4F50D7 db "STO",'P'+0x80FFFFFFFFFFFFD030 43D35953C55942D0 db "CL",'S'+0x80FFFFFFFFFFFFD038 434452D24C43D34C db "RDC",'F'+0x80FFFFFFFFFFFFD042 TAB4:FFFFFFFFFFFFD040 50C34B45455000C6 db "PEEK",'H'+0x80 ;FunctionsFFFFFFFFFFFFD048 4B454550C84B4545 db "PEEK",'W'+0x80 ;FunctionsFFFFFFFFFFFFD050 C44E52CB454550D7 db "RN",'D'+0x80FFFFFFFFFFFFD058 55C55A4953D34241 db "US",'R'+0x80FFFFFFFFFFFFD063 TAB5:FFFFFFFFFFFFD066 TAB6:FFFFFFFFFFFFD060 545300CF5400D253 db "STE",'P'+0x80 ;"STEP" in "FOR"FFFFFFFFFFFFD06B TAB8:FFFFFFFFFFFFD068 BEBE3CBD3E00D045 db '>'+0x80FFFFFFFFFFFFD075 TAB9:FFFFFFFFFFFFD070 C44E4100BCBD3CBD db "AN",'D'+0x80FFFFFFFFFFFFD079 TAB10:FFFFFFFFFFFFD080 .align 8;* Execution address tables:FFFFFFFFFFFFD080 TAB1_1:FFFFFFFFFFFFD080 FFFFFFFFFFFFD338 dw LISTX ;Direct commandsFFFFFFFFFFFFD088 FFFFFFFFFFFFD67C dw LOADFFFFFFFFFFFFD090 FFFFFFFFFFFFD284 dw NEWFFFFFFFFFFFFD098 FFFFFFFFFFFFD29C dw RUNFFFFFFFFFFFFD0A0 FFFFFFFFFFFFD728 dw SAVEFFFFFFFFFFFFD0A8 TAB2_1:FFFFFFFFFFFFD0A8 FFFFFFFFFFFFD508 dw NEXT ; Direct / statementFFFFFFFFFFFFD0B0 FFFFFFFFFFFFD664 dw LETFFFFFFFFFFFFD0B8 FFFFFFFFFFFFD578 dw IFFFFFFFFFFFFFD0C0 FFFFFFFFFFFFD2E4 dw GOTOFFFFFFFFFFFFD0C8 FFFFFFFFFFFFD418 dw GOSUBFFFFFFFFFFFFD0D0 FFFFFFFFFFFFD454 dw RETURNFFFFFFFFFFFFD0D8 FFFFFFFFFFFFD580 dw IF2 ; REMFFFFFFFFFFFFD0E0 FFFFFFFFFFFFD48C dw FORFFFFFFFFFFFFD0E8 FFFFFFFFFFFFD5A8 dw INPUTFFFFFFFFFFFFD0F0 FFFFFFFFFFFFD380 dw PRINTFFFFFFFFFFFFD0F8 FFFFFFFFFFFFD83C dw POKECFFFFFFFFFFFFD100 FFFFFFFFFFFFD868 dw POKEHFFFFFFFFFFFFD108 FFFFFFFFFFFFD894 dw POKEWFFFFFFFFFFFFD110 FFFFFFFFFFFFD808 dw POKEFFFFFFFFFFFFD118 FFFFFFFFFFFFD294 dw STOPFFFFFFFFFFFFD120 FFFFFFFFFFFFCE5C dw GOBYEFFFFFFFFFFFFD128 FFFFFFFFFFFFD8C0 dw SYSXFFFFFFFFFFFFD130 FFFFFFFFFFFFE58C dw _clsFFFFFFFFFFFFD138 FFFFFFFFFFFFD304 dw _clrFFFFFFFFFFFFD140 FFFFFFFFFFFFE5A0 dw _rdcfFFFFFFFFFFFFD148 FFFFFFFFFFFFD65C dw DEFLTFFFFFFFFFFFFD150 TAB4_1:FFFFFFFFFFFFD150 FFFFFFFFFFFFDD3C dw PEEKCFFFFFFFFFFFFD158 FFFFFFFFFFFFDD50 dw PEEKHFFFFFFFFFFFFD160 FFFFFFFFFFFFDD64 dw PEEKWFFFFFFFFFFFFD168 FFFFFFFFFFFFDD2C dw PEEK ;FunctionsFFFFFFFFFFFFD170 FFFFFFFFFFFFDD94 dw RNDFFFFFFFFFFFFD178 FFFFFFFFFFFFDE2C dw ABSFFFFFFFFFFFFD180 FFFFFFFFFFFFDE4C dw SIZEXFFFFFFFFFFFFD188 FFFFFFFFFFFFDD78 dw USRXFFFFFFFFFFFFD190 FFFFFFFFFFFFDB50 dw XP40FFFFFFFFFFFFD198 TAB5_1FFFFFFFFFFFFD198 FFFFFFFFFFFFD4A4 dw FR1 ;"TO" in "FOR"FFFFFFFFFFFFD1A0 FFFFFFFFFFFFDF1C dw QWHATFFFFFFFFFFFFD1A8 TAB6_1FFFFFFFFFFFFD1A8 FFFFFFFFFFFFD4B8 dw FR2 ;"STEP" in "FOR"FFFFFFFFFFFFD1B0 FFFFFFFFFFFFD4C0 dw FR3FFFFFFFFFFFFD1B8 TAB8_1FFFFFFFFFFFFD1B8 FFFFFFFFFFFFD9D0 dw XP11 ;>= Relational operatorsFFFFFFFFFFFFD1C0 FFFFFFFFFFFFD9E0 dw XP12 ;<>FFFFFFFFFFFFD1C8 FFFFFFFFFFFFD9F0 dw XP13 ;>FFFFFFFFFFFFD1D0 FFFFFFFFFFFFDA10 dw XP15 ;=FFFFFFFFFFFFD1D8 FFFFFFFFFFFFDA00 dw XP14 ;<=FFFFFFFFFFFFD1E0 FFFFFFFFFFFFDA20 dw XP16 ;<FFFFFFFFFFFFD1E8 FFFFFFFFFFFFDA48 dw XP17FFFFFFFFFFFFD1F0 TAB9_1FFFFFFFFFFFFD1F0 FFFFFFFFFFFFD93C dw XP_ANDFFFFFFFFFFFFD1F8 FFFFFFFFFFFFD94C dw XP_ANDXFFFFFFFFFFFFD200 TAB10_1FFFFFFFFFFFFD200 FFFFFFFFFFFFD904 dw XP_ORFFFFFFFFFFFFD208 FFFFFFFFFFFFD914 dw XP_ORXFFFFFFFFFFFFD210 .align 16;*; r3 = match flag (trashed); r9 = text table; r10 = exec table; r11 = trashedFFFFFFFFFFFFD210 DIRECT:FFFFFFFFFFFFD210 9A04CFE0 lea r9,TAB1FFFFFFFFFFFFD214 9A055080 lea r10,TAB1_1FFFFFFFFFFFFD218 EXEC:FFFFFFFFFFFFD218 03F58009 mov r11,lr ; save link regFFFFFFFFFFFFD21C 31FFF914 call IGNBLK ; ignore leading blanksFFFFFFFFFFFFD220 02BF8009 mov lr,r11 ; restore link regFFFFFFFFFFFFD224 02858009 mov r11,r8 ; save the pointerFFFFFFFFFFFFD228 E0C00000 setlo r3,#0 ; clear match flagFFFFFFFFFFFFD22C EXLP:FFFFFFFFFFFFD22C 4A808000 lbu r1,[r8] ; get the program characterFFFFFFFFFFFFD230 0A840001 addui r8,r8,#1FFFFFFFFFFFFD234 4A910000 lbu r2,[r9] ; get the table characterFFFFFFFFFFFFD238 BE200069 bne r2,r0,EXNGO ; If end of table,FFFFFFFFFFFFD23C 02B40009 mov r8,r11 ; restore the text pointer and...FFFFFFFFFFFFD240 BE0001EA bra EXGO ; execute the default.FFFFFFFFFFFFD244 EXNGO:FFFFFFFFFFFFD244 BE1181C8 beq r1,r3,EXGO ; Else check for period... if so, executeFFFFFFFFFFFFD248 1421007F andi r2,r2,#0x7f ; ignore the table's high bitFFFFFFFFFFFFD24C BE208108 beq r2,r1,EXMAT; is there a match?FFFFFFFFFFFFD250 0AA50008 addui r10,r10,#8 ;if not, try the next entryFFFFFFFFFFFFD254 02B40009 mov r8,r11 ; reset the program pointerFFFFFFFFFFFFD258 E0C00000 setlo r3,#0 ; sorry, no matchFFFFFFFFFFFFD25C EX1:FFFFFFFFFFFFD25C 0A948001 addui r9,r9,#1FFFFFFFFFFFFD260 4090FFFF lb r1,-1[r9] ; get to the end of the entryFFFFFFFFFFFFD264 BE107FC3 bgt r1,r0,EX1FFFFFFFFFFFFD268 BE007E2A bra EXLP ; back for more matchingFFFFFFFFFFFFD26C EXMAT:FFFFFFFFFFFFD26C E0C0002E setlo r3,#'.' ; we've got a match so farFFFFFFFFFFFFD270 0A948001 addui r9,r9,#1FFFFFFFFFFFFD274 4090FFFF lb r1,-1[r9] ; end of table entry?FFFFFFFFFFFFD278 BE107DA3 bgt r1,r0,EXLP ; if not, go back for moreFFFFFFFFFFFFD27C EXGO:FFFFFFFFFFFFD27C 46A58000 lw r11,[r10] ; execute the appropriate routineFFFFFFFFFFFFD280 34B00000 jal r0,[r11]; lb r1,[r8] ; get token from text space; bpl; and r1,#0x7f; shl r1,#2 ; * 4 - word offset; add r1,r1,#TAB1_1; lw r1,[r1]; jmp [r1];******************************************************************;; What follows is the code to execute direct and statement; commands. Control is transferred to these points via the command; table lookup code of 'DIRECT' and 'EXEC' in the last section.; After the command is executed, control is transferred to other; sections as follows:;; For 'LISTX', 'NEW', and 'STOP': go back to the warm start point.; For 'RUN': go execute the first stored line if any; else go; back to the warm start point.; For 'GOTO' and 'GOSUB': go execute the target line.; For 'RETURN' and 'NEXT'; go back to saved return line.; For all others: if 'CURRNT' is 0, go to warm start; else go; execute next command. (This is done in 'FINISH'.);;******************************************************************;; *** NEW *** STOP *** RUN (& friends) *** GOTO ***;; 'NEW<CR>' sets TXTUNF to point to TXTBGN;; 'STOP<CR>' goes back to WSTART;; 'RUN<CR>' finds the first stored line, stores its address; in CURRNT, and starts executing it. Note that only those; commands in TAB2 are legal for a stored program.;; There are 3 more entries in 'RUN':; 'RUNNXL' finds next line, stores it's address and executes it.; 'RUNTSL' stores the address of this line and executes it.; 'RUNSML' continues the execution on same line.;; 'GOTO expr<CR>' evaluates the expression, finds the target; line, and jumps to 'RUNTSL' to do it.;FFFFFFFFFFFFD284 NEW:FFFFFFFFFFFFD284 31FFF7B9 call ENDCHKFFFFFFFFFFFFD288 4600CE60 lw r1,TXTBGNFFFFFFFFFFFFD28C 660090D0 sw r1,TXTUNF ; set the end pointerFFFFFFFFFFFFD290 31FFF4C3 call clearVarsFFFFFFFFFFFFD294 STOP:FFFFFFFFFFFFD294 31FFF7B9 call ENDCHKFFFFFFFFFFFFD298 BE00630A bra WSTART ; WSTART will reset the stackFFFFFFFFFFFFD29C RUN:FFFFFFFFFFFFD29C 31FFF7B9 call ENDCHKFFFFFFFFFFFFD2A0 46044E60 lw r8,TXTBGN ; set pointer to beginningFFFFFFFFFFFFD2A4 66041090 sw r8,CURRNTFFFFFFFFFFFFD2A8 31FFF4C3 call clearVarsFFFFFFFFFFFFD2AC RUNNXL: ; RUN <next line>FFFFFFFFFFFFD2AC 46009090 lw r1,CURRNT ; executing a program?FFFFFFFFFFFFD2B0 BE106248 beq r1,r0,WSTART ; if not, we've finished a direct stat.FFFFFFFFFFFFD2B4 E0400000 setlo r1,#0 ; else find the next line numberFFFFFFFFFFFFD2B8 02848009 mov r9,r8FFFFFFFFFFFFD2BC 31FFF810 call FNDLNP ; search for the next lineFFFFFFFFFFFFD2C0 BE100069 bne r1,r0,RUNTSLFFFFFFFFFFFFD2C4 BE900049 bne r9,r0,RUNTSLFFFFFFFFFFFFD2C8 BE00618A bra WSTART ; if we've fallen off the end, stopFFFFFFFFFFFFD2CC RUNTSL: ; RUN <this line>FFFFFFFFFFFFD2CC 66049090 sw r9,CURRNT ; set CURRNT to point to the line no.FFFFFFFFFFFFD2D0 9A940002 lea r8,2[r9] ; set the text pointer toFFFFFFFFFFFFD2D4 RUNSML: ; RUN <same line>FFFFFFFFFFFFD2D4 31FFF936 call CHKIO ; see if a control-C was pressedFFFFFFFFFFFFD2D8 9A04CFF2 lea r9,TAB2 ; find command in TAB2FFFFFFFFFFFFD2DC 9A0550A8 lea r10,TAB2_1FFFFFFFFFFFFD2E0 BE0079CA bra EXEC ; and execute itFFFFFFFFFFFFD2E4 GOTO:FFFFFFFFFFFFD2E4 31FFF63A call OREXPR ;evaluate the following expressionFFFFFFFFFFFFD2E8 02128009 mov r5,r1FFFFFFFFFFFFD2EC 31FFF7B9 call ENDCHK ;must find end of lineFFFFFFFFFFFFD2F0 02508009 mov r1,r5FFFFFFFFFFFFD2F4 31FFF80C call FNDLN ; find the target lineFFFFFFFFFFFFD2F8 BE107EA9 bne r1,r0,RUNTSL ; go do itFFFFFFFFFFFFD2FC 9A00E73B lea r1,msgBadGotoGosubFFFFFFFFFFFFD300 BE00610A bra ERROR ; no such line no.FFFFFFFFFFFFD304 _clr:FFFFFFFFFFFFD304 31FFF4C3 call clearVarsFFFFFFFFFFFFD308 BE00084A bra FINISH; Clear the variable area of memoryFFFFFFFFFFFFD30C clearVars:FFFFFFFFFFFFD30C 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFD310 67E30000 sw r6,[sp]FFFFFFFFFFFFD314 67EF8008 sw lr,8[sp]FFFFFFFFFFFFD318 E1800800 setlo r6,#2048 ; number of words to clearFFFFFFFFFFFFD31C 460090D8 lw r1,VARBGNFFFFFFFFFFFFD320 cv1:FFFFFFFFFFFFD320 66100000 sw r0,[r1]FFFFFFFFFFFFD324 08108008 add r1,r1,#8FFFFFFFFFFFFD328 BE037FCF loop r6,cv1FFFFFFFFFFFFD32C 47EF8008 lw lr,8[sp]FFFFFFFFFFFFD330 47E30000 lw r6,[sp]FFFFFFFFFFFFD334 37EF8010 ret #16;******************************************************************; LIST;; LISTX has two forms:; 'LIST<CR>' lists all saved lines; 'LIST #<CR>' starts listing at the line #; Control-S pauses the listing, control-C stops it.;******************************************************************;FFFFFFFFFFFFD338 LISTX:FFFFFFFFFFFFD338 31FFF8FF call TSTNUM ; see if there's a line no.FFFFFFFFFFFFD33C 02128009 mov r5,r1FFFFFFFFFFFFD340 31FFF7B9 call ENDCHK ; if not, we get a zeroFFFFFFFFFFFFD344 02508009 mov r1,r5FFFFFFFFFFFFD348 31FFF80C call FNDLN ; find this or next lineFFFFFFFFFFFFD34C LS1:FFFFFFFFFFFFD34C BE100049 bne r1,r0,LS4FFFFFFFFFFFFD350 BE905D48 beq r9,r0,WSTART ; warm start if we passed the endFFFFFFFFFFFFD354 LS4:FFFFFFFFFFFFD354 02908009 mov r1,r9FFFFFFFFFFFFD358 31FFF8DF call PRTLN ; print the lineFFFFFFFFFFFFD35C 02148009 mov r9,r1 ; set pointer for nextFFFFFFFFFFFFD360 31FFF936 call CHKIO ; check for listing halt requestFFFFFFFFFFFFD364 BE100088 beq r1,r0,LS3FFFFFFFFFFFFD368 B2100313 bnei r1,#CTRLS,LS3 ; pause the listing?FFFFFFFFFFFFD36C LS2:FFFFFFFFFFFFD36C 31FFF936 call CHKIO ; if so, wait for another keypressFFFFFFFFFFFFD370 BE107FE8 beq r1,r0,LS2FFFFFFFFFFFFD374 LS3:FFFFFFFFFFFFD374 E0400000 setlo r1,#0FFFFFFFFFFFFD378 31FFF810 call FNDLNP ; find the next lineFFFFFFFFFFFFD37C BE007E8A bra LS1;******************************************************************; PRINT command is 'PRINT ....:' or 'PRINT ....<CR>'; where '....' is a list of expressions, formats, back-arrows,; and strings. These items a separated by commas.;; A format is a pound sign followed by a number. It controls; the number of spaces the value of an expression is going to; be printed in. It stays effective for the rest of the print; command unless changed by another format. If no format is; specified, 11 positions will be used.;; A string is quoted in a pair of single- or double-quotes.;; An underline (back-arrow) means generate a <CR> without a <LF>;; A <CR LF> is generated after the entire list has been printed; or if the list is empty. If the list ends with a semicolon,; however, no <CR LF> is generated.;******************************************************************;FFFFFFFFFFFFD380 PRINT:FFFFFFFFFFFFD380 1602800B lw r5,#11 ; D4 = number of print spacesFFFFFFFFFFFFD384 E0C0003A setlo r3,#':'FFFFFFFFFFFFD388 9A025398 lea r4,PR2FFFFFFFFFFFFD38C 31FFF8F1 call TSTC ; if null list and ":"FFFFFFFFFFFFD390 31FFEFFA call CRLF ; give CR-LF and continueFFFFFFFFFFFFD394 BE007A0A bra RUNSML ; execution on the same lineFFFFFFFFFFFFD398 PR2:FFFFFFFFFFFFD398 E0C0000D setlo r3,#CRFFFFFFFFFFFFD39C 9A0253AC lea r4,PR0FFFFFFFFFFFFD3A0 31FFF8F1 call TSTC ;if null list and <CR>FFFFFFFFFFFFD3A4 31FFEFFA call CRLF ;also give CR-LF andFFFFFFFFFFFFD3A8 BE00782A bra RUNNXL ;execute the next lineFFFFFFFFFFFFD3AC PR0:FFFFFFFFFFFFD3AC E0C00023 setlo r3,#'#'FFFFFFFFFFFFD3B0 9A0253C4 lea r4,PR1FFFFFFFFFFFFD3B4 31FFF8F1 call TSTC ;else is it a format?FFFFFFFFFFFFD3B8 31FFF63A call OREXPR ; yes, evaluate expressionFFFFFFFFFFFFD3BC 04101409 lw r5,r1 ; and save it as print widthFFFFFFFFFFFFD3C0 BE00012A bra PR3 ; look for more to printFFFFFFFFFFFFD3C4 PR1:FFFFFFFFFFFFD3C4 E0C00024 setlo r3,#'$'FFFFFFFFFFFFD3C8 9A0253DC lea r4,PR4FFFFFFFFFFFFD3CC 31FFF8F1 call TSTC ; is character expression? (MRL)FFFFFFFFFFFFD3D0 31FFF63A call OREXPR ; yep. Evaluate expression (MRL)FFFFFFFFFFFFD3D4 31FFF393 call GOOUT ; print low byte (MRL)FFFFFFFFFFFFD3D8 BE00006A bra PR3 ;look for more. (MRL)FFFFFFFFFFFFD3DC PR4:FFFFFFFFFFFFD3DC 31FFF867 call QTSTG ; is it a string?; the following branch must occupy only two bytes!FFFFFFFFFFFFD3E0 BE00010A bra PR8 ; if not, must be an expressionFFFFFFFFFFFFD3E4 PR3:FFFFFFFFFFFFD3E4 E0C0002C setlo r3,#','FFFFFFFFFFFFD3E8 9A0253F8 lea r4,PR6FFFFFFFFFFFFD3EC 31FFF8F1 call TSTC ; if ",", go find nextFFFFFFFFFFFFD3F0 31FFF7AA call FIN ;in the list.FFFFFFFFFFFFD3F4 BE007DCA bra PR0FFFFFFFFFFFFD3F8 PR6:FFFFFFFFFFFFD3F8 31FFEFFA call CRLF ;list ends hereFFFFFFFFFFFFD3FC BE0000AA bra FINISHFFFFFFFFFFFFD400 PR8:FFFFFFFFFFFFD400 31FFF63A call OREXPR ; evaluate the expressionFFFFFFFFFFFFD404 04500809 lw r2,r5 ; set the widthFFFFFFFFFFFFD408 31FFF88D call PRTNUM ; print its valueFFFFFFFFFFFFD40C BE007ECA bra PR3 ; more to print?FFFFFFFFFFFFD410 FINISH:FFFFFFFFFFFFD410 31FFF7AA call FIN ; Check end of commandFFFFFFFFFFFFD414 33FFF7C7 jmp QWHAT ; print "What?" if wrong;*******************************************************************;; *** GOSUB *** & RETURN ***;; 'GOSUB expr:' or 'GOSUB expr<CR>' is like the 'GOTO' command,; except that the current text pointer, stack pointer, etc. are; saved so that execution can be continued after the subroutine; 'RETURN's. In order that 'GOSUB' can be nested (and even; recursive), the save area must be stacked. The stack pointer; is saved in 'STKGOS'. The old 'STKGOS' is saved on the stack.; If we are in the main routine, 'STKGOS' is zero (this was done; in the initialization section of the interpreter), but we still; save it as a flag for no further 'RETURN's.;******************************************************************;FFFFFFFFFFFFD418 GOSUB:FFFFFFFFFFFFD418 31FFF83E call PUSHA ; save the current 'FOR' parametersFFFFFFFFFFFFD41C 31FFF63A call OREXPR ; get line numberFFFFFFFFFFFFD420 31FFF80C call FNDLN ; find the target lineFFFFFFFFFFFFD424 BE100069 bne r1,r0,gosub1FFFFFFFFFFFFD428 9A00E73B lea r1,msgBadGotoGosubFFFFFFFFFFFFD42C BE0057AA bra ERROR ; if not there, say "How?"FFFFFFFFFFFFD430 gosub1:FFFFFFFFFFFFD430 0DEF0018 sub sp,sp,#24FFFFFFFFFFFFD434 67E40000 sw r8,[sp] ; save text pointerFFFFFFFFFFFFD438 46009090 lw r1,CURRNTFFFFFFFFFFFFD43C 67E08008 sw r1,8[sp] ; found it, save old 'CURRNT'...FFFFFFFFFFFFD440 46009098 lw r1,STKGOSFFFFFFFFFFFFD444 67E08010 sw r1,16[sp] ; and 'STKGOS'FFFFFFFFFFFFD448 660010A8 sw r0,LOPVAR ; load new valuesFFFFFFFFFFFFD44C 660F1098 sw sp,STKGOSFFFFFFFFFFFFD450 BE0073EA bra RUNTSL;******************************************************************; 'RETURN<CR>' undoes everything that 'GOSUB' did, and thus; returns the execution to the command after the most recent; 'GOSUB'. If 'STKGOS' is zero, it indicates that we never had; a 'GOSUB' and is thus an error.;******************************************************************;FFFFFFFFFFFFD454 RETURN:FFFFFFFFFFFFD454 31FFF7B9 call ENDCHK ; there should be just a <CR>FFFFFFFFFFFFD458 46009098 lw r1,STKGOS ; get old stack pointerFFFFFFFFFFFFD45C BE100069 bne r1,r0,return1FFFFFFFFFFFFD460 9A00E758 lea r1,msgRetWoGosubFFFFFFFFFFFFD464 BE0055EA bra ERROR ; if zero, it doesn't existFFFFFFFFFFFFD468 return1:FFFFFFFFFFFFD468 021F0009 mov sp,r1 ; else restore itFFFFFFFFFFFFD46C 47E08010 lw r1,16[sp]FFFFFFFFFFFFD470 66009098 sw r1,STKGOS ; and the old 'STKGOS'FFFFFFFFFFFFD474 47E08008 lw r1,8[sp]FFFFFFFFFFFFD478 66009090 sw r1,CURRNT ; and the old 'CURRNT'FFFFFFFFFFFFD47C 47E40000 lw r8,[sp] ; and the old text pointerFFFFFFFFFFFFD480 09EF0018 add sp,sp,#24FFFFFFFFFFFFD484 31FFF831 call POPA ;and the old 'FOR' parametersFFFFFFFFFFFFD488 BE007C4A bra FINISH ;and we are back home;******************************************************************; *** FOR *** & NEXT ***;; 'FOR' has two forms:; 'FOR var=exp1 TO exp2 STEP exp1' and 'FOR var=exp1 TO exp2'; The second form means the same thing as the first form with a; STEP of positive 1. The interpreter will find the variable 'var'; and set its value to the current value of 'exp1'. It also; evaluates 'exp2' and 'exp1' and saves all these together with; the text pointer, etc. in the 'FOR' save area, which consists of; 'LOPVAR', 'LOPINC', 'LOPLMT', 'LOPLN', and 'LOPPT'. If there is; already something in the save area (indicated by a non-zero; 'LOPVAR'), then the old save area is saved on the stack before; the new values are stored. The interpreter will then dig in the; stack and find out if this same variable was used in another; currently active 'FOR' loop. If that is the case, then the old; 'FOR' loop is deactivated. (i.e. purged from the stack);******************************************************************;FFFFFFFFFFFFD48C FOR:FFFFFFFFFFFFD48C 31FFF83E call PUSHA ; save the old 'FOR' save areaFFFFFFFFFFFFD490 31FFF798 call SETVAL ; set the control variableFFFFFFFFFFFFD494 660090A8 sw r1,LOPVAR ; save its addressFFFFFFFFFFFFD498 9A04D063 lea r9,TAB5FFFFFFFFFFFFD49C 9A055198 lea r10,TAB5_1; use 'EXEC' to test for 'TO'FFFFFFFFFFFFD4A0 33FFF486 jmp EXECFFFFFFFFFFFFD4A4 FR1:FFFFFFFFFFFFD4A4 31FFF63A call OREXPR ; evaluate the limitFFFFFFFFFFFFD4A8 660090B8 sw r1,LOPLMT ; save thatFFFFFFFFFFFFD4AC 9A04D066 lea r9,TAB6FFFFFFFFFFFFD4B0 9A0551A8 lea r10,TAB6_1 ; use 'EXEC' to test for the word 'STEPFFFFFFFFFFFFD4B4 33FFF486 jmp EXECFFFFFFFFFFFFD4B8 FR2:FFFFFFFFFFFFD4B8 31FFF63A call OREXPR ; found it, get the step valueFFFFFFFFFFFFD4BC BE00004A bra FR4FFFFFFFFFFFFD4C0 FR3:FFFFFFFFFFFFD4C0 E0400001 setlo r1,#1 ; not found, step defaults to 1FFFFFFFFFFFFD4C4 FR4:FFFFFFFFFFFFD4C4 660090B0 sw r1,LOPINC ; save that tooFFFFFFFFFFFFD4C8 FR5:FFFFFFFFFFFFD4C8 46011090 lw r2,CURRNTFFFFFFFFFFFFD4CC 660110C0 sw r2,LOPLN ; save address of current line numberFFFFFFFFFFFFD4D0 660410C8 sw r8,LOPPT ; and text pointerFFFFFFFFFFFFD4D4 05E00C09 lw r3,sp ; dig into the stack to find 'LOPVAR'FFFFFFFFFFFFD4D8 460310A8 lw r6,LOPVARFFFFFFFFFFFFD4DC BE00004A bra FR7FFFFFFFFFFFFD4E0 FR6:FFFFFFFFFFFFD4E0 0A318028 addui r3,r3,#40 ; look at next stack frameFFFFFFFFFFFFD4E4 FR7:FFFFFFFFFFFFD4E4 46310000 lw r2,[r3] ; is it zero?FFFFFFFFFFFFD4E8 BE2000E8 beq r2,r0,FR8 ; if so, we're doneFFFFFFFFFFFFD4EC BE237FA9 bne r2,r6,FR6 ; same as current LOPVAR? nope, look some moreFFFFFFFFFFFFD4F0 04300409 lw r1,r3 ; Else remove 5 long words from...FFFFFFFFFFFFD4F4 0A310028 addui r2,r3,#40 ; inside the stack.FFFFFFFFFFFFD4F8 05E00C09 lw r3,spFFFFFFFFFFFFD4FC 31FFF82F call MVDOWNFFFFFFFFFFFFD500 09EF0028 add sp,sp,#40 ; set the SP 5 long words upFFFFFFFFFFFFD504 FR8:FFFFFFFFFFFFD504 BE00786A bra FINISH ; and continue execution;******************************************************************; 'NEXT var' serves as the logical (not necessarily physical) end; of the 'FOR' loop. The control variable 'var' is checked with; the 'LOPVAR'. If they are not the same, the interpreter digs in; the stack to find the right one and purges all those that didn't; match. Either way, it then adds the 'STEP' to that variable and; checks the result with against the limit value. If it is within; the limit, control loops back to the command following the; 'FOR'. If it's outside the limit, the save area is purged and; execution continues.;******************************************************************;FFFFFFFFFFFFD508 NEXT:FFFFFFFFFFFFD508 E0400000 setlo r1,#0 ; don't allocate itFFFFFFFFFFFFD50C 31FFF6EC call TSTV ; get address of variableFFFFFFFFFFFFD510 BE100069 bne r1,r0,NX4FFFFFFFFFFFFD514 9A00E717 lea r1,msgNextVarFFFFFFFFFFFFD518 BE00504A bra ERROR ; if no variable, say "What?"FFFFFFFFFFFFD51C NX4:FFFFFFFFFFFFD51C 02148009 mov r9,r1 ; save variable's addressFFFFFFFFFFFFD520 NX0:FFFFFFFFFFFFD520 460090A8 lw r1,LOPVAR ; If 'LOPVAR' is zero, we never...FFFFFFFFFFFFD524 BE100069 bne r1,r0,NX5 ; had a FOR loopFFFFFFFFFFFFD528 9A00E704 lea r1,msgNextForFFFFFFFFFFFFD52C BE004FAA bra ERRORFFFFFFFFFFFFD530 NX5:FFFFFFFFFFFFD530 BE148068 beq r1,r9,NX2 ; else we check them OK, they agreeFFFFFFFFFFFFD534 31FFF831 call POPA ; nope, let's see the next frameFFFFFFFFFFFFD538 BE007F4A bra NX0FFFFFFFFFFFFD53C NX2:FFFFFFFFFFFFD53C 46908000 lw r1,[r9] ; get control variable's valueFFFFFFFFFFFFD540 460110B0 lw r2,LOPINCFFFFFFFFFFFFD544 04110403 addu r1,r1,r2 ; add in loop increment; BVS.L QHOW say "How?" for 32-bit overflowFFFFFFFFFFFFD548 66908000 sw r1,[r9] ; save control variable's new valueFFFFFFFFFFFFD54C 460190B8 lw r3,LOPLMT ; get loop's limit valueFFFFFFFFFFFFD550 BE200063 bgt r2,r0,NX1 ; check loop increment, branch if loop increment is positiveFFFFFFFFFFFFD554 BE1180E0 blt r1,r3,NXPurge ; test against limitFFFFFFFFFFFFD558 BE00004A bra NX3FFFFFFFFFFFFD55C NX1:FFFFFFFFFFFFD55C BE1180A3 bgt r1,r3,NXPurgeFFFFFFFFFFFFD560 NX3:FFFFFFFFFFFFD560 460410C0 lw r8,LOPLN ; Within limit, go back to the...FFFFFFFFFFFFD564 66041090 sw r8,CURRNTFFFFFFFFFFFFD568 460410C8 lw r8,LOPPT ; saved 'CURRNT' and text pointer.FFFFFFFFFFFFD56C BE00752A bra FINISHFFFFFFFFFFFFD570 NXPurge:FFFFFFFFFFFFD570 31FFF831 call POPA ; purge this loopFFFFFFFFFFFFD574 BE0074EA bra FINISH;******************************************************************; *** REM *** IF *** INPUT *** LET (& DEFLT) ***;; 'REM' can be followed by anything and is ignored by the; interpreter.;;REM; br IF2 ; skip the rest of the line; 'IF' is followed by an expression, as a condition and one or; more commands (including other 'IF's) separated by colons.; Note that the word 'THEN' is not used. The interpreter evaluates; the expression. If it is non-zero, execution continues. If it; is zero, the commands that follow are ignored and execution; continues on the next line.;******************************************************************;FFFFFFFFFFFFD578 IF:FFFFFFFFFFFFD578 31FFF63A call OREXPR ; evaluate the expressionFFFFFFFFFFFFD57C IF1:FFFFFFFFFFFFD57C BE106AC9 bne r1,r0,RUNSML ; is it zero? if not, continueFFFFFFFFFFFFD580 IF2:FFFFFFFFFFFFD580 02848009 mov r9,r8 ; set lookup pointerFFFFFFFFFFFFD584 E0400000 setlo r1,#0 ; find line #0 (impossible)FFFFFFFFFFFFD588 31FFF821 call FNDSKP ; if so, skip the rest of the lineFFFFFFFFFFFFD58C BE104B63 bgt r1,r0,WSTART ; if no next line, do a warm startFFFFFFFFFFFFD590 IF3:FFFFFFFFFFFFD590 BE0069EA bra RUNTSL ; run the next line;******************************************************************; INPUT is called first and establishes a stack frameFFFFFFFFFFFFD594 INPERR:FFFFFFFFFFFFD594 460F10A0 lw sp,STKINP ; restore the old stack pointerFFFFFFFFFFFFD598 47E40010 lw r8,16[sp]FFFFFFFFFFFFD59C 66041090 sw r8,CURRNT ; and old 'CURRNT'FFFFFFFFFFFFD5A0 47E40008 lw r8,8[sp] ; and old text pointerFFFFFFFFFFFFD5A4 0BEF0028 addui sp,sp,#40 ; fall through will subtract 40; 'INPUT' is like the 'PRINT' command, and is followed by a list; of items. If the item is a string in single or double quotes,; or is an underline (back arrow), it has the same effect as in; 'PRINT'. If an item is a variable, this variable name is; printed out followed by a colon, then the interpreter waits for; an expression to be typed in. The variable is then set to the; value of this expression. If the variable is preceeded by a; string (again in single or double quotes), the string will be; displayed followed by a colon. The interpreter the waits for an; expression to be entered and sets the variable equal to the; expression's value. If the input expression is invalid, the; interpreter will print "What?", "How?", or "Sorry" and reprint; the prompt and redo the input. The execution will not terminate; unless you press control-C. This is handled in 'INPERR'.;FFFFFFFFFFFFD5A8 INPUT:FFFFFFFFFFFFD5A8 0FEF0028 subui sp,sp,#40 ; allocate stack frameFFFFFFFFFFFFD5AC 67E28020 sw r5,32[sp]FFFFFFFFFFFFD5B0 IP6:FFFFFFFFFFFFD5B0 67E40000 sw r8,[sp] ; save in case of errorFFFFFFFFFFFFD5B4 31FFF867 call QTSTG ; is next item a string?FFFFFFFFFFFFD5B8 BE0000CA bra IP2 ; nope - this branch must take only two bytesFFFFFFFFFFFFD5BC E0400001 setlo r1,#1 ; allocate varFFFFFFFFFFFFD5C0 31FFF6EC call TSTV ; yes, but is it followed by a variable?FFFFFFFFFFFFD5C4 BE1003E8 beq r1,r0,IP4 ; if not, brnchFFFFFFFFFFFFD5C8 02150009 mov r10,r1 ; put away the variable's addressFFFFFFFFFFFFD5CC BE0001AA bra IP3 ; if so, input to variableFFFFFFFFFFFFD5D0 IP2:FFFFFFFFFFFFD5D0 67E40008 sw r8,8[sp] ; save for 'PRTSTG'FFFFFFFFFFFFD5D4 E0400001 setlo r1,#1FFFFFFFFFFFFD5D8 31FFF6EC call TSTV ; must be a variable nowFFFFFFFFFFFFD5DC BE100069 bne r1,r0,IP7FFFFFFFFFFFFD5E0 9A00E6E7 lea r1,msgInputVarFFFFFFFFFFFFD5E4 BE0049EA bra ERROR ; "What?" it isn't?FFFFFFFFFFFFD5E8 IP7:FFFFFFFFFFFFD5E8 02150009 mov r10,r1 ; put away the variable's addressFFFFFFFFFFFFD5EC 40828000 lb r5,[r8] ; get ready for 'PRTSTG' by null terminatingFFFFFFFFFFFFD5F0 60800000 sb r0,[r8]FFFFFFFFFFFFD5F4 47E08008 lw r1,8[sp] ; get back text pointerFFFFFFFFFFFFD5F8 31FFF851 call PRTSTG ; print string as promptFFFFFFFFFFFFD5FC 60828000 sb r5,[r8] ; un-null terminateFFFFFFFFFFFFD600 IP3FFFFFFFFFFFFD600 67E40008 sw r8,8[sp] ; save in case of errorFFFFFFFFFFFFD604 46009090 lw r1,CURRNTFFFFFFFFFFFFD608 67E08010 sw r1,16[sp] ; also save 'CURRNT'FFFFFFFFFFFFD60C E07FFFFF setlo r1,#-1FFFFFFFFFFFFD610 66009090 sw r1,CURRNT ; flag that we are in INPUTFFFFFFFFFFFFD614 660F10A0 sw sp,STKINP ; save the stack pointer tooFFFFFFFFFFFFD618 67E50018 sw r10,24[sp] ; save the variable addressFFFFFFFFFFFFD61C E040003A setlo r1,#':' ; print a colon firstFFFFFFFFFFFFD620 31FFF7D8 call GETLN ; then get an input lineFFFFFFFFFFFFD624 9A04111B lea r8,BUFFER ; point to the bufferFFFFFFFFFFFFD628 31FFF63A call OREXPR ; evaluate the inputFFFFFFFFFFFFD62C 47E50018 lw r10,24[sp] ; restore the variable addressFFFFFFFFFFFFD630 66A08000 sw r1,[r10] ; save value in variableFFFFFFFFFFFFD634 47E08010 lw r1,16[sp] ; restore old 'CURRNT'FFFFFFFFFFFFD638 66009090 sw r1,CURRNTFFFFFFFFFFFFD63C 47E40008 lw r8,8[sp] ; and the old text pointerFFFFFFFFFFFFD640 IP4:FFFFFFFFFFFFD640 E0C0002C setlo r3,#','FFFFFFFFFFFFD644 9A025650 lea r4,IP5 ; is the next thing a comma?FFFFFFFFFFFFD648 31FFF8F1 call TSTCFFFFFFFFFFFFD64C BE007B2A bra IP6 ; yes, more itemsFFFFFFFFFFFFD650 IP5:FFFFFFFFFFFFD650 47E28020 lw r5,32[sp]FFFFFFFFFFFFD654 09EF0028 add sp,sp,#40 ; clean up the stackFFFFFFFFFFFFD658 33FFF504 jmp FINISHFFFFFFFFFFFFD65C DEFLT:FFFFFFFFFFFFD65C 40808000 lb r1,[r8]FFFFFFFFFFFFD660 B01F6C0D beq r1,#CR,FINISH ; empty line is OK else it is 'LET';******************************************************************; 'LET' is followed by a list of items separated by commas.; Each item consists of a variable, an equals sign, and an; expression. The interpreter evaluates the expression and sets; the variable to that value. The interpreter will also handle; 'LET' commands without the word 'LET'. This is done by 'DEFLT'.;******************************************************************;FFFFFFFFFFFFD664 LET:FFFFFFFFFFFFD664 31FFF798 call SETVAL ; do the assignmentFFFFFFFFFFFFD668 E0C0002C setlo r3,#','FFFFFFFFFFFFD66C 9A025410 lea r4,FINISHFFFFFFFFFFFFD670 31FFF8F1 call TSTC ; check for more 'LET' itemsFFFFFFFFFFFFD674 BE007F8A bra LETFFFFFFFFFFFFD678 LT1:FFFFFFFFFFFFD678 BE006CCA bra FINISH ; until we are finished.;******************************************************************; *** LOAD *** & SAVE ***;; These two commands transfer a program to/from an auxiliary; device such as a cassette, another computer, etc. The program; is converted to an easily-stored format: each line starts with; a colon, the line no. as 4 hex digits, and the rest of the line.; At the end, a line starting with an '@' sign is sent. This; format can be read back with a minimum of processing time by; the Butterfly.;******************************************************************;FFFFFFFFFFFFD67C LOADFFFFFFFFFFFFD67C 46044E60 lw r8,TXTBGN ; set pointer to start of prog. areaFFFFFFFFFFFFD680 E040000D setlo r1,#CR ; For a CP/M host, tell it we're ready...FFFFFFFFFFFFD684 31FFF395 call GOAUXO ; by sending a CR to finish PIP command.FFFFFFFFFFFFD688 LOD1:FFFFFFFFFFFFD688 31FFF396 call GOAUXI ; look for start of lineFFFFFFFFFFFFD68C BE107FE2 ble r1,r0,LOD1FFFFFFFFFFFFD690 B0100E40 beq r1,#'@',LODEND ; end of program?FFFFFFFFFFFFD694 B0100D1A beq r1,#0x1A,LODEND ; or EOF markerFFFFFFFFFFFFD698 B21FFC3A bne r1,#':',LOD1 ; if not, is it start of line? if not, wait for itFFFFFFFFFFFFD69C 31FFF5B4 call GCHAR ; get line numberFFFFFFFFFFFFD6A0 60808000 sb r1,[r8] ; store itFFFFFFFFFFFFD6A4 06109001 shrui r1,r1,#8FFFFFFFFFFFFD6A8 60808001 sb r1,1[r8]FFFFFFFFFFFFD6AC 0A840002 addui r8,r8,#2FFFFFFFFFFFFD6B0 LOD2:FFFFFFFFFFFFD6B0 31FFF396 call GOAUXI ; get another text char.FFFFFFFFFFFFD6B4 BE107FE2 ble r1,r0,LOD2FFFFFFFFFFFFD6B8 60808000 sb r1,[r8]FFFFFFFFFFFFD6BC 0A840001 addui r8,r8,#1 ; store itFFFFFFFFFFFFD6C0 B21FFC0D bne r1,#CR,LOD2 ; is it the end of the line? if not, go back for moreFFFFFFFFFFFFD6C4 BE007E2A bra LOD1 ; if so, start a new lineFFFFFFFFFFFFD6C8 LODEND:FFFFFFFFFFFFD6C8 660410D0 sw r8,TXTUNF ; set end-of program pointerFFFFFFFFFFFFD6CC BE00416A bra WSTART ; back to direct mode; get character from input (16 bit value)FFFFFFFFFFFFD6D0 GCHAR:FFFFFFFFFFFFD6D0 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFD6D4 67E28000 sw r5,[sp]FFFFFFFFFFFFD6D8 67E30008 sw r6,8[sp]FFFFFFFFFFFFD6DC 67EF8010 sw lr,16[sp]FFFFFFFFFFFFD6E0 E1800003 setlo r6,#3 ; repeat four timesFFFFFFFFFFFFD6E4 E1400000 setlo r5,#0FFFFFFFFFFFFD6E8 GCHAR1:FFFFFFFFFFFFD6E8 31FFF396 call GOAUXI ; get a charFFFFFFFFFFFFD6EC BE107FE2 ble r1,r0,GCHAR1FFFFFFFFFFFFD6F0 31FFF5C5 call asciiToHexFFFFFFFFFFFFD6F4 06528800 shli r5,r5,#4FFFFFFFFFFFFD6F8 04509409 or r5,r5,r1FFFFFFFFFFFFD6FC BE037F6F loop r6,GCHAR1FFFFFFFFFFFFD700 02508009 mov r1,r5FFFFFFFFFFFFD704 47EF8010 lw lr,16[sp]FFFFFFFFFFFFD708 47E30008 lw r6,8[sp]FFFFFFFFFFFFD70C 47E28000 lw r5,[sp]FFFFFFFFFFFFD710 37EF8018 ret #24; convert an ascii char to hex code; input; r1 = char to convertFFFFFFFFFFFFD714 asciiToHex:FFFFFFFFFFFFD714 A4100239 blei r1,#'9',a2h1 ; less than '9'FFFFFFFFFFFFD718 0E108007 subui r1,r1,#7 ; shift 'A' to '9'+1FFFFFFFFFFFFD71C a2h1:FFFFFFFFFFFFD71C 0E108030 subui r1,r1,#'0' ;FFFFFFFFFFFFD720 1410800F andi r1,r1,#15 ; make sure a nybbleFFFFFFFFFFFFD724 37EF8000 retFFFFFFFFFFFFD728 SAVE:FFFFFFFFFFFFD728 46044E60 lw r8,TXTBGN ;set pointer to start of prog. areaFFFFFFFFFFFFD72C 460490D0 lw r9,TXTUNF ;set pointer to end of prog. areaFFFFFFFFFFFFD730 SAVE1:FFFFFFFFFFFFD730 31FFF5E1 call AUXOCRLF ; send out a CR & LF (CP/M likes this)FFFFFFFFFFFFD734 BE8481C5 bgeu r8,r9,SAVEND ; are we finished?FFFFFFFFFFFFD738 E040003A setlo r1,#':' ; if not, start a lineFFFFFFFFFFFFD73C 31FFF395 call GOAUXOFFFFFFFFFFFFD740 4A808000 lbu r1,[r8] ; get line numberFFFFFFFFFFFFD744 4A810001 lbu r2,1[r8]FFFFFFFFFFFFD748 06211000 shli r2,r2,#8FFFFFFFFFFFFD74C 04110409 or r1,r1,r2FFFFFFFFFFFFD750 0A840002 addui r8,r8,#2FFFFFFFFFFFFD754 31FFF5E9 call PWORD ; output line number as 4-digit hexFFFFFFFFFFFFD758 SAVE2:FFFFFFFFFFFFD758 40808000 lb r1,[r8] ; get a text char.FFFFFFFFFFFFD75C 0A840001 addui r8,r8,#1FFFFFFFFFFFFD760 B01FF40D beqi r1,#CR,SAVE1 ; is it the end of the line? if so, send CR & LF and start new lineFFFFFFFFFFFFD764 31FFF395 call GOAUXO ; send it outFFFFFFFFFFFFD768 BE007F8A bra SAVE2 ; go back for more textFFFFFFFFFFFFD76C SAVEND:FFFFFFFFFFFFD76C E0400040 setlo r1,#'@' ; send end-of-program indicatorFFFFFFFFFFFFD770 31FFF395 call GOAUXOFFFFFFFFFFFFD774 31FFF5E1 call AUXOCRLF ; followed by a CR & LFFFFFFFFFFFFFD778 E040001A setlo r1,#0x1A ; and a control-Z to end the CP/M fileFFFFFFFFFFFFD77C 31FFF395 call GOAUXOFFFFFFFFFFFFD780 BE003BCA bra WSTART ; then go do a warm start; output a CR LF sequence to auxillary output; Registers Affected; r3 = LFFFFFFFFFFFFFD784 AUXOCRLF:FFFFFFFFFFFFD784 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFD788 67EF8000 sw lr,[sp]FFFFFFFFFFFFD78C E040000D setlo r1,#CRFFFFFFFFFFFFD790 31FFF395 call GOAUXOFFFFFFFFFFFFD794 E040000A setlo r1,#LFFFFFFFFFFFFFD798 31FFF395 call GOAUXOFFFFFFFFFFFFD79C 47EF8000 lw lr,[sp]FFFFFFFFFFFFD7A0 37EF8008 ret #8; output a word in hex format; tricky because of the need to reverse the order of the charsFFFFFFFFFFFFD7A4 PWORD:FFFFFFFFFFFFD7A4 0DEF0010 sub sp,sp,#16FFFFFFFFFFFFD7A8 67EF8000 sw lr,[sp]FFFFFFFFFFFFD7AC 67E28008 sw r5,8[sp]FFFFFFFFFFFFD7B0 9A02910F lea r5,NUMWKA+15FFFFFFFFFFFFD7B4 02120009 mov r4,r1 ; r4 = valueFFFFFFFFFFFFD7B8 pword1:FFFFFFFFFFFFD7B8 02408009 mov r1,r4 ; r1 = valueFFFFFFFFFFFFD7BC 06420801 shrui r4,r4,#4 ; shift over to next nybbleFFFFFFFFFFFFD7C0 31FFF5FD call toAsciiHex ; convert LS nybble to ascii hexFFFFFFFFFFFFD7C4 60508000 sb r1,[r5] ; save in work areaFFFFFFFFFFFFD7C8 0E528001 subui r5,r5,#1FFFFFFFFFFFFD7CC 12509100 cmpui r1,r5,#NUMWKAFFFFFFFFFFFFD7D0 BE107F41 bge r1,r0,pword1FFFFFFFFFFFFD7D4 pword2:FFFFFFFFFFFFD7D4 0A528001 addui r5,r5,#1FFFFFFFFFFFFD7D8 40508000 lb r1,[r5] ; get char to outputFFFFFFFFFFFFD7DC 31FFF395 call GOAUXO ; send itFFFFFFFFFFFFD7E0 1250910F cmpui r1,r5,#NUMWKA+15FFFFFFFFFFFFD7E4 BE107F80 blt r1,r0,pword2FFFFFFFFFFFFD7E8 47E28008 lw r5,8[sp]FFFFFFFFFFFFD7EC 47EF8000 lw lr,[sp]FFFFFFFFFFFFD7F0 37EF8010 ret #16; convert nybble in r2 to ascii hex char2; r2 = character to convertFFFFFFFFFFFFD7F4 toAsciiHex:FFFFFFFFFFFFD7F4 1410800F andi r1,r1,#15 ; make sure it's a nybbleFFFFFFFFFFFFD7F8 A010020A blti r1,#10,tah1 ; > 10 ?FFFFFFFFFFFFD7FC 08108007 addi r1,r1,#7 ; bump it up to the letter 'A'FFFFFFFFFFFFD800 tah1:FFFFFFFFFFFFD800 0A108030 addui r1,r1,#'0' ; bump up to ascii '0'FFFFFFFFFFFFD804 37EF8000 ret;******************************************************************; *** POKE *** & SYSX ***;; 'POKE expr1,expr2' stores the byte from 'expr2' into the memory; address specified by 'expr1'.;; 'SYSX expr' jumps to the machine language subroutine whose; starting address is specified by 'expr'. The subroutine can use; all registers but must leave the stack the way it found it.; The subroutine returns to the interpreter by executing an RET.;******************************************************************;FFFFFFFFFFFFD808 POKE:FFFFFFFFFFFFD808 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFD80C 31FFF63A call OREXPR ; get the memory addressFFFFFFFFFFFFD810 E0C0002C setlo r3,#','FFFFFFFFFFFFD814 9A025834 lea r4,PKER ; it must be followed by a commaFFFFFFFFFFFFD818 31FFF8F1 call TSTC ; it must be followed by a commaFFFFFFFFFFFFD81C 67E08000 sw r1,[sp] ; save the addressFFFFFFFFFFFFD820 31FFF63A call OREXPR ; get the byte to be POKE'dFFFFFFFFFFFFD824 47E10000 lw r2,[sp] ; get the address backFFFFFFFFFFFFD828 60208000 sb r1,[r2] ; store the byte in memoryFFFFFFFFFFFFD82C 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFD830 BE005F0A bra FINISHFFFFFFFFFFFFD834 PKER:FFFFFFFFFFFFD834 9A00E680 lea r1,msgCommaFFFFFFFFFFFFD838 BE00374A bra ERROR ; if no comma, say "What?"FFFFFFFFFFFFD83C POKEC:FFFFFFFFFFFFD83C 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFD840 31FFF63A call OREXPR ; get the memory addressFFFFFFFFFFFFD844 E0C0002C setlo r3,#','FFFFFFFFFFFFD848 9A025834 lea r4,PKER ; it must be followed by a commaFFFFFFFFFFFFD84C 31FFF8F1 call TSTC ; it must be followed by a commaFFFFFFFFFFFFD850 67E08000 sw r1,[sp] ; save the addressFFFFFFFFFFFFD854 31FFF63A call OREXPR ; get the byte to be POKE'dFFFFFFFFFFFFD858 47E10000 lw r2,[sp] ; get the address backFFFFFFFFFFFFD85C 62208000 sc r1,[r2] ; store the char in memoryFFFFFFFFFFFFD860 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFD864 33FFF504 jmp FINISHFFFFFFFFFFFFD868 POKEH:FFFFFFFFFFFFD868 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFD86C 31FFF63A call OREXPR ; get the memory addressFFFFFFFFFFFFD870 E0C0002C setlo r3,#','FFFFFFFFFFFFD874 9A025834 lea r4,PKER ; it must be followed by a commaFFFFFFFFFFFFD878 31FFF8F1 call TSTCFFFFFFFFFFFFD87C 67E08000 sw r1,[sp] ; save the addressFFFFFFFFFFFFD880 31FFF63A call OREXPR ; get the byte to be POKE'dFFFFFFFFFFFFD884 47E10000 lw r2,[sp] ; get the address backFFFFFFFFFFFFD888 64208000 sh r1,[r2] ; store the word in memoryFFFFFFFFFFFFD88C 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFD890 33FFF504 jmp FINISHFFFFFFFFFFFFD894 POKEW:FFFFFFFFFFFFD894 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFD898 31FFF63A call OREXPR ; get the memory addressFFFFFFFFFFFFD89C E0C0002C setlo r3,#','FFFFFFFFFFFFD8A0 9A025834 lea r4,PKER ; it must be followed by a commaFFFFFFFFFFFFD8A4 31FFF8F1 call TSTCFFFFFFFFFFFFD8A8 67E08000 sw r1,[sp] ; save the addressFFFFFFFFFFFFD8AC 31FFF63A call OREXPR ; get the word to be POKE'dFFFFFFFFFFFFD8B0 47E10000 lw r2,[sp] ; get the address backFFFFFFFFFFFFD8B4 66208000 sw r1,[r2] ; store the word in memoryFFFFFFFFFFFFD8B8 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFD8BC 33FFF504 jmp FINISHFFFFFFFFFFFFD8C0 SYSX:FFFFFFFFFFFFD8C0 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFD8C4 31FFF63A call OREXPR ; get the subroutine's addressFFFFFFFFFFFFD8C8 BE100069 bne r1,r0,sysx1 ; make sure we got a valid addressFFFFFFFFFFFFD8CC 9A00E6D5 lea r1,msgSYSBadFFFFFFFFFFFFD8D0 BE00328A bra ERRORFFFFFFFFFFFFD8D4 sysx1:FFFFFFFFFFFFD8D4 67E40000 sw r8,[sp] ; save the text pointerFFFFFFFFFFFFD8D8 341F8000 jal r31,[r1] ; jump to the subroutineFFFFFFFFFFFFD8DC 47E40000 lw r8,[sp] ; restore the text pointerFFFFFFFFFFFFD8E0 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFD8E4 BE00596A bra FINISH;******************************************************************; *** EXPR ***;; 'EXPR' evaluates arithmetical or logical expressions.; <OREXPR>::= <ANDEXPR> OR <ANDEXPR> ...; <ANDEXPR>::=<EXPR> AND <EXPR> ...; <EXPR>::=<EXPR2>; <EXPR2><rel.op.><EXPR2>; where <rel.op.> is one of the operators in TAB8 and the result; of these operations is 1 if true and 0 if false.; <EXPR2>::=(+ or -)<EXPR3>(+ or -)<EXPR3>(...; where () are optional and (... are optional repeats.; <EXPR3>::=<EXPR4>( <* or /><EXPR4> )(...; <EXPR4>::=<variable>; <function>; (<EXPR>); <EXPR> is recursive so that the variable '@' can have an <EXPR>; as an index, functions can have an <EXPR> as arguments, and; <EXPR4> can be an <EXPR> in parenthesis.;; <OREXPR>::=<ANDEXPR> OR <ANDEXPR> ...;FFFFFFFFFFFFD8E8 OREXPR:FFFFFFFFFFFFD8E8 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFD8EC 67EF8000 sw lr,[sp]FFFFFFFFFFFFD8F0 31FFF648 call ANDEXPR ; get first <ANDEXPR>FFFFFFFFFFFFD8F4 XP_OR1:FFFFFFFFFFFFD8F4 67E08004 sw r1,4[sp] ; save <ANDEXPR> valueFFFFFFFFFFFFD8F8 9A04D079 lea r9,TAB10 ; look up a logical operatorFFFFFFFFFFFFD8FC 9A055200 lea r10,TAB10_1FFFFFFFFFFFFD900 33FFF486 jmp EXEC ; go do itFFFFFFFFFFFFD904 XP_OR:FFFFFFFFFFFFD904 31FFF648 call ANDEXPRFFFFFFFFFFFFD908 47E10008 lw r2,8[sp]FFFFFFFFFFFFD90C 04110409 or r1,r1,r2FFFFFFFFFFFFD910 BE007F2A bra XP_OR1FFFFFFFFFFFFD914 XP_ORX:FFFFFFFFFFFFD914 47E08008 lw r1,8[sp]FFFFFFFFFFFFD918 47EF8000 lw lr,[sp]FFFFFFFFFFFFD91C 37EF8010 ret #16; <ANDEXPR>::=<EXPR> AND <EXPR> ...;FFFFFFFFFFFFD920 ANDEXPR:FFFFFFFFFFFFD920 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFD924 67EF8000 sw lr,[sp]FFFFFFFFFFFFD928 31FFF66D call EXPR ; get first <EXPR>FFFFFFFFFFFFD92C XP_AND1:FFFFFFFFFFFFD92C 67E08008 sw r1,8[sp] ; save <EXPR> valueFFFFFFFFFFFFD930 9A04D075 lea r9,TAB9 ; look up a logical operatorFFFFFFFFFFFFD934 9A0551F0 lea r10,TAB9_1FFFFFFFFFFFFD938 33FFF486 jmp EXEC ; go do itFFFFFFFFFFFFD93C XP_AND:FFFFFFFFFFFFD93C 31FFF66D call EXPRFFFFFFFFFFFFD940 47E10008 lw r2,8[sp]FFFFFFFFFFFFD944 04110408 and r1,r1,r2FFFFFFFFFFFFD948 BE007F2A bra XP_AND1FFFFFFFFFFFFD94C XP_ANDX:FFFFFFFFFFFFD94C 47E08008 lw r1,8[sp]FFFFFFFFFFFFD950 47EF8000 lw lr,[sp]FFFFFFFFFFFFD954 37EF8010 ret #16; Determine if the character is a digit; Parameters; r1 = char to test; Returns; r1 = 1 if digit, otherwise 0;FFFFFFFFFFFFD958 isDigit:FFFFFFFFFFFFD958 A0100430 blt r1,#'0',isDigitFalseFFFFFFFFFFFFD95C A6100339 bgt r1,#'9',isDigitFalseFFFFFFFFFFFFD960 E0400001 setlo r1,#1FFFFFFFFFFFFD964 37EF8000 retFFFFFFFFFFFFD968 isDigitFalse:FFFFFFFFFFFFD968 E0400000 setlo r1,#0FFFFFFFFFFFFD96C 37EF8000 ret; Determine if the character is a alphabetic; Parameters; r1 = char to test; Returns; r1 = 1 if alpha, otherwise 0;FFFFFFFFFFFFD970 isAlpha:FFFFFFFFFFFFD970 A0100641 blt r1,#'A',isAlphaFalseFFFFFFFFFFFFD974 A410035A ble r1,#'Z',isAlphaTrueFFFFFFFFFFFFD978 A0100461 blt r1,#'a',isAlphaFalseFFFFFFFFFFFFD97C A610037A bgt r1,#'z',isAlphaFalseFFFFFFFFFFFFD980 isAlphaTrue:FFFFFFFFFFFFD980 E0400001 setlo r1,#1FFFFFFFFFFFFD984 37EF8000 retFFFFFFFFFFFFD988 isAlphaFalse:FFFFFFFFFFFFD988 E0400000 setlo r1,#0FFFFFFFFFFFFD98C 37EF8000 ret; Determine if the character is a alphanumeric; Parameters; r1 = char to test; Returns; r1 = 1 if alpha, otherwise 0;FFFFFFFFFFFFD990 isAlnum:FFFFFFFFFFFFD990 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFD994 67EF8000 sw lr,[sp]FFFFFFFFFFFFD998 04100809 or r2,r1,r0 ; save test charFFFFFFFFFFFFD99C 31FFF656 call isDigitFFFFFFFFFFFFD9A0 BE100069 bne r1,r0,isDigitx ; if it is a digitFFFFFFFFFFFFD9A4 04200409 or r1,r2,r0 ; get back test charFFFFFFFFFFFFD9A8 31FFF65C call isAlphaFFFFFFFFFFFFD9AC isDigitx:FFFFFFFFFFFFD9AC 47EF8000 lw lr,[sp]FFFFFFFFFFFFD9B0 37EF8008 ret #8FFFFFFFFFFFFD9B4 EXPR:FFFFFFFFFFFFD9B4 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFD9B8 67EF8000 sw lr,[sp]FFFFFFFFFFFFD9BC 31FFF69C call EXPR2FFFFFFFFFFFFD9C0 67E08008 sw r1,8[sp] ; save <EXPR2> valueFFFFFFFFFFFFD9C4 9A04D06B lea r9,TAB8 ; look up a relational operatorFFFFFFFFFFFFD9C8 9A0551B8 lea r10,TAB8_1FFFFFFFFFFFFD9CC 33FFF486 jmp EXEC ; go do itFFFFFFFFFFFFD9D0 XP11:FFFFFFFFFFFFD9D0 47E08008 lw r1,8[sp]FFFFFFFFFFFFD9D4 31FFF695 call XP18 ; is it ">="?FFFFFFFFFFFFD9D8 BE208321 bge r2,r1,XPRT1 ; no, return r2=1FFFFFFFFFFFFD9DC BE0002AA bra XPRT0 ; else return r2=0FFFFFFFFFFFFD9E0 XP12:FFFFFFFFFFFFD9E0 47E08008 lw r1,8[sp]FFFFFFFFFFFFD9E4 31FFF695 call XP18 ; is it "<>"?FFFFFFFFFFFFD9E8 BE2082A9 bne r2,r1,XPRT1 ; no, return r2=1FFFFFFFFFFFFD9EC BE00022A bra XPRT0 ; else return r2=0FFFFFFFFFFFFD9F0 XP13:FFFFFFFFFFFFD9F0 47E08008 lw r1,8[sp]FFFFFFFFFFFFD9F4 31FFF695 call XP18 ; is it ">"?FFFFFFFFFFFFD9F8 BE208223 bgt r2,r1,XPRT1 ; no, return r2=1FFFFFFFFFFFFD9FC BE0001AA bra XPRT0 ; else return r2=0FFFFFFFFFFFFDA00 XP14:FFFFFFFFFFFFDA00 47E08008 lw r1,8[sp]FFFFFFFFFFFFDA04 31FFF695 call XP18 ; is it "<="?FFFFFFFFFFFFDA08 BE2081A2 ble r2,r1,XPRT1 ; no, return r2=1FFFFFFFFFFFFDA0C BE00012A bra XPRT0 ; else return r2=0FFFFFFFFFFFFDA10 XP15:FFFFFFFFFFFFDA10 47E08008 lw r1,8[sp]FFFFFFFFFFFFDA14 31FFF695 call XP18 ; is it "="?FFFFFFFFFFFFDA18 BE208128 beq r2,r1,XPRT1 ; if not, return r2=1FFFFFFFFFFFFDA1C BE0000AA bra XPRT0 ; else return r2=0FFFFFFFFFFFFDA20 XP16:FFFFFFFFFFFFDA20 47E08008 lw r1,8[sp]FFFFFFFFFFFFDA24 31FFF695 call XP18 ; is it "<"?FFFFFFFFFFFFDA28 BE2080A0 blt r2,r1,XPRT1 ; if not, return r2=1FFFFFFFFFFFFDA2C BE00002A bra XPRT0 ; else return r2=0FFFFFFFFFFFFDA30 XPRT0:FFFFFFFFFFFFDA30 47EF8000 lw lr,[sp]FFFFFFFFFFFFDA34 E0400000 setlo r1,#0 ; return r1=0 (false)FFFFFFFFFFFFDA38 37EF8010 ret #16FFFFFFFFFFFFDA3C XPRT1:FFFFFFFFFFFFDA3C 47EF8000 lw lr,[sp]FFFFFFFFFFFFDA40 E0400001 setlo r1,#1 ; return r1=1 (true)FFFFFFFFFFFFDA44 37EF8010 ret #16FFFFFFFFFFFFDA48 XP17: ; it's not a rel. operatorFFFFFFFFFFFFDA48 47E08008 lw r1,8[sp] ; return r2=<EXPR2>FFFFFFFFFFFFDA4C 47EF8000 lw lr,[sp]FFFFFFFFFFFFDA50 37EF8010 ret #16FFFFFFFFFFFFDA54 XP18:FFFFFFFFFFFFDA54 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFDA58 67EF8000 sw lr,[sp]FFFFFFFFFFFFDA5C 67E08008 sw r1,8[sp]FFFFFFFFFFFFDA60 31FFF69C call EXPR2 ; do a second <EXPR2>FFFFFFFFFFFFDA64 47E10008 lw r2,8[sp]FFFFFFFFFFFFDA68 47EF8000 lw lr,[sp]FFFFFFFFFFFFDA6C 37EF8010 ret #16; <EXPR2>::=(+ or -)<EXPR3>(+ or -)<EXPR3>(...FFFFFFFFFFFFDA70 EXPR2:FFFFFFFFFFFFDA70 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFDA74 67EF8000 sw lr,[sp]FFFFFFFFFFFFDA78 E0C0002D setlo r3,#'-'FFFFFFFFFFFFDA7C 9A025A90 lea r4,XP21FFFFFFFFFFFFDA80 31FFF8F1 call TSTC ; negative sign?FFFFFFFFFFFFDA84 E0400000 setlo r1,#0 ; yes, fake '0-'FFFFFFFFFFFFDA88 67E00008 sw r0,8[sp]FFFFFFFFFFFFDA8C BE00020A bra XP26FFFFFFFFFFFFDA90 XP21:FFFFFFFFFFFFDA90 E0C0002B setlo r3,#'+'FFFFFFFFFFFFDA94 9A025A9C lea r4,XP22FFFFFFFFFFFFDA98 31FFF8F1 call TSTC ; positive sign? ignore itFFFFFFFFFFFFDA9C XP22:FFFFFFFFFFFFDA9C 31FFF6B9 call EXPR3 ; first <EXPR3>FFFFFFFFFFFFDAA0 XP23:FFFFFFFFFFFFDAA0 67E08008 sw r1,8[sp] ; yes, save the valueFFFFFFFFFFFFDAA4 E0C0002B setlo r3,#'+'FFFFFFFFFFFFDAA8 9A025AC0 lea r4,XP25FFFFFFFFFFFFDAAC 31FFF8F1 call TSTC ; add?FFFFFFFFFFFFDAB0 31FFF6B9 call EXPR3 ; get the second <EXPR3>FFFFFFFFFFFFDAB4 XP24:FFFFFFFFFFFFDAB4 47E10008 lw r2,8[sp]FFFFFFFFFFFFDAB8 04110402 add r1,r1,r2 ; add it to the first <EXPR3>; BVS.L QHOW brnch if there's an overflowFFFFFFFFFFFFDABC BE007F2A bra XP23 ; else go back for more operationsFFFFFFFFFFFFDAC0 XP25:FFFFFFFFFFFFDAC0 E0C0002D setlo r3,#'-'FFFFFFFFFFFFDAC4 9A025AD8 lea r4,XP45FFFFFFFFFFFFDAC8 31FFF8F1 call TSTC ; subtract?FFFFFFFFFFFFDACC XP26:FFFFFFFFFFFFDACC 31FFF6B9 call EXPR3 ; get second <EXPR3>FFFFFFFFFFFFDAD0 02108006 neg r1,r1 ; change its signFFFFFFFFFFFFDAD4 BE007F0A bra XP24 ; and do an additionFFFFFFFFFFFFDAD8 XP45:FFFFFFFFFFFFDAD8 47E08008 lw r1,8[sp]FFFFFFFFFFFFDADC 47EF8000 lw lr,[sp]FFFFFFFFFFFFDAE0 37EF8010 ret #16; <EXPR3>::=<EXPR4>( <* or /><EXPR4> )(...FFFFFFFFFFFFDAE4 EXPR3:FFFFFFFFFFFFDAE4 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFDAE8 67EF8000 sw lr,[sp]FFFFFFFFFFFFDAEC 31FFF6CF call EXPR4 ; get first <EXPR4>FFFFFFFFFFFFDAF0 XP31:FFFFFFFFFFFFDAF0 67E08008 sw r1,8[sp] ; yes, save that first resultFFFFFFFFFFFFDAF4 E0C0002A setlo r3,#'*'FFFFFFFFFFFFDAF8 9A025B10 lea r4,XP34FFFFFFFFFFFFDAFC 31FFF8F1 call TSTC ; multiply?FFFFFFFFFFFFDB00 31FFF6CF call EXPR4 ; get second <EXPR4>FFFFFFFFFFFFDB04 47E10008 lw r2,8[sp]FFFFFFFFFFFFDB08 04110419 muls r1,r1,r2 ; multiply the twoFFFFFFFFFFFFDB0C BE007F2A bra XP31 ; then look for more termsFFFFFFFFFFFFDB10 XP34:FFFFFFFFFFFFDB10 E0C0002F setlo r3,#'/'FFFFFFFFFFFFDB14 9A025B30 lea r4,XP47FFFFFFFFFFFFDB18 31FFF8F1 call TSTC ; divide?FFFFFFFFFFFFDB1C 31FFF6CF call EXPR4 ; get second <EXPR4>FFFFFFFFFFFFDB20 04100809 or r2,r1,r0FFFFFFFFFFFFDB24 47E08008 lw r1,8[sp]FFFFFFFFFFFFDB28 0411041B divs r1,r1,r2 ; do the divisionFFFFFFFFFFFFDB2C BE007E2A bra XP31 ; go back for any more termsFFFFFFFFFFFFDB30 XP47:FFFFFFFFFFFFDB30 47E08008 lw r1,8[sp]FFFFFFFFFFFFDB34 47EF8000 lw lr,[sp]FFFFFFFFFFFFDB38 37EF8010 ret #16; Functions are called through EXPR4; <EXPR4>::=<variable>; <function>; (<EXPR>)FFFFFFFFFFFFDB3C EXPR4:FFFFFFFFFFFFDB3C 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFDB40 67EF8000 sw lr,[sp]FFFFFFFFFFFFDB44 9A04D042 lea r9,TAB4 ; find possible functionFFFFFFFFFFFFDB48 9A055150 lea r10,TAB4_1FFFFFFFFFFFFDB4C 33FFF486 jmp EXEC ; branch to function which does subsequent ret for EXPR4FFFFFFFFFFFFDB50 XP40: ; we get here if it wasn't a functionFFFFFFFFFFFFDB50 E0400000 setlo r1,#0FFFFFFFFFFFFDB54 31FFF6EC call TSTVFFFFFFFFFFFFDB58 BE100088 beq r1,r0,XP41 ; nor a variableFFFFFFFFFFFFDB5C 46108000 lw r1,[r1] ; if a variable, return its value in r1FFFFFFFFFFFFDB60 47EF8000 lw lr,[sp]FFFFFFFFFFFFDB64 37EF8018 ret #24FFFFFFFFFFFFDB68 XP41:FFFFFFFFFFFFDB68 31FFF8FF call TSTNUM ; or is it a number?FFFFFFFFFFFFDB6C BE200049 bne r2,r0,XP46 ; (if not, # of digits will be zero) if so, return it in r1FFFFFFFFFFFFDB70 31FFF6DF call PARN ; check for (EXPR)FFFFFFFFFFFFDB74 XP46:FFFFFFFFFFFFDB74 47EF8000 lw lr,[sp]FFFFFFFFFFFFDB78 37EF8018 ret #24; Check for a parenthesized expressionFFFFFFFFFFFFDB7C PARN:FFFFFFFFFFFFDB7C 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFDB80 67EF8000 sw lr,[sp]FFFFFFFFFFFFDB84 E0C00028 setlo r3,#'('FFFFFFFFFFFFDB88 9A025BA8 lea r4,XP43FFFFFFFFFFFFDB8C 31FFF8F1 call TSTC ; else look for ( OREXPR )FFFFFFFFFFFFDB90 31FFF63A call OREXPRFFFFFFFFFFFFDB94 E0C00029 setlo r3,#')'FFFFFFFFFFFFDB98 9A025BA8 lea r4,XP43FFFFFFFFFFFFDB9C 31FFF8F1 call TSTCFFFFFFFFFFFFDBA0 XP42:FFFFFFFFFFFFDBA0 47EF8000 lw lr,[sp]FFFFFFFFFFFFDBA4 37EF8008 ret #8FFFFFFFFFFFFDBA8 XP43:FFFFFFFFFFFFDBA8 9A00E5FD lea r1,msgWhatFFFFFFFFFFFFDBAC BE001BAA bra ERROR; ===== Test for a valid variable name. Returns Z=1 if not; found, else returns Z=0 and the address of the; variable in r1.; Parameters; r1 = 1 = allocate if not found; Returns; r1 = address of variable, zero if not foundFFFFFFFFFFFFDBB0 TSTV:FFFFFFFFFFFFDBB0 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFDBB4 67EF8000 sw lr,[sp]FFFFFFFFFFFFDBB8 67E28008 sw r5,8[sp]FFFFFFFFFFFFDBBC 04101409 or r5,r1,r0 ; allocate flagFFFFFFFFFFFFDBC0 31FFF914 call IGNBLKFFFFFFFFFFFFDBC4 4A808000 lbu r1,[r8] ; look at the program textFFFFFFFFFFFFDBC8 A0101740 blt r1,#'@',tstv_notfound ; C=1: not a variableFFFFFFFFFFFFDBCC B2100F40 bne r1,#'@',TV1 ; brnch if not "@" arrayFFFFFFFFFFFFDBD0 0A840001 addui r8,r8,#1 ; If it is, it should beFFFFFFFFFFFFDBD4 31FFF6DF call PARN ; followed by (EXPR) as its index.FFFFFFFFFFFFDBD8 06108600 shli r1,r1,#3; BCS.L QHOW say "How?" if index is too bigFFFFFFFFFFFFDBDC 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFDBE0 67E08008 sw r1,8[sp] ; save the indexFFFFFFFFFFFFDBE4 67EF8000 sw lr,[sp]FFFFFFFFFFFFDBE8 31FFF793 call SIZEX ; get amount of free memoryFFFFFFFFFFFFDBEC 47EF8000 lw lr,[sp]FFFFFFFFFFFFDBF0 47E10008 lw r2,8[sp] ; get back the indexFFFFFFFFFFFFDBF4 BE208044 bltu r2,r1,TV2 ; see if there's enough memoryFFFFFFFFFFFFDBF8 33FFF7C5 jmp QSORRY ; if not, say "Sorry"FFFFFFFFFFFFDBFC TV2:FFFFFFFFFFFFDBFC 9A0090D8 lea r1,VARBGN ; put address of array element...FFFFFFFFFFFFDC00 04110405 subu r1,r1,r2 ; into r1 (neg. offset is used)FFFFFFFFFFFFDC04 BE0000AA bra TSTVRTFFFFFFFFFFFFDC08 TV1:FFFFFFFFFFFFDC08 31FFF70D call getVarName ; get variable nameFFFFFFFFFFFFDC0C BE100068 beq r1,r0,TSTVRT ; if not, return r1=0FFFFFFFFFFFFDC10 02510009 mov r2,r5FFFFFFFFFFFFDC14 31FFF733 call findVar ; find or allocateFFFFFFFFFFFFDC18 TSTVRT:FFFFFFFFFFFFDC18 47E28008 lw r5,8[sp]FFFFFFFFFFFFDC1C 47EF8000 lw lr,[sp]FFFFFFFFFFFFDC20 37EF8018 ret #24 ; r1<>0 (found)FFFFFFFFFFFFDC24 tstv_notfound:FFFFFFFFFFFFDC24 47E28008 lw r5,8[sp]FFFFFFFFFFFFDC28 47EF8000 lw lr,[sp]FFFFFFFFFFFFDC2C E0400000 setlo r1,#0 ; r1=0 if not foundFFFFFFFFFFFFDC30 37EF8018 ret #24; Returns; r1 = 6 character variable name + type;FFFFFFFFFFFFDC34 getVarName:FFFFFFFFFFFFDC34 0FEF0018 subui sp,sp,#24FFFFFFFFFFFFDC38 67EF8000 sw lr,[sp]FFFFFFFFFFFFDC3C 67E28010 sw r5,16[sp]FFFFFFFFFFFFDC40 40808000 lb r1,[r8] ; get first characterFFFFFFFFFFFFDC44 67E08008 sw r1,8[sp] ; save off current nameFFFFFFFFFFFFDC48 31FFF65C call isAlphaFFFFFFFFFFFFDC4C BE100388 beq r1,r0,gvn1FFFFFFFFFFFFDC50 E1400005 setlo r5,#5 ; loop six more times; check for second/third characterFFFFFFFFFFFFDC54 gvn4:FFFFFFFFFFFFDC54 0A840001 addui r8,r8,#1FFFFFFFFFFFFDC58 40808000 lb r1,[r8] ; do we have another char ?FFFFFFFFFFFFDC5C 31FFF664 call isAlnumFFFFFFFFFFFFDC60 BE100168 beq r1,r0,gvn2 ; nopeFFFFFFFFFFFFDC64 47E08008 lw r1,8[sp] ; get varnameFFFFFFFFFFFFDC68 06109000 shli r1,r1,#8FFFFFFFFFFFFDC6C 40810000 lb r2,[r8]FFFFFFFFFFFFDC70 04110409 or r1,r1,r2 ; add in new charFFFFFFFFFFFFDC74 67E08008 sw r1,8[sp] ; save off name againFFFFFFFFFFFFDC78 BE02FEEF loop r5,gvn4; now ignore extra variable name charactersFFFFFFFFFFFFDC7C gvn6:FFFFFFFFFFFFDC7C 0A840001 addui r8,r8,#1FFFFFFFFFFFFDC80 40808000 lb r1,[r8]FFFFFFFFFFFFDC84 31FFF664 call isAlnumFFFFFFFFFFFFDC88 BE107FA9 bne r1,r0,gvn6 ; keep looping as long as we have identifier chars; check for a variable typeFFFFFFFFFFFFDC8C gvn2:FFFFFFFFFFFFDC8C 40808000 lb r1,[r8]FFFFFFFFFFFFDC90 B0100425 beq r1,#'%',gvn3FFFFFFFFFFFFDC94 B0100324 beq r1,#'$',gvn3FFFFFFFFFFFFDC98 E0400000 setlo r1,#0FFFFFFFFFFFFDC9C 0E840001 subui r8,r8,#1; insert variable type indicator and returnFFFFFFFFFFFFDCA0 gvn3:FFFFFFFFFFFFDCA0 0A840001 addui r8,r8,#1FFFFFFFFFFFFDCA4 47E10008 lw r2,8[sp]FFFFFFFFFFFFDCA8 06211000 shli r2,r2,#8FFFFFFFFFFFFDCAC 04110409 or r1,r1,r2 ; add in variable typeFFFFFFFFFFFFDCB0 47EF8000 lw lr,[sp]FFFFFFFFFFFFDCB4 47E28010 lw r5,16[sp]FFFFFFFFFFFFDCB8 37EF8018 ret #24 ; return Z = 0, r1 = varname; not a variable nameFFFFFFFFFFFFDCBC gvn1:FFFFFFFFFFFFDCBC 47EF8000 lw lr,[sp]FFFFFFFFFFFFDCC0 47E28010 lw r5,16[sp]FFFFFFFFFFFFDCC4 E0400000 setlo r1,#0 ; return Z = 1 if not a varnameFFFFFFFFFFFFDCC8 37EF8018 ret #24; Find variable; r1 = varname; r2 = allocate flag; Returns; r1 = variable address, Z =0 if found / allocated, Z=1 if not foundFFFFFFFFFFFFDCCC findVar:FFFFFFFFFFFFDCCC 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFDCD0 67EF8000 sw lr,[sp]FFFFFFFFFFFFDCD4 67E38008 sw r7,8[sp]FFFFFFFFFFFFDCD8 460190D8 lw r3,VARBGNFFFFFFFFFFFFDCDC fv4:FFFFFFFFFFFFDCDC 46338000 lw r7,[r3] ; get varname / typeFFFFFFFFFFFFDCE0 BE700108 beq r7,r0,fv3 ; no more vars ?FFFFFFFFFFFFDCE4 BE138128 beq r1,r7,fv1 ; match ?FFFFFFFFFFFFDCE8 08318008 add r3,r3,#8 ; move to next varFFFFFFFFFFFFDCEC 460390F8 lw r7,STKBOTFFFFFFFFFFFFDCF0 BE33FF60 blt r3,r7,fv4 ; loop back to look at next var; variable not found; no more memoryFFFFFFFFFFFFDCF4 E07FE650 setlo r1,#<msgVarSpaceFFFFFFFFFFFFDCF8 F04FFFFF sethi r1,#>msgVarSpaceFFFFFFFFFFFFDCFC BE00112A bra ERROR; lw lr,[sp]; lw r7,4[sp]; add sp,sp,#8; lw r1,#0; ret; variable not found; allocate new ?FFFFFFFFFFFFDD00 fv3:FFFFFFFFFFFFDD00 BE2000C8 beq r2,r0,fv2FFFFFFFFFFFFDD04 66308000 sw r1,[r3] ; save varname / type; found variable; return addressFFFFFFFFFFFFDD08 fv1:FFFFFFFFFFFFDD08 0A308008 addui r1,r3,#8FFFFFFFFFFFFDD0C 47EF8000 lw lr,[sp]FFFFFFFFFFFFDD10 47E38008 lw r7,8[sp]FFFFFFFFFFFFDD14 37EF8010 ret #16 ; Z = 0, r1 = address; didn't find var and not allocatingFFFFFFFFFFFFDD18 fv2:FFFFFFFFFFFFDD18 47EF8000 lw lr,[sp]FFFFFFFFFFFFDD1C 47E38008 lw r7,8[sp]FFFFFFFFFFFFDD20 0BEF0010 addui sp,sp,#16 ; Z = 0, r1 = addressFFFFFFFFFFFFDD24 E0400000 setlo r1,#0 ; Z = 1, r1 = 0FFFFFFFFFFFFDD28 37EF8000 ret; ===== Multiplies the 32 bit values in r1 and r2, returning; the 32 bit result in r1.;; ===== Divide the 32 bit value in r2 by the 32 bit value in r3.; Returns the 32 bit quotient in r1, remainder in r2;; r2 = a; r3 = b; r6 = remainder; r7 = iteration count; r8 = sign;; q = a / b; a = r1; b = r2; q = r2; ===== The PEEK function returns the byte stored at the address; contained in the following expression.;FFFFFFFFFFFFDD2C PEEK:FFFFFFFFFFFFDD2C 31FFF6DF call PARN ; get the memory addressFFFFFFFFFFFFDD30 4A108000 lbu r1,[r1] ; get the addressed byteFFFFFFFFFFFFDD34 47EF8000 lw lr,[sp] ; and return itFFFFFFFFFFFFDD38 37EF8018 ret #24; ===== The PEEK function returns the byte stored at the address; contained in the following expression.;FFFFFFFFFFFFDD3C PEEKC:FFFFFFFFFFFFDD3C 31FFF6DF call PARN ; get the memory addressFFFFFFFFFFFFDD40 1410FFFE andi r1,r1,#-2 ; align to char addressFFFFFFFFFFFFDD44 4C108000 lcu r1,[r1] ; get the addressed charFFFFFFFFFFFFDD48 47EF8000 lw lr,[sp] ; and return itFFFFFFFFFFFFDD4C 37EF8018 ret #24; ===== The PEEK function returns the byte stored at the address; contained in the following expression.;FFFFFFFFFFFFDD50 PEEKH:FFFFFFFFFFFFDD50 31FFF6DF call PARN ; get the memory addressFFFFFFFFFFFFDD54 1410FFFC andi r1,r1,#-4 ; align to half-word addressFFFFFFFFFFFFDD58 4E108000 lhu r1,[r1] ; get the addressed charFFFFFFFFFFFFDD5C 47EF8000 lw lr,[sp] ; and return itFFFFFFFFFFFFDD60 37EF8018 ret #24; ===== The PEEK function returns the byte stored at the address; contained in the following expression.;FFFFFFFFFFFFDD64 PEEKW:FFFFFFFFFFFFDD64 31FFF6DF call PARN ; get the memory addressFFFFFFFFFFFFDD68 1410FFF8 andi r1,r1,#-8 ; align to word addressFFFFFFFFFFFFDD6C 46108000 lw r1,[r1] ; get the addressed wordFFFFFFFFFFFFDD70 47EF8000 lw lr,[sp] ; and return itFFFFFFFFFFFFDD74 37EF8018 ret #24; user function call; call the user function with argument in r1FFFFFFFFFFFFDD78 USRX:FFFFFFFFFFFFDD78 31FFF6DF call PARN ; get expression valueFFFFFFFFFFFFDD7C 67E40008 sw r8,8[sp] ; save the text pointerFFFFFFFFFFFFDD80 46011028 lw r2,usrJmp ; get usr vectorFFFFFFFFFFFFDD84 342F8000 jal r31,[r2] ; jump to the subroutineFFFFFFFFFFFFDD88 47E40008 lw r8,8[sp] ; restore the text pointerFFFFFFFFFFFFDD8C 47EF8000 lw lr,[sp]FFFFFFFFFFFFDD90 37EF8018 ret #24; ===== The RND function returns a random number from 1 to; the value of the following expression in D0.;FFFFFFFFFFFFDD94 RND:FFFFFFFFFFFFDD94 31FFF6DF call PARN ; get the upper limitFFFFFFFFFFFFDD98 BE100168 beq r1,r0,rnd2 ; it must be positive and non-zeroFFFFFFFFFFFFDD9C BE100100 blt r1,r0,rnd1FFFFFFFFFFFFDDA0 04100809 lw r2,r1FFFFFFFFFFFFDDA4 00000050 gran ; generate a random numberFFFFFFFFFFFFDDA8 020088A8 mfspr r1,rand ; get the numberFFFFFFFFFFFFDDAC 31FFF775 call modu4 ; RND(n)=MOD(number,n)+1FFFFFFFFFFFFDDB0 0A108001 addui r1,r1,#1FFFFFFFFFFFFDDB4 47EF8000 lw lr,[sp]FFFFFFFFFFFFDDB8 37EF8018 ret #24FFFFFFFFFFFFDDBC rnd1:FFFFFFFFFFFFDDBC 9A00E6C1 lea r1,msgRNDBadFFFFFFFFFFFFDDC0 BE000B0A bra ERRORFFFFFFFFFFFFDDC4 rnd2:FFFFFFFFFFFFDDC4 00000050 granFFFFFFFFFFFFDDC8 020088A8 mfspr r1,randFFFFFFFFFFFFDDCC 47EF8000 lw lr,[sp]FFFFFFFFFFFFDDD0 37EF8018 ret #24; r = a mod b; a = r1; b = r2; r = r6FFFFFFFFFFFFDDD4 modu4:FFFFFFFFFFFFDDD4 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFDDD8 67E18000 sw r3,[sp]FFFFFFFFFFFFDDDC 67E28008 sw r5,8[sp]FFFFFFFFFFFFDDE0 67E30010 sw r6,16[sp]FFFFFFFFFFFFDDE4 67E38018 sw r7,24[sp]FFFFFFFFFFFFDDE8 1603803F lw r7,#63 ; n = 64FFFFFFFFFFFFDDEC 0452940A xor r5,r5,r5 ; w = 0FFFFFFFFFFFFDDF0 0463180A xor r6,r6,r6 ; r = 0FFFFFFFFFFFFDDF4 mod2:FFFFFFFFFFFFDDF4 06108202 roli r1,r1,#1 ; a <<= 1FFFFFFFFFFFFDDF8 14118001 andi r3,r1,#1FFFFFFFFFFFFDDFC 06630200 shli r6,r6,#1 ; r <<= 1FFFFFFFFFFFFDE00 04619809 or r6,r6,r3FFFFFFFFFFFFDE04 1410FFFE andi r1,r1,#-2FFFFFFFFFFFFDE08 BE230047 bgtu r2,r6,mod1 ; b < r ?FFFFFFFFFFFFDE0C 04611805 subu r6,r6,r2 ; r -= bFFFFFFFFFFFFDE10 mod1:FFFFFFFFFFFFDE10 BE03FF2F loop r7,mod2 ; n--FFFFFFFFFFFFDE14 02608009 mov r1,r6FFFFFFFFFFFFDE18 47E18000 lw r3,[sp]FFFFFFFFFFFFDE1C 47E28008 lw r5,8[sp]FFFFFFFFFFFFDE20 47E30010 lw r6,16[sp]FFFFFFFFFFFFDE24 47E38018 lw r7,24[sp]FFFFFFFFFFFFDE28 37EF8020 ret #32; ===== The ABS function returns an absolute value in r2.;FFFFFFFFFFFFDE2C ABS:FFFFFFFFFFFFDE2C 31FFF6DF call PARN ; get the following expr.'s valueFFFFFFFFFFFFDE30 02108007 abs r1,r1FFFFFFFFFFFFDE34 47EF8000 lw lr,[sp]FFFFFFFFFFFFDE38 37EF8018 ret #24; ===== The SGN function returns the sign in r1. +1,0, or -1;FFFFFFFFFFFFDE3C SGN:FFFFFFFFFFFFDE3C 31FFF6DF call PARN ; get the following expr.'s valueFFFFFFFFFFFFDE40 02108008 sgn r1,r1FFFFFFFFFFFFDE44 47EF8000 lw lr,[sp]FFFFFFFFFFFFDE48 37EF8018 ret #24; ===== The SIZE function returns the size of free memory in r1.;FFFFFFFFFFFFDE4C SIZEX:FFFFFFFFFFFFDE4C 460090D8 lw r1,VARBGN ; get the number of free bytes...FFFFFFFFFFFFDE50 460110D0 lw r2,TXTUNF ; between 'TXTUNF' and 'VARBGN'FFFFFFFFFFFFDE54 04110405 subu r1,r1,r2FFFFFFFFFFFFDE58 47EF8000 lw lr,[sp]FFFFFFFFFFFFDE5C 37EF8018 ret #24 ; return the number in r2;******************************************************************;; *** SETVAL *** FIN *** ENDCHK *** ERROR (& friends) ***;; 'SETVAL' expects a variable, followed by an equal sign and then; an expression. It evaluates the expression and sets the variable; to that value.;; 'FIN' checks the end of a command. If it ended with ":",; execution continues. If it ended with a CR, it finds the; the next line and continues from there.;; 'ENDCHK' checks if a command is ended with a CR. This is; required in certain commands, such as GOTO, RETURN, STOP, etc.;; 'ERROR' prints the string pointed to by r1. It then prints the; line pointed to by CURRNT with a "?" inserted at where the; old text pointer (should be on top of the stack) points to.; Execution of Tiny BASIC is stopped and a warm start is done.; If CURRNT is zero (indicating a direct command), the direct; command is not printed. If CURRNT is -1 (indicating; 'INPUT' command in progress), the input line is not printed; and execution is not terminated but continues at 'INPERR'.;; Related to 'ERROR' are the following:; 'QWHAT' saves text pointer on stack and gets "What?" message.; 'AWHAT' just gets the "What?" message and jumps to 'ERROR'.; 'QSORRY' and 'ASORRY' do the same kind of thing.; 'QHOW' and 'AHOW' also do this for "How?".;; returns; r2 = variable's address;FFFFFFFFFFFFDE60 SETVAL:FFFFFFFFFFFFDE60 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFDE64 67EF8000 sw lr,[sp]FFFFFFFFFFFFDE68 E0400001 setlo r1,#1 ; allocate varFFFFFFFFFFFFDE6C 31FFF6EC call TSTV ; variable name?FFFFFFFFFFFFDE70 BE100069 bne r1,r0,sv2FFFFFFFFFFFFDE74 9A00E6AA lea r1,msgVarFFFFFFFFFFFFDE78 BE00054A bra ERRORFFFFFFFFFFFFDE7C sv2:FFFFFFFFFFFFDE7C 67E08008 sw r1,8[sp] ; save the variable's addressFFFFFFFFFFFFDE80 E0C0003D setlo r3,#'='FFFFFFFFFFFFDE84 9A025EA4 lea r4,SV1FFFFFFFFFFFFDE88 31FFF8F1 call TSTC ; get past the "=" signFFFFFFFFFFFFDE8C 31FFF63A call OREXPR ; evaluate the expressionFFFFFFFFFFFFDE90 47E10008 lw r2,8[sp] ; get back the variable's addressFFFFFFFFFFFFDE94 66208000 sw r1,[r2] ; and save value in the variableFFFFFFFFFFFFDE98 04200409 lw r1,r2 ; return r1 = variable addressFFFFFFFFFFFFDE9C 47EF8000 lw lr,[sp]FFFFFFFFFFFFDEA0 37EF8010 ret #16FFFFFFFFFFFFDEA4 SV1:FFFFFFFFFFFFDEA4 BE0003CA bra QWHAT ; if no "=" signFFFFFFFFFFFFDEA8 FIN:FFFFFFFFFFFFDEA8 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFDEAC 67EF8000 sw lr,[sp]FFFFFFFFFFFFDEB0 E0C0003A setlo r3,#':'FFFFFFFFFFFFDEB4 9A025EC4 lea r4,FI1FFFFFFFFFFFFDEB8 31FFF8F1 call TSTC ; *** FIN ***FFFFFFFFFFFFDEBC 0BEF0008 addui sp,sp,#8 ; if ":", discard return addressFFFFFFFFFFFFDEC0 BE0020AA bra RUNSML ; continue on the same lineFFFFFFFFFFFFDEC4 FI1:FFFFFFFFFFFFDEC4 E0C0000D setlo r3,#CRFFFFFFFFFFFFDEC8 9A025EDC lea r4,FI2FFFFFFFFFFFFDECC 31FFF8F1 call TSTC ; not ":", is it a CR?FFFFFFFFFFFFDED0 47EF8000 lw lr,[sp] ; else return to the callerFFFFFFFFFFFFDED4 0BEF0008 addui sp,sp,#8 ; yes, purge return addressFFFFFFFFFFFFDED8 BE001EAA bra RUNNXL ; execute the next lineFFFFFFFFFFFFDEDC FI2:FFFFFFFFFFFFDEDC 47EF8000 lw lr,[sp] ; else return to the callerFFFFFFFFFFFFDEE0 37EF8008 ret #8; Check that there is nothing else on the line; Registers Affected; r1;FFFFFFFFFFFFDEE4 ENDCHK:FFFFFFFFFFFFDEE4 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFDEE8 67EF8000 sw lr,[sp]FFFFFFFFFFFFDEEC 31FFF914 call IGNBLKFFFFFFFFFFFFDEF0 40808000 lb r1,[r8]FFFFFFFFFFFFDEF4 B010040D beq r1,#CR,ec1 ; does it end with a CR?FFFFFFFFFFFFDEF8 E07FE784 setlo r1,#<msgExtraCharsFFFFFFFFFFFFDEFC F04FFFFF sethi r1,#>msgExtraCharsFFFFFFFFFFFFDF00 33FFF7C8 jmp ERRORFFFFFFFFFFFFDF04 ec1:FFFFFFFFFFFFDF04 47EF8000 lw lr,[sp]FFFFFFFFFFFFDF08 37EF8008 ret #8FFFFFFFFFFFFDF0C TOOBIG:FFFFFFFFFFFFDF0C 9A00E76F lea r1,msgTooBigFFFFFFFFFFFFDF10 BE00008A bra ERRORFFFFFFFFFFFFDF14 QSORRY:FFFFFFFFFFFFDF14 9A00E605 lea r1,SRYMSGFFFFFFFFFFFFDF18 BE00004A bra ERRORFFFFFFFFFFFFDF1C QWHAT:FFFFFFFFFFFFDF1C 9A00E5FD lea r1,msgWhatFFFFFFFFFFFFDF20 ERROR:FFFFFFFFFFFFDF20 31FFF940 call PRMESG ; display the error messageFFFFFFFFFFFFDF24 46009090 lw r1,CURRNT ; get the current line numberFFFFFFFFFFFFDF28 BE107E88 beq r1,r0,WSTART ; if zero, do a warm startFFFFFFFFFFFFDF2C B01D9AFF beq r1,#-1,INPERR ; is the line no. pointer = -1? if so, redo inputFFFFFFFFFFFFDF30 40828000 lb r5,[r8] ; save the char. pointed toFFFFFFFFFFFFDF34 60800000 sb r0,[r8] ; put a zero where the error isFFFFFFFFFFFFDF38 46009090 lw r1,CURRNT ; point to start of current lineFFFFFFFFFFFFDF3C 31FFF8DF call PRTLN ; display the line in error up to the 0FFFFFFFFFFFFDF40 04101809 or r6,r1,r0 ; save off end pointerFFFFFFFFFFFFDF44 60828000 sb r5,[r8] ; restore the characterFFFFFFFFFFFFDF48 E040003F setlo r1,#'?' ; display a "?"FFFFFFFFFFFFDF4C 31FFF393 call GOOUTFFFFFFFFFFFFDF50 E0800000 setlo r2,#0 ; stop char = 0FFFFFFFFFFFFDF54 0E608001 subui r1,r6,#1 ; point back to the error char.FFFFFFFFFFFFDF58 31FFF851 call PRTSTG ; display the rest of the lineFFFFFFFFFFFFDF5C 33FFF3BE jmp WSTART ; and do a warm start;******************************************************************;; *** GETLN *** FNDLN (& friends) ***;; 'GETLN' reads in input line into 'BUFFER'. It first prompts with; the character in r3 (given by the caller), then it fills the; buffer and echos. It ignores LF's but still echos; them back. Control-H is used to delete the last character; entered (if there is one), and control-X is used to delete the; whole line and start over again. CR signals the end of a line,; and causes 'GETLN' to return.;;FFFFFFFFFFFFDF60 GETLN:FFFFFFFFFFFFDF60 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFDF64 67EF8000 sw lr,[sp]FFFFFFFFFFFFDF68 67E28008 sw r5,8[sp]FFFFFFFFFFFFDF6C 31FFF393 call GOOUT ; display the promptFFFFFFFFFFFFDF70 E0400001 setlo r1,#1 ; turn on cursor flashFFFFFFFFFFFFDF74 60009046 sb r1,cursFlashFFFFFFFFFFFFDF78 E0400020 setlo r1,#' ' ; and a spaceFFFFFFFFFFFFDF7C 31FFF393 call GOOUTFFFFFFFFFFFFDF80 E200111B setlo r8,#<BUFFER ; r8 is the buffer pointerFFFFFFFFFFFFDF84 F2000000 sethi r8,#>BUFFERFFFFFFFFFFFFDF88 GL1:FFFFFFFFFFFFDF88 31FFF936 call CHKIO ; check keyboardFFFFFFFFFFFFDF8C BE107FE8 beq r1,r0,GL1 ; wait for a char. to come inFFFFFFFFFFFFDF90 B0100B08 beq r1,#CTRLH,GL3 ; delete last character? if soFFFFFFFFFFFFDF94 B0101418 beq r1,#CTRLX,GL4 ; delete the whole line?FFFFFFFFFFFFDF98 B010020D beq r1,#CR,GL2 ; accept a CRFFFFFFFFFFFFDF9C A81FFB20 bltu r1,#' ',GL1 ; if other control char., discard itFFFFFFFFFFFFDFA0 GL2:FFFFFFFFFFFFDFA0 60808000 sb r1,[r8] ; save the char.FFFFFFFFFFFFDFA4 08840001 add r8,r8,#1FFFFFFFFFFFFDFA8 31FFF393 call GOOUT ; echo the char back outFFFFFFFFFFFFDFAC 4080FFFF lb r1,-1[r8] ; get char back (GOOUT destroys r1)FFFFFFFFFFFFDFB0 B010190D beq r1,#CR,GL7 ; if it's a CR, end the lineFFFFFFFFFFFFDFB4 1280916A cmpui r1,r8,#BUFFER+BUFLEN-1 ; any more room?FFFFFFFFFFFFDFB8 BE107E80 blt r1,r0,GL1 ; yes: get some more, else delete last char.FFFFFFFFFFFFDFBC GL3:FFFFFFFFFFFFDFBC E0400008 setlo r1,#CTRLH ; delete a char. if possibleFFFFFFFFFFFFDFC0 31FFF393 call GOOUTFFFFFFFFFFFFDFC4 E0400020 setlo r1,#' 'FFFFFFFFFFFFDFC8 31FFF393 call GOOUTFFFFFFFFFFFFDFCC 1280911B cmpui r1,r8,#BUFFER ; any char.'s left?FFFFFFFFFFFFDFD0 BE107DC2 ble r1,r0,GL1 ; if notFFFFFFFFFFFFDFD4 E0400008 setlo r1,#CTRLH ; if so, finish the BS-space-BS sequenceFFFFFFFFFFFFDFD8 31FFF393 call GOOUTFFFFFFFFFFFFDFDC 0C840001 sub r8,r8,#1 ; decrement the text pointerFFFFFFFFFFFFDFE0 BE007D4A bra GL1 ; back for moreFFFFFFFFFFFFDFE4 GL4:FFFFFFFFFFFFDFE4 04800409 or r1,r8,r0 ; delete the whole lineFFFFFFFFFFFFDFE8 0E12911B subui r5,r1,#BUFFER ; figure out how many backspaces we needFFFFFFFFFFFFDFEC BE500108 beq r5,r0,GL6 ; if none needed, brnchFFFFFFFFFFFFDFF0 GL5:FFFFFFFFFFFFDFF0 E0400008 setlo r1,#CTRLH ; and display BS-space-BS sequencesFFFFFFFFFFFFDFF4 31FFF393 call GOOUTFFFFFFFFFFFFDFF8 E0400020 setlo r1,#' 'FFFFFFFFFFFFDFFC 31FFF393 call GOOUTFFFFFFFFFFFFE000 E0400008 setlo r1,#CTRLHFFFFFFFFFFFFE004 31FFF393 call GOOUTFFFFFFFFFFFFE008 BE02FF4F loop r5,GL5FFFFFFFFFFFFE00C GL6:FFFFFFFFFFFFE00C 9A04111B lea r8,BUFFER ; reinitialize the text pointerFFFFFFFFFFFFE010 BE007BCA bra GL1 ; and go back for moreFFFFFFFFFFFFE014 GL7:FFFFFFFFFFFFE014 E0400000 setlo r1,#0 ; turn off cursor flashFFFFFFFFFFFFE018 60009046 sb r1,cursFlashFFFFFFFFFFFFE01C E040000A setlo r1,#LF ; echo a LF for the CRFFFFFFFFFFFFE020 31FFF393 call GOOUTFFFFFFFFFFFFE024 47EF8000 lw lr,[sp]FFFFFFFFFFFFE028 47E28008 lw r5,8[sp]FFFFFFFFFFFFE02C 37EF8010 ret #16; 'FNDLN' finds a line with a given line no. (in r1) in the; text save area. r9 is used as the text pointer. If the line; is found, r9 will point to the beginning of that line; (i.e. the high byte of the line no.), and flags are Z.; If that line is not there and a line with a higher line no.; is found, r9 points there and flags are NC & NZ. If we reached; the end of the text save area and cannot find the line, flags; are C & NZ.; Z=1 if line found; N=1 if end of text save area; Z=0 & N=0 if higher line found; r0 = 1 <= line is found; r9 = pointer to line; r0 = 0 <= line is not found; r9 = zero, if end of text area; r9 = otherwise higher line number;; 'FNDLN' will initialize r9 to the beginning of the text save; area to start the search. Some other entries of this routine; will not initialize r9 and do the search.; 'FNDLNP' will start with r9 and search for the line no.; 'FNDNXT' will bump r9 by 2, find a CR and then start search.; 'FNDSKP' uses r9 to find a CR, and then starts the search.; return Z=1 if line is found, r9 = pointer to line;; Parameters; r1 = line number to find;FFFFFFFFFFFFE030 FNDLN:FFFFFFFFFFFFE030 AC1003FF bleui r1,#0xFFFF,fl1 ; line no. must be < 65535FFFFFFFFFFFFE034 9A00E694 lea r1,msgLineRangeFFFFFFFFFFFFE038 BE00774A bra ERRORFFFFFFFFFFFFE03C fl1:FFFFFFFFFFFFE03C 4604CE60 lw r9,TXTBGN ; init. the text save pointerFFFFFFFFFFFFE040 FNDLNP:FFFFFFFFFFFFE040 460510D0 lw r10,TXTUNF ; check if we passed the endFFFFFFFFFFFFE044 0EA50001 subui r10,r10,#1FFFFFFFFFFFFE048 BE950127 bgtu r9,r10,FNDRET1 ; if so, return with r9=0,r1=0FFFFFFFFFFFFE04C 4A918000 lbu r3,[r9] ; get low order byte of line numberFFFFFFFFFFFFE050 4A910001 lbu r2,1[r9] ; get high order byteFFFFFFFFFFFFE054 06211000 shli r2,r2,#8FFFFFFFFFFFFE058 04218809 or r2,r2,r3 ; build whole line numberFFFFFFFFFFFFE05C BE110127 bgtu r1,r2,FNDNXT ; is this the line we want? no, not there yetFFFFFFFFFFFFE060 BE1100C8 beq r1,r2,FNDRET2FFFFFFFFFFFFE064 FNDRET:FFFFFFFFFFFFE064 0410840A xor r1,r1,r1 ; line not found, but r9=next line pointerFFFFFFFFFFFFE068 37EF8000 ret ; return the cond. codesFFFFFFFFFFFFE06C FNDRET1:FFFFFFFFFFFFE06C 0494A40A xor r9,r9,r9 ; no higher lineFFFFFFFFFFFFE070 0410840A xor r1,r1,r1 ; line not foundFFFFFFFFFFFFE074 37EF8000 retFFFFFFFFFFFFE078 FNDRET2:FFFFFFFFFFFFE078 E0400001 setlo r1,#1 ; line foundFFFFFFFFFFFFE07C 37EF8000 retFFFFFFFFFFFFE080 FNDNXT:FFFFFFFFFFFFE080 0A948002 addui r9,r9,#2 ; find the next lineFFFFFFFFFFFFE084 FNDSKP:FFFFFFFFFFFFE084 4A910000 lbu r2,[r9]FFFFFFFFFFFFE088 0A948001 addui r9,r9,#1FFFFFFFFFFFFE08C B22FFE0D bnei r2,#CR,FNDSKP ; try to find a CR, keep lookingFFFFFFFFFFFFE090 BE007D8A bra FNDLNP ; check if end of text;******************************************************************; 'MVUP' moves a block up from where r1 points to where r2 points; until r1=r3;FFFFFFFFFFFFE094 MVUP1:FFFFFFFFFFFFE094 40120000 lb r4,[r1]FFFFFFFFFFFFE098 60220000 sb r4,[r2]FFFFFFFFFFFFE09C 08108001 add r1,r1,#1FFFFFFFFFFFFE0A0 08210001 add r2,r2,#1FFFFFFFFFFFFE0A4 MVUP:FFFFFFFFFFFFE0A4 BE11FF89 bne r1,r3,MVUP1FFFFFFFFFFFFE0A8 MVRET:FFFFFFFFFFFFE0A8 37EF8000 ret; 'MVDOWN' moves a block down from where r1 points to where r2; points until r1=r3;FFFFFFFFFFFFE0AC MVDOWN1:FFFFFFFFFFFFE0AC 0C108001 sub r1,r1,#1FFFFFFFFFFFFE0B0 0C210001 sub r2,r2,#1FFFFFFFFFFFFE0B4 40120000 lb r4,[r1]FFFFFFFFFFFFE0B8 60220000 sb r4,[r2]FFFFFFFFFFFFE0BC MVDOWN:FFFFFFFFFFFFE0BC BE11FF89 bne r1,r3,MVDOWN1FFFFFFFFFFFFE0C0 37EF8000 ret; 'POPA' restores the 'FOR' loop variable save area from the stack;; 'PUSHA' stacks for 'FOR' loop variable save area onto the stack;; Note: a single zero word is stored on the stack in the; case that no FOR loops need to be saved. This needs to be; done because PUSHA / POPA is called all the time.FFFFFFFFFFFFE0C4 POPA:FFFFFFFFFFFFE0C4 47E08000 lw r1,[sp] ; restore LOPVAR, but zero means no moreFFFFFFFFFFFFE0C8 660090A8 sw r1,LOPVARFFFFFFFFFFFFE0CC BE100148 beq r1,r0,PP1FFFFFFFFFFFFE0D0 47E08020 lw r1,32[sp] ; if not zero, restore the restFFFFFFFFFFFFE0D4 660090C8 sw r1,LOPPTFFFFFFFFFFFFE0D8 47E08018 lw r1,24[sp]FFFFFFFFFFFFE0DC 660090C0 sw r1,LOPLNFFFFFFFFFFFFE0E0 47E08010 lw r1,16[sp]FFFFFFFFFFFFE0E4 660090B8 sw r1,LOPLMTFFFFFFFFFFFFE0E8 47E08008 lw r1,8[sp]FFFFFFFFFFFFE0EC 660090B0 sw r1,LOPINCFFFFFFFFFFFFE0F0 37EF8028 ret #40FFFFFFFFFFFFE0F4 PP1:FFFFFFFFFFFFE0F4 37EF8008 ret #8FFFFFFFFFFFFE0F8 PUSHA:FFFFFFFFFFFFE0F8 460090F8 lw r1,STKBOT ; Are we running out of stack room?FFFFFFFFFFFFE0FC 0A108028 addui r1,r1,#40 ; we might need this many bytesFFFFFFFFFFFFE100 BFE0F0A4 bltu sp,r1,QSORRY ; out of stack spaceFFFFFFFFFFFFE104 460090A8 lw r1,LOPVAR ; save loop variablesFFFFFFFFFFFFE108 BE100188 beq r1,r0,PU1 ; if LOPVAR is zero, that's allFFFFFFFFFFFFE10C 0FEF0028 subui sp,sp,#40FFFFFFFFFFFFE110 67E08000 sw r1,[sp]FFFFFFFFFFFFE114 460090C8 lw r1,LOPPTFFFFFFFFFFFFE118 67E08020 sw r1,32[sp] ; else save all the othersFFFFFFFFFFFFE11C 460090C0 lw r1,LOPLNFFFFFFFFFFFFE120 67E08018 sw r1,24[sp]FFFFFFFFFFFFE124 460090B8 lw r1,LOPLMTFFFFFFFFFFFFE128 67E08010 sw r1,16[sp]FFFFFFFFFFFFE12C 460090B0 lw r1,LOPINCFFFFFFFFFFFFE130 67E08008 sw r1,8[sp]FFFFFFFFFFFFE134 37EF8000 retFFFFFFFFFFFFE138 PU1:FFFFFFFFFFFFE138 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFE13C 67E08000 sw r1,[sp]FFFFFFFFFFFFE140 37EF8000 ret;******************************************************************;; *** PRTSTG *** QTSTG *** PRTNUM *** PRTLN ***;; 'PRTSTG' prints a string pointed to by r3. It stops printing; and returns to the caller when either a CR is printed or when; the next byte is the same as what was passed in r4 by the; caller.;; 'QTSTG' looks for an underline (back-arrow on some systems),; single-quote, or double-quote. If none of these are found, returns; to the caller. If underline, outputs a CR without a LF. If single; or double quote, prints the quoted string and demands a matching; end quote. After the printing, the next i-word of the caller is; skipped over (usually a branch instruction).;; 'PRTNUM' prints the 32 bit number in r3, leading blanks are added if; needed to pad the number of spaces to the number in r4.; However, if the number of digits is larger than the no. in; r4, all digits are printed anyway. Negative sign is also; printed and counted in, positive sign is not.;; 'PRTLN' prints the saved text line pointed to by r3; with line no. and all.;; r1 = pointer to string; r2 = stop character; return r1 = pointer to end of line + 1FFFFFFFFFFFFE144 PRTSTG:FFFFFFFFFFFFE144 0DEF0020 sub sp,sp,#32FFFFFFFFFFFFE148 67E28000 sw r5,[sp]FFFFFFFFFFFFE14C 67E28008 sw r5,8[sp]FFFFFFFFFFFFE150 67E38010 sw r7,16[sp]FFFFFFFFFFFFE154 67EF8018 sw lr,24[sp]FFFFFFFFFFFFE158 02128009 mov r5,r1 ; r5 = pointerFFFFFFFFFFFFE15C 02230009 mov r6,r2 ; r6 = stop charFFFFFFFFFFFFE160 PS1:FFFFFFFFFFFFE160 4A538000 lbu r7,[r5] ; get a text characterFFFFFFFFFFFFE164 0A528001 addui r5,r5,#1FFFFFFFFFFFFE168 BE7300C8 beq r7,r6,PRTRET ; same as stop character? if so, returnFFFFFFFFFFFFE16C 02708009 mov r1,r7FFFFFFFFFFFFE170 31FFF393 call GOOUT ; display the char.FFFFFFFFFFFFE174 B27FFB0D bnei r7,#CR,PS1 ; is it a C.R.? no, go back for moreFFFFFFFFFFFFE178 E040000A setlo r1,#LF ; yes, add a L.F.FFFFFFFFFFFFE17C 31FFF393 call GOOUTFFFFFFFFFFFFE180 PRTRET:FFFFFFFFFFFFE180 02710009 mov r2,r7 ; return r2 = stop charFFFFFFFFFFFFE184 02508009 mov r1,r5 ; return r1 = line pointerFFFFFFFFFFFFE188 47EF8018 lw lr,24[sp]FFFFFFFFFFFFE18C 47E38010 lw r7,16[sp]FFFFFFFFFFFFE190 47E28008 lw r5,8[sp]FFFFFFFFFFFFE194 47E28000 lw r5,[sp]FFFFFFFFFFFFE198 37EF8020 ret #32 ; then returnFFFFFFFFFFFFE19C QTSTG:FFFFFFFFFFFFE19C 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFE1A0 67EF8000 sw lr,[sp]FFFFFFFFFFFFE1A4 E0C00022 setlo r3,#'"'FFFFFFFFFFFFE1A8 E13FE1D0 setlo r4,#<QT3FFFFFFFFFFFFE1AC F10FFFFF sethi r4,#>QT3FFFFFFFFFFFFE1B0 31FFF8F1 call TSTC ; *** QTSTG ***FFFFFFFFFFFFE1B4 E0800022 setlo r2,#'"' ; it is a "FFFFFFFFFFFFE1B8 QT1:FFFFFFFFFFFFE1B8 04800409 or r1,r8,r0FFFFFFFFFFFFE1BC 31FFF851 call PRTSTG ; print until anotherFFFFFFFFFFFFE1C0 04102009 lw r8,r1FFFFFFFFFFFFE1C4 B2200F0A bne r2,#LF,QT2 ; was last one a CR?FFFFFFFFFFFFE1C8 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFE1CC BE00070A bra RUNNXL ; if so, run next lineFFFFFFFFFFFFE1D0 QT3:FFFFFFFFFFFFE1D0 E0C00027 setlo r3,#''''FFFFFFFFFFFFE1D4 E13FE1E8 setlo r4,#<QT4FFFFFFFFFFFFE1D8 F10FFFFF sethi r4,#>QT4FFFFFFFFFFFFE1DC 31FFF8F1 call TSTC ; is it a single quote?FFFFFFFFFFFFE1E0 E0800027 setlo r2,#'''' ; if so, do same as aboveFFFFFFFFFFFFE1E4 BE007EAA bra QT1FFFFFFFFFFFFE1E8 QT4:FFFFFFFFFFFFE1E8 E0C0005F setlo r3,#'_'FFFFFFFFFFFFE1EC E13FE20C setlo r4,#<QT5FFFFFFFFFFFFE1F0 F10FFFFF sethi r4,#>QT5FFFFFFFFFFFFE1F4 31FFF8F1 call TSTC ; is it an underline?FFFFFFFFFFFFE1F8 E040000D setlo r1,#CR ; if so, output a CR without LFFFFFFFFFFFFFE1FC 31FFF393 call GOOUTFFFFFFFFFFFFE200 QT2:FFFFFFFFFFFFE200 47EF8000 lw lr,[sp]FFFFFFFFFFFFE204 0BEF0008 addui sp,sp,#8FFFFFFFFFFFFE208 35F00004 jal r0,4[lr] ; skip over next i-word when returningFFFFFFFFFFFFE20C QT5: ; not " ' or _FFFFFFFFFFFFE20C 47EF8000 lw lr,[sp]FFFFFFFFFFFFE210 37EF8008 ret #8; Output a CR LF sequence;FFFFFFFFFFFFE214 prCRLF:FFFFFFFFFFFFE214 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFE218 67EF8000 sw lr,[sp]FFFFFFFFFFFFE21C E040000D setlo r1,#CRFFFFFFFFFFFFE220 31FFF393 call GOOUTFFFFFFFFFFFFE224 E040000A setlo r1,#LFFFFFFFFFFFFFE228 31FFF393 call GOOUTFFFFFFFFFFFFE22C 47EF8000 lw lr,[sp]FFFFFFFFFFFFE230 37EF8008 ret #8; r1 = number to print; r2 = number of digits; Register Usage; r5 = number of padding spacesFFFFFFFFFFFFE234 PRTNUM:FFFFFFFFFFFFE234 0FEF0028 subui sp,sp,#40FFFFFFFFFFFFE238 67E18000 sw r3,[sp]FFFFFFFFFFFFE23C 67E28008 sw r5,8[sp]FFFFFFFFFFFFE240 67E30010 sw r6,16[sp]FFFFFFFFFFFFE244 67E38018 sw r7,24[sp]FFFFFFFFFFFFE248 67EF8020 sw lr,32[sp]FFFFFFFFFFFFE24C 16039100 ori r7,r0,#NUMWKA ; r7 = pointer to numeric work areaFFFFFFFFFFFFE250 02130009 mov r6,r1 ; save number for laterFFFFFFFFFFFFE254 02228009 mov r5,r2 ; r5 = min number of charsFFFFFFFFFFFFE258 BE100063 bgt r1,r0,PN1 ; is it negative? if notFFFFFFFFFFFFE25C 02108006 neg r1,r1 ; else make it positiveFFFFFFFFFFFFE260 0E528001 subui r5,r5,#1 ; one less for width countFFFFFFFFFFFFE264 PN1:FFFFFFFFFFFFE264 1601800A lw r3,#10FFFFFFFFFFFFE268 0411881C mod r2,r1,r3 ; r2 = r1 mod 10FFFFFFFFFFFFE26C 1C10800A divui r1,r1,#10 ; r1 /= 10 divide by 10FFFFFFFFFFFFE270 0A210030 addui r2,r2,#'0' ; convert remainder to asciiFFFFFFFFFFFFE274 60710000 sb r2,[r7] ; and store in bufferFFFFFFFFFFFFE278 0A738001 addui r7,r7,#1FFFFFFFFFFFFE27C 0E528001 subui r5,r5,#1 ; decrement widthFFFFFFFFFFFFE280 BE107F29 bne r1,r0,PN1FFFFFFFFFFFFE284 PN6:FFFFFFFFFFFFE284 BE500082 ble r5,r0,PN4 ; test pad count, skip padding if not neededFFFFFFFFFFFFE288 PN3:FFFFFFFFFFFFE288 E0400020 setlo r1,#' ' ; display the required leading spacesFFFFFFFFFFFFE28C 31FFF393 call GOOUTFFFFFFFFFFFFE290 BE02FFCF loop r5,PN3FFFFFFFFFFFFE294 PN4:FFFFFFFFFFFFE294 BE600063 bgt r6,r0,PN5 ; is number negative?FFFFFFFFFFFFE298 E040002D setlo r1,#'-' ; if so, display the signFFFFFFFFFFFFE29C 31FFF393 call GOOUTFFFFFFFFFFFFE2A0 PN5:FFFFFFFFFFFFE2A0 0E738001 subui r7,r7,#1FFFFFFFFFFFFE2A4 40708000 lb r1,[r7] ; now unstack the digits and displayFFFFFFFFFFFFE2A8 31FFF393 call GOOUTFFFFFFFFFFFFE2AC 12709100 cmpui r1,r7,#NUMWKAFFFFFFFFFFFFE2B0 BE107F87 bgtu r1,r0,PN5FFFFFFFFFFFFE2B4 PNRET:FFFFFFFFFFFFE2B4 47EF8020 lw lr,32[sp]FFFFFFFFFFFFE2B8 47E38018 lw r7,24[sp]FFFFFFFFFFFFE2BC 47E30010 lw r6,16[sp]FFFFFFFFFFFFE2C0 47E28008 lw r5,8[sp]FFFFFFFFFFFFE2C4 47E18000 lw r3,[sp]FFFFFFFFFFFFE2C8 37EF8028 ret #40; r1 = number to print; r2 = number of digitsFFFFFFFFFFFFE2CC PRTHEXNUM:FFFFFFFFFFFFE2CC 0FEF0028 subui sp,sp,#40FFFFFFFFFFFFE2D0 67E28000 sw r5,[sp]FFFFFFFFFFFFE2D4 67E30008 sw r6,8[sp]FFFFFFFFFFFFE2D8 67E38010 sw r7,16[sp]FFFFFFFFFFFFE2DC 67E40018 sw r8,24[sp]FFFFFFFFFFFFE2E0 67EF8020 sw lr,32[sp]FFFFFFFFFFFFE2E4 E1C01100 setlo r7,#<NUMWKA ; r7 = pointer to numeric work areaFFFFFFFFFFFFE2E8 F1C00000 sethi r7,#>NUMWKAFFFFFFFFFFFFE2EC 04101809 or r6,r1,r0 ; save number for laterFFFFFFFFFFFFE2F0 E1400014 setlo r5,#20 ; r5 = min number of charsFFFFFFFFFFFFE2F4 04101009 or r4,r1,r0FFFFFFFFFFFFE2F8 BE400083 bgt r4,r0,PHN1 ; is it negative? if notFFFFFFFFFFFFE2FC 02420006 neg r4,r4 ; else make it positiveFFFFFFFFFFFFE300 0C528001 sub r5,r5,#1 ; one less for width countFFFFFFFFFFFFE304 E2000014 setlo r8,#20 ; maximum of 10 digitsFFFFFFFFFFFFE308 PHN1:FFFFFFFFFFFFE308 04400409 or r1,r4,r0FFFFFFFFFFFFE30C 1410800F andi r1,r1,#15FFFFFFFFFFFFE310 A010030A blt r1,#10,PHN7FFFFFFFFFFFFE314 0A108037 addui r1,r1,#'A'-10FFFFFFFFFFFFE318 BE00004A bra PHN8FFFFFFFFFFFFE31C PHN7:FFFFFFFFFFFFE31C 08108030 add r1,r1,#'0' ; convert remainder to asciiFFFFFFFFFFFFE320 PHN8:FFFFFFFFFFFFE320 60708000 sb r1,[r7] ; and store in bufferFFFFFFFFFFFFE324 08738001 add r7,r7,#1FFFFFFFFFFFFE328 0C528001 sub r5,r5,#1 ; decrement widthFFFFFFFFFFFFE32C shru r4,r4,#4FFFFFFFFFFFFE32C BE400048 beq r4,r0,PHN6 ; is it zero yet ?FFFFFFFFFFFFE330 BE047ECF loop r8,PHN1 ; safetyFFFFFFFFFFFFE334 PHN6: ; test pad countFFFFFFFFFFFFE334 BE500082 ble r5,r0,PHN4 ; skip padding if not neededFFFFFFFFFFFFE338 PHN3:FFFFFFFFFFFFE338 E0400020 setlo r1,#' ' ; display the required leading spacesFFFFFFFFFFFFE33C 31FFF393 call GOOUTFFFFFFFFFFFFE340 BE02FFCF loop r5,PHN3FFFFFFFFFFFFE344 PHN4:FFFFFFFFFFFFE344 BE600063 bgt r6,r0,PHN5 ; is number negative?FFFFFFFFFFFFE348 E040002D setlo r1,#'-' ; if so, display the signFFFFFFFFFFFFE34C 31FFF393 call GOOUTFFFFFFFFFFFFE350 PHN5:FFFFFFFFFFFFE350 0C738001 sub r7,r7,#1FFFFFFFFFFFFE354 40708000 lb r1,[r7] ; now unstack the digits and displayFFFFFFFFFFFFE358 31FFF393 call GOOUTFFFFFFFFFFFFE35C 12709100 cmpui r1,r7,#NUMWKAFFFFFFFFFFFFE360 BE107F83 bgt r1,r0,PHN5FFFFFFFFFFFFE364 PHNRET:FFFFFFFFFFFFE364 47EF8020 lw lr,32[sp]FFFFFFFFFFFFE368 47E40018 lw r8,24[sp]FFFFFFFFFFFFE36C 47E38010 lw r7,16[sp]FFFFFFFFFFFFE370 47E30008 lw r6,8[sp]FFFFFFFFFFFFE374 47E28000 lw r5,[sp]FFFFFFFFFFFFE378 37EF8028 ret #40; r1 = pointer to line; returns r1 = pointer to end of line + 1FFFFFFFFFFFFE37C PRTLN:FFFFFFFFFFFFE37C 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFE380 67E28000 sw r5,[sp]FFFFFFFFFFFFE384 67EF8008 sw lr,8[sp]FFFFFFFFFFFFE388 08128002 addi r5,r1,#2FFFFFFFFFFFFE38C 4A50FFFE lbu r1,-2[r5] ; get the binary line numberFFFFFFFFFFFFE390 4A517FFF lbu r2,-1[r5]FFFFFFFFFFFFE394 06211000 shli r2,r2,#8FFFFFFFFFFFFE398 04110409 or r1,r1,r2FFFFFFFFFFFFE39C E0800000 setlo r2,#0 ; display a 0 or more digit line no.FFFFFFFFFFFFE3A0 31FFF88D call PRTNUMFFFFFFFFFFFFE3A4 E0400020 setlo r1,#' ' ; followed by a blankFFFFFFFFFFFFE3A8 31FFF393 call GOOUTFFFFFFFFFFFFE3AC E0800000 setlo r2,#0 ; stop char. is a zeroFFFFFFFFFFFFE3B0 04500409 or r1,r5,r0FFFFFFFFFFFFE3B4 31FFF851 call PRTSTG ; display the rest of the lineFFFFFFFFFFFFE3B8 47EF8008 lw lr,8[sp]FFFFFFFFFFFFE3BC 47E28000 lw r5,[sp]FFFFFFFFFFFFE3C0 37EF8010 ret #16; ===== Test text byte following the call to this subroutine. If it; equals the byte pointed to by r8, return to the code following; the call. If they are not equal, brnch to the point; indicated in r4.;; Registers Affected; r3,r8; Returns; r8 = updated text pointer;FFFFFFFFFFFFE3C4 TSTCFFFFFFFFFFFFE3C4 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFE3C8 67EF8000 sw lr,[sp]FFFFFFFFFFFFE3CC 67E08008 sw r1,8[sp]FFFFFFFFFFFFE3D0 31FFF914 call IGNBLK ; ignore leading blanksFFFFFFFFFFFFE3D4 40808000 lb r1,[r8]FFFFFFFFFFFFE3D8 BE3080A8 beq r3,r1,TC1 ; is it = to what r8 points to? if soFFFFFFFFFFFFE3DC 47E08008 lw r1,8[sp]FFFFFFFFFFFFE3E0 47EF8000 lw lr,[sp]FFFFFFFFFFFFE3E4 0BEF0010 addui sp,sp,#16FFFFFFFFFFFFE3E8 34400000 jal r0,[r4] ; jump to the routineFFFFFFFFFFFFE3EC TC1:FFFFFFFFFFFFE3EC 08840001 add r8,r8,#1 ; if equal, bump text pointerFFFFFFFFFFFFE3F0 47E08008 lw r1,8[sp]FFFFFFFFFFFFE3F4 47EF8000 lw lr,[sp]FFFFFFFFFFFFE3F8 37EF8010 ret #16; ===== See if the text pointed to by r8 is a number. If so,; return the number in r2 and the number of digits in r3,; else return zero in r2 and r3.; Registers Affected; r1,r2,r3,r4; Returns; r1 = number; r2 = number of digits in number; r8 = updated text pointer;FFFFFFFFFFFFE3FC TSTNUM:FFFFFFFFFFFFE3FC 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFE400 67EF8000 sw lr,[sp]FFFFFFFFFFFFE404 31FFF914 call IGNBLK ; skip over blanksFFFFFFFFFFFFE408 E0400000 setlo r1,#0 ; initialize return parametersFFFFFFFFFFFFE40C E0800000 setlo r2,#0FFFFFFFFFFFFE410 TN1:FFFFFFFFFFFFE410 40818000 lb r3,[r8]FFFFFFFFFFFFE414 A8300D30 bltui r3,#'0',TSNMRET ; is it less than zero?FFFFFFFFFFFFE418 AE300C39 bgtui r3,#'9',TSNMRET ; is it greater than nine?FFFFFFFFFFFFE41C E13FFFFF setlo r4,#0xFFFFFFFFFFFFFFFFFFFFE420 F10FFFFF sethi r4,#0x07FFFFFFFFFFFFFFFFFFE424 BE120066 bleu r1,r4,TN2 ; see if there's room for new digitFFFFFFFFFFFFE428 E07FE629 setlo r1,msgNumTooBigFFFFFFFFFFFFE42C BE0057AA bra ERROR ; if not, we've overflowdFFFFFFFFFFFFE430 TN2:FFFFFFFFFFFFE430 1A10800A mului r1,r1,#10 ; quickly multiply result by 10FFFFFFFFFFFFE434 08840001 addi r8,r8,#1 ; adjust text pointerFFFFFFFFFFFFE438 1431800F andi r3,r3,#0x0F ; add in the new digitFFFFFFFFFFFFE43C 04118402 add r1,r1,r3FFFFFFFFFFFFE440 08210001 addi r2,r2,#1 ; increment the no. of digitsFFFFFFFFFFFFE444 BE007E6A bra TN1FFFFFFFFFFFFE448 TSNMRET:FFFFFFFFFFFFE448 47EF8000 lw lr,[sp]FFFFFFFFFFFFE44C 37EF8008 ret #8;===== Skip over blanks in the text pointed to by r8.;; Registers Affected:; r8; Returns; r8 = pointer updateded past any spaces or tabs;FFFFFFFFFFFFE450 IGNBLK:FFFFFFFFFFFFE450 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFE454 67E08000 sw r1,[sp]FFFFFFFFFFFFE458 IGB2:FFFFFFFFFFFFE458 40808000 lb r1,[r8] ; get charFFFFFFFFFFFFE45C B0100220 beqi r1,#' ',IGB1 ; see if it's a spaceFFFFFFFFFFFFE460 B2100300 bnei r1,#'\t',IGBRET ; or a tabFFFFFFFFFFFFE464 IGB1:FFFFFFFFFFFFE464 08840001 add r8,r8,#1 ; increment the text pointerFFFFFFFFFFFFE468 BE007F8A bra IGB2FFFFFFFFFFFFE46C IGBRET:FFFFFFFFFFFFE46C 47E08000 lw r1,[sp]FFFFFFFFFFFFE470 37EF8008 ret #8; ===== Convert the line of text in the input buffer to upper; case (except for stuff between quotes).;; Registers Affected; r1,r3; Returns; r8 = pointing to end of text in buffer;FFFFFFFFFFFFE474 TOUPBUF:FFFFFFFFFFFFE474 0FEF0008 subui sp,sp,#8FFFFFFFFFFFFE478 67EF8000 sw lr,[sp]FFFFFFFFFFFFE47C E200111B setlo r8,BUFFER ; set up text pointerFFFFFFFFFFFFE480 E0C00000 setlo r3,#0 ; clear quote flagFFFFFFFFFFFFE484 TOUPB1:FFFFFFFFFFFFE484 40808000 lb r1,[r8] ; get the next text char.FFFFFFFFFFFFE488 08840001 add r8,r8,#1FFFFFFFFFFFFE48C B0100D0D beqi r1,#CR,TOUPBRT ; is it end of line?FFFFFFFFFFFFE490 B0100622 beqi r1,#'"',DOQUO ; a double quote?FFFFFFFFFFFFE494 B0100527 beqi r1,#'''',DOQUO ; or a single quote?FFFFFFFFFFFFE498 BE307F69 bne r3,r0,TOUPB1 ; inside quotes?FFFFFFFFFFFFE49C 31FFF932 call toUpper ; convert to upper caseFFFFFFFFFFFFE4A0 6080FFFF sb r1,-1[r8] ; store itFFFFFFFFFFFFE4A4 BE007F0A bra TOUPB1 ; and go back for moreFFFFFFFFFFFFE4A8 DOQUO:FFFFFFFFFFFFE4A8 BE300069 bne r3,r0,DOQUO1; are we inside quotes?FFFFFFFFFFFFE4AC 04100C09 or r3,r1,r0 ; if not, toggle inside-quotes flagFFFFFFFFFFFFE4B0 BE007EAA bra TOUPB1FFFFFFFFFFFFE4B4 DOQUO1:FFFFFFFFFFFFE4B4 BE30FE89 bne r3,r1,TOUPB1 ; make sure we're ending proper quoteFFFFFFFFFFFFE4B8 E0C00000 setlo r3,#0 ; else clear quote flagFFFFFFFFFFFFE4BC BE007E4A bra TOUPB1FFFFFFFFFFFFE4C0 TOUPBRT:FFFFFFFFFFFFE4C0 47EF8000 lw lr,[sp]FFFFFFFFFFFFE4C4 37EF8008 ret #8; ===== Convert the character in r1 to upper case;FFFFFFFFFFFFE4C8 toUpperFFFFFFFFFFFFE4C8 A0100361 blt r1,#'a',TOUPRET ; is it < 'a'?FFFFFFFFFFFFE4CC A610027A bgt r1,#'z',TOUPRET ; or > 'z'?FFFFFFFFFFFFE4D0 0C108020 sub r1,r1,#32 ; if not, make it upper caseFFFFFFFFFFFFE4D4 TOUPRETFFFFFFFFFFFFE4D4 37EF8000 ret; 'CHKIO' checks the input. If there's no input, it will return; to the caller with the r1=0. If there is input, the input byte is in r1.; However, if a control-C is read, 'CHKIO' will warm-start BASIC and will; not return to the caller.;FFFFFFFFFFFFE4D8 CHKIO:FFFFFFFFFFFFE4D8 0FEF0008 subui sp,sp,#8 ; save link regFFFFFFFFFFFFE4DC 67EF8000 sw lr,[sp]FFFFFFFFFFFFE4E0 31FFF394 call GOIN ; get input if possibleFFFFFFFFFFFFE4E4 B01003FF beq r1,#-1,CHKRET2 ; if Zero, no inputFFFFFFFFFFFFE4E8 B2100303 bnei r1,#CTRLC,CHKRET ; is it control-C?FFFFFFFFFFFFE4EC 33FFF3BE jmp WSTART ; if so, do a warm startFFFFFFFFFFFFE4F0 CHKRET2:FFFFFFFFFFFFE4F0 0410840A xor r1,r1,r1FFFFFFFFFFFFE4F4 CHKRET:FFFFFFFFFFFFE4F4 47EF8000 lw lr,[sp] ;r1=0FFFFFFFFFFFFE4F8 37EF8008 ret #8; ===== Display a CR-LF sequence;FFFFFFFFFFFFE4FC CRLF:FFFFFFFFFFFFE4FC E07FE60B setlo r1,CLMSG; ===== Display a zero-ended string pointed to by register r1; Registers Affected; r1,r2,r4;FFFFFFFFFFFFE500 PRMESG:FFFFFFFFFFFFE500 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFE504 67E28000 sw r5,[sp]FFFFFFFFFFFFE508 67EF8008 sw lr,8[sp]FFFFFFFFFFFFE50C 02128009 mov r5,r1 ; r5 = pointer to messageFFFFFFFFFFFFE510 PRMESG1:FFFFFFFFFFFFE510 08528001 add r5,r5,#1FFFFFFFFFFFFE514 4050FFFF lb r1,-1[r5] ; get the char.FFFFFFFFFFFFE518 BE100068 beq r1,r0,PRMRETFFFFFFFFFFFFE51C 31FFF393 call GOOUT ;else display it trashes r4FFFFFFFFFFFFE520 BE007F8A bra PRMESG1FFFFFFFFFFFFE524 PRMRET:FFFFFFFFFFFFE524 02508009 mov r1,r5FFFFFFFFFFFFE528 47EF8008 lw lr,8[sp]FFFFFFFFFFFFE52C 47E28000 lw r5,[sp]FFFFFFFFFFFFE530 37EF8010 ret #16; ===== Display a zero-ended string pointed to by register r1; Registers Affected; r1,r2,r3;FFFFFFFFFFFFE534 PRMESGAUX:FFFFFFFFFFFFE534 0FEF0010 subui sp,sp,#16FFFFFFFFFFFFE538 67E28000 sw r5,[sp]FFFFFFFFFFFFE53C 67EF8008 sw lr,8[sp]FFFFFFFFFFFFE540 02128009 mov r5,r1 ; r3 = pointerFFFFFFFFFFFFE544 PRMESGA1:FFFFFFFFFFFFE544 0A528001 addui r5,r5,#1FFFFFFFFFFFFE548 4050FFFF lb r1,-1[r5] ; get the char.FFFFFFFFFFFFE54C BE100068 beq r1,r0,PRMRETAFFFFFFFFFFFFE550 31FFF395 call GOAUXO ;else display itFFFFFFFFFFFFE554 BE007F8A bra PRMESGA1FFFFFFFFFFFFE558 PRMRETA:FFFFFFFFFFFFE558 02508009 mov r1,r5FFFFFFFFFFFFE55C 47EF8008 lw lr,8[sp]FFFFFFFFFFFFE560 47E28000 lw r5,[sp]FFFFFFFFFFFFE564 37EF8010 ret #16;*****************************************************; The following routines are the only ones that need *; to be changed for a different I/O environment. *;*****************************************************; ===== Output character to the console (Port 1) from register r1; (Preserves all registers.);FFFFFFFFFFFFE568 OUTC:FFFFFFFFFFFFE568 33FFEF47 jmp DisplayChar; ===== Input a character from the console into register D0 (or; return Zero status if there's no character available).;FFFFFFFFFFFFE56C INC:FFFFFFFFFFFFE56C 33FFEE08 jmp KeybdGetChar;*;* ===== Input a character from the host into register r1 (or;* return Zero status if there's no character available).;*FFFFFFFFFFFFE570 AUXIN:FFFFFFFFFFFFE570 31FFED54 call SerialGetCharFFFFFFFFFFFFE574 B01003FF beqi r1,#-1,AXIRET_ZEROFFFFFFFFFFFFE578 1410807F andi r1,r1,#0x7f ;zero out the high bitFFFFFFFFFFFFE57C AXIRET:FFFFFFFFFFFFE57C 37EF8000 retFFFFFFFFFFFFE580 AXIRET_ZERO:FFFFFFFFFFFFE580 0410840A xor r1,r1,r1FFFFFFFFFFFFE584 37EF8000 ret; ===== Output character to the host (Port 2) from register r1; (Preserves all registers.);FFFFFFFFFFFFE588 AUXOUTFFFFFFFFFFFFE588 33FFED0C jmp SerialPutChar ; call boot rom routineFFFFFFFFFFFFE58C _clsFFFFFFFFFFFFE58C 31FFEED9 call clearScreenFFFFFFFFFFFFE590 BE00740A bra FINISHFFFFFFFFFFFFE594 _wait10FFFFFFFFFFFFE594 37EF8000 retFFFFFFFFFFFFE598 _getATAStatusFFFFFFFFFFFFE598 37EF8000 retFFFFFFFFFFFFE59C _waitCFNotBusyFFFFFFFFFFFFE59C 37EF8000 retFFFFFFFFFFFFE5A0 _rdcfFFFFFFFFFFFFE5A0 BE00738A br FINISHFFFFFFFFFFFFE5A4 rdcf6FFFFFFFFFFFFE5A4 BE004BEA br ERROR; ===== Return to the resident monitor, operating system, etc.;FFFFFFFFFFFFE5A8 BYEBYE:FFFFFFFFFFFFE5A8 460F1088 lw sp,OSSPFFFFFFFFFFFFE5AC 47EF8000 lw lr,[sp]FFFFFFFFFFFFE5B0 37EF8008 ret #8; MOVE.B #228,D7 return to Tutor; TRAP #14FFFFFFFFFFFFE5B0 C44E4100BCBD3CBD .align 16FFFFFFFFFFFFE5B8 0000000000D24F00FFFFFFFFFFFFE5C0 .align 16FFFFFFFFFFFFE5C0 726F747061520A0D msgInit db CR,LF,"Raptor64 Tiny BASIC v1.0",CR,LF,"(C) 2012 Robert Finch",CR,LF,LF,0FFFFFFFFFFFFE5C8 20796E6954203436FFFFFFFFFFFFE5D0 3176204349534142FFFFFFFFFFFFE5D8 202943280A0D302EFFFFFFFFFFFFE5E0 6F52202032313032FFFFFFFFFFFFE5E8 6E69462074726562FFFFFFFFFFFFE5F0 0A0D000A0A0D6863 OKMSG db CR,LF,"OK",CR,LF,0FFFFFFFFFFFFE5F8 616857000A0D4B4F msgWhat db "What?",CR,LF,0FFFFFFFFFFFFE600 726F53000A0D3F74 SRYMSG db "Sorry."FFFFFFFFFFFFE608 6F43000A0D2E7972 msgReadError db "Compact FLASH read error",CR,LF,0FFFFFFFFFFFFE610 4C4620746361706DFFFFFFFFFFFFE618 6461657220485341FFFFFFFFFFFFE620 0A0D726F72726520FFFFFFFFFFFFE628 207265626D754E00 msgNumTooBig db "Number is too big",CR,LF,0FFFFFFFFFFFFE630 62206F6F74207369FFFFFFFFFFFFE638 766944000A0D6769 msgDivZero db "Division by zero",CR,LF,0FFFFFFFFFFFFE640 7962206E6F697369FFFFFFFFFFFFE648 000A0D6F72657A20FFFFFFFFFFFFE650 7620666F2074754F msgVarSpace db "Out of variable space",CR,LF,0FFFFFFFFFFFFE658 20656C6261697261FFFFFFFFFFFFE660 000A0D6563617073FFFFFFFFFFFFE668 6620736574796220 msgBytesFree db " bytes free",CR,LF,0FFFFFFFFFFFFE670 0A0D000A0D656572 msgReady db CR,LF,"Ready",CR,LF,0FFFFFFFFFFFFE678 000A0D7964616552FFFFFFFFFFFFE680 6E69746365707845 msgComma db "Expecting a comma",CR,LF,0FFFFFFFFFFFFE688 6D6D6F6320612067FFFFFFFFFFFFE690 656E694C000A0D61 msgLineRange db "Line number too big",CR,LF,0FFFFFFFFFFFFE698 207265626D756E20FFFFFFFFFFFFE6A0 0D676962206F6F74FFFFFFFFFFFFE6A8 746365707845000A msgVar db "Expecting a variable",CR,LF,0FFFFFFFFFFFFE6B0 6176206120676E69FFFFFFFFFFFFE6B8 0A0D656C62616972FFFFFFFFFFFFE6C0 64616220444E5200 msgRNDBad db "RND bad parameter",CR,LF,0FFFFFFFFFFFFE6C8 74656D6172617020FFFFFFFFFFFFE6D0 535953000A0D7265 msgSYSBad db "SYS bad address",CR,LF,0FFFFFFFFFFFFE6D8 6464612064616220FFFFFFFFFFFFE6E0 49000A0D73736572 msgInputVar db "INPUT expecting a variable",CR,LF,0FFFFFFFFFFFFE6E8 707865205455504EFFFFFFFFFFFFE6F0 6120676E69746365FFFFFFFFFFFFE6F8 6C62616972617620FFFFFFFFFFFFE700 5458454E000A0D65 msgNextFor db "NEXT without FOR",CR,LF,0FFFFFFFFFFFFE708 74756F6874697720FFFFFFFFFFFFE710 4E000A0D524F4620 msgNextVar db "NEXT expecting a defined variable",CR,LF,0FFFFFFFFFFFFE718 6570786520545845FFFFFFFFFFFFE720 206120676E697463FFFFFFFFFFFFE728 2064656E69666564FFFFFFFFFFFFE730 656C626169726176FFFFFFFFFFFFE738 2F4F544F47000A0D msgBadGotoGosub db "GOTO/GOSUB bad line number",CR,LF,0FFFFFFFFFFFFE740 6162204255534F47FFFFFFFFFFFFE748 6E20656E696C2064FFFFFFFFFFFFE750 000A0D7265626D75FFFFFFFFFFFFE758 77204E5255544552 msgRetWoGosub db "RETURN without GOSUB",CR,LF,0FFFFFFFFFFFFE760 472074756F687469FFFFFFFFFFFFE768 50000A0D4255534F msgTooBig db "Program is too big",CR,LF,0FFFFFFFFFFFFE770 69206D6172676F72FFFFFFFFFFFFE778 6962206F6F742073FFFFFFFFFFFFE780 72747845000A0D67 msgExtraChars db "Extra characters on line ignored",CR,LF,0FFFFFFFFFFFFE788 6361726168632061FFFFFFFFFFFFE790 206E6F2073726574FFFFFFFFFFFFE798 6E676920656E696CFFFFFFFFFFFFE7A0 00000A0D6465726F align 8FFFFFFFFFFFFE7A8 align 8LSTROM equ * ; end of possible ROM area; END;*;* ===== Return to the resident monitor, operating system, etc.;*FFFFFFFFFFFFE7A8 BYEBYE:FFFFFFFFFFFFE7A8 33FFF096 jmp Monitor; MOVE.B #228,D7 ;return to Tutor; TRAP #14;==============================================================================; Checkerboard RAM tester;==============================================================================;FFFFFFFFFFFFE7AC codeFFFFFFFFFFFFE7A8 0000000033FFF096 align 16FFFFFFFFFFFFE7B0 align 16FFFFFFFFFFFFE7B0 ramtest:FFFFFFFFFFFFE7B0 04002009 or r8,r0,r0 ; r8 = 0FFFFFFFFFFFFE7B4 E6AA5555 ; SETLOFFFFFFFFFFFFE7B8 EE9556AA ; SETMIDFFFFFFFFFFFFE7BC F68AAAA5 ; SETHIFFFFFFFFFFFFE7C0 040D0409 ori r1,r0,#0xAAAA5555AAAA5555 ; checkerboard patternFFFFFFFFFFFFE7C4 ramtest2:FFFFFFFFFFFFE7C4 66808000 sw r1,[r8] ; save the checkerboard to memoryFFFFFFFFFFFFE7C8 46810000 lw r2,[r8] ; read it backFFFFFFFFFFFFE7CC 04110C06 cmp r3,r1,r2 ; is it the same ?FFFFFFFFFFFFE7D0 BE3000C9 bne r3,r0,ramtest1FFFFFFFFFFFFE7D4 0A840008 addui r8,r8,#8 ; increment RAM pointerFFFFFFFFFFFFE7D8 E6800000 ; SETLOFFFFFFFFFFFFE7DC EE800010 ; SETMIDFFFFFFFFFFFFE7E0 048D0C06 cmpi r3,r8,#0x0000_0000_0400_0000FFFFFFFFFFFFE7E4 BE307F00 blt r3,r0,ramtest2FFFFFFFFFFFFE7E8 ramtest1:FFFFFFFFFFFFE7E8 04802809 or r10,r8,r0 ; r10 = max ram address; readback the checkerboard patternFFFFFFFFFFFFE7EC 04002009 or r8,r0,r0 ; r8 = 0FFFFFFFFFFFFE7F0 ramtest4:FFFFFFFFFFFFE7F0 46810000 lw r2,[r8]FFFFFFFFFFFFE7F4 E6AA5555 ; SETLOFFFFFFFFFFFFE7F8 EE9556AA ; SETMIDFFFFFFFFFFFFE7FC F68AAAA5 ; SETHIFFFFFFFFFFFFE800 042D0C06 cmpi r3,r2,#0xAAAA5555AAAA5555FFFFFFFFFFFFE804 BE3000C9 bne r3,r0,ramtest3FFFFFFFFFFFFE808 08840008 addi r8,r8,#8FFFFFFFFFFFFE80C E6800000 ; SETLOFFFFFFFFFFFFE810 EE800004 ; SETMIDFFFFFFFFFFFFE814 048D0C06 cmpi r3,r8,#0x0000_0000_0100_0000FFFFFFFFFFFFE818 BE307EC0 blt r3,r0,ramtest4FFFFFFFFFFFFE81C ramtest3:FFFFFFFFFFFFE81C BE850389 bne r8,r10,ramtest8 ; check for equal maximum address; perform ramtest again with inverted checkerboardFFFFFFFFFFFFE820 04002009 or r8,r0,r0 ; r8 = 0FFFFFFFFFFFFE824 E695AAAA ; SETLOFFFFFFFFFFFFE828 EEAAA955 ; SETMIDFFFFFFFFFFFFE82C F685555A ; SETHIFFFFFFFFFFFFE830 040D0409 ori r1,r0,#0x5555AAAA5555AAAAFFFFFFFFFFFFE834 ramtest5:FFFFFFFFFFFFE834 66808000 sw r1,[r8]FFFFFFFFFFFFE838 46810000 lw r2,[r8]FFFFFFFFFFFFE83C 04110C06 cmp r3,r1,r2FFFFFFFFFFFFE840 BE3000C9 bne r3,r0,ramtest6FFFFFFFFFFFFE844 08840008 addi r8,r8,#8FFFFFFFFFFFFE848 E6800000 ; SETLOFFFFFFFFFFFFE84C EE800004 ; SETMIDFFFFFFFFFFFFE850 048D0C06 cmpi r3,r8,#0x0000_0000_0100_0000FFFFFFFFFFFFE854 BE307F00 blt r3,r0,ramtest5FFFFFFFFFFFFE858 ramtest6:FFFFFFFFFFFFE858 04802C09 or r11,r8,r0 ; r11 = max ram address; readback checkerboardFFFFFFFFFFFFE85C 04002009 or r8,r0,r0FFFFFFFFFFFFE860 ramtest7:FFFFFFFFFFFFE860 46810000 lw r2,[r8]FFFFFFFFFFFFE864 E695AAAA ; SETLOFFFFFFFFFFFFE868 EEAAA955 ; SETMIDFFFFFFFFFFFFE86C F685555A ; SETHIFFFFFFFFFFFFE870 042D0C06 cmpi r3,r2,#0x5555AAAA5555AAAAFFFFFFFFFFFFE874 BE3000C9 bne r3,r0,ramtest8FFFFFFFFFFFFE878 08840008 addi r8,r8,#8FFFFFFFFFFFFE87C E6800000 ; SETLOFFFFFFFFFFFFE880 EE800004 ; SETMIDFFFFFFFFFFFFE884 048D0C06 cmpi r3,r8,#0x0000_0000_0100_0000FFFFFFFFFFFFE888 BE307EC0 blt r3,r0,ramtest7FFFFFFFFFFFFE88C ramtest8:FFFFFFFFFFFFE88C BE858048 beq r8,r11,ramtest9FFFFFFFFFFFFE890 0485A014 min r8,r8,r11FFFFFFFFFFFFE894 ramtest9:FFFFFFFFFFFFE894 BE850048 beq r8,r10,ramtest10FFFFFFFFFFFFE898 04852014 min r8,r8,r10FFFFFFFFFFFFE89C ramtest10:FFFFFFFFFFFFE89C 66040400 sw r8,0x00000400 ;memendFFFFFFFFFFFFE8A0 37EF8000 ret;-------------------------------------------;-------------------------------------------;FFFFFFFFFFFFE8A4 iberr_rout:FFFFFFFFFFFFE8A4 9A00E92B lea r1,msgiberrFFFFFFFFFFFFE8A8 31FFEFE7 call DisplayStringFFFFFFFFFFFFE8AC 020085E8 mfspr r1,EPCFFFFFFFFFFFFE8B0 31FFF019 call DisplayWordFFFFFFFFFFFFE8B4 00000028 waitFFFFFFFFFFFFE8B8 33FFEC07 jmp startFFFFFFFFFFFFE8BC dberr_rout:FFFFFFFFFFFFE8BC 9A00E910 lea r1,msgdberrFFFFFFFFFFFFE8C0 31FFEFE7 call DisplayStringFFFFFFFFFFFFE8C4 02008628 mfspr r1,ERRADRFFFFFFFFFFFFE8C8 31FFF019 call DisplayWordFFFFFFFFFFFFE8CC 9A00E924 lea r1,msgEPCFFFFFFFFFFFFE8D0 31FFEFE7 call DisplayStringFFFFFFFFFFFFE8D4 020085E8 mfspr r1,EPCFFFFFFFFFFFFE8D8 31FFF019 call DisplayWordFFFFFFFFFFFFE8DC 31FFF93F call CRLFFFFFFFFFFFFFE8E0 1601001F lw r2,#31FFFFFFFFFFFFE8E4 dberr1:FFFFFFFFFFFFE8E4 02200FA9 mtspr PCHI,r2FFFFFFFFFFFFE8E8 DE000000 nopFFFFFFFFFFFFE8EC DE000000 nopFFFFFFFFFFFFE8F0 DE000000 nopFFFFFFFFFFFFE8F4 02008FE8 mfspr r1,PCHISTORICFFFFFFFFFFFFE8F8 31FFF019 call DisplayWordFFFFFFFFFFFFE8FC 31FFF93F call CRLFFFFFFFFFFFFFE900 BE017F2F loop r2,dberr1FFFFFFFFFFFFE904 00000028 waitFFFFFFFFFFFFE908 33FFEC07 jmp startFFFFFFFFFFFFE908 0000000033FFEC07 .align 16FFFFFFFFFFFFE910 .align 16FFFFFFFFFFFFE910 msgdberr:FFFFFFFFFFFFE910 7375622061746144 db "Data bus error at: ",0FFFFFFFFFFFFE918 6120726F72726520FFFFFFFFFFFFE924 msgEPC:FFFFFFFFFFFFE920 4350452000203A74 db " EPC: ",0FFFFFFFFFFFFE92B msgiberr:FFFFFFFFFFFFE928 662072724500203A db "Err fetching instruction at: ",0FFFFFFFFFFFFE930 20676E6968637465FFFFFFFFFFFFE938 7463757274736E69FFFFFFFFFFFFE940 203A7461206E6F69FFFFFFFFFFFFE948 0000000000000000 .align 16FFFFFFFFFFFFE950 .align 16;------------------------------------------------------------------------------; IRQ routine;------------------------------------------------------------------------------;FFFFFFFFFFFFE950 irqrout:FFFFFFFFFFFFE950 0FEF0020 subui sp,sp,#32FFFFFFFFFFFFE954 67E08000 sw r1,[sp] ; save off a working registerFFFFFFFFFFFFE958 67E10008 sw r2,8[sp] ; and a second work registerFFFFFFFFFFFFE95C 67ED0010 sw r26,16[sp] ; save off implicit constant builder regFFFFFFFFFFFFE960 67EF8018 sw lr,24[sp]FFFFFFFFFFFFE964 E69C0FF0 ; SETLOFFFFFFFFFFFFE968 EE800003 ; SETMIDFFFFFFFFFFFFE96C 6A0D0421 inch r1,PIC ; r1= which IRQ line is active; 1000 Hz interrupt; This IRQ must be fast, so it's placed inline; Increments the millisecond counter, and switches to the next context;FFFFFFFFFFFFE970 irq1000Hz:FFFFFFFFFFFFE970 B2101602 bnei r1,#2,irq100HzFFFFFFFFFFFFE974 E6BF0000 ; SETLOFFFFFFFFFFFFE978 6A0D0028 outb r0,0xFFFFFFFF_FFFF0000 ; acknowledge interruptFFFFFFFFFFFFE97C 46009400 lw r1,Milliseconds ; increment milliseconds countFFFFFFFFFFFFE980 0A108001 addui r1,r1,#1FFFFFFFFFFFFE984 66009400 sw r1,MillisecondsFFFFFFFFFFFFE988 E6900000 ; SETLOFFFFFFFFFFFFE98C EE800003 ; SETMIDFFFFFFFFFFFFE990 6A0D082D lea r2,TEXTSCRFFFFFFFFFFFFE994 8220814C inch r1,332[r2]FFFFFFFFFFFFE998 0A108001 addui r1,r1,#1FFFFFFFFFFFFE99C 9220814C outc r1,332[r2]FFFFFFFFFFFFE9A0 47EF8018 lw lr,24[sp]FFFFFFFFFFFFE9A4 47ED0010 lw r26,16[sp] ; restore registers from stackFFFFFFFFFFFFE9A8 47E10008 lw r2,8[sp]FFFFFFFFFFFFE9AC 47E08000 lw r1,[sp]FFFFFFFFFFFFE9B0 0BEF0020 addui sp,sp,#32 ; restore stack pointerFFFFFFFFFFFFE9B4 0000000F iepp ; move to the next contextFFFFFFFFFFFFE9B8 DE000000 nopFFFFFFFFFFFFE9BC DE000000 nopFFFFFFFFFFFFE9C0 DE000000 nopFFFFFFFFFFFFE9C4 01900020 iret ; return to the next context; 100 Hz interrupt; This IRQ could have some work to do, including flashing a cursor. So; we call a subroutine.;FFFFFFFFFFFFE9C8 irq100Hz:FFFFFFFFFFFFE9C8 B2100403 bnei r1,#3,irqSerialFFFFFFFFFFFFE9CC 4600B000 lw r1,p100IRQvec; jal lr,[r1]FFFFFFFFFFFFE9D0 31FFEE3B call Pulse100FFFFFFFFFFFFE9D4 BE0001AA bra irqretFFFFFFFFFFFFE9D8 irqSerial:FFFFFFFFFFFFE9D8 B2100408 bnei r1,#8,irqRasterFFFFFFFFFFFFE9DC 4600B010 lw r1,serialIRQvecFFFFFFFFFFFFE9E0 341F8000 jal lr,[r1]FFFFFFFFFFFFE9E4 BE00012A bra irqretFFFFFFFFFFFFE9E8 irqRaster:FFFFFFFFFFFFE9E8 B210040D bnei r1,#13,irqKeybdFFFFFFFFFFFFE9EC 4600B018 lw r1,rasterIRQvec; jal lr,[r1]FFFFFFFFFFFFE9F0 31FFF2B1 call RasterIRQfnFFFFFFFFFFFFE9F4 BE0000AA bra irqretFFFFFFFFFFFFE9F8 irqKeybd:FFFFFFFFFFFFE9F8 B0118901 beqi r1,#1,ColdStart ; CTRL-ALT-DEL interruptFFFFFFFFFFFFE9FC B210030F bnei r1,#15,irqretFFFFFFFFFFFFEA00 4600B008 lw r1,keybdIRQvecFFFFFFFFFFFFEA04 31FFEDF1 call KeybdIRQ; jal lr,[r1]FFFFFFFFFFFFEA08 irqret:FFFFFFFFFFFFEA08 47EF8018 lw lr,24[sp]FFFFFFFFFFFFEA0C 47ED0010 lw r26,16[sp] ; restore registers from stackFFFFFFFFFFFFEA10 47E10008 lw r2,8[sp]FFFFFFFFFFFFEA14 47E08000 lw r1,[sp]FFFFFFFFFFFFEA18 0BEF0020 addui sp,sp,#32 ; restore stack pointerFFFFFFFFFFFFEA1C 01900020 iret;-------------------------------------------; NMI routine;-------------------------------------------FFFFFFFFFFFFEA20 nmirout:FFFFFFFFFFFFEA20 01900020 iret;-------------------------------------------; Handle miss on Data TLB;-------------------------------------------FFFFFFFFFFFFEA24 DTLBHandler:FFFFFFFFFFFFEA24 E6BF0000 ; SETLOFFFFFFFFFFFFEA28 6A0D0413 sw r1,0xFFFF_FFFF_FFFF_0000FFFFFFFFFFFFEA2C E6BF0008 ; SETLOFFFFFFFFFFFFEA30 6A0D0813 sw r2,0xFFFF_FFFF_FFFF_0008FFFFFFFFFFFFEA34 dh1:FFFFFFFFFFFFEA34 02008034 omgi r1,#0 ; try open mutex gate #0 (TLB protector)FFFFFFFFFFFFEA38 BE107FE9 bne r1,r0,dh1 ; spinlock if gate is closedFFFFFFFFFFFFEA3C 02008128 mfspr r1,PTA ; get the page table addressFFFFFFFFFFFFEA40 02010228 mfspr r2,BadVAddr ; get the bad virtual addressFFFFFFFFFFFFEA44 022002E9 mtspr TLBVirtPage,r2 ; which virtual address to updateFFFFFFFFFFFFEA48 06211A01 shrui r2,r2,#13 ; turn va into indexFFFFFFFFFFFFEA4C 04110403 addu r1,r1,r2FFFFFFFFFFFFEA50 46110000 lw r2,[r1] ; get the physical address from the tableFFFFFFFFFFFFEA54 14210000 and r2,r2,#FFFF_FFFF_FFFF_E000 ; mask off lower bitsFFFFFFFFFFFFEA58 022002A9 mtspr TLBPhysPage0,r2 ;FFFFFFFFFFFFEA5C 46110008 lw r2,8[r1] ; get the physical address from the tableFFFFFFFFFFFFEA60 14210000 and r2,r2,#FFFF_FFFF_FFFF_E000 ; mask off lower bitsFFFFFFFFFFFFEA64 022002E9 mtspr TLBPhysPage1,r2 ;FFFFFFFFFFFFEA68 02000034 tlbwr ; update a random entry in the TLBFFFFFFFFFFFFEA6C 02000035 cmgi #0 ; close the mutex gateFFFFFFFFFFFFEA70 E6BF0000 ; SETLOFFFFFFFFFFFFEA74 6A0D0403 lw r1,0xFFFF_FFFF_FFFF_0000FFFFFFFFFFFFEA78 E6BF0008 ; SETLOFFFFFFFFFFFFEA7C 6A0D0803 lw r2,0xFFFF_FFFF_FFFF_0008FFFFFFFFFFFFEA80 01900020 iretFFFFFFFFFFFFEA80 0000000001900020 .align 32FFFFFFFFFFFFEA88 6A0D0803E6BF0008FFFFFFFFFFFFEA90 0000000000000000FFFFFFFFFFFFEA98 0000000000000000FFFFFFFFFFFFEAA0 .align 32FFFFFFFFFFFFFFB0 org 0xFFFF_FFFF_FFFF_FFB0FFFFFFFFFFFFFFB0 33FFFA89 jmp DTLBHandlerFFFFFFFFFFFFFFB4 DE000000 nopFFFFFFFFFFFFFFB8 DE000000 nopFFFFFFFFFFFFFFC0 org 0xFFFF_FFFF_FFFF_FFC0FFFFFFFFFFFFFFC0 33FFFA89 jmp DTLBHandlerFFFFFFFFFFFFFFC4 DE000000 nopFFFFFFFFFFFFFFC8 DE000000 nop; NMI vectorFFFFFFFFFFFFFFE0 org 0xFFFF_FFFF_FFFF_FFE0FFFFFFFFFFFFFFE0 33FFFA88 jmp nmiroutFFFFFFFFFFFFFFE4 DE000000 nopFFFFFFFFFFFFFFE8 DE000000 nop; RST vectorFFFFFFFFFFFFFFF0 org 0xFFFF_FFFF_FFFF_FFF0FFFFFFFFFFFFFFF0 33FFEC07 jmp startFFFFFFFFFFFFFFF4 DE000000 nopFFFFFFFFFFFFFFF8 DE000000 nopFFFFFFFFFFFFFFFC 000000000000000000000000 00000000Symbol Table:==========================================================Name Typ Segment Address/Value----------------------------------------------------------CR C constant 000000000000000DLF C constant 000000000000000ATAB C constant 0000000000000009CTRLC C constant 0000000000000003CTRLH C constant 0000000000000008CTRLS C constant 0000000000000013CTRLX C constant 0000000000000018XON C constant 0000000000000011XOFF C constant 0000000000000013DATA_PRESENT C constant 0000000000000001XMIT_NOT_FULL C constant 0000000000000020BUFLEN C constant 0000000000000050STACKTOP0 C constant FFFFFFFFFFFEFFF8STACKTOP1 C constant FFFFFFFFFFFEFBF8STACKTOP2 C constant FFFFFFFFFFFEF7F8STACKTOP3 C constant FFFFFFFFFFFEF3F8STACKTOP4 C constant FFFFFFFFFFFEEFF8STACKTOP5 C constant FFFFFFFFFFFEEBF8STACKTOP6 C constant FFFFFFFFFFFEE7F8STACKTOP7 C constant FFFFFFFFFFFEE3F8STACKTOP8 C constant FFFFFFFFFFFEDFF8STACKTOP9 C constant FFFFFFFFFFFEDBF8STACKTOP10 C constant FFFFFFFFFFFED7F8STACKTOP11 C constant FFFFFFFFFFFED3F8STACKTOP12 C constant FFFFFFFFFFFECFF8STACKTOP13 C constant FFFFFFFFFFFECBF8STACKTOP14 C constant FFFFFFFFFFFEC7F8STACKTOP15 C constant FFFFFFFFFFFEC3F8TCBSize C constant 0000000000000200TCBBase C constant 0000000100000000TCBr1 C constant 0000000000000000TCBr2 C constant 0000000000000008TCBr3 C constant 0000000000000010TCBr4 C constant 0000000000000018TCBr5 C constant 0000000000000020TCBr6 C constant 0000000000000028TCBr7 C constant 0000000000000030TCBr8 C constant 0000000000000038TCBr9 C constant 0000000000000040TCBr10 C constant 0000000000000048TCBr11 C constant 0000000000000050TCBr12 C constant 0000000000000058TCBr13 C constant 0000000000000060TCBr14 C constant 0000000000000068TCBr15 C constant 0000000000000070TCBr16 C constant 0000000000000078TCBr17 C constant 0000000000000080TCBr18 C constant 0000000000000088TCBr19 C constant 0000000000000090TCBr20 C constant 0000000000000098TCBr21 C constant 00000000000000A0TCBr22 C constant 00000000000000A8TCBr23 C constant 00000000000000B0TCBr24 C constant 00000000000000B8TCBr25 C constant 00000000000000C0TCBr26 C constant 00000000000000C8TCBr27 C constant 00000000000000D0TCBr28 C constant 00000000000000D8TCBr29 C constant 00000000000000E0TCBr30 C constant 00000000000000E8TCBr31 C constant 00000000000000F0warmStart C constant 0000000000001020usrJmp C constant 0000000000001028TickIRQAddr C constant 0000000000001030TaskBlock C constant 0000000000001038tencount C constant 00000000000013F8Milliseconds C constant 0000000000001400Lastloc C constant 0000000000001408ScreenColor C constant 0000000000001414CursorRow C constant 0000000000001416CursorCol C constant 0000000000001418CursorFlash C constant 000000000000141AKeybdEcho C constant 000000000000141CKeybdBuffer C constant 0000000000001440KeybdHead C constant 0000000000001450KeybdTail C constant 0000000000001451Score C constant 0000000000001500Manpos C constant 0000000000001508MissileActive C constant 0000000000001510MissileX C constant 0000000000001512MissileY C constant 0000000000001514InvadersRow1 C constant 0000000000001520InvadersRow2 C constant 0000000000001530InvadersRow3 C constant 0000000000001540InvadersRow4 C constant 0000000000001550InvadersRow5 C constant 0000000000001560InvadersColpos C constant 0000000000001570InvadersRowpos C constant 0000000000001571Uart_rxfifo C constant 0000000000001600Uart_rxhead C constant 0000000000001800Uart_rxtail C constant 0000000000001802Uart_ms C constant 0000000000001808Uart_rxrts C constant 0000000000001809Uart_rxdtr C constant 000000000000180AUart_rxxon C constant 000000000000180BUart_rxflow C constant 000000000000180CUart_fon C constant 000000000000180EUart_foff C constant 0000000000001810Uart_txrts C constant 0000000000001812Uart_txdtr C constant 0000000000001813Uart_txxon C constant 0000000000001814Uart_txxonoff C constant 0000000000001815TaskList C constant 0000000000002000ReadyList1 C constant 0000000000002000ReadyList2 C constant 0000000000002020ReadyList3 C constant 0000000000002040ReadyList4 C constant 0000000000002060ReadyList5 C constant 0000000000002080ReadyNdx1 C constant 00000000000020A0ReadyNdx2 C constant 00000000000020A1ReadyNdx3 C constant 00000000000020A2ReadyNdx4 C constant 00000000000020A3ReadyNdx5 C constant 00000000000020A4RunningTCB C constant 00000000000020A6NextToRunTCB C constant 00000000000020A8r1save C constant 00000000000020B0r2save C constant 00000000000020B8AXCstart C constant 00000000000020C0p100IRQvec C constant 0000000000003000keybdIRQvec C constant 0000000000003008serialIRQvec C constant 0000000000003010rasterIRQvec C constant 0000000000003018TEXTSCR C constant 0000000000D00000COLORSCR C constant 0000000000D10000TEXTREG C constant 0000000000DA0000TEXT_COLS C constant 0000000000000000TEXT_ROWS C constant 0000000000000002TEXT_CURPOS C constant 0000000000000016KEYBD C constant 0000000000DC0000KEYBDCLR C constant 0000000000DC0002UART C constant 0000000000DC0A00UART_LS C constant 0000000000DC0A01UART_IS C constant 0000000000DC0A03UART_IE C constant 0000000000DC0A04UART_MC C constant 0000000000DC0A06DATETIME C constant 0000000000DC0400PIC C constant 0000000000DC0FF0PIC_IE C constant 0000000000DC0FF2PSG C constant 0000000000D50000PSGFREQ0 C constant 0000000000D50000PSGPW0 C constant 0000000000D50002PSGCTRL0 C constant 0000000000D50004PSGADSR0 C constant 0000000000D50006SPRRAM C constant 0000000000D80000AC97 C constant 0000000000DC1000LED C constant 0000000000DC0600GACCEL C constant 0000000000DAE000RASTERIRQ C constant 0000000000DA0100BOOT_STACK C constant FFFFFFFFFFFEFFF8SPRITEREGS C constant 0000000000DAD000BITMAPSCR C constant 0000000100200000txempty C constant 0000000000000040rxfull C constant 0000000000000001txtWidth L bss 0000000000001038txtHeight L bss 0000000000001039cursx L bss 000000000000103Acursy L bss 000000000000103Bpos L bss 000000000000103Cdh L bss 000000000000103C0 L bss 000000000000103CcharToPrint L bss 0000000000001040fgColor L bss 0000000000001042bkColor L bss 0000000000001045cursFlash L bss 0000000000001046lineLinkTbl L bss 0000000000001047typef L bss 0000000000001080OSSP L bss 0000000000001088CURRNT L bss 0000000000001090STKGOS L bss 0000000000001098STKINP L bss 00000000000010A0LOPVAR L bss 00000000000010A8LOPINC L bss 00000000000010B0LOPLMT L bss 00000000000010B8LOPLN L bss 00000000000010C0LOPPT L bss 00000000000010C8TXTUNF L bss 00000000000010D0VARBGN L bss 00000000000010D8IVARBGN L bss 00000000000010E0SVARBGN L bss 00000000000010E8FVARBGN L bss 00000000000010F0STKBOT L bss 00000000000010F8NUMWKA L bss 0000000000001100BUFFER L bss 000000000000111BTXT C constant 0000000100600000SerialGetChar L code FFFFFFFFFFFFB550SerialPutChar L code FFFFFFFFFFFFB430SetKeyboardEcho L code FFFFFFFFFFFFB818KeybdCheckForKey L code FFFFFFFFFFFFB874KeybdGetChar L code FFFFFFFFFFFFB820DisplayChar L code FFFFFFFFFFFFBD1CDisplayString L code FFFFFFFFFFFFBF9Cstart L code FFFFFFFFFFFFB01CColdStart L code FFFFFFFFFFFFB01Cict1 L code FFFFFFFFFFFFB028ctxstart3 L code FFFFFFFFFFFFB1F8ctxstart2 L code FFFFFFFFFFFFB210ctxstart L code FFFFFFFFFFFFB214ctxstart1 L code FFFFFFFFFFFFB318csj5 L code FFFFFFFFFFFFB22CSerialInit L code FFFFFFFFFFFFB3B0KeybdInit L code FFFFFFFFFFFFB7B0PICInit L code FFFFFFFFFFFFB390SetupRasterIRQ L code FFFFFFFFFFFFCA64dcokay L code FFFFFFFFFFFFB2C4ClearScreen L code FFFFFFFFFFFFBB64ClearBmpScreen L code FFFFFFFFFFFFBB10RandomizeSprram L code FFFFFFFFFFFFC7B4DisplayStringCRLF L code FFFFFFFFFFFFBFD4Monitor L code FFFFFFFFFFFFC258SetupAC97 L code FFFFFFFFFFFFC7DCBeep L code FFFFFFFFFFFFC884j4 L code FFFFFFFFFFFFB310HelloWorld L code FFFFFFFFFFFFB31Cj3 L code FFFFFFFFFFFFB334j2 L code FFFFFFFFFFFFB348MSG L code FFFFFFFFFFFFB360MSGSTART L code FFFFFFFFFFFFB36DPICret L code FFFFFFFFFFFFB3ACSerialGetCharDirect L code FFFFFFFFFFFFB3F4sgc1 L code FFFFFFFFFFFFC6E0SerialCheckForCharDirect L code FFFFFFFFFFFFB418spcb1 L code FFFFFFFFFFFFB490spcb3 L code FFFFFFFFFFFFB470spcabort L code FFFFFFFFFFFFB518spcb2 L code FFFFFFFFFFFFB4C0spcb4 L code FFFFFFFFFFFFB4A0spcb5 L code FFFFFFFFFFFFB4DCspcb6 L code FFFFFFFFFFFFB4C8spcb8 L code FFFFFFFFFFFFB4E4spcb7 L code FFFFFFFFFFFFB50CCharsInRxBuf L code FFFFFFFFFFFFB52Ccirxb1 L code FFFFFFFFFFFFB54Csgcfifo1 L code FFFFFFFFFFFFB610sgcfifo2 L code FFFFFFFFFFFFB5FCsgcfifo3 L code FFFFFFFFFFFFB5C0sgcfifo4 L code FFFFFFFFFFFFB5E4sgcfifo5 L code FFFFFFFFFFFFB5FCSerialIRQ L code FFFFFFFFFFFFB628sirq1 L code FFFFFFFFFFFFB660srxirq L code FFFFFFFFFFFFB688stxirq L code FFFFFFFFFFFFB684smsirq L code FFFFFFFFFFFFB678srxirq1 L code FFFFFFFFFFFFB688srxirq3 L code FFFFFFFFFFFFB6B8srxirq2 L code FFFFFFFFFFFFB6ACsrxirq5 L code FFFFFFFFFFFFB6D4srxirq8 L code FFFFFFFFFFFFB764srxirq6 L code FFFFFFFFFFFFB728srxirq7 L code FFFFFFFFFFFFB74CKeybdSC L code FFFFFFFFFFFFB768kbdsc1 L code FFFFFFFFFFFFB77CkbdscRet L code FFFFFFFFFFFFB7A4kbdsc2 L code FFFFFFFFFFFFB78Ckbdsc3 L code FFFFFFFFFFFFB798kbdsc4 L code FFFFFFFFFFFFB7A4KeybdIRQ L code FFFFFFFFFFFFB7C4KeybdIRQa L code FFFFFFFFFFFFB7D4KeybdIRQb L code FFFFFFFFFFFFB7FCKeybdIRQc L code FFFFFFFFFFFFB810nochar L code FFFFFFFFFFFFB864kgc3 L code FFFFFFFFFFFFB868kgc2 L code FFFFFFFFFFFFB85CCRLF L code FFFFFFFFFFFFE4FCKeybdCheckForKeyDirect L code FFFFFFFFFFFFB884KeybdGetCharDirect L code FFFFFFFFFFFFB898kgc1 L code FFFFFFFFFFFFB8A8gk1 L code FFFFFFFFFFFFB8E0gk2 L code FFFFFFFFFFFFB8DCPulse100 L code FFFFFFFFFFFFB8ECDisplayDatetime L code FFFFFFFFFFFFCB60SelectNextToRunTCB L code FFFFFFFFFFFFB928SwitchTask L code FFFFFFFFFFFFB930p1001 L code FFFFFFFFFFFFB920swtsk1 L code FFFFFFFFFFFFB950FlashCursor L code FFFFFFFFFFFFBA80CalcScreenLoc L code FFFFFFFFFFFFBCDCflshcrsr2 L code FFFFFFFFFFFFBADCflshcrsr3 L code FFFFFFFFFFFFBAB4flshcrsr1 L code FFFFFFFFFFFFBAC8CursorOff L code FFFFFFFFFFFFBAE8CursorOn L code FFFFFFFFFFFFBAFCcsj4 L code FFFFFFFFFFFFBBACAsciiToScreen L code FFFFFFFFFFFFBCACScrollUp L code FFFFFFFFFFFFBBD8scrup1 L code FFFFFFFFFFFFBC18BlankLine L code FFFFFFFFFFFFBC58blnkln1 L code FFFFFFFFFFFFBC90atoscr1 L code FFFFFFFFFFFFBCC4ScreenToAscii L code FFFFFFFFFFFFBCCCstasc1 L code FFFFFFFFFFFFBCD8dccr L code FFFFFFFFFFFFBD3Cdcx7 L code FFFFFFFFFFFFBD68dcx6 L code FFFFFFFFFFFFBD80dcx8 L code FFFFFFFFFFFFBDB0dcx9 L code FFFFFFFFFFFFBDE0dcx10 L code FFFFFFFFFFFFBE10dcx11 L code FFFFFFFFFFFFBE44dcx12 L code FFFFFFFFFFFFBE3Cdcx13 L code FFFFFFFFFFFFBE78dcx5 L code FFFFFFFFFFFFBE98dcx3 L code FFFFFFFFFFFFBECCdcx4 L code FFFFFFFFFFFFBEF4dclf L code FFFFFFFFFFFFBEF0IncCursorPos L code FFFFFFFFFFFFBF10IncCursorRow L code FFFFFFFFFFFFBF48icc1 L code FFFFFFFFFFFFBF84icr1 L code FFFFFFFFFFFFBF5Cdspj1 L code FFFFFFFFFFFFBFB0dsret L code FFFFFFFFFFFFBFC4DisplayNybble L code FFFFFFFFFFFFC010dispnyb1 L code FFFFFFFFFFFFC02CDisplayByte L code FFFFFFFFFFFFC03CDisplayWord L code FFFFFFFFFFFFC064dspwd1 L code FFFFFFFFFFFFC078DisplayMem L code FFFFFFFFFFFFC094dspmem1 L code FFFFFFFFFFFFC0B8BinToBCD L code FFFFFFFFFFFFC0E4bta1 L code FFFFFFFFFFFFC108BCDToAscii L code FFFFFFFFFFFFC160bta2 L code FFFFFFFFFFFFC178BinToStr L code FFFFFFFFFFFFC1BCbtos3 L code FFFFFFFFFFFFC1F0btos1 L code FFFFFFFFFFFFC1F4btos2 L code FFFFFFFFFFFFC224PromptLn L code FFFFFFFFFFFFC264Prompt3 L code FFFFFFFFFFFFC270Prompt1 L code FFFFFFFFFFFFC284Prompt2 L code FFFFFFFFFFFFC2ACEditmem L code FFFFFFFFFFFFC404Dumpmem L code FFFFFFFFFFFFC43CCSTART L code FFFFFFFFFFFFCE70ExecuteCode L code FFFFFFFFFFFFC42CLoadS19 L code FFFFFFFFFFFFC500DisplayHelp L code FFFFFFFFFFFFC314TestCLS L code FFFFFFFFFFFFC2E0RandomLinesCall L code FFFFFFFFFFFFC2D8Invaders L code FFFFFFFFFFFFCDACPiano L code FFFFFFFFFFFFC95CRandomLines L code FFFFFFFFFFFFC6F0HelpMsg L code FFFFFFFFFFFFC320ignBlanks L code FFFFFFFFFFFFC3E0ignBlanks1 L code FFFFFFFFFFFFC3E8GetHexNumber L code FFFFFFFFFFFFC470edtmem1 L code FFFFFFFFFFFFC414gthxn2 L code FFFFFFFFFFFFC488AsciiToHexNybble L code FFFFFFFFFFFFC4C0gthxn1 L code FFFFFFFFFFFFC4ACgthx3 L code FFFFFFFFFFFFC4F8gthx5 L code FFFFFFFFFFFFC4D0gthx6 L code FFFFFFFFFFFFC4E4ProcessRec L code FFFFFFFFFFFFC50CNextRec L code FFFFFFFFFFFFC504sGetChar L code FFFFFFFFFFFFC6C8ProcessS1 L code FFFFFFFFFFFFC5C4ProcessS2 L code FFFFFFFFFFFFC5CCProcessS3 L code FFFFFFFFFFFFC5D4ProcessS7 L code FFFFFFFFFFFFC5DCProcessS8 L code FFFFFFFFFFFFC5E8ProcessS9 L code FFFFFFFFFFFFC5F4pcssxa L code FFFFFFFFFFFFC56Cpcss1a L code FFFFFFFFFFFFC574S19Get16BitAddress L code FFFFFFFFFFFFC600S19Get24BitAddress L code FFFFFFFFFFFFC618S19Get32BitAddress L code FFFFFFFFFFFFC630S1932b L code FFFFFFFFFFFFC684S1932a L code FFFFFFFFFFFFC664sgc2 L code FFFFFFFFFFFFC6D0AUXIN L code FFFFFFFFFFFFE570rl5 L code FFFFFFFFFFFFC700rl1 L code FFFFFFFFFFFFC714rl2 L code FFFFFFFFFFFFC730rl3 L code FFFFFFFFFFFFC74Crl4 L code FFFFFFFFFFFFC768rl8 L code FFFFFFFFFFFFC794rl7 L code FFFFFFFFFFFFC7A4rsr1 L code FFFFFFFFFFFFC7C4sac974 L code FFFFFFFFFFFFC7E8sac971 L code FFFFFFFFFFFFC7F4sac973 L code FFFFFFFFFFFFC820sac972 L code FFFFFFFFFFFFC860sac975 L code FFFFFFFFFFFFC878beep1 L code FFFFFFFFFFFFC8FCbeep2 L code FFFFFFFFFFFFC92Cplaynt L code FFFFFFFFFFFFC96Cplaynt1a L code FFFFFFFFFFFFC994playnt1b L code FFFFFFFFFFFFC9A0playnt1c L code FFFFFFFFFFFFC9ACplaynt1d L code FFFFFFFFFFFFC9B8playnt1e L code FFFFFFFFFFFFC9C4playnt1f L code FFFFFFFFFFFFC9D0playnt1g L code FFFFFFFFFFFFC9DCTone L code FFFFFFFFFFFFC9E8tone1 L code FFFFFFFFFFFFCA28tone2 L code FFFFFFFFFFFFCA44RasterIRQfn L code FFFFFFFFFFFFCAC4rirq1 L code FFFFFFFFFFFFCAF4rirq2 L code FFFFFFFFFFFFCAF4rirq3 L code FFFFFFFFFFFFCAF4rirq4 L code FFFFFFFFFFFFCAF4rirq5 L code FFFFFFFFFFFFCAF4rirq6 L code FFFFFFFFFFFFCAF4rirq7 L code FFFFFFFFFFFFCAF4rirq8 L code FFFFFFFFFFFFCAF4InitializeGame L code FFFFFFFFFFFFCBD0DrawScore L code FFFFFFFFFFFFCBF8DrawMissile L code FFFFFFFFFFFFCC28MissileOff L code FFFFFFFFFFFFCC84DrawMan L code FFFFFFFFFFFFCCACDrawInvader L code FFFFFFFFFFFFCCF8DrawInvaders L code FFFFFFFFFFFFCD18dinv1 L code FFFFFFFFFFFFCDA0DrawBombs L code FFFFFFFFFFFFCDA8InvadersLoop L code FFFFFFFFFFFFCDB8TestMoveMan L code FFFFFFFFFFFFCDCCMoveManRight L code FFFFFFFFFFFFCDE0MoveManLeft L code FFFFFFFFFFFFCDF8FireMissile L code FFFFFFFFFFFFCE0CInvaders1 L code FFFFFFFFFFFFCE30InvadersEnd L code FFFFFFFFFFFFCE38GOSTART L code FFFFFFFFFFFFCE44GOWARM L code FFFFFFFFFFFFCE48WSTART L code FFFFFFFFFFFFCEF8GOOUT L code FFFFFFFFFFFFCE4COUTC L code FFFFFFFFFFFFE568GOIN L code FFFFFFFFFFFFCE50INC L code FFFFFFFFFFFFE56CGOAUXO L code FFFFFFFFFFFFCE54AUXOUT L code FFFFFFFFFFFFE588GOAUXI L code FFFFFFFFFFFFCE58GOBYE L code FFFFFFFFFFFFCE5CBYEBYE L code FFFFFFFFFFFFE7A8TXTBGN L code FFFFFFFFFFFFCE60ENDMEM L code FFFFFFFFFFFFCE68PRMESGAUX L code FFFFFFFFFFFFE534PRMESG L code FFFFFFFFFFFFE500clearVars L code FFFFFFFFFFFFD30CPRTNUM L code FFFFFFFFFFFFE234ST3 L code FFFFFFFFFFFFCF10GETLN L code FFFFFFFFFFFFDF60TOUPBUF L code FFFFFFFFFFFFE474TSTNUM L code FFFFFFFFFFFFE3FCIGNBLK L code FFFFFFFFFFFFE450DIRECT L code FFFFFFFFFFFFD210ST2 L code FFFFFFFFFFFFCF3CERROR L code FFFFFFFFFFFFDF20FNDLN L code FFFFFFFFFFFFE030ST4 L code FFFFFFFFFFFFCF90FNDNXT L code FFFFFFFFFFFFE080ST7 L code FFFFFFFFFFFFCF6CST6 L code FFFFFFFFFFFFCF88MVUP L code FFFFFFFFFFFFE0A4ST5 L code FFFFFFFFFFFFCFB8MVDOWN L code FFFFFFFFFFFFE0BCTAB1 L code FFFFFFFFFFFFCFE0TAB2 L code FFFFFFFFFFFFCFF2TAB4 L code FFFFFFFFFFFFD042TAB5 L code FFFFFFFFFFFFD063TAB6 L code FFFFFFFFFFFFD066TAB8 L code FFFFFFFFFFFFD06BTAB9 L code FFFFFFFFFFFFD075TAB10 L code FFFFFFFFFFFFD079TAB1_1 L code FFFFFFFFFFFFD080TAB2_1 L code FFFFFFFFFFFFD0A8TAB4_1 L code FFFFFFFFFFFFD150TAB5_1 L code FFFFFFFFFFFFD198TAB6_1 L code FFFFFFFFFFFFD1A8TAB8_1 L code FFFFFFFFFFFFD1B8TAB9_1 L code FFFFFFFFFFFFD1F0TAB10_1 L code FFFFFFFFFFFFD200EXEC L code FFFFFFFFFFFFD218EXLP L code FFFFFFFFFFFFD22CEXNGO L code FFFFFFFFFFFFD244EXGO L code FFFFFFFFFFFFD27CEXMAT L code FFFFFFFFFFFFD26CEX1 L code FFFFFFFFFFFFD25CNEW L code FFFFFFFFFFFFD284ENDCHK L code FFFFFFFFFFFFDEE4STOP L code FFFFFFFFFFFFD294RUN L code FFFFFFFFFFFFD29CRUNNXL L code FFFFFFFFFFFFD2ACFNDLNP L code FFFFFFFFFFFFE040RUNTSL L code FFFFFFFFFFFFD2CCRUNSML L code FFFFFFFFFFFFD2D4CHKIO L code FFFFFFFFFFFFE4D8GOTO L code FFFFFFFFFFFFD2E4OREXPR L code FFFFFFFFFFFFD8E8_clr L code FFFFFFFFFFFFD304FINISH L code FFFFFFFFFFFFD410cv1 L code FFFFFFFFFFFFD320LISTX L code FFFFFFFFFFFFD338LS1 L code FFFFFFFFFFFFD34CLS4 L code FFFFFFFFFFFFD354PRTLN L code FFFFFFFFFFFFE37CLS3 L code FFFFFFFFFFFFD374LS2 L code FFFFFFFFFFFFD36CPRINT L code FFFFFFFFFFFFD380TSTC L code FFFFFFFFFFFFE3C4PR2 L code FFFFFFFFFFFFD398PR0 L code FFFFFFFFFFFFD3ACPR3 L code FFFFFFFFFFFFD3E4PR1 L code FFFFFFFFFFFFD3C4PR4 L code FFFFFFFFFFFFD3DCQTSTG L code FFFFFFFFFFFFE19CPR8 L code FFFFFFFFFFFFD400FIN L code FFFFFFFFFFFFDEA8PR6 L code FFFFFFFFFFFFD3F8QWHAT L code FFFFFFFFFFFFDF1CGOSUB L code FFFFFFFFFFFFD418PUSHA L code FFFFFFFFFFFFE0F8gosub1 L code FFFFFFFFFFFFD430RETURN L code FFFFFFFFFFFFD454return1 L code FFFFFFFFFFFFD468POPA L code FFFFFFFFFFFFE0C4FOR L code FFFFFFFFFFFFD48CSETVAL L code FFFFFFFFFFFFDE60FR1 L code FFFFFFFFFFFFD4A4FR2 L code FFFFFFFFFFFFD4B8FR4 L code FFFFFFFFFFFFD4C4FR3 L code FFFFFFFFFFFFD4C0FR5 L code FFFFFFFFFFFFD4C8FR7 L code FFFFFFFFFFFFD4E4FR6 L code FFFFFFFFFFFFD4E0FR8 L code FFFFFFFFFFFFD504NEXT L code FFFFFFFFFFFFD508TSTV L code FFFFFFFFFFFFDBB0NX4 L code FFFFFFFFFFFFD51CNX0 L code FFFFFFFFFFFFD520NX5 L code FFFFFFFFFFFFD530NX2 L code FFFFFFFFFFFFD53CNX1 L code FFFFFFFFFFFFD55CNXPurge L code FFFFFFFFFFFFD570NX3 L code FFFFFFFFFFFFD560IF L code FFFFFFFFFFFFD578IF1 L code FFFFFFFFFFFFD57CIF2 L code FFFFFFFFFFFFD580FNDSKP L code FFFFFFFFFFFFE084IF3 L code FFFFFFFFFFFFD590INPERR L code FFFFFFFFFFFFD594INPUT L code FFFFFFFFFFFFD5A8IP6 L code FFFFFFFFFFFFD5B0IP2 L code FFFFFFFFFFFFD5D0IP4 L code FFFFFFFFFFFFD640IP3 L code FFFFFFFFFFFFD600IP7 L code FFFFFFFFFFFFD5E8PRTSTG L code FFFFFFFFFFFFE144IP5 L code FFFFFFFFFFFFD650DEFLT L code FFFFFFFFFFFFD65CLET L code FFFFFFFFFFFFD664LT1 L code FFFFFFFFFFFFD678LOAD L code FFFFFFFFFFFFD67CLOD1 L code FFFFFFFFFFFFD688LODEND L code FFFFFFFFFFFFD6C8GCHAR L code FFFFFFFFFFFFD6D0LOD2 L code FFFFFFFFFFFFD6B0GCHAR1 L code FFFFFFFFFFFFD6E8asciiToHex L code FFFFFFFFFFFFD714a2h1 L code FFFFFFFFFFFFD71CSAVE L code FFFFFFFFFFFFD728SAVE1 L code FFFFFFFFFFFFD730AUXOCRLF L code FFFFFFFFFFFFD784SAVEND L code FFFFFFFFFFFFD76CPWORD L code FFFFFFFFFFFFD7A4SAVE2 L code FFFFFFFFFFFFD758pword1 L code FFFFFFFFFFFFD7B8toAsciiHex L code FFFFFFFFFFFFD7F4pword2 L code FFFFFFFFFFFFD7D4tah1 L code FFFFFFFFFFFFD800POKE L code FFFFFFFFFFFFD808PKER L code FFFFFFFFFFFFD834POKEC L code FFFFFFFFFFFFD83CPOKEH L code FFFFFFFFFFFFD868POKEW L code FFFFFFFFFFFFD894SYSX L code FFFFFFFFFFFFD8C0sysx1 L code FFFFFFFFFFFFD8D4ANDEXPR L code FFFFFFFFFFFFD920XP_OR1 L code FFFFFFFFFFFFD8F4XP_OR L code FFFFFFFFFFFFD904XP_ORX L code FFFFFFFFFFFFD914EXPR L code FFFFFFFFFFFFD9B4XP_AND1 L code FFFFFFFFFFFFD92CXP_AND L code FFFFFFFFFFFFD93CXP_ANDX L code FFFFFFFFFFFFD94CisDigit L code FFFFFFFFFFFFD958isDigitFalse L code FFFFFFFFFFFFD968isAlpha L code FFFFFFFFFFFFD970isAlphaFalse L code FFFFFFFFFFFFD988isAlphaTrue L code FFFFFFFFFFFFD980isAlnum L code FFFFFFFFFFFFD990isDigitx L code FFFFFFFFFFFFD9ACEXPR2 L code FFFFFFFFFFFFDA70XP11 L code FFFFFFFFFFFFD9D0XP18 L code FFFFFFFFFFFFDA54XPRT1 L code FFFFFFFFFFFFDA3CXPRT0 L code FFFFFFFFFFFFDA30XP12 L code FFFFFFFFFFFFD9E0XP13 L code FFFFFFFFFFFFD9F0XP14 L code FFFFFFFFFFFFDA00XP15 L code FFFFFFFFFFFFDA10XP16 L code FFFFFFFFFFFFDA20XP17 L code FFFFFFFFFFFFDA48XP26 L code FFFFFFFFFFFFDACCXP21 L code FFFFFFFFFFFFDA90XP22 L code FFFFFFFFFFFFDA9CEXPR3 L code FFFFFFFFFFFFDAE4XP23 L code FFFFFFFFFFFFDAA0XP24 L code FFFFFFFFFFFFDAB4XP25 L code FFFFFFFFFFFFDAC0XP45 L code FFFFFFFFFFFFDAD8EXPR4 L code FFFFFFFFFFFFDB3CXP31 L code FFFFFFFFFFFFDAF0XP34 L code FFFFFFFFFFFFDB10XP47 L code FFFFFFFFFFFFDB30XP40 L code FFFFFFFFFFFFDB50XP41 L code FFFFFFFFFFFFDB68XP46 L code FFFFFFFFFFFFDB74PARN L code FFFFFFFFFFFFDB7CXP42 L code FFFFFFFFFFFFDBA0XP43 L code FFFFFFFFFFFFDBA8tstv_notfound L code FFFFFFFFFFFFDC24TV1 L code FFFFFFFFFFFFDC08SIZEX L code FFFFFFFFFFFFDE4CTV2 L code FFFFFFFFFFFFDBFCQSORRY L code FFFFFFFFFFFFDF14TSTVRT L code FFFFFFFFFFFFDC18getVarName L code FFFFFFFFFFFFDC34findVar L code FFFFFFFFFFFFDCCCgvn1 L code FFFFFFFFFFFFDCBCgvn4 L code FFFFFFFFFFFFDC54gvn2 L code FFFFFFFFFFFFDC8Cgvn6 L code FFFFFFFFFFFFDC7Cgvn3 L code FFFFFFFFFFFFDCA0fv4 L code FFFFFFFFFFFFDCDCfv3 L code FFFFFFFFFFFFDD00fv1 L code FFFFFFFFFFFFDD08fv2 L code FFFFFFFFFFFFDD18PEEK L code FFFFFFFFFFFFDD2CPEEKC L code FFFFFFFFFFFFDD3CPEEKH L code FFFFFFFFFFFFDD50PEEKW L code FFFFFFFFFFFFDD64USRX L code FFFFFFFFFFFFDD78RND L code FFFFFFFFFFFFDD94rnd2 L code FFFFFFFFFFFFDDC4rnd1 L code FFFFFFFFFFFFDDBCmodu4 L code FFFFFFFFFFFFDDD4mod2 L code FFFFFFFFFFFFDDF4mod1 L code FFFFFFFFFFFFDE10ABS L code FFFFFFFFFFFFDE2CSGN L code FFFFFFFFFFFFDE3Csv2 L code FFFFFFFFFFFFDE7CSV1 L code FFFFFFFFFFFFDEA4FI1 L code FFFFFFFFFFFFDEC4FI2 L code FFFFFFFFFFFFDEDCec1 L code FFFFFFFFFFFFDF04TOOBIG L code FFFFFFFFFFFFDF0CGL1 L code FFFFFFFFFFFFDF88GL3 L code FFFFFFFFFFFFDFBCGL4 L code FFFFFFFFFFFFDFE4GL2 L code FFFFFFFFFFFFDFA0GL7 L code FFFFFFFFFFFFE014GL6 L code FFFFFFFFFFFFE00CGL5 L code FFFFFFFFFFFFDFF0fl1 L code FFFFFFFFFFFFE03CFNDRET1 L code FFFFFFFFFFFFE06CFNDRET2 L code FFFFFFFFFFFFE078FNDRET L code FFFFFFFFFFFFE064MVUP1 L code FFFFFFFFFFFFE094MVRET L code FFFFFFFFFFFFE0A8MVDOWN1 L code FFFFFFFFFFFFE0ACPP1 L code FFFFFFFFFFFFE0F4PU1 L code FFFFFFFFFFFFE138PS1 L code FFFFFFFFFFFFE160PRTRET L code FFFFFFFFFFFFE180QT1 L code FFFFFFFFFFFFE1B8QT2 L code FFFFFFFFFFFFE200QT3 L code FFFFFFFFFFFFE1D0QT4 L code FFFFFFFFFFFFE1E8QT5 L code FFFFFFFFFFFFE20CprCRLF L code FFFFFFFFFFFFE214PN1 L code FFFFFFFFFFFFE264PN6 L code FFFFFFFFFFFFE284PN4 L code FFFFFFFFFFFFE294PN3 L code FFFFFFFFFFFFE288PN5 L code FFFFFFFFFFFFE2A0PNRET L code FFFFFFFFFFFFE2B4PRTHEXNUM L code FFFFFFFFFFFFE2CCPHN1 L code FFFFFFFFFFFFE308PHN7 L code FFFFFFFFFFFFE31CPHN8 L code FFFFFFFFFFFFE320shru L code FFFFFFFFFFFFE32Cr4 L code FFFFFFFFFFFFE32C#4 L code FFFFFFFFFFFFE32CPHN6 L code FFFFFFFFFFFFE334PHN4 L code FFFFFFFFFFFFE344PHN3 L code FFFFFFFFFFFFE338PHN5 L code FFFFFFFFFFFFE350PHNRET L code FFFFFFFFFFFFE364TC1 L code FFFFFFFFFFFFE3ECTN1 L code FFFFFFFFFFFFE410TSNMRET L code FFFFFFFFFFFFE448TN2 L code FFFFFFFFFFFFE430IGB2 L code FFFFFFFFFFFFE458IGB1 L code FFFFFFFFFFFFE464IGBRET L code FFFFFFFFFFFFE46CTOUPB1 L code FFFFFFFFFFFFE484TOUPBRT L code FFFFFFFFFFFFE4C0DOQUO L code FFFFFFFFFFFFE4A8toUpper L code FFFFFFFFFFFFE4C8DOQUO1 L code FFFFFFFFFFFFE4B4TOUPRET L code FFFFFFFFFFFFE4D4CHKRET2 L code FFFFFFFFFFFFE4F0CHKRET L code FFFFFFFFFFFFE4F4PRMESG1 L code FFFFFFFFFFFFE510PRMRET L code FFFFFFFFFFFFE524PRMESGA1 L code FFFFFFFFFFFFE544PRMRETA L code FFFFFFFFFFFFE558AXIRET_ZERO L code FFFFFFFFFFFFE580AXIRET L code FFFFFFFFFFFFE57C_cls L code FFFFFFFFFFFFE58C_wait10 L code FFFFFFFFFFFFE594_getATAStatus L code FFFFFFFFFFFFE598_waitCFNotBusy L code FFFFFFFFFFFFE59C_rdcf L code FFFFFFFFFFFFE5A0rdcf6 L code FFFFFFFFFFFFE5A4msgInit L code FFFFFFFFFFFFE5C0OKMSG L code FFFFFFFFFFFFE5F6msgWhat L code FFFFFFFFFFFFE5FDSRYMSG L code FFFFFFFFFFFFE605CLMSG L code FFFFFFFFFFFFE60BmsgReadError L code FFFFFFFFFFFFE60EmsgNumTooBig L code FFFFFFFFFFFFE629msgDivZero L code FFFFFFFFFFFFE63DmsgVarSpace L code FFFFFFFFFFFFE650msgBytesFree L code FFFFFFFFFFFFE668msgReady L code FFFFFFFFFFFFE676msgComma L code FFFFFFFFFFFFE680msgLineRange L code FFFFFFFFFFFFE694msgVar L code FFFFFFFFFFFFE6AAmsgRNDBad L code FFFFFFFFFFFFE6C1msgSYSBad L code FFFFFFFFFFFFE6D5msgInputVar L code FFFFFFFFFFFFE6E7msgNextFor L code FFFFFFFFFFFFE704msgNextVar L code FFFFFFFFFFFFE717msgBadGotoGosub L code FFFFFFFFFFFFE73BmsgRetWoGosub L code FFFFFFFFFFFFE758msgTooBig L code FFFFFFFFFFFFE76FmsgExtraChars L code FFFFFFFFFFFFE784LSTROM C constant 0000000000000000ramtest L code FFFFFFFFFFFFE7B0ramtest2 L code FFFFFFFFFFFFE7C4ramtest1 L code FFFFFFFFFFFFE7E8ramtest4 L code FFFFFFFFFFFFE7F0ramtest3 L code FFFFFFFFFFFFE81Cramtest8 L code FFFFFFFFFFFFE88Cramtest5 L code FFFFFFFFFFFFE834ramtest6 L code FFFFFFFFFFFFE858ramtest7 L code FFFFFFFFFFFFE860ramtest9 L code FFFFFFFFFFFFE894ramtest10 L code FFFFFFFFFFFFE89Ciberr_rout L code FFFFFFFFFFFFE8A4dberr_rout L code FFFFFFFFFFFFE8BCdberr1 L code FFFFFFFFFFFFE8E4msgdberr L code FFFFFFFFFFFFE910msgEPC L code FFFFFFFFFFFFE924msgiberr L code FFFFFFFFFFFFE92Birqrout L code FFFFFFFFFFFFE950irq1000Hz L code FFFFFFFFFFFFE970irq100Hz L code FFFFFFFFFFFFE9C8irqSerial L code FFFFFFFFFFFFE9D8irqret L code FFFFFFFFFFFFEA08irqRaster L code FFFFFFFFFFFFE9E8irqKeybd L code FFFFFFFFFFFFE9F8nmirout L code FFFFFFFFFFFFEA20DTLBHandler L code FFFFFFFFFFFFEA24dh1 L code FFFFFFFFFFFFEA34
Go to most recent revision | Compare with Previous | Blame | View Log